Tracing without performance

client.go

@@ -90,7 +90,7 @@ type EventProcessor func(event *Event, hint *EventHint) *Event
 // ApplyToEvent changes an event based on external data and/or
 // an event hint.
 type EventModifier interface {
-	ApplyToEvent(event *Event, hint *EventHint) *Event
+	ApplyToEvent(event *Event, hint *EventHint, client *Client) *Event
 }
 
 var globalEventProcessors []EventProcessor
@@ -685,7 +685,7 @@ func (client *Client) prepareEvent(event *Event, hint *EventHint, scope EventMod
 	}
 
 	if scope != nil {
-		event = scope.ApplyToEvent(event, hint)
+		event = scope.ApplyToEvent(event, hint, client)
 		if event == nil {
 			return nil
 		}

dynamic_sampling_context.go

@@ -78,15 +78,7 @@
 		}
 	}
 
-	if userSegment := scope.user.Segment; userSegment != "" {
-		entries["user_segment"] = userSegment
-	}
-
-	if span.Sampled.Bool() {
-		entries["sampled"] = "true"
-	} else {
-		entries["sampled"] = "false"
-	}
+	entries["sampled"] = strconv.FormatBool(span.Sampled.Bool())
 
 	return DynamicSamplingContext{
 		Entries: entries,
@@ -121,3 +113,43 @@
 
 	return ""
 }
+
+// Constructs a new DynamicSamplingContext using a scope and client. Accessing
+// fields on the scope are not thread safe, and this function should only be
+// called within scope methods.
+func DynamicSamplingContextFromScope(scope *Scope, client *Client) DynamicSamplingContext {
+	entries := map[string]string{}
+
+	if client == nil || scope == nil {
+		return DynamicSamplingContext{
+			Entries: entries,
+			Frozen:  false,
+		}
+	}
+
+	propagationContext := scope.propagationContext
+
+	if traceID := propagationContext.TraceID.String(); traceID != "" {
+		entries["trace_id"] = traceID
+	}
+	if sampleRate := client.options.TracesSampleRate; sampleRate != 0 {
+		entries["sample_rate"] = strconv.FormatFloat(sampleRate, 'f', -1, 64)
+	}
+
+	if dsn := client.dsn; dsn != nil {
+		if publicKey := dsn.publicKey; publicKey != "" {
+			entries["public_key"] = publicKey
+		}
+	}
+	if release := client.options.Release; release != "" {
+		entries["release"] = release
+	}
+	if environment := client.options.Environment; environment != "" {
+		entries["environment"] = environment
+	}
+
+	return DynamicSamplingContext{
+		Entries: entries,
+		Frozen:  true,
+	}
+}

dynamic_sampling_context_test.go

@@ -97,14 +97,13 @@ func TestDynamicSamplingContextFromTransaction(t *testing.T) {
 			want: DynamicSamplingContext{
 				Frozen: true,
 				Entries: map[string]string{
-					"sample_rate":  "1",
-					"trace_id":     "d49d9bf66f13450b81f65bc51cf49c03",
-					"public_key":   "public",
-					"release":      "1.0.0",
-					"environment":  "test",
-					"transaction":  "name",
-					"user_segment": "user_segment",
-					"sampled":      "true",
+					"sample_rate": "1",
+					"trace_id":    "d49d9bf66f13450b81f65bc51cf49c03",
+					"public_key":  "public",
+					"release":     "1.0.0",
+					"environment": "test",
+					"transaction": "name",
+					"sampled":     "true",
 				},
 			},
 		},

http/sentryhttp.go

@@ -136,6 +136,7 @@ func (h *Handler) handle(handler http.Handler) http.HandlerFunc {
 		// level?, ...).
 		r = r.WithContext(transaction.Context())
 		hub.Scope().SetRequest(r)
+
 		defer h.recoverWithSentry(hub, r)
 		handler.ServeHTTP(rw, r)
 	}

hub.go

@@ -2,6 +2,7 @@
 
 import (
 	"context"
+	"fmt"
 	"sync"
 	"time"
 )
@@ -365,6 +366,31 @@
 	return client.Flush(timeout)
 }
 
+// Continue a trace based on HTTP header values. If performance is enabled this
+// returns a SpanOption that can be used to start a transaction, otherwise nil.
+func (hub *Hub) ContinueTrace(trace, baggage string) (SpanOption, error) {
+	scope := hub.Scope()
+	propagationContext, err := PropagationContextFromHeaders(trace, baggage)
+	if err != nil {
+		return nil, err
+	}
+
+	fmt.Printf("Propagation context ContinueTrace: %v \n", propagationContext.Map())
+
+	scope.SetPropagationContext(propagationContext)
+
+	client := hub.Client()
+	if client != nil && client.options.EnableTracing {
+		return ContinueFromHeaders(trace, baggage), nil
+	}
+
+	scope.SetContext("trace", propagationContext.Map())
+
+	fmt.Println("Scope context in ContinueTrace: ", scope.contexts["trace"])
+
+	return nil, nil
+}
+
 // HasHubOnContext checks whether Hub instance is bound to a given Context struct.
 func HasHubOnContext(ctx context.Context) bool {
 	_, ok := ctx.Value(HubContextKey).(*Hub)

mocks_test.go

@@ -14,7 +14,7 @@ func (scope *ScopeMock) AddBreadcrumb(breadcrumb *Breadcrumb, _ int) {
 	scope.breadcrumb = breadcrumb
 }
 
-func (scope *ScopeMock) ApplyToEvent(event *Event, _ *EventHint) *Event {
+func (scope *ScopeMock) ApplyToEvent(event *Event, _ *EventHint, _ *Client) *Event {
 	if scope.shouldDropEvent {
 		return nil
 	}

propagation_context.go

@@ -0,0 +1,90 @@
+package sentry
+
+import (
+	"crypto/rand"
+	"encoding/json"
+)
+
+type PropagationContext struct {
+	TraceID                TraceID                `json:"trace_id"`
+	SpanID                 SpanID                 `json:"span_id"`
+	ParentSpanID           SpanID                 `json:"parent_span_id"`
+	DynamicSamplingContext DynamicSamplingContext `json:"-"`
+}
+
+func (p PropagationContext) MarshalJSON() ([]byte, error) {
+	type propagationContext PropagationContext
+	var parentSpanID string
+	if p.ParentSpanID != zeroSpanID {
+		parentSpanID = p.ParentSpanID.String()
+	}
+	return json.Marshal(struct {
+		*propagationContext
+		ParentSpanID string `json:"parent_span_id,omitempty"`
+	}{
+		propagationContext: (*propagationContext)(&p),
+		ParentSpanID:       parentSpanID,
+	})
+}
+
+func (p PropagationContext) Map() map[string]interface{} {
+	m := map[string]interface{}{
+		"trace_id": p.TraceID,
+		"span_id":  p.SpanID,
+	}
+
+	if p.ParentSpanID != zeroSpanID {
+		m["parent_span_id"] = p.ParentSpanID
+	}
+
+	return m
+}
+
+func NewPropagationContext() PropagationContext {
+	p := PropagationContext{}
+
+	if _, err := rand.Read(p.TraceID[:]); err != nil {
+		panic(err)
+	}
+
+	if _, err := rand.Read(p.SpanID[:]); err != nil {
+		panic(err)
+	}
+
+	return p
+}
+
+func PropagationContextFromHeaders(trace, baggage string) (PropagationContext, error) {
+	p := NewPropagationContext()
+
+	if _, err := rand.Read(p.SpanID[:]); err != nil {
+		panic(err)
+	}
+
+	hasTrace := false
+	if trace != "" {
+		if tpc, valid := ParseTraceParentContext([]byte(trace)); valid {
+			hasTrace = true
+			p.TraceID = tpc.TraceID
+			p.ParentSpanID = tpc.ParentSpanID
+		}
+	}
+
+	if baggage != "" {
+		dsc, err := DynamicSamplingContextFromHeader([]byte(baggage))
+		if err != nil {
+			return PropagationContext{}, err
+		}
+		p.DynamicSamplingContext = dsc
+	}
+
+	// In case a sentry-trace header is present but there are no sentry-related
+	// values in the baggage, create an empty, frozen DynamicSamplingContext.
+	if hasTrace && !p.DynamicSamplingContext.HasEntries() {
+		p.DynamicSamplingContext = DynamicSamplingContext{
+			Frozen: true,
+		}
+	}
+
+	return p, nil
+}

propagation_context_test.go

@@ -0,0 +1,133 @@
+package sentry
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+)
+
+func TestPropagationContextMarshalJSON(t *testing.T) {
+	v := NewPropagationContext()
+	b, err := json.Marshal(v)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if bytes.Contains(b, []byte("parent_span_id")) {
+		t.Fatalf("unwanted parent_span_id: %s", b)
+	}
+
+	v.ParentSpanID = SpanIDFromHex("b72fa28504b07285")
+	b2, err := json.Marshal(v)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Contains(b2, []byte("parent_span_id")) {
+		t.Fatalf("missing parent_span_id: %s", b)
+	}
+}
+
+func TestPropagationContextMap(t *testing.T) {
+	p := NewPropagationContext()
+	assertEqual(t,
+		p.Map(),
+		map[string]interface{}{
+			"trace_id": p.TraceID,
+			"span_id":  p.SpanID,
+		},
+		"without parent span id")
+
+	p.ParentSpanID = SpanIDFromHex("b72fa28504b07285")
+	assertEqual(t,
+		p.Map(),
+		map[string]interface{}{
+			"trace_id":       p.TraceID,
+			"span_id":        p.SpanID,
+			"parent_span_id": p.ParentSpanID,
+		},
+		"without praent span id")
+}
+
+func TestPropagationContextFromHeaders(t *testing.T) {
+	tests := []struct {
+		traceStr   string
+		baggageStr string
+		want       PropagationContext
+	}{
+		{
+			// No sentry-trace or baggage => nothing to do, unfrozen DSC
+			traceStr:   "",
+			baggageStr: "",
+			want: PropagationContext{
+				DynamicSamplingContext: DynamicSamplingContext{
+					Frozen:  false,
+					Entries: nil,
+				},
+			},
+		},
+		{
+			// Third-party baggage => nothing to do, unfrozen DSC
+			traceStr:   "",
+			baggageStr: "other-vendor-key1=value1;value2, other-vendor-key2=value3",
+			want: PropagationContext{
+				DynamicSamplingContext: DynamicSamplingContext{
+					Frozen:  false,
+					Entries: map[string]string{},
+				},
+			},
+		},
+		{
+			// sentry-trace and no baggage => we should create a new DSC and freeze it
+			// immediately.
+			traceStr:   "bc6d53f15eb88f4320054569b8c553d4-b72fa28504b07285-1",
+			baggageStr: "",
+			want: PropagationContext{
+				TraceID:      TraceIDFromHex("bc6d53f15eb88f4320054569b8c553d4"),
+				ParentSpanID: SpanIDFromHex("b72fa28504b07285"),
+				DynamicSamplingContext: DynamicSamplingContext{
+					Frozen: true,
+				},
+			},
+		},
+		{
+			traceStr:   "bc6d53f15eb88f4320054569b8c553d4-b72fa28504b07285-1",
+			baggageStr: "sentry-trace_id=d49d9bf66f13450b81f65bc51cf49c03,sentry-public_key=public,sentry-sample_rate=1",
+			want: PropagationContext{
+				TraceID:      TraceIDFromHex("bc6d53f15eb88f4320054569b8c553d4"),
+				ParentSpanID: SpanIDFromHex("b72fa28504b07285"),
+				DynamicSamplingContext: DynamicSamplingContext{
+					Frozen: true,
+					Entries: map[string]string{
+						"public_key":  "public",
+						"sample_rate": "1",
+						"trace_id":    "d49d9bf66f13450b81f65bc51cf49c03",
+					},
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		p, err := PropagationContextFromHeaders(tt.traceStr, tt.baggageStr)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if tt.want.TraceID != zeroTraceID && p.TraceID != tt.want.TraceID {
+			t.Errorf("got TraceID = %s, want %s", p.TraceID, tt.want.TraceID)
+		}
+
+		if p.TraceID == zeroTraceID {
+			t.Errorf("got TraceID = %s, want non-zero", p.TraceID)
+		}
+
+		if p.ParentSpanID != tt.want.ParentSpanID {
+			t.Errorf("got ParentSpanID = %s, want %s", p.ParentSpanID, tt.want.ParentSpanID)
+		}
+
+		if p.SpanID == zeroSpanID {
+			t.Errorf("got SpanID = %s, want non-zero", p.SpanID)
+		}
+
+		assertEqual(t, p.DynamicSamplingContext, tt.want.DynamicSamplingContext)
+	}
+}