[exporter/datadog]: add ignore_resources configuration option

exporter/datadogexporter/blocklister.go

@@ -0,0 +1,61 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package datadogexporter
+
+import (
+	"regexp"
+
+	"github.com/DataDog/datadog-agent/pkg/trace/exportable/pb"
+)
+
+// From: https://github.com/DataDog/datadog-agent/blob/a6872e436681ea2136cf8a67465e99fdb4450519/pkg/trace/filters/blacklister.go#L15-L19
+// Blocklister holds a list of regular expressions which will match resources
+// on spans that should be dropped.
+type Blocklister struct {
+	list []*regexp.Regexp
+}
+
+// From: https://github.com/DataDog/datadog-agent/blob/a6872e436681ea2136cf8a67465e99fdb4450519/pkg/trace/filters/blacklister.go#L21-L29
+// Allows returns true if the Blocklister permits this span.
+func (f *Blocklister) Allows(span *pb.Span) bool {
+	for _, entry := range f.list {
+		if entry.MatchString(span.Resource) {
+			return false
+		}
+	}
+	return true
+}
+
+// From: https://github.com/DataDog/datadog-agent/blob/a6872e436681ea2136cf8a67465e99fdb4450519/pkg/trace/filters/blacklister.go#L41-L45
+// NewBlocklister creates a new Blocklister based on the given list of
+// regular expressions.
+func NewBlocklister(exprs []string) *Blocklister {
+	return &Blocklister{list: compileRules(exprs)}
+}
+
+// From: https://github.com/DataDog/datadog-agent/blob/a6872e436681ea2136cf8a67465e99fdb4450519/pkg/trace/filters/blacklister.go#L47-L59
+// compileRules compiles as many rules as possible from the list of expressions.
+func compileRules(exprs []string) []*regexp.Regexp {
+	list := make([]*regexp.Regexp, 0, len(exprs))
+	for _, entry := range exprs {
+		rule, err := regexp.Compile(entry)
+		if err != nil {
+			// log.Errorf("Invalid resource filter: %q", entry)
+			continue
+		}
+		list = append(list, rule)
+	}
+	return list
+}

exporter/datadogexporter/blocklister_test.go

@@ -0,0 +1,85 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package datadogexporter
+
+import (
+	"testing"
+
+	"github.com/DataDog/datadog-agent/pkg/trace/exportable/pb"
+	"github.com/stretchr/testify/assert"
+)
+
+// https://github.com/DataDog/datadog-agent/blob/d3a4cd66314d70162e2c76d2481f4b93455cf717/pkg/trace/test/testutil/span.go#L372
+// TestSpan returns a fix span with hardcoded info, useful for reproducible tests
+func testSpan() *pb.Span {
+	return &pb.Span{
+		Duration: 10000000,
+		Error:    0,
+		Resource: "GET /some/raclette",
+		Service:  "django",
+		Name:     "django.controller",
+		SpanID:   42,
+		Start:    1472732573337575936,
+		TraceID:  424242,
+		Meta: map[string]string{
+			"user": "eric",
+			"pool": "fondue",
+		},
+		Metrics: map[string]float64{
+			"cheese_weight": 100000.0,
+		},
+		ParentID: 1111,
+		Type:     "http",
+	}
+}
+
+func TestBlocklister(t *testing.T) {
+	tests := []struct {
+		filter      []string
+		resource    string
+		expectation bool
+	}{
+		{[]string{"/foo/bar"}, "/foo/bar", false},
+		{[]string{"/foo/b.r"}, "/foo/bar", false},
+		{[]string{"[0-9]+"}, "/abcde", true},
+		{[]string{"[0-9]+"}, "/abcde123", false},
+		{[]string{"\\(foobar\\)"}, "(foobar)", false},
+		{[]string{"\\(foobar\\)"}, "(bar)", true},
+		{[]string{"(GET|POST) /healthcheck"}, "GET /foobar", true},
+		{[]string{"(GET|POST) /healthcheck"}, "GET /healthcheck", false},
+		{[]string{"(GET|POST) /healthcheck"}, "POST /healthcheck", false},
+		{[]string{"SELECT COUNT\\(\\*\\) FROM BAR"}, "SELECT COUNT(*) FROM BAR", false},
+		{[]string{"[123"}, "[123", true},
+		{[]string{"\\[123"}, "[123", false},
+		{[]string{"ABC+", "W+"}, "ABCCCC", false},
+		{[]string{"ABC+", "W+"}, "WWW", false},
+	}
+
+	for _, test := range tests {
+		span := testSpan()
+		span.Resource = test.resource
+		filter := NewBlocklister(test.filter)
+
+		assert.Equal(t, test.expectation, filter.Allows(span))
+	}
+}
+
+func TestCompileRules(t *testing.T) {
+	filter := NewBlocklister([]string{"[123", "]123", "{6}"})
+	for i := 0; i < 100; i++ {
+		span := testSpan()
+		assert.True(t, filter.Allows(span))
+	}
+}

exporter/datadogexporter/config/config.go

@@ -97,6 +97,12 @@ type TracesConfig struct {
 	// meaning no sampling. If you want to send one event out of every 250
 	// times Send() is called, you would specify 250 here.
 	SampleRate uint `mapstructure:"sample_rate"`
+
+	// ignored resources
+	// A blacklist of regular expressions can be provided to disable certain traces based on their resource name
+	// all entries must be surrounded by double quotes and separated by commas.
+	// ignore_resources: ["(GET|POST) /healthcheck"]
+	IgnoreResources []string `mapstructure:"ignore_resources"`
 }
 
 // TagsConfig defines the tag-related configuration
@@ -224,5 +230,9 @@ func (c *Config) Sanitize() error {
 		c.Traces.TCPAddr.Endpoint = fmt.Sprintf("https://trace.agent.%s", c.API.Site)
 	}
 
+	if c.Traces.IgnoreResources == nil {
+		c.Traces.IgnoreResources = []string{}
+	}
+
 	return nil
 }

exporter/datadogexporter/example/config.yaml

@@ -116,6 +116,12 @@ exporters:
       #
       # endpoint: https://api.datadoghq.com
 
+      ## @param ignore_resources - list of strings - optional
+      ## A blacklist of regular expressions can be provided to disable certain traces based on their resource name
+      ## all entries must be surrounded by double quotes and separated by commas.
+      #
+      # ignore_resources: ["(GET|POST) /healthcheck"]      
+
 service:
   pipelines:
     traces:

exporter/datadogexporter/factory.go

@@ -75,6 +75,7 @@ func createDefaultConfig() config.Exporter {
 			TCPAddr: confignet.TCPAddr{
 				Endpoint: "$DD_APM_URL", // If not provided, set during config sanitization
 			},
+			IgnoreResources: []string{},
 		},
 
 		SendMetadata:        true,

exporter/datadogexporter/factory_test.go

@@ -64,6 +64,7 @@ func TestCreateDefaultConfig(t *testing.T) {
 			TCPAddr: confignet.TCPAddr{
 				Endpoint: "$DD_APM_URL",
 			},
+			IgnoreResources: []string{},
 		},
 
 		TagsConfig: ddconfig.TagsConfig{
@@ -131,6 +132,7 @@ func TestLoadConfig(t *testing.T) {
 			TCPAddr: confignet.TCPAddr{
 				Endpoint: "https://trace.agent.datadoghq.eu",
 			},
+			IgnoreResources: []string{},
 		},
 		SendMetadata:        true,
 		OnlyMetadata:        false,
@@ -173,6 +175,7 @@ func TestLoadConfig(t *testing.T) {
 			TCPAddr: confignet.TCPAddr{
 				Endpoint: "https://trace.agent.datadoghq.com",
 			},
+			IgnoreResources: []string{},
 		},
 		SendMetadata:        true,
 		OnlyMetadata:        false,
@@ -257,6 +260,7 @@ func TestLoadConfigEnvVariables(t *testing.T) {
 			TCPAddr: confignet.TCPAddr{
 				Endpoint: "https://trace.agent.datadoghq.test",
 			},
+			IgnoreResources: []string{},
 		},
 		SendMetadata:        true,
 		OnlyMetadata:        false,
@@ -302,6 +306,7 @@ func TestLoadConfigEnvVariables(t *testing.T) {
 			TCPAddr: confignet.TCPAddr{
 				Endpoint: "https://trace.agent.datadoghq.com",
 			},
+			IgnoreResources: []string{},
 		},
 		SendMetadata:        true,
 		OnlyMetadata:        false,

exporter/datadogexporter/traces_exporter.go

@@ -56,6 +56,7 @@ type traceExporter struct {
 	obfuscator     *obfuscate.Obfuscator
 	calculator     *sublayerCalculator
 	client         *datadog.Client
+	blocklister    *Blocklister
 }
 
 var (
@@ -85,6 +86,9 @@ func newTracesExporter(ctx context.Context, params component.ExporterCreateParam
 	// https://github.com/DataDog/datadog-serverless-functions/blob/11f170eac105d66be30f18eda09eca791bc0d31b/aws/logs_monitoring/trace_forwarder/cmd/trace/main.go#L43
 	obfuscator := obfuscate.NewObfuscator(obfuscatorConfig)
 
+	// a blocklist for dropping ignored resources
+	blocklister := NewBlocklister(cfg.Traces.IgnoreResources)
+
 	calculator := &sublayerCalculator{sc: stats.NewSublayerCalculator()}
 	exporter := &traceExporter{
 		params:         params,
@@ -94,6 +98,7 @@ func newTracesExporter(ctx context.Context, params component.ExporterCreateParam
 		obfuscator:     obfuscator,
 		calculator:     calculator,
 		client:         client,
+		blocklister:    blocklister,
 	}
 
 	return exporter
@@ -131,7 +136,7 @@ func (exp *traceExporter) pushTraceData(
 	// convert traces to datadog traces and group trace payloads by env
 	// we largely apply the same logic as the serverless implementation, simplified a bit
 	// https://github.com/DataDog/datadog-serverless-functions/blob/f5c3aedfec5ba223b11b76a4239fcbf35ec7d045/aws/logs_monitoring/trace_forwarder/cmd/trace/main.go#L61-L83
-	ddTraces, ms := convertToDatadogTd(td, exp.calculator, exp.cfg)
+	ddTraces, ms := convertToDatadogTd(td, exp.calculator, exp.cfg, exp.blocklister)
 
 	// group the traces by env to reduce the number of flushes
 	aggregatedTraces := aggregateTracePayloadsByEnv(ddTraces)

exporter/datadogexporter/traces_exporter_test.go

@@ -81,6 +81,7 @@ func testTracesExporterHelper(td pdata.Traces, t *testing.T) []string {
 			TCPAddr: confignet.TCPAddr{
 				Endpoint: server.URL,
 			},
+			IgnoreResources: []string{},
 		},
 	}
 

exporter/datadogexporter/translate_traces.go

@@ -57,7 +57,7 @@ const (
 )
 
 // converts Traces into an array of datadog trace payloads grouped by env
-func convertToDatadogTd(td pdata.Traces, calculator *sublayerCalculator, cfg *config.Config) ([]*pb.TracePayload, []datadog.Metric) {
+func convertToDatadogTd(td pdata.Traces, calculator *sublayerCalculator, cfg *config.Config, blk *Blocklister) ([]*pb.TracePayload, []datadog.Metric) {
 	// TODO:
 	// do we apply other global tags, like version+service, to every span or only root spans of a service
 	// should globalTags['service'] take precedence over a trace's resource.service.name? I don't believe so, need to confirm
@@ -77,7 +77,7 @@ func convertToDatadogTd(td pdata.Traces, calculator *sublayerCalculator, cfg *co
 			hostname = resHostname
 		}
 
-		payload := resourceSpansToDatadogSpans(rs, calculator, hostname, cfg)
+		payload := resourceSpansToDatadogSpans(rs, calculator, hostname, cfg, blk)
 		traces = append(traces, &payload)
 
 		ms := metrics.DefaultMetrics("traces", uint64(pushTime))
@@ -115,7 +115,7 @@ func aggregateTracePayloadsByEnv(tracePayloads []*pb.TracePayload) []*pb.TracePa
 }
 
 // converts a Trace's resource spans into a trace payload
-func resourceSpansToDatadogSpans(rs pdata.ResourceSpans, calculator *sublayerCalculator, hostname string, cfg *config.Config) pb.TracePayload {
+func resourceSpansToDatadogSpans(rs pdata.ResourceSpans, calculator *sublayerCalculator, hostname string, cfg *config.Config, blk *Blocklister) pb.TracePayload {
 	// get env tag
 	env := cfg.Env
 
@@ -168,7 +168,29 @@ func resourceSpansToDatadogSpans(rs pdata.ResourceSpans, calculator *sublayerCal
 		}
 	}
 
-	for _, apiTrace := range apiTraces {
+	for traceID, apiTrace := range apiTraces {
+		// first drop trace if root span exists in trace chunk that is on blocklist (drop trace no stats).
+		// In the dd-agent, the blocklist/blacklist behavior can be performed before most of the expensive
+		// operations on the span.
+		// See: https://github.com/DataDog/datadog-agent/blob/a6872e436681ea2136cf8a67465e99fdb4450519/pkg/trace/agent/agent.go#L200
+		// However, in our case, the span must be converted from otlp span into a dd span first. This is for 2 reasons.
+		// First, DD trace chunks rec'd by datadog-agent v0.4+ endpoint are expected as arrays of spans grouped by trace id.
+		// But, since OTLP groups by arrays of spans from the same instrumentation library, not trace-id,
+		// (contrib-instrumention-redis, contrib-instrumention-rails, etc), we have to iterate
+		// over batch and group all spans by trace id.
+		// Second, otlp->dd conversion is what creates the resource name that we are checking in the blocklist.
+		// Note: OTLP also groups by ResourceSpans but practically speaking a payload will usually only
+		// contain 1 ResourceSpan array.
+
+		// Root span is used to carry some trace-level metadata, such as sampling rate and priority.
+		rootSpan := utils.GetRoot(apiTrace)
+
+		if !blk.Allows(rootSpan) {
+			//TODO: do we need to delete if we're skipping appending to payload?
+			delete(apiTraces, traceID)
+			continue
+		}
+
 		// calculates analyzed spans for use in trace search and app analytics
 		// appends a specific piece of metadata to these spans marking them as analyzed
 		// TODO: allow users to configure specific spans to be marked as an analyzed spans for app analytics
@@ -246,11 +268,13 @@ func spanToDatadogSpan(s pdata.Span,
 	// we can then set Error field when creating and predefine a max meta capacity
 	isSpanError := getSpanErrorAndSetTags(s, tags)
 
+	resourceName := getDatadogResourceName(s, tags)
+
 	span := &pb.Span{
 		TraceID:  decodeAPMTraceID(s.TraceID().Bytes()),
 		SpanID:   decodeAPMSpanID(s.SpanID().Bytes()),
 		Name:     getDatadogSpanName(s, tags),
-		Resource: getDatadogResourceName(s, tags),
+		Resource: resourceName,
 		Service:  normalizedServiceName,
 		Start:    int64(startTime),
 		Duration: duration,