metrictank: github.com/grafana/metrictank/api/models Index | Files

package models

import "github.com/grafana/metrictank/api/models"

Index

Package Files

ccache.go cluster.go cluster_gen.go graphite.go graphite_gen.go graphite_render_meta.go meta_records.go node.go request.go request_gen.go series.go series_gen.go storagestats.go storagestats_gen.go

type CCacheDelete Uses

type CCacheDelete struct {
    // patterns with name globbing
    Patterns []string `json:"patterns" form:"patterns" `
    // tag expressions to select series
    Expr      []string `json:"expr" form:"expr"`
    OrgId     uint32   `json:"orgId" form:"orgId" binding:"Required"`
    Propagate bool     `json:"propagate" form:"propagate"`
}

func (CCacheDelete) Trace Uses

func (cd CCacheDelete) Trace(span opentracing.Span)

func (CCacheDelete) TraceDebug Uses

func (cd CCacheDelete) TraceDebug(span opentracing.Span)

type CCacheDeleteResp Uses

type CCacheDeleteResp struct {
    Errors          int                         `json:"errors"`
    FirstError      string                      `json:"firstError"`
    DeletedSeries   int                         `json:"deletedSeries"`
    DeletedArchives int                         `json:"deletedArchives"`
    Peers           map[string]CCacheDeleteResp `json:"peers"`
}

func (*CCacheDeleteResp) AddError Uses

func (c *CCacheDeleteResp) AddError(err error)

type ClusterMembers Uses

type ClusterMembers struct {
    Members []string `json:"members"`
}

type ClusterMembersResp Uses

type ClusterMembersResp struct {
    Status       string `json:"status"`
    MembersAdded int    `json:"membersAdded"`
}

type ClusterStatus Uses

type ClusterStatus struct {
    ClusterName string         `json:"clusterName"`
    NodeName    string         `json:"nodeName"`
    Members     []cluster.Node `json:"members"`
}

type FromTo Uses

type FromTo struct {
    From  string `json:"from" form:"from"`
    Until string `json:"until" form:"until"`
    To    string `json:"to" form:"to"` // graphite uses 'until' but we allow to alternatively cause it's shorter
    Tz    string `json:"tz" form:"tz"`
}

type GetData Uses

type GetData struct {
    Requests []Req `json:"requests" binding:"Required"`
}

func (GetData) Trace Uses

func (g GetData) Trace(span opentracing.Span)

func (GetData) TraceDebug Uses

func (g GetData) TraceDebug(span opentracing.Span)

type GetDataRespV0 Uses

type GetDataRespV0 struct {
    Series []Series
}

go:generate msgp

func (*GetDataRespV0) DecodeMsg Uses

func (z *GetDataRespV0) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*GetDataRespV0) EncodeMsg Uses

func (z *GetDataRespV0) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*GetDataRespV0) MarshalMsg Uses

func (z *GetDataRespV0) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*GetDataRespV0) Msgsize Uses

func (z *GetDataRespV0) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*GetDataRespV0) UnmarshalMsg Uses

func (z *GetDataRespV0) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type GetDataRespV1 Uses

type GetDataRespV1 struct {
    Stats  StorageStats
    Series []Series
}

go:generate msgp

func (*GetDataRespV1) DecodeMsg Uses

func (z *GetDataRespV1) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*GetDataRespV1) EncodeMsg Uses

func (z *GetDataRespV1) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*GetDataRespV1) MarshalMsg Uses

func (z *GetDataRespV1) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*GetDataRespV1) Msgsize Uses

func (z *GetDataRespV1) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*GetDataRespV1) UnmarshalMsg Uses

func (z *GetDataRespV1) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type GraphiteAutoCompleteTagValues Uses

type GraphiteAutoCompleteTagValues struct {
    Tag    string   `json:"tag" form:"tag"`
    Prefix string   `json:"valuePrefix" form:"valuePrefix"`
    Expr   []string `json:"expr" form:"expr"`
    Limit  uint     `json:"limit" form:"limit"`
}

type GraphiteAutoCompleteTags Uses

type GraphiteAutoCompleteTags struct {
    Prefix string   `json:"tagPrefix" form:"tagPrefix"`
    Expr   []string `json:"expr" form:"expr"`
    Limit  uint     `json:"limit" form:"limit"`
}

type GraphiteFind Uses

type GraphiteFind struct {
    FromTo
    Query  string `json:"query" form:"query" binding:"Required"`
    Format string `json:"format" form:"format" binding:"In(,completer,json,treejson,msgpack,pickle)"`
    Jsonp  string `json:"jsonp" form:"jsonp"`
}

type GraphiteRender Uses

type GraphiteRender struct {
    FromTo
    MaxDataPoints uint32   `json:"maxDataPoints" form:"maxDataPoints" binding:"Default(800)"`
    Targets       []string `json:"target" form:"target"`
    TargetsRails  []string `form:"target[]"` // # Rails/PHP/jQuery common practice format: ?target[]=path.1&target[]=path.2 -> like graphite, we allow this.
    Format        string   `json:"format" form:"format" binding:"In(,json,msgp,msgpack,pickle)"`
    NoProxy       bool     `json:"local" form:"local"` //this is set to true by graphite-web when it passes request to cluster servers
    Meta          bool     `json:"meta" form:"meta"`   // request for meta data, which will be returned as long as the format is compatible (json) and we don't have to go via graphite
    Process       string   `json:"process" form:"process" binding:"In(,none,stable,any);Default(stable)"`
    Optimizations string   `json:"optimizations" form:"optimizations"`
}

func (GraphiteRender) Validate Uses

func (gr GraphiteRender) Validate(ctx *macaron.Context, errs binding.Errors) binding.Errors

type GraphiteTagDelSeries Uses

type GraphiteTagDelSeries struct {
    Paths []string `json:"path" form:"path"`
}

func (*GraphiteTagDelSeries) DecodeMsg Uses

func (z *GraphiteTagDelSeries) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*GraphiteTagDelSeries) EncodeMsg Uses

func (z *GraphiteTagDelSeries) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*GraphiteTagDelSeries) MarshalMsg Uses

func (z *GraphiteTagDelSeries) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*GraphiteTagDelSeries) Msgsize Uses

func (z *GraphiteTagDelSeries) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (GraphiteTagDelSeries) Trace Uses

func (g GraphiteTagDelSeries) Trace(span opentracing.Span)

func (GraphiteTagDelSeries) TraceDebug Uses

func (g GraphiteTagDelSeries) TraceDebug(span opentracing.Span)

func (*GraphiteTagDelSeries) UnmarshalMsg Uses

func (z *GraphiteTagDelSeries) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type GraphiteTagDelSeriesResp Uses

type GraphiteTagDelSeriesResp struct {
    Count int            `json:"count"`
    Peers map[string]int `json:"peers"`
}

func (*GraphiteTagDelSeriesResp) DecodeMsg Uses

func (z *GraphiteTagDelSeriesResp) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*GraphiteTagDelSeriesResp) EncodeMsg Uses

func (z *GraphiteTagDelSeriesResp) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*GraphiteTagDelSeriesResp) MarshalMsg Uses

func (z *GraphiteTagDelSeriesResp) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*GraphiteTagDelSeriesResp) Msgsize Uses

func (z *GraphiteTagDelSeriesResp) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*GraphiteTagDelSeriesResp) UnmarshalMsg Uses

func (z *GraphiteTagDelSeriesResp) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type GraphiteTagDetails Uses

type GraphiteTagDetails struct {
    Tag    string `json:"tag" form:"tag"`
    Filter string `json:"filter" form:"filter"`
}

type GraphiteTagDetailsResp Uses

type GraphiteTagDetailsResp struct {
    Tag    string                        `json:"tag"`
    Values []GraphiteTagDetailsValueResp `json:"values"`
}

type GraphiteTagDetailsValueResp Uses

type GraphiteTagDetailsValueResp struct {
    Count uint64 `json:"count"`
    Value string `json:"value"`
}

type GraphiteTagFindSeries Uses

type GraphiteTagFindSeries struct {
    Expr   []string `json:"expr" form:"expr"`
    From   int64    `json:"from" form:"from"`
    Format string   `json:"format" form:"format" binding:"In(,series-json,lastts-json);Default(series-json)"`
    Limit  int      `json:"limit" binding:"Default(0)"`
    Meta   bool     `json:"meta" binding:"Default(false)"`
}

type GraphiteTagFindSeriesLastTsResp Uses

type GraphiteTagFindSeriesLastTsResp struct {
    Series   []SeriesLastTs `json:"series"`
    Warnings []string       `json:"warnings,omitempty"`
}

type GraphiteTagFindSeriesMetaResp Uses

type GraphiteTagFindSeriesMetaResp struct {
    Series   []string `json:"series"`
    Warnings []string `json:"warnings,omitempty"`
}

type GraphiteTagFindSeriesResp Uses

type GraphiteTagFindSeriesResp struct {
    Series []string `json:"series"`
}

type GraphiteTagResp Uses

type GraphiteTagResp struct {
    Tag string `json:"tag"`
}

type GraphiteTagTerms Uses

type GraphiteTagTerms struct {
    Tags []string `json:"tags"`
    Expr []string `json:"expressions"`
}

func (*GraphiteTagTerms) DecodeMsg Uses

func (z *GraphiteTagTerms) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*GraphiteTagTerms) EncodeMsg Uses

func (z *GraphiteTagTerms) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*GraphiteTagTerms) MarshalMsg Uses

func (z *GraphiteTagTerms) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*GraphiteTagTerms) Msgsize Uses

func (z *GraphiteTagTerms) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*GraphiteTagTerms) UnmarshalMsg Uses

func (z *GraphiteTagTerms) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type GraphiteTagTermsResp Uses

type GraphiteTagTermsResp struct {
    TotalSeries uint32                       `json:"totalSeries"`
    Terms       map[string]map[string]uint32 `json:"terms"`
}

func (*GraphiteTagTermsResp) DecodeMsg Uses

func (z *GraphiteTagTermsResp) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*GraphiteTagTermsResp) EncodeMsg Uses

func (z *GraphiteTagTermsResp) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*GraphiteTagTermsResp) MarshalMsg Uses

func (z *GraphiteTagTermsResp) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*GraphiteTagTermsResp) Msgsize Uses

func (z *GraphiteTagTermsResp) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*GraphiteTagTermsResp) UnmarshalMsg Uses

func (z *GraphiteTagTermsResp) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type GraphiteTags Uses

type GraphiteTags struct {
    Filter string `json:"filter" form:"filter"`
}

type GraphiteTagsResp Uses

type GraphiteTagsResp []GraphiteTagResp

type IndexAutoCompleteTagValues Uses

type IndexAutoCompleteTagValues struct {
    OrgId  uint32   `json:"orgId" binding:"Required"`
    Tag    string   `json:"tag"`
    Prefix string   `json:"prefix"`
    Expr   []string `json:"expressions"`
    Limit  uint     `json:"limit"`
}

func (IndexAutoCompleteTagValues) Trace Uses

func (t IndexAutoCompleteTagValues) Trace(span opentracing.Span)

func (IndexAutoCompleteTagValues) TraceDebug Uses

func (i IndexAutoCompleteTagValues) TraceDebug(span opentracing.Span)

type IndexAutoCompleteTags Uses

type IndexAutoCompleteTags struct {
    OrgId  uint32   `json:"orgId" binding:"Required"`
    Prefix string   `json:"Prefix"`
    Expr   []string `json:"expressions"`
    Limit  uint     `json:"limit"`
}

func (IndexAutoCompleteTags) Trace Uses

func (t IndexAutoCompleteTags) Trace(span opentracing.Span)

func (IndexAutoCompleteTags) TraceDebug Uses

func (i IndexAutoCompleteTags) TraceDebug(span opentracing.Span)

type IndexDelete Uses

type IndexDelete struct {
    Query string `json:"query" form:"query" binding:"Required"`
    OrgId uint32 `json:"orgId" form:"orgId" binding:"Required"`
}

func (IndexDelete) Trace Uses

func (i IndexDelete) Trace(span opentracing.Span)

func (IndexDelete) TraceDebug Uses

func (i IndexDelete) TraceDebug(span opentracing.Span)

type IndexFind Uses

type IndexFind struct {
    Patterns []string `json:"patterns" form:"patterns" binding:"Required"`
    OrgId    uint32   `json:"orgId" form:"orgId" binding:"Required"`
    From     int64    `json:"from" form:"from"`
}

func (IndexFind) Trace Uses

func (i IndexFind) Trace(span opentracing.Span)

func (IndexFind) TraceDebug Uses

func (i IndexFind) TraceDebug(span opentracing.Span)

type IndexFindByTag Uses

type IndexFindByTag struct {
    OrgId uint32   `json:"orgId" binding:"Required"`
    Expr  []string `json:"expressions"`
    From  int64    `json:"from"`
}

func (IndexFindByTag) Trace Uses

func (t IndexFindByTag) Trace(span opentracing.Span)

func (IndexFindByTag) TraceDebug Uses

func (i IndexFindByTag) TraceDebug(span opentracing.Span)

type IndexFindByTagResp Uses

type IndexFindByTagResp struct {
    Metrics []idx.Node `json:"metrics"`
}

go:generate msgp

func (*IndexFindByTagResp) DecodeMsg Uses

func (z *IndexFindByTagResp) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*IndexFindByTagResp) EncodeMsg Uses

func (z *IndexFindByTagResp) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*IndexFindByTagResp) MarshalMsg Uses

func (z *IndexFindByTagResp) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*IndexFindByTagResp) Msgsize Uses

func (z *IndexFindByTagResp) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*IndexFindByTagResp) UnmarshalMsg Uses

func (z *IndexFindByTagResp) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type IndexFindResp Uses

type IndexFindResp struct {
    Nodes map[string][]idx.Node
}

go:generate msgp

func NewIndexFindResp Uses

func NewIndexFindResp() *IndexFindResp

go:generate msgp

func (*IndexFindResp) DecodeMsg Uses

func (z *IndexFindResp) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*IndexFindResp) EncodeMsg Uses

func (z *IndexFindResp) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*IndexFindResp) MarshalMsg Uses

func (z *IndexFindResp) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*IndexFindResp) Msgsize Uses

func (z *IndexFindResp) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*IndexFindResp) UnmarshalMsg Uses

func (z *IndexFindResp) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type IndexGet Uses

type IndexGet struct {
    MKey schema.MKey `json:"id" form:"id" binding:"Required"`
}

type IndexList Uses

type IndexList struct {
    OrgId uint32 `json:"orgId" form:"orgId" binding:"Required"`
}

func (IndexList) Trace Uses

func (i IndexList) Trace(span opentracing.Span)

func (IndexList) TraceDebug Uses

func (i IndexList) TraceDebug(span opentracing.Span)

type IndexTagDelSeries Uses

type IndexTagDelSeries struct {
    OrgId uint32   `json:"orgId" binding:"Required"`
    Paths []string `json:"path" form:"path"`
}

func (IndexTagDelSeries) Trace Uses

func (t IndexTagDelSeries) Trace(span opentracing.Span)

func (IndexTagDelSeries) TraceDebug Uses

func (i IndexTagDelSeries) TraceDebug(span opentracing.Span)

type IndexTagDelSeriesResp Uses

type IndexTagDelSeriesResp struct {
    Count int
}

go:generate msgp

func (*IndexTagDelSeriesResp) DecodeMsg Uses

func (z *IndexTagDelSeriesResp) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (IndexTagDelSeriesResp) EncodeMsg Uses

func (z IndexTagDelSeriesResp) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (IndexTagDelSeriesResp) MarshalMsg Uses

func (z IndexTagDelSeriesResp) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (IndexTagDelSeriesResp) Msgsize Uses

func (z IndexTagDelSeriesResp) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*IndexTagDelSeriesResp) UnmarshalMsg Uses

func (z *IndexTagDelSeriesResp) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type IndexTagDetails Uses

type IndexTagDetails struct {
    OrgId  uint32 `json:"orgId" binding:"Required"`
    Filter string `json:"filter"`
    Tag    string `json:"tag" binding:"Required"`
}

func (IndexTagDetails) Trace Uses

func (t IndexTagDetails) Trace(span opentracing.Span)

func (IndexTagDetails) TraceDebug Uses

func (i IndexTagDetails) TraceDebug(span opentracing.Span)

type IndexTagDetailsResp Uses

type IndexTagDetailsResp struct {
    Values map[string]uint64 `json:"values"`
}

go:generate msgp

func (*IndexTagDetailsResp) DecodeMsg Uses

func (z *IndexTagDetailsResp) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*IndexTagDetailsResp) EncodeMsg Uses

func (z *IndexTagDetailsResp) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*IndexTagDetailsResp) MarshalMsg Uses

func (z *IndexTagDetailsResp) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*IndexTagDetailsResp) Msgsize Uses

func (z *IndexTagDetailsResp) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*IndexTagDetailsResp) UnmarshalMsg Uses

func (z *IndexTagDetailsResp) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type IndexTagTerms Uses

type IndexTagTerms struct {
    OrgId uint32   `json:"orgId" binding:"Required"`
    Tags  []string `json:"tags"`
    Expr  []string `json:"expressions"`
}

func (IndexTagTerms) Trace Uses

func (t IndexTagTerms) Trace(span opentracing.Span)

func (IndexTagTerms) TraceDebug Uses

func (i IndexTagTerms) TraceDebug(span opentracing.Span)

type IndexTags Uses

type IndexTags struct {
    OrgId  uint32 `json:"orgId" binding:"Required"`
    Filter string `json:"filter"`
}

func (IndexTags) Trace Uses

func (t IndexTags) Trace(span opentracing.Span)

func (IndexTags) TraceDebug Uses

func (i IndexTags) TraceDebug(span opentracing.Span)

type IndexTagsResp Uses

type IndexTagsResp struct {
    Tags []string `json:"tags"`
}

go:generate msgp

func (*IndexTagsResp) DecodeMsg Uses

func (z *IndexTagsResp) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*IndexTagsResp) EncodeMsg Uses

func (z *IndexTagsResp) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*IndexTagsResp) MarshalMsg Uses

func (z *IndexTagsResp) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*IndexTagsResp) Msgsize Uses

func (z *IndexTagsResp) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*IndexTagsResp) UnmarshalMsg Uses

func (z *IndexTagsResp) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MetaTagRecord Uses

type MetaTagRecord struct {
    MetaTags    []string `json:"metaTags" binding:"Required"`
    Expressions []string `json:"expressions" binding:"Required"`
}

type MetaTagRecordSwap Uses

type MetaTagRecordSwap struct {
    Records []MetaTagRecord `json:"records"`
}

func (MetaTagRecordSwap) Trace Uses

func (m MetaTagRecordSwap) Trace(span opentracing.Span)

func (MetaTagRecordSwap) TraceDebug Uses

func (m MetaTagRecordSwap) TraceDebug(span opentracing.Span)

type MetaTagRecordUpsert Uses

type MetaTagRecordUpsert struct {
    MetaTags    []string `json:"metaTags"`
    Expressions []string `json:"expressions" binding:"Required"`
}

func (MetaTagRecordUpsert) Trace Uses

func (m MetaTagRecordUpsert) Trace(span opentracing.Span)

func (MetaTagRecordUpsert) TraceDebug Uses

func (m MetaTagRecordUpsert) TraceDebug(span opentracing.Span)

type MetricNames Uses

type MetricNames []idx.Archive

func (MetricNames) MarshalJSON Uses

func (defs MetricNames) MarshalJSON() ([]byte, error)

func (MetricNames) MarshalJSONFast Uses

func (defs MetricNames) MarshalJSONFast(b []byte) ([]byte, error)

type MetricsDelete Uses

type MetricsDelete struct {
    Query string `json:"query" form:"query" binding:"Required"`
}

type MetricsDeleteResp Uses

type MetricsDeleteResp struct {
    DeletedDefs int `json:"deletedDefs"`
}

func (*MetricsDeleteResp) DecodeMsg Uses

func (z *MetricsDeleteResp) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (MetricsDeleteResp) EncodeMsg Uses

func (z MetricsDeleteResp) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (MetricsDeleteResp) MarshalMsg Uses

func (z MetricsDeleteResp) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (MetricsDeleteResp) Msgsize Uses

func (z MetricsDeleteResp) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MetricsDeleteResp) UnmarshalMsg Uses

func (z *MetricsDeleteResp) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type NodeStatus Uses

type NodeStatus struct {
    Primary string `json:"primary" form:"primary" binding:"Required"`
}

type PNGroup Uses

type PNGroup uint64

PNGroup is an identifier for a pre-normalization group: data that can be pre-normalized together

func (*PNGroup) DecodeMsg Uses

func (z *PNGroup) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (PNGroup) EncodeMsg Uses

func (z PNGroup) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (PNGroup) MarshalMsg Uses

func (z PNGroup) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (PNGroup) Msgsize Uses

func (z PNGroup) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*PNGroup) UnmarshalMsg Uses

func (z *PNGroup) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type RenderMeta Uses

type RenderMeta struct {
    RenderStats
    StorageStats
}

RenderMeta holds metadata about a render request/response

func (RenderMeta) MarshalJSONFast Uses

func (rm RenderMeta) MarshalJSONFast(b []byte) ([]byte, error)

type RenderStats Uses

type RenderStats struct {
    ResolveSeriesDuration time.Duration `json:"executeplan.resolve-series.ms"`
    GetTargetsDuration    time.Duration `json:"executeplan.get-targets.ms"`
    PrepareSeriesDuration time.Duration `json:"executeplan.prepare-series.ms"`
    PlanRunDuration       time.Duration `json:"executeplan.plan-run.ms"`
    SeriesFetch           uint32        `json:"executeplan.series-fetch.count"`
    PointsFetch           uint32        `json:"executeplan.points-fetch.count"`
    PointsReturn          uint32        `json:"executeplan.points-return.count"`
}

func (RenderStats) MarshalJSONFast Uses

func (s RenderStats) MarshalJSONFast(b []byte) ([]byte, error)

func (RenderStats) MarshalJSONFastRaw Uses

func (s RenderStats) MarshalJSONFastRaw(b []byte) ([]byte, error)

type Req Uses

type Req struct {
    // these fields can be set straight away:
    MKey        schema.MKey `json:"key"`     // metric key aka metric definition id (orgid.<hash>), often same as target for graphite-metrictank requests
    Target      string      `json:"target"`  // the target we should return either to graphite or as if we're graphite.  simply the graphite metric key from the index
    Pattern     string      `json:"pattern"` // the original query pattern specified by user (not wrapped by any functions). e.g. `foo.b*`. To be able to tie the result data back to the data need as requested
    From        uint32      `json:"from"`
    To          uint32      `json:"to"`
    MaxPoints   uint32      `json:"maxPoints"`
    PNGroup     PNGroup     `json:"pngroup"`
    RawInterval uint32      `json:"rawInterval"` // the interval of the raw metric before any consolidation
    // the consolidation method for rollup archive and normalization (pre-normalization and runtime normalization). (but not runtime consolidation). Is never 0/None
    // if ConsReq == 0 -> configured value
    // if Conseq != 0 -> closest value we can offer based on config
    Consolidator consolidation.Consolidator `json:"consolidator"`
    // requested consolidation method via consolidateBy(), if any.
    // could be 0 if it was not specified or reset by a "special" functions. in which case, we use the configured default.
    // we need to make this differentiation to tie back to the original request (and we can't just fill in the concrete consolidation in the request,
    // because one request may result in multiple series with different consolidators)
    ConsReq  consolidation.Consolidator `json:"consolidator_req"`
    Node     cluster.Node               `json:"-"`
    SchemaId uint16                     `json:"schemaId"`
    AggId    uint16                     `json:"aggId"`

    // these fields need some more coordination and are typically set later (after request planning)
    Archive      uint8  `json:"archive"`      // 0 means original data, 1 means first agg level, 2 means 2nd, etc.
    ArchInterval uint32 `json:"archInterval"` // the interval corresponding to the archive we'll fetch
    TTL          uint32 `json:"ttl"`          // the ttl of the archive we'll fetch
    OutInterval  uint32 `json:"outInterval"`  // the interval of the series after fetching (possibly with pre-normalization) and after-fetch runtime normalization. not aware of further normalization or runtime consolidation
    AggNum       uint32 `json:"aggNum"`       // how many points to consolidate together for after-fetch runtime normalization (see docs/consolidation.md)
}

Req is a request for data by MKey and parameters such as consolidator, max points, etc

func NewReq Uses

func NewReq(key schema.MKey, target, patt string, from, to, maxPoints, rawInterval uint32, pngroup PNGroup, cons, consReq consolidation.Consolidator, node cluster.Node, schemaId, aggId uint16) Req

NewReq creates a new request. It sets all properties except the ones that need request planning

func (*Req) AdjustTo Uses

func (r *Req) AdjustTo(interval, from uint32, as archives.Archives)

AdjustTo adjusts the request to accommodate the requested interval notes: * the Req MUST have been Plan()'d already! * interval MUST be a multiple of the ArchInterval (so we can normalize if needed) * the TTL of lower resolution archives is always assumed to be at least as long as the current archive

func (Req) DebugString Uses

func (r Req) DebugString() string

func (Req) Equals Uses

func (a Req) Equals(b Req) bool

Equals compares all fields of a to b for equality. Except the Node field: we just compare the node.Name rather then doing a deep comparison.

func (*Req) Init Uses

func (r *Req) Init(archive idx.Archive, cons consolidation.Consolidator, node cluster.Node)

Init initializes a request based on the metadata that we know of. It sets all properties except the ones that need request planning

func (*Req) Plan Uses

func (r *Req) Plan(i int, a archives.Archive)

Plan updates the planning parameters to match the i'th archive in its retention rules

func (*Req) PlanNormalization Uses

func (r *Req) PlanNormalization(interval uint32)

PlanNormalization updates the planning parameters to accommodate after-fetch runtime normalization to the specified interval

func (Req) PointsFetch Uses

func (r Req) PointsFetch() uint32

PointsFetch returns how many points this request will fetch when executed

func (Req) PointsReturn Uses

func (r Req) PointsReturn(planMDP uint32) uint32

PointsReturn estimates the amount of points that will be returned for this request It is not aware of summarize() or on-demand runtime normalization. but does account for after-fetch runtime normalization and runtime consolidation

func (Req) String Uses

func (r Req) String() string

func (Req) TraceLog Uses

func (r Req) TraceLog(span opentracing.Span)

TraceLog puts all request properties in a span log entry good for when a span deals with multiple requests note that the amount of data generated here can be up to 1000~1500 bytes

type ResponseWithMeta Uses

type ResponseWithMeta struct {
    Meta   RenderMeta
    Series SeriesByTarget
}

ResponseWithMeta is a graphite render response with metadata

func (ResponseWithMeta) MarshalJSONFast Uses

func (rwm ResponseWithMeta) MarshalJSONFast(b []byte) ([]byte, error)

type Series Uses

type Series struct {
    Target       string            // for fetched data, set from models.Req.Target, i.e. the metric graphite key. for function output, whatever should be shown as target string (legend)
    Tags         map[string]string // Must be set initially via call to `SetTags()`
    Interval     uint32
    QueryPatt    string                     // to tie series back to request it came from. e.g. foo.bar.*, or if series outputted by func it would be e.g. scale(foo.bar.*,0.123456)
    QueryFrom    uint32                     // to tie series back to request it came from
    QueryTo      uint32                     // to tie series back to request it came from
    QueryCons    consolidation.Consolidator // to tie series back to request it came from (may be 0 to mean use configured default)
    Consolidator consolidation.Consolidator // consolidator to actually use (for fetched series this may not be 0, default must be resolved. if series created by function, may be 0)
    QueryMDP     uint32                     // to tie series back to request it came from
    QueryPNGroup PNGroup                    // to tie series back to request it came from
    Meta         SeriesMeta                 // note: this series could be a "just fetched" series, or one derived from many other series
    Datapoints   []schema.Point
}

func (Series) Copy Uses

func (s Series) Copy(emptyDatapoints []schema.Point) Series

Copy returns a deep copy. The returned value does not link to the same memory space for any of the properties

func (*Series) CopyTags Uses

func (s *Series) CopyTags() map[string]string

CopyTags makes a deep copy of the tags

func (*Series) CopyTagsWith Uses

func (s *Series) CopyTagsWith(key, val string) map[string]string

CopyTagsWith makes a deep copy of the tags and sets the given tag

func (*Series) DecodeMsg Uses

func (z *Series) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*Series) EncodeMsg Uses

func (z *Series) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*Series) EnrichWithTags Uses

func (s *Series) EnrichWithTags(tags tagquery.Tags)

func (Series) IsCanonical Uses

func (s Series) IsCanonical() bool

IsCanonical checks whether the series is canonical wrt to its interval and from/to

func (*Series) MarshalMsg Uses

func (z *Series) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*Series) Msgsize Uses

func (z *Series) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*Series) SetTags Uses

func (s *Series) SetTags()

SetTags fills in the Tags property with tags parsed out of s.Target the "name" tag is always set from s.Target, overriding any attempted override

func (*Series) UnmarshalMsg Uses

func (z *Series) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type SeriesByTarget Uses

type SeriesByTarget []Series

func (*SeriesByTarget) DecodeMsg Uses

func (z *SeriesByTarget) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (SeriesByTarget) EncodeMsg Uses

func (z SeriesByTarget) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (SeriesByTarget) ForGraphite Uses

func (series SeriesByTarget) ForGraphite(format string) SeriesListForPickle

func (SeriesByTarget) Len Uses

func (g SeriesByTarget) Len() int

func (SeriesByTarget) Less Uses

func (g SeriesByTarget) Less(i, j int) bool

func (SeriesByTarget) MarshalJSON Uses

func (series SeriesByTarget) MarshalJSON() ([]byte, error)

func (SeriesByTarget) MarshalJSONFast Uses

func (series SeriesByTarget) MarshalJSONFast(b []byte) ([]byte, error)

regular graphite output

func (SeriesByTarget) MarshalJSONFastWithMeta Uses

func (series SeriesByTarget) MarshalJSONFastWithMeta(b []byte) ([]byte, error)

func (SeriesByTarget) MarshalMsg Uses

func (z SeriesByTarget) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (SeriesByTarget) Msgsize Uses

func (z SeriesByTarget) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (SeriesByTarget) Pickle Uses

func (series SeriesByTarget) Pickle(buf []byte) ([]byte, error)

func (SeriesByTarget) Swap Uses

func (g SeriesByTarget) Swap(i, j int)

func (*SeriesByTarget) UnmarshalMsg Uses

func (z *SeriesByTarget) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type SeriesCompleter Uses

type SeriesCompleter map[string][]SeriesCompleterItem

func NewSeriesCompleter Uses

func NewSeriesCompleter() SeriesCompleter

func (SeriesCompleter) Add Uses

func (c SeriesCompleter) Add(e SeriesCompleterItem)

type SeriesCompleterItem Uses

type SeriesCompleterItem struct {
    Path   string `json:"path"`
    Name   string `json:"name"`
    IsLeaf string `json:"is_leaf"`
}

type SeriesForPickle Uses

type SeriesForPickle struct {
    Name           string        `pickle:"name" msg:"name"`
    Start          uint32        `pickle:"start" msg:"start"`
    End            uint32        `pickle:"end" msg:"end"`
    Step           uint32        `pickle:"step" msg:"step"`
    Values         []interface{} `pickle:"values" msg:"values"`
    PathExpression string        `pickle:"pathExpression" msg:"pathExpression"`
}

func (*SeriesForPickle) DecodeMsg Uses

func (z *SeriesForPickle) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*SeriesForPickle) EncodeMsg Uses

func (z *SeriesForPickle) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*SeriesForPickle) MarshalMsg Uses

func (z *SeriesForPickle) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*SeriesForPickle) Msgsize Uses

func (z *SeriesForPickle) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*SeriesForPickle) UnmarshalMsg Uses

func (z *SeriesForPickle) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type SeriesLastTs Uses

type SeriesLastTs struct {
    Series string `json:"val"`
    Ts     int64  `json:"lastTs"`
}

type SeriesListForPickle Uses

type SeriesListForPickle []SeriesForPickle

func (*SeriesListForPickle) DecodeMsg Uses

func (z *SeriesListForPickle) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (SeriesListForPickle) EncodeMsg Uses

func (z SeriesListForPickle) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (SeriesListForPickle) MarshalMsg Uses

func (z SeriesListForPickle) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (SeriesListForPickle) Msgsize Uses

func (z SeriesListForPickle) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*SeriesListForPickle) UnmarshalMsg Uses

func (z *SeriesListForPickle) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type SeriesMeta Uses

type SeriesMeta []SeriesMetaProperties

SeriesMeta counts the number of series for each set of meta properties note: it's illegal for SeriesMeta to include multiple entries that include the same properties

func (SeriesMeta) Copy Uses

func (a SeriesMeta) Copy() SeriesMeta

Copy creates a copy of SeriesMeta

func (SeriesMeta) CopyWithChange Uses

func (a SeriesMeta) CopyWithChange(fn func(in SeriesMetaProperties) SeriesMetaProperties) SeriesMeta

CopyWithChange creates a copy of SeriesMeta, but executes the requested change on each SeriesMetaProperties

func (*SeriesMeta) DecodeMsg Uses

func (z *SeriesMeta) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (SeriesMeta) EncodeMsg Uses

func (z SeriesMeta) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (SeriesMeta) MarshalJSONFast Uses

func (meta SeriesMeta) MarshalJSONFast(b []byte) ([]byte, error)

func (SeriesMeta) MarshalMsg Uses

func (z SeriesMeta) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (SeriesMeta) Merge Uses

func (a SeriesMeta) Merge(b SeriesMeta) SeriesMeta

Merge merges SeriesMeta b into a and returns the modified a counts for identical properties get added together

func (SeriesMeta) Msgsize Uses

func (z SeriesMeta) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*SeriesMeta) UnmarshalMsg Uses

func (z *SeriesMeta) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type SeriesMetaProperties Uses

type SeriesMetaProperties struct {
    SchemaID              uint16                     // id of storage-schemas rule this series corresponds to
    Archive               uint8                      // which archive was being read from
    ArchInterval          uint32                     // the interval of the archive we fetch
    AggNumNorm            uint32                     // aggNum for normalization
    AggNumRC              uint32                     // aggNum runtime consolidation
    ConsolidatorNormFetch consolidation.Consolidator // consolidator used for normalization and reading from store (if applicable)
    ConsolidatorRC        consolidation.Consolidator // consolidator used for runtime consolidation to honor maxdatapoints (if applicable).
    Count                 uint32                     // number of series corresponding to these properties
}

SeriesMetaProperties describes the properties of a series (fetching and normalization and the count of series corresponding to them)

func (*SeriesMetaProperties) DecodeMsg Uses

func (z *SeriesMetaProperties) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*SeriesMetaProperties) EncodeMsg Uses

func (z *SeriesMetaProperties) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (SeriesMetaProperties) Export Uses

func (smp SeriesMetaProperties) Export() SeriesMetaPropertiesExport

Export returns a human-friendly version of the SeriesMetaProperties.

func (*SeriesMetaProperties) MarshalMsg Uses

func (z *SeriesMetaProperties) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*SeriesMetaProperties) Msgsize Uses

func (z *SeriesMetaProperties) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*SeriesMetaProperties) UnmarshalMsg Uses

func (z *SeriesMetaProperties) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type SeriesMetaPropertiesExport Uses

type SeriesMetaPropertiesExport struct {
    SchemaName            string                     // name of schema rule used
    SchemaRetentions      string                     // schema retentions used
    ArchiveRead           uint8                      // which archive was being read from
    ArchInterval          uint32                     // the interval of the archive we fetch
    AggNumNorm            uint32                     // aggNum for normalization
    AggNumRC              uint32                     // aggNum runtime consolidation
    ConsolidatorNormFetch consolidation.Consolidator // consolidator used for normalization and reading from store (if applicable)
    ConsolidatorRC        consolidation.Consolidator // consolidator used for runtime consolidation to honor maxdatapoints (if applicable).
    Count                 uint32                     // number of series corresponding to these properties
}

SeriesMetaPropertiesExport is an "export" of a SeriesMetaProperties it is a more user friendly representation

type SeriesPickle Uses

type SeriesPickle []SeriesPickleItem

func (*SeriesPickle) DecodeMsg Uses

func (z *SeriesPickle) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (SeriesPickle) EncodeMsg Uses

func (z SeriesPickle) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (SeriesPickle) MarshalMsg Uses

func (z SeriesPickle) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (SeriesPickle) Msgsize Uses

func (z SeriesPickle) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (SeriesPickle) Pickle Uses

func (s SeriesPickle) Pickle(buf []byte) ([]byte, error)

func (*SeriesPickle) UnmarshalMsg Uses

func (z *SeriesPickle) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type SeriesPickleItem Uses

type SeriesPickleItem struct {
    Path      string    `pickle:"path" msg:"path"`
    IsLeaf    bool      `pickle:"isLeaf" msg:"isLeaf"`
    Intervals [][]int64 `pickle:"intervals" msg:"intervals"` // list of (start,end) tuples
}

func NewSeriesPickleItem Uses

func NewSeriesPickleItem(path string, isLeaf bool, intervals [][]int64) SeriesPickleItem

func (*SeriesPickleItem) DecodeMsg Uses

func (z *SeriesPickleItem) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*SeriesPickleItem) EncodeMsg Uses

func (z *SeriesPickleItem) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*SeriesPickleItem) MarshalMsg Uses

func (z *SeriesPickleItem) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*SeriesPickleItem) Msgsize Uses

func (z *SeriesPickleItem) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*SeriesPickleItem) UnmarshalMsg Uses

func (z *SeriesPickleItem) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type SeriesTree Uses

type SeriesTree []SeriesTreeItem

func (*SeriesTree) Add Uses

func (s *SeriesTree) Add(i *SeriesTreeItem)

type SeriesTreeItem Uses

type SeriesTreeItem struct {
    AllowChildren int            `json:"allowChildren"`
    Expandable    int            `json:"expandable"`
    Leaf          int            `json:"leaf"`
    ID            string         `json:"id"`
    Text          string         `json:"text"`
    Context       map[string]int `json:"context"` // unused
}

type StorageStats Uses

type StorageStats struct {
    CacheMiss       uint32 `json:"executeplan.cache-miss.count"`
    CacheHitPartial uint32 `json:"executeplan.cache-hit-partial.count"`
    CacheHit        uint32 `json:"executeplan.cache-hit.count"`
    ChunksFromTank  uint32 `json:"executeplan.chunks-from-tank.count"`
    ChunksFromCache uint32 `json:"executeplan.chunks-from-cache.count"`
    ChunksFromStore uint32 `json:"executeplan.chunks-from-store.count"`
}

go:generate msgp

func (*StorageStats) Add Uses

func (ss *StorageStats) Add(a *StorageStats)

Add adds a to ss.

func (*StorageStats) DecodeMsg Uses

func (z *StorageStats) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*StorageStats) EncodeMsg Uses

func (z *StorageStats) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*StorageStats) IncCacheResult Uses

func (ss *StorageStats) IncCacheResult(t cache.ResultType)

func (*StorageStats) IncChunksFromCache Uses

func (ss *StorageStats) IncChunksFromCache(n uint32)

func (*StorageStats) IncChunksFromStore Uses

func (ss *StorageStats) IncChunksFromStore(n uint32)

func (*StorageStats) IncChunksFromTank Uses

func (ss *StorageStats) IncChunksFromTank(n uint32)

func (*StorageStats) MarshalJSONFast Uses

func (ss *StorageStats) MarshalJSONFast(b []byte) ([]byte, error)

func (*StorageStats) MarshalJSONFastRaw Uses

func (ss *StorageStats) MarshalJSONFastRaw(b []byte) ([]byte, error)

func (*StorageStats) MarshalMsg Uses

func (z *StorageStats) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*StorageStats) Msgsize Uses

func (z *StorageStats) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*StorageStats) Trace Uses

func (ss *StorageStats) Trace(span opentracing.Span)

func (*StorageStats) UnmarshalMsg Uses

func (z *StorageStats) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type StringList Uses

type StringList []string

go:generate msgp

func (*StringList) DecodeMsg Uses

func (z *StringList) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (StringList) EncodeMsg Uses

func (z StringList) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (StringList) MarshalMsg Uses

func (z StringList) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (StringList) Msgsize Uses

func (z StringList) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*StringList) UnmarshalMsg Uses

func (z *StringList) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

Package models imports 24 packages (graph) and is imported by 6 packages. Updated 2020-07-15. Refresh now. Tools for package owners.