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

Replace `LokiLabelNamesRequest` with `logproto.LabelRequest`. (#10801)

Browse Source 
**What this PR does / why we need it**:
This is an attempt to unify our API models and use the definitions in
`logproto` which is helpful for #10688.

**Checklist**
- [ ] Reviewed the
[`CONTRIBUTING.md`](https://github.com/grafana/loki/blob/main/CONTRIBUTING.md)
guide (**required**)
- [ ] Documentation added
- [ ] Tests updated
- [ ] `CHANGELOG.md` updated
- [ ] If the change is worth mentioning in the release notes, add
`add-to-release-notes` label
- [ ] Changes that require user attention or interaction to upgrade are
documented in `docs/sources/setup/upgrade/_index.md`
- [ ] For Helm chart changes bump the Helm chart version in
`production/helm/loki/Chart.yaml` and update
`production/helm/loki/CHANGELOG.md` and
`production/helm/loki/README.md`. [Example
PR](d10549e3ec)
pull/10868/head
Karsten Jeschkies 3 years ago committed by GitHub
parent d1dee9150b
commit 56437fa0c4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 209 additions and 609 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. 122
      pkg/querier/queryrange/codec.go
  2. 66
      pkg/querier/queryrange/codec_test.go
  3. 562
      pkg/querier/queryrange/queryrange.pb.go
  4. 13
      pkg/querier/queryrange/queryrange.proto
  5. 12
      pkg/querier/queryrange/roundtrip_test.go
  6. 13
      pkg/querier/queryrange/split_by_interval.go
  7. 6
      pkg/querier/queryrange/split_by_interval_test.go
  8. 24
      pkg/querier/queryrange/stats.go

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

@ -173,38 +173,76 @@ func (r *LokiSeriesRequest) LogToSpan(sp opentracing.Span) {
func (*LokiSeriesRequest) GetCachingOptions() (res queryrangebase.CachingOptions) { return }
func (r *LokiLabelNamesRequest) GetEnd() int64 {
return r.EndTs.UnixNano() / (int64(time.Millisecond) / int64(time.Nanosecond))
// In some other world LabelRequest could implement queryrangebase.Request.
type LabelRequest struct {
path string
logproto.LabelRequest
}
func NewLabelRequest(start, end time.Time, query, name, path string) *LabelRequest {
return &LabelRequest{
LabelRequest: logproto.LabelRequest{
Start: &start,
End: &end,
Query: query,
Name: name,
Values: name != "",
},
path: path,
}
}
func (r *LokiLabelNamesRequest) GetStart() int64 {
return r.StartTs.UnixNano() / (int64(time.Millisecond) / int64(time.Nanosecond))
func (r *LabelRequest) AsProto() *logproto.LabelRequest {
return &r.LabelRequest
}
func (r *LokiLabelNamesRequest) WithStartEnd(s int64, e int64) queryrangebase.Request {
clone := *r
clone.StartTs = time.Unix(0, s*int64(time.Millisecond))
clone.EndTs = time.Unix(0, e*int64(time.Millisecond))
return &clone
func (r *LabelRequest) GetEnd() int64 {
return r.End.UnixNano() / (int64(time.Millisecond) / int64(time.Nanosecond))
}
func (r *LabelRequest) GetEndTs() time.Time {
return *r.End
}
func (r *LabelRequest) GetStart() int64 {
return r.Start.UnixNano() / (int64(time.Millisecond) / int64(time.Nanosecond))
}
func (r *LabelRequest) GetStartTs() time.Time {
return *r.Start
}
func (r *LabelRequest) GetStep() int64 {
return 0
}
func (r *LokiLabelNamesRequest) WithQuery(_ string) queryrangebase.Request {
func (r *LabelRequest) WithStartEnd(s int64, e int64) queryrangebase.Request {
clone := *r
tmp := time.Unix(0, s*int64(time.Millisecond))
clone.Start = &tmp
tmp = time.Unix(0, e*int64(time.Millisecond))
clone.End = &tmp
return &clone
}
func (r *LokiLabelNamesRequest) GetStep() int64 {
return 0
func (r *LabelRequest) WithQuery(query string) queryrangebase.Request {
clone := *r
clone.Query = query
return &clone
}
func (r *LokiLabelNamesRequest) LogToSpan(sp opentracing.Span) {
func (r *LabelRequest) LogToSpan(sp opentracing.Span) {
sp.LogFields(
otlog.String("start", timestamp.Time(r.GetStart()).String()),
otlog.String("end", timestamp.Time(r.GetEnd()).String()),
)
}
func (*LokiLabelNamesRequest) GetCachingOptions() (res queryrangebase.CachingOptions) { return }
func (r *LabelRequest) Path() string {
return r.path
}
func (*LabelRequest) GetCachingOptions() (res queryrangebase.CachingOptions) { return }
func (Codec) DecodeRequest(_ context.Context, r *http.Request, _ []string) (queryrangebase.Request, error) {
if err := r.ParseForm(); err != nil {
@ -258,11 +296,9 @@ func (Codec) DecodeRequest(_ context.Context, r *http.Request, _ []string) (quer
if err != nil {
return nil, httpgrpc.Errorf(http.StatusBadRequest, err.Error())
}
return &LokiLabelNamesRequest{
StartTs: *req.Start,
EndTs: *req.End,
Path: r.URL.Path,
Query: req.Query,
return &LabelRequest{
LabelRequest: *req,
path: r.URL.Path,
}, nil
case IndexStatsOp:
req, err := loghttp.ParseIndexStatsQuery(r)
@ -375,15 +411,15 @@ func (c Codec) EncodeRequest(ctx context.Context, r queryrangebase.Request) (*ht
Header: header,
}
return req.WithContext(ctx), nil
case *LokiLabelNamesRequest:
case *LabelRequest:
params := url.Values{
"start": []string{fmt.Sprintf("%d", request.StartTs.UnixNano())},
"end": []string{fmt.Sprintf("%d", request.EndTs.UnixNano())},
"start": []string{fmt.Sprintf("%d", request.Start.UnixNano())},
"end": []string{fmt.Sprintf("%d", request.End.UnixNano())},
"query": []string{request.GetQuery()},
}
u := &url.URL{
Path: request.Path, // NOTE: this could be either /label or /label/{name}/values endpoint. So forward the original path as it is.
Path: request.Path(), // NOTE: this could be either /label or /label/{name}/values endpoint. So forward the original path as it is.
RawQuery: params.Encode(),
}
req := &http.Request{
@ -537,14 +573,14 @@ func decodeResponseJSON(r *http.Response, req queryrangebase.Request) (queryrang
Data: data,
Headers: httpResponseHeadersToPromResponseHeaders(r.Header),
}, nil
case *LokiLabelNamesRequest:
case *LabelRequest:
var resp loghttp.LabelResponse
if err := json.Unmarshal(buf, &resp); err != nil {
return nil, httpgrpc.Errorf(http.StatusInternalServerError, "error decoding response: %v", err)
}
return &LokiLabelNamesResponse{
Status: resp.Status,
Version: uint32(loghttp.GetVersion(req.Path)),
Version: uint32(loghttp.GetVersion(req.Path())),
Data: resp.Data,
Headers: httpResponseHeadersToPromResponseHeaders(r.Header),
}, nil
@ -669,7 +705,7 @@ func decodeResponseProtobuf(r *http.Response, req queryrangebase.Request) (query
switch req.(type) {
case *LokiSeriesRequest:
return resp.GetSeries().WithHeaders(headers), nil
case *LokiLabelNamesRequest:
case *LabelRequest:
return resp.GetLabels().WithHeaders(headers), nil
case *logproto.IndexStatsRequest:
return resp.GetStats().WithHeaders(headers), nil
@ -1137,9 +1173,9 @@ func paramsFromRequest(req queryrangebase.Request) (logql.Params, error) {
return &paramsSeriesWrapper{
LokiSeriesRequest: r,
}, nil
case *LokiLabelNamesRequest:
return &paramsLabelNamesWrapper{
LokiLabelNamesRequest: r,
case *LabelRequest:
return &paramsLabelWrapper{
LabelRequest: r,
}, nil
default:
return nil, fmt.Errorf("expected one of the *LokiRequest, *LokiInstantRequest, *LokiSeriesRequest, *LokiLabelNamesRequest, got (%T)", r)
@ -1232,31 +1268,31 @@ func (p paramsSeriesWrapper) Shards() []string {
return p.GetShards()
}
type paramsLabelNamesWrapper struct {
*LokiLabelNamesRequest
type paramsLabelWrapper struct {
*LabelRequest
}
func (p paramsLabelNamesWrapper) Query() string {
func (p paramsLabelWrapper) Query() string {
return p.GetQuery()
}
func (p paramsLabelNamesWrapper) Start() time.Time {
return p.LokiLabelNamesRequest.GetStartTs()
func (p paramsLabelWrapper) Start() time.Time {
return p.LabelRequest.GetStartTs()
}
func (p paramsLabelNamesWrapper) End() time.Time {
return p.LokiLabelNamesRequest.GetEndTs()
func (p paramsLabelWrapper) End() time.Time {
return p.LabelRequest.GetEndTs()
}
func (p paramsLabelNamesWrapper) Step() time.Duration {
func (p paramsLabelWrapper) Step() time.Duration {
return time.Duration(p.GetStep() * 1e6)
}
func (p paramsLabelNamesWrapper) Interval() time.Duration { return 0 }
func (p paramsLabelNamesWrapper) Direction() logproto.Direction {
func (p paramsLabelWrapper) Interval() time.Duration { return 0 }
func (p paramsLabelWrapper) Direction() logproto.Direction {
return logproto.FORWARD
}
func (p paramsLabelNamesWrapper) Limit() uint32 { return 0 }
func (p paramsLabelNamesWrapper) Shards() []string {
func (p paramsLabelWrapper) Limit() uint32 { return 0 }
func (p paramsLabelWrapper) Shards() []string {
return make([]string, 0)
}
@ -1281,10 +1317,10 @@ func NewEmptyResponse(r queryrangebase.Request) (queryrangebase.Response, error)
Status: loghttp.QueryStatusSuccess,
Version: uint32(loghttp.GetVersion(req.Path)),
}, nil
case *LokiLabelNamesRequest:
case *LabelRequest:
return &LokiLabelNamesResponse{
Status: loghttp.QueryStatusSuccess,
Version: uint32(loghttp.GetVersion(req.Path)),
Version: uint32(loghttp.GetVersion(req.Path())),
}, nil
case *LokiInstantRequest:
// instant queries in the frontend are always metrics queries.

66
pkg/querier/queryrange/codec_test.go
Unescape View File

@ -13,6 +13,7 @@ import (
"testing"
"time"
"github.com/gorilla/mux"
"github.com/prometheus/common/model"
"github.com/prometheus/prometheus/model/labels"
"github.com/prometheus/prometheus/promql"
@ -82,20 +83,15 @@ func Test_codec_EncodeDecodeRequest(t *testing.T) {
{"labels", func() (*http.Request, error) {
return http.NewRequest(http.MethodGet,
fmt.Sprintf(`/label?start=%d&end=%d`, start.UnixNano(), end.UnixNano()), nil)
}, &LokiLabelNamesRequest{
Path: "/label",
StartTs: start,
EndTs: end,
}, false},
}, NewLabelRequest(start, end, "", "", "/label"),
false},
{"label_values", func() (*http.Request, error) {
return http.NewRequest(http.MethodGet,
req, err := http.NewRequest(http.MethodGet,
fmt.Sprintf(`/label/test/values?start=%d&end=%d&query={foo="bar"}`, start.UnixNano(), end.UnixNano()), nil)
}, &LokiLabelNamesRequest{
Path: "/label/test/values",
StartTs: start,
EndTs: end,
Query: `{foo="bar"}`,
}, false},
req = mux.SetURLVars(req, map[string]string{"name": "test"})
return req, err
}, NewLabelRequest(start, end, `{foo="bar"}`, "test", "/label/test/values"),
false},
{"index_stats", func() (*http.Request, error) {
return DefaultCodec.EncodeRequest(context.Background(), &logproto.IndexStatsRequest{
From: model.TimeFromUnixNano(start.UnixNano()),
@ -180,6 +176,7 @@ func Test_codec_EncodeDecodeRequest(t *testing.T) {
if err != nil {
t.Fatal(err)
}
// TODO: context must save mux vars
got, err := DefaultCodec.DecodeRequest(context.TODO(), req, nil)
if (err != nil) != tt.wantErr {
t.Errorf("codec.DecodeRequest() error = %v, wantErr %v", err, tt.wantErr)
@ -287,7 +284,7 @@ func Test_codec_DecodeResponse(t *testing.T) {
},
{
"labels legacy", &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(labelsString))},
&LokiLabelNamesRequest{Path: "/api/prom/label"},
NewLabelRequest(time.Now(), time.Now(), "", "", "/api/prom/label"),
&LokiLabelNamesResponse{
Status: "success",
Version: uint32(loghttp.VersionLegacy),
@ -626,11 +623,7 @@ func Test_codec_series_EncodeRequest(t *testing.T) {
func Test_codec_labels_EncodeRequest(t *testing.T) {
ctx := context.Background()
toEncode := &LokiLabelNamesRequest{
Path: "/loki/api/v1/labels",
StartTs: start,
EndTs: end,
}
toEncode := NewLabelRequest(start, end, "", "", "/loki/api/v1/labels")
got, err := DefaultCodec.EncodeRequest(ctx, toEncode)
require.NoError(t, err)
require.Equal(t, ctx, got.Context())
@ -641,51 +634,48 @@ func Test_codec_labels_EncodeRequest(t *testing.T) {
// testing a full roundtrip
req, err := DefaultCodec.DecodeRequest(context.TODO(), got, nil)
require.NoError(t, err)
require.Equal(t, toEncode.StartTs, req.(*LokiLabelNamesRequest).StartTs)
require.Equal(t, toEncode.EndTs, req.(*LokiLabelNamesRequest).EndTs)
require.Equal(t, "/loki/api/v1/labels", req.(*LokiLabelNamesRequest).Path)
require.Equal(t, toEncode.Start, req.(*LabelRequest).Start)
require.Equal(t, toEncode.End, req.(*LabelRequest).End)
require.Equal(t, "/loki/api/v1/labels", req.(*LabelRequest).Path())
// Test labels values endpoint
toEncode = &LokiLabelNamesRequest{
Path: "/loki/api/v1/labels/__name__/values",
StartTs: start,
EndTs: end,
Query: `{foo="bar"}`,
}
toEncode = NewLabelRequest(start, end, `{foo="bar"}`, "__name__", "/loki/api/v1/label/__name__/values")
got, err = DefaultCodec.EncodeRequest(ctx, toEncode)
require.NoError(t, err)
require.Equal(t, ctx, got.Context())
require.Equal(t, "/loki/api/v1/labels/__name__/values", got.URL.Path)
require.Equal(t, "/loki/api/v1/label/__name__/values", got.URL.Path)
require.Equal(t, fmt.Sprintf("%d", start.UnixNano()), got.URL.Query().Get("start"))
require.Equal(t, fmt.Sprintf("%d", end.UnixNano()), got.URL.Query().Get("end"))
require.Equal(t, `{foo="bar"}`, got.URL.Query().Get("query"))
// testing a full roundtrip
got = mux.SetURLVars(got, map[string]string{"name": "__name__"})
req, err = DefaultCodec.DecodeRequest(context.TODO(), got, nil)
require.NoError(t, err)
require.Equal(t, toEncode.StartTs, req.(*LokiLabelNamesRequest).StartTs)
require.Equal(t, toEncode.EndTs, req.(*LokiLabelNamesRequest).EndTs)
require.Equal(t, toEncode.Query, req.(*LokiLabelNamesRequest).Query)
require.Equal(t, "/loki/api/v1/labels/__name__/values", req.(*LokiLabelNamesRequest).Path)
require.Equal(t, toEncode.Start, req.(*LabelRequest).Start)
require.Equal(t, toEncode.End, req.(*LabelRequest).End)
require.Equal(t, toEncode.Query, req.(*LabelRequest).Query)
require.Equal(t, "/loki/api/v1/label/__name__/values", req.(*LabelRequest).Path())
}
func Test_codec_labels_DecodeRequest(t *testing.T) {
ctx := context.Background()
u, err := url.Parse(`/loki/api/v1/labels/__name__/values?start=1575285010000000010&end=1575288610000000010&query={foo="bar"}`)
u, err := url.Parse(`/loki/api/v1/label/__name__/values?start=1575285010000000010&end=1575288610000000010&query={foo="bar"}`)
require.NoError(t, err)
r := &http.Request{URL: u}
r = mux.SetURLVars(r, map[string]string{"name": "__name__"})
req, err := DefaultCodec.DecodeRequest(context.TODO(), r, nil)
require.NoError(t, err)
require.Equal(t, start, req.(*LokiLabelNamesRequest).StartTs)
require.Equal(t, end, req.(*LokiLabelNamesRequest).EndTs)
require.Equal(t, `{foo="bar"}`, req.(*LokiLabelNamesRequest).Query)
require.Equal(t, "/loki/api/v1/labels/__name__/values", req.(*LokiLabelNamesRequest).Path)
require.Equal(t, start, *req.(*LabelRequest).Start)
require.Equal(t, end, *req.(*LabelRequest).End)
require.Equal(t, `{foo="bar"}`, req.(*LabelRequest).Query)
require.Equal(t, "/loki/api/v1/label/__name__/values", req.(*LabelRequest).Path())
got, err := DefaultCodec.EncodeRequest(ctx, req)
require.NoError(t, err)
require.Equal(t, ctx, got.Context())
require.Equal(t, "/loki/api/v1/labels/__name__/values", got.URL.Path)
require.Equal(t, "/loki/api/v1/label/__name__/values", got.URL.Path)
require.Equal(t, fmt.Sprintf("%d", start.UnixNano()), got.URL.Query().Get("start"))
require.Equal(t, fmt.Sprintf("%d", end.UnixNano()), got.URL.Query().Get("end"))
require.Equal(t, `{foo="bar"}`, got.URL.Query().Get("query"))

562
pkg/querier/queryrange/queryrange.pb.go
Unescape View File

@ -470,73 +470,6 @@ func (m *LokiSeriesResponse) GetStatistics() stats.Result {
return stats.Result{}
}
type LokiLabelNamesRequest struct {
StartTs time.Time `protobuf:"bytes,1,opt,name=startTs,proto3,stdtime" json:"startTs"`
EndTs time.Time `protobuf:"bytes,2,opt,name=endTs,proto3,stdtime" json:"endTs"`
Path string `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
Query string `protobuf:"bytes,4,opt,name=query,proto3" json:"query,omitempty"`
}
func (m *LokiLabelNamesRequest) Reset() { *m = LokiLabelNamesRequest{} }
func (*LokiLabelNamesRequest) ProtoMessage() {}
func (*LokiLabelNamesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_51b9d53b40d11902, []int{5}
}
func (m *LokiLabelNamesRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *LokiLabelNamesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_LokiLabelNamesRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *LokiLabelNamesRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_LokiLabelNamesRequest.Merge(m, src)
}
func (m *LokiLabelNamesRequest) XXX_Size() int {
return m.Size()
}
func (m *LokiLabelNamesRequest) XXX_DiscardUnknown() {
xxx_messageInfo_LokiLabelNamesRequest.DiscardUnknown(m)
}
var xxx_messageInfo_LokiLabelNamesRequest proto.InternalMessageInfo
func (m *LokiLabelNamesRequest) GetStartTs() time.Time {
if m != nil {
return m.StartTs
}
return time.Time{}
}
func (m *LokiLabelNamesRequest) GetEndTs() time.Time {
if m != nil {
return m.EndTs
}
return time.Time{}
}
func (m *LokiLabelNamesRequest) GetPath() string {
if m != nil {
return m.Path
}
return ""
}
func (m *LokiLabelNamesRequest) GetQuery() string {
if m != nil {
return m.Query
}
return ""
}
type LokiLabelNamesResponse struct {
Status string `protobuf:"bytes,1,opt,name=Status,proto3" json:"status"`
Data []string `protobuf:"bytes,2,rep,name=Data,proto3" json:"data,omitempty"`
@ -548,7 +481,7 @@ type LokiLabelNamesResponse struct {
func (m *LokiLabelNamesResponse) Reset() { *m = LokiLabelNamesResponse{} }
func (*LokiLabelNamesResponse) ProtoMessage() {}
func (*LokiLabelNamesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_51b9d53b40d11902, []int{6}
return fileDescriptor_51b9d53b40d11902, []int{5}
}
func (m *LokiLabelNamesResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -613,7 +546,7 @@ type LokiData struct {
func (m *LokiData) Reset() { *m = LokiData{} }
func (*LokiData) ProtoMessage() {}
func (*LokiData) Descriptor() ([]byte, []int) {
return fileDescriptor_51b9d53b40d11902, []int{7}
return fileDescriptor_51b9d53b40d11902, []int{6}
}
func (m *LokiData) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -658,7 +591,7 @@ type LokiPromResponse struct {
func (m *LokiPromResponse) Reset() { *m = LokiPromResponse{} }
func (*LokiPromResponse) ProtoMessage() {}
func (*LokiPromResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_51b9d53b40d11902, []int{8}
return fileDescriptor_51b9d53b40d11902, []int{7}
}
func (m *LokiPromResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -709,7 +642,7 @@ type IndexStatsResponse struct {
func (m *IndexStatsResponse) Reset() { *m = IndexStatsResponse{} }
func (*IndexStatsResponse) ProtoMessage() {}
func (*IndexStatsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_51b9d53b40d11902, []int{9}
return fileDescriptor_51b9d53b40d11902, []int{8}
}
func (m *IndexStatsResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -746,7 +679,7 @@ type VolumeResponse struct {
func (m *VolumeResponse) Reset() { *m = VolumeResponse{} }
func (*VolumeResponse) ProtoMessage() {}
func (*VolumeResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_51b9d53b40d11902, []int{10}
return fileDescriptor_51b9d53b40d11902, []int{9}
}
func (m *VolumeResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -783,7 +716,7 @@ type TopKSketchesResponse struct {
func (m *TopKSketchesResponse) Reset() { *m = TopKSketchesResponse{} }
func (*TopKSketchesResponse) ProtoMessage() {}
func (*TopKSketchesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_51b9d53b40d11902, []int{11}
return fileDescriptor_51b9d53b40d11902, []int{10}
}
func (m *TopKSketchesResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -820,7 +753,7 @@ type QuantileSketchResponse struct {
func (m *QuantileSketchResponse) Reset() { *m = QuantileSketchResponse{} }
func (*QuantileSketchResponse) ProtoMessage() {}
func (*QuantileSketchResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_51b9d53b40d11902, []int{12}
return fileDescriptor_51b9d53b40d11902, []int{11}
}
func (m *QuantileSketchResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -865,7 +798,7 @@ type QueryResponse struct {
func (m *QueryResponse) Reset() { *m = QueryResponse{} }
func (*QueryResponse) ProtoMessage() {}
func (*QueryResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_51b9d53b40d11902, []int{13}
return fileDescriptor_51b9d53b40d11902, []int{12}
}
func (m *QueryResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1018,7 +951,6 @@ func init() {
proto.RegisterType((*LokiResponse)(nil), "queryrange.LokiResponse")
proto.RegisterType((*LokiSeriesRequest)(nil), "queryrange.LokiSeriesRequest")
proto.RegisterType((*LokiSeriesResponse)(nil), "queryrange.LokiSeriesResponse")
proto.RegisterType((*LokiLabelNamesRequest)(nil), "queryrange.LokiLabelNamesRequest")
proto.RegisterType((*LokiLabelNamesResponse)(nil), "queryrange.LokiLabelNamesResponse")
proto.RegisterType((*LokiData)(nil), "queryrange.LokiData")
proto.RegisterType((*LokiPromResponse)(nil), "queryrange.LokiPromResponse")
@ -1034,88 +966,86 @@ func init() {
}
var fileDescriptor_51b9d53b40d11902 = []byte{
// 1283 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x57, 0x4d, 0x6f, 0x1b, 0x45,
0x18, 0xde, 0xf1, 0x57, 0xe2, 0x49, 0x1b, 0xca, 0x24, 0xb4, 0x4b, 0xa8, 0x76, 0x2d, 0x4b, 0x50,
0x23, 0x81, 0x2d, 0x92, 0xd2, 0x52, 0xbe, 0x44, 0x97, 0x52, 0xa5, 0xa2, 0xa0, 0x76, 0x1b, 0x71,
0x1f, 0xc7, 0x13, 0x7b, 0xf1, 0x7e, 0x65, 0x67, 0x5c, 0x35, 0x37, 0x2e, 0xdc, 0x40, 0xea, 0xaf,
0x40, 0x48, 0x54, 0xfc, 0x00, 0x24, 0x2e, 0x9c, 0x7a, 0xcc, 0xb1, 0xb2, 0xc4, 0x42, 0xdd, 0x0b,
0xe4, 0xd4, 0x9f, 0x80, 0x66, 0x66, 0x77, 0x3d, 0x6b, 0xbb, 0xad, 0xdd, 0x5e, 0x1a, 0x89, 0x8b,
0x3d, 0x1f, 0xef, 0x33, 0x3b, 0xef, 0x33, 0xcf, 0xfb, 0xbe, 0x33, 0xf0, 0x5c, 0xd8, 0xef, 0xb6,
0xf6, 0x07, 0x24, 0x72, 0x48, 0x24, 0xfe, 0x0f, 0x22, 0xec, 0x77, 0x89, 0xd2, 0x6c, 0x86, 0x51,
0xc0, 0x02, 0x04, 0xc7, 0x23, 0x1b, 0xeb, 0xdd, 0xa0, 0x1b, 0x88, 0xe1, 0x16, 0x6f, 0x49, 0x8b,
0x0d, 0xb3, 0x1b, 0x04, 0x5d, 0x97, 0xb4, 0x44, 0xaf, 0x3d, 0xd8, 0x6b, 0x31, 0xc7, 0x23, 0x94,
0x61, 0x2f, 0x4c, 0x0c, 0xde, 0xe0, 0xdf, 0x72, 0x83, 0xae, 0x44, 0xa6, 0x8d, 0x64, 0xf2, 0xf5,
0xdc, 0x24, 0xed, 0x13, 0xb6, 0xdb, 0x4b, 0xa6, 0x6a, 0xc9, 0xd4, 0xbe, 0xeb, 0x05, 0x1d, 0xe2,
0xb6, 0x28, 0xc3, 0x8c, 0xca, 0xdf, 0xc4, 0x62, 0x8d, 0x5b, 0x84, 0x03, 0xda, 0x13, 0x3f, 0xc9,
0xe0, 0xe7, 0xcf, 0x74, 0xad, 0x8d, 0x29, 0x69, 0x75, 0xc8, 0x9e, 0xe3, 0x3b, 0xcc, 0x09, 0x7c,
0xaa, 0xb6, 0x93, 0x45, 0x2e, 0xcc, 0xb7, 0xc8, 0x24, 0x5d, 0xf5, 0xc3, 0x02, 0x5c, 0xb9, 0x1e,
0xf4, 0x1d, 0x9b, 0xec, 0x0f, 0x08, 0x65, 0x68, 0x1d, 0x96, 0x85, 0x8d, 0x0e, 0x6a, 0xa0, 0x51,
0xb5, 0x65, 0x87, 0x8f, 0xba, 0x8e, 0xe7, 0x30, 0xbd, 0x50, 0x03, 0x8d, 0x93, 0xb6, 0xec, 0x20,
0x04, 0x4b, 0x94, 0x91, 0x50, 0x2f, 0xd6, 0x40, 0xa3, 0x68, 0x8b, 0x36, 0xda, 0x80, 0xcb, 0x8e,
0xcf, 0x48, 0x74, 0x1b, 0xbb, 0x7a, 0x55, 0x8c, 0x67, 0x7d, 0xf4, 0x29, 0x5c, 0xa2, 0x0c, 0x47,
0x6c, 0x87, 0xea, 0xa5, 0x1a, 0x68, 0xac, 0x6c, 0x6e, 0x34, 0xe5, 0x51, 0x34, 0xd3, 0xa3, 0x68,
0xee, 0xa4, 0x47, 0x61, 0x2d, 0xdf, 0x8f, 0x4d, 0xed, 0xee, 0x5f, 0x26, 0xb0, 0x53, 0x10, 0xfa,
0x10, 0x96, 0x89, 0xdf, 0xd9, 0xa1, 0x7a, 0x79, 0x01, 0xb4, 0x84, 0xa0, 0xf7, 0x60, 0xb5, 0xe3,
0x44, 0x64, 0x97, 0x73, 0xa6, 0x57, 0x6a, 0xa0, 0xb1, 0xba, 0xb9, 0xd6, 0xcc, 0x8e, 0xf6, 0x4a,
0x3a, 0x65, 0x8f, 0xad, 0xb8, 0x7b, 0x21, 0x66, 0x3d, 0x7d, 0x49, 0x30, 0x21, 0xda, 0xa8, 0x0e,
0x2b, 0xb4, 0x87, 0xa3, 0x0e, 0xd5, 0x97, 0x6b, 0xc5, 0x46, 0xd5, 0x82, 0x47, 0xb1, 0x99, 0x8c,
0xd8, 0xc9, 0x7f, 0xfd, 0x5f, 0x00, 0x11, 0xa7, 0xf4, 0x9a, 0x4f, 0x19, 0xf6, 0xd9, 0xf3, 0x30,
0xfb, 0x31, 0xac, 0x70, 0x51, 0xee, 0x50, 0xc1, 0xed, 0xbc, 0xae, 0x26, 0x98, 0xbc, 0xaf, 0xa5,
0x85, 0x7c, 0x2d, 0xcf, 0xf4, 0xb5, 0xf2, 0x44, 0x5f, 0x7f, 0x29, 0xc1, 0x13, 0x52, 0x3e, 0x34,
0x0c, 0x7c, 0x4a, 0x38, 0xe8, 0x16, 0xc3, 0x6c, 0x40, 0xa5, 0x9b, 0x09, 0x48, 0x8c, 0xd8, 0xc9,
0x0c, 0xfa, 0x0c, 0x96, 0xae, 0x60, 0x86, 0x85, 0xcb, 0x2b, 0x9b, 0xeb, 0x4d, 0x45, 0x94, 0x7c,
0x2d, 0x3e, 0x67, 0x9d, 0xe6, 0x5e, 0x1d, 0xc5, 0xe6, 0x6a, 0x07, 0x33, 0xfc, 0x4e, 0xe0, 0x39,
0x8c, 0x78, 0x21, 0x3b, 0xb0, 0x05, 0x12, 0xbd, 0x0f, 0xab, 0x5f, 0x44, 0x51, 0x10, 0xed, 0x1c,
0x84, 0x44, 0x50, 0x54, 0xb5, 0xce, 0x1c, 0xc5, 0xe6, 0x1a, 0x49, 0x07, 0x15, 0xc4, 0xd8, 0x12,
0xbd, 0x0d, 0xcb, 0xa2, 0x23, 0x48, 0xa9, 0x5a, 0x6b, 0x47, 0xb1, 0xf9, 0x8a, 0x80, 0x28, 0xe6,
0xd2, 0x22, 0xcf, 0x61, 0x79, 0x2e, 0x0e, 0xb3, 0xa3, 0xac, 0xa8, 0x47, 0xa9, 0xc3, 0xa5, 0xdb,
0x24, 0xa2, 0x7c, 0x99, 0x25, 0x31, 0x9e, 0x76, 0xd1, 0x65, 0x08, 0x39, 0x31, 0x0e, 0x65, 0xce,
0x2e, 0xd7, 0x13, 0x27, 0xe3, 0x64, 0x53, 0xa6, 0x0b, 0x9b, 0xd0, 0x81, 0xcb, 0x2c, 0x94, 0xb0,
0xa0, 0x18, 0xda, 0x4a, 0x1b, 0xdd, 0x03, 0x70, 0x69, 0x9b, 0xe0, 0x0e, 0x89, 0xa8, 0x5e, 0xad,
0x15, 0x1b, 0x2b, 0x9b, 0x6f, 0x36, 0xd5, 0xdc, 0x70, 0x23, 0x0a, 0x3c, 0xc2, 0x7a, 0x64, 0x40,
0xd3, 0x03, 0x92, 0xd6, 0x56, 0x7f, 0x18, 0x9b, 0xed, 0xae, 0xc3, 0x7a, 0x83, 0x76, 0x73, 0x37,
0xf0, 0x5a, 0xdd, 0x08, 0xef, 0x61, 0x1f, 0xb7, 0xdc, 0xa0, 0xef, 0xb4, 0x16, 0xce, 0x47, 0x4f,
0xfc, 0xce, 0x51, 0x6c, 0x82, 0x77, 0xed, 0x74, 0x8b, 0xf5, 0x3f, 0x01, 0x7c, 0x95, 0x9f, 0xf0,
0x2d, 0xbe, 0x36, 0x55, 0x02, 0xc3, 0xc3, 0x6c, 0xb7, 0xa7, 0x03, 0x2e, 0x33, 0x5b, 0x76, 0xd4,
0x64, 0x51, 0x78, 0xa1, 0x64, 0x51, 0x5c, 0x3c, 0x59, 0xa4, 0xd1, 0x50, 0x9a, 0x19, 0x0d, 0xe5,
0x27, 0x46, 0xc3, 0x0f, 0x45, 0x19, 0xf9, 0xa9, 0x7f, 0x0b, 0xc4, 0xc4, 0xd5, 0x2c, 0x26, 0x8a,
0x62, 0xb7, 0x99, 0xd4, 0xe4, 0x5a, 0xd7, 0x3a, 0xc4, 0x67, 0xce, 0x9e, 0x43, 0xa2, 0x67, 0x44,
0x86, 0x22, 0xb7, 0x62, 0x5e, 0x6e, 0xaa, 0x56, 0x4a, 0x2f, 0xbd, 0x56, 0x26, 0xa2, 0xa3, 0xfc,
0x1c, 0xd1, 0x51, 0xff, 0x1d, 0xc0, 0xd7, 0xf8, 0x71, 0x5c, 0xc7, 0x6d, 0xe2, 0x7e, 0x8d, 0xbd,
0xb1, 0xe4, 0x14, 0x71, 0x81, 0x17, 0x12, 0x57, 0xe1, 0xf9, 0xc5, 0x55, 0x54, 0xc4, 0x95, 0xd5,
0x86, 0x92, 0x52, 0x1b, 0xea, 0x8f, 0x0b, 0xf0, 0xf4, 0xe4, 0xfe, 0x17, 0x90, 0xd4, 0x5b, 0x8a,
0xa4, 0xaa, 0x16, 0xfa, 0x5f, 0x32, 0x73, 0x48, 0xe6, 0x27, 0x00, 0x97, 0xd3, 0x1a, 0x84, 0x9a,
0x10, 0x4a, 0x98, 0x28, 0x33, 0x92, 0xe8, 0x55, 0x0e, 0x8e, 0xb2, 0x51, 0x5b, 0xb1, 0x40, 0xdf,
0xc2, 0x8a, 0xec, 0x25, 0x51, 0x7c, 0x46, 0x89, 0x62, 0x16, 0x11, 0xec, 0x5d, 0xee, 0xe0, 0x90,
0x91, 0xc8, 0xba, 0xc4, 0x77, 0x31, 0x8c, 0xcd, 0x73, 0x4f, 0xa3, 0x48, 0xdc, 0x10, 0x25, 0x8e,
0x1f, 0xae, 0xfc, 0xa6, 0x9d, 0x7c, 0xa1, 0xfe, 0x23, 0x80, 0xa7, 0xf8, 0x46, 0x39, 0x35, 0x99,
0x2a, 0xae, 0xc0, 0xe5, 0x28, 0x69, 0x27, 0xba, 0xae, 0x37, 0xf3, 0xb4, 0xce, 0xa0, 0xd2, 0x2a,
0xdd, 0x8f, 0x4d, 0x60, 0x67, 0x48, 0xb4, 0x95, 0xa3, 0xb1, 0x30, 0x8b, 0x46, 0x0e, 0xd1, 0x72,
0xc4, 0xfd, 0x56, 0x80, 0xe8, 0x9a, 0xdf, 0x21, 0x77, 0xb8, 0xf8, 0xc6, 0x3a, 0x1d, 0x4c, 0xed,
0xe8, 0xec, 0x98, 0x94, 0x69, 0x7b, 0xeb, 0xa3, 0x61, 0x6c, 0x5e, 0x7c, 0x1a, 0x2b, 0x4f, 0x01,
0x2b, 0x2e, 0xa8, 0xc2, 0x2d, 0xbc, 0xfc, 0x75, 0xf1, 0xd7, 0x02, 0x5c, 0xfd, 0x26, 0x70, 0x07,
0x1e, 0xc9, 0x88, 0xf3, 0xa6, 0x88, 0xd3, 0xc7, 0xc4, 0xe5, 0x6d, 0xad, 0x8b, 0xc3, 0xd8, 0xdc,
0x9a, 0x8b, 0xb4, 0x3c, 0xf0, 0xf8, 0x12, 0x76, 0xaf, 0x00, 0xd7, 0x77, 0x82, 0xf0, 0xcb, 0x5b,
0xe2, 0xf9, 0xa5, 0xe4, 0x45, 0x32, 0x45, 0xdb, 0xfa, 0x98, 0x36, 0x8e, 0xf8, 0x0a, 0xb3, 0xc8,
0xb9, 0x63, 0x6d, 0x0d, 0x63, 0xb3, 0x35, 0x17, 0x65, 0x63, 0xd0, 0xf1, 0xa5, 0xeb, 0x8f, 0x02,
0x3c, 0x7d, 0x73, 0x80, 0x7d, 0xe6, 0xb8, 0x44, 0x52, 0x96, 0x11, 0x76, 0x30, 0x45, 0x98, 0x31,
0x26, 0x2c, 0x8f, 0x49, 0xa8, 0xfb, 0x64, 0x18, 0x9b, 0x97, 0xe6, 0xa2, 0x6e, 0x16, 0xfc, 0xf8,
0x92, 0xf8, 0x7d, 0x09, 0x9e, 0xbc, 0xc9, 0x57, 0xc9, 0xb8, 0xfb, 0x00, 0x56, 0xa8, 0xb8, 0x9d,
0x65, 0xcc, 0x4d, 0xbc, 0x64, 0xf2, 0xf7, 0xc0, 0x6d, 0xcd, 0x4e, 0xec, 0xf9, 0xfb, 0xce, 0xe5,
0x45, 0x3d, 0x4d, 0xaf, 0xf5, 0x49, 0xe4, 0x74, 0xc9, 0xe7, 0x68, 0x89, 0x41, 0x17, 0x60, 0x59,
0x64, 0xe3, 0xe4, 0x6a, 0x9b, 0xfb, 0xec, 0x74, 0x5a, 0xdc, 0xd6, 0x6c, 0x69, 0x8e, 0x36, 0x61,
0x29, 0x8c, 0x02, 0x2f, 0x79, 0x7c, 0x9f, 0x9d, 0xfc, 0xa6, 0x5a, 0x4a, 0xb6, 0x35, 0x5b, 0xd8,
0xa2, 0xf3, 0xfc, 0xa6, 0xc4, 0x6b, 0x50, 0x5a, 0x50, 0xf5, 0x49, 0x98, 0x02, 0x49, 0x4d, 0xd1,
0x79, 0x58, 0xb9, 0x2d, 0x52, 0x8d, 0x78, 0x0b, 0xf1, 0x0b, 0x92, 0x02, 0xca, 0x27, 0x21, 0xee,
0x97, 0xb4, 0x45, 0x57, 0xe1, 0x09, 0x16, 0x84, 0xfd, 0x34, 0xa8, 0xc5, 0x7b, 0x69, 0x65, 0xb3,
0xa6, 0x62, 0x67, 0x05, 0xfd, 0xb6, 0x66, 0xe7, 0x70, 0xe8, 0x06, 0x3c, 0xb5, 0x9f, 0x93, 0x1e,
0x49, 0x9f, 0x57, 0x39, 0x9e, 0x67, 0x47, 0xc4, 0xb6, 0x66, 0x4f, 0xa1, 0x2d, 0x38, 0x8e, 0x12,
0xeb, 0xfc, 0xe1, 0x43, 0x43, 0x7b, 0xf0, 0xd0, 0xd0, 0x1e, 0x3f, 0x34, 0xc0, 0x77, 0x23, 0x03,
0xfc, 0x3c, 0x32, 0xc0, 0xfd, 0x91, 0x01, 0x0e, 0x47, 0x06, 0xf8, 0x7b, 0x64, 0x80, 0x7f, 0x46,
0x86, 0xf6, 0x78, 0x64, 0x80, 0xbb, 0x8f, 0x0c, 0xed, 0xf0, 0x91, 0xa1, 0x3d, 0x78, 0x64, 0x68,
0xed, 0x8a, 0x08, 0x89, 0xad, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x19, 0xf8, 0x4d, 0xef, 0xc8,
0x12, 0x00, 0x00,
// 1257 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x97, 0xcd, 0x6f, 0x1b, 0xc5,
0x1b, 0xc7, 0x77, 0xfd, 0x96, 0x78, 0xdc, 0xe6, 0xd7, 0xdf, 0x24, 0x6a, 0x97, 0x50, 0xed, 0x5a,
0x96, 0xa0, 0x46, 0x02, 0x5b, 0x38, 0xa5, 0xa5, 0xbc, 0x89, 0x2e, 0xa1, 0x72, 0x44, 0x41, 0xed,
0xc6, 0xe2, 0x3e, 0x8e, 0x27, 0xf6, 0xe2, 0x7d, 0xcb, 0xce, 0x38, 0x6a, 0x6e, 0x5c, 0xb8, 0x81,
0xd4, 0xbf, 0x02, 0x21, 0x51, 0xf1, 0x07, 0x70, 0xe4, 0x94, 0x63, 0x8e, 0x95, 0x25, 0x16, 0xe2,
0x5c, 0x20, 0xa7, 0xfc, 0x09, 0x68, 0x66, 0x76, 0xd7, 0xbb, 0xb6, 0x93, 0xda, 0xe5, 0xd2, 0x48,
0x5c, 0xec, 0x79, 0x79, 0xbe, 0xb3, 0xfb, 0x7c, 0xe6, 0x79, 0x9e, 0x9d, 0x01, 0xb7, 0xbc, 0x7e,
0xb7, 0xbe, 0x37, 0xc0, 0xbe, 0x89, 0x7d, 0xfe, 0x7f, 0xe0, 0x23, 0xa7, 0x8b, 0x13, 0xcd, 0x9a,
0xe7, 0xbb, 0xd4, 0x85, 0x60, 0x3c, 0xb2, 0xbe, 0xd6, 0x75, 0xbb, 0x2e, 0x1f, 0xae, 0xb3, 0x96,
0xb0, 0x58, 0xd7, 0xba, 0xae, 0xdb, 0xb5, 0x70, 0x9d, 0xf7, 0xda, 0x83, 0xdd, 0x3a, 0x35, 0x6d,
0x4c, 0x28, 0xb2, 0xbd, 0xd0, 0xe0, 0x75, 0xf6, 0x2c, 0xcb, 0xed, 0x0a, 0x65, 0xd4, 0x08, 0x27,
0x5f, 0x4b, 0x4d, 0x92, 0x3e, 0xa6, 0x3b, 0xbd, 0x70, 0xaa, 0x1c, 0x4e, 0xed, 0x59, 0xb6, 0xdb,
0xc1, 0x56, 0x9d, 0x50, 0x44, 0x89, 0xf8, 0x0d, 0x2d, 0x56, 0x99, 0x85, 0x37, 0x20, 0x3d, 0xfe,
0x13, 0x0e, 0x7e, 0xf6, 0x42, 0xd7, 0xda, 0x88, 0xe0, 0x7a, 0x07, 0xef, 0x9a, 0x8e, 0x49, 0x4d,
0xd7, 0x21, 0xc9, 0x76, 0xb8, 0xc8, 0x9d, 0xf9, 0x16, 0x99, 0xc4, 0x55, 0x39, 0xca, 0x80, 0xd2,
0x43, 0xb7, 0x6f, 0x1a, 0x78, 0x6f, 0x80, 0x09, 0x85, 0x6b, 0x20, 0xcf, 0x6d, 0x14, 0xb9, 0x2c,
0x57, 0x8b, 0x86, 0xe8, 0xb0, 0x51, 0xcb, 0xb4, 0x4d, 0xaa, 0x64, 0xca, 0x72, 0xf5, 0xaa, 0x21,
0x3a, 0x10, 0x82, 0x1c, 0xa1, 0xd8, 0x53, 0xb2, 0x65, 0xb9, 0x9a, 0x35, 0x78, 0x1b, 0xae, 0x83,
0x65, 0xd3, 0xa1, 0xd8, 0xdf, 0x47, 0x96, 0x52, 0xe4, 0xe3, 0x71, 0x1f, 0x7e, 0x02, 0x96, 0x08,
0x45, 0x3e, 0x6d, 0x11, 0x25, 0x57, 0x96, 0xab, 0xa5, 0xc6, 0x7a, 0x4d, 0x6c, 0x45, 0x2d, 0xda,
0x8a, 0x5a, 0x2b, 0xda, 0x0a, 0x7d, 0xf9, 0x30, 0xd0, 0xa4, 0xa7, 0x7f, 0x68, 0xb2, 0x11, 0x89,
0xe0, 0x07, 0x20, 0x8f, 0x9d, 0x4e, 0x8b, 0x28, 0xf9, 0x05, 0xd4, 0x42, 0x02, 0xdf, 0x05, 0xc5,
0x8e, 0xe9, 0xe3, 0x1d, 0xc6, 0x4c, 0x29, 0x94, 0xe5, 0xea, 0x4a, 0x63, 0xb5, 0x16, 0x6f, 0xed,
0x66, 0x34, 0x65, 0x8c, 0xad, 0x98, 0x7b, 0x1e, 0xa2, 0x3d, 0x65, 0x89, 0x93, 0xe0, 0x6d, 0x58,
0x01, 0x05, 0xd2, 0x43, 0x7e, 0x87, 0x28, 0xcb, 0xe5, 0x6c, 0xb5, 0xa8, 0x83, 0xd3, 0x40, 0x0b,
0x47, 0x8c, 0xf0, 0xbf, 0xf2, 0xb7, 0x0c, 0x20, 0x43, 0xba, 0xe5, 0x10, 0x8a, 0x1c, 0xfa, 0x32,
0x64, 0x3f, 0x02, 0x05, 0x16, 0x94, 0x2d, 0xc2, 0xd9, 0xce, 0xeb, 0x6a, 0xa8, 0x49, 0xfb, 0x9a,
0x5b, 0xc8, 0xd7, 0xfc, 0x4c, 0x5f, 0x0b, 0xe7, 0xfa, 0xfa, 0x73, 0x0e, 0x5c, 0x11, 0xe1, 0x43,
0x3c, 0xd7, 0x21, 0x98, 0x89, 0xb6, 0x29, 0xa2, 0x03, 0x22, 0xdc, 0x0c, 0x45, 0x7c, 0xc4, 0x08,
0x67, 0xe0, 0xa7, 0x20, 0xb7, 0x89, 0x28, 0xe2, 0x2e, 0x97, 0x1a, 0x6b, 0xb5, 0x44, 0x50, 0xb2,
0xb5, 0xd8, 0x9c, 0x7e, 0x9d, 0x79, 0x75, 0x1a, 0x68, 0x2b, 0x1d, 0x44, 0xd1, 0xdb, 0xae, 0x6d,
0x52, 0x6c, 0x7b, 0xf4, 0xc0, 0xe0, 0x4a, 0xf8, 0x1e, 0x28, 0x7e, 0xee, 0xfb, 0xae, 0xdf, 0x3a,
0xf0, 0x30, 0x47, 0x54, 0xd4, 0x6f, 0x9c, 0x06, 0xda, 0x2a, 0x8e, 0x06, 0x13, 0x8a, 0xb1, 0x25,
0x7c, 0x0b, 0xe4, 0x79, 0x87, 0x43, 0x29, 0xea, 0xab, 0xa7, 0x81, 0xf6, 0x3f, 0x2e, 0x49, 0x98,
0x0b, 0x8b, 0x34, 0xc3, 0xfc, 0x5c, 0x0c, 0xe3, 0xad, 0x2c, 0x24, 0xb7, 0x52, 0x01, 0x4b, 0xfb,
0xd8, 0x27, 0x6c, 0x99, 0x25, 0x3e, 0x1e, 0x75, 0xe1, 0x7d, 0x00, 0x18, 0x18, 0x93, 0x50, 0x73,
0x87, 0xc5, 0x13, 0x83, 0x71, 0xb5, 0x26, 0xca, 0x85, 0x81, 0xc9, 0xc0, 0xa2, 0x3a, 0x0c, 0x29,
0x24, 0x0c, 0x8d, 0x44, 0x1b, 0x3e, 0x93, 0xc1, 0x52, 0x13, 0xa3, 0x0e, 0xf6, 0x89, 0x52, 0x2c,
0x67, 0xab, 0xa5, 0xc6, 0x1b, 0xb5, 0x64, 0x6d, 0x78, 0xe4, 0xbb, 0x36, 0xa6, 0x3d, 0x3c, 0x20,
0xd1, 0x06, 0x09, 0x6b, 0xbd, 0x3f, 0x0c, 0xb4, 0x76, 0xd7, 0xa4, 0xbd, 0x41, 0xbb, 0xb6, 0xe3,
0xda, 0xf5, 0xae, 0x8f, 0x76, 0x91, 0x83, 0xea, 0x96, 0xdb, 0x37, 0xeb, 0x0b, 0xd7, 0xa3, 0x73,
0x9f, 0x73, 0x1a, 0x68, 0xf2, 0x3b, 0x46, 0xf4, 0x8a, 0x95, 0xdf, 0x65, 0xf0, 0x7f, 0xb6, 0xc3,
0xdb, 0x6c, 0x6d, 0x92, 0x48, 0x0c, 0x1b, 0xd1, 0x9d, 0x9e, 0x22, 0xb3, 0x30, 0x33, 0x44, 0x27,
0x59, 0x2c, 0x32, 0xff, 0xaa, 0x58, 0x64, 0x17, 0x2f, 0x16, 0x51, 0x36, 0xe4, 0x66, 0x66, 0x43,
0xfe, 0xdc, 0x6c, 0xf8, 0x3e, 0x2b, 0x32, 0x3f, 0xf2, 0x6f, 0x81, 0x9c, 0x78, 0x10, 0xe7, 0x44,
0x96, 0xbf, 0x6d, 0x1c, 0x6a, 0x62, 0xad, 0xad, 0x0e, 0x76, 0xa8, 0xb9, 0x6b, 0x62, 0xff, 0x05,
0x99, 0x91, 0x08, 0xb7, 0x6c, 0x3a, 0xdc, 0x92, 0xb1, 0x92, 0x7b, 0xe5, 0x63, 0x65, 0x22, 0x3b,
0xf2, 0x2f, 0x91, 0x1d, 0x95, 0xb3, 0x0c, 0xb8, 0xce, 0xb6, 0xe3, 0x21, 0x6a, 0x63, 0xeb, 0x2b,
0x64, 0x2f, 0xb8, 0x25, 0x6f, 0x26, 0xb6, 0xa4, 0xa8, 0xc3, 0xff, 0x90, 0xcf, 0x81, 0xfc, 0x47,
0x19, 0x2c, 0x47, 0x35, 0x1c, 0xd6, 0x00, 0x10, 0x32, 0x5e, 0xa6, 0x05, 0xe8, 0x15, 0x26, 0xf6,
0xe3, 0x51, 0x23, 0x61, 0x01, 0xbf, 0x01, 0x05, 0xd1, 0x0b, 0xb3, 0xe0, 0x46, 0x22, 0x0b, 0xa8,
0x8f, 0x91, 0x7d, 0xbf, 0x83, 0x3c, 0x8a, 0x7d, 0xfd, 0x1e, 0x7b, 0x8b, 0x61, 0xa0, 0xdd, 0xba,
0x08, 0x11, 0x3f, 0x61, 0x09, 0x1d, 0xdb, 0x5c, 0xf1, 0x4c, 0x23, 0x7c, 0x42, 0xe5, 0x07, 0x19,
0x5c, 0x63, 0x2f, 0xca, 0xd0, 0xc4, 0x51, 0xb1, 0x09, 0x96, 0xfd, 0xb0, 0xcd, 0x5f, 0xb7, 0xd4,
0xa8, 0xd4, 0xd2, 0x58, 0x67, 0xa0, 0xd4, 0x73, 0x87, 0x81, 0x26, 0x1b, 0xb1, 0x12, 0x6e, 0xa4,
0x30, 0x66, 0x66, 0x61, 0x64, 0x12, 0x29, 0x05, 0xee, 0xd7, 0x0c, 0x80, 0x5b, 0x4e, 0x07, 0x3f,
0x61, 0xc1, 0x37, 0x8e, 0xd3, 0xc1, 0xd4, 0x1b, 0xdd, 0x1c, 0x43, 0x99, 0xb6, 0xd7, 0x3f, 0x1c,
0x06, 0xda, 0xdd, 0x8b, 0xa8, 0x5c, 0x20, 0x4e, 0xb8, 0x90, 0x0c, 0xdc, 0xcc, 0xab, 0xff, 0x5d,
0xf9, 0x25, 0x03, 0x56, 0xbe, 0x76, 0xad, 0x81, 0x8d, 0x63, 0x70, 0xf6, 0x14, 0x38, 0x65, 0x0c,
0x2e, 0x6d, 0xab, 0xdf, 0x1d, 0x06, 0xda, 0xc6, 0x5c, 0xd0, 0xd2, 0xc2, 0xcb, 0x0b, 0xec, 0x59,
0x06, 0xac, 0xb5, 0x5c, 0xef, 0x8b, 0x6d, 0x7e, 0x7d, 0x49, 0xd4, 0x45, 0x3c, 0x85, 0x6d, 0x6d,
0x8c, 0x8d, 0x29, 0xbe, 0x44, 0xd4, 0x37, 0x9f, 0xe8, 0x1b, 0xc3, 0x40, 0xab, 0xcf, 0x85, 0x6c,
0x2c, 0xba, 0xbc, 0xb8, 0x7e, 0xcb, 0x80, 0xeb, 0x8f, 0x07, 0xc8, 0xa1, 0xa6, 0x85, 0x05, 0xb2,
0x18, 0xd8, 0xc1, 0x14, 0x30, 0x75, 0x0c, 0x2c, 0xad, 0x09, 0xd1, 0x7d, 0x3c, 0x0c, 0xb4, 0x7b,
0x73, 0xa1, 0x9b, 0x25, 0xbf, 0xbc, 0x10, 0xbf, 0xcb, 0x81, 0xab, 0x8f, 0xd9, 0x2a, 0x31, 0xbb,
0xf7, 0x41, 0x81, 0xf0, 0xd3, 0x4d, 0x4c, 0x6e, 0xe2, 0x26, 0x90, 0x3e, 0x47, 0x35, 0x25, 0x23,
0xb4, 0x67, 0xf7, 0x23, 0x8b, 0x7d, 0xd4, 0xa3, 0xf2, 0x5a, 0x99, 0x54, 0x4e, 0x7f, 0xf2, 0x99,
0x5a, 0x68, 0xe0, 0x1d, 0x90, 0xe7, 0xd5, 0x38, 0x3c, 0x1a, 0xa6, 0x1e, 0x3b, 0x5d, 0x16, 0x9b,
0x92, 0x21, 0xcc, 0x61, 0x03, 0xe4, 0x3c, 0xdf, 0xb5, 0xc3, 0xcb, 0xeb, 0xcd, 0xc9, 0x67, 0x26,
0x3f, 0x25, 0x4d, 0xc9, 0xe0, 0xb6, 0xf0, 0x36, 0x3b, 0xc6, 0xb2, 0x6f, 0x50, 0xf4, 0x41, 0x55,
0x26, 0x65, 0x09, 0x49, 0x64, 0x0a, 0x6f, 0x83, 0xc2, 0x3e, 0x2f, 0x35, 0xfc, 0x2e, 0xc1, 0xce,
0x83, 0x09, 0x51, 0xba, 0x08, 0x31, 0xbf, 0x84, 0x2d, 0x7c, 0x00, 0xae, 0x50, 0xd7, 0xeb, 0x47,
0x49, 0xcd, 0xef, 0x1b, 0xa5, 0x46, 0x39, 0xa9, 0x9d, 0x95, 0xf4, 0x4d, 0xc9, 0x48, 0xe9, 0xe0,
0x23, 0x70, 0x6d, 0x2f, 0x15, 0x7a, 0x38, 0xba, 0x9e, 0xa4, 0x38, 0xcf, 0xce, 0x88, 0xa6, 0x64,
0x4c, 0xa9, 0x75, 0x30, 0xce, 0x12, 0xfd, 0xf6, 0xd1, 0xb1, 0x2a, 0x3d, 0x3f, 0x56, 0xa5, 0xb3,
0x63, 0x55, 0xfe, 0x76, 0xa4, 0xca, 0x3f, 0x8d, 0x54, 0xf9, 0x70, 0xa4, 0xca, 0x47, 0x23, 0x55,
0xfe, 0x73, 0xa4, 0xca, 0x7f, 0x8d, 0x54, 0xe9, 0x6c, 0xa4, 0xca, 0x4f, 0x4f, 0x54, 0xe9, 0xe8,
0x44, 0x95, 0x9e, 0x9f, 0xa8, 0x52, 0xbb, 0xc0, 0x53, 0x62, 0xe3, 0x9f, 0x00, 0x00, 0x00, 0xff,
0xff, 0x57, 0xdc, 0x66, 0x15, 0x08, 0x12, 0x00, 0x00,
}
func (this *LokiRequest) Equal(that interface{}) bool {
@ -1360,39 +1290,6 @@ func (this *LokiSeriesResponse) Equal(that interface{}) bool {
}
return true
}
func (this *LokiLabelNamesRequest) Equal(that interface{}) bool {
if that == nil {
return this == nil
}
that1, ok := that.(*LokiLabelNamesRequest)
if !ok {
that2, ok := that.(LokiLabelNamesRequest)
if ok {
that1 = &that2
} else {
return false
}
}
if that1 == nil {
return this == nil
} else if this == nil {
return false
}
if !this.StartTs.Equal(that1.StartTs) {
return false
}
if !this.EndTs.Equal(that1.EndTs) {
return false
}
if this.Path != that1.Path {
return false
}
if this.Query != that1.Query {
return false
}
return true
}
func (this *LokiLabelNamesResponse) Equal(that interface{}) bool {
if that == nil {
return this == nil
@ -1949,19 +1846,6 @@ func (this *LokiSeriesResponse) GoString() string {
s = append(s, "}")
return strings.Join(s, "")
}
func (this *LokiLabelNamesRequest) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 8)
s = append(s, "&queryrange.LokiLabelNamesRequest{")
s = append(s, "StartTs: "+fmt.Sprintf("%#v", this.StartTs)+",\n")
s = append(s, "EndTs: "+fmt.Sprintf("%#v", this.EndTs)+",\n")
s = append(s, "Path: "+fmt.Sprintf("%#v", this.Path)+",\n")
s = append(s, "Query: "+fmt.Sprintf("%#v", this.Query)+",\n")
s = append(s, "}")
return strings.Join(s, "")
}
func (this *LokiLabelNamesResponse) GoString() string {
if this == nil {
return "nil"
@ -2504,59 +2388,6 @@ func (m *LokiSeriesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *LokiLabelNamesRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *LokiLabelNamesRequest) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *LokiLabelNamesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Query) > 0 {
i -= len(m.Query)
copy(dAtA[i:], m.Query)
i = encodeVarintQueryrange(dAtA, i, uint64(len(m.Query)))
i--
dAtA[i] = 0x22
}
if len(m.Path) > 0 {
i -= len(m.Path)
copy(dAtA[i:], m.Path)
i = encodeVarintQueryrange(dAtA, i, uint64(len(m.Path)))
i--
dAtA[i] = 0x1a
}
n9, err9 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTs, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTs):])
if err9 != nil {
return 0, err9
}
i -= n9
i = encodeVarintQueryrange(dAtA, i, uint64(n9))
i--
dAtA[i] = 0x12
n10, err10 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTs, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTs):])
if err10 != nil {
return 0, err10
}
i -= n10
i = encodeVarintQueryrange(dAtA, i, uint64(n10))
i--
dAtA[i] = 0xa
return len(dAtA) - i, nil
}
func (m *LokiLabelNamesResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -3282,27 +3113,6 @@ func (m *LokiSeriesResponse) Size() (n int) {
return n
}
func (m *LokiLabelNamesRequest) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTs)
n += 1 + l + sovQueryrange(uint64(l))
l = github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTs)
n += 1 + l + sovQueryrange(uint64(l))
l = len(m.Path)
if l > 0 {
n += 1 + l + sovQueryrange(uint64(l))
}
l = len(m.Query)
if l > 0 {
n += 1 + l + sovQueryrange(uint64(l))
}
return n
}
func (m *LokiLabelNamesResponse) Size() (n int) {
if m == nil {
return 0
@ -3642,19 +3452,6 @@ func (this *LokiSeriesResponse) String() string {
}, "")
return s
}
func (this *LokiLabelNamesRequest) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&LokiLabelNamesRequest{`,
`StartTs:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.StartTs), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
`EndTs:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.EndTs), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
`Path:` + fmt.Sprintf("%v", this.Path) + `,`,
`Query:` + fmt.Sprintf("%v", this.Query) + `,`,
`}`,
}, "")
return s
}
func (this *LokiLabelNamesResponse) String() string {
if this == nil {
return "nil"
@ -5070,189 +4867,6 @@ func (m *LokiSeriesResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *LokiLabelNamesRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQueryrange
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: LokiLabelNamesRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: LokiLabelNamesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQueryrange
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthQueryrange
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthQueryrange
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartTs, dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field EndTs", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQueryrange
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthQueryrange
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthQueryrange
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.EndTs, dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQueryrange
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthQueryrange
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQueryrange
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Path = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQueryrange
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthQueryrange
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQueryrange
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Query = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipQueryrange(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthQueryrange
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthQueryrange
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *LokiLabelNamesResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0

13
pkg/querier/queryrange/queryrange.proto
Unescape View File

@ -96,19 +96,6 @@ message LokiSeriesResponse {
];
}
message LokiLabelNamesRequest {
google.protobuf.Timestamp startTs = 1 [
(gogoproto.stdtime) = true,
(gogoproto.nullable) = false
];
google.protobuf.Timestamp endTs = 2 [
(gogoproto.stdtime) = true,
(gogoproto.nullable) = false
];
string path = 3;
string query = 4;
}
message LokiLabelNamesResponse {
string Status = 1 [(gogoproto.jsontag) = "status"];
repeated string Data = 2 [(gogoproto.jsontag) = "data,omitempty"];

12
pkg/querier/queryrange/roundtrip_test.go
Unescape View File

@ -468,11 +468,13 @@ func TestLabelsTripperware(t *testing.T) {
require.NoError(t, err)
defer rt.Close()
lreq := &LokiLabelNamesRequest{
StartTs: testTime.Add(-25 * time.Hour), // bigger than the limit
EndTs: testTime,
Path: "/loki/api/v1/labels",
}
lreq := NewLabelRequest(
testTime.Add(-25*time.Hour), // bigger than the limit
testTime,
"",
"",
"/loki/api/v1/labels",
)
ctx := user.InjectOrgID(context.Background(), "1")
req, err := DefaultCodec.EncodeRequest(ctx, lreq)

13
pkg/querier/queryrange/split_by_interval.go
Unescape View File

@ -213,7 +213,7 @@ func (h *splitByInterval) Do(ctx context.Context, r queryrangebase.Request) (que
intervals[i], intervals[j] = intervals[j], intervals[i]
}
}
case *LokiSeriesRequest, *LokiLabelNamesRequest, *logproto.IndexStatsRequest, *logproto.VolumeRequest:
case *LokiSeriesRequest, *LabelRequest, *logproto.IndexStatsRequest, *logproto.VolumeRequest:
// Set this to 0 since this is not used in Series/Labels/Index Request.
limit = 0
default:
@ -268,17 +268,12 @@ func splitByTime(req queryrangebase.Request, interval time.Duration) ([]queryran
Shards: r.Shards,
})
})
case *LokiLabelNamesRequest:
case *LabelRequest:
// metadata queries have end time inclusive.
// Set endTimeInclusive to true so that ForInterval keeps a gap of 1ms between splits to
// avoid querying duplicate data in adjacent queries.
util.ForInterval(interval, r.StartTs, r.EndTs, true, func(start, end time.Time) {
reqs = append(reqs, &LokiLabelNamesRequest{
Path: r.Path,
StartTs: start,
EndTs: end,
Query: r.Query,
})
util.ForInterval(interval, *r.Start, *r.End, true, func(start, end time.Time) {
reqs = append(reqs, NewLabelRequest(start, end, r.Query, r.Name, r.Path()))
})
case *logproto.IndexStatsRequest:
startTS := model.Time(r.GetStart()).Time()

6
pkg/querier/queryrange/split_by_interval_test.go
Unescape View File

@ -90,11 +90,7 @@ func Test_splitQuery(t *testing.T) {
}
buildLokiLabelNamesRequest := func(start, end time.Time) queryrangebase.Request {
return &LokiLabelNamesRequest{
StartTs: start,
EndTs: end,
Path: "/labels",
}
return NewLabelRequest(start, end, "", "", "/lables")
}
type interval struct {

24
pkg/querier/queryrange/stats.go
Unescape View File

@ -7,7 +7,6 @@ import (
"net"
"net/http"
"strconv"
"strings"
"time"
"github.com/grafana/loki/pkg/logproto"
@ -182,8 +181,8 @@ func StatsCollectorMiddleware() queryrangebase.Middleware {
// Record information for metadata queries.
switch r := req.(type) {
case *LokiLabelNamesRequest:
data.label = getLabelNameFromLabelsQuery(r.Path)
case *LabelRequest:
data.label = r.Name
case *LokiSeriesRequest:
data.match = r.Match
}
@ -193,25 +192,6 @@ func StatsCollectorMiddleware() queryrangebase.Middleware {
})
}
func getLabelNameFromLabelsQuery(path string) string {
if strings.HasSuffix(path, "/values") {
toks := strings.FieldsFunc(path, func(r rune) bool {
return r == '/'
})
// now assuming path has suffix `/values` label name should be second last to the suffix
// **if** there exists the second last.
length := len(toks)
if length >= 2 {
return toks[length-2]
}
}
return ""
}
// interceptor implements WriteHeader to intercept status codes. WriteHeader
// may not be called on success, so initialize statusCode with the status you
// want to report on success, i.e. http.StatusOK.

Write Preview
Loading…
Cancel
Save