temporal/common/telemetry/config_test.go at main · wei-hai-clickup/temporal · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
package telemetry_test

import (
	"testing"
	"time"

	"github.com/stretchr/testify/require"
	"go.temporal.io/server/common/telemetry"
	"gopkg.in/yaml.v3"
)

var basicOTLPTraceOnlyConfig = `
exporters:
  - kind:
      signal: traces
      model: otlp
      protocol: grpc
    spec:
      headers:
        a: b
        c: d
      timeout: 10s
      retry:
        enabled: true
        initial_interval: 1s
        max_interval: 1s
        max_elapsed_time: 1s
      connection:
        block: false
        insecure: true
        endpoint: localhost:4317
`

var sharedConnOTLPConfig = `
otel:
  connections:
    - kind: grpc
      metadata:
        name: conn1
      spec:
        endpoint: localhost:4317
  exporters:
    - kind:
        signal: traces
        model: otlp
        protocol: grpc
      spec:
        connection_name: conn1
    - kind:
        signal: metrics
        model: otlp
        protocol: grpc
      spec:
        connection_name: conn1
`

func TestEmptyConfig(t *testing.T) {
	cfg := telemetry.ExportConfig{}
	exporters, err := cfg.SpanExporters()
	require.NoError(t, err)
	require.Len(t, exporters, 0)
}

func TestExportersWithSharedConn(t *testing.T) {
	root := struct{ Otel telemetry.PrivateExportConfig }{}
	err := yaml.Unmarshal([]byte(sharedConnOTLPConfig), &root)
	require.NoError(t, err)
	cfg := &root.Otel

	spanExporters, err := cfg.SpanExporters()
	require.NoError(t, err)
	require.Len(t, spanExporters, 1)

	metricExporters, err := cfg.MetricExporters()
	require.NoError(t, err)
	require.Len(t, metricExporters, 1)
}

func TestSharedConn(t *testing.T) {
	root := struct{ Otel telemetry.PrivateExportConfig }{}
	err := yaml.Unmarshal([]byte(sharedConnOTLPConfig), &root)
	require.NoError(t, err)
	cfg := &root.Otel
	require.Len(t, cfg.Connections, 1)
	require.Len(t, cfg.Exporters, 2)

	exp := cfg.Exporters[0]
	require.Equal(t, exp.Kind.Signal, "traces")
	require.Equal(t, exp.Kind.Model, "otlp")
	require.Equal(t, exp.Kind.Protocol, "grpc")
	require.NotNil(t, exp.Spec)
	sspec, ok := exp.Spec.(*telemetry.OTLPGRPCSpanExporter)
	require.True(t, ok)
	require.Equal(t, "conn1", sspec.ConnectionName)

	exp = cfg.Exporters[1]
	require.Equal(t, exp.Kind.Signal, "metrics")
	require.Equal(t, exp.Kind.Model, "otlp")
	require.Equal(t, exp.Kind.Protocol, "grpc")
	require.NotNil(t, exp.Spec)
	mspec, ok := exp.Spec.(*telemetry.OTLPGRPCMetricExporter)
	require.True(t, ok)
	require.Equal(t, "conn1", mspec.ConnectionName)
}

func TestOTLPTraceGRPC(t *testing.T) {
	cfg := telemetry.PrivateExportConfig{}
	err := yaml.Unmarshal([]byte(basicOTLPTraceOnlyConfig), &cfg)
	require.NoError(t, err)
	require.Len(t, cfg.Connections, 0)
	require.Len(t, cfg.Exporters, 1)

	exp := cfg.Exporters[0]
	require.Equal(t, exp.Kind.Signal, "traces")
	require.Equal(t, exp.Kind.Model, "otlp")
	require.Equal(t, exp.Kind.Protocol, "grpc")
	require.NotNil(t, exp.Spec)

	spec, ok := exp.Spec.(*telemetry.OTLPGRPCSpanExporter)
	require.True(t, ok)
	require.Equal(t, map[string]string{"a": "b", "c": "d"}, spec.Headers)
	require.Equal(t, 10*time.Second, spec.Timeout)
	require.True(t, spec.Retry.Enabled)
	require.Equal(t, time.Second, spec.Retry.InitialInterval)
	require.Equal(t, time.Second, spec.Retry.MaxInterval)
	require.Equal(t, time.Second, spec.Retry.MaxElapsedTime)

	conn := spec.Connection
	require.True(t, conn.Insecure)
	require.Equal(t, "localhost:4317", conn.Endpoint)
	require.False(t, conn.Block)
}