rules_complete.1.x.toml

############################
## Sampling Rules Config ##
############################

# DryRun - If enabled, marks traces that would be dropped given current sampling rules,
# and sends all traces regardless
# DryRun = false

# DryRunFieldName - the key to add to use to add to event data when using DryRun mode above, defaults to refinery_kept
# DryRunFieldName = "refinery_kept"

# DeterministicSampler is a section of the config for manipulating the
# Deterministic Sampler implementation. This is the simplest sampling algorithm
# - it is a static sample rate, choosing traces randomly to either keep or send
# (at the appropriate rate). It is not influenced by the contents of the trace.
Sampler = "DeterministicSampler"

# SampleRate is the rate at which to sample. It indicates a ratio, where one
# sample trace is kept for every n traces seen. For example, a SampleRate of 30
# will keep 1 out of every 30 traces. The choice on whether to keep any specific
# trace is random, so the rate is approximate.
# Eligible for live reload.
SampleRate = 1

[dataset1]

	# Note: If your dataset name contains a space, you will have to escape the dataset name
	# using single quotes, such as ['dataset 1']

	# DynamicSampler is a section of the config for manipulating the simple Dynamic Sampler
	# implementation. This sampler collects the values of a number of fields from a
	# trace and uses them to form a key. This key is handed to the standard dynamic
	# sampler algorithm which generates a sample rate based on the frequency with
	# which that key has appeared in the previous ClearFrequency. See
	# https://github.com/honeycombio/dynsampler-go for more detail on the mechanics
	# of the dynamic sampler.  This sampler uses the AvgSampleRate algorithm from
	# that package.
	Sampler = "DynamicSampler"

	# SampleRate is the goal rate at which to sample. It indicates a ratio, where
	# one sample trace is kept for every n traces seen. For example, a SampleRate of
	# 30 will keep 1 out of every 30 traces. This rate is handed to the dynamic
	# sampler, who assigns a sample rate for each trace based on the fields selected
	# from that trace.
	# Eligible for live reload.
	SampleRate = 2

	# FieldList is a list of all the field names to use to form the key that will be handed to the dynamic sampler.
	# The combination of values from all of these fields should reflect how interesting the trace is compared to
	# another. A good field selection has consistent values for high-frequency, boring traffic, and unique values for
	# outliers and interesting traffic. Including an error field (or something like HTTP status code) is an excellent
	# choice. Using fields with very high cardinality (like `k8s.pod.id`), is a bad choice. If the combination of
	# fields essentially makes them unique, the dynamic sampler will sample everything. If the combination of fields is
	# not unique enough, you will not be guaranteed samples of the most interesting traces. As an example, consider a
	# combination of HTTP endpoint (high-frequency and boring), HTTP method, and status code (normally boring but can
	# become interesting when indicating an error) as a good set of fields since it will allowing proper sampling
	# of all endpoints under normal traffic and call out when there is failing traffic to any endpoint.
	# For example, in contrast, consider a combination of HTTP endpoint, status code, and pod id as a bad set of
	# fields, since it would result in keys that are all unique, and therefore results in sampling 100% of traces.
	# Using only the HTTP endpoint field would be a **bad** choice, as it is not unique enough and therefore
	# interesting traces, like traces that experienced a `500`, might not be sampled.
	# Field names may come from any span in the trace.
	# Eligible for live reload.
	FieldList = ["request.method", "http.target", "response.status_code"]

	# UseTraceLength will add the number of spans in the trace into the dynamic
	# sampler as part of the key. The number of spans is exact, so if there are
	# normally small variations in trace length you may want to leave this off. If
	# traces are consistent lengths and changes in trace length is a useful
	# indicator of traces you'd like to see in Honeycomb, set this to true.
	# Eligible for live reload.
	UseTraceLength = true

	# AddSampleRateKeyToTrace when this is set to true, the sampler will add a field
	# to the root span of the trace containing the key used by the sampler to decide
	# the sample rate. This can be helpful in understanding why the sampler is
	# making certain decisions about sample rate and help you understand how to
	# better choose the sample rate key (aka the FieldList setting above) to use.
	AddSampleRateKeyToTrace = true

	# AddSampleRateKeyToTraceField is the name of the field the sampler will use
	# when adding the sample rate key to the trace. This setting is only used when
	# AddSampleRateKeyToTrace is true.
	AddSampleRateKeyToTraceField = "meta.refinery.dynsampler_key"

	# ClearFrequency is the name of the field the sampler will use to determine
	# the period over which it will calculate the sample rate. This setting defaults
	# to 30.
	# Eligible for live reload.
	ClearFrequency = "60s"

[dataset2]

	# EMADynamicSampler is a section of the config for manipulating the Exponential
	# Moving Average (EMA) Dynamic Sampler implementation. Like the simple DynamicSampler,
	# it attempts to average a given sample rate, weighting rare traffic and frequent
	# traffic differently so as to end up with the correct average.
	#
	# EMADynamicSampler is an improvement upon the simple DynamicSampler and is recommended
	# for most use cases. Based on the DynamicSampler implementation, EMADynamicSampler differs
	# in that rather than compute rate based on a periodic sample of traffic, it maintains an Exponential
	# Moving Average of counts seen per key, and adjusts this average at regular intervals.
	# The weight applied to more recent intervals is defined by `weight`, a number between
	# (0, 1) - larger values weight the average more toward recent observations. In other words,
	# a larger weight will cause sample rates more quickly adapt to traffic patterns,
	# while a smaller weight will result in sample rates that are less sensitive to bursts or drops
	# in traffic and thus more consistent over time.
	#
	# Keys that are not found in the EMA will always have a sample
	# rate of 1. Keys that occur more frequently will be sampled on a logarithmic
	# curve. In other words, every key will be represented at least once in any
	# given window and more frequent keys will have their sample rate
	# increased proportionally to wind up with the goal sample rate.
	Sampler = "EMADynamicSampler"

	# GoalSampleRate is the goal rate at which to sample. It indicates a ratio, where
	# one sample trace is kept for every n traces seen. For example, a SampleRate of
	# 30 will keep 1 out of every 30 traces. This rate is handed to the dynamic
	# sampler, who assigns a sample rate for each trace based on the fields selected
	# from that trace.
	# Eligible for live reload.
	GoalSampleRate = 2

	# FieldList is a list of all the field names to use to form the key that will be handed to the dynamic sampler.
	# The combination of values from all of these fields should reflect how interesting the trace is compared to
    # another. A good field selection has consistent values for high-frequency, boring traffic, and unique values for
	# outliers and interesting traffic. Including an error field (or something like HTTP status code) is an excellent
	# choice. Using fields with very high cardinality (like `k8s.pod.id`), is a bad choice. If the combination of
	# fields essentially makes them unique, the dynamic sampler will sample everything. If the combination of fields is
	# not unique enough, you will not be guaranteed samples of the most interesting traces. As an example, consider a
	# combination of HTTP endpoint (high-frequency and boring), HTTP method, and status code (normally boring but can
	# become interesting when indicating an error) as a good set of fields since it will allowing proper sampling
	# of all endpoints under normal traffic and call out when there is failing traffic to any endpoint.
	# For example, in contrast, consider a combination of HTTP endpoint, status code, and pod id as a bad set of
	# fields, since it would result in keys that are all unique, and therefore results in sampling 100% of traces.
	# Using only the HTTP endpoint field would be a **bad** choice, as it is not unique enough and therefore
	# interesting traces, like traces that experienced a `500`, might not be sampled.
	# Field names may come from any span in the trace.
	# Eligible for live reload.
	FieldList = ["request.method", "http.target", "response.status_code"]

	# UseTraceLength will add the number of spans in the trace into the dynamic
	# sampler as part of the key. The number of spans is exact, so if there are
	# normally small variations in trace length you may want to leave this off. If
	# traces are consistent lengths and changes in trace length is a useful
	# indicator of traces you'd like to see in Honeycomb, set this to true.
	# Eligible for live reload.
	UseTraceLength = true

	# AddSampleRateKeyToTrace when this is set to true, the sampler will add a field
	# to the root span of the trace containing the key used by the sampler to decide
	# the sample rate. This can be helpful in understanding why the sampler is
	# making certain decisions about sample rate and help you understand how to
	# better choose the sample rate key (aka the FieldList setting above) to use.
	AddSampleRateKeyToTrace = true

	# AddSampleRateKeyToTraceField is the name of the field the sampler will use
	# when adding the sample rate key to the trace. This setting is only used when
	# AddSampleRateKeyToTrace is true.
	AddSampleRateKeyToTraceField = "meta.refinery.dynsampler_key"

	# AdjustmentInterval defines how often (in seconds) we adjust the moving average from
	# recent observations. Default 15s
	# Eligible for live reload.
	AdjustmentInterval = 15

	# Weight is a value between (0, 1) indicating the weighting factor used to adjust
	# the EMA. With larger values, newer data will influence the average more, and older
	# values will be factored out more quickly.  In mathematical literature concerning EMA,
	# this is referred to as the `alpha` constant.
	# Default is 0.5
	# Eligible for live reload.
	Weight = 0.5

	# MaxKeys, if greater than 0, limits the number of distinct keys tracked in EMA.
	# Once MaxKeys is reached, new keys will not be included in the sample rate map, but
	# existing keys will continue to be be counted. You can use this to keep the sample rate
	# map size under control.
	# Eligible for live reload
	MaxKeys = 0

	# AgeOutValue indicates the threshold for removing keys from the EMA. The EMA of any key
	# will approach 0 if it is not repeatedly observed, but will never truly reach it, so we have to
	# decide what constitutes "zero". Keys with averages below this threshold will be removed
	# from the EMA. Default is the same as Weight, as this prevents a key with the smallest
	# integer value (1) from being aged out immediately. This value should generally be <= Weight,
	# unless you have very specific reasons to set it higher.
	# Eligible for live reload
	AgeOutValue = 0.5

	# BurstMultiple, if set, is multiplied by the sum of the running average of counts to define
	# the burst detection threshold. If total counts observed for a given interval exceed the threshold
	# EMA is updated immediately, rather than waiting on the AdjustmentInterval.
	# Defaults to 2; negative value disables. With a default of 2, if your traffic suddenly doubles,
	# burst detection will kick in.
	# Eligible for live reload
	BurstMultiple = 2.0

	# BurstDetectionDelay indicates the number of intervals to run after Start is called before
	# burst detection kicks in.
	# Defaults to 3
	# Eligible for live reload
	BurstDetectionDelay = 3

[dataset3]

	Sampler = "DeterministicSampler"
	SampleRate = 10

[dataset4]

	Sampler = "RulesBasedSampler"
	# Optional, if set to true then the rules will also check nested json fields, in the format of parent.child
	CheckNestedFields = false

	[[dataset4.rule]]
		name = "drop healthchecks"
		drop = true
		[[dataset4.rule.condition]]
			field = "http.route"
			operator = "="
			value = "/health-check"

	[[dataset4.rule]]
		name = "keep slow 500 errors"
		SampleRate = 1
		[[dataset4.rule.condition]]
			field = "status_code"
			operator = "="
			value = 500
		[[dataset4.rule.condition]]
			field = "duration_ms"
			operator = ">="
			value = 1000.789

	[[dataset4.rule]]
		name = "dynamically sample 200 responses"
		[[dataset4.rule.condition]]
			field = "status_code"
			operator = "="
			value = 200
		[dataset4.rule.sampler.EMADynamicSampler]
			Sampler = "EMADynamicSampler"
			GoalSampleRate = 15
			FieldList = ["request.method", "request.route"]
			AddSampleRateKeyToTrace = true
			AddSampleRateKeyToTraceField = "meta.refinery.dynsampler_key"

	# Note that Refinery comparisons are type-dependent. If you are operating in an environment where different
	# telemetry may send the same field with different types (for example, some systems send status codes as "200"
	# instead of 200), you may wish to use the "datatype" setting to force them all to the same type.
	[[dataset4.rule]]
		name = "dynamically sample 200 string responses"
		[[dataset4.rule.condition]]
			field = "status_code"
			operator = "="
			value = "200"
			datatype = "int"
		[dataset4.rule.sampler.EMADynamicSampler]
			Sampler = "EMADynamicSampler"
			GoalSampleRate = 15
			FieldList = ["request.method", "request.route"]
			AddSampleRateKeyToTrace = true
			AddSampleRateKeyToTraceField = "meta.refinery.dynsampler_key"

	[[dataset4.rule]]
		name = "sample traces originating from a service"
		# if scope is set to "span", a single span in the trace must match
		# *all* of the conditions associated with this rule for the rule to
		# apply to the trace.
		#
		# this is especially helpful when sampling a dataset written to
		# by multiple services that call one another in normal operation –
		# you can set Scope to 'span' to attribute traces to an origin
		# service in a way that would be difficult without it.
		Scope = "span"
		SampleRate = 5
		[[dataset4.rule.condition]]
			field = "service name"
			operator = "="
			value = "users"
		[[dataset4.rule.condition]]
			field = "trace.parent_id"
			operator = "="
			value = "root"

	[[dataset4.rule]]
		SampleRate = 10 # default when no rules match, if missing defaults to 10

[dataset5]

    Sampler = "TotalThroughputSampler"
    GoalThroughputPerSec = 100
    FieldList = ["request.method"]