Debian Codegraph @

otel/internal/utils/spanattributes_test.go

raw
1 package utils_test
2
3 import (
4 "fmt"
5 "net/http"
6 "testing"
7
8 "github.com/stretchr/testify/assert"
9 "go.opentelemetry.io/otel/attribute"
10 semconv "go.opentelemetry.io/otel/semconv/v1.12.0"
11 oteltrace "go.opentelemetry.io/otel/trace"
12
13 "github.com/getsentry/sentry-go"
14 "github.com/getsentry/sentry-go/otel/internal/utils"
15 )
16
17 func TestParseSpanAttributes(t *testing.T) {
18 t.Run("Handles HTTP spans", func(t *testing.T) {
19 t.Run("Prefers httpRoute over httpTarget", func(t *testing.T) {
20 span := &mockReadOnlySpan{
21 name: "<overridden>",
22 spanKind: oteltrace.SpanKindServer,
23 attributes: []attribute.KeyValue{
24 semconv.HTTPMethodKey.String(http.MethodOptions),
25 semconv.HTTPTargetKey.String("/projects/123/settings?q=proj#123"),
26 semconv.HTTPRouteKey.String("/projects/:projectID/settings"),
27 semconv.HTTPURLKey.String("https://sentry.io/projects/:projectID/settings?q=proj#123"),
28 },
29 }
30
31 parsed := utils.ParseSpanAttributes(span)
32 assert.Equal(t, "OPTIONS /projects/:projectID/settings", parsed.Description)
33 assert.Equal(t, "http.server", parsed.Op)
34 assert.Equal(t, sentry.SourceRoute, parsed.Source)
35 })
36
37 t.Run("Falls back to httpTarget when httpRoute is missing", func(t *testing.T) {
38 span := &mockReadOnlySpan{
39 name: "<overridden>",
40 spanKind: oteltrace.SpanKindClient,
41 attributes: []attribute.KeyValue{
42 semconv.HTTPMethodKey.String(http.MethodGet),
43 semconv.HTTPTargetKey.String("/users?page=2"),
44 semconv.HTTPURLKey.String("https://sentry.io/users?page=2"),
45 },
46 }
47
48 parsed := utils.ParseSpanAttributes(span)
49 assert.Equal(t, "GET /users", parsed.Description)
50 assert.Equal(t, "http.client", parsed.Op)
51 assert.Equal(t, sentry.SourceURL, parsed.Source)
52 })
53
54 t.Run("Falls back to httpUrl if route and target are missing", func(t *testing.T) {
55 span := &mockReadOnlySpan{
56 name: "<overridden>",
57 spanKind: oteltrace.SpanKindClient,
58 attributes: []attribute.KeyValue{
59 semconv.HTTPMethodKey.String(http.MethodGet),
60 semconv.HTTPURLKey.String("https://sentry.io/api/v1/issues?limit=10"),
61 },
62 }
63
64 parsed := utils.ParseSpanAttributes(span)
65 assert.Equal(t, "GET https://sentry.io/api/v1/issues", parsed.Description)
66 assert.Equal(t, "http.client", parsed.Op)
67 assert.Equal(t, sentry.SourceURL, parsed.Source)
68 })
69
70 t.Run("Uses fallback when no URL info exists", func(t *testing.T) {
71 span := &mockReadOnlySpan{
72 name: "Some description",
73 spanKind: oteltrace.SpanKindClient,
74 attributes: []attribute.KeyValue{
75 semconv.HTTPMethodKey.String(http.MethodGet),
76 },
77 }
78
79 parsed := utils.ParseSpanAttributes(span)
80 assert.Equal(t, "Some description", parsed.Description)
81 assert.Equal(t, "http.client", parsed.Op)
82 assert.Equal(t, sentry.SourceCustom, parsed.Source)
83 })
84 })
85
86 t.Run("Falls back to raw httpTarget when URL parsing fails", func(t *testing.T) {
87 invalidTarget := "://bad:url::not_valid"
88 span := &mockReadOnlySpan{
89 name: "<overridden>",
90 spanKind: oteltrace.SpanKindServer,
91 attributes: []attribute.KeyValue{
92 semconv.HTTPMethodKey.String(http.MethodGet),
93 semconv.HTTPTargetKey.String(invalidTarget),
94 },
95 }
96
97 parsed := utils.ParseSpanAttributes(span)
98 assert.Equal(t, fmt.Sprintf("GET %s", invalidTarget), parsed.Description)
99 assert.Equal(t, "http.server", parsed.Op)
100 assert.Equal(t, sentry.SourceURL, parsed.Source)
101 })
102
103 t.Run("Handles DB spans", func(t *testing.T) {
104 t.Run("Includes DB statement in description", func(t *testing.T) {
105 stmt := "SELECT * FROM users"
106 span := &mockReadOnlySpan{
107 name: "<overridden>",
108 attributes: []attribute.KeyValue{
109 semconv.DBSystemKey.String("postgresql"),
110 semconv.DBStatementKey.String(stmt),
111 },
112 }
113
114 parsed := utils.ParseSpanAttributes(span)
115 assert.Equal(t, stmt, parsed.Description)
116 assert.Equal(t, "db", parsed.Op)
117 assert.Equal(t, sentry.SourceTask, parsed.Source)
118 })
119 })
120
121 t.Run("Handles RPC spans", func(t *testing.T) {
122 span := &mockReadOnlySpan{
123 name: "rpc call",
124 attributes: []attribute.KeyValue{
125 semconv.RPCSystemKey.String("grpc"),
126 },
127 }
128
129 parsed := utils.ParseSpanAttributes(span)
130 assert.Equal(t, "rpc", parsed.Op)
131 assert.Equal(t, "rpc call", parsed.Description)
132 assert.Equal(t, sentry.SourceRoute, parsed.Source)
133 })
134
135 t.Run("Handles Messaging spans", func(t *testing.T) {
136 span := &mockReadOnlySpan{
137 name: "publish event",
138 attributes: []attribute.KeyValue{
139 semconv.MessagingSystemKey.String("kafka"),
140 },
141 }
142
143 parsed := utils.ParseSpanAttributes(span)
144 assert.Equal(t, "messaging", parsed.Op)
145 assert.Equal(t, "publish event", parsed.Description)
146 assert.Equal(t, sentry.SourceRoute, parsed.Source)
147 })
148
149 t.Run("Handles FaaS spans", func(t *testing.T) {
150 span := &mockReadOnlySpan{
151 name: "lambda triggered",
152 attributes: []attribute.KeyValue{
153 semconv.FaaSTriggerKey.String("http"),
154 },
155 }
156
157 parsed := utils.ParseSpanAttributes(span)
158 assert.Equal(t, "http", parsed.Op)
159 assert.Equal(t, "lambda triggered", parsed.Description)
160 assert.Equal(t, sentry.SourceRoute, parsed.Source)
161 })
162
163 t.Run("Handles unknown span types", func(t *testing.T) {
164 span := &mockReadOnlySpan{
165 name: "some span",
166 attributes: []attribute.KeyValue{},
167 }
168
169 parsed := utils.ParseSpanAttributes(span)
170 assert.Equal(t, "", parsed.Op)
171 assert.Equal(t, "some span", parsed.Description)
172 assert.Equal(t, sentry.SourceCustom, parsed.Source)
173 })
174 }