From d4a57c43829488e1ee174932edfcade3d7f1f6fe Mon Sep 17 00:00:00 2001 From: Trevor Whitney Date: Mon, 1 Apr 2024 10:19:44 -0600 Subject: [PATCH] feat: parse detected fields in querier --- pkg/loghttp/labels.go | 13 - pkg/loghttp/params.go | 23 ++ pkg/loghttp/query.go | 87 +++++ pkg/logproto/logproto.pb.go | 510 +++++++++++++++++----------- pkg/logproto/logproto.proto | 11 +- pkg/querier/querier.go | 252 +++++++++++++- pkg/querier/queryrange/codec.go | 23 +- pkg/querier/queryrange/roundtrip.go | 2 +- 8 files changed, 680 insertions(+), 241 deletions(-) diff --git a/pkg/loghttp/labels.go b/pkg/loghttp/labels.go index f239873323cfe..8c154c3839fa0 100644 --- a/pkg/loghttp/labels.go +++ b/pkg/loghttp/labels.go @@ -87,16 +87,3 @@ func ParseLabelQuery(r *http.Request) (*logproto.LabelRequest, error) { return req, nil } -func ParseDetectedFieldsQuery(r *http.Request) (*logproto.DetectedFieldsRequest, error) { - req := &logproto.DetectedFieldsRequest{} - - start, end, err := bounds(r) - if err != nil { - return nil, err - } - req.Start = &start - req.End = &end - - req.Query = query(r) - return req, nil -} diff --git a/pkg/loghttp/params.go b/pkg/loghttp/params.go index 74597a1970d4f..0fdbd1226bfa5 100644 --- a/pkg/loghttp/params.go +++ b/pkg/loghttp/params.go @@ -19,6 +19,7 @@ import ( const ( defaultQueryLimit = 100 + defaultFieldLimit = 1000 defaultSince = 1 * time.Hour defaultDirection = logproto.BACKWARD ) @@ -34,6 +35,28 @@ func limit(r *http.Request) (uint32, error) { return uint32(l), nil } +func lineLimit(r *http.Request) (uint32, error) { + l, err := parseInt(r.Form.Get("line_limit"), defaultQueryLimit) + if err != nil { + return 0, err + } + if l <= 0 { + return 0, errors.New("limit must be a positive value") + } + return uint32(l), nil +} + +func fieldLimit(r *http.Request) (uint32, error) { + l, err := parseInt(r.Form.Get("field_limit"), defaultFieldLimit) + if err != nil { + return 0, err + } + if l <= 0 { + return 0, errors.New("limit must be a positive value") + } + return uint32(l), nil +} + func query(r *http.Request) string { return r.Form.Get("query") } diff --git a/pkg/loghttp/query.go b/pkg/loghttp/query.go index 75f75c60ccc03..4107db90fead6 100644 --- a/pkg/loghttp/query.go +++ b/pkg/loghttp/query.go @@ -617,6 +617,93 @@ func ParseVolumeRangeQuery(r *http.Request) (*VolumeRangeQuery, error) { }, nil } +func ParseDetectedFieldsQuery(r *http.Request) (*logproto.DetectedFieldsRequest, error) { + var err error + result := &logproto.DetectedFieldsRequest{} + + result.Query = query(r) + result.Start, result.End, err = bounds(r) + if err != nil { + return nil, err + } + + if result.End.Before(result.Start) { + return nil, errEndBeforeStart + } + + result.LineLimit, err = lineLimit(r) + if err != nil { + return nil, err + } + + result.FieldLimit, err = fieldLimit(r) + if err != nil { + return nil, err + } + + step, err := step(r, result.Start, result.End) + result.Step = step.Milliseconds() + if err != nil { + return nil, err + } + + if result.Step <= 0 { + return nil, errZeroOrNegativeStep + } + + // For safety, limit the number of returned points per timeseries. + // This is sufficient for 60s resolution for a week or 1h resolution for a year. + if (result.End.Sub(result.Start) / step) > 11000 { + return nil, errStepTooSmall + } + return result, nil +} + +// type DetectedFieldsQuery struct { +// Start time.Time +// End time.Time +// Step time.Duration +// Query string +// Limit uint32 +// } + +// func ParseDetectedFieldsQuery(r *http.Request) (*DetectedFieldsQuery, error) { +// var result DetectedFieldsQuery +// var err error + +// result.Query = query(r) +// result.Start, result.End, err = bounds(r) +// if err != nil { +// return nil, err +// } + +// if result.End.Before(result.Start) { +// return nil, errEndBeforeStart +// } + +// result.Limit, err = limit(r) +// if err != nil { +// return nil, err +// } + +// result.Step, err = step(r, result.Start, result.End) +// if err != nil { +// return nil, err +// } + +// if result.Step <= 0 { +// return nil, errZeroOrNegativeStep +// } + +// // For safety, limit the number of returned points per timeseries. +// // This is sufficient for 60s resolution for a week or 1h resolution for a year. +// if (result.End.Sub(result.Start) / result.Step) > 11000 { +// return nil, errStepTooSmall +// } + +// return &result, nil +// } + func targetLabels(r *http.Request) []string { lbls := strings.Split(r.Form.Get("targetLabels"), ",") if (len(lbls) == 1 && lbls[0] == "") || len(lbls) == 0 { diff --git a/pkg/logproto/logproto.pb.go b/pkg/logproto/logproto.pb.go index 2b794a5f899c2..7e7199aab43fb 100644 --- a/pkg/logproto/logproto.pb.go +++ b/pkg/logproto/logproto.pb.go @@ -2513,9 +2513,12 @@ func (m *Volume) GetVolume() uint64 { } type DetectedFieldsRequest struct { - Start *time.Time `protobuf:"bytes,1,opt,name=start,proto3,stdtime" json:"start,omitempty"` - End *time.Time `protobuf:"bytes,2,opt,name=end,proto3,stdtime" json:"end,omitempty"` - Query string `protobuf:"bytes,3,opt,name=query,proto3" json:"query,omitempty"` + Start time.Time `protobuf:"bytes,1,opt,name=start,proto3,stdtime" json:"start"` + End time.Time `protobuf:"bytes,2,opt,name=end,proto3,stdtime" json:"end"` + Query string `protobuf:"bytes,3,opt,name=query,proto3" json:"query,omitempty"` + LineLimit uint32 `protobuf:"varint,4,opt,name=lineLimit,proto3" json:"lineLimit,omitempty"` + FieldLimit uint32 `protobuf:"varint,5,opt,name=fieldLimit,proto3" json:"fieldLimit,omitempty"` + Step int64 `protobuf:"varint,6,opt,name=step,proto3" json:"step,omitempty"` } func (m *DetectedFieldsRequest) Reset() { *m = DetectedFieldsRequest{} } @@ -2550,18 +2553,18 @@ func (m *DetectedFieldsRequest) XXX_DiscardUnknown() { var xxx_messageInfo_DetectedFieldsRequest proto.InternalMessageInfo -func (m *DetectedFieldsRequest) GetStart() *time.Time { +func (m *DetectedFieldsRequest) GetStart() time.Time { if m != nil { return m.Start } - return nil + return time.Time{} } -func (m *DetectedFieldsRequest) GetEnd() *time.Time { +func (m *DetectedFieldsRequest) GetEnd() time.Time { if m != nil { return m.End } - return nil + return time.Time{} } func (m *DetectedFieldsRequest) GetQuery() string { @@ -2571,6 +2574,27 @@ func (m *DetectedFieldsRequest) GetQuery() string { return "" } +func (m *DetectedFieldsRequest) GetLineLimit() uint32 { + if m != nil { + return m.LineLimit + } + return 0 +} + +func (m *DetectedFieldsRequest) GetFieldLimit() uint32 { + if m != nil { + return m.FieldLimit + } + return 0 +} + +func (m *DetectedFieldsRequest) GetStep() int64 { + if m != nil { + return m.Step + } + return 0 +} + type DetectedFieldsResponse struct { Fields []*DetectedField `protobuf:"bytes,1,rep,name=fields,proto3" json:"fields,omitempty"` } @@ -2729,157 +2753,159 @@ func init() { func init() { proto.RegisterFile("pkg/logproto/logproto.proto", fileDescriptor_c28a5f14f1f4c79a) } var fileDescriptor_c28a5f14f1f4c79a = []byte{ - // 2395 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x19, 0x4b, 0x6f, 0x1b, 0xc7, - 0x99, 0x4b, 0x2e, 0x5f, 0x1f, 0x29, 0x59, 0x1e, 0xd1, 0x36, 0xc1, 0xd8, 0xa4, 0x3c, 0x48, 0x1d, - 0xd5, 0x71, 0xc8, 0x58, 0x6e, 0xdc, 0xd4, 0x6e, 0xd0, 0x9a, 0x52, 0xec, 0xc8, 0x96, 0x1f, 0x19, - 0xb9, 0x6e, 0x60, 0xb4, 0x35, 0x56, 0xe4, 0x90, 0x5a, 0x88, 0xdc, 0xa5, 0x77, 0x87, 0xb1, 0x09, - 0xf4, 0xd0, 0x3f, 0x10, 0x34, 0xb7, 0xa2, 0x97, 0xa2, 0x05, 0x0a, 0xa4, 0x40, 0xd1, 0x4b, 0x7f, - 0x40, 0x7b, 0xe9, 0xc1, 0xbd, 0x39, 0xb7, 0x20, 0x07, 0xb6, 0x96, 0x2f, 0x85, 0x4e, 0xb9, 0x15, - 0xe8, 0xa9, 0x98, 0xd7, 0x3e, 0x28, 0xca, 0x0d, 0x55, 0x17, 0x85, 0x2f, 0xdc, 0x99, 0x6f, 0xbe, - 0xf9, 0xe6, 0x7b, 0xcd, 0xf7, 0x18, 0xc2, 0x6b, 0x83, 0x9d, 0x6e, 0xa3, 0xe7, 0x76, 0x07, 0x9e, - 0xcb, 0xdc, 0x60, 0x50, 0x17, 0xbf, 0x28, 0xa7, 0xe7, 0x95, 0x52, 0xd7, 0xed, 0xba, 0x12, 0x87, - 0x8f, 0xe4, 0x7a, 0xa5, 0xd6, 0x75, 0xdd, 0x6e, 0x8f, 0x36, 0xc4, 0x6c, 0x6b, 0xd8, 0x69, 0x30, - 0xbb, 0x4f, 0x7d, 0x66, 0xf5, 0x07, 0x0a, 0x61, 0x49, 0x51, 0x7f, 0xd8, 0xeb, 0xbb, 0x6d, 0xda, - 0x6b, 0xf8, 0xcc, 0x62, 0xbe, 0xfc, 0x55, 0x18, 0x8b, 0x1c, 0x63, 0x30, 0xf4, 0xb7, 0xc5, 0x8f, - 0x04, 0xe2, 0x12, 0xa0, 0x4d, 0xe6, 0x51, 0xab, 0x4f, 0x2c, 0x46, 0x7d, 0x42, 0x1f, 0x0e, 0xa9, - 0xcf, 0xf0, 0x4d, 0x58, 0x8c, 0x41, 0xfd, 0x81, 0xeb, 0xf8, 0x14, 0x5d, 0x84, 0x82, 0x1f, 0x82, - 0xcb, 0xc6, 0x52, 0x6a, 0xb9, 0xb0, 0x52, 0xaa, 0x07, 0xa2, 0x84, 0x7b, 0x48, 0x14, 0x11, 0xff, - 0xca, 0x00, 0x08, 0xd7, 0x50, 0x15, 0x40, 0xae, 0x7e, 0x60, 0xf9, 0xdb, 0x65, 0x63, 0xc9, 0x58, - 0x36, 0x49, 0x04, 0x82, 0xce, 0xc1, 0xd1, 0x70, 0x76, 0xcb, 0xdd, 0xdc, 0xb6, 0xbc, 0x76, 0x39, - 0x29, 0xd0, 0xf6, 0x2f, 0x20, 0x04, 0xa6, 0x67, 0x31, 0x5a, 0x4e, 0x2d, 0x19, 0xcb, 0x29, 0x22, - 0xc6, 0xe8, 0x38, 0x64, 0x18, 0x75, 0x2c, 0x87, 0x95, 0xcd, 0x25, 0x63, 0x39, 0x4f, 0xd4, 0x8c, - 0xc3, 0xb9, 0xec, 0xd4, 0x2f, 0xa7, 0x97, 0x8c, 0xe5, 0x39, 0xa2, 0x66, 0xf8, 0xb3, 0x14, 0x14, - 0x3f, 0x1c, 0x52, 0x6f, 0xa4, 0x14, 0x80, 0xaa, 0x90, 0xf3, 0x69, 0x8f, 0xb6, 0x98, 0xeb, 0x09, - 0x06, 0xf3, 0xcd, 0x64, 0xd9, 0x20, 0x01, 0x0c, 0x95, 0x20, 0xdd, 0xb3, 0xfb, 0x36, 0x13, 0x6c, - 0xcd, 0x11, 0x39, 0x41, 0x97, 0x20, 0xed, 0x33, 0xcb, 0x63, 0x82, 0x97, 0xc2, 0x4a, 0xa5, 0x2e, - 0x8d, 0x56, 0xd7, 0x46, 0xab, 0xdf, 0xd5, 0x46, 0x6b, 0xe6, 0x9e, 0x8c, 0x6b, 0x89, 0x4f, 0xff, - 0x56, 0x33, 0x88, 0xdc, 0x82, 0x2e, 0x42, 0x8a, 0x3a, 0x6d, 0xc1, 0xef, 0xd7, 0xdd, 0xc9, 0x37, - 0xa0, 0xf3, 0x90, 0x6f, 0xdb, 0x1e, 0x6d, 0x31, 0xdb, 0x75, 0x84, 0x54, 0xf3, 0x2b, 0x8b, 0xa1, - 0x45, 0xd6, 0xf4, 0x12, 0x09, 0xb1, 0xd0, 0x39, 0xc8, 0xf8, 0x5c, 0x75, 0x7e, 0x39, 0xbb, 0x94, - 0x5a, 0xce, 0x37, 0x4b, 0x7b, 0xe3, 0xda, 0x82, 0x84, 0x9c, 0x73, 0xfb, 0x36, 0xa3, 0xfd, 0x01, - 0x1b, 0x11, 0x85, 0x83, 0xce, 0x42, 0xb6, 0x4d, 0x7b, 0x94, 0x1b, 0x3c, 0x27, 0x0c, 0xbe, 0x10, - 0x21, 0x2f, 0x16, 0x88, 0x46, 0x40, 0xf7, 0xc1, 0x1c, 0xf4, 0x2c, 0xa7, 0x9c, 0x17, 0x52, 0xcc, - 0x87, 0x88, 0x77, 0x7a, 0x96, 0xd3, 0xbc, 0xf8, 0xe5, 0xb8, 0xb6, 0xd2, 0xb5, 0xd9, 0xf6, 0x70, - 0xab, 0xde, 0x72, 0xfb, 0x8d, 0xae, 0x67, 0x75, 0x2c, 0xc7, 0x6a, 0xf4, 0xdc, 0x1d, 0xbb, 0xc1, - 0x9d, 0xf3, 0xe1, 0x90, 0x7a, 0x36, 0xf5, 0x1a, 0x9c, 0x46, 0x5d, 0xd8, 0x83, 0xef, 0x23, 0x82, - 0xe6, 0x75, 0x33, 0x97, 0x59, 0xc8, 0xe2, 0x71, 0x12, 0xd0, 0xa6, 0xd5, 0x1f, 0xf4, 0xe8, 0x4c, - 0xf6, 0x0a, 0x2c, 0x93, 0x3c, 0xb4, 0x65, 0x52, 0xb3, 0x5a, 0x26, 0x54, 0xb3, 0x39, 0x9b, 0x9a, - 0xd3, 0x5f, 0x57, 0xcd, 0x99, 0x97, 0xaf, 0x66, 0x5c, 0x06, 0x93, 0xcf, 0xd0, 0x02, 0xa4, 0x3c, - 0xeb, 0x91, 0x50, 0x66, 0x91, 0xf0, 0x21, 0xde, 0x80, 0x8c, 0x64, 0x04, 0x55, 0x26, 0xb5, 0x1d, - 0xbf, 0x19, 0xa1, 0xa6, 0x53, 0x5a, 0x87, 0x0b, 0xa1, 0x0e, 0x53, 0x42, 0x3b, 0xf8, 0xd7, 0x06, - 0xcc, 0x29, 0x13, 0xaa, 0xe8, 0xb2, 0x05, 0x59, 0x79, 0xbb, 0x75, 0x64, 0x39, 0x31, 0x19, 0x59, - 0xae, 0xb4, 0xad, 0x01, 0xa3, 0x5e, 0xb3, 0xf1, 0x64, 0x5c, 0x33, 0xbe, 0x1c, 0xd7, 0xde, 0x78, - 0x91, 0x94, 0x22, 0xc8, 0xa9, 0xa8, 0xa3, 0x09, 0xa3, 0x37, 0x05, 0x77, 0xcc, 0x57, 0x7e, 0x70, - 0xa4, 0x2e, 0x03, 0xe4, 0xba, 0xd3, 0xa5, 0x3e, 0xa7, 0x6c, 0x72, 0x13, 0x12, 0x89, 0x83, 0x7f, - 0x0a, 0x8b, 0x31, 0x57, 0x53, 0x7c, 0xbe, 0x0b, 0x19, 0x9f, 0x2b, 0x50, 0xb3, 0x19, 0x31, 0xd4, - 0xa6, 0x80, 0x37, 0xe7, 0x15, 0x7f, 0x19, 0x39, 0x27, 0x0a, 0x7f, 0xb6, 0xd3, 0xff, 0x62, 0x40, - 0x71, 0xc3, 0xda, 0xa2, 0x3d, 0xed, 0xe3, 0x08, 0x4c, 0xc7, 0xea, 0x53, 0xa5, 0x71, 0x31, 0xe6, - 0x01, 0xed, 0x63, 0xab, 0x37, 0xa4, 0x92, 0x64, 0x8e, 0xa8, 0xd9, 0xac, 0x91, 0xc8, 0x38, 0x74, - 0x24, 0x32, 0x42, 0x7f, 0x2f, 0x41, 0x9a, 0x7b, 0xd6, 0x48, 0x44, 0xa1, 0x3c, 0x91, 0x13, 0xfc, - 0x06, 0xcc, 0x29, 0x29, 0x94, 0xfa, 0x42, 0x96, 0xb9, 0xfa, 0xf2, 0x9a, 0x65, 0xdc, 0x87, 0x8c, - 0xd4, 0x36, 0x7a, 0x1d, 0xf2, 0x41, 0x76, 0x13, 0xd2, 0xa6, 0x9a, 0x99, 0xbd, 0x71, 0x2d, 0xc9, - 0x7c, 0x12, 0x2e, 0xa0, 0x1a, 0xa4, 0xc5, 0x4e, 0x21, 0xb9, 0xd1, 0xcc, 0xef, 0x8d, 0x6b, 0x12, - 0x40, 0xe4, 0x07, 0x9d, 0x04, 0x73, 0x9b, 0x27, 0x18, 0xae, 0x02, 0xb3, 0x99, 0xdb, 0x1b, 0xd7, - 0xc4, 0x9c, 0x88, 0x5f, 0x7c, 0x0d, 0x8a, 0x1b, 0xb4, 0x6b, 0xb5, 0x46, 0xea, 0xd0, 0x92, 0x26, - 0xc7, 0x0f, 0x34, 0x34, 0x8d, 0xd3, 0x50, 0x0c, 0x4e, 0x7c, 0xd0, 0xf7, 0x95, 0x53, 0x17, 0x02, - 0xd8, 0x4d, 0x1f, 0xff, 0xd2, 0x00, 0x65, 0x67, 0x84, 0x21, 0xd3, 0xe3, 0xb2, 0xfa, 0x2a, 0x06, - 0xc1, 0xde, 0xb8, 0xa6, 0x20, 0x44, 0x7d, 0xd1, 0x65, 0xc8, 0xfa, 0xe2, 0x44, 0x4e, 0x6c, 0xd2, - 0x7d, 0xc4, 0x42, 0xf3, 0x08, 0x77, 0x83, 0xbd, 0x71, 0x4d, 0x23, 0x12, 0x3d, 0x40, 0xf5, 0x58, - 0xe6, 0x94, 0x82, 0xcd, 0xef, 0x8d, 0x6b, 0x11, 0x68, 0x34, 0x93, 0xe2, 0x7f, 0x1a, 0x50, 0xb8, - 0x6b, 0xd9, 0x81, 0x0b, 0x95, 0xb5, 0x89, 0xc2, 0x18, 0x29, 0x01, 0xfc, 0x4a, 0xb7, 0x69, 0xcf, - 0x1a, 0x5d, 0x75, 0x3d, 0x41, 0x77, 0x8e, 0x04, 0xf3, 0x30, 0xd9, 0x99, 0x53, 0x93, 0x5d, 0x7a, - 0xf6, 0x90, 0xfa, 0x3f, 0x0c, 0x60, 0xd7, 0xcd, 0x5c, 0x72, 0x21, 0x85, 0xff, 0x60, 0x40, 0x51, - 0x4a, 0xae, 0xdc, 0xee, 0x47, 0x90, 0x91, 0x8a, 0x11, 0xb2, 0xbf, 0x20, 0xb8, 0xbc, 0x39, 0x4b, - 0x60, 0x51, 0x34, 0xd1, 0xf7, 0x60, 0xbe, 0xed, 0xb9, 0x83, 0x01, 0x6d, 0x6f, 0xaa, 0x10, 0x96, - 0x9c, 0x0c, 0x61, 0x6b, 0xd1, 0x75, 0x32, 0x81, 0x8e, 0xff, 0x6a, 0xc0, 0x9c, 0x8a, 0x16, 0xca, - 0x56, 0x81, 0x7e, 0x8d, 0x43, 0xa7, 0xac, 0xe4, 0xac, 0x29, 0xeb, 0x38, 0x64, 0xba, 0x9e, 0x3b, - 0x1c, 0xf8, 0xe5, 0x94, 0xbc, 0x9b, 0x72, 0x36, 0x5b, 0x2a, 0xc3, 0xd7, 0x61, 0x5e, 0x8b, 0x72, - 0x40, 0xc8, 0xac, 0x4c, 0x86, 0xcc, 0xf5, 0x36, 0x75, 0x98, 0xdd, 0xb1, 0x83, 0x20, 0xa8, 0xf0, - 0xf1, 0xcf, 0x0d, 0x58, 0x98, 0x44, 0x41, 0x6b, 0x91, 0x7b, 0xc6, 0xc9, 0x9d, 0x39, 0x98, 0x5c, - 0x5d, 0x04, 0x1f, 0xff, 0x7d, 0x87, 0x79, 0x23, 0x4d, 0x5a, 0xee, 0xad, 0xbc, 0x03, 0x85, 0xc8, - 0x22, 0x4f, 0x51, 0x3b, 0x54, 0xdd, 0x0c, 0xc2, 0x87, 0x61, 0x48, 0x48, 0xca, 0x80, 0x26, 0x26, - 0xf8, 0x17, 0x06, 0xcc, 0xc5, 0x6c, 0x89, 0xde, 0x05, 0xb3, 0xe3, 0xb9, 0xfd, 0x99, 0x0c, 0x25, - 0x76, 0xa0, 0x6f, 0x41, 0x92, 0xb9, 0x33, 0x99, 0x29, 0xc9, 0x5c, 0x6e, 0x25, 0x25, 0x7e, 0x4a, - 0x56, 0xb7, 0x72, 0x86, 0xdf, 0x81, 0xbc, 0x10, 0xe8, 0x8e, 0x65, 0x7b, 0x53, 0xb3, 0xc5, 0x74, - 0x81, 0x2e, 0xc3, 0x11, 0x19, 0x09, 0xa7, 0x6f, 0x2e, 0x4e, 0xdb, 0x5c, 0xd4, 0x9b, 0x5f, 0x83, - 0xf4, 0xea, 0xf6, 0xd0, 0xd9, 0xe1, 0x5b, 0xda, 0x16, 0xb3, 0xf4, 0x16, 0x3e, 0xc6, 0xc7, 0x60, - 0x91, 0xdf, 0x41, 0xea, 0xf9, 0xab, 0xee, 0xd0, 0x61, 0xba, 0xbb, 0x38, 0x07, 0xa5, 0x38, 0x58, - 0x79, 0x49, 0x09, 0xd2, 0x2d, 0x0e, 0x10, 0x34, 0xe6, 0x88, 0x9c, 0xe0, 0xdf, 0x1a, 0x80, 0xae, - 0x51, 0x26, 0x4e, 0x59, 0x5f, 0x0b, 0xae, 0x47, 0x05, 0x72, 0x7d, 0x8b, 0xb5, 0xb6, 0xa9, 0xe7, - 0xeb, 0x1a, 0x44, 0xcf, 0xff, 0x1f, 0xd5, 0x1e, 0x3e, 0x0f, 0x8b, 0x31, 0x2e, 0x95, 0x4c, 0x15, - 0xc8, 0xb5, 0x14, 0x4c, 0xe5, 0xbb, 0x60, 0x8e, 0xff, 0x98, 0x84, 0x9c, 0xd8, 0x40, 0x68, 0x07, - 0x9d, 0x87, 0x42, 0xc7, 0x76, 0xba, 0xd4, 0x1b, 0x78, 0xb6, 0x52, 0x81, 0xd9, 0x3c, 0xb2, 0x37, - 0xae, 0x45, 0xc1, 0x24, 0x3a, 0x41, 0x6f, 0x41, 0x76, 0xe8, 0x53, 0xef, 0x81, 0x2d, 0x6f, 0x7a, - 0xbe, 0x59, 0xda, 0x1d, 0xd7, 0x32, 0x3f, 0xf0, 0xa9, 0xb7, 0xbe, 0xc6, 0x33, 0xcf, 0x50, 0x8c, - 0x88, 0xfc, 0xb6, 0xd1, 0x0d, 0xe5, 0xa6, 0xa2, 0x08, 0x6b, 0x7e, 0x9b, 0xb3, 0x3f, 0x11, 0xea, - 0x06, 0x9e, 0xdb, 0xa7, 0x6c, 0x9b, 0x0e, 0xfd, 0x46, 0xcb, 0xed, 0xf7, 0x5d, 0xa7, 0x21, 0x7a, - 0x49, 0x21, 0x34, 0x4f, 0x9f, 0x7c, 0xbb, 0xf2, 0xdc, 0xbb, 0x90, 0x65, 0xdb, 0x9e, 0x3b, 0xec, - 0x6e, 0x8b, 0xac, 0x90, 0x6a, 0x5e, 0x9a, 0x9d, 0x9e, 0xa6, 0x40, 0xf4, 0x00, 0x9d, 0xe6, 0xda, - 0xa2, 0xad, 0x1d, 0x7f, 0xd8, 0x97, 0x1d, 0x5a, 0x33, 0xbd, 0x37, 0xae, 0x19, 0x6f, 0x91, 0x00, - 0x8c, 0x3f, 0x49, 0x42, 0x4d, 0x38, 0xea, 0x3d, 0x51, 0x36, 0x5c, 0x75, 0xbd, 0x9b, 0x94, 0x79, - 0x76, 0xeb, 0x96, 0xd5, 0xa7, 0xda, 0x37, 0x6a, 0x50, 0xe8, 0x0b, 0xe0, 0x83, 0xc8, 0x15, 0x80, - 0x7e, 0x80, 0x87, 0x4e, 0x01, 0x88, 0x3b, 0x23, 0xd7, 0xe5, 0x6d, 0xc8, 0x0b, 0x88, 0x58, 0x5e, - 0x8d, 0x69, 0xaa, 0x31, 0xa3, 0x64, 0x4a, 0x43, 0xeb, 0x93, 0x1a, 0x9a, 0x99, 0x4e, 0xa0, 0x96, - 0xa8, 0xaf, 0xa7, 0xe3, 0xbe, 0x8e, 0x3f, 0x37, 0xa0, 0xba, 0xa1, 0x39, 0x3f, 0xa4, 0x3a, 0xb4, - 0xbc, 0xc9, 0x97, 0x24, 0x6f, 0xea, 0xbf, 0x93, 0x17, 0x57, 0x01, 0x36, 0x6c, 0x87, 0x5e, 0xb5, - 0x7b, 0x8c, 0x7a, 0x53, 0x3a, 0x91, 0x4f, 0x52, 0x61, 0x48, 0x20, 0xb4, 0xa3, 0xe5, 0x5c, 0x8d, - 0xc4, 0xe1, 0x97, 0x21, 0x46, 0xf2, 0x25, 0x9a, 0x2d, 0x35, 0x11, 0xa2, 0x76, 0x20, 0xdb, 0x11, - 0xe2, 0xc9, 0x94, 0x1a, 0x7b, 0x46, 0x09, 0x65, 0x6f, 0x5e, 0x56, 0x87, 0x5f, 0x78, 0x51, 0x41, - 0x22, 0x5e, 0x7d, 0x1a, 0xfe, 0xc8, 0x61, 0xd6, 0xe3, 0xc8, 0x66, 0xa2, 0x4f, 0x40, 0x3f, 0x51, - 0xe5, 0x56, 0x7a, 0x6a, 0xb9, 0xa5, 0x6f, 0xee, 0xe1, 0x7b, 0xc6, 0xf7, 0xc2, 0xd8, 0x27, 0xcc, - 0xa1, 0x62, 0xdf, 0x19, 0x30, 0x3d, 0xda, 0xd1, 0x49, 0x1a, 0x85, 0xc7, 0x06, 0x98, 0x62, 0x1d, - 0xff, 0xc9, 0x80, 0x85, 0x6b, 0x94, 0xc5, 0xcb, 0x9f, 0x57, 0xc8, 0x98, 0xf8, 0x03, 0x38, 0x1a, - 0xe1, 0x5f, 0x49, 0x7f, 0x61, 0xa2, 0xe6, 0x39, 0x16, 0xca, 0xbf, 0xee, 0xb4, 0xe9, 0x63, 0xd5, - 0x2b, 0xc6, 0xcb, 0x9d, 0x3b, 0x50, 0x88, 0x2c, 0xa2, 0x2b, 0x13, 0x85, 0x4e, 0xe4, 0x65, 0x27, - 0x48, 0xd6, 0xcd, 0x92, 0x92, 0x49, 0x76, 0x8b, 0xaa, 0x8c, 0x0d, 0x8a, 0x82, 0x4d, 0x40, 0xc2, - 0x5c, 0x82, 0x6c, 0x34, 0x2d, 0x09, 0xe8, 0x8d, 0xa0, 0xe2, 0x09, 0xe6, 0xe8, 0x34, 0x98, 0x9e, - 0xfb, 0x48, 0x57, 0xb0, 0x73, 0xe1, 0x91, 0xc4, 0x7d, 0x44, 0xc4, 0x12, 0xbe, 0x0c, 0x29, 0xe2, - 0x3e, 0x42, 0x55, 0x00, 0xcf, 0x72, 0xba, 0xf4, 0x5e, 0xd0, 0x38, 0x15, 0x49, 0x04, 0x72, 0x40, - 0xc9, 0xb0, 0x0a, 0x47, 0xa3, 0x1c, 0x49, 0x73, 0xd7, 0x21, 0xfb, 0xe1, 0x30, 0xaa, 0xae, 0xd2, - 0x84, 0xba, 0x64, 0x0f, 0xae, 0x91, 0xb8, 0xcf, 0x40, 0x08, 0x47, 0x27, 0x21, 0xcf, 0xac, 0xad, - 0x1e, 0xbd, 0x15, 0x06, 0xb8, 0x10, 0xc0, 0x57, 0x79, 0xcf, 0x77, 0x2f, 0x52, 0xfb, 0x84, 0x00, - 0x74, 0x16, 0x16, 0x42, 0x9e, 0xef, 0x78, 0xb4, 0x63, 0x3f, 0x16, 0x16, 0x2e, 0x92, 0x7d, 0x70, - 0xb4, 0x0c, 0x47, 0x42, 0xd8, 0xa6, 0xa8, 0x31, 0x4c, 0x81, 0x3a, 0x09, 0xe6, 0xba, 0x11, 0xe2, - 0xbe, 0xff, 0x70, 0x68, 0xf5, 0xc4, 0xcd, 0x2b, 0x92, 0x08, 0x04, 0xff, 0xd9, 0x80, 0xa3, 0xd2, - 0xd4, 0xbc, 0xdb, 0x7f, 0x15, 0xbd, 0xfe, 0x33, 0x03, 0x50, 0x54, 0x02, 0xe5, 0x5a, 0xdf, 0x88, - 0x3e, 0xe3, 0xf0, 0x22, 0xa6, 0x20, 0x5a, 0x59, 0x09, 0x0a, 0x5f, 0x62, 0x30, 0x64, 0x44, 0x21, - 0x24, 0x7b, 0x6a, 0x53, 0xf6, 0xca, 0x12, 0x42, 0xd4, 0x97, 0xb7, 0xf8, 0x5b, 0x23, 0x46, 0x7d, - 0xd5, 0xe9, 0x8a, 0x16, 0x5f, 0x00, 0x88, 0xfc, 0xf0, 0xb3, 0xa8, 0xc3, 0x84, 0xd7, 0x98, 0xe1, - 0x59, 0x0a, 0x44, 0xf4, 0x00, 0xff, 0x3e, 0x09, 0x73, 0xf7, 0xdc, 0xde, 0x30, 0x4c, 0x89, 0xaf, - 0x52, 0xaa, 0x88, 0xb5, 0xdf, 0x69, 0xdd, 0x7e, 0x23, 0x30, 0x7d, 0x46, 0x07, 0xc2, 0xb3, 0x52, - 0x44, 0x8c, 0x11, 0x86, 0x22, 0xb3, 0xbc, 0x2e, 0x65, 0xb2, 0xaf, 0x29, 0x67, 0x44, 0xc1, 0x19, - 0x83, 0xa1, 0x25, 0x28, 0x58, 0xdd, 0xae, 0x47, 0xbb, 0x16, 0xa3, 0xcd, 0x51, 0x39, 0x2b, 0x0e, - 0x8b, 0x82, 0xf0, 0x47, 0x30, 0xaf, 0x95, 0xa5, 0x4c, 0xfa, 0x36, 0x64, 0x3f, 0x16, 0x90, 0x29, - 0x4f, 0x5e, 0x12, 0x55, 0x85, 0x31, 0x8d, 0x16, 0x7f, 0x1f, 0xd7, 0x3c, 0xe3, 0xeb, 0x90, 0x91, - 0xe8, 0xe8, 0x64, 0xb4, 0x3b, 0x91, 0x6f, 0x33, 0x7c, 0xae, 0x5a, 0x0d, 0x0c, 0x19, 0x49, 0x48, - 0x19, 0x5e, 0xf8, 0x86, 0x84, 0x10, 0xf5, 0xc5, 0xbf, 0x31, 0xe0, 0xd8, 0x1a, 0x65, 0xb4, 0xc5, - 0x68, 0xfb, 0xaa, 0x4d, 0x7b, 0xed, 0xc3, 0x36, 0xce, 0xc6, 0xa1, 0x1b, 0xe7, 0x69, 0x6f, 0x5f, - 0xa9, 0xe8, 0xdb, 0xd7, 0x3a, 0x1c, 0x9f, 0x64, 0x51, 0x69, 0xb4, 0x01, 0x99, 0x8e, 0x80, 0xec, - 0x7f, 0xea, 0x8c, 0xed, 0x20, 0x0a, 0x0d, 0x7b, 0x30, 0x17, 0x5b, 0x10, 0x1a, 0xe6, 0x16, 0x55, - 0xd1, 0x4e, 0x4e, 0xd0, 0x37, 0xc1, 0x64, 0xa3, 0x81, 0x0a, 0x72, 0xcd, 0x63, 0xff, 0x1a, 0xd7, - 0x8e, 0xc6, 0xb6, 0xdd, 0x1d, 0x0d, 0x28, 0x11, 0x28, 0xdc, 0x11, 0x5a, 0x96, 0xd7, 0xb6, 0x1d, - 0xab, 0x67, 0x33, 0xc9, 0xb8, 0x49, 0xa2, 0xa0, 0xb3, 0x67, 0x20, 0x1f, 0xfc, 0x7f, 0x80, 0x0a, - 0x90, 0xbd, 0x7a, 0x9b, 0xfc, 0xf0, 0x0a, 0x59, 0x5b, 0x48, 0xa0, 0x22, 0xe4, 0x9a, 0x57, 0x56, - 0x6f, 0x88, 0x99, 0xb1, 0xf2, 0x79, 0x5a, 0x07, 0x6f, 0x0f, 0x7d, 0x17, 0xd2, 0x32, 0x22, 0x1f, - 0x0f, 0x25, 0x8a, 0xbe, 0xd4, 0x57, 0x4e, 0xec, 0x83, 0x4b, 0x95, 0xe0, 0xc4, 0xdb, 0x06, 0xba, - 0x05, 0x05, 0x01, 0x54, 0x6f, 0x72, 0x27, 0x27, 0x9f, 0xc6, 0x62, 0x94, 0x4e, 0x1d, 0xb0, 0x1a, - 0xa1, 0x77, 0x09, 0xd2, 0xc2, 0xed, 0xa3, 0xdc, 0x44, 0xdf, 0x54, 0xa3, 0xdc, 0xc4, 0x5e, 0x29, - 0x71, 0x02, 0x7d, 0x07, 0x4c, 0xde, 0xa5, 0xa2, 0x48, 0xde, 0x8e, 0x3c, 0xa5, 0x55, 0x8e, 0x4f, - 0x82, 0x23, 0xc7, 0xbe, 0x17, 0xbc, 0x08, 0x9e, 0x98, 0x7c, 0x99, 0xd0, 0xdb, 0xcb, 0xfb, 0x17, - 0x82, 0x93, 0x6f, 0xcb, 0xa7, 0x2b, 0xdd, 0x1f, 0xa3, 0x53, 0xf1, 0xa3, 0x26, 0xda, 0xe9, 0x4a, - 0xf5, 0xa0, 0xe5, 0x80, 0xe0, 0x06, 0x14, 0x22, 0xbd, 0x69, 0x54, 0xad, 0xfb, 0x1b, 0xeb, 0xa8, - 0x5a, 0xa7, 0x34, 0xb4, 0x38, 0x81, 0xae, 0x41, 0x8e, 0x57, 0x3b, 0x3c, 0xe8, 0xa3, 0xd7, 0x26, - 0x8b, 0x9a, 0x48, 0x32, 0xab, 0x9c, 0x9c, 0xbe, 0x18, 0x10, 0xfa, 0x3e, 0xe4, 0xaf, 0x51, 0xa6, - 0x22, 0xc2, 0x89, 0xc9, 0x90, 0x32, 0x45, 0x53, 0xf1, 0xb0, 0x84, 0x13, 0xe8, 0x23, 0x51, 0x78, - 0xc5, 0xef, 0x18, 0xaa, 0x1d, 0x70, 0x97, 0x02, 0xbe, 0x96, 0x0e, 0x46, 0xd0, 0x94, 0x57, 0x7e, - 0xac, 0xff, 0xb1, 0x5c, 0xb3, 0x98, 0x85, 0x6e, 0xc3, 0xbc, 0x10, 0x39, 0xf8, 0x4b, 0x33, 0xe6, - 0x9a, 0xfb, 0xfe, 0x3f, 0x8d, 0xb9, 0xe6, 0xfe, 0xff, 0x51, 0x71, 0xa2, 0x79, 0xff, 0xe9, 0xb3, - 0x6a, 0xe2, 0x8b, 0x67, 0xd5, 0xc4, 0x57, 0xcf, 0xaa, 0xc6, 0xcf, 0x76, 0xab, 0xc6, 0xef, 0x76, - 0xab, 0xc6, 0x93, 0xdd, 0xaa, 0xf1, 0x74, 0xb7, 0x6a, 0xfc, 0x7d, 0xb7, 0x6a, 0xfc, 0x63, 0xb7, - 0x9a, 0xf8, 0x6a, 0xb7, 0x6a, 0x7c, 0xfa, 0xbc, 0x9a, 0x78, 0xfa, 0xbc, 0x9a, 0xf8, 0xe2, 0x79, - 0x35, 0x71, 0xff, 0xf5, 0xff, 0xd0, 0x05, 0xc8, 0x38, 0x95, 0x11, 0x9f, 0x0b, 0xff, 0x0e, 0x00, - 0x00, 0xff, 0xff, 0x46, 0xc6, 0x73, 0x88, 0x70, 0x1e, 0x00, 0x00, + // 2421 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x19, 0x4d, 0x6f, 0x1b, 0xc7, + 0x95, 0x4b, 0x2e, 0xbf, 0x1e, 0x29, 0x59, 0x1e, 0xd1, 0x36, 0x41, 0xdb, 0xa4, 0x3c, 0x48, 0x1d, + 0xd5, 0x71, 0xc4, 0x58, 0x6e, 0xdc, 0xd4, 0x6e, 0xd0, 0x9a, 0x52, 0xec, 0xc8, 0x96, 0x3f, 0x32, + 0x72, 0xdd, 0xc0, 0x68, 0x6b, 0xac, 0xc8, 0x11, 0xb5, 0xd0, 0x72, 0x97, 0xde, 0x1d, 0xc6, 0x26, + 0xd0, 0x43, 0xff, 0x40, 0xd0, 0xdc, 0x8a, 0x5e, 0x8a, 0x1e, 0x0a, 0xa4, 0x40, 0xd1, 0x4b, 0x7f, + 0x40, 0x7b, 0xe9, 0xc1, 0xbd, 0x39, 0xb7, 0x20, 0x07, 0xb6, 0x96, 0x2f, 0x85, 0x4e, 0x01, 0x7a, + 0x28, 0xd0, 0x53, 0x31, 0x1f, 0xbb, 0x3b, 0x4b, 0x51, 0x6e, 0xe8, 0x3a, 0x08, 0x7c, 0xe1, 0xce, + 0x7b, 0xf3, 0xe6, 0xcd, 0xbc, 0x8f, 0x79, 0x1f, 0x43, 0x38, 0xde, 0xdf, 0xe9, 0x36, 0x1d, 0xaf, + 0xdb, 0xf7, 0x3d, 0xe6, 0x45, 0x83, 0x25, 0xf1, 0x8b, 0x0a, 0x21, 0x5c, 0xab, 0x74, 0xbd, 0xae, + 0x27, 0x69, 0xf8, 0x48, 0xce, 0xd7, 0x1a, 0x5d, 0xcf, 0xeb, 0x3a, 0xb4, 0x29, 0xa0, 0xcd, 0xc1, + 0x56, 0x93, 0xd9, 0x3d, 0x1a, 0x30, 0xab, 0xd7, 0x57, 0x04, 0x0b, 0x8a, 0xfb, 0x03, 0xa7, 0xe7, + 0x75, 0xa8, 0xd3, 0x0c, 0x98, 0xc5, 0x02, 0xf9, 0xab, 0x28, 0xe6, 0x39, 0x45, 0x7f, 0x10, 0x6c, + 0x8b, 0x1f, 0x89, 0xc4, 0x15, 0x40, 0x1b, 0xcc, 0xa7, 0x56, 0x8f, 0x58, 0x8c, 0x06, 0x84, 0x3e, + 0x18, 0xd0, 0x80, 0xe1, 0x1b, 0x30, 0x9f, 0xc0, 0x06, 0x7d, 0xcf, 0x0d, 0x28, 0xba, 0x00, 0xa5, + 0x20, 0x46, 0x57, 0x8d, 0x85, 0xcc, 0x62, 0x69, 0xb9, 0xb2, 0x14, 0x89, 0x12, 0xaf, 0x21, 0x3a, + 0x21, 0xfe, 0x8d, 0x01, 0x10, 0xcf, 0xa1, 0x3a, 0x80, 0x9c, 0x7d, 0xdf, 0x0a, 0xb6, 0xab, 0xc6, + 0x82, 0xb1, 0x68, 0x12, 0x0d, 0x83, 0xce, 0xc2, 0xe1, 0x18, 0xba, 0xe9, 0x6d, 0x6c, 0x5b, 0x7e, + 0xa7, 0x9a, 0x16, 0x64, 0xfb, 0x27, 0x10, 0x02, 0xd3, 0xb7, 0x18, 0xad, 0x66, 0x16, 0x8c, 0xc5, + 0x0c, 0x11, 0x63, 0x74, 0x14, 0x72, 0x8c, 0xba, 0x96, 0xcb, 0xaa, 0xe6, 0x82, 0xb1, 0x58, 0x24, + 0x0a, 0xe2, 0x78, 0x2e, 0x3b, 0x0d, 0xaa, 0xd9, 0x05, 0x63, 0x71, 0x86, 0x28, 0x08, 0x7f, 0x9a, + 0x81, 0xf2, 0x07, 0x03, 0xea, 0x0f, 0x95, 0x02, 0x50, 0x1d, 0x0a, 0x01, 0x75, 0x68, 0x9b, 0x79, + 0xbe, 0x38, 0x60, 0xb1, 0x95, 0xae, 0x1a, 0x24, 0xc2, 0xa1, 0x0a, 0x64, 0x1d, 0xbb, 0x67, 0x33, + 0x71, 0xac, 0x19, 0x22, 0x01, 0x74, 0x11, 0xb2, 0x01, 0xb3, 0x7c, 0x26, 0xce, 0x52, 0x5a, 0xae, + 0x2d, 0x49, 0xa3, 0x2d, 0x85, 0x46, 0x5b, 0xba, 0x13, 0x1a, 0xad, 0x55, 0x78, 0x3c, 0x6a, 0xa4, + 0x3e, 0xf9, 0x7b, 0xc3, 0x20, 0x72, 0x09, 0xba, 0x00, 0x19, 0xea, 0x76, 0xc4, 0x79, 0xbf, 0xea, + 0x4a, 0xbe, 0x00, 0x9d, 0x83, 0x62, 0xc7, 0xf6, 0x69, 0x9b, 0xd9, 0x9e, 0x2b, 0xa4, 0x9a, 0x5d, + 0x9e, 0x8f, 0x2d, 0xb2, 0x1a, 0x4e, 0x91, 0x98, 0x0a, 0x9d, 0x85, 0x5c, 0xc0, 0x55, 0x17, 0x54, + 0xf3, 0x0b, 0x99, 0xc5, 0x62, 0xab, 0xb2, 0x37, 0x6a, 0xcc, 0x49, 0xcc, 0x59, 0xaf, 0x67, 0x33, + 0xda, 0xeb, 0xb3, 0x21, 0x51, 0x34, 0xe8, 0x0c, 0xe4, 0x3b, 0xd4, 0xa1, 0xdc, 0xe0, 0x05, 0x61, + 0xf0, 0x39, 0x8d, 0xbd, 0x98, 0x20, 0x21, 0x01, 0xba, 0x07, 0x66, 0xdf, 0xb1, 0xdc, 0x6a, 0x51, + 0x48, 0x31, 0x1b, 0x13, 0xde, 0x76, 0x2c, 0xb7, 0x75, 0xe1, 0x8b, 0x51, 0x63, 0xb9, 0x6b, 0xb3, + 0xed, 0xc1, 0xe6, 0x52, 0xdb, 0xeb, 0x35, 0xbb, 0xbe, 0xb5, 0x65, 0xb9, 0x56, 0xd3, 0xf1, 0x76, + 0xec, 0x26, 0x77, 0xce, 0x07, 0x03, 0xea, 0xdb, 0xd4, 0x6f, 0x72, 0x1e, 0x4b, 0xc2, 0x1e, 0x7c, + 0x1d, 0x11, 0x3c, 0xaf, 0x99, 0x85, 0xdc, 0x5c, 0x1e, 0x8f, 0xd2, 0x80, 0x36, 0xac, 0x5e, 0xdf, + 0xa1, 0x53, 0xd9, 0x2b, 0xb2, 0x4c, 0xfa, 0x85, 0x2d, 0x93, 0x99, 0xd6, 0x32, 0xb1, 0x9a, 0xcd, + 0xe9, 0xd4, 0x9c, 0xfd, 0xaa, 0x6a, 0xce, 0xbd, 0x7c, 0x35, 0xe3, 0x2a, 0x98, 0x1c, 0x42, 0x73, + 0x90, 0xf1, 0xad, 0x87, 0x42, 0x99, 0x65, 0xc2, 0x87, 0x78, 0x1d, 0x72, 0xf2, 0x20, 0xa8, 0x36, + 0xae, 0xed, 0xe4, 0xcd, 0x88, 0x35, 0x9d, 0x09, 0x75, 0x38, 0x17, 0xeb, 0x30, 0x23, 0xb4, 0x83, + 0x7f, 0x6b, 0xc0, 0x8c, 0x32, 0xa1, 0x8a, 0x2e, 0x9b, 0x90, 0x97, 0xb7, 0x3b, 0x8c, 0x2c, 0xc7, + 0xc6, 0x23, 0xcb, 0xe5, 0x8e, 0xd5, 0x67, 0xd4, 0x6f, 0x35, 0x1f, 0x8f, 0x1a, 0xc6, 0x17, 0xa3, + 0xc6, 0xeb, 0xcf, 0x93, 0x52, 0x04, 0x39, 0x15, 0x75, 0x42, 0xc6, 0xe8, 0x0d, 0x71, 0x3a, 0x16, + 0x28, 0x3f, 0x38, 0xb4, 0x24, 0x03, 0xe4, 0x9a, 0xdb, 0xa5, 0x01, 0xe7, 0x6c, 0x72, 0x13, 0x12, + 0x49, 0x83, 0x7f, 0x0e, 0xf3, 0x09, 0x57, 0x53, 0xe7, 0x7c, 0x07, 0x72, 0x01, 0x57, 0x60, 0x78, + 0x4c, 0xcd, 0x50, 0x1b, 0x02, 0xdf, 0x9a, 0x55, 0xe7, 0xcb, 0x49, 0x98, 0x28, 0xfa, 0xe9, 0x76, + 0xff, 0xab, 0x01, 0xe5, 0x75, 0x6b, 0x93, 0x3a, 0xa1, 0x8f, 0x23, 0x30, 0x5d, 0xab, 0x47, 0x95, + 0xc6, 0xc5, 0x98, 0x07, 0xb4, 0x8f, 0x2c, 0x67, 0x40, 0x25, 0xcb, 0x02, 0x51, 0xd0, 0xb4, 0x91, + 0xc8, 0x78, 0xe1, 0x48, 0x64, 0xc4, 0xfe, 0x5e, 0x81, 0x2c, 0xf7, 0xac, 0xa1, 0x88, 0x42, 0x45, + 0x22, 0x01, 0xfc, 0x3a, 0xcc, 0x28, 0x29, 0x94, 0xfa, 0xe2, 0x23, 0x73, 0xf5, 0x15, 0xc3, 0x23, + 0xe3, 0x1e, 0xe4, 0xa4, 0xb6, 0xd1, 0x6b, 0x50, 0x8c, 0xb2, 0x9b, 0x90, 0x36, 0xd3, 0xca, 0xed, + 0x8d, 0x1a, 0x69, 0x16, 0x90, 0x78, 0x02, 0x35, 0x20, 0x2b, 0x56, 0x0a, 0xc9, 0x8d, 0x56, 0x71, + 0x6f, 0xd4, 0x90, 0x08, 0x22, 0x3f, 0xe8, 0x04, 0x98, 0xdb, 0x3c, 0xc1, 0x70, 0x15, 0x98, 0xad, + 0xc2, 0xde, 0xa8, 0x21, 0x60, 0x22, 0x7e, 0xf1, 0x55, 0x28, 0xaf, 0xd3, 0xae, 0xd5, 0x1e, 0xaa, + 0x4d, 0x2b, 0x21, 0x3b, 0xbe, 0xa1, 0x11, 0xf2, 0x38, 0x05, 0xe5, 0x68, 0xc7, 0xfb, 0xbd, 0x40, + 0x39, 0x75, 0x29, 0xc2, 0xdd, 0x08, 0xf0, 0xaf, 0x0d, 0x50, 0x76, 0x46, 0x18, 0x72, 0x0e, 0x97, + 0x35, 0x50, 0x31, 0x08, 0xf6, 0x46, 0x0d, 0x85, 0x21, 0xea, 0x8b, 0x2e, 0x41, 0x3e, 0x10, 0x3b, + 0x72, 0x66, 0xe3, 0xee, 0x23, 0x26, 0x5a, 0x87, 0xb8, 0x1b, 0xec, 0x8d, 0x1a, 0x21, 0x21, 0x09, + 0x07, 0x68, 0x29, 0x91, 0x39, 0xa5, 0x60, 0xb3, 0x7b, 0xa3, 0x86, 0x86, 0xd5, 0x33, 0x29, 0xfe, + 0xb7, 0x01, 0xa5, 0x3b, 0x96, 0x1d, 0xb9, 0x50, 0x35, 0x34, 0x51, 0x1c, 0x23, 0x25, 0x82, 0x5f, + 0xe9, 0x0e, 0x75, 0xac, 0xe1, 0x15, 0xcf, 0x17, 0x7c, 0x67, 0x48, 0x04, 0xc7, 0xc9, 0xce, 0x9c, + 0x98, 0xec, 0xb2, 0xd3, 0x87, 0xd4, 0xaf, 0x31, 0x80, 0x5d, 0x33, 0x0b, 0xe9, 0xb9, 0x0c, 0xfe, + 0xa3, 0x01, 0x65, 0x29, 0xb9, 0x72, 0xbb, 0x9f, 0x40, 0x4e, 0x2a, 0x46, 0xc8, 0xfe, 0x9c, 0xe0, + 0xf2, 0xc6, 0x34, 0x81, 0x45, 0xf1, 0x44, 0x3f, 0x80, 0xd9, 0x8e, 0xef, 0xf5, 0xfb, 0xb4, 0xb3, + 0xa1, 0x42, 0x58, 0x7a, 0x3c, 0x84, 0xad, 0xea, 0xf3, 0x64, 0x8c, 0x1c, 0xff, 0xcd, 0x80, 0x19, + 0x15, 0x2d, 0x94, 0xad, 0x22, 0xfd, 0x1a, 0x2f, 0x9c, 0xb2, 0xd2, 0xd3, 0xa6, 0xac, 0xa3, 0x90, + 0xeb, 0xfa, 0xde, 0xa0, 0x1f, 0x54, 0x33, 0xf2, 0x6e, 0x4a, 0x68, 0xba, 0x54, 0x86, 0xaf, 0xc1, + 0x6c, 0x28, 0xca, 0x01, 0x21, 0xb3, 0x36, 0x1e, 0x32, 0xd7, 0x3a, 0xd4, 0x65, 0xf6, 0x96, 0x1d, + 0x05, 0x41, 0x45, 0x8f, 0x7f, 0x69, 0xc0, 0xdc, 0x38, 0x09, 0x5a, 0xd5, 0xee, 0x19, 0x67, 0x77, + 0xfa, 0x60, 0x76, 0x4b, 0x22, 0xf8, 0x04, 0xef, 0xb9, 0xcc, 0x1f, 0x86, 0xac, 0xe5, 0xda, 0xda, + 0xdb, 0x50, 0xd2, 0x26, 0x79, 0x8a, 0xda, 0xa1, 0xea, 0x66, 0x10, 0x3e, 0x8c, 0x43, 0x42, 0x5a, + 0x06, 0x34, 0x01, 0xe0, 0x5f, 0x19, 0x30, 0x93, 0xb0, 0x25, 0x7a, 0x07, 0xcc, 0x2d, 0xdf, 0xeb, + 0x4d, 0x65, 0x28, 0xb1, 0x02, 0x7d, 0x07, 0xd2, 0xcc, 0x9b, 0xca, 0x4c, 0x69, 0xe6, 0x71, 0x2b, + 0x29, 0xf1, 0x33, 0xb2, 0xba, 0x95, 0x10, 0x7e, 0x1b, 0x8a, 0x42, 0xa0, 0xdb, 0x96, 0xed, 0x4f, + 0xcc, 0x16, 0x93, 0x05, 0xba, 0x04, 0x87, 0x64, 0x24, 0x9c, 0xbc, 0xb8, 0x3c, 0x69, 0x71, 0x39, + 0x5c, 0x7c, 0x1c, 0xb2, 0x2b, 0xdb, 0x03, 0x77, 0x87, 0x2f, 0xe9, 0x58, 0xcc, 0x0a, 0x97, 0xf0, + 0x31, 0x3e, 0x02, 0xf3, 0xfc, 0x0e, 0x52, 0x3f, 0x58, 0xf1, 0x06, 0x2e, 0x0b, 0xbb, 0x8b, 0xb3, + 0x50, 0x49, 0xa2, 0x95, 0x97, 0x54, 0x20, 0xdb, 0xe6, 0x08, 0xc1, 0x63, 0x86, 0x48, 0x00, 0xff, + 0xce, 0x00, 0x74, 0x95, 0x32, 0xb1, 0xcb, 0xda, 0x6a, 0x74, 0x3d, 0x6a, 0x50, 0xe8, 0x59, 0xac, + 0xbd, 0x4d, 0xfd, 0x20, 0xac, 0x41, 0x42, 0xf8, 0x9b, 0xa8, 0xf6, 0xf0, 0x39, 0x98, 0x4f, 0x9c, + 0x52, 0xc9, 0x54, 0x83, 0x42, 0x5b, 0xe1, 0x54, 0xbe, 0x8b, 0x60, 0xfc, 0xa7, 0x34, 0x14, 0xc4, + 0x02, 0x42, 0xb7, 0xd0, 0x39, 0x28, 0x6d, 0xd9, 0x6e, 0x97, 0xfa, 0x7d, 0xdf, 0x56, 0x2a, 0x30, + 0x5b, 0x87, 0xf6, 0x46, 0x0d, 0x1d, 0x4d, 0x74, 0x00, 0xbd, 0x09, 0xf9, 0x41, 0x40, 0xfd, 0xfb, + 0xb6, 0xbc, 0xe9, 0xc5, 0x56, 0x65, 0x77, 0xd4, 0xc8, 0xfd, 0x28, 0xa0, 0xfe, 0xda, 0x2a, 0xcf, + 0x3c, 0x03, 0x31, 0x22, 0xf2, 0xdb, 0x41, 0xd7, 0x95, 0x9b, 0x8a, 0x22, 0xac, 0xf5, 0x5d, 0x7e, + 0xfc, 0xb1, 0x50, 0xd7, 0xf7, 0xbd, 0x1e, 0x65, 0xdb, 0x74, 0x10, 0x34, 0xdb, 0x5e, 0xaf, 0xe7, + 0xb9, 0x4d, 0xd1, 0x4b, 0x0a, 0xa1, 0x79, 0xfa, 0xe4, 0xcb, 0x95, 0xe7, 0xde, 0x81, 0x3c, 0xdb, + 0xf6, 0xbd, 0x41, 0x77, 0x5b, 0x64, 0x85, 0x4c, 0xeb, 0xe2, 0xf4, 0xfc, 0x42, 0x0e, 0x24, 0x1c, + 0xa0, 0x53, 0x5c, 0x5b, 0xb4, 0xbd, 0x13, 0x0c, 0x7a, 0xb2, 0x43, 0x6b, 0x65, 0xf7, 0x46, 0x0d, + 0xe3, 0x4d, 0x12, 0xa1, 0xf1, 0xc7, 0x69, 0x68, 0x08, 0x47, 0xbd, 0x2b, 0xca, 0x86, 0x2b, 0x9e, + 0x7f, 0x83, 0x32, 0xdf, 0x6e, 0xdf, 0xb4, 0x7a, 0x34, 0xf4, 0x8d, 0x06, 0x94, 0x7a, 0x02, 0x79, + 0x5f, 0xbb, 0x02, 0xd0, 0x8b, 0xe8, 0xd0, 0x49, 0x00, 0x71, 0x67, 0xe4, 0xbc, 0xbc, 0x0d, 0x45, + 0x81, 0x11, 0xd3, 0x2b, 0x09, 0x4d, 0x35, 0xa7, 0x94, 0x4c, 0x69, 0x68, 0x6d, 0x5c, 0x43, 0x53, + 0xf3, 0x89, 0xd4, 0xa2, 0xfb, 0x7a, 0x36, 0xe9, 0xeb, 0xf8, 0x33, 0x03, 0xea, 0xeb, 0xe1, 0xc9, + 0x5f, 0x50, 0x1d, 0xa1, 0xbc, 0xe9, 0x97, 0x24, 0x6f, 0xe6, 0xff, 0x93, 0x17, 0xd7, 0x01, 0xd6, + 0x6d, 0x97, 0x5e, 0xb1, 0x1d, 0x46, 0xfd, 0x09, 0x9d, 0xc8, 0xc7, 0x99, 0x38, 0x24, 0x10, 0xba, + 0x15, 0xca, 0xb9, 0xa2, 0xc5, 0xe1, 0x97, 0x21, 0x46, 0xfa, 0x25, 0x9a, 0x2d, 0x33, 0x16, 0xa2, + 0x76, 0x20, 0xbf, 0x25, 0xc4, 0x93, 0x29, 0x35, 0xf1, 0x8c, 0x12, 0xcb, 0xde, 0xba, 0xa4, 0x36, + 0x3f, 0xff, 0xbc, 0x82, 0x44, 0xbc, 0xfa, 0x34, 0x83, 0xa1, 0xcb, 0xac, 0x47, 0xda, 0x62, 0x12, + 0xee, 0x80, 0x7e, 0xa6, 0xca, 0xad, 0xec, 0xc4, 0x72, 0x2b, 0xbc, 0xb9, 0x2f, 0xde, 0x33, 0xbe, + 0x1b, 0xc7, 0x3e, 0x61, 0x0e, 0x15, 0xfb, 0x4e, 0x83, 0xe9, 0xd3, 0xad, 0x30, 0x49, 0xa3, 0x78, + 0xdb, 0x88, 0x52, 0xcc, 0xe3, 0x3f, 0x1b, 0x30, 0x77, 0x95, 0xb2, 0x64, 0xf9, 0xf3, 0x0a, 0x19, + 0x13, 0xbf, 0x0f, 0x87, 0xb5, 0xf3, 0x2b, 0xe9, 0xcf, 0x8f, 0xd5, 0x3c, 0x47, 0x62, 0xf9, 0xd7, + 0xdc, 0x0e, 0x7d, 0xa4, 0x7a, 0xc5, 0x64, 0xb9, 0x73, 0x1b, 0x4a, 0xda, 0x24, 0xba, 0x3c, 0x56, + 0xe8, 0x68, 0x2f, 0x3b, 0x51, 0xb2, 0x6e, 0x55, 0x94, 0x4c, 0xb2, 0x5b, 0x54, 0x65, 0x6c, 0x54, + 0x14, 0x6c, 0x00, 0x12, 0xe6, 0x12, 0x6c, 0xf5, 0xb4, 0x24, 0xb0, 0xd7, 0xa3, 0x8a, 0x27, 0x82, + 0xd1, 0x29, 0x30, 0x7d, 0xef, 0x61, 0x58, 0xc1, 0xce, 0xc4, 0x5b, 0x12, 0xef, 0x21, 0x11, 0x53, + 0xf8, 0x12, 0x64, 0x88, 0xf7, 0x10, 0xd5, 0x01, 0x7c, 0xcb, 0xed, 0xd2, 0xbb, 0x51, 0xe3, 0x54, + 0x26, 0x1a, 0xe6, 0x80, 0x92, 0x61, 0x05, 0x0e, 0xeb, 0x27, 0x92, 0xe6, 0x5e, 0x82, 0xfc, 0x07, + 0x03, 0x5d, 0x5d, 0x95, 0x31, 0x75, 0xc9, 0x1e, 0x3c, 0x24, 0xe2, 0x3e, 0x03, 0x31, 0x1e, 0x9d, + 0x80, 0x22, 0xb3, 0x36, 0x1d, 0x7a, 0x33, 0x0e, 0x70, 0x31, 0x82, 0xcf, 0xf2, 0x9e, 0xef, 0xae, + 0x56, 0xfb, 0xc4, 0x08, 0x74, 0x06, 0xe6, 0xe2, 0x33, 0xdf, 0xf6, 0xe9, 0x96, 0xfd, 0x48, 0x58, + 0xb8, 0x4c, 0xf6, 0xe1, 0xd1, 0x22, 0x1c, 0x8a, 0x71, 0x1b, 0xa2, 0xc6, 0x30, 0x05, 0xe9, 0x38, + 0x9a, 0xeb, 0x46, 0x88, 0xfb, 0xde, 0x83, 0x81, 0xe5, 0x88, 0x9b, 0x57, 0x26, 0x1a, 0x06, 0xff, + 0xc5, 0x80, 0xc3, 0xd2, 0xd4, 0xbc, 0xdb, 0x7f, 0x15, 0xbd, 0xfe, 0x53, 0x03, 0x90, 0x2e, 0x81, + 0x72, 0xad, 0x6f, 0xe9, 0xcf, 0x38, 0xbc, 0x88, 0x29, 0x89, 0x56, 0x56, 0xa2, 0xe2, 0x97, 0x18, + 0x0c, 0x39, 0x51, 0x08, 0xc9, 0x9e, 0xda, 0x94, 0xbd, 0xb2, 0xc4, 0x10, 0xf5, 0xe5, 0x2d, 0xfe, + 0xe6, 0x90, 0xd1, 0x40, 0x75, 0xba, 0xa2, 0xc5, 0x17, 0x08, 0x22, 0x3f, 0x7c, 0x2f, 0xea, 0x32, + 0xe1, 0x35, 0x66, 0xbc, 0x97, 0x42, 0x91, 0x70, 0x80, 0xff, 0x90, 0x86, 0x99, 0xbb, 0x9e, 0x33, + 0x88, 0x53, 0xe2, 0xab, 0x94, 0x2a, 0x12, 0xed, 0x77, 0x36, 0x6c, 0xbf, 0x11, 0x98, 0x01, 0xa3, + 0x7d, 0xe1, 0x59, 0x19, 0x22, 0xc6, 0x08, 0x43, 0x99, 0x59, 0x7e, 0x97, 0x32, 0xd9, 0xd7, 0x54, + 0x73, 0xa2, 0xe0, 0x4c, 0xe0, 0xd0, 0x02, 0x94, 0xac, 0x6e, 0xd7, 0xa7, 0x5d, 0x8b, 0xd1, 0xd6, + 0xb0, 0x9a, 0x17, 0x9b, 0xe9, 0x28, 0xfc, 0x21, 0xcc, 0x86, 0xca, 0x52, 0x26, 0x7d, 0x0b, 0xf2, + 0x1f, 0x09, 0xcc, 0x84, 0x27, 0x2f, 0x49, 0xaa, 0xc2, 0x58, 0x48, 0x96, 0x7c, 0x1f, 0x0f, 0xcf, + 0x8c, 0xaf, 0x41, 0x4e, 0x92, 0xa3, 0x13, 0x7a, 0x77, 0x22, 0xdf, 0x66, 0x38, 0xac, 0x5a, 0x0d, + 0x0c, 0x39, 0xc9, 0x48, 0x19, 0x5e, 0xf8, 0x86, 0xc4, 0x10, 0xf5, 0xc5, 0xff, 0x32, 0xe0, 0xc8, + 0x2a, 0x65, 0xb4, 0xcd, 0x68, 0xe7, 0x8a, 0x4d, 0x9d, 0xce, 0x37, 0xda, 0x38, 0x47, 0x6f, 0x5f, + 0x19, 0xed, 0xed, 0x8b, 0xc7, 0x1d, 0xc7, 0x76, 0xe9, 0xba, 0xf6, 0x78, 0x12, 0x23, 0x78, 0x84, + 0xd8, 0xe2, 0x07, 0x97, 0xd3, 0xf2, 0x0f, 0x09, 0x0d, 0x13, 0x59, 0x38, 0x17, 0x5b, 0x18, 0xaf, + 0xc1, 0xd1, 0x71, 0xa1, 0x95, 0x8d, 0x9a, 0x90, 0x13, 0x6b, 0x27, 0x3c, 0x9e, 0x26, 0x56, 0x10, + 0x45, 0x86, 0x7d, 0x98, 0x49, 0x4c, 0x08, 0x9b, 0x71, 0x1f, 0x51, 0xf1, 0x53, 0x02, 0xe8, 0xdb, + 0x60, 0xb2, 0x61, 0x5f, 0x85, 0xcd, 0xd6, 0x91, 0xff, 0x8c, 0x1a, 0x87, 0x13, 0xcb, 0xee, 0x0c, + 0xfb, 0x94, 0x08, 0x12, 0xee, 0x5a, 0x6d, 0xcb, 0xef, 0xd8, 0xae, 0xe5, 0xd8, 0x4c, 0xaa, 0xc2, + 0x24, 0x3a, 0xea, 0xcc, 0x69, 0x28, 0x46, 0xff, 0x48, 0xa0, 0x12, 0xe4, 0xaf, 0xdc, 0x22, 0x3f, + 0xbe, 0x4c, 0x56, 0xe7, 0x52, 0xa8, 0x0c, 0x85, 0xd6, 0xe5, 0x95, 0xeb, 0x02, 0x32, 0x96, 0x3f, + 0xcb, 0x86, 0xe9, 0xc0, 0x47, 0xdf, 0x87, 0xac, 0x8c, 0xf1, 0x47, 0x63, 0x89, 0xf4, 0xb7, 0xff, + 0xda, 0xb1, 0x7d, 0x78, 0xa9, 0x12, 0x9c, 0x7a, 0xcb, 0x40, 0x37, 0xa1, 0x24, 0x90, 0xea, 0x95, + 0xef, 0xc4, 0xf8, 0x63, 0x5b, 0x82, 0xd3, 0xc9, 0x03, 0x66, 0x35, 0x7e, 0x17, 0x21, 0x2b, 0x2e, + 0x92, 0x7e, 0x1a, 0xfd, 0x95, 0x56, 0x3f, 0x4d, 0xe2, 0xdd, 0x13, 0xa7, 0xd0, 0xf7, 0xc0, 0xe4, + 0x7d, 0x2f, 0xd2, 0x2a, 0x01, 0xed, 0x71, 0xae, 0x76, 0x74, 0x1c, 0xad, 0x6d, 0xfb, 0x6e, 0xf4, + 0xc6, 0x78, 0x6c, 0xfc, 0xad, 0x23, 0x5c, 0x5e, 0xdd, 0x3f, 0x11, 0xed, 0x7c, 0x4b, 0x3e, 0x86, + 0x85, 0x1d, 0x37, 0x3a, 0x99, 0xdc, 0x6a, 0xac, 0x41, 0xaf, 0xd5, 0x0f, 0x9a, 0x8e, 0x18, 0xae, + 0x43, 0x49, 0xeb, 0x76, 0x75, 0xb5, 0xee, 0x6f, 0xd5, 0x75, 0xb5, 0x4e, 0x68, 0x91, 0x71, 0x0a, + 0x5d, 0x85, 0x02, 0xaf, 0x9f, 0x78, 0x1a, 0x41, 0xc7, 0xc7, 0xcb, 0x24, 0x2d, 0x3d, 0xd6, 0x4e, + 0x4c, 0x9e, 0x8c, 0x18, 0xfd, 0x10, 0x8a, 0x57, 0x29, 0x53, 0x31, 0xe6, 0xd8, 0x78, 0x90, 0x9a, + 0xa0, 0xa9, 0x64, 0xa0, 0xc3, 0x29, 0xf4, 0xa1, 0x28, 0xe5, 0x92, 0x77, 0x0c, 0x35, 0x0e, 0xb8, + 0x4b, 0xd1, 0xb9, 0x16, 0x0e, 0x26, 0x08, 0x39, 0x2f, 0xff, 0x34, 0xfc, 0x0f, 0x74, 0xd5, 0x62, + 0x16, 0xba, 0x05, 0xb3, 0x42, 0xe4, 0xe8, 0x4f, 0xd2, 0x84, 0x6b, 0xee, 0xfb, 0x47, 0x36, 0xe1, + 0x9a, 0xfb, 0xff, 0x99, 0xc5, 0xa9, 0xd6, 0xbd, 0x27, 0x4f, 0xeb, 0xa9, 0xcf, 0x9f, 0xd6, 0x53, + 0x5f, 0x3e, 0xad, 0x1b, 0xbf, 0xd8, 0xad, 0x1b, 0xbf, 0xdf, 0xad, 0x1b, 0x8f, 0x77, 0xeb, 0xc6, + 0x93, 0xdd, 0xba, 0xf1, 0x8f, 0xdd, 0xba, 0xf1, 0xcf, 0xdd, 0x7a, 0xea, 0xcb, 0xdd, 0xba, 0xf1, + 0xc9, 0xb3, 0x7a, 0xea, 0xc9, 0xb3, 0x7a, 0xea, 0xf3, 0x67, 0xf5, 0xd4, 0xbd, 0xd7, 0xfe, 0x47, + 0x5f, 0x21, 0x23, 0x5f, 0x4e, 0x7c, 0xce, 0xff, 0x37, 0x00, 0x00, 0xff, 0xff, 0x02, 0xc8, 0x89, + 0xb6, 0xc2, 0x1e, 0x00, 0x00, } func (x Direction) String() string { @@ -4382,23 +4408,24 @@ func (this *DetectedFieldsRequest) Equal(that interface{}) bool { } else if this == nil { return false } - if that1.Start == nil { - if this.Start != nil { - return false - } - } else if !this.Start.Equal(*that1.Start) { + if !this.Start.Equal(that1.Start) { return false } - if that1.End == nil { - if this.End != nil { - return false - } - } else if !this.End.Equal(*that1.End) { + if !this.End.Equal(that1.End) { return false } if this.Query != that1.Query { return false } + if this.LineLimit != that1.LineLimit { + return false + } + if this.FieldLimit != that1.FieldLimit { + return false + } + if this.Step != that1.Step { + return false + } return true } func (this *DetectedFieldsResponse) Equal(that interface{}) bool { @@ -5045,11 +5072,14 @@ func (this *DetectedFieldsRequest) GoString() string { if this == nil { return "nil" } - s := make([]string, 0, 7) + s := make([]string, 0, 10) s = append(s, "&logproto.DetectedFieldsRequest{") s = append(s, "Start: "+fmt.Sprintf("%#v", this.Start)+",\n") s = append(s, "End: "+fmt.Sprintf("%#v", this.End)+",\n") s = append(s, "Query: "+fmt.Sprintf("%#v", this.Query)+",\n") + s = append(s, "LineLimit: "+fmt.Sprintf("%#v", this.LineLimit)+",\n") + s = append(s, "FieldLimit: "+fmt.Sprintf("%#v", this.FieldLimit)+",\n") + s = append(s, "Step: "+fmt.Sprintf("%#v", this.Step)+",\n") s = append(s, "}") return strings.Join(s, "") } @@ -7686,6 +7716,21 @@ func (m *DetectedFieldsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.Step != 0 { + i = encodeVarintLogproto(dAtA, i, uint64(m.Step)) + i-- + dAtA[i] = 0x30 + } + if m.FieldLimit != 0 { + i = encodeVarintLogproto(dAtA, i, uint64(m.FieldLimit)) + i-- + dAtA[i] = 0x28 + } + if m.LineLimit != 0 { + i = encodeVarintLogproto(dAtA, i, uint64(m.LineLimit)) + i-- + dAtA[i] = 0x20 + } if len(m.Query) > 0 { i -= len(m.Query) copy(dAtA[i:], m.Query) @@ -7693,26 +7738,22 @@ func (m *DetectedFieldsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x1a } - if m.End != nil { - n21, err21 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.End, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.End):]) - if err21 != nil { - return 0, err21 - } - i -= n21 - i = encodeVarintLogproto(dAtA, i, uint64(n21)) - i-- - dAtA[i] = 0x12 + n21, err21 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.End, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.End):]) + if err21 != nil { + return 0, err21 } - if m.Start != nil { - n22, err22 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Start, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Start):]) - if err22 != nil { - return 0, err22 - } - i -= n22 - i = encodeVarintLogproto(dAtA, i, uint64(n22)) - i-- - dAtA[i] = 0xa + i -= n21 + i = encodeVarintLogproto(dAtA, i, uint64(n21)) + i-- + dAtA[i] = 0x12 + n22, err22 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Start, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Start):]) + if err22 != nil { + return 0, err22 } + i -= n22 + i = encodeVarintLogproto(dAtA, i, uint64(n22)) + i-- + dAtA[i] = 0xa return len(dAtA) - i, nil } @@ -8694,18 +8735,23 @@ func (m *DetectedFieldsRequest) Size() (n int) { } var l int _ = l - if m.Start != nil { - l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Start) - n += 1 + l + sovLogproto(uint64(l)) - } - if m.End != nil { - l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.End) - n += 1 + l + sovLogproto(uint64(l)) - } + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Start) + n += 1 + l + sovLogproto(uint64(l)) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.End) + n += 1 + l + sovLogproto(uint64(l)) l = len(m.Query) if l > 0 { n += 1 + l + sovLogproto(uint64(l)) } + if m.LineLimit != 0 { + n += 1 + sovLogproto(uint64(m.LineLimit)) + } + if m.FieldLimit != 0 { + n += 1 + sovLogproto(uint64(m.FieldLimit)) + } + if m.Step != 0 { + n += 1 + sovLogproto(uint64(m.Step)) + } return n } @@ -9352,9 +9398,12 @@ func (this *DetectedFieldsRequest) String() string { return "nil" } s := strings.Join([]string{`&DetectedFieldsRequest{`, - `Start:` + strings.Replace(fmt.Sprintf("%v", this.Start), "Timestamp", "types.Timestamp", 1) + `,`, - `End:` + strings.Replace(fmt.Sprintf("%v", this.End), "Timestamp", "types.Timestamp", 1) + `,`, + `Start:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Start), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`, + `End:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.End), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`, `Query:` + fmt.Sprintf("%v", this.Query) + `,`, + `LineLimit:` + fmt.Sprintf("%v", this.LineLimit) + `,`, + `FieldLimit:` + fmt.Sprintf("%v", this.FieldLimit) + `,`, + `Step:` + fmt.Sprintf("%v", this.Step) + `,`, `}`, }, "") return s @@ -15355,10 +15404,7 @@ func (m *DetectedFieldsRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Start == nil { - m.Start = new(time.Time) - } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.Start, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Start, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -15391,10 +15437,7 @@ func (m *DetectedFieldsRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.End == nil { - m.End = new(time.Time) - } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.End, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.End, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -15430,6 +15473,63 @@ func (m *DetectedFieldsRequest) Unmarshal(dAtA []byte) error { } m.Query = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LineLimit", wireType) + } + m.LineLimit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLogproto + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LineLimit |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldLimit", wireType) + } + m.FieldLimit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLogproto + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.FieldLimit |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Step", wireType) + } + m.Step = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLogproto + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Step |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipLogproto(dAtA[iNdEx:]) diff --git a/pkg/logproto/logproto.proto b/pkg/logproto/logproto.proto index b170a46af28b6..0274b2f7e02b5 100644 --- a/pkg/logproto/logproto.proto +++ b/pkg/logproto/logproto.proto @@ -426,13 +426,16 @@ message Volume { message DetectedFieldsRequest { google.protobuf.Timestamp start = 1 [ (gogoproto.stdtime) = true, - (gogoproto.nullable) = true + (gogoproto.nullable) = false ]; google.protobuf.Timestamp end = 2 [ (gogoproto.stdtime) = true, - (gogoproto.nullable) = true + (gogoproto.nullable) = false ]; string query = 3; // Naming this query instead of match because this should be with queryrangebase.Request interface + uint32 lineLimit = 4; + uint32 fieldLimit = 5; + int64 step = 6; } message DetectedFieldsResponse { @@ -441,8 +444,6 @@ message DetectedFieldsResponse { message DetectedField { string label = 1; - string type = 2 [ - (gogoproto.casttype) = "DetectedFieldType" - ]; + string type = 2 [(gogoproto.casttype) = "DetectedFieldType"]; uint64 cardinality = 3; } diff --git a/pkg/querier/querier.go b/pkg/querier/querier.go index c2e744a6f03d9..95ebcc5f12a66 100644 --- a/pkg/querier/querier.go +++ b/pkg/querier/querier.go @@ -4,11 +4,17 @@ import ( "context" "flag" "net/http" + "sort" + "strconv" "time" + "github.com/axiomhq/hyperloglog" + "github.com/dustin/go-humanize" "github.com/go-kit/log" "github.com/opentracing/opentracing-go" + logql_log "github.com/grafana/loki/pkg/logql/log" + "github.com/grafana/loki/pkg/logqlmodel" "github.com/grafana/loki/pkg/storage/stores/index" "github.com/grafana/loki/pkg/storage/stores/index/seriesvolume" "github.com/grafana/loki/pkg/storage/stores/shipper/indexshipper/indexgateway" @@ -899,14 +905,244 @@ func (q *SingleTenantQuerier) Volume(ctx context.Context, req *logproto.VolumeRe return seriesvolume.Merge(responses, req.Limit), nil } -func (q *SingleTenantQuerier) DetectedFields(_ context.Context, _ *logproto.DetectedFieldsRequest) (*logproto.DetectedFieldsResponse, error) { - return &logproto.DetectedFieldsResponse{ - Fields: []*logproto.DetectedField{ - { - Label: "foo", - Type: logproto.DetectedFieldString, - Cardinality: 1, +func (q *SingleTenantQuerier) DetectedFields(ctx context.Context, req *logproto.DetectedFieldsRequest) (*logproto.DetectedFieldsResponse, error) { + iters := []iter.EntryIterator{} + parsed, err := syntax.ParseLogSelector(req.Query, true) + if err != nil { + return nil, err + } + + ingesterQueryInterval, storeQueryInterval := q.buildQueryIntervals(req.Start, req.End) + + if !q.cfg.QueryStoreOnly && ingesterQueryInterval != nil { + params := logql.SelectLogParams{ + QueryRequest: &logproto.QueryRequest{ + Selector: req.Query, + Limit: req.LineLimit, + Start: ingesterQueryInterval.start, + End: ingesterQueryInterval.end, + Direction: logproto.FORWARD, + Plan: &plan.QueryPlan{ + AST: parsed, + }, }, - }, + } + + level.Debug(spanlogger.FromContext(ctx)).Log( + "msg", "querying ingester", + "params", params) + ingesterIters, err := q.ingesterQuerier.SelectLogs(ctx, params) + if err != nil { + return nil, err + } + + iters = append(iters, ingesterIters...) + } + + if !q.cfg.QueryIngesterOnly && storeQueryInterval != nil { + params := logql.SelectLogParams{ + QueryRequest: &logproto.QueryRequest{ + Selector: req.Query, + Limit: req.LineLimit, + Start: storeQueryInterval.start, + End: storeQueryInterval.end, + Direction: logproto.FORWARD, + Plan: &plan.QueryPlan{ + AST: parsed, + }, + }, + } + level.Debug(spanlogger.FromContext(ctx)).Log( + "msg", "querying store for detected fields", + "params", params) + storeIter, err := q.store.SelectLogs(ctx, params) + if err != nil { + return nil, err + } + + iters = append(iters, storeIter) + } + + finalIters := iter.NewMergeEntryIterator(ctx, iters, logproto.FORWARD) + + //TODO(twhitney): converting from a step to a duration should be abstracted and reused, + // doing this in a few places now. + streams, err := streamsForFieldDetection(finalIters, req.LineLimit, time.Duration(req.Step*1e6)) + detectedFields := parseDetectedFields(req.FieldLimit, streams) + + fields := make([]*logproto.DetectedField, len(detectedFields)) + fieldCount := 0 + for k, v := range detectedFields { + fields[fieldCount] = &logproto.DetectedField{ + Label: k, + Type: v.fieldType, + Cardinality: v.Estimate(), + } + + fieldCount++ + } + + return &logproto.DetectedFieldsResponse{ + Fields: fields, }, nil } + +type parsedFields struct { + sketch *hyperloglog.Sketch + isTypeDetected bool + fieldType logproto.DetectedFieldType +} + +func newParsedFields() *parsedFields { + return &parsedFields{ + sketch: hyperloglog.New(), + isTypeDetected: false, + fieldType: logproto.DetectedFieldString, + } +} + +func (p *parsedFields) Insert(value string) { + p.sketch.Insert([]byte(value)) +} + +func (p *parsedFields) Estimate() uint64 { + return p.sketch.Estimate() +} + +func (p *parsedFields) DetermineType(value string) { + p.fieldType = determineType(value) + p.isTypeDetected = true +} + +func determineType(value string) logproto.DetectedFieldType { + if _, err := strconv.ParseInt(value, 10, 64); err == nil { + return logproto.DetectedFieldInt + } + + if _, err := strconv.ParseFloat(value, 64); err == nil { + return logproto.DetectedFieldFloat + } + + if _, err := strconv.ParseBool(value); err == nil { + return logproto.DetectedFieldBoolean + } + + if _, err := time.ParseDuration(value); err == nil { + return logproto.DetectedFieldDuration + } + + if _, err := humanize.ParseBytes(value); err == nil { + return logproto.DetectedFieldBytes + } + + return logproto.DetectedFieldString +} + +func parseDetectedFields(limit uint32, streams logqlmodel.Streams) map[string]*parsedFields { + detectedFields := make(map[string]*parsedFields, limit) + fieldCount := uint32(0) + + for _, stream := range streams { + for _, entry := range stream.Entries { + detected := parseLine(entry.Line) + for k, vals := range detected { + if fieldCount >= limit { + return detectedFields + } + + if _, ok := detectedFields[k]; !ok { + detectedFields[k] = newParsedFields() + } + + for _, v := range vals { + parsedFields := detectedFields[k] + if !parsedFields.isTypeDetected { + parsedFields.DetermineType(v) + } + + parsedFields.Insert(v) + } + + fieldCount++ + } + } + } + + return detectedFields +} + +func parseLine(line string) map[string][]string { + logFmtParser := logql_log.NewLogfmtParser(true, false) + jsonParser := logql_log.NewJSONParser() + + lbls := logql_log.NewBaseLabelsBuilder().ForLabels(labels.EmptyLabels(), 0) + _, logfmtSuccess := logFmtParser.Process(0, []byte(line), lbls) + if !logfmtSuccess || lbls.HasErr() { + lbls.Reset() + _, jsonSuccess := jsonParser.Process(0, []byte(line), lbls) + if !jsonSuccess || lbls.HasErr() { + return map[string][]string{} + } + } + + parsedLabels := map[string]map[string]struct{}{} + for _, lbl := range lbls.LabelsResult().Labels() { + if values, ok := parsedLabels[lbl.Name]; ok { + values[lbl.Value] = struct{}{} + } else { + parsedLabels[lbl.Name] = map[string]struct{}{lbl.Value: struct{}{}} + } + } + + result := make(map[string][]string, len(parsedLabels)) + for lbl, values := range parsedLabels { + vals := make([]string, 0, len(values)) + for v := range values { + vals = append(vals, v) + } + result[lbl] = vals + } + + return result +} + +// readStreams 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) { + 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 + // value here because many unit tests start at time.Unix(0,0) + lastEntry := time.Unix(-100, 0) + for respSize < size && i.Next() { + streamLabels, entry := i.Labels(), i.Entry() + + forwardShouldOutput := entry.Timestamp.Equal(lastEntry.Add(interval)) || + entry.Timestamp.After(lastEntry.Add(interval)) + + // 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 || forwardShouldOutput { + stream, ok := streams[streamLabels] + if !ok { + stream = &logproto.Stream{ + Labels: streamLabels, + } + streams[streamLabels] = stream + } + stream.Entries = append(stream.Entries, entry) + lastEntry = i.Entry().Timestamp + respSize++ + } + } + + result := make(logqlmodel.Streams, 0, len(streams)) + for _, stream := range streams { + result = append(result, *stream) + } + sort.Sort(result) + return result, i.Error() +} diff --git a/pkg/querier/queryrange/codec.go b/pkg/querier/queryrange/codec.go index 820931e97efd3..6a77d32ecd308 100644 --- a/pkg/querier/queryrange/codec.go +++ b/pkg/querier/queryrange/codec.go @@ -394,6 +394,11 @@ func (Codec) DecodeRequest(_ context.Context, r *http.Request, _ []string) (quer return nil, httpgrpc.Errorf(http.StatusBadRequest, err.Error()) } + _, err = syntax.ParseExpr(req.Query) + if err != nil { + return nil, httpgrpc.Errorf(http.StatusBadRequest, err.Error()) + } + return &DetectedFieldsRequest{ DetectedFieldsRequest: *req, path: r.URL.Path, @@ -435,7 +440,7 @@ func (Codec) DecodeHTTPGrpcRequest(ctx context.Context, r *httpgrpc.HTTPRequest) ctx = httpreq.InjectQueryTags(ctx, queryTags) } - // Add disable pipleine wrappers + // Add disable pipeline wrappers if disableWrappers := httpReq.Header.Get(httpreq.LokiDisablePipelineWrappersHeader); disableWrappers != "" { httpreq.InjectHeader(ctx, httpreq.LokiDisablePipelineWrappersHeader, disableWrappers) } @@ -1865,8 +1870,8 @@ type DetectedFieldsRequest struct { func NewDetectedFieldsRequest(start, end time.Time, query, path string) *DetectedFieldsRequest { return &DetectedFieldsRequest{ DetectedFieldsRequest: logproto.DetectedFieldsRequest{ - Start: &start, - End: &end, + Start: start, + End: end, Query: query, }, path: path, @@ -1878,19 +1883,19 @@ func (r *DetectedFieldsRequest) AsProto() *logproto.DetectedFieldsRequest { } func (r *DetectedFieldsRequest) GetEnd() time.Time { - return *r.End + return r.End } func (r *DetectedFieldsRequest) GetEndTs() time.Time { - return *r.End + return r.End } func (r *DetectedFieldsRequest) GetStart() time.Time { - return *r.Start + return r.Start } func (r *DetectedFieldsRequest) GetStartTs() time.Time { - return *r.Start + return r.Start } func (r *DetectedFieldsRequest) GetStep() int64 { @@ -1903,8 +1908,8 @@ func (r *DetectedFieldsRequest) Path() string { func (r *DetectedFieldsRequest) WithStartEnd(s, e time.Time) queryrangebase.Request { clone := *r - clone.Start = &s - clone.End = &e + clone.Start = s + clone.End = e return &clone } diff --git a/pkg/querier/queryrange/roundtrip.go b/pkg/querier/queryrange/roundtrip.go index 3d1a5daf1afb4..fe6e8d15a6efd 100644 --- a/pkg/querier/queryrange/roundtrip.go +++ b/pkg/querier/queryrange/roundtrip.go @@ -372,7 +372,7 @@ func (r roundTripper) Do(ctx context.Context, req base.Request) (base.Response, "msg", "executing query", "type", "detected fields", "query", op.Query, - "length", op.End.Sub(*op.Start), + "length", op.End.Sub(op.Start), "start", op.Start, "end", op.End, )