Merge branch 'main' into push-ulqypuyoyylv

Author: nsrip-dd

.github/workflows/all-green.yml

@@ -21,3 +21,9 @@ jobs:
         with:
           initial-delay-seconds: "1000"  # smoke tests takes approx 20 mn to finish
           max-retries: "60"
+          ignored-name-patterns: |
+            devflow/merge
+
+# Reason for ignored-name-patterns:
+#
+# * devflow/merge: technical job used by the merge queue, do not remove it.

MIGRATING.md

@@ -2,13 +2,13 @@
 
 This document outlines migrating from an older version of the Datadog tracer (v1.x.x) to v2.
 
-Datadog's v2 version of the Go tracer provides a huge refactor of our API, moving away from interfaces to provide flexibility in future works, isolating our integrations to prevent false-positives from security scanners, and enforcing proper library patterns to prevent misuse. This update is the result of continuous feedback from customers, the community, as well as our extensive internal usage.
+Datadog's v2 version of the Go tracer provides a significant refactor of our API, moving away from interfaces to provide flexibility in future works, isolating our integrations to prevent false-positives from security scanners, and enforcing proper library patterns to prevent misuse. This update is the result of continuous feedback from customers, the community, as well as our extensive internal usage, introducing better maintainability, simplified APIs, and unlocking performance benefits.
 
 As is common and recommended in the Go community, the best way to approach migrating to this new API is by using the [gradual code repair](https://talks.golang.org/2016/refactor.article) method. We have done the same internally and it has worked just great! For this exact reason we have provided a new, [semver](https://semver.org/) friendly import path to help with using both tracers in parallel, without conflict, for the duration of the migration. This new path is `github.com/DataDog/dd-trace-go/v2`.
 
 We have also provided a new migration tool to help with the most essential changes made in v2, which you can read about [here](./tools/v2fix/README.md).
 
-Our [godoc page](https://godoc.org/github.com/DataDog/dd-trace-go/v2/ddtrace) should deem helpful during this process. We also have the [official documentation](https://docs.datadoghq.com/tracing/setup/go/), which contains a couple of examples.
+Our [godoc page](https://pkg.go.dev/github.com/DataDog/dd-trace-go/v2/ddtrace) should be helpful during this process. We also have the [official documentation](https://docs.datadoghq.com/tracing/setup/go/), which contains a couple of examples.
 
 This document will further outline some _before_ and _after_ examples.
 
@@ -28,7 +28,7 @@ import "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer"
 
 It is important to note that when using our contrib libraries, import URLs may be impacted differently. This will be covered in the next section:
 
-## Independent Contrib Packages
+### Independent Contrib Packages
 
 This version upgrade comes with a large overhaul of what was previously one single package that held all of our integrations. In v2, we introduce independent packages for each of our contribs, which will prevent false-positives in security scanners that were caused by indirect dependencies. As a result, importing contribs will also change. Before:
 
@@ -59,18 +59,48 @@ var sp *tracer.Span = tracer.StartSpan("opname")
 var ctx *tracer.SpanContext = sp.Context()
 ```
 
-## WithService()
+### Deprecated ddtrace interfaces
 
-The previously deprecated `tracer.WithServiceName()` has been fully removed and replaced with the method `tracer.WithService()`. If you would like to specify a service name upon starting the tracer, you would have before:
+All the interfaces in `ddtrace` have been removed in favor of struct types, except for `SpanContext`. The new types have moved into `ddtrace/tracer`.
+
+### Deprecated constants and options
+
+The following constants and functions have been removed:
+
+* `ddtrace/ext.AppTypeWeb`
+* `ddtrace/ext.CassandraQuery`
+* `ddtrace/ext.CassandraBatch`
+* `ddtrace/tracer.WithPrioritySampling`; priority sampling is enabled by default.
+* `ddtrace/tracer.WithHTTPRoundTripper`; use `WithHTTPClient` instead.
+
+### StartChild
+
+Child spans can be started with StartChild rather than ChildOf. Before:
 
 ```go
-tracer.Start(tracer.WithServiceName("service"))
+import "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer"
+
+func main() {
+  tracer.Start()
+	defer tracer.Stop()
+
+	parent := tracer.StartSpan("op").Context()
+	child := tracer.StartSpan("op", tracer.ChildOf(parent))
+}
 ```
 
-After:
+Becomes:
 
 ```go
-tracer.Start(tracer.WithService("service"))
+import "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer"
+
+func main() {
+  tracer.Start()
+	defer tracer.Stop()
+
+	parent := tracer.StartSpan("op")
+	child := parent.StartChild("op")
+}
 ```
 
 ## Trace IDs
@@ -90,9 +120,108 @@ fmt.Printf("traceID: %s\n", sp.Context().TraceID()) //recommended for using 128-
 fmt.Printf("traceID: %d\n", sp.Context().TraceIDLower()) // for maintaining old behavior with 64-bit IDs
 ```
 
-## Further reading
+## Span Links API
+
+`Span.AddSpanLink` has been renamed to `Span.AddLink`.
+
+## WithService
+
+The previously deprecated `tracer.WithServiceName()` has been fully removed and replaced with the method `tracer.WithService()`. If you would like to specify a service name upon starting the tracer, you would have before:
+
+```go
+tracer.Start(tracer.WithServiceName("service"))
+```
+
+After:
+
+```go
+tracer.Start(tracer.WithService("service"))
+```
+
+## NewStartSpanConfig, WithStartSpanConfig & WithFinishConfig
+
+These functional options for `ddtrace/tracer.Tracer.StartSpan` and `ddtrace/tracer.Span.Finish` reduces the number of calls (in functional option form) in hot loops by giving the freedom to prepare a common span configuration in hot paths.
+
+Before:
+
+```go
+var err error
+span := tracer.StartSpan(
+	"operation",
+	ChildOf(parent.Context()),
+	Measured(),
+	ResourceName("resource"),
+	ServiceName(service),
+	SpanType(ext.SpanTypeWeb),
+	Tag("key", "value"),
+)
+defer span.Finish(tracer.NoDebugStack())
+```
+
+After:
+
+```go
+cfg := tracer.NewStartSpanConfig(
+	tracer.ChildOf(parent.Context()),
+	tracer.Measured(),
+	tracer.ResourceName("resource"),
+	tracer.ServiceName(service),
+	tracer.SpanType(ext.SpanTypeWeb),
+	tracer.Tag("key", "value"),
+)
+finishCfg := &FinishConfig{
+	NoDebugStack: true,
+}
+// [...]
+// Reuse the configuration in your hot path:
+span := tracer.StartSpan("operation", tracer.WithStartSpanConfig(cfg))
+defer span.Finish(tracer.WithFinishConfig(finishCfg))
+```
+
+## Sampling API simplified
+
+The following functions have been removed in favour of `SpanSamplingRules` and `TraceSamplingRules`:
+
+* `NameRule`
+* `NameServiceRule`
+* `RateRule`
+* `ServiceRule`
+* `SpanNameServiceMPSRule`
+* `SpanNameServiceRule`
+* `SpanTagsResourceRule`
+* `TagsResourceRule`
+
+Also, `ext.SamplingPriority` tag is deprecated. Use `ext.ManualKeep` and `ext.ManualDrop` instead.
+
+## Contrib API
+
+A support package to create contribs without depending on internal packages is available in `instrumentation`. Please refer to [`instrumentation` godoc page](https://pkg.go.dev/github.com/DataDog/dd-trace-go/v2/instrumentation) and existing contribs for more detail.
+
+## Updated User Monitoring SDK for Appsec
+
+`appsec` package offers a new API for user monitoring; essentially deprecating login success & failure event functions, replacing them with versions that accept a `login` field, which is to be used by user monitoring rules (ATO monitoring & protection). Before:
+
+```go
+appsec.TrackUserLoginSuccessEvent(...)
+appsec.TrackUserLoginFailureEvent(...)
+```
+
+Becomes:
+
+```go
+appsec.TrackUserLoginSuccess(...)
+appsec.TrackUserLoginFailure(...)
+```
+
+## API Security sampling
+
+The API Security sampler now takes decisions specific to a given endpoint (method + route + response status code) instead of using a simplistic sampling rate. This allows for improved coverage and accuracy of schema extraction as part of API Security.
+
+## Opentracing deprecation
+
+`opentracer` is in "Maintenance" mode and limited support was offered in `v1`. We recommend to use OpenTelemetry or ddtrace/tracer directly. For additional details, please see our [Support Policy](https://github.com/DataDog/dd-trace-go?tab=readme-ov-file#go-support-policy).
 
-The new version of the tracer also comes with a lot of new features, such as support for distributed tracing and distributed sampling priority. 
+## Further reading 
 
-* package level documentation of the [`tracer` package](https://godoc.org/github.com/DataDog/dd-trace-go/v2/ddtrace/tracer) for a better overview.
+* package level documentation of the [`tracer` package](https://pkg.go.dev/github.com/DataDog/dd-trace-go/v2/ddtrace/tracer) for a better overview.
 * [official documentation](https://docs.datadoghq.com/tracing/setup/go/)

SECURITY.md

@@ -2,7 +2,7 @@
 
 ## Supported Versions
 
-Please see our [Support Policy](README.md#support-policy)
+Please see our [Support Policy](README.md#go-support-policy)
 
 ## Reporting a Vulnerability
 

contrib/README.md

@@ -1,4 +1,4 @@
-[![Godoc](http://img.shields.io/badge/godoc-reference-blue.svg?style=flat)](https://godoc.org/github.com/DataDog/dd-trace-go/v2/contrib)
+[![Godoc](http://img.shields.io/badge/godoc-reference-blue.svg?style=flat)](https://pkg.go.dev/github.com/DataDog/dd-trace-go/v2/contrib)
 
 The purpose of these packages is to provide tracing on top of commonly used packages from the standard library as well as the 
 community in a "plug-and-play" manner. This means that by simply importing the appropriate path, functions are exposed having
@@ -34,7 +34,7 @@ Third, some guidelines to follow on naming functions:
 
 * Use `WithService` instead of `WithServiceName` when setting the service name.
 
-Each integration comes with a thorough documentation and usage examples. A good overview can be seen on our [godoc](https://godoc.org/github.com/DataDog/dd-trace-go/v2/contrib) page.
+Each integration comes with a thorough documentation and usage examples. A good overview can be seen on our [godoc](https://pkg.go.dev/github.com/DataDog/dd-trace-go/v2/contrib) page.
 
 ### Instrumentation telemetry
 

contrib/gomodule/redigo/redigo.go

@@ -190,7 +190,7 @@ func withSpan(ctx context.Context, do func(commandName string, args ...interface
 		span.SetTag(ext.ResourceName, commandName)
 	} else {
 		// When the command argument to the Do method is "", then the Do method will flush the output buffer
-		// See https://godoc.org/github.com/gomodule/redigo/redis#hdr-Pipelining
+		// See https://pkg.go.dev/github.com/gomodule/redigo/redis#hdr-Pipelining
 		span.SetTag(ext.ResourceName, "redigo.Conn.Flush")
 	}
 	var b bytes.Buffer

contrib/graph-gophers/graphql-go/graphql.go

@@ -6,7 +6,7 @@
 // Package graphql provides functions to trace the graph-gophers/graphql-go package (https://github.com/graph-gophers/graphql-go).
 //
 // We use the tracing mechanism available in the
-// https://godoc.org/github.com/graph-gophers/graphql-go/trace subpackage.
+// https://pkg.go.dev/github.com/graph-gophers/graphql-go/trace subpackage.
 // Create a new Tracer with `NewTracer` and pass it as an additional option to
 // `MustParseSchema`.
 package graphql // import "github.com/DataDog/dd-trace-go/contrib/graph-gophers/graphql-go/v2"

ddtrace/ddtrace.go

@@ -9,7 +9,7 @@
 // Additionally, package "ext" provides a set of tag names and values specific to Datadog's APM product.
 //
 // To get started, visit the documentation for any of the packages you'd like to begin
-// with by accessing the subdirectories of this package: https://godoc.org/github.com/DataDog/dd-trace-go/v2/ddtrace#pkg-subdirectories.
+// with by accessing the subdirectories of this package: https://pkg.go.dev/github.com/DataDog/dd-trace-go/v2/ddtrace#pkg-subdirectories.
 package ddtrace // import "github.com/DataDog/dd-trace-go/v2/ddtrace"
 
 // SpanContext represents a span state that can propagate to descendant spans

ddtrace/mocktracer/civisibilitymocktracer.go

@@ -168,8 +168,10 @@ func (t *civisibilitymocktracer) TracerConf() tracer.TracerConf {
 func (t *civisibilitymocktracer) Submit(span *tracer.Span) {
 	t.mock.Submit(span)
 }
-func (t *civisibilitymocktracer) SubmitChunk(chunk *tracer.Chunk) {
-	t.real.SubmitChunk(chunk)
+func (t *civisibilitymocktracer) SubmitChunk(ch *tracer.Chunk) {
+	if mtr, ok := t.real.(interface{ SubmitChunk(*tracer.Chunk) }); ok {
+		mtr.SubmitChunk(ch)
+	}
 }
 
 // Flush forces a flush of both the mock tracer and the real tracer.

ddtrace/tracer/api.txt

@@ -365,8 +365,6 @@ type TextMapCarrier map[string]string
 func Extract(interface{}) (*SpanContext, error)
 func Flush()
 func Inject(*SpanContext, interface{}) (error)
-func NewChunk([]*Span, bool) (*Chunk)
-func NewUnstartedTracer(...StartOption) (Tracer, error)
 func SetUser(*Span, string, ...UserMonitoringOption)
 func Start(...StartOption) (error)
 func StartSpan(string, ...StartSpanOption) (*Span)
@@ -381,8 +379,6 @@ type Tracer interface {
 	func Inject(*SpanContext, interface{}) (error)
 	func StartSpan(string, ...StartSpanOption) (*Span)
 	func Stop()
-	func Submit(*Span)
-	func SubmitChunk(*Chunk)
 	func TracerConf() (TracerConf)
 }
 

ddtrace/tracer/doc.go

@@ -106,5 +106,5 @@
 //
 // Some libraries and frameworks are supported out-of-the-box by using one
 // of our integrations. You can see a list of supported integrations here:
-// https://godoc.org/github.com/DataDog/dd-trace-go/v2/contrib
+// https://pkg.go.dev/github.com/DataDog/dd-trace-go/v2/contrib
 package tracer // import "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer"

ddtrace/tracer/log.go

@@ -62,6 +62,7 @@ type startupInfo struct {
 	PropagationStyleExtract     string                       `json:"propagation_style_extract"` // Propagation style for extract
 	TracingAsTransport          bool                         `json:"tracing_as_transport"`      // Whether the tracer is disabled and other products are using it as a transport
 	DogstatsdAddr               string                       `json:"dogstatsd_address"`         // Destination of statsd payloads
+	DataStreamsEnabled          bool                         `json:"data_streams_enabled"`      // Whether Data Streams is enabled
 }
 
 // checkEndpoint tries to connect to the URL specified by endpoint.
@@ -114,7 +115,6 @@ func logStartup(t *tracer) {
 	} else {
 		agentURL = t.config.transport.endpoint()
 	}
-
 	info := startupInfo{
 		Date:                        time.Now().Format(time.RFC3339),
 		OSName:                      osinfo.OSName(),
@@ -152,6 +152,7 @@ func logStartup(t *tracer) {
 		PropagationStyleExtract:     extractorNames,
 		TracingAsTransport:          t.config.tracingAsTransport,
 		DogstatsdAddr:               t.config.dogstatsdAddr,
+		DataStreamsEnabled:          t.config.dataStreamsMonitoringEnabled,
 	}
 	if _, _, err := samplingRulesFromEnv(); err != nil {
 		info.SamplingRulesError = fmt.Sprintf("%s", err)