downsample

type AggregateOperationConfiguration struct {
	// Type is an aggregation operation type.
	Type aggregation.Type `yaml:"type"`
}

type AggregationTypes []aggregation.Type

type AutoMappingRule struct {
	Aggregations []aggregation.Type
	Policies     policy.StoragePolicies
}

type BufferPastLimitConfiguration struct {
	Resolution time.Duration `yaml:"resolution"`
	BufferPast time.Duration `yaml:"bufferPast"`
}

type Configuration struct {
	// Matcher is the configuration for the downsampler matcher.
	Matcher MatcherConfiguration `yaml:"matcher"`

	// Rules is a set of downsample rules. If set, this overrides any rules set
	// in the KV store (and the rules in KV store are not evaluated at all).
	Rules *RulesConfiguration `yaml:"rules"`

	// RemoteAggregator specifies that downsampling should be done remotely
	// by sending values to a remote m3aggregator cluster which then
	// can forward the aggregated values to stateless m3coordinator backends.
	RemoteAggregator *RemoteAggregatorConfiguration `yaml:"remoteAggregator"`

	// AggregationTypes configs the aggregation types.
	AggregationTypes *aggregation.TypesConfiguration `yaml:"aggregationTypes"`

	// Pool of counter elements.
	CounterElemPool pool.ObjectPoolConfiguration `yaml:"counterElemPool"`

	// Pool of timer elements.
	TimerElemPool pool.ObjectPoolConfiguration `yaml:"timerElemPool"`

	// Pool of gauge elements.
	GaugeElemPool pool.ObjectPoolConfiguration `yaml:"gaugeElemPool"`

	// BufferPastLimits specifies the buffer past limits.
	BufferPastLimits []BufferPastLimitConfiguration `yaml:"bufferPastLimits"`

	// EntryTTL determines how long an entry remains alive before it may be
	// expired due to inactivity.
	EntryTTL time.Duration `yaml:"entryTTL"`

	// UntimedRollups indicates rollup rules should be untimed.
	UntimedRollups bool `yaml:"untimedRollups"`
}

type CustomRuleStoreFn func(clusterclient.Client, instrument.Options) (kv.TxnStore, error)

type Downsampler interface {
	rules.Fetcher
	// LatestRollupRules returns a snapshot of the latest rollup rules for a given namespace
	// at a given time.
	NewMetricsAppender() (MetricsAppender, error)
	// Enabled indicates whether the downsampler is enabled or not. A
	// downsampler is enabled if there are aggregated ClusterNamespaces
	// that exist as downsampling only applies to aggregations.
	Enabled() bool
}

type DownsamplerOptions struct {
	Storage                    storage.Appender
	StorageFlushConcurrency    int
	ClusterClient              clusterclient.Client
	RulesKVStore               kv.Store
	ClusterNamespacesWatcher   m3.ClusterNamespacesWatcher
	NameTag                    string
	ClockOptions               clock.Options
	InstrumentOptions          instrument.Options
	TagEncoderOptions          serialize.TagEncoderOptions
	TagDecoderOptions          serialize.TagDecoderOptions
	TagEncoderPoolOptions      pool.ObjectPoolOptions
	TagDecoderPoolOptions      pool.ObjectPoolOptions
	OpenTimeout                time.Duration
	TagOptions                 models.TagOptions
	MetricsAppenderPoolOptions pool.ObjectPoolOptions
	RWOptions                  xio.Options
	InterruptedCh              <-chan struct{}
}

type MappingRuleConfiguration struct {
	// Filter is a string separated filter of label name to label value
	// glob patterns to filter the mapping rule to.
	// e.g. "app:*nginx* foo:bar baz:qux*qaz*"
	Filter string `yaml:"filter"`

	// Aggregations is the aggregations to apply to the set of metrics.
	// One of:
	// - "Last"
	// - "Min"
	// - "Max"
	// - "Mean"
	// - "Median"
	// - "Count"
	// - "Sum"
	// - "SumSq"
	// - "Stdev"
	// - "P10"
	// - "P20"
	// - "P30"
	// - "P40"
	// - "P50"
	// - "P60"
	// - "P70"
	// - "P80"
	// - "P90"
	// - "P95"
	// - "P99"
	// - "P999"
	// - "P9999"
	Aggregations []aggregation.Type `yaml:"aggregations"`

	// StoragePolicies are retention/resolution storage policies at which to
	// keep matched metrics.
	StoragePolicies []StoragePolicyConfiguration `yaml:"storagePolicies"`

	// Drop specifies to drop any metrics that match the filter rather than
	// keeping them with a storage policy.
	Drop bool `yaml:"drop"`

	// Tags are the tags to be added to the metric while applying the mapping
	// rule. Users are free to add name/value combinations to the metric. The
	// coordinator also supports certain first class tags which will augment
	// the metric with coordinator generated tag values.
	// __m3_graphite_aggregation__ as a tag will augment the metric with an
	// aggregation tag which is required for graphite. If a metric is of the
	// form {__g0__:stats __g1__:metric __g2__:timer} and we have configured
	// a P95 aggregation, this option will add __g3__:P95 to the metric.
	// __m3_graphite_prefix__ as a tag will add the provided value as a prefix
	// to graphite metrics.
	// __m3_drop_timestamp__ as a tag will drop the timestamp from while
	// writing the metric out. So effectively treat it as an untimed metric.
	Tags []Tag `yaml:"tags"`

	// Name is optional.
	Name string `yaml:"name"`
}

type MatcherCacheConfiguration struct {
	// Capacity if set the capacity of the rules matching cache.
	Capacity *int `yaml:"capacity"`
}

type MatcherConfiguration struct {
	// Cache if non-zero will set the capacity of the rules matching cache.
	Cache MatcherCacheConfiguration `yaml:"cache"`
	// NamespaceTag defines the namespace tag to use to select rules
	// namespace to evaluate against. Default is "__m3_namespace__".
	NamespaceTag string `yaml:"namespaceTag"`
	// RequireNamespaceWatchOnInit returns the flag to ensure matcher is initialized with a loaded namespace watch.
	// This only makes sense to use if the corresponding namespace / ruleset values are properly seeded.
	RequireNamespaceWatchOnInit bool `yaml:"requireNamespaceWatchOnInit"`
}

type MetricsAppender interface {
	// NextMetric progresses to building the next metric.
	NextMetric()
	// AddTag adds a tag to the current metric being built.
	AddTag(name, value []byte)
	// SamplesAppender returns a samples appender for the current
	// metric built with the tags that have been set.
	SamplesAppender(opts SampleAppenderOptions) (SamplesAppenderResult, error)
	// Finalize finalizes the entire metrics appender for reuse.
	Finalize()
}

type MockDownsampler struct {
	// contains filtered or unexported fields
}

type MockDownsamplerMockRecorder struct {
	// contains filtered or unexported fields
}

type MockMetricsAppender struct {
	// contains filtered or unexported fields
}

type MockMetricsAppenderMockRecorder struct {
	// contains filtered or unexported fields
}

type MockSamplesAppender struct {
	// contains filtered or unexported fields
}

type MockSamplesAppenderMockRecorder struct {
	// contains filtered or unexported fields
}

type NewDownsamplerFn func() (Downsampler, error)

type RemoteAggregatorConfiguration struct {
	// Client is the remote aggregator client.
	Client client.Configuration `yaml:"client"`
	// contains filtered or unexported fields
}

type RollupOperationConfiguration struct {
	// MetricName is the name of the new metric that is emitted after
	// the rollup is applied with its aggregations and group by's.
	MetricName string `yaml:"metricName"`

	// GroupBy is a set of labels to group by, only these remain on the
	// new metric name produced by the rollup operation.
	// Note: Can only use either groupBy or excludeBy, not both, use the
	// rollup operation "type" to specify which is used.
	GroupBy []string `yaml:"groupBy"`

	// ExcludeBy is a set of labels to exclude by, only these tags are removed
	// from the resulting rolled up metric.
	// Note: Can only use either groupBy or excludeBy, not both, use the
	// rollup operation "type" to specify which is used.
	ExcludeBy []string `yaml:"excludeBy"`

	// Aggregations is a set of aggregate operations to perform.
	Aggregations []aggregation.Type `yaml:"aggregations"`
}

type RollupRuleConfiguration struct {
	// Filter is a space separated filter of label name to label value glob
	// patterns to which to filter the mapping rule.
	// e.g. "app:*nginx* foo:bar baz:qux*qaz*"
	Filter string `yaml:"filter"`

	// Transforms are a set of of rollup rule transforms.
	Transforms []TransformConfiguration `yaml:"transforms"`

	// StoragePolicies are retention/resolution storage policies at which to keep
	// the matched metrics.
	StoragePolicies []StoragePolicyConfiguration `yaml:"storagePolicies"`

	// Name is optional.
	Name string `yaml:"name"`

	// Tags are the tags to be added to the metric while applying the rollup
	// rule. Users are free to add name/value combinations to the metric.
	Tags []Tag `yaml:"tags"`
}

type RulesConfiguration struct {
	// MappingRules are mapping rules that set retention and resolution
	// for metrics given a filter to match metrics against.
	MappingRules []MappingRuleConfiguration `yaml:"mappingRules"`

	// RollupRules are rollup rules that sets specific aggregations for sets
	// of metrics given a filter to match metrics against.
	RollupRules []RollupRuleConfiguration `yaml:"rollupRules"`
}

type SampleAppenderOptions struct {
	Override         bool
	OverrideRules    SamplesAppenderOverrideRules
	SeriesAttributes ts.SeriesAttributes
}

type SamplesAppender interface {
	AppendUntimedCounterSample(t xtime.UnixNano, value int64, annotation []byte) error
	AppendUntimedGaugeSample(t xtime.UnixNano, value float64, annotation []byte) error
	AppendUntimedTimerSample(t xtime.UnixNano, value float64, annotation []byte) error
	AppendCounterSample(t xtime.UnixNano, value int64, annotation []byte) error
	AppendGaugeSample(t xtime.UnixNano, value float64, annotation []byte) error
	AppendTimerSample(t xtime.UnixNano, value float64, annotation []byte) error
}

type SamplesAppenderOverrideRules struct {
	MappingRules []AutoMappingRule
}

type SamplesAppenderResult struct {
	SamplesAppender     SamplesAppender
	IsDropPolicyApplied bool
	ShouldDropTimestamp bool
}

type StoragePolicyConfiguration struct {
	Resolution time.Duration `yaml:"resolution"`
	Retention  time.Duration `yaml:"retention"`
}

type StoragePolicyConfigurations []StoragePolicyConfiguration

type Tag struct {
	// Name is the tag name.
	Name string `yaml:"name"`
	// Value is the tag value.
	Value string `yaml:"value"`
}

type TransformConfiguration struct {
	Rollup    *RollupOperationConfiguration    `yaml:"rollup"`
	Aggregate *AggregateOperationConfiguration `yaml:"aggregate"`
	Transform *TransformOperationConfiguration `yaml:"transform"`
}

type TransformOperationConfiguration struct {
	// Type is a transformation operation type.
	Type transformation.Type `yaml:"type"`
}