From 2e7bf1cb7b7475bcd1f5f49c4be794a2d0223767 Mon Sep 17 00:00:00 2001 From: Kyle Nusbaum Date: Thu, 25 Jun 2020 12:46:32 -0500 Subject: [PATCH] updates --- ddtrace/tracer/metrics_test.go | 2 +- ddtrace/tracer/option_test.go | 16 +++---- ddtrace/tracer/sampler.go | 75 +++++++++++++++++++------------- ddtrace/tracer/sampler_test.go | 22 ++++++---- ddtrace/tracer/span_test.go | 16 +++---- ddtrace/tracer/startup.go | 21 +++++---- ddtrace/tracer/textmap_test.go | 12 ++--- ddtrace/tracer/tracer.go | 22 +++++++--- ddtrace/tracer/tracer_test.go | 48 ++++++++++---------- ddtrace/tracer/transport_test.go | 2 +- 10 files changed, 133 insertions(+), 103 deletions(-) diff --git a/ddtrace/tracer/metrics_test.go b/ddtrace/tracer/metrics_test.go index 8225b5b244..45ef0e5122 100644 --- a/ddtrace/tracer/metrics_test.go +++ b/ddtrace/tracer/metrics_test.go @@ -245,7 +245,7 @@ func (tg *testStatsdClient) Wait(n int, d time.Duration) error { func TestReportRuntimeMetrics(t *testing.T) { var tg testStatsdClient - trc := newUnstartedTracer(withStatsdClient(&tg)) + trc, _ := newUnstartedTracer(withStatsdClient(&tg)) trc.wg.Add(1) go func() { diff --git a/ddtrace/tracer/option_test.go b/ddtrace/tracer/option_test.go index 5b091d4ac5..96542c8385 100644 --- a/ddtrace/tracer/option_test.go +++ b/ddtrace/tracer/option_test.go @@ -53,7 +53,7 @@ func TestTracerOptionsDefaults(t *testing.T) { t.Run("dogstatsd", func(t *testing.T) { t.Run("default", func(t *testing.T) { - tracer := newTracer() + tracer, _ := newTracer() c := tracer.config assert.Equal(t, c.dogstatsdAddr, "localhost:8125") }) @@ -61,7 +61,7 @@ func TestTracerOptionsDefaults(t *testing.T) { t.Run("env-host", func(t *testing.T) { os.Setenv("DD_AGENT_HOST", "my-host") defer os.Unsetenv("DD_AGENT_HOST") - tracer := newTracer() + tracer, _ := newTracer() c := tracer.config assert.Equal(t, c.dogstatsdAddr, "my-host:8125") }) @@ -69,7 +69,7 @@ func TestTracerOptionsDefaults(t *testing.T) { t.Run("env-port", func(t *testing.T) { os.Setenv("DD_DOGSTATSD_PORT", "123") defer os.Unsetenv("DD_DOGSTATSD_PORT") - tracer := newTracer() + tracer, _ := newTracer() c := tracer.config assert.Equal(t, c.dogstatsdAddr, "localhost:123") }) @@ -79,7 +79,7 @@ func TestTracerOptionsDefaults(t *testing.T) { os.Setenv("DD_DOGSTATSD_PORT", "123") defer os.Unsetenv("DD_AGENT_HOST") defer os.Unsetenv("DD_DOGSTATSD_PORT") - tracer := newTracer() + tracer, _ := newTracer() c := tracer.config assert.Equal(t, c.dogstatsdAddr, "my-host:123") }) @@ -87,13 +87,13 @@ func TestTracerOptionsDefaults(t *testing.T) { t.Run("env-env", func(t *testing.T) { os.Setenv("DD_ENV", "testEnv") defer os.Unsetenv("DD_ENV") - tracer := newTracer() + tracer, _ := newTracer() c := tracer.config assert.Equal(t, "testEnv", c.env) }) t.Run("option", func(t *testing.T) { - tracer := newTracer(WithDogstatsdAddress("10.1.0.12:4002")) + tracer, _ := newTracer(WithDogstatsdAddress("10.1.0.12:4002")) c := tracer.config assert.Equal(t, c.dogstatsdAddr, "10.1.0.12:4002") }) @@ -104,14 +104,14 @@ func TestTracerOptionsDefaults(t *testing.T) { defer os.Unsetenv("DD_ENV") assert := assert.New(t) env := "production" - tracer := newTracer(WithEnv(env)) + tracer, _ := newTracer(WithEnv(env)) c := tracer.config assert.Equal(env, c.env) }) t.Run("other", func(t *testing.T) { assert := assert.New(t) - tracer := newTracer( + tracer, _ := newTracer( WithSampler(NewRateSampler(0.5)), WithAgentAddr("ddagent.consul.local:58126"), WithGlobalTag("k", "v"), diff --git a/ddtrace/tracer/sampler.go b/ddtrace/tracer/sampler.go index 53af13c4e2..b35c2bae39 100644 --- a/ddtrace/tracer/sampler.go +++ b/ddtrace/tracer/sampler.go @@ -14,6 +14,7 @@ import ( "strconv" "sync" "time" + "fmt" "gopkg.in/DataDog/dd-trace-go.v1/ddtrace" "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/ext" @@ -185,42 +186,54 @@ func newRulesSampler(rules []SamplingRule) *rulesSampler { } } -// appliedSamplingRules validates the user-provided rules and returns an internal representation. -// If the DD_TRACE_SAMPLING_RULES environment variable is set, it will replace the given rules. -func appliedSamplingRules(rules []SamplingRule) []SamplingRule { +func samplingRulesFromEnv() ([]SamplingRule, error) { rulesFromEnv := os.Getenv("DD_TRACE_SAMPLING_RULES") - if rulesFromEnv != "" { - rules = rules[:0] - jsonRules := []struct { - Service string `json:"service"` - Name string `json:"name"` - Rate json.Number `json:"sample_rate"` - }{} - err := json.Unmarshal([]byte(rulesFromEnv), &jsonRules) + if rulesFromEnv == "" { + return nil, nil + } + //var rules []SamplingRule + rules := make([]SamplingRule, 0) + jsonRules := []struct { + Service string `json:"service"` + Name string `json:"name"` + Rate json.Number `json:"sample_rate"` + }{} + err := json.Unmarshal([]byte(rulesFromEnv), &jsonRules) + if err != nil { + log.Warn("error parsing DD_TRACE_SAMPLING_RULES: %v", err) + return nil, fmt.Errorf("error parsing DD_TRACE_SAMPLING_RULES: %v", err) + } + var errStr string + for _, v := range jsonRules { + if v.Rate == "" { + log.Warn("error parsing rule: rate not provided") + errStr += "error parsing rule: rate not provided" + continue + } + rate, err := v.Rate.Float64() if err != nil { - log.Warn("error parsing DD_TRACE_SAMPLING_RULES: %v", err) - return nil + log.Warn("error parsing rule: invalid rate: %v", err) + errStr += fmt.Sprintf("error parsing rule: invalid rate: %v", err) + continue } - for _, v := range jsonRules { - if v.Rate == "" { - log.Warn("error parsing rule: rate not provided") - continue - } - rate, err := v.Rate.Float64() - if err != nil { - log.Warn("error parsing rule: invalid rate: %v", err) - continue - } - switch { - case v.Service != "" && v.Name != "": - rules = append(rules, NameServiceRule(v.Name, v.Service, rate)) - case v.Service != "": - rules = append(rules, ServiceRule(v.Service, rate)) - case v.Name != "": - rules = append(rules, NameRule(v.Name, rate)) - } + switch { + case v.Service != "" && v.Name != "": + rules = append(rules, NameServiceRule(v.Name, v.Service, rate)) + case v.Service != "": + rules = append(rules, ServiceRule(v.Service, rate)) + case v.Name != "": + rules = append(rules, NameRule(v.Name, rate)) } } + if errStr != "" { + return rules, fmt.Errorf("WARN parsing DD_TRACE_SAMPLING_RULES: %s", errStr) + } + return rules, nil +} + +// appliedSamplingRules validates the user-provided rules and returns an internal representation. +// If the DD_TRACE_SAMPLING_RULES environment variable is set, it will replace the given rules. +func appliedSamplingRules(rules []SamplingRule) []SamplingRule { validRules := make([]SamplingRule, 0, len(rules)) for _, v := range rules { if !(v.Rate >= 0.0 && v.Rate <= 1.0) { diff --git a/ddtrace/tracer/sampler_test.go b/ddtrace/tracer/sampler_test.go index 618aca4431..5ebdbe67bd 100644 --- a/ddtrace/tracer/sampler_test.go +++ b/ddtrace/tracer/sampler_test.go @@ -234,41 +234,45 @@ func TestRuleEnvVars(t *testing.T) { t.Run("sampling-rules", func(t *testing.T) { assert := assert.New(t) defer os.Unsetenv("DD_TRACE_SAMPLING_RULES") - // represents hard-coded rules - rules := []SamplingRule{ - RateRule(1.0), - } + // env overrides provided rules os.Setenv("DD_TRACE_SAMPLING_RULES", "[]") + rules, _ := samplingRulesFromEnv() validRules := appliedSamplingRules(rules) assert.Len(validRules, 0) // valid rules os.Setenv("DD_TRACE_SAMPLING_RULES", `[{"service": "abcd", "sample_rate": 1.0}]`) + rules, _ = samplingRulesFromEnv() validRules = appliedSamplingRules(rules) assert.Len(validRules, 1) os.Setenv("DD_TRACE_SAMPLING_RULES", `[{"service": "abcd", "sample_rate": 1.0},`+ `{"name": "wxyz", "sample_rate": 0.9},`+ `{"service": "efgh", "name": "lmnop", "sample_rate": 0.42}]`) + rules, _ = samplingRulesFromEnv() validRules = appliedSamplingRules(rules) assert.Len(validRules, 3) // invalid rule ignored os.Setenv("DD_TRACE_SAMPLING_RULES", `[{"service": "abcd", "sample_rate": 42.0}]`) + rules, _ = samplingRulesFromEnv() validRules = appliedSamplingRules(rules) assert.Len(validRules, 0) os.Setenv("DD_TRACE_SAMPLING_RULES", `[{"service": "abcd", "sample_rate": "all of them"}]`) + rules, _ = samplingRulesFromEnv() validRules = appliedSamplingRules(rules) assert.Len(validRules, 0) os.Setenv("DD_TRACE_SAMPLING_RULES", `[{"service": "abcd"}]`) + rules, _ = samplingRulesFromEnv() validRules = appliedSamplingRules(rules) assert.Len(validRules, 0) os.Setenv("DD_TRACE_SAMPLING_RULES", `not JSON at all`) + rules, _ = samplingRulesFromEnv() validRules = appliedSamplingRules(rules) assert.Len(validRules, 0) }) @@ -368,7 +372,7 @@ func TestRulesSamplerConcurrency(t *testing.T) { NameServiceRule("db.query", "postgres.db", 1.0), NameRule("notweb.request", 1.0), } - tracer := newTracer(WithSamplingRules(rules)) + tracer, _ := newTracer(WithSamplingRules(rules)) span := func(wg *sync.WaitGroup) { defer wg.Done() tracer.StartSpan("db.query", ServiceName("postgres.db")).Finish() @@ -537,7 +541,7 @@ func BenchmarkRulesSampler(b *testing.B) { } b.Run("no-rules", func(b *testing.B) { - tracer := newUnstartedTracer() + tracer, _ := newUnstartedTracer() benchmarkStartSpan(b, tracer) }) @@ -547,7 +551,7 @@ func BenchmarkRulesSampler(b *testing.B) { NameServiceRule("db.query", "postgres.db", 1.0), NameRule("notweb.request", 1.0), } - tracer := newUnstartedTracer(WithSamplingRules(rules)) + tracer, _ := newUnstartedTracer(WithSamplingRules(rules)) benchmarkStartSpan(b, tracer) }) @@ -557,7 +561,7 @@ func BenchmarkRulesSampler(b *testing.B) { NameServiceRule("db.query", "postgres.db", 1.0), NameRule("web.request", 1.0), } - tracer := newUnstartedTracer(WithSamplingRules(rules)) + tracer, _ := newUnstartedTracer(WithSamplingRules(rules)) benchmarkStartSpan(b, tracer) }) @@ -587,7 +591,7 @@ func BenchmarkRulesSampler(b *testing.B) { NameRule("notweb.request", 1.0), NameRule("web.request", 1.0), } - tracer := newUnstartedTracer(WithSamplingRules(rules)) + tracer, _ := newUnstartedTracer(WithSamplingRules(rules)) benchmarkStartSpan(b, tracer) }) } diff --git a/ddtrace/tracer/span_test.go b/ddtrace/tracer/span_test.go index 7927aff02d..7bb5c35f9c 100644 --- a/ddtrace/tracer/span_test.go +++ b/ddtrace/tracer/span_test.go @@ -67,7 +67,7 @@ func TestSpanOperationName(t *testing.T) { func TestSpanFinish(t *testing.T) { assert := assert.New(t) wait := time.Millisecond * 2 - tracer := newTracer(withTransport(newDefaultTransport())) + tracer, _ := newTracer(withTransport(newDefaultTransport())) span := tracer.newRootSpan("pylons.request", "pylons", "/") // the finish should set finished and the duration @@ -219,7 +219,7 @@ func TestSpanSetDatadogTags(t *testing.T) { func TestSpanStart(t *testing.T) { assert := assert.New(t) - tracer := newTracer(withTransport(newDefaultTransport())) + tracer, _ := newTracer(withTransport(newDefaultTransport())) span := tracer.newRootSpan("pylons.request", "pylons", "/") // a new span sets the Start after the initialization @@ -228,7 +228,7 @@ func TestSpanStart(t *testing.T) { func TestSpanString(t *testing.T) { assert := assert.New(t) - tracer := newTracer(withTransport(newDefaultTransport())) + tracer, _ := newTracer(withTransport(newDefaultTransport())) span := tracer.newRootSpan("pylons.request", "pylons", "/") // don't bother checking the contents, just make sure it works. assert.NotEqual("", span.String()) @@ -286,7 +286,7 @@ func TestSpanSetMetric(t *testing.T) { } { t.Run(name, func(t *testing.T) { assert := assert.New(t) - tracer := newTracer(withTransport(newDefaultTransport())) + tracer, _ := newTracer(withTransport(newDefaultTransport())) span := tracer.newRootSpan("http.request", "mux.router", "/") tt(assert, span) }) @@ -295,7 +295,7 @@ func TestSpanSetMetric(t *testing.T) { func TestSpanError(t *testing.T) { assert := assert.New(t) - tracer := newTracer(withTransport(newDefaultTransport())) + tracer, _ := newTracer(withTransport(newDefaultTransport())) span := tracer.newRootSpan("pylons.request", "pylons", "/") // check the error is set in the default meta @@ -320,7 +320,7 @@ func TestSpanError(t *testing.T) { func TestSpanError_Typed(t *testing.T) { assert := assert.New(t) - tracer := newTracer(withTransport(newDefaultTransport())) + tracer, _ := newTracer(withTransport(newDefaultTransport())) span := tracer.newRootSpan("pylons.request", "pylons", "/") // check the error is set in the default meta @@ -334,7 +334,7 @@ func TestSpanError_Typed(t *testing.T) { func TestSpanErrorNil(t *testing.T) { assert := assert.New(t) - tracer := newTracer(withTransport(newDefaultTransport())) + tracer, _ := newTracer(withTransport(newDefaultTransport())) span := tracer.newRootSpan("pylons.request", "pylons", "/") // don't set the error if it's nil @@ -375,7 +375,7 @@ func TestSpanModifyWhileFlushing(t *testing.T) { func TestSpanSamplingPriority(t *testing.T) { assert := assert.New(t) - tracer := newTracer(withTransport(newDefaultTransport())) + tracer, _ := newTracer(withTransport(newDefaultTransport())) span := tracer.newRootSpan("my.name", "my.service", "my.resource") _, ok := span.Metrics[keySamplingPriority] diff --git a/ddtrace/tracer/startup.go b/ddtrace/tracer/startup.go index 34b6f7812e..fd3f0af35c 100644 --- a/ddtrace/tracer/startup.go +++ b/ddtrace/tracer/startup.go @@ -14,9 +14,10 @@ import ( "gopkg.in/DataDog/dd-trace-go.v1/internal/globalconfig" "gopkg.in/DataDog/dd-trace-go.v1/internal/version" + "gopkg.in/DataDog/dd-trace-go.v1/internal/log" ) -type startupLog struct { +type startupInfo struct { // Common startup status Date string `json:"date"` OSName string `json:"os_name"` @@ -33,7 +34,7 @@ type startupLog struct { AnalyticsEnabled bool `json:"analytics_enabled"` SampleRate float64 `json:"sample_rate"` SamplingRules []SamplingRule `json:"sampling_rules"` - SamplingRulesError string `json:"sampling_rules_error"` + SamplingRulesError error `json:"sampling_rules_error"` Tags map[string]interface{} `json:"tags"` RuntimeMetricsEnabled bool `json:"runtime_metrics_enabled"` @@ -46,10 +47,9 @@ func agentReachable(t *tracer) (bool, error) { return false, nil } -func logStartup(t *tracer) { +func newStartupInfo(t *tracer) *startupInfo { reachable, reachableErr := agentReachable(t) - - sl := startupLog{ + return &startupInfo{ Date: time.Now().Format("2006-01-02 15:04:05"), OSName: osName(), OSVersion: osVersion(), @@ -65,15 +65,18 @@ func logStartup(t *tracer) { AnalyticsEnabled: globalconfig.AnalyticsRate() != math.NaN(), SampleRate: t.prioritySampling.defaultRate, SamplingRules: t.rulesSampling.rules, - SamplingRulesError: "TODO", + SamplingRulesError: nil, Tags: t.globalTags, RuntimeMetricsEnabled: t.config.runtimeMetrics, GlobalService: globalconfig.ServiceName(), } - bs, err := json.Marshal(sl) +} + +func logStartup(info *startupInfo) { + bs, err := json.Marshal(info) if err != nil { - fmt.Printf("Failed to serialize json for startup log: %#v\n", sl) + fmt.Printf("Failed to serialize json for startup log: %#v\n", info) return } - fmt.Printf("Startup: %s\n", string(bs)) + log.Warn("Startup: %s\n", string(bs)) } diff --git a/ddtrace/tracer/textmap_test.go b/ddtrace/tracer/textmap_test.go index 626cd68bfd..ec1e858e0d 100644 --- a/ddtrace/tracer/textmap_test.go +++ b/ddtrace/tracer/textmap_test.go @@ -125,7 +125,7 @@ func TestTextMapPropagatorInjectHeader(t *testing.T) { TraceHeader: "tid", ParentHeader: "pid", }) - tracer := newTracer(WithPropagator(propagator)) + tracer, _ := newTracer(WithPropagator(propagator)) root := tracer.StartSpan("web.request").(*span) root.SetBaggageItem("item", "x") @@ -152,7 +152,7 @@ func TestTextMapPropagatorOrigin(t *testing.T) { DefaultTraceIDHeader: "1", DefaultParentIDHeader: "1", }) - tracer := newTracer() + tracer, _ := newTracer() ctx, err := tracer.Extract(src) if err != nil { t.Fatal(err) @@ -179,7 +179,7 @@ func TestTextMapPropagatorInjectExtract(t *testing.T) { TraceHeader: "tid", ParentHeader: "pid", }) - tracer := newTracer(WithPropagator(propagator)) + tracer, _ := newTracer(WithPropagator(propagator)) root := tracer.StartSpan("web.request").(*span) root.SetTag(ext.SamplingPriority, -1) root.SetBaggageItem("item", "x") @@ -206,7 +206,7 @@ func TestB3(t *testing.T) { os.Setenv("DD_PROPAGATION_STYLE_INJECT", "B3") defer os.Unsetenv("DD_PROPAGATION_STYLE_INJECT") - tracer := newTracer() + tracer, _ := newTracer() root := tracer.StartSpan("web.request").(*span) root.SetTag(ext.SamplingPriority, -1) root.SetBaggageItem("item", "x") @@ -231,7 +231,7 @@ func TestB3(t *testing.T) { b3SpanIDHeader: "1", }) - tracer := newTracer() + tracer, _ := newTracer() assert := assert.New(t) ctx, err := tracer.Extract(headers) assert.Nil(err) @@ -252,7 +252,7 @@ func TestB3(t *testing.T) { b3SampledHeader: "1", }) - tracer := newTracer() + tracer, _ := newTracer() assert := assert.New(t) ctx, err := tracer.Extract(b3Headers) diff --git a/ddtrace/tracer/tracer.go b/ddtrace/tracer/tracer.go index b7a1868e6e..e657807c1a 100644 --- a/ddtrace/tracer/tracer.go +++ b/ddtrace/tracer/tracer.go @@ -91,7 +91,9 @@ func Start(opts ...StartOption) { if internal.Testing { return // mock tracer active } - internal.SetGlobalTracer(newTracer(opts...)) + t, info := newTracer(opts...) + internal.SetGlobalTracer(t) + logStartup(info) } // Stop stops the started tracer. Subsequent calls are valid but become no-op. @@ -130,7 +132,11 @@ const payloadQueueSize = 1000 func newUnstartedTracer(opts ...StartOption) *tracer { c := newConfig(opts...) - return &tracer{ + envRules, envRulesErr := samplingRulesFromEnv() + if envRules != nil { + c.samplingRules = envRules + } + t := &tracer{ config: c, payload: newPayload(), payloadChan: make(chan []*span, payloadQueueSize), @@ -140,11 +146,15 @@ func newUnstartedTracer(opts ...StartOption) *tracer { prioritySampling: newPrioritySampler(), pid: strconv.Itoa(os.Getpid()), } + info := newStartupInfo(t) + if envRulesErr != nil { + info.SamplingRulesError = envRulesErr + } + return t, info } -func newTracer(opts ...StartOption) *tracer { - t := newUnstartedTracer(opts...) - logStartup(t) +func newTracer(opts ...StartOption) (*tracer, *startupInfo) { + t, info := newUnstartedTracer(opts...) c := t.config t.config.statsd.Incr("datadog.tracer.started", nil, 1) if c.runtimeMetrics { @@ -172,7 +182,7 @@ func newTracer(opts ...StartOption) *tracer { defer t.wg.Done() t.reportHealthMetrics(statsInterval) }() - return t + return t, info } // worker receives finished traces to be added into the payload, as well diff --git a/ddtrace/tracer/tracer_test.go b/ddtrace/tracer/tracer_test.go index d7a6a4668f..16595f197f 100644 --- a/ddtrace/tracer/tracer_test.go +++ b/ddtrace/tracer/tracer_test.go @@ -175,7 +175,7 @@ func TestTracerStart(t *testing.T) { func TestTracerStartSpan(t *testing.T) { t.Run("generic", func(t *testing.T) { - tracer := newTracer() + tracer, _ := newTracer() span := tracer.StartSpan("web.request").(*span) assert := assert.New(t) assert.NotEqual(uint64(0), span.TraceID) @@ -193,20 +193,20 @@ func TestTracerStartSpan(t *testing.T) { }) t.Run("priority", func(t *testing.T) { - tracer := newTracer() + tracer, _ := newTracer() span := tracer.StartSpan("web.request", Tag(ext.SamplingPriority, ext.PriorityUserKeep)).(*span) assert.Equal(t, float64(ext.PriorityUserKeep), span.Metrics[keySamplingPriority]) }) t.Run("name", func(t *testing.T) { - tracer := newTracer() + tracer, _ := newTracer() span := tracer.StartSpan("/home/user", Tag(ext.SpanName, "db.query")).(*span) assert.Equal(t, "db.query", span.Name) assert.Equal(t, "/home/user", span.Resource) }) t.Run("measured", func(t *testing.T) { - tracer := newTracer() + tracer, _ := newTracer() span := tracer.StartSpan("/home/user", Measured()).(*span) assert.Equal(t, 1.0, span.Metrics[keyMeasured]) }) @@ -215,14 +215,14 @@ func TestTracerStartSpan(t *testing.T) { func TestTracerRuntimeMetrics(t *testing.T) { t.Run("on", func(t *testing.T) { tp := new(testLogger) - tracer := newTracer(WithRuntimeMetrics(), WithLogger(tp), WithDebugMode(true)) + tracer, _ := newTracer(WithRuntimeMetrics(), WithLogger(tp), WithDebugMode(true)) defer tracer.Stop() assert.Contains(t, tp.Lines()[0], "DEBUG: Runtime metrics enabled") }) t.Run("off", func(t *testing.T) { tp := new(testLogger) - tracer := newTracer(WithLogger(tp), WithDebugMode(true)) + tracer, _ := newTracer(WithLogger(tp), WithDebugMode(true)) defer tracer.Stop() assert.Len(t, tp.Lines(), 0) s := tracer.StartSpan("op").(*span) @@ -231,7 +231,7 @@ func TestTracerRuntimeMetrics(t *testing.T) { }) t.Run("spans", func(t *testing.T) { - tracer := newTracer(WithRuntimeMetrics(), WithServiceName("main")) + tracer, _ := newTracer(WithRuntimeMetrics(), WithServiceName("main")) defer tracer.Stop() s := tracer.StartSpan("op").(*span) @@ -244,7 +244,7 @@ func TestTracerRuntimeMetrics(t *testing.T) { } func TestTracerStartSpanOptions(t *testing.T) { - tracer := newTracer() + tracer, _ := newTracer() now := time.Now() opts := []StartSpanOption{ SpanType("test"), @@ -268,7 +268,7 @@ func TestTracerStartSpanOptions(t *testing.T) { func TestTracerStartChildSpan(t *testing.T) { t.Run("own-service", func(t *testing.T) { assert := assert.New(t) - tracer := newTracer() + tracer, _ := newTracer() root := tracer.StartSpan("web.request", ServiceName("root-service")).(*span) child := tracer.StartSpan("db.query", ChildOf(root.Context()), @@ -286,7 +286,7 @@ func TestTracerStartChildSpan(t *testing.T) { t.Run("inherit-service", func(t *testing.T) { assert := assert.New(t) - tracer := newTracer() + tracer, _ := newTracer() root := tracer.StartSpan("web.request", ServiceName("root-service")).(*span) child := tracer.StartSpan("db.query", ChildOf(root.Context())).(*span) @@ -296,7 +296,7 @@ func TestTracerStartChildSpan(t *testing.T) { func TestTracerBaggagePropagation(t *testing.T) { assert := assert.New(t) - tracer := newTracer() + tracer, _ := newTracer() root := tracer.StartSpan("web.request").(*span) root.SetBaggageItem("key", "value") child := tracer.StartSpan("db.query", ChildOf(root.Context())).(*span) @@ -308,7 +308,7 @@ func TestTracerBaggagePropagation(t *testing.T) { func TestStartSpanOrigin(t *testing.T) { assert := assert.New(t) - tracer := newTracer() + tracer, _ := newTracer() carrier := TextMapCarrier(map[string]string{ DefaultTraceIDHeader: "1", @@ -336,7 +336,7 @@ func TestStartSpanOrigin(t *testing.T) { func TestPropagationDefaults(t *testing.T) { assert := assert.New(t) - tracer := newTracer() + tracer, _ := newTracer() root := tracer.StartSpan("web.request").(*span) root.SetBaggageItem("x", "y") root.SetTag(ext.SamplingPriority, -1) @@ -379,7 +379,7 @@ func TestPropagationDefaults(t *testing.T) { func TestTracerSamplingPriorityPropagation(t *testing.T) { assert := assert.New(t) - tracer := newTracer() + tracer, _ := newTracer() root := tracer.StartSpan("web.request", Tag(ext.SamplingPriority, 2)).(*span) child := tracer.StartSpan("db.query", ChildOf(root.Context())).(*span) assert.EqualValues(2, root.Metrics[keySamplingPriority]) @@ -390,7 +390,7 @@ func TestTracerSamplingPriorityPropagation(t *testing.T) { func TestTracerBaggageImmutability(t *testing.T) { assert := assert.New(t) - tracer := newTracer() + tracer, _ := newTracer() root := tracer.StartSpan("web.request").(*span) root.SetBaggageItem("key", "value") child := tracer.StartSpan("db.query", ChildOf(root.Context())).(*span) @@ -402,7 +402,7 @@ func TestTracerBaggageImmutability(t *testing.T) { } func TestTracerSpanTags(t *testing.T) { - tracer := newTracer() + tracer, _ := newTracer() tag := Tag("key", "value") span := tracer.StartSpan("web.request", tag).(*span) assert := assert.New(t) @@ -411,7 +411,7 @@ func TestTracerSpanTags(t *testing.T) { func TestTracerSpanGlobalTags(t *testing.T) { assert := assert.New(t) - tracer := newTracer(WithGlobalTag("key", "value")) + tracer, _ := newTracer(WithGlobalTag("key", "value")) s := tracer.StartSpan("web.request").(*span) assert.Equal("value", s.Meta["key"]) child := tracer.StartSpan("db.query", ChildOf(s.Context())).(*span) @@ -422,7 +422,7 @@ func TestNewSpan(t *testing.T) { assert := assert.New(t) // the tracer must create root spans - tracer := newTracer(withTransport(newDefaultTransport())) + tracer, _ := newTracer(withTransport(newDefaultTransport())) span := tracer.newRootSpan("pylons.request", "pylons", "/") assert.Equal(uint64(0), span.ParentID) assert.Equal("pylons", span.Service) @@ -434,7 +434,7 @@ func TestNewSpanChild(t *testing.T) { assert := assert.New(t) // the tracer must create child spans - tracer := newTracer(withTransport(newDefaultTransport())) + tracer, _ := newTracer(withTransport(newDefaultTransport())) parent := tracer.newRootSpan("pylons.request", "pylons", "/") child := tracer.newChildSpan("redis.command", parent) // ids and services are inherited @@ -448,7 +448,7 @@ func TestNewSpanChild(t *testing.T) { func TestNewRootSpanHasPid(t *testing.T) { assert := assert.New(t) - tracer := newTracer(withTransport(newDefaultTransport())) + tracer, _ := newTracer(withTransport(newDefaultTransport())) root := tracer.newRootSpan("pylons.request", "pylons", "/") assert.Equal(strconv.Itoa(os.Getpid()), root.Meta[ext.Pid]) @@ -457,7 +457,7 @@ func TestNewRootSpanHasPid(t *testing.T) { func TestNewChildHasNoPid(t *testing.T) { assert := assert.New(t) - tracer := newTracer(withTransport(newDefaultTransport())) + tracer, _ := newTracer(withTransport(newDefaultTransport())) root := tracer.newRootSpan("pylons.request", "pylons", "/") child := tracer.newChildSpan("redis.command", root) @@ -468,7 +468,7 @@ func TestTracerSampler(t *testing.T) { assert := assert.New(t) sampler := NewRateSampler(0.9999) // high probability of sampling - tracer := newTracer( + tracer, _ := newTracer( withTransport(newDefaultTransport()), WithSampler(sampler), ) @@ -904,7 +904,7 @@ func TestPushTrace(t *testing.T) { tp := new(testLogger) log.UseLogger(tp) - tracer := newUnstartedTracer() + tracer, _ := newUnstartedTracer() trace := []*span{ &span{ Name: "pylons.request", @@ -1094,7 +1094,7 @@ func startTestTracer(t interface { withTransport(transport), withTickChan(tick), }, opts...) - tracer := newTracer(o...) + tracer, _ := newTracer(o...) internal.SetGlobalTracer(tracer) flushFunc := func(n int) { if n < 0 { diff --git a/ddtrace/tracer/transport_test.go b/ddtrace/tracer/transport_test.go index 01166aa43e..0acbc610a2 100644 --- a/ddtrace/tracer/transport_test.go +++ b/ddtrace/tracer/transport_test.go @@ -252,7 +252,7 @@ func TestWithHTTPClient(t *testing.T) { u, err := url.Parse(srv.URL) assert.NoError(err) rt := new(recordingRoundTripper) - trc := newTracer(WithAgentAddr(u.Host), WithHTTPClient(&http.Client{Transport: rt})) + trc, _ := newTracer(WithAgentAddr(u.Host), WithHTTPClient(&http.Client{Transport: rt})) defer trc.Stop() p, err := encode(getTestTrace(1, 1))