apitech
/
loki
mirror of https://github.com/grafana/loki
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

fix: make detected fields work for both json and proto (#12682)

Browse Source
pull/12590/head
Trevor Whitney 2 years ago committed by GitHub
parent ee0020c1b1
commit f68d1f7faf
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
9 changed files with 468 additions and 196 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 10
      integration/client/client.go
  2. 223
      integration/explore_logs_test.go
  3. 330
      pkg/logproto/logproto.pb.go
  4. 4
      pkg/logproto/logproto.proto
  5. 7
      pkg/loki/modules.go
  6. 14
      pkg/querier/querier.go
  7. 2
      pkg/querier/queryrange/codec.go
  8. 65
      pkg/querier/queryrange/roundtrip.go
  9. 9
      pkg/storage/detected/fields.go

10
integration/client/client.go
Unescape View File

@ -111,7 +111,7 @@ func (c *Client) PushOTLPLogLine(line string, timestamp time.Time, logAttributes
return c.pushOTLPLogLine(line, timestamp, logAttributes)
}
func formatTS(ts time.Time) string {
func FormatTS(ts time.Time) string {
return strconv.FormatInt(ts.UnixNano(), 10)
}
@ -130,7 +130,7 @@ func (c *Client) pushLogLine(line string, timestamp time.Time, structuredMetadat
},
Values: [][]any{
{
formatTS(timestamp),
FormatTS(timestamp),
line,
structuredMetadata,
},
@ -509,7 +509,7 @@ func (c *Client) RunQuery(ctx context.Context, query string, extraHeaders ...Hea
v := url.Values{}
v.Set("query", query)
v.Set("time", formatTS(c.Now.Add(time.Second)))
v.Set("time", FormatTS(c.Now.Add(time.Second)))
u, err := url.Parse(c.baseURL)
if err != nil {
@ -568,8 +568,8 @@ func (c *Client) parseResponse(buf []byte, statusCode int) (*Response, error) {
func (c *Client) rangeQueryURL(query string, start, end time.Time) string {
v := url.Values{}
v.Set("query", query)
v.Set("start", formatTS(start))
v.Set("end", formatTS(end))
v.Set("start", FormatTS(start))
v.Set("end", FormatTS(end))
u, err := url.Parse(c.baseURL)
if err != nil {

223
integration/explore_logs_test.go
Unescape View File

@ -0,0 +1,223 @@
//go:build integration
package integration
import (
"context"
"encoding/json"
"io"
"net/url"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/grafana/loki/v3/integration/client"
"github.com/grafana/loki/v3/integration/cluster"
)
type DetectedField struct {
Label string `json:"label"`
Type string `json:"type"`
Cardinality uint64 `json:"cardinality"`
}
type DetectedFields []DetectedField
type DetectedFieldResponse struct {
Fields DetectedFields `json:"fields"`
}
func Test_ExploreLogsApis(t *testing.T) {
clu := cluster.New(nil, cluster.SchemaWithTSDBAndTSDB, func(c *cluster.Cluster) {
c.SetSchemaVer("v13")
})
defer func() {
assert.NoError(t, clu.Cleanup())
}()
// run initially the compactor, indexgateway, and distributor.
var (
tCompactor = clu.AddComponent(
"compactor",
"-target=compactor",
"-compactor.compaction-interval=1s",
"-compactor.retention-delete-delay=1s",
// By default, a minute is added to the delete request start time. This compensates for that.
"-compactor.delete-request-cancel-period=-60s",
"-compactor.deletion-mode=filter-and-delete",
)
tIndexGateway = clu.AddComponent(
"index-gateway",
"-target=index-gateway",
)
tDistributor = clu.AddComponent(
"distributor",
"-target=distributor",
)
)
require.NoError(t, clu.Run())
// then, run only the ingester and query scheduler.
var (
tIngester = clu.AddComponent(
"ingester",
"-target=ingester",
"-boltdb.shipper.index-gateway-client.server-address="+tIndexGateway.GRPCURL(),
)
tQueryScheduler = clu.AddComponent(
"query-scheduler",
"-target=query-scheduler",
"-query-scheduler.use-scheduler-ring=false",
"-boltdb.shipper.index-gateway-client.server-address="+tIndexGateway.GRPCURL(),
)
)
require.NoError(t, clu.Run())
// the run querier.
var (
tQuerier = clu.AddComponent(
"querier",
"-target=querier",
"-querier.scheduler-address="+tQueryScheduler.GRPCURL(),
"-boltdb.shipper.index-gateway-client.server-address="+tIndexGateway.GRPCURL(),
"-common.compactor-address="+tCompactor.HTTPURL(),
)
)
require.NoError(t, clu.Run())
// finally, run the query-frontend.
var (
tQueryFrontend = clu.AddComponent(
"query-frontend",
"-target=query-frontend",
"-frontend.scheduler-address="+tQueryScheduler.GRPCURL(),
"-boltdb.shipper.index-gateway-client.server-address="+tIndexGateway.GRPCURL(),
"-common.compactor-address="+tCompactor.HTTPURL(),
"-querier.per-request-limits-enabled=true",
"-frontend.encoding=protobuf",
"-querier.shard-aggregations=quantile_over_time",
"-frontend.tail-proxy-url="+tQuerier.HTTPURL(),
)
)
require.NoError(t, clu.Run())
tenantID := randStringRunes()
now := time.Now()
cliDistributor := client.New(tenantID, "", tDistributor.HTTPURL())
cliDistributor.Now = now
cliIngester := client.New(tenantID, "", tIngester.HTTPURL())
cliIngester.Now = now
cliQueryFrontend := client.New(tenantID, "", tQueryFrontend.HTTPURL())
cliQueryFrontend.Now = now
t.Run("/detected_fields", func(t *testing.T) {
// ingest some log lines
require.NoError(t, cliDistributor.PushLogLine("foo=bar color=red", now.Add(-45*time.Minute), nil, map[string]string{"job": "fake"}))
require.NoError(t, cliDistributor.PushLogLine("foo=bar color=blue", now.Add(-45*time.Minute), nil, map[string]string{"job": "fake"}))
require.NoError(t, cliDistributor.PushLogLine("foo=bar color=red", now.Add(-5*time.Second), nil, map[string]string{"job": "fake"}))
require.NoError(t, cliDistributor.PushLogLine("foo=bar color=purple", now.Add(-5*time.Second), nil, map[string]string{"job": "fake"}))
require.NoError(t, cliDistributor.PushLogLine("foo=bar color=green", now, nil, map[string]string{"job": "fake"}))
require.NoError(t, cliDistributor.PushLogLine("foo=bar color=red", now, nil, map[string]string{"job": "fake"}))
// validate logs are there
resp, err := cliQueryFrontend.RunRangeQuery(context.Background(), `{job="fake"}`)
require.NoError(t, err)
assert.Equal(t, "streams", resp.Data.ResultType)
var lines []string
for _, stream := range resp.Data.Stream {
for _, val := range stream.Values {
lines = append(lines, val[1])
}
}
assert.ElementsMatch(t, []string{"foo=bar color=red", "foo=bar color=blue", "foo=bar color=red", "foo=bar color=purple", "foo=bar color=green", "foo=bar color=red"}, lines)
t.Run("non-split queries", func(t *testing.T) {
start := cliQueryFrontend.Now.Add(-1 * time.Minute)
end := cliQueryFrontend.Now.Add(time.Minute)
v := url.Values{}
v.Set("query", `{job="fake"}`)
v.Set("start", client.FormatTS(start))
v.Set("end", client.FormatTS(end))
u := url.URL{}
u.Path = "/loki/api/v1/detected_fields"
u.RawQuery = v.Encode()
dfResp, err := cliQueryFrontend.Get(u.String())
require.NoError(t, err)
defer dfResp.Body.Close()
buf, err := io.ReadAll(dfResp.Body)
require.NoError(t, err)
var detectedFieldResponse DetectedFieldResponse
err = json.Unmarshal(buf, &detectedFieldResponse)
require.NoError(t, err)
require.Equal(t, 2, len(detectedFieldResponse.Fields))
var fooField, colorField DetectedField
for _, field := range detectedFieldResponse.Fields {
if field.Label == "foo" {
fooField = field
}
if field.Label == "color" {
colorField = field
}
}
require.Equal(t, "string", fooField.Type)
require.Equal(t, "string", colorField.Type)
require.Equal(t, uint64(1), fooField.Cardinality)
require.Equal(t, uint64(3), colorField.Cardinality)
})
t.Run("split queries", func(t *testing.T) {
start := cliQueryFrontend.Now.Add(-24 * time.Hour)
end := cliQueryFrontend.Now.Add(time.Minute)
v := url.Values{}
v.Set("query", `{job="fake"}`)
v.Set("start", client.FormatTS(start))
v.Set("end", client.FormatTS(end))
u := url.URL{}
u.Path = "/loki/api/v1/detected_fields"
u.RawQuery = v.Encode()
dfResp, err := cliQueryFrontend.Get(u.String())
require.NoError(t, err)
defer dfResp.Body.Close()
buf, err := io.ReadAll(dfResp.Body)
require.NoError(t, err)
var detectedFieldResponse DetectedFieldResponse
err = json.Unmarshal(buf, &detectedFieldResponse)
require.NoError(t, err)
require.Equal(t, 2, len(detectedFieldResponse.Fields))
var fooField, colorField DetectedField
for _, field := range detectedFieldResponse.Fields {
if field.Label == "foo" {
fooField = field
}
if field.Label == "color" {
colorField = field
}
}
require.Equal(t, "string", fooField.Type)
require.Equal(t, "string", colorField.Type)
require.Equal(t, uint64(1), fooField.Cardinality)
require.Equal(t, uint64(4), colorField.Cardinality)
})
})
}

330
pkg/logproto/logproto.pb.go
Unescape View File

@ -2755,7 +2755,7 @@ type DetectedField struct {
Label string `protobuf:"bytes,1,opt,name=label,proto3" json:"label,omitempty"`
Type DetectedFieldType `protobuf:"bytes,2,opt,name=type,proto3,casttype=DetectedFieldType" json:"type,omitempty"`
Cardinality uint64 `protobuf:"varint,3,opt,name=cardinality,proto3" json:"cardinality,omitempty"`
Sketch []byte `protobuf:"bytes,4,opt,name=sketch,proto3" json:"-"`
Sketch []byte `protobuf:"bytes,4,opt,name=sketch,proto3" json:"sketch,omitempty"`
}
func (m *DetectedField) Reset() { *m = DetectedField{} }
@ -3033,169 +3033,171 @@ func init() {
func init() { proto.RegisterFile("pkg/logproto/logproto.proto", fileDescriptor_c28a5f14f1f4c79a) }
var fileDescriptor_c28a5f14f1f4c79a = []byte{
// 2590 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x1a, 0x4d, 0x6f, 0x1b, 0xc7,
0x95, 0x4b, 0x2e, 0xbf, 0x1e, 0x29, 0x59, 0x1e, 0xd1, 0x36, 0x41, 0xdb, 0xa4, 0x32, 0x68, 0x13,
0x35, 0x76, 0xc4, 0x58, 0x69, 0xd2, 0xc4, 0x69, 0x9a, 0x9a, 0x52, 0xac, 0xc8, 0x51, 0x1c, 0x67,
0xa4, 0x38, 0x69, 0xd1, 0x20, 0x58, 0x91, 0x23, 0x6a, 0x21, 0x72, 0x97, 0xde, 0x1d, 0xc6, 0xe1,
0xad, 0x7f, 0xa0, 0x68, 0x8a, 0x1e, 0xda, 0x5e, 0x0a, 0x14, 0x28, 0xd0, 0x22, 0x45, 0x2f, 0x45,
0x8f, 0x45, 0x7b, 0xe9, 0x21, 0xbd, 0xa5, 0xb7, 0x20, 0x07, 0xb6, 0x56, 0x2e, 0x85, 0x4e, 0x01,
0x7a, 0xcb, 0xa9, 0x98, 0xaf, 0xfd, 0x12, 0x59, 0x87, 0x8a, 0x83, 0xc0, 0x17, 0x71, 0xe6, 0xcd,
0x9b, 0x37, 0xf3, 0x3e, 0xe6, 0x7d, 0xad, 0xe0, 0xfc, 0xe0, 0xa0, 0xdb, 0xec, 0xb9, 0xdd, 0x81,
0xe7, 0x32, 0x37, 0x18, 0xac, 0x88, 0xbf, 0xa8, 0xa0, 0xe7, 0xb5, 0x4a, 0xd7, 0xed, 0xba, 0x12,
0x87, 0x8f, 0xe4, 0x7a, 0xad, 0xd1, 0x75, 0xdd, 0x6e, 0x8f, 0x36, 0xc5, 0x6c, 0x77, 0xb8, 0xd7,
0x64, 0x76, 0x9f, 0xfa, 0xcc, 0xea, 0x0f, 0x14, 0xc2, 0x92, 0xa2, 0x7e, 0xa7, 0xd7, 0x77, 0x3b,
0xb4, 0xd7, 0xf4, 0x99, 0xc5, 0x7c, 0xf9, 0x57, 0x61, 0x2c, 0x72, 0x8c, 0xc1, 0xd0, 0xdf, 0x17,
0x7f, 0x24, 0x10, 0xff, 0xd9, 0x80, 0x33, 0x5b, 0xd6, 0x2e, 0xed, 0xed, 0xb8, 0xb7, 0xad, 0xde,
0x90, 0xfa, 0x84, 0xfa, 0x03, 0xd7, 0xf1, 0x29, 0x5a, 0x83, 0x5c, 0x8f, 0x2f, 0xf8, 0x55, 0x63,
0x29, 0xb3, 0x5c, 0x5a, 0xbd, 0xb4, 0x12, 0x5c, 0x79, 0xe2, 0x06, 0x09, 0xf5, 0x5f, 0x72, 0x98,
0x37, 0x22, 0x6a, 0x6b, 0xed, 0x36, 0x94, 0x22, 0x60, 0xb4, 0x00, 0x99, 0x03, 0x3a, 0xaa, 0x1a,
0x4b, 0xc6, 0x72, 0x91, 0xf0, 0x21, 0xba, 0x02, 0xd9, 0x77, 0x39, 0x99, 0x6a, 0x7a, 0xc9, 0x58,
0x2e, 0xad, 0x9e, 0x0f, 0x0f, 0x79, 0xc3, 0xb1, 0xef, 0x0c, 0xa9, 0xd8, 0xad, 0x0e, 0x92, 0x98,
0x57, 0xd3, 0xcf, 0x1a, 0xf8, 0x12, 0x9c, 0x3e, 0xb6, 0x8e, 0xce, 0x42, 0x4e, 0x60, 0xc8, 0x1b,
0x17, 0x89, 0x9a, 0xe1, 0x0a, 0xa0, 0x6d, 0xe6, 0x51, 0xab, 0x4f, 0x2c, 0xc6, 0xef, 0x7b, 0x67,
0x48, 0x7d, 0x86, 0x5f, 0x85, 0xc5, 0x18, 0x54, 0xb1, 0xfd, 0x0c, 0x94, 0xfc, 0x10, 0xac, 0x78,
0xaf, 0x84, 0xd7, 0x0a, 0xf7, 0x90, 0x28, 0x22, 0xfe, 0xb5, 0x01, 0x10, 0xae, 0xa1, 0x3a, 0x80,
0x5c, 0x7d, 0xd9, 0xf2, 0xf7, 0x05, 0xc3, 0x26, 0x89, 0x40, 0xd0, 0x65, 0x38, 0x1d, 0xce, 0x6e,
0xba, 0xdb, 0xfb, 0x96, 0xd7, 0x11, 0x32, 0x30, 0xc9, 0xf1, 0x05, 0x84, 0xc0, 0xf4, 0x2c, 0x46,
0xab, 0x99, 0x25, 0x63, 0x39, 0x43, 0xc4, 0x98, 0x73, 0xcb, 0xa8, 0x63, 0x39, 0xac, 0x6a, 0x0a,
0x71, 0xaa, 0x19, 0x87, 0x73, 0xfd, 0x52, 0xbf, 0x9a, 0x5d, 0x32, 0x96, 0xe7, 0x88, 0x9a, 0xe1,
0x0f, 0x32, 0x50, 0x7e, 0x7d, 0x48, 0xbd, 0x91, 0x12, 0x00, 0xaa, 0x43, 0xc1, 0xa7, 0x3d, 0xda,
0x66, 0xae, 0x27, 0x35, 0xd2, 0x4a, 0x57, 0x0d, 0x12, 0xc0, 0x50, 0x05, 0xb2, 0x3d, 0xbb, 0x6f,
0x33, 0x71, 0xad, 0x39, 0x22, 0x27, 0xe8, 0x2a, 0x64, 0x7d, 0x66, 0x79, 0x4c, 0xdc, 0xa5, 0xb4,
0x5a, 0x5b, 0x91, 0x86, 0xb9, 0xa2, 0x0d, 0x73, 0x65, 0x47, 0x1b, 0x66, 0xab, 0xf0, 0xe1, 0xb8,
0x91, 0x7a, 0xff, 0x5f, 0x0d, 0x83, 0xc8, 0x2d, 0xe8, 0x19, 0xc8, 0x50, 0xa7, 0x23, 0xee, 0xfb,
0x45, 0x77, 0xf2, 0x0d, 0xe8, 0x0a, 0x14, 0x3b, 0xb6, 0x47, 0xdb, 0xcc, 0x76, 0x1d, 0xc1, 0xd5,
0xfc, 0xea, 0x62, 0xa8, 0x91, 0x75, 0xbd, 0x44, 0x42, 0x2c, 0x74, 0x19, 0x72, 0x3e, 0x17, 0x9d,
0x5f, 0xcd, 0x73, 0x5b, 0x68, 0x55, 0x8e, 0xc6, 0x8d, 0x05, 0x09, 0xb9, 0xec, 0xf6, 0x6d, 0x46,
0xfb, 0x03, 0x36, 0x22, 0x0a, 0x07, 0x3d, 0x0e, 0xf9, 0x0e, 0xed, 0x51, 0xae, 0xf0, 0x82, 0x50,
0xf8, 0x42, 0x84, 0xbc, 0x58, 0x20, 0x1a, 0x01, 0xbd, 0x0d, 0xe6, 0xa0, 0x67, 0x39, 0xd5, 0xa2,
0xe0, 0x62, 0x3e, 0x44, 0xbc, 0xd5, 0xb3, 0x9c, 0xd6, 0x73, 0x9f, 0x8c, 0x1b, 0x4f, 0x77, 0x6d,
0xb6, 0x3f, 0xdc, 0x5d, 0x69, 0xbb, 0xfd, 0x66, 0xd7, 0xb3, 0xf6, 0x2c, 0xc7, 0x6a, 0xf6, 0xdc,
0x03, 0xbb, 0xf9, 0xee, 0x53, 0x4d, 0xfe, 0x06, 0xef, 0x0c, 0xa9, 0x67, 0x53, 0xaf, 0xc9, 0xc9,
0xac, 0x08, 0x95, 0xf0, 0xad, 0x44, 0x90, 0xbd, 0x61, 0x16, 0x72, 0x0b, 0x79, 0x7c, 0x2f, 0x0d,
0x68, 0xdb, 0xea, 0x0f, 0x7a, 0x74, 0x26, 0x95, 0x05, 0xca, 0x49, 0x9f, 0x58, 0x39, 0x99, 0x59,
0x95, 0x13, 0x4a, 0xda, 0x9c, 0x4d, 0xd2, 0xd9, 0x2f, 0x2a, 0xe9, 0xdc, 0x57, 0x22, 0x69, 0x5c,
0x05, 0x93, 0xcf, 0xb8, 0x53, 0xf2, 0xac, 0xbb, 0x42, 0x9e, 0x65, 0xc2, 0x87, 0x78, 0x0b, 0x72,
0xf2, 0x2e, 0xa8, 0x96, 0x14, 0x78, 0xfc, 0x7d, 0x84, 0xc2, 0xce, 0x68, 0x31, 0x2e, 0x84, 0x62,
0xcc, 0x08, 0x01, 0xe1, 0xbf, 0x18, 0x30, 0xa7, 0xb4, 0xa8, 0x7c, 0xcc, 0x2e, 0xe4, 0xe5, 0x1b,
0xd7, 0xfe, 0xe5, 0x5c, 0xd2, 0xbf, 0x5c, 0xeb, 0x58, 0x03, 0x46, 0xbd, 0x56, 0xf3, 0xc3, 0x71,
0xc3, 0xf8, 0x64, 0xdc, 0x78, 0x6c, 0x1a, 0xa3, 0xda, 0xa7, 0x6b, 0xbf, 0xa4, 0x09, 0xa3, 0x4b,
0xe2, 0x76, 0xcc, 0x57, 0xa6, 0x70, 0x6a, 0x45, 0x86, 0x82, 0x4d, 0xa7, 0x4b, 0x7d, 0x4e, 0xd9,
0xe4, 0x5a, 0x24, 0x12, 0x87, 0xb3, 0x79, 0xd7, 0xf2, 0x1c, 0xdb, 0xe9, 0xfa, 0xd5, 0x8c, 0xf0,
0x9d, 0xc1, 0x1c, 0xff, 0xd2, 0x80, 0xc5, 0x98, 0x29, 0x2a, 0x26, 0x9e, 0x85, 0x9c, 0xcf, 0xa5,
0xab, 0x79, 0x88, 0x28, 0x72, 0x5b, 0xc0, 0x5b, 0xf3, 0xea, 0xf2, 0x39, 0x39, 0x27, 0x0a, 0xff,
0xc1, 0x5d, 0xed, 0xef, 0x06, 0x94, 0x45, 0x00, 0xd0, 0xef, 0x03, 0x81, 0xe9, 0x58, 0x7d, 0xaa,
0x54, 0x25, 0xc6, 0x91, 0xa8, 0xc0, 0x8f, 0x2b, 0xe8, 0xa8, 0x30, 0xab, 0x23, 0x33, 0x4e, 0xec,
0xc8, 0x8c, 0xf0, 0xad, 0x54, 0x20, 0xcb, 0x4d, 0x72, 0x24, 0x9c, 0x58, 0x91, 0xc8, 0x09, 0x7e,
0x0c, 0xe6, 0x14, 0x17, 0x4a, 0xb4, 0xd3, 0x02, 0x59, 0x1f, 0x72, 0x52, 0x13, 0xe8, 0x1b, 0x50,
0x0c, 0x12, 0x00, 0xc1, 0x6d, 0xa6, 0x95, 0x3b, 0x1a, 0x37, 0xd2, 0xcc, 0x27, 0xe1, 0x02, 0x6a,
0x44, 0x83, 0xab, 0xd1, 0x2a, 0x1e, 0x8d, 0x1b, 0x12, 0xa0, 0x42, 0x29, 0xba, 0x00, 0xe6, 0x3e,
0x8f, 0x4f, 0x5c, 0x04, 0x66, 0xab, 0x70, 0x34, 0x6e, 0x88, 0x39, 0x11, 0x7f, 0xf1, 0x06, 0x94,
0xb7, 0x68, 0xd7, 0x6a, 0x8f, 0xd4, 0xa1, 0x15, 0x4d, 0x8e, 0x1f, 0x68, 0x68, 0x1a, 0x8f, 0x40,
0x39, 0x38, 0xf1, 0x9d, 0xbe, 0xaf, 0x5e, 0x43, 0x29, 0x80, 0xbd, 0xea, 0xe3, 0x5f, 0x19, 0xa0,
0x6c, 0x00, 0xe1, 0x48, 0x56, 0xc1, 0xfd, 0x17, 0x1c, 0x8d, 0x1b, 0x0a, 0xa2, 0x93, 0x06, 0xf4,
0x3c, 0xe4, 0x7d, 0x71, 0x22, 0x27, 0x96, 0x34, 0x2d, 0xb1, 0xd0, 0x3a, 0xc5, 0x4d, 0xe4, 0x68,
0xdc, 0xd0, 0x88, 0x44, 0x0f, 0xd0, 0x4a, 0x2c, 0xf0, 0x4a, 0xc6, 0xe6, 0x8f, 0xc6, 0x8d, 0x08,
0x34, 0x1a, 0x88, 0xf1, 0xe7, 0x06, 0x94, 0x76, 0x2c, 0x3b, 0x30, 0xa1, 0xaa, 0x56, 0x51, 0xe8,
0x5f, 0x25, 0x80, 0x5b, 0x62, 0x87, 0xf6, 0xac, 0xd1, 0x75, 0xd7, 0x13, 0x74, 0xe7, 0x48, 0x30,
0x0f, 0x63, 0xa5, 0x39, 0x31, 0x56, 0x66, 0x67, 0x77, 0xc7, 0x5f, 0xad, 0xf3, 0xbb, 0x61, 0x16,
0xd2, 0x0b, 0x19, 0xfc, 0x47, 0x03, 0xca, 0x92, 0x79, 0x65, 0x79, 0x3f, 0x82, 0x9c, 0x94, 0x8d,
0x60, 0xff, 0xff, 0x38, 0xa6, 0x4b, 0xb3, 0x38, 0x25, 0x45, 0x13, 0xbd, 0x08, 0xf3, 0x1d, 0xcf,
0x1d, 0x0c, 0x68, 0x67, 0x5b, 0xb9, 0xbf, 0x74, 0xd2, 0xfd, 0xad, 0x47, 0xd7, 0x49, 0x02, 0x1d,
0xff, 0xc3, 0x80, 0x39, 0xe5, 0x4c, 0x94, 0xba, 0x02, 0x11, 0x1b, 0x27, 0x8e, 0x78, 0xe9, 0x59,
0x23, 0xde, 0x59, 0xc8, 0x75, 0x3d, 0x77, 0x38, 0xd0, 0x0e, 0x49, 0xcd, 0x66, 0x8b, 0x84, 0xf8,
0x06, 0xcc, 0x6b, 0x56, 0xa6, 0x78, 0xd4, 0x5a, 0xd2, 0xa3, 0x6e, 0x76, 0xa8, 0xc3, 0xec, 0x3d,
0x3b, 0xf0, 0x91, 0x0a, 0x1f, 0xff, 0xd4, 0x80, 0x85, 0x24, 0x0a, 0x5a, 0x4f, 0x24, 0xf0, 0x8f,
0x4e, 0x27, 0x17, 0xcd, 0xdd, 0x35, 0x69, 0x95, 0xc1, 0x3f, 0x7d, 0xbf, 0x0c, 0xbe, 0x12, 0x75,
0x32, 0x45, 0xe5, 0x15, 0xf0, 0x2f, 0x0c, 0x98, 0x8b, 0xe9, 0x12, 0x3d, 0x0b, 0xe6, 0x9e, 0xe7,
0xf6, 0x67, 0x52, 0x94, 0xd8, 0x81, 0xbe, 0x0d, 0x69, 0xe6, 0xce, 0xa4, 0xa6, 0x34, 0x73, 0xb9,
0x96, 0x14, 0xfb, 0x19, 0x99, 0x1f, 0xcb, 0x19, 0x7e, 0x1a, 0x8a, 0x82, 0xa1, 0x5b, 0x96, 0xed,
0x4d, 0x0c, 0x18, 0x93, 0x19, 0x7a, 0x1e, 0x4e, 0x49, 0x67, 0x38, 0x79, 0x73, 0x79, 0xd2, 0xe6,
0xb2, 0xde, 0x7c, 0x1e, 0xb2, 0x6b, 0xfb, 0x43, 0xe7, 0x80, 0x6f, 0xe9, 0x58, 0xcc, 0xd2, 0x5b,
0xf8, 0x18, 0x9f, 0x81, 0x45, 0xfe, 0x06, 0xa9, 0xe7, 0xaf, 0xb9, 0x43, 0x87, 0xe9, 0xfa, 0xe4,
0x32, 0x54, 0xe2, 0x60, 0x65, 0x25, 0x15, 0xc8, 0xb6, 0x39, 0x40, 0xd0, 0x98, 0x23, 0x72, 0x82,
0x7f, 0x6b, 0x00, 0xda, 0xa0, 0x4c, 0x9c, 0xb2, 0xb9, 0x1e, 0x3c, 0x8f, 0x1a, 0x14, 0xfa, 0x16,
0x6b, 0xef, 0x53, 0xcf, 0xd7, 0xf9, 0x8b, 0x9e, 0x7f, 0x1d, 0xc9, 0x22, 0xbe, 0x02, 0x8b, 0xb1,
0x5b, 0x2a, 0x9e, 0x6a, 0x50, 0x68, 0x2b, 0x98, 0x0a, 0x79, 0xc1, 0x1c, 0xff, 0x29, 0x0d, 0x05,
0xb1, 0x81, 0xd0, 0x3d, 0x74, 0x05, 0x4a, 0x7b, 0xb6, 0xd3, 0xa5, 0xde, 0xc0, 0xb3, 0x95, 0x08,
0xcc, 0xd6, 0xa9, 0xa3, 0x71, 0x23, 0x0a, 0x26, 0xd1, 0x09, 0x7a, 0x02, 0xf2, 0x43, 0x9f, 0x7a,
0xef, 0xd8, 0xf2, 0xa5, 0x17, 0x5b, 0x95, 0xc3, 0x71, 0x23, 0xf7, 0x86, 0x4f, 0xbd, 0xcd, 0x75,
0x1e, 0x7c, 0x86, 0x62, 0x44, 0xe4, 0x6f, 0x07, 0xbd, 0xa2, 0xcc, 0x54, 0x24, 0x70, 0xad, 0xef,
0xf0, 0xeb, 0x27, 0x5c, 0xdd, 0xc0, 0x73, 0xfb, 0x94, 0xed, 0xd3, 0xa1, 0xdf, 0x6c, 0xbb, 0xfd,
0xbe, 0xeb, 0x34, 0x45, 0xc5, 0x2d, 0x98, 0xe6, 0x11, 0x94, 0x6f, 0x57, 0x96, 0xbb, 0x03, 0x79,
0xb6, 0xef, 0xb9, 0xc3, 0xee, 0xbe, 0x08, 0x0c, 0x99, 0xd6, 0xd5, 0xd9, 0xe9, 0x69, 0x0a, 0x44,
0x0f, 0xd0, 0x23, 0x5c, 0x5a, 0xb4, 0x7d, 0xe0, 0x0f, 0xfb, 0xb2, 0xc6, 0x6b, 0x65, 0x8f, 0xc6,
0x0d, 0xe3, 0x09, 0x12, 0x80, 0xf1, 0x4f, 0xd2, 0xd0, 0x88, 0x94, 0xc6, 0xd7, 0x5d, 0xef, 0x55,
0xca, 0x3c, 0xbb, 0x7d, 0xd3, 0xea, 0x53, 0x6d, 0x1b, 0x0d, 0x28, 0xf5, 0x05, 0xf0, 0x9d, 0xc8,
0x13, 0x80, 0x7e, 0x80, 0x87, 0x2e, 0x02, 0x88, 0x37, 0x23, 0xd7, 0xe5, 0x6b, 0x28, 0x0a, 0x88,
0x58, 0x5e, 0x8b, 0x49, 0xaa, 0x39, 0x23, 0x67, 0x4a, 0x42, 0x9b, 0x49, 0x09, 0xcd, 0x4c, 0x27,
0x10, 0x4b, 0xd4, 0xd6, 0xb3, 0x71, 0x5b, 0xc7, 0xff, 0x34, 0xa0, 0xbe, 0xa5, 0x6f, 0x7e, 0x42,
0x71, 0x68, 0x7e, 0xd3, 0x0f, 0x88, 0xdf, 0xcc, 0x97, 0xe3, 0x17, 0xd7, 0x01, 0xb6, 0x6c, 0x87,
0x5e, 0xb7, 0x7b, 0x8c, 0x7a, 0x13, 0xaa, 0x98, 0x9f, 0x67, 0x42, 0x97, 0x40, 0xe8, 0x9e, 0xe6,
0x73, 0x2d, 0xe2, 0x87, 0x1f, 0x04, 0x1b, 0xe9, 0x07, 0xa8, 0xb6, 0x4c, 0xc2, 0x45, 0x39, 0x90,
0xdf, 0x13, 0xec, 0xc9, 0x90, 0x1a, 0x6b, 0xc4, 0x84, 0xbc, 0xb7, 0xbe, 0xa7, 0x0e, 0x7f, 0xe6,
0x3e, 0x19, 0x91, 0x68, 0x8f, 0x35, 0xfd, 0x91, 0xc3, 0xac, 0xf7, 0x22, 0xfb, 0x89, 0x3e, 0x04,
0x59, 0x2a, 0xe9, 0xca, 0x4e, 0x4c, 0xba, 0x5e, 0x50, 0xc7, 0x7c, 0xa9, 0xaa, 0xf3, 0x85, 0xd0,
0x03, 0x0a, 0xa5, 0x28, 0x0f, 0xf8, 0x28, 0x98, 0x1e, 0xdd, 0xd3, 0xa1, 0x1a, 0x85, 0x27, 0x07,
0x98, 0x62, 0x1d, 0xff, 0xd5, 0x80, 0x85, 0x0d, 0xca, 0xe2, 0x49, 0xd0, 0x43, 0xa4, 0x52, 0xfc,
0x32, 0x9c, 0x8e, 0xdc, 0x5f, 0x71, 0xff, 0x54, 0x22, 0xf3, 0x39, 0x13, 0xf2, 0xbf, 0xe9, 0x74,
0xe8, 0x7b, 0xaa, 0xa0, 0x8c, 0x27, 0x3d, 0xb7, 0xa0, 0x14, 0x59, 0x44, 0xd7, 0x12, 0xe9, 0xce,
0x62, 0xa2, 0x5f, 0xc9, 0x43, 0x76, 0xab, 0xa2, 0x78, 0x92, 0x65, 0xa3, 0x4a, 0x66, 0x83, 0xd4,
0x60, 0x1b, 0x90, 0x50, 0x97, 0x20, 0x1b, 0x0d, 0x4e, 0x02, 0xfa, 0x4a, 0x90, 0xf7, 0x04, 0x73,
0xf4, 0x08, 0x98, 0x9e, 0x7b, 0x57, 0xe7, 0xb1, 0x73, 0xe1, 0x91, 0xc4, 0xbd, 0x4b, 0xc4, 0x12,
0x7e, 0x1e, 0x32, 0xc4, 0xbd, 0x8b, 0xea, 0x00, 0x9e, 0xe5, 0x74, 0xe9, 0xed, 0xa0, 0x82, 0x2a,
0x93, 0x08, 0x64, 0x4a, 0xe2, 0xb0, 0x06, 0xa7, 0xa3, 0x37, 0x92, 0xea, 0x5e, 0x81, 0xfc, 0xeb,
0xc3, 0xa8, 0xb8, 0x2a, 0x09, 0x71, 0xc9, 0x42, 0x5d, 0x23, 0x71, 0x9b, 0x81, 0x10, 0x8e, 0x2e,
0x40, 0x91, 0x59, 0xbb, 0x3d, 0x7a, 0x33, 0x74, 0x73, 0x21, 0x80, 0xaf, 0xf2, 0xe2, 0xef, 0x76,
0x24, 0x03, 0x0a, 0x01, 0xe8, 0x71, 0x58, 0x08, 0xef, 0x7c, 0xcb, 0xa3, 0x7b, 0xf6, 0x7b, 0x42,
0xc3, 0x65, 0x72, 0x0c, 0x8e, 0x96, 0xe1, 0x54, 0x08, 0xdb, 0x16, 0x99, 0x86, 0x29, 0x50, 0x93,
0x60, 0x2e, 0x1b, 0xc1, 0xee, 0x4b, 0x77, 0x86, 0x56, 0x4f, 0x3c, 0xbe, 0x32, 0x89, 0x40, 0xf0,
0xdf, 0x0c, 0x38, 0x2d, 0x55, 0xcd, 0x2c, 0xf6, 0x50, 0x5a, 0xfd, 0xef, 0x0c, 0x40, 0x51, 0x0e,
0x94, 0x69, 0x7d, 0x33, 0xda, 0x08, 0xe2, 0xa9, 0x4c, 0x49, 0xd4, 0xb4, 0x12, 0x14, 0xf6, 0x72,
0x30, 0xe4, 0x44, 0x3a, 0x24, 0x8b, 0x6b, 0x53, 0x16, 0xcd, 0x12, 0x42, 0xd4, 0x2f, 0xaf, 0xf5,
0x77, 0x47, 0x8c, 0xfa, 0xaa, 0xe4, 0x15, 0xb5, 0xbe, 0x00, 0x10, 0xf9, 0xc3, 0xcf, 0xa2, 0x0e,
0x13, 0x56, 0x63, 0x86, 0x67, 0x29, 0x10, 0xd1, 0x03, 0xfc, 0x87, 0x34, 0xcc, 0xdd, 0x76, 0x7b,
0xc3, 0x30, 0x30, 0x3e, 0x4c, 0x01, 0x23, 0x56, 0x87, 0x67, 0x75, 0x1d, 0x8e, 0xc0, 0xf4, 0x19,
0x1d, 0x08, 0xcb, 0xca, 0x10, 0x31, 0x46, 0x18, 0xca, 0xcc, 0xf2, 0xba, 0x94, 0xc9, 0xea, 0xa6,
0x9a, 0x13, 0x69, 0x67, 0x0c, 0x86, 0x96, 0xa0, 0x64, 0x75, 0xbb, 0x1e, 0xed, 0x5a, 0x8c, 0xb6,
0x46, 0xd5, 0xbc, 0x38, 0x2c, 0x0a, 0xc2, 0x6f, 0xc1, 0xbc, 0x16, 0x96, 0x52, 0xe9, 0x93, 0x90,
0x7f, 0x57, 0x40, 0x26, 0xf4, 0xc5, 0x24, 0xaa, 0x72, 0x63, 0x1a, 0x2d, 0xde, 0x67, 0xd7, 0x77,
0xc6, 0x37, 0x20, 0x27, 0xd1, 0xd1, 0x85, 0x68, 0x8d, 0x22, 0x9b, 0x34, 0x7c, 0xae, 0x0a, 0x0e,
0x0c, 0x39, 0x49, 0x48, 0x29, 0x5e, 0xd8, 0x86, 0x84, 0x10, 0xf5, 0x8b, 0xff, 0x6b, 0xc0, 0x99,
0x75, 0xca, 0x68, 0x9b, 0xd1, 0xce, 0x75, 0x9b, 0xf6, 0x3a, 0x5f, 0x6b, 0xf9, 0x1c, 0x34, 0xc1,
0x32, 0x91, 0x26, 0x18, 0xf7, 0x3b, 0x3d, 0xdb, 0xa1, 0x5b, 0x91, 0x2e, 0x4a, 0x08, 0xe0, 0x1e,
0x62, 0x8f, 0x5f, 0x5c, 0x2e, 0xcb, 0x0f, 0x1b, 0x11, 0x48, 0xa0, 0xe1, 0x5c, 0xa8, 0x61, 0x6c,
0xc3, 0xd9, 0x24, 0xd3, 0x4a, 0x47, 0x4d, 0xc8, 0x89, 0xbd, 0x13, 0xda, 0xaf, 0xb1, 0x1d, 0x44,
0xa1, 0x25, 0x8e, 0x4f, 0x27, 0x8f, 0xc7, 0x3f, 0xe3, 0xd5, 0x6e, 0x74, 0xa7, 0x50, 0x2a, 0x37,
0x22, 0xe5, 0x60, 0xe5, 0x04, 0x7d, 0x0b, 0x4c, 0x36, 0x1a, 0x28, 0xbf, 0xda, 0x3a, 0xf3, 0xf9,
0xb8, 0x71, 0x3a, 0xb6, 0x6d, 0x67, 0x34, 0xa0, 0x44, 0xa0, 0x70, 0xdb, 0x6b, 0x5b, 0x5e, 0xc7,
0x76, 0xac, 0x9e, 0xcd, 0xa4, 0xac, 0x4c, 0x12, 0x05, 0xa1, 0x8b, 0x90, 0xf3, 0x0f, 0x28, 0x6b,
0xcb, 0xcc, 0xb9, 0xac, 0x8b, 0x00, 0x05, 0xc4, 0xbf, 0x89, 0x28, 0x5d, 0xda, 0xf3, 0x09, 0x95,
0x6e, 0x9c, 0x58, 0xe9, 0xc6, 0x7d, 0x94, 0x8e, 0x7f, 0x10, 0xaa, 0x48, 0x5f, 0x51, 0xa9, 0xe8,
0x45, 0x98, 0xef, 0xc4, 0x56, 0xa6, 0xab, 0x4a, 0xf6, 0x4e, 0x13, 0xe8, 0x78, 0x23, 0xd4, 0x88,
0x80, 0x4c, 0xd1, 0x48, 0x42, 0xcc, 0xe9, 0x63, 0x62, 0x7e, 0xfc, 0x51, 0x28, 0x06, 0x5f, 0x98,
0x50, 0x09, 0xf2, 0xd7, 0x5f, 0x23, 0x6f, 0x5e, 0x23, 0xeb, 0x0b, 0x29, 0x54, 0x86, 0x42, 0xeb,
0xda, 0xda, 0x2b, 0x62, 0x66, 0xac, 0x7e, 0x90, 0xd3, 0x61, 0xd9, 0x43, 0xdf, 0x85, 0xac, 0x8c,
0xb5, 0x67, 0xc3, 0xeb, 0x46, 0x3f, 0xe4, 0xd4, 0xce, 0x1d, 0x83, 0x4b, 0xbe, 0x71, 0xea, 0x49,
0x03, 0xdd, 0x84, 0x92, 0x00, 0xaa, 0xb6, 0xeb, 0x85, 0x64, 0xf7, 0x33, 0x46, 0xe9, 0xe2, 0x94,
0xd5, 0x08, 0xbd, 0xab, 0x90, 0x95, 0x22, 0x38, 0x9b, 0x48, 0x89, 0x26, 0xdc, 0x26, 0xd6, 0x88,
0xc6, 0x29, 0xf4, 0x1c, 0x98, 0x3b, 0x96, 0xdd, 0x43, 0x91, 0x8c, 0x2c, 0xd2, 0x2d, 0xad, 0x9d,
0x4d, 0x82, 0x23, 0xc7, 0xbe, 0x10, 0x34, 0x7d, 0xcf, 0x25, 0x3b, 0x4f, 0x7a, 0x7b, 0xf5, 0xf8,
0x42, 0x70, 0xf2, 0x6b, 0xb2, 0x35, 0xa9, 0xfb, 0x1f, 0xe8, 0x62, 0xfc, 0xa8, 0x44, 0xbb, 0xa4,
0x56, 0x9f, 0xb6, 0x1c, 0x10, 0xdc, 0x82, 0x52, 0xa4, 0xf7, 0x10, 0x15, 0xeb, 0xf1, 0xc6, 0x49,
0x54, 0xac, 0x13, 0x1a, 0x16, 0x38, 0x85, 0x36, 0xa0, 0xc0, 0xf3, 0x58, 0xf1, 0x8d, 0xe2, 0x7c,
0x32, 0x5d, 0x8d, 0xa4, 0x29, 0xb5, 0x0b, 0x93, 0x17, 0x03, 0x42, 0xdf, 0x87, 0xe2, 0x06, 0x65,
0xca, 0xd7, 0x9f, 0x4b, 0x06, 0x8b, 0x09, 0x92, 0x8a, 0x07, 0x1c, 0x9c, 0x42, 0x6f, 0x89, 0x94,
0x3a, 0xee, 0xeb, 0x50, 0x63, 0x8a, 0x4f, 0x0b, 0xee, 0xb5, 0x34, 0x1d, 0x21, 0xa0, 0xfc, 0x66,
0x8c, 0xb2, 0x8a, 0x8a, 0x8d, 0x29, 0x4f, 0x30, 0xa0, 0xdc, 0xb8, 0xcf, 0x7f, 0x0a, 0xe0, 0xd4,
0xea, 0xdb, 0xfa, 0x63, 0xf9, 0xba, 0xc5, 0x2c, 0xf4, 0x1a, 0xcc, 0x0b, 0x59, 0x06, 0x5f, 0xd3,
0x63, 0x36, 0x7f, 0xec, 0xd3, 0x7d, 0xcc, 0xe6, 0x8f, 0x7f, 0xc2, 0xc7, 0xa9, 0xd6, 0xdb, 0x1f,
0xdd, 0xab, 0xa7, 0x3e, 0xbe, 0x57, 0x4f, 0x7d, 0x76, 0xaf, 0x6e, 0xfc, 0xf8, 0xb0, 0x6e, 0xfc,
0xfe, 0xb0, 0x6e, 0x7c, 0x78, 0x58, 0x37, 0x3e, 0x3a, 0xac, 0x1b, 0xff, 0x3e, 0xac, 0x1b, 0xff,
0x39, 0xac, 0xa7, 0x3e, 0x3b, 0xac, 0x1b, 0xef, 0x7f, 0x5a, 0x4f, 0x7d, 0xf4, 0x69, 0x3d, 0xf5,
0xf1, 0xa7, 0xf5, 0xd4, 0x0f, 0x1f, 0xbb, 0x7f, 0xf9, 0x28, 0x1d, 0x5d, 0x4e, 0xfc, 0x3c, 0xf5,
0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x90, 0x3c, 0x9c, 0xf7, 0xd2, 0x21, 0x00, 0x00,
// 2611 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x3a, 0x4d, 0x6c, 0x1b, 0xc7,
0xd5, 0x5c, 0x72, 0xf9, 0xf7, 0x48, 0xc9, 0xf2, 0x88, 0xb6, 0x09, 0xda, 0xe1, 0x2a, 0x83, 0xef,
0x4b, 0xdc, 0xd8, 0x11, 0x63, 0xa7, 0x49, 0x1d, 0xa7, 0x69, 0x6a, 0x4a, 0xb1, 0x63, 0x47, 0x71,
0x9c, 0x91, 0xe2, 0xa4, 0x45, 0x83, 0x60, 0x45, 0x8e, 0xa8, 0x85, 0xc8, 0x5d, 0x7a, 0x77, 0x18,
0x87, 0xb7, 0x02, 0x3d, 0x17, 0x0d, 0xd0, 0x43, 0xdb, 0x4b, 0xd1, 0x02, 0x05, 0x5a, 0xa4, 0xe8,
0xa5, 0xe8, 0xb1, 0x68, 0x2f, 0x3d, 0xa4, 0xb7, 0xf4, 0x16, 0xe4, 0xc0, 0xd6, 0xca, 0xa5, 0xd0,
0x29, 0x40, 0x6f, 0x39, 0x15, 0xf3, 0xb3, 0xbb, 0xb3, 0x2b, 0xb2, 0x0e, 0x15, 0x07, 0x81, 0x2f,
0xe2, 0xcc, 0x9b, 0x37, 0x6f, 0xe6, 0xfd, 0xcc, 0xfb, 0x5b, 0xc1, 0xe9, 0xe1, 0x5e, 0xaf, 0xd5,
0xf7, 0x7a, 0x43, 0xdf, 0x63, 0x5e, 0x34, 0x58, 0x15, 0x7f, 0x51, 0x29, 0x9c, 0x37, 0x6a, 0x3d,
0xaf, 0xe7, 0x49, 0x1c, 0x3e, 0x92, 0xeb, 0x0d, 0xab, 0xe7, 0x79, 0xbd, 0x3e, 0x6d, 0x89, 0xd9,
0xf6, 0x68, 0xa7, 0xc5, 0x9c, 0x01, 0x0d, 0x98, 0x3d, 0x18, 0x2a, 0x84, 0x15, 0x45, 0xfd, 0x4e,
0x7f, 0xe0, 0x75, 0x69, 0xbf, 0x15, 0x30, 0x9b, 0x05, 0xf2, 0xaf, 0xc2, 0x58, 0xe6, 0x18, 0xc3,
0x51, 0xb0, 0x2b, 0xfe, 0x48, 0x20, 0xfe, 0x93, 0x01, 0x27, 0x36, 0xec, 0x6d, 0xda, 0xdf, 0xf2,
0x6e, 0xdb, 0xfd, 0x11, 0x0d, 0x08, 0x0d, 0x86, 0x9e, 0x1b, 0x50, 0xb4, 0x06, 0x85, 0x3e, 0x5f,
0x08, 0xea, 0xc6, 0x4a, 0xee, 0x6c, 0xe5, 0xe2, 0xb9, 0xd5, 0xe8, 0xca, 0x53, 0x37, 0x48, 0x68,
0xf0, 0x92, 0xcb, 0xfc, 0x31, 0x51, 0x5b, 0x1b, 0xb7, 0xa1, 0xa2, 0x81, 0xd1, 0x12, 0xe4, 0xf6,
0xe8, 0xb8, 0x6e, 0xac, 0x18, 0x67, 0xcb, 0x84, 0x0f, 0xd1, 0x05, 0xc8, 0xbf, 0xcb, 0xc9, 0xd4,
0xb3, 0x2b, 0xc6, 0xd9, 0xca, 0xc5, 0xd3, 0xf1, 0x21, 0x6f, 0xb8, 0xce, 0x9d, 0x11, 0x15, 0xbb,
0xd5, 0x41, 0x12, 0xf3, 0x72, 0xf6, 0x92, 0x81, 0xcf, 0xc1, 0xf1, 0x43, 0xeb, 0xe8, 0x24, 0x14,
0x04, 0x86, 0xbc, 0x71, 0x99, 0xa8, 0x19, 0xae, 0x01, 0xda, 0x64, 0x3e, 0xb5, 0x07, 0xc4, 0x66,
0xfc, 0xbe, 0x77, 0x46, 0x34, 0x60, 0xf8, 0x55, 0x58, 0x4e, 0x40, 0x15, 0xdb, 0xcf, 0x42, 0x25,
0x88, 0xc1, 0x8a, 0xf7, 0x5a, 0x7c, 0xad, 0x78, 0x0f, 0xd1, 0x11, 0xf1, 0x2f, 0x0d, 0x80, 0x78,
0x0d, 0x35, 0x01, 0xe4, 0xea, 0xcb, 0x76, 0xb0, 0x2b, 0x18, 0x36, 0x89, 0x06, 0x41, 0xe7, 0xe1,
0x78, 0x3c, 0xbb, 0xe9, 0x6d, 0xee, 0xda, 0x7e, 0x57, 0xc8, 0xc0, 0x24, 0x87, 0x17, 0x10, 0x02,
0xd3, 0xb7, 0x19, 0xad, 0xe7, 0x56, 0x8c, 0xb3, 0x39, 0x22, 0xc6, 0x9c, 0x5b, 0x46, 0x5d, 0xdb,
0x65, 0x75, 0x53, 0x88, 0x53, 0xcd, 0x38, 0x9c, 0xeb, 0x97, 0x06, 0xf5, 0xfc, 0x8a, 0x71, 0x76,
0x81, 0xa8, 0x19, 0xfe, 0x20, 0x07, 0xd5, 0xd7, 0x47, 0xd4, 0x1f, 0x2b, 0x01, 0xa0, 0x26, 0x94,
0x02, 0xda, 0xa7, 0x1d, 0xe6, 0xf9, 0x52, 0x23, 0xed, 0x6c, 0xdd, 0x20, 0x11, 0x0c, 0xd5, 0x20,
0xdf, 0x77, 0x06, 0x0e, 0x13, 0xd7, 0x5a, 0x20, 0x72, 0x82, 0x2e, 0x43, 0x3e, 0x60, 0xb6, 0xcf,
0xc4, 0x5d, 0x2a, 0x17, 0x1b, 0xab, 0xd2, 0x30, 0x57, 0x43, 0xc3, 0x5c, 0xdd, 0x0a, 0x0d, 0xb3,
0x5d, 0xfa, 0x70, 0x62, 0x65, 0xde, 0xff, 0xa7, 0x65, 0x10, 0xb9, 0x05, 0x3d, 0x0b, 0x39, 0xea,
0x76, 0xc5, 0x7d, 0xbf, 0xe8, 0x4e, 0xbe, 0x01, 0x5d, 0x80, 0x72, 0xd7, 0xf1, 0x69, 0x87, 0x39,
0x9e, 0x2b, 0xb8, 0x5a, 0xbc, 0xb8, 0x1c, 0x6b, 0x64, 0x3d, 0x5c, 0x22, 0x31, 0x16, 0x3a, 0x0f,
0x85, 0x80, 0x8b, 0x2e, 0xa8, 0x17, 0xb9, 0x2d, 0xb4, 0x6b, 0x07, 0x13, 0x6b, 0x49, 0x42, 0xce,
0x7b, 0x03, 0x87, 0xd1, 0xc1, 0x90, 0x8d, 0x89, 0xc2, 0x41, 0x4f, 0x40, 0xb1, 0x4b, 0xfb, 0x94,
0x2b, 0xbc, 0x24, 0x14, 0xbe, 0xa4, 0x91, 0x17, 0x0b, 0x24, 0x44, 0x40, 0x6f, 0x83, 0x39, 0xec,
0xdb, 0x6e, 0xbd, 0x2c, 0xb8, 0x58, 0x8c, 0x11, 0x6f, 0xf5, 0x6d, 0xb7, 0xfd, 0xdc, 0x27, 0x13,
0xeb, 0x99, 0x9e, 0xc3, 0x76, 0x47, 0xdb, 0xab, 0x1d, 0x6f, 0xd0, 0xea, 0xf9, 0xf6, 0x8e, 0xed,
0xda, 0xad, 0xbe, 0xb7, 0xe7, 0xb4, 0xde, 0x7d, 0xba, 0xc5, 0xdf, 0xe0, 0x9d, 0x11, 0xf5, 0x1d,
0xea, 0xb7, 0x38, 0x99, 0x55, 0xa1, 0x12, 0xbe, 0x95, 0x08, 0xb2, 0x37, 0xcc, 0x52, 0x61, 0xa9,
0x88, 0xef, 0x65, 0x01, 0x6d, 0xda, 0x83, 0x61, 0x9f, 0xce, 0xa5, 0xb2, 0x48, 0x39, 0xd9, 0x23,
0x2b, 0x27, 0x37, 0xaf, 0x72, 0x62, 0x49, 0x9b, 0xf3, 0x49, 0x3a, 0xff, 0x45, 0x25, 0x5d, 0xf8,
0x4a, 0x24, 0x8d, 0xeb, 0x60, 0xf2, 0x19, 0x77, 0x4a, 0xbe, 0x7d, 0x57, 0xc8, 0xb3, 0x4a, 0xf8,
0x10, 0x6f, 0x40, 0x41, 0xde, 0x05, 0x35, 0xd2, 0x02, 0x4f, 0xbe, 0x8f, 0x58, 0xd8, 0xb9, 0x50,
0x8c, 0x4b, 0xb1, 0x18, 0x73, 0x42, 0x40, 0xf8, 0xcf, 0x06, 0x2c, 0x28, 0x2d, 0x2a, 0x1f, 0xb3,
0x0d, 0x45, 0xf9, 0xc6, 0x43, 0xff, 0x72, 0x2a, 0xed, 0x5f, 0xae, 0x74, 0xed, 0x21, 0xa3, 0x7e,
0xbb, 0xf5, 0xe1, 0xc4, 0x32, 0x3e, 0x99, 0x58, 0x8f, 0xcf, 0x62, 0x34, 0xf4, 0xe9, 0xa1, 0x5f,
0x0a, 0x09, 0xa3, 0x73, 0xe2, 0x76, 0x2c, 0x50, 0xa6, 0x70, 0x6c, 0x55, 0x86, 0x82, 0xeb, 0x6e,
0x8f, 0x06, 0x9c, 0xb2, 0xc9, 0xb5, 0x48, 0x24, 0x0e, 0x67, 0xf3, 0xae, 0xed, 0xbb, 0x8e, 0xdb,
0x0b, 0xea, 0x39, 0xe1, 0x3b, 0xa3, 0x39, 0xfe, 0xb9, 0x01, 0xcb, 0x09, 0x53, 0x54, 0x4c, 0x5c,
0x82, 0x42, 0xc0, 0xa5, 0x1b, 0xf2, 0xa0, 0x29, 0x72, 0x53, 0xc0, 0xdb, 0x8b, 0xea, 0xf2, 0x05,
0x39, 0x27, 0x0a, 0xff, 0xc1, 0x5d, 0xed, 0x6f, 0x06, 0x54, 0x45, 0x00, 0x08, 0xdf, 0x07, 0x02,
0xd3, 0xb5, 0x07, 0x54, 0xa9, 0x4a, 0x8c, 0xb5, 0xa8, 0xc0, 0x8f, 0x2b, 0x85, 0x51, 0x61, 0x5e,
0x47, 0x66, 0x1c, 0xd9, 0x91, 0x19, 0xf1, 0x5b, 0xa9, 0x41, 0x9e, 0x9b, 0xe4, 0x58, 0x38, 0xb1,
0x32, 0x91, 0x13, 0xfc, 0x38, 0x2c, 0x28, 0x2e, 0x94, 0x68, 0x67, 0x05, 0xb2, 0x01, 0x14, 0xa4,
0x26, 0xd0, 0xff, 0x41, 0x39, 0x4a, 0x00, 0x04, 0xb7, 0xb9, 0x76, 0xe1, 0x60, 0x62, 0x65, 0x59,
0x40, 0xe2, 0x05, 0x64, 0xe9, 0xc1, 0xd5, 0x68, 0x97, 0x0f, 0x26, 0x96, 0x04, 0xa8, 0x50, 0x8a,
0xce, 0x80, 0xb9, 0xcb, 0xe3, 0x13, 0x17, 0x81, 0xd9, 0x2e, 0x1d, 0x4c, 0x2c, 0x31, 0x27, 0xe2,
0x2f, 0xbe, 0x06, 0xd5, 0x0d, 0xda, 0xb3, 0x3b, 0x63, 0x75, 0x68, 0x2d, 0x24, 0xc7, 0x0f, 0x34,
0x42, 0x1a, 0x8f, 0x42, 0x35, 0x3a, 0xf1, 0x9d, 0x41, 0xa0, 0x5e, 0x43, 0x25, 0x82, 0xbd, 0x1a,
0xe0, 0x5f, 0x18, 0xa0, 0x6c, 0x00, 0x61, 0x2d, 0xab, 0xe0, 0xfe, 0x0b, 0x0e, 0x26, 0x96, 0x82,
0x84, 0x49, 0x03, 0x7a, 0x1e, 0x8a, 0x81, 0x38, 0x91, 0x13, 0x4b, 0x9b, 0x96, 0x58, 0x68, 0x1f,
0xe3, 0x26, 0x72, 0x30, 0xb1, 0x42, 0x44, 0x12, 0x0e, 0xd0, 0x6a, 0x22, 0xf0, 0x4a, 0xc6, 0x16,
0x0f, 0x26, 0x96, 0x06, 0xd5, 0x03, 0x31, 0xfe, 0xdc, 0x80, 0xca, 0x96, 0xed, 0x44, 0x26, 0x54,
0x0f, 0x55, 0x14, 0xfb, 0x57, 0x09, 0xe0, 0x96, 0xd8, 0xa5, 0x7d, 0x7b, 0x7c, 0xd5, 0xf3, 0x05,
0xdd, 0x05, 0x12, 0xcd, 0xe3, 0x58, 0x69, 0x4e, 0x8d, 0x95, 0xf9, 0xf9, 0xdd, 0xf1, 0x57, 0xeb,
0xfc, 0x6e, 0x98, 0xa5, 0xec, 0x52, 0x0e, 0xff, 0xc1, 0x80, 0xaa, 0x64, 0x5e, 0x59, 0xde, 0x0f,
0xa0, 0x20, 0x65, 0x23, 0xd8, 0xff, 0x1f, 0x8e, 0xe9, 0xdc, 0x3c, 0x4e, 0x49, 0xd1, 0x44, 0x2f,
0xc2, 0x62, 0xd7, 0xf7, 0x86, 0x43, 0xda, 0xdd, 0x54, 0xee, 0x2f, 0x9b, 0x76, 0x7f, 0xeb, 0xfa,
0x3a, 0x49, 0xa1, 0xe3, 0xbf, 0x1b, 0xb0, 0xa0, 0x9c, 0x89, 0x52, 0x57, 0x24, 0x62, 0xe3, 0xc8,
0x11, 0x2f, 0x3b, 0x6f, 0xc4, 0x3b, 0x09, 0x85, 0x9e, 0xef, 0x8d, 0x86, 0xa1, 0x43, 0x52, 0xb3,
0xf9, 0x22, 0x21, 0xbe, 0x01, 0x8b, 0x21, 0x2b, 0x33, 0x3c, 0x6a, 0x23, 0xed, 0x51, 0xaf, 0x77,
0xa9, 0xcb, 0x9c, 0x1d, 0x27, 0xf2, 0x91, 0x0a, 0x1f, 0xff, 0xc4, 0x80, 0xa5, 0x34, 0x0a, 0x5a,
0x4f, 0x25, 0xf0, 0x8f, 0xcd, 0x26, 0xa7, 0xe7, 0xee, 0x21, 0x69, 0x95, 0xc1, 0x3f, 0x73, 0xbf,
0x0c, 0xbe, 0xa6, 0x3b, 0x99, 0xb2, 0xf2, 0x0a, 0xf8, 0x67, 0x06, 0x2c, 0x24, 0x74, 0x89, 0x2e,
0x81, 0xb9, 0xe3, 0x7b, 0x83, 0xb9, 0x14, 0x25, 0x76, 0xa0, 0x6f, 0x42, 0x96, 0x79, 0x73, 0xa9,
0x29, 0xcb, 0x3c, 0xae, 0x25, 0xc5, 0x7e, 0x4e, 0xe6, 0xc7, 0x72, 0x86, 0x9f, 0x81, 0xb2, 0x60,
0xe8, 0x96, 0xed, 0xf8, 0x53, 0x03, 0xc6, 0x74, 0x86, 0x9e, 0x87, 0x63, 0xd2, 0x19, 0x4e, 0xdf,
0x5c, 0x9d, 0xb6, 0xb9, 0x1a, 0x6e, 0x3e, 0x0d, 0xf9, 0xb5, 0xdd, 0x91, 0xbb, 0xc7, 0xb7, 0x74,
0x6d, 0x66, 0x87, 0x5b, 0xf8, 0x18, 0x9f, 0x80, 0x65, 0xfe, 0x06, 0xa9, 0x1f, 0xac, 0x79, 0x23,
0x97, 0x85, 0xf5, 0xc9, 0x79, 0xa8, 0x25, 0xc1, 0xca, 0x4a, 0x6a, 0x90, 0xef, 0x70, 0x80, 0xa0,
0xb1, 0x40, 0xe4, 0x04, 0xff, 0xc6, 0x00, 0x74, 0x8d, 0x32, 0x71, 0xca, 0xf5, 0xf5, 0xe8, 0x79,
0x34, 0xa0, 0x34, 0xb0, 0x59, 0x67, 0x97, 0xfa, 0x41, 0x98, 0xbf, 0x84, 0xf3, 0xaf, 0x23, 0x59,
0xc4, 0x17, 0x60, 0x39, 0x71, 0x4b, 0xc5, 0x53, 0x03, 0x4a, 0x1d, 0x05, 0x53, 0x21, 0x2f, 0x9a,
0xe3, 0x3f, 0x66, 0xa1, 0x24, 0x36, 0x10, 0xba, 0x83, 0x2e, 0x40, 0x65, 0xc7, 0x71, 0x7b, 0xd4,
0x1f, 0xfa, 0x8e, 0x12, 0x81, 0xd9, 0x3e, 0x76, 0x30, 0xb1, 0x74, 0x30, 0xd1, 0x27, 0xe8, 0x49,
0x28, 0x8e, 0x02, 0xea, 0xbf, 0xe3, 0xc8, 0x97, 0x5e, 0x6e, 0xd7, 0xf6, 0x27, 0x56, 0xe1, 0x8d,
0x80, 0xfa, 0xd7, 0xd7, 0x79, 0xf0, 0x19, 0x89, 0x11, 0x91, 0xbf, 0x5d, 0xf4, 0x8a, 0x32, 0x53,
0x91, 0xc0, 0xb5, 0xbf, 0xc5, 0xaf, 0x9f, 0x72, 0x75, 0x43, 0xdf, 0x1b, 0x50, 0xb6, 0x4b, 0x47,
0x41, 0xab, 0xe3, 0x0d, 0x06, 0x9e, 0xdb, 0x12, 0x15, 0xb7, 0x60, 0x9a, 0x47, 0x50, 0xbe, 0x5d,
0x59, 0xee, 0x16, 0x14, 0xd9, 0xae, 0xef, 0x8d, 0x7a, 0xbb, 0x22, 0x30, 0xe4, 0xda, 0x97, 0xe7,
0xa7, 0x17, 0x52, 0x20, 0xe1, 0x00, 0x3d, 0xca, 0xa5, 0x45, 0x3b, 0x7b, 0xc1, 0x68, 0x20, 0x6b,
0xbc, 0x76, 0xfe, 0x60, 0x62, 0x19, 0x4f, 0x92, 0x08, 0x8c, 0x7f, 0x9c, 0x05, 0x4b, 0x2b, 0x8d,
0xaf, 0x7a, 0xfe, 0xab, 0x94, 0xf9, 0x4e, 0xe7, 0xa6, 0x3d, 0xa0, 0xa1, 0x6d, 0x58, 0x50, 0x19,
0x08, 0xe0, 0x3b, 0xda, 0x13, 0x80, 0x41, 0x84, 0x87, 0x1e, 0x01, 0x10, 0x6f, 0x46, 0xae, 0xcb,
0xd7, 0x50, 0x16, 0x10, 0xb1, 0xbc, 0x96, 0x90, 0x54, 0x6b, 0x4e, 0xce, 0x94, 0x84, 0xae, 0xa7,
0x25, 0x34, 0x37, 0x9d, 0x48, 0x2c, 0xba, 0xad, 0xe7, 0x93, 0xb6, 0x8e, 0xff, 0x61, 0x40, 0x73,
0x23, 0xbc, 0xf9, 0x11, 0xc5, 0x11, 0xf2, 0x9b, 0x7d, 0x40, 0xfc, 0xe6, 0xbe, 0x1c, 0xbf, 0xb8,
0x09, 0xb0, 0xe1, 0xb8, 0xf4, 0xaa, 0xd3, 0x67, 0xd4, 0x9f, 0x52, 0xc5, 0xfc, 0x34, 0x17, 0xbb,
0x04, 0x42, 0x77, 0x42, 0x3e, 0xd7, 0x34, 0x3f, 0xfc, 0x20, 0xd8, 0xc8, 0x3e, 0x40, 0xb5, 0xe5,
0x52, 0x2e, 0xca, 0x85, 0xe2, 0x8e, 0x60, 0x4f, 0x86, 0xd4, 0x44, 0x23, 0x26, 0xe6, 0xbd, 0xfd,
0x1d, 0x75, 0xf8, 0xb3, 0xf7, 0xc9, 0x88, 0x44, 0x7b, 0xac, 0x15, 0x8c, 0x5d, 0x66, 0xbf, 0xa7,
0xed, 0x27, 0xe1, 0x21, 0xc8, 0x56, 0x49, 0x57, 0x7e, 0x6a, 0xd2, 0xf5, 0x82, 0x3a, 0xe6, 0x4b,
0x55, 0x9d, 0x2f, 0xc4, 0x1e, 0x50, 0x28, 0x45, 0x79, 0xc0, 0xc7, 0xc0, 0xf4, 0xe9, 0x4e, 0x18,
0xaa, 0x51, 0x7c, 0x72, 0x84, 0x29, 0xd6, 0xf1, 0x5f, 0x0c, 0x58, 0xba, 0x46, 0x59, 0x32, 0x09,
0x7a, 0x88, 0x54, 0x8a, 0x5f, 0x86, 0xe3, 0xda, 0xfd, 0x15, 0xf7, 0x4f, 0xa7, 0x32, 0x9f, 0x13,
0x31, 0xff, 0xd7, 0xdd, 0x2e, 0x7d, 0x4f, 0x15, 0x94, 0xc9, 0xa4, 0xe7, 0x16, 0x54, 0xb4, 0x45,
0x74, 0x25, 0x95, 0xee, 0x2c, 0xa7, 0xfa, 0x95, 0x3c, 0x64, 0xb7, 0x6b, 0x8a, 0x27, 0x59, 0x36,
0xaa, 0x64, 0x36, 0x4a, 0x0d, 0x36, 0x01, 0x09, 0x75, 0x09, 0xb2, 0x7a, 0x70, 0x12, 0xd0, 0x57,
0xa2, 0xbc, 0x27, 0x9a, 0xa3, 0x47, 0xc1, 0xf4, 0xbd, 0xbb, 0x61, 0x1e, 0xbb, 0x10, 0x1f, 0x49,
0xbc, 0xbb, 0x44, 0x2c, 0xe1, 0xe7, 0x21, 0x47, 0xbc, 0xbb, 0xa8, 0x09, 0xe0, 0xdb, 0x6e, 0x8f,
0xde, 0x8e, 0x2a, 0xa8, 0x2a, 0xd1, 0x20, 0x33, 0x12, 0x87, 0x35, 0x38, 0xae, 0xdf, 0x48, 0xaa,
0x7b, 0x15, 0x8a, 0xaf, 0x8f, 0x74, 0x71, 0xd5, 0x52, 0xe2, 0x92, 0x85, 0x7a, 0x88, 0xc4, 0x6d,
0x06, 0x62, 0x38, 0x3a, 0x03, 0x65, 0x66, 0x6f, 0xf7, 0xe9, 0xcd, 0xd8, 0xcd, 0xc5, 0x00, 0xbe,
0xca, 0x8b, 0xbf, 0xdb, 0x5a, 0x06, 0x14, 0x03, 0xd0, 0x13, 0xb0, 0x14, 0xdf, 0xf9, 0x96, 0x4f,
0x77, 0x9c, 0xf7, 0x84, 0x86, 0xab, 0xe4, 0x10, 0x1c, 0x9d, 0x85, 0x63, 0x31, 0x6c, 0x53, 0x64,
0x1a, 0xa6, 0x40, 0x4d, 0x83, 0xb9, 0x6c, 0x04, 0xbb, 0x2f, 0xdd, 0x19, 0xd9, 0x7d, 0xf1, 0xf8,
0xaa, 0x44, 0x83, 0xe0, 0xbf, 0x1a, 0x70, 0x5c, 0xaa, 0x9a, 0xd9, 0xec, 0xa1, 0xb4, 0xfa, 0xdf,
0x1a, 0x80, 0x74, 0x0e, 0x94, 0x69, 0xfd, 0xbf, 0xde, 0x08, 0xe2, 0xa9, 0x4c, 0x45, 0xd4, 0xb4,
0x12, 0x14, 0xf7, 0x72, 0x30, 0x14, 0x44, 0x3a, 0x24, 0x8b, 0x6b, 0x53, 0x16, 0xcd, 0x12, 0x42,
0xd4, 0x2f, 0xaf, 0xf5, 0xb7, 0xc7, 0x8c, 0x06, 0xaa, 0xe4, 0x15, 0xb5, 0xbe, 0x00, 0x10, 0xf9,
0xc3, 0xcf, 0xa2, 0x2e, 0x13, 0x56, 0x63, 0xc6, 0x67, 0x29, 0x10, 0x09, 0x07, 0xf8, 0xf7, 0x59,
0x58, 0xb8, 0xed, 0xf5, 0x47, 0x71, 0x60, 0x7c, 0x98, 0x02, 0x46, 0xa2, 0x0e, 0xcf, 0x87, 0x75,
0x38, 0x02, 0x33, 0x60, 0x74, 0x28, 0x2c, 0x2b, 0x47, 0xc4, 0x18, 0x61, 0xa8, 0x32, 0xdb, 0xef,
0x51, 0x26, 0xab, 0x9b, 0x7a, 0x41, 0xa4, 0x9d, 0x09, 0x18, 0x5a, 0x81, 0x8a, 0xdd, 0xeb, 0xf9,
0xb4, 0x67, 0x33, 0xda, 0x1e, 0xd7, 0x8b, 0xe2, 0x30, 0x1d, 0x84, 0xdf, 0x82, 0xc5, 0x50, 0x58,
0x4a, 0xa5, 0x4f, 0x41, 0xf1, 0x5d, 0x01, 0x99, 0xd2, 0x17, 0x93, 0xa8, 0xca, 0x8d, 0x85, 0x68,
0xc9, 0x3e, 0x7b, 0x78, 0x67, 0x7c, 0x03, 0x0a, 0x12, 0x1d, 0x9d, 0xd1, 0x6b, 0x14, 0xd9, 0xa4,
0xe1, 0x73, 0x55, 0x70, 0x60, 0x28, 0x48, 0x42, 0x4a, 0xf1, 0xc2, 0x36, 0x24, 0x84, 0xa8, 0x5f,
0xfc, 0x1f, 0x03, 0x4e, 0xac, 0x53, 0x46, 0x3b, 0x8c, 0x76, 0xaf, 0x3a, 0xb4, 0xdf, 0xfd, 0x5a,
0xcb, 0xe7, 0xa8, 0x09, 0x96, 0xd3, 0x9a, 0x60, 0xdc, 0xef, 0xf4, 0x1d, 0x97, 0x6e, 0x68, 0x5d,
0x94, 0x18, 0xc0, 0x3d, 0xc4, 0x0e, 0xbf, 0xb8, 0x5c, 0x96, 0x1f, 0x36, 0x34, 0x48, 0xa4, 0xe1,
0x42, 0xac, 0x61, 0xfc, 0x23, 0x03, 0x4e, 0xa6, 0xb9, 0x56, 0x4a, 0x6a, 0x41, 0x41, 0x6c, 0x9e,
0xd2, 0x7f, 0x4d, 0xec, 0x20, 0x0a, 0x0d, 0x5d, 0x4a, 0x9c, 0x2f, 0x3e, 0x88, 0xb4, 0xeb, 0x07,
0x13, 0xab, 0x16, 0x43, 0xb5, 0x12, 0x5f, 0xc3, 0xc5, 0xbf, 0xe2, 0x85, 0xb0, 0x4e, 0x53, 0xe8,
0x9b, 0xdb, 0x97, 0xf2, 0xbd, 0x72, 0x82, 0xbe, 0x01, 0x26, 0x1b, 0x0f, 0x95, 0xcb, 0x6d, 0x9f,
0xf8, 0x7c, 0x62, 0x1d, 0x4f, 0x6c, 0xdb, 0x1a, 0x0f, 0x29, 0x11, 0x28, 0xdc, 0x2c, 0x3b, 0xb6,
0xdf, 0x75, 0x5c, 0xbb, 0xef, 0x30, 0x29, 0x46, 0x93, 0xe8, 0x20, 0xd1, 0x89, 0xd8, 0xa3, 0xac,
0x23, 0x93, 0xea, 0xaa, 0xea, 0x44, 0x08, 0x48, 0xa2, 0x13, 0x21, 0x20, 0xf8, 0xd7, 0x9a, 0x79,
0x48, 0xcb, 0x3f, 0xa2, 0x79, 0x18, 0x47, 0x36, 0x0f, 0xe3, 0x3e, 0xe6, 0x81, 0xbf, 0x17, 0xeb,
0x32, 0xbc, 0xa2, 0xd2, 0xe5, 0x8b, 0xb0, 0xd8, 0x4d, 0xac, 0xcc, 0xd6, 0xa9, 0xec, 0xb2, 0xa6,
0xd0, 0xf1, 0xb5, 0x58, 0x41, 0x02, 0x32, 0x43, 0x41, 0x29, 0xa9, 0x67, 0x0f, 0x49, 0xfd, 0x89,
0xc7, 0xa0, 0x1c, 0x7d, 0x8b, 0x42, 0x15, 0x28, 0x5e, 0x7d, 0x8d, 0xbc, 0x79, 0x85, 0xac, 0x2f,
0x65, 0x50, 0x15, 0x4a, 0xed, 0x2b, 0x6b, 0xaf, 0x88, 0x99, 0x71, 0xf1, 0x83, 0x42, 0x18, 0xc0,
0x7d, 0xf4, 0x6d, 0xc8, 0xcb, 0xa8, 0x7c, 0x32, 0xbe, 0xae, 0xfe, 0xc9, 0xa7, 0x71, 0xea, 0x10,
0x5c, 0xf2, 0x8d, 0x33, 0x4f, 0x19, 0xe8, 0x26, 0x54, 0x04, 0x50, 0x35, 0x68, 0xcf, 0xa4, 0xfb,
0xa4, 0x09, 0x4a, 0x8f, 0xcc, 0x58, 0xd5, 0xe8, 0x5d, 0x86, 0xbc, 0x14, 0xc1, 0xc9, 0x54, 0xf2,
0x34, 0xe5, 0x36, 0x89, 0x96, 0x35, 0xce, 0xa0, 0xe7, 0xc0, 0xdc, 0xb2, 0x9d, 0x3e, 0xd2, 0x72,
0x37, 0xad, 0xaf, 0xda, 0x38, 0x99, 0x06, 0x6b, 0xc7, 0xbe, 0x10, 0xb5, 0x87, 0x4f, 0xa5, 0x7b,
0x54, 0xe1, 0xf6, 0xfa, 0xe1, 0x85, 0xe8, 0xe4, 0xd7, 0x64, 0x13, 0x33, 0xec, 0x94, 0xa0, 0x47,
0x92, 0x47, 0xa5, 0x1a, 0x2b, 0x8d, 0xe6, 0xac, 0xe5, 0x88, 0xe0, 0x06, 0x54, 0xb4, 0x2e, 0x85,
0x2e, 0xd6, 0xc3, 0x2d, 0x16, 0x5d, 0xac, 0x53, 0x5a, 0x1b, 0x38, 0x83, 0xae, 0x41, 0x89, 0x67,
0xbc, 0xe2, 0x6b, 0xc6, 0xe9, 0x74, 0x62, 0xab, 0x25, 0x34, 0x8d, 0x33, 0xd3, 0x17, 0x23, 0x42,
0xdf, 0x85, 0xf2, 0x35, 0xca, 0x54, 0x54, 0x38, 0x95, 0x0e, 0x2b, 0x53, 0x24, 0x95, 0x0c, 0x4d,
0x38, 0x83, 0xde, 0x12, 0xc9, 0x77, 0xd2, 0x29, 0x22, 0x6b, 0x86, 0xf3, 0x8b, 0xee, 0xb5, 0x32,
0x1b, 0x21, 0xa2, 0xfc, 0x66, 0x82, 0xb2, 0x8a, 0x9f, 0xd6, 0x8c, 0x27, 0x18, 0x51, 0xb6, 0xee,
0xf3, 0x3f, 0x05, 0x38, 0x73, 0xf1, 0xed, 0xf0, 0xb3, 0xfa, 0xba, 0xcd, 0x6c, 0xf4, 0x1a, 0x2c,
0x0a, 0x59, 0x46, 0xdf, 0xdd, 0x13, 0x36, 0x7f, 0xe8, 0x23, 0x7f, 0xc2, 0xe6, 0x0f, 0x7f, 0xec,
0xc7, 0x99, 0xf6, 0xdb, 0x1f, 0xdd, 0x6b, 0x66, 0x3e, 0xbe, 0xd7, 0xcc, 0x7c, 0x76, 0xaf, 0x69,
0xfc, 0x70, 0xbf, 0x69, 0xfc, 0x6e, 0xbf, 0x69, 0x7c, 0xb8, 0xdf, 0x34, 0x3e, 0xda, 0x6f, 0x1a,
0xff, 0xda, 0x6f, 0x1a, 0xff, 0xde, 0x6f, 0x66, 0x3e, 0xdb, 0x6f, 0x1a, 0xef, 0x7f, 0xda, 0xcc,
0x7c, 0xf4, 0x69, 0x33, 0xf3, 0xf1, 0xa7, 0xcd, 0xcc, 0xf7, 0x1f, 0xbf, 0x7f, 0xa1, 0x29, 0x1d,
0x5d, 0x41, 0xfc, 0x3c, 0xfd, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf0, 0xfa, 0x1a, 0x95, 0xfc,
0x21, 0x00, 0x00,
}
func (x Direction) String() string {

4
pkg/logproto/logproto.proto
Unescape View File

@ -452,7 +452,7 @@ message DetectedFieldsRequest {
message DetectedFieldsResponse {
repeated DetectedField fields = 1;
uint32 fieldLimit = 2;
uint32 fieldLimit = 2 [(gogoproto.jsontag) = "fieldLimit,omitempty"];
}
// TODO: make the detected field include the serialized sketch
@ -461,7 +461,7 @@ message DetectedField {
string label = 1;
string type = 2 [(gogoproto.casttype) = "DetectedFieldType"];
uint64 cardinality = 3;
bytes sketch = 4 [(gogoproto.jsontag) = "-"]; //serialized hyperloglog sketch
bytes sketch = 4 [(gogoproto.jsontag) = "sketch,omitempty"];
}
message DetectedLabelsRequest {

7
pkg/loki/modules.go
Unescape View File

@ -1087,6 +1087,7 @@ func (t *Loki) initQueryFrontend() (_ services.Service, err error) {
t.Server.HTTP.Path("/loki/api/v1/series").Methods("GET", "POST").Handler(frontendHandler)
t.Server.HTTP.Path("/loki/api/v1/patterns").Methods("GET", "POST").Handler(frontendHandler)
t.Server.HTTP.Path("/loki/api/v1/detected_labels").Methods("GET", "POST").Handler(frontendHandler)
t.Server.HTTP.Path("/loki/api/v1/detected_fields").Methods("GET", "POST").Handler(frontendHandler)
t.Server.HTTP.Path("/loki/api/v1/index/stats").Methods("GET", "POST").Handler(frontendHandler)
t.Server.HTTP.Path("/loki/api/v1/index/shards").Methods("GET", "POST").Handler(frontendHandler)
t.Server.HTTP.Path("/loki/api/v1/index/volume").Methods("GET", "POST").Handler(frontendHandler)
@ -1104,12 +1105,6 @@ func (t *Loki) initQueryFrontend() (_ services.Service, err error) {
t.Server.HTTP.Path("/api/prom/tail").Methods("GET", "POST").Handler(defaultHandler)
}
// We don't marshal the hyperloglog sketch in the detected fields response to JSON, so this endpoint
// only works correctly in V2 with protobuf encoding enabled.
if frontendV2 != nil && frontendV2.IsProtobufEncoded() {
t.Server.HTTP.Path("/loki/api/v1/detected_fields").Methods("GET", "POST").Handler(frontendHandler)
}
if t.frontend == nil {
return services.NewIdleService(nil, func(_ error) error {
if t.stopper != nil {

14
pkg/querier/querier.go
Unescape View File

@ -1018,7 +1018,7 @@ func (q *SingleTenantQuerier) DetectedFields(ctx context.Context, req *logproto.
// TODO(twhitney): converting from a step to a duration should be abstracted and reused,
// doing this in a few places now.
streams, err := streamsForFieldDetection(iters, req.LineLimit, time.Duration(req.Step))
streams, err := streamsForFieldDetection(iters, req.LineLimit)
if err != nil {
return nil, err
}
@ -1186,11 +1186,11 @@ func parseLine(line string) map[string][]string {
return result
}
// readStreams reads the streams from the iterator and returns them sorted.
// streamsForFieldDetection reads the streams from the iterator and returns them sorted.
// If categorizeLabels is true, the stream labels contains just the stream labels and entries inside each stream have their
// structuredMetadata and parsed fields populated with structured metadata labels plus the parsed labels respectively.
// Otherwise, the stream labels are the whole series labels including the stream labels, structured metadata labels and parsed labels.
func streamsForFieldDetection(i iter.EntryIterator, size uint32, interval time.Duration) (logqlmodel.Streams, error) {
func streamsForFieldDetection(i iter.EntryIterator, size uint32) (logqlmodel.Streams, error) {
streams := map[string]*logproto.Stream{}
respSize := uint32(0)
// lastEntry should be a really old time so that the first comparison is always true, we use a negative
@ -1199,14 +1199,12 @@ func streamsForFieldDetection(i iter.EntryIterator, size uint32, interval time.D
for respSize < size && i.Next() {
streamLabels, entry := i.Labels(), i.Entry()
// Always going backward
shouldOutput := entry.Timestamp.Equal(lastEntry.Add(-interval)) ||
entry.Timestamp.Before(lastEntry.Add(-interval))
// Always going backward as the direction for field detection is hard-coded to BACKWARD
shouldOutput := entry.Timestamp.Equal(lastEntry) || entry.Timestamp.Before(lastEntry)
// If step == 0 output every line.
// If lastEntry.Unix < 0 this is the first pass through the loop and we should output the line.
// Then check to see if the entry is equal to, or past a forward step
if interval == 0 || lastEntry.Unix() < 0 || shouldOutput {
if lastEntry.Unix() < 0 || shouldOutput {
stream, ok := streams[streamLabels]
if !ok {
stream = &logproto.Stream{

2
pkg/querier/queryrange/codec.go
Unescape View File

@ -1610,7 +1610,7 @@ func (Codec) MergeResponse(responses ...queryrangebase.Response) (queryrangebase
return &DetectedFieldsResponse{
Response: &logproto.DetectedFieldsResponse{
Fields: mergedFields,
FieldLimit: fieldLimit,
FieldLimit: 0,
},
Headers: headers,
}, nil

65
pkg/querier/queryrange/roundtrip.go
Unescape View File

@ -11,6 +11,7 @@ import (
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/grafana/dskit/httpgrpc"
"github.com/grafana/dskit/tenant"
"github.com/grafana/dskit/user"
"github.com/pkg/errors"
"github.com/prometheus/client_golang/prometheus"
@ -21,12 +22,14 @@ import (
logqllog "github.com/grafana/loki/v3/pkg/logql/log"
"github.com/grafana/loki/v3/pkg/logql/syntax"
"github.com/grafana/loki/v3/pkg/logqlmodel/stats"
"github.com/grafana/loki/v3/pkg/querier/queryrange/queryrangebase"
base "github.com/grafana/loki/v3/pkg/querier/queryrange/queryrangebase"
"github.com/grafana/loki/v3/pkg/storage/chunk/cache"
"github.com/grafana/loki/v3/pkg/storage/config"
"github.com/grafana/loki/v3/pkg/util"
"github.com/grafana/loki/v3/pkg/util/constants"
logutil "github.com/grafana/loki/v3/pkg/util/log"
"github.com/grafana/loki/v3/pkg/util/validation"
)
const (
@ -1132,12 +1135,14 @@ func NewDetectedFieldsTripperware(
return base.MiddlewareFunc(func(next base.Handler) base.Handler {
statsHandler := indexStatsTripperware.Wrap(next)
splitter := newDefaultSplitter(limits, iqo)
queryRangeMiddleware := []base.Middleware{
StatsCollectorMiddleware(),
NewLimitsMiddleware(limits),
NewQuerySizeLimiterMiddleware(schema.Configs, engineOpts, log, limits, statsHandler),
base.InstrumentMiddleware("split_by_interval", metrics.InstrumentMiddlewareMetrics),
SplitByIntervalMiddleware(schema.Configs, limits, merger, newDefaultSplitter(limits, iqo), metrics.SplitByMetrics),
SplitByIntervalMiddleware(schema.Configs, limits, merger, splitter, metrics.SplitByMetrics),
}
// The sharding middleware takes care of enforcing this limit for both shardable and non-shardable queries.
@ -1153,6 +1158,62 @@ func NewDetectedFieldsTripperware(
)
}
return NewLimitedRoundTripper(next, limits, schema.Configs, queryRangeMiddleware...)
limitedRT := NewLimitedRoundTripper(next, limits, schema.Configs, queryRangeMiddleware...)
return NewSketchRemovingHandler(limitedRT, limits, splitter)
}), nil
}
// NewSketchRemovingHandler returns a handler that removes sketches from detected fields responses before
// returning them to the user. We only need sketches internally for calculating cardinality for split queries.
// We're already doing this sanitization in the merge code, so this handler catches non-split queries
// to make sure their sketches are also removed.
func NewSketchRemovingHandler(next queryrangebase.Handler, limits Limits, splitter splitter) queryrangebase.Handler {
return queryrangebase.HandlerFunc(
func(ctx context.Context, req queryrangebase.Request) (queryrangebase.Response, error) {
res, err := next.Do(ctx, req)
if err != nil {
return nil, err
}
resp, ok := res.(*DetectedFieldsResponse)
if !ok {
return res, nil
}
tenantIDs, err := tenant.TenantIDs(ctx)
if err != nil {
return resp, nil
}
interval := validation.SmallestPositiveNonZeroDurationPerTenant(
tenantIDs,
limits.QuerySplitDuration,
)
// sketeches get cleaned up in the merge code, so we only need catch the cases
// where no splitting happened
if interval == 0 {
return removeSketches(resp), nil
}
intervals, err := splitter.split(time.Now().UTC(), tenantIDs, req, interval)
if err != nil || len(intervals) < 2 {
return removeSketches(resp), nil
}
// must have been splits, so sketches are already removed
return resp, nil
},
)
}
// removeSketches removes sketches and field limit from a detected fields response.
// this is only needed for queries that were not split.
func removeSketches(resp *DetectedFieldsResponse) *DetectedFieldsResponse {
for i := range resp.Response.Fields {
resp.Response.Fields[i].Sketch = nil
}
resp.Response.FieldLimit = 0
return resp
}

9
pkg/storage/detected/fields.go
Unescape View File

@ -73,18 +73,11 @@ func MergeFields(
result := make([]*logproto.DetectedField, 0, fieldLimit)
for _, field := range mergedFields {
// TODO(twhitney): what's the performance cost of marshalling here? We technically don't need to marshal in the merge
// but it's nice to keep the response consistent through middlewares in case we need the sketch somewhere else,
// need to benchmark this to find out.
sketch, err := field.Sketch.MarshalBinary()
if err != nil {
return nil, err
}
detectedField := &logproto.DetectedField{
Label: field.Label,
Type: field.Type,
Cardinality: field.Sketch.Estimate(),
Sketch: sketch,
Sketch: nil,
}
result = append(result, detectedField)
}

Write Preview
Loading…
Cancel
Save