Vihren Atlas

Atlas › Test

TestSlogFromLayeredLogger

go.temporal.io/server/common/log/TestSlogFromLayeredLogger

Package
go.temporal.io/server/common/log
Suite / test hierarchy
TestSlogFromLayeredLogger
Test
TestSlogFromLayeredLogger
Introduced at
slog.go ×16 Joint frontier
Covered ranges
100
Covered lines
477
Covered files
21

Covered source

Expand a file to inspect source; the > gutter marks covered lines.

go.temporal.io/server/common/log/slog.go 65 covered LOC · 22 ranges

Open complete file

27
28 // NewSlogLogger creates an slog.Logger from a given logger.
29 > func NewSlogLogger(logger Logger) *slog.Logger { slog.go
30 > // Try extracting and underlying slog logger (e.g. for Temporal CLI).
31 > if sl, ok := logger.(SLogWrapper); ok {
32 return sl.SLog()
33 }
34 > logger = withIncreasedSkip(logger, 3) slog.go
35 > return slog.New(&handler{logger: logger, zapLogger: extractZapLogger(logger), group: "", tags: nil})
36 }
37
38 // Enabled reports whether the handler handles records at the given level.
39 > func (h *handler) Enabled(_ context.Context, level slog.Level) bool { slog.go
40 > if h.zapLogger == nil {
41 return true
42 }
43 > return h.zapLogger.Core().Enabled(convertSlogToZapLevel(level)) slog.go
44 }
45
46 // Handle implements slog.Handler.
47 > func (h *handler) Handle(_ context.Context, record slog.Record) error { slog.go
48 > tags := make([]tag.Tag, len(h.tags), len(h.tags)+record.NumAttrs())
49 > copy(tags, h.tags)
50 > record.Attrs(func(attr slog.Attr) bool {
51 > tags = append(tags, tag.Zap(convertAttrToField(h.prependGroup(attr))))
52 > return true
53 > })
54 // Not capturing the log location and stack trace here. We seem to not need this functionality since our zapLogger
55 // adds the logging-call-at tag.
56 > switch record.Level { slog.go
57 case slog.LevelDebug:
58 h.logger.Debug(record.Message, tags...)
59 > case slog.LevelInfo: slog.go
60 > h.logger.Info(record.Message, tags...)
61 case slog.LevelWarn:
62 h.logger.Warn(record.Message, tags...)
65 default:
66 }
67 > return nil slog.go
68 }
69
70 // WithAttrs implements slog.Handler.
71 > func (h *handler) WithAttrs(attrs []slog.Attr) slog.Handler { slog.go
72 > tags := make([]tag.Tag, len(h.tags), len(h.tags)+len(attrs))
73 > copy(tags, h.tags)
74 > for _, attr := range attrs {
75 > tags = append(tags, tag.Zap(convertAttrToField(h.prependGroup(attr))))
76 > }
77 > return &handler{logger: h.logger, zapLogger: h.zapLogger, tags: tags, group: h.group}
78 }
79
80 // WithGroup implements slog.Handler.
81 > func (h *handler) WithGroup(name string) slog.Handler { slog.go
82 > group := name
83 > if h.group != "" {
84 > group = h.group + "." + name
85 > }
86 > return &handler{logger: h.logger, zapLogger: h.zapLogger, tags: h.tags, group: group}
87 }
88
89 > func (h *handler) prependGroup(attr slog.Attr) slog.Attr { slog.go
90 > if h.group == "" {
91 > return attr
92 > }
93 > return slog.Attr{Key: h.group + "." + attr.Key, Value: attr.Value}
94 }
95
96 > func extractZapLogger(logger Logger) *zap.Logger { slog.go
97 > switch l := logger.(type) {
98 > case *zapLogger: slog.go
99 > return l.zl
100 > case *throttledLogger: slog.go
101 > return extractZapLogger(l.logger)
102 case *withLogger:
103 return extractZapLogger(l.logger)
107
108 // withIncreasedSkip increases the skip level for the given logger if it embeds a zapLogger.
109 > func withIncreasedSkip(logger Logger, skip int) Logger { slog.go
110 > switch l := logger.(type) {
111 > case *zapLogger: slog.go
112 > return l.Skip(skip)
113 > case *throttledLogger: slog.go
114 > return &throttledLogger{
115 > limiter: l.limiter,
116 > logger: withIncreasedSkip(l.logger, skip),
117 > }
118 case *withLogger:
119 return &withLogger{
129 // Note that there is some room between slog levels while zap levels are continuous, so we can't 1:1 map them.
130 // See also https://go.googlesource.com/proposal/+/master/design/56345-structured-logging.md?pli=1#levels
131 > func convertSlogToZapLevel(l slog.Level) zapcore.Level { slog.go
132 > switch {
133 case l >= slog.LevelError:
134 return zapcore.ErrorLevel
135 case l >= slog.LevelWarn:
136 return zapcore.WarnLevel
137 > case l >= slog.LevelInfo: slog.go
138 > return zapcore.InfoLevel
139 > default:
140 > return zapcore.DebugLevel
141 }
142 }
152 }
153
154 > func convertAttrToField(attr slog.Attr) zapcore.Field { slog.go
155 > if attr.Equal(slog.Attr{}) {
156 // Ignore empty attrs.
157 return zap.Skip()
158 }
159
160 > switch attr.Value.Kind() { slog.go
161 case slog.KindBool:
162 return zap.Bool(attr.Key, attr.Value.Bool())
165 case slog.KindFloat64:
166 return zap.Float64(attr.Key, attr.Value.Float64())
167 > case slog.KindInt64: slog.go
168 > return zap.Int64(attr.Key, attr.Value.Int64())
169 > case slog.KindString:
170 > return zap.String(attr.Key, attr.Value.String())
171 case slog.KindTime:
172 return zap.Time(attr.Key, attr.Value.Time())
go.temporal.io/server/common/log/zap_logger.go 62 covered LOC · 16 ranges

Open complete file

82
83 // NewZapLogger returns a new zap based logger from zap.Logger
84 > func NewZapLogger(zl *zap.Logger) *zapLogger { zap_logger.go
85 > return &zapLogger{
86 > zl: zl,
87 > skip: skipForZapLogger,
88 > baseZl: zl,
89 > }
90 > }
91
92 // BuildZapLogger builds and returns a new zap.Logger for this logging configuration
95 }
96
97 > func caller(skip int) string { zap_logger.go
98 > _, path, line, ok := runtime.Caller(skip)
99 > if !ok {
100 return ""
101 }
102 > return path + ":" + strconv.Itoa(line) zap_logger.go
103 }
104
105 > func (l *zapLogger) buildFieldsWithCallAt(tags []tag.Tag) []zap.Field { zap_logger.go
106 > fields := make([]zap.Field, len(tags)+1)
107 > l.fillFields(tags, fields)
108 > fields[len(fields)-1] = zap.String(tag.LoggingCallAtKey, caller(l.skip))
109 > return fields
110 > }
111
112 // fillFields fill fields parameter with fields read from tags. Optimized for performance.
113 > func (l *zapLogger) fillFields(tags []tag.Tag, fields []zap.Field) { zap_logger.go
114 > for i, t := range tags {
115 > if zt, ok := t.(tag.ZapTag); ok { zap_logger.go
116 > fields[i] = zt.Field()
117 > } else {
118 fields[i] = zap.Any(t.Key(), t.Value())
119 }
121 }
122
123 > func setDefaultMsg(msg string) string { zap_logger.go
124 > if msg == "" {
125 return defaultMsgForEmpty
126 }
127 > return msg zap_logger.go
128 }
129
136 }
137
138 > func (l *zapLogger) Info(msg string, tags ...tag.Tag) { zap_logger.go
139 > if l.zl.Core().Enabled(zap.InfoLevel) {
140 > msg = setDefaultMsg(msg)
141 > fields := l.buildFieldsWithCallAt(tags)
142 > l.zl.Info(msg, fields...)
143 > }
144 }
145
191 //
192 // by deduping "foo" against any existing "foo" tags *only in the former*
193 > func (l *zapLogger) With(tags ...tag.Tag) Logger { zap_logger.go
194 > cloneTags := mergeTags(l.tags, tags)
195 > if l.baseZl == nil {
196 l.baseZl = l.zl
197 }
198 > return l.cloneWithTags(cloneTags) zap_logger.go
199 }
200
201 > func (l *zapLogger) cloneWithTags(tags []tag.Tag) Logger { zap_logger.go
202 > fields := make([]zap.Field, len(tags))
203 > l.fillFields(tags, fields)
204 > zl := l.baseZl.With(fields...)
205 > return &zapLogger{
206 > zl: zl,
207 > skip: l.skip,
208 > baseZl: l.baseZl,
209 > tags: tags,
210 > }
211 > }
212
213 > func (l *zapLogger) Skip(extraSkip int) Logger { zap_logger.go
214 > return &zapLogger{
215 > zl: l.zl,
216 > skip: l.skip + extraSkip,
217 > baseZl: l.baseZl,
218 > }
219 > }
220
221 > func mergeTags(oldTags, newTags []tag.Tag) (outTags []tag.Tag) { zap_logger.go
222 > // Even if oldTags empty, we don't just return newTags because we need to de-dupe it.
223 > outTags = slices.Clone(oldTags)
224 > for _, t := range newTags {
225 > if i := slices.IndexFunc(outTags, func(ti tag.Tag) bool {
226 return ti.Key() == t.Key()
227 }); i >= 0 {
228 outTags[i] = t
229 > } else { zap_logger.go
230 > outTags = append(outTags, t)
231 > }
232 }
233 > return outTags zap_logger.go
234 }
235
go.temporal.io/server/common/log/tag/tags.go 30 covered LOC · 10 ranges

Open complete file

53
54 // ClusterName returns tag for ClusterName
55 > func ClusterName(clusterName string) ZapTag { tags.go
56 > return NewStringTag("cluster-name", clusterName)
57 > }
58
59 // Timestamp returns tag for Timestamp
70
71 // WorkflowAction returns tag for WorkflowAction
72 > func workflowAction(action string) ZapTag { tags.go
73 > return NewStringTag("wf-action", action)
74 > }
75
76 // WorkflowListFilterType returns tag for WorkflowListFilterType
77 > func workflowListFilterType(listFilterType string) ZapTag { tags.go
78 > return NewStringTag("wf-list-filter-type", listFilterType)
79 > }
80
81 // general
376
377 // Component returns tag for Component
378 > func component(component string) ZapTag { tags.go
379 > return NewStringTag("component", component)
380 > }
381
382 // Lifecycle returns tag for Lifecycle
383 > func lifecycle(lifecycle string) ZapTag { tags.go
384 > return NewStringTag("lifecycle", lifecycle)
385 > }
386
387 // StoreOperation returns tag for StoreOperation
388 > func storeOperation(storeOperation string) ZapTag { tags.go
389 > return NewStringTag("store-operation", storeOperation)
390 > }
391
392 // OperationResult returns tag for OperationResult
393 > func operationResult(operationResult string) ZapTag { tags.go
394 > return NewStringTag("operation-result", operationResult)
395 > }
396
397 // ErrorType returns tag for ErrorType
401
402 // errorType returns tag for ErrorType given a string
403 > func errorType(errorType string) ZapTag { tags.go
404 > return NewStringTag("error-type", errorType)
405 > }
406
407 // Shardupdate returns tag for Shardupdate
408 > func shardupdate(shardupdate string) ZapTag { tags.go
409 > return NewStringTag("shard-update", shardupdate)
410 > }
411
412 // scope returns a tag for scope
413 // Pre-defined scope tags are in values.go.
414 > func scope(scope string) ZapTag { tags.go
415 > return NewStringTag("scope", scope)
416 > }
417
418 // general
go.temporal.io/server/common/quotas/rate_burst.go 26 covered LOC · 10 ranges

Open complete file

85 rateFn RateFn,
86 burstFn BurstFn,
87 > ) *RateBurstImpl { rate_burst.go
88 > return &RateBurstImpl{
89 > rateFn: rateFn,
90 > burstFn: burstFn,
91 > }
92 > }
93
94 func NewDefaultIncomingRateBurst(
102 func NewDefaultOutgoingRateBurst(
103 rateFn RateFn,
104 > ) *RateBurstImpl { rate_burst.go
105 > return NewDefaultRateBurst(rateFn, func() float64 {
106 > return defaultOutgoingRateBurstRatio
107 > })
108 }
109
111 rateFn RateFn,
112 rateToBurstRatio BurstRatioFn,
113 > ) *RateBurstImpl { rate_burst.go
114 > burstFn := func() int {
115 > rate := rateFn() rate_burst.go
116 > if rate < 0 {
117 rate = 0
118 }
119
120 > ratio := rateToBurstRatio() rate_burst.go
121 > if ratio < 0 {
122 ratio = 0
123 }
124 > burst := int(rate * ratio) rate_burst.go
125 > if burst == 0 && rate > 0 && ratio > 0 {
126 burst = 1
127 }
128 > return burst rate_burst.go
129 }
130 > return NewRateBurst(rateFn, burstFn) rate_burst.go
131 }
132
133 > func (d *RateBurstImpl) Rate() float64 { rate_burst.go
134 > return d.rateFn()
135 > }
136
137 > func (d *RateBurstImpl) Burst() int { rate_burst.go
138 > return d.burstFn()
139 > }
140
141 func NewMutableRateBurst(
go.temporal.io/server/common/quotas/dynamic_rate_limiter_impl.go 23 covered LOC · 5 ranges

Open complete file

29 rateBurstFn RateBurst,
30 refreshInterval time.Duration,
31 > ) *DynamicRateLimiterImpl { dynamic_rate_limiter_impl.go
32 > rateLimiter := &DynamicRateLimiterImpl{
33 > rateBurstFn: rateBurstFn,
34 > refreshInterval: refreshInterval,
35 >
36 > refreshTimer: time.NewTimer(refreshInterval),
37 > rateLimiter: NewRateLimiter(rateBurstFn.Rate(), rateBurstFn.Burst()),
38 > }
39 > return rateLimiter
40 > }
41
42 // NewDefaultIncomingRateLimiter returns a default rate limiter
57 func NewDefaultOutgoingRateLimiter(
58 rateFn RateFn,
59 > ) *DynamicRateLimiterImpl { dynamic_rate_limiter_impl.go
60 > return NewDynamicRateLimiter(
61 > NewDefaultOutgoingRateBurst(rateFn),
62 > defaultRefreshInterval,
63 > )
64 > }
65
66 // NewDefaultRateLimiter returns a default rate limiter with a dynamic burst ratio
78 // Allow immediately returns with true or false indicating if a rate limit
79 // token is available or not
80 > func (d *DynamicRateLimiterImpl) Allow() bool { dynamic_rate_limiter_impl.go
81 > d.maybeRefresh()
82 > return d.rateLimiter.Allow()
83 > }
84
85 // AllowN immediately returns with true or false indicating if n rate limit
go.temporal.io/server/api/enums/v1/cluster.pb.go 20 covered LOC · 2 ranges

Open complete file

209 }
210
211 > func init() { file_temporal_server_api_enums_v1_cluster_proto_init() } cluster.pb.go
212 > func file_temporal_server_api_enums_v1_cluster_proto_init() {
213 > if File_temporal_server_api_enums_v1_cluster_proto != nil {
214 return
215 }
216 > type x struct{} cluster.pb.go
217 > out := protoimpl.TypeBuilder{
218 > File: protoimpl.DescBuilder{
219 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
220 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_cluster_proto_rawDesc), len(file_temporal_server_api_enums_v1_cluster_proto_rawDesc)),
221 > NumEnums: 2,
222 > NumMessages: 0,
223 > NumExtensions: 0,
224 > NumServices: 0,
225 > },
226 > GoTypes: file_temporal_server_api_enums_v1_cluster_proto_goTypes,
227 > DependencyIndexes: file_temporal_server_api_enums_v1_cluster_proto_depIdxs,
228 > EnumInfos: file_temporal_server_api_enums_v1_cluster_proto_enumTypes,
229 > }.Build()
230 > File_temporal_server_api_enums_v1_cluster_proto = out.File
231 > file_temporal_server_api_enums_v1_cluster_proto_goTypes = nil
232 > file_temporal_server_api_enums_v1_cluster_proto_depIdxs = nil
233 }
go.temporal.io/server/api/enums/v1/common.pb.go 20 covered LOC · 2 ranges

Open complete file

264 }
265
266 > func init() { file_temporal_server_api_enums_v1_common_proto_init() } common.pb.go
267 > func file_temporal_server_api_enums_v1_common_proto_init() {
268 > if File_temporal_server_api_enums_v1_common_proto != nil {
269 return
270 }
271 > type x struct{} common.pb.go
272 > out := protoimpl.TypeBuilder{
273 > File: protoimpl.DescBuilder{
274 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
275 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_common_proto_rawDesc), len(file_temporal_server_api_enums_v1_common_proto_rawDesc)),
276 > NumEnums: 3,
277 > NumMessages: 0,
278 > NumExtensions: 0,
279 > NumServices: 0,
280 > },
281 > GoTypes: file_temporal_server_api_enums_v1_common_proto_goTypes,
282 > DependencyIndexes: file_temporal_server_api_enums_v1_common_proto_depIdxs,
283 > EnumInfos: file_temporal_server_api_enums_v1_common_proto_enumTypes,
284 > }.Build()
285 > File_temporal_server_api_enums_v1_common_proto = out.File
286 > file_temporal_server_api_enums_v1_common_proto_goTypes = nil
287 > file_temporal_server_api_enums_v1_common_proto_depIdxs = nil
288 }
go.temporal.io/server/api/enums/v1/dlq.pb.go 20 covered LOC · 2 ranges

Open complete file

187 }
188
189 > func init() { file_temporal_server_api_enums_v1_dlq_proto_init() } dlq.pb.go
190 > func file_temporal_server_api_enums_v1_dlq_proto_init() {
191 > if File_temporal_server_api_enums_v1_dlq_proto != nil {
192 return
193 }
194 > type x struct{} dlq.pb.go
195 > out := protoimpl.TypeBuilder{
196 > File: protoimpl.DescBuilder{
197 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
198 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_dlq_proto_rawDesc), len(file_temporal_server_api_enums_v1_dlq_proto_rawDesc)),
199 > NumEnums: 2,
200 > NumMessages: 0,
201 > NumExtensions: 0,
202 > NumServices: 0,
203 > },
204 > GoTypes: file_temporal_server_api_enums_v1_dlq_proto_goTypes,
205 > DependencyIndexes: file_temporal_server_api_enums_v1_dlq_proto_depIdxs,
206 > EnumInfos: file_temporal_server_api_enums_v1_dlq_proto_enumTypes,
207 > }.Build()
208 > File_temporal_server_api_enums_v1_dlq_proto = out.File
209 > file_temporal_server_api_enums_v1_dlq_proto_goTypes = nil
210 > file_temporal_server_api_enums_v1_dlq_proto_depIdxs = nil
211 }
go.temporal.io/server/api/enums/v1/fairness_state.pb.go 20 covered LOC · 2 ranges

Open complete file

123 }
124
125 > func init() { file_temporal_server_api_enums_v1_fairness_state_proto_init() } fairness_state.pb.go
126 > func file_temporal_server_api_enums_v1_fairness_state_proto_init() {
127 > if File_temporal_server_api_enums_v1_fairness_state_proto != nil {
128 return
129 }
130 > type x struct{} fairness_state.pb.go
131 > out := protoimpl.TypeBuilder{
132 > File: protoimpl.DescBuilder{
133 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
134 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_fairness_state_proto_rawDesc), len(file_temporal_server_api_enums_v1_fairness_state_proto_rawDesc)),
135 > NumEnums: 1,
136 > NumMessages: 0,
137 > NumExtensions: 0,
138 > NumServices: 0,
139 > },
140 > GoTypes: file_temporal_server_api_enums_v1_fairness_state_proto_goTypes,
141 > DependencyIndexes: file_temporal_server_api_enums_v1_fairness_state_proto_depIdxs,
142 > EnumInfos: file_temporal_server_api_enums_v1_fairness_state_proto_enumTypes,
143 > }.Build()
144 > File_temporal_server_api_enums_v1_fairness_state_proto = out.File
145 > file_temporal_server_api_enums_v1_fairness_state_proto_goTypes = nil
146 > file_temporal_server_api_enums_v1_fairness_state_proto_depIdxs = nil
147 }
go.temporal.io/server/api/enums/v1/nexus.pb.go 20 covered LOC · 2 ranges

Open complete file

158 }
159
160 > func init() { file_temporal_server_api_enums_v1_nexus_proto_init() } nexus.pb.go
161 > func file_temporal_server_api_enums_v1_nexus_proto_init() {
162 > if File_temporal_server_api_enums_v1_nexus_proto != nil {
163 return
164 }
165 > type x struct{} nexus.pb.go
166 > out := protoimpl.TypeBuilder{
167 > File: protoimpl.DescBuilder{
168 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
169 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_nexus_proto_rawDesc), len(file_temporal_server_api_enums_v1_nexus_proto_rawDesc)),
170 > NumEnums: 1,
171 > NumMessages: 0,
172 > NumExtensions: 0,
173 > NumServices: 0,
174 > },
175 > GoTypes: file_temporal_server_api_enums_v1_nexus_proto_goTypes,
176 > DependencyIndexes: file_temporal_server_api_enums_v1_nexus_proto_depIdxs,
177 > EnumInfos: file_temporal_server_api_enums_v1_nexus_proto_enumTypes,
178 > }.Build()
179 > File_temporal_server_api_enums_v1_nexus_proto = out.File
180 > file_temporal_server_api_enums_v1_nexus_proto_goTypes = nil
181 > file_temporal_server_api_enums_v1_nexus_proto_depIdxs = nil
182 }
go.temporal.io/server/api/enums/v1/predicate.pb.go 20 covered LOC · 2 ranges

Open complete file

170 }
171
172 > func init() { file_temporal_server_api_enums_v1_predicate_proto_init() } predicate.pb.go
173 > func file_temporal_server_api_enums_v1_predicate_proto_init() {
174 > if File_temporal_server_api_enums_v1_predicate_proto != nil {
175 return
176 }
177 > type x struct{} predicate.pb.go
178 > out := protoimpl.TypeBuilder{
179 > File: protoimpl.DescBuilder{
180 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
181 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_predicate_proto_rawDesc), len(file_temporal_server_api_enums_v1_predicate_proto_rawDesc)),
182 > NumEnums: 1,
183 > NumMessages: 0,
184 > NumExtensions: 0,
185 > NumServices: 0,
186 > },
187 > GoTypes: file_temporal_server_api_enums_v1_predicate_proto_goTypes,
188 > DependencyIndexes: file_temporal_server_api_enums_v1_predicate_proto_depIdxs,
189 > EnumInfos: file_temporal_server_api_enums_v1_predicate_proto_enumTypes,
190 > }.Build()
191 > File_temporal_server_api_enums_v1_predicate_proto = out.File
192 > file_temporal_server_api_enums_v1_predicate_proto_goTypes = nil
193 > file_temporal_server_api_enums_v1_predicate_proto_depIdxs = nil
194 }
go.temporal.io/server/api/enums/v1/replication.pb.go 20 covered LOC · 2 ranges

Open complete file

314 }
315
316 > func init() { file_temporal_server_api_enums_v1_replication_proto_init() } replication.pb.go
317 > func file_temporal_server_api_enums_v1_replication_proto_init() {
318 > if File_temporal_server_api_enums_v1_replication_proto != nil {
319 return
320 }
321 > type x struct{} replication.pb.go
322 > out := protoimpl.TypeBuilder{
323 > File: protoimpl.DescBuilder{
324 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
325 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_replication_proto_rawDesc), len(file_temporal_server_api_enums_v1_replication_proto_rawDesc)),
326 > NumEnums: 3,
327 > NumMessages: 0,
328 > NumExtensions: 0,
329 > NumServices: 0,
330 > },
331 > GoTypes: file_temporal_server_api_enums_v1_replication_proto_goTypes,
332 > DependencyIndexes: file_temporal_server_api_enums_v1_replication_proto_depIdxs,
333 > EnumInfos: file_temporal_server_api_enums_v1_replication_proto_enumTypes,
334 > }.Build()
335 > File_temporal_server_api_enums_v1_replication_proto = out.File
336 > file_temporal_server_api_enums_v1_replication_proto_goTypes = nil
337 > file_temporal_server_api_enums_v1_replication_proto_depIdxs = nil
338 }
go.temporal.io/server/api/enums/v1/task.pb.go 20 covered LOC · 2 ranges

Open complete file

456 }
457
458 > func init() { file_temporal_server_api_enums_v1_task_proto_init() } task.pb.go
459 > func file_temporal_server_api_enums_v1_task_proto_init() {
460 > if File_temporal_server_api_enums_v1_task_proto != nil {
461 return
462 }
463 > type x struct{} task.pb.go
464 > out := protoimpl.TypeBuilder{
465 > File: protoimpl.DescBuilder{
466 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
467 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_task_proto_rawDesc), len(file_temporal_server_api_enums_v1_task_proto_rawDesc)),
468 > NumEnums: 3,
469 > NumMessages: 0,
470 > NumExtensions: 0,
471 > NumServices: 0,
472 > },
473 > GoTypes: file_temporal_server_api_enums_v1_task_proto_goTypes,
474 > DependencyIndexes: file_temporal_server_api_enums_v1_task_proto_depIdxs,
475 > EnumInfos: file_temporal_server_api_enums_v1_task_proto_enumTypes,
476 > }.Build()
477 > File_temporal_server_api_enums_v1_task_proto = out.File
478 > file_temporal_server_api_enums_v1_task_proto_goTypes = nil
479 > file_temporal_server_api_enums_v1_task_proto_depIdxs = nil
480 }
go.temporal.io/server/api/enums/v1/workflow.pb.go 20 covered LOC · 2 ranges

Open complete file

275 }
276
277 > func init() { file_temporal_server_api_enums_v1_workflow_proto_init() } workflow.pb.go
278 > func file_temporal_server_api_enums_v1_workflow_proto_init() {
279 > if File_temporal_server_api_enums_v1_workflow_proto != nil {
280 return
281 }
282 > type x struct{} workflow.pb.go
283 > out := protoimpl.TypeBuilder{
284 > File: protoimpl.DescBuilder{
285 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
286 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_workflow_proto_rawDesc), len(file_temporal_server_api_enums_v1_workflow_proto_rawDesc)),
287 > NumEnums: 3,
288 > NumMessages: 0,
289 > NumExtensions: 0,
290 > NumServices: 0,
291 > },
292 > GoTypes: file_temporal_server_api_enums_v1_workflow_proto_goTypes,
293 > DependencyIndexes: file_temporal_server_api_enums_v1_workflow_proto_depIdxs,
294 > EnumInfos: file_temporal_server_api_enums_v1_workflow_proto_enumTypes,
295 > }.Build()
296 > File_temporal_server_api_enums_v1_workflow_proto = out.File
297 > file_temporal_server_api_enums_v1_workflow_proto_goTypes = nil
298 > file_temporal_server_api_enums_v1_workflow_proto_depIdxs = nil
299 }
go.temporal.io/server/api/enums/v1/workflow_task_type.pb.go 20 covered LOC · 2 ranges

Open complete file

124 }
125
126 > func init() { file_temporal_server_api_enums_v1_workflow_task_type_proto_init() } workflow_task_type.pb.go
127 > func file_temporal_server_api_enums_v1_workflow_task_type_proto_init() {
128 > if File_temporal_server_api_enums_v1_workflow_task_type_proto != nil {
129 return
130 }
131 > type x struct{} workflow_task_type.pb.go
132 > out := protoimpl.TypeBuilder{
133 > File: protoimpl.DescBuilder{
134 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
135 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_workflow_task_type_proto_rawDesc), len(file_temporal_server_api_enums_v1_workflow_task_type_proto_rawDesc)),
136 > NumEnums: 1,
137 > NumMessages: 0,
138 > NumExtensions: 0,
139 > NumServices: 0,
140 > },
141 > GoTypes: file_temporal_server_api_enums_v1_workflow_task_type_proto_goTypes,
142 > DependencyIndexes: file_temporal_server_api_enums_v1_workflow_task_type_proto_depIdxs,
143 > EnumInfos: file_temporal_server_api_enums_v1_workflow_task_type_proto_enumTypes,
144 > }.Build()
145 > File_temporal_server_api_enums_v1_workflow_task_type_proto = out.File
146 > file_temporal_server_api_enums_v1_workflow_task_type_proto_goTypes = nil
147 > file_temporal_server_api_enums_v1_workflow_task_type_proto_depIdxs = nil
148 }
go.temporal.io/server/common/log/tag/zap_tag.go 18 covered LOC · 4 ranges

Open complete file

26 }
27
28 > func (t ZapTag) Field() zap.Field { zap_tag.go
29 > return t.field
30 > }
31
32 func (t ZapTag) Key() string {
44 }
45
46 > func NewStringTag(key string, value string) ZapTag { zap_tag.go
47 > return ZapTag{
48 > field: zap.String(key, value),
49 > }
50 > }
51
52 func NewStringsTag(key string, value []string) ZapTag {
118 }
119
120 > func NewBoolTag(key string, value bool) ZapTag { zap_tag.go
121 > return ZapTag{
122 > field: zap.Bool(key, value),
123 > }
124 > }
125
126 func NewErrorTag(key string, value error) ZapTag {
236 }
237
238 > func Zap(field zap.Field) ZapTag { zap_tag.go
239 > return ZapTag{
240 > field: field,
241 > }
242 > }
go.temporal.io/server/common/log/throttle_logger.go 18 covered LOC · 5 ranges

Open complete file

21 //
22 // Fatal/Panic/DPanic logs are always emitted without any throttling
23 > func NewThrottledLogger(logger Logger, rps quotas.RateFn) *throttledLogger { throttle_logger.go
24 > if sl, ok := logger.(SkipLogger); ok {
25 > logger = sl.Skip(extraSkipForThrottleLogger) throttle_logger.go
26 > }
27
28 > limiter := quotas.NewDefaultOutgoingRateLimiter(rps) throttle_logger.go
29 > tl := &throttledLogger{
30 > limiter: limiter,
31 > logger: logger,
32 > }
33 > return tl
34 }
35
40 }
41
42 > func (tl *throttledLogger) Info(msg string, tags ...tag.Tag) { throttle_logger.go
43 > tl.rateLimit(func() {
44 > tl.logger.Info(msg, tags...)
45 > })
46 }
47
89 }
90
91 > func (tl *throttledLogger) rateLimit(f func()) { throttle_logger.go
92 > if tl.limiter.Allow() {
93 > f()
94 > }
95 }
96
go.temporal.io/server/common/quotas/clocked_rate_limiter.go 13 covered LOC · 3 ranges

Open complete file

25 )
26
27 > func NewClockedRateLimiter(rateLimiter *rate.Limiter, timeSource clock.TimeSource) ClockedRateLimiter { clocked_rate_limiter.go
28 > return ClockedRateLimiter{
29 > rateLimiter: rateLimiter,
30 > timeSource: timeSource,
31 > recycleCh: make(chan struct{}),
32 > }
33 > }
34
35 > func (l ClockedRateLimiter) Allow() bool { clocked_rate_limiter.go
36 > return l.AllowN(l.timeSource.Now(), 1)
37 > }
38
39 > func (l ClockedRateLimiter) AllowN(now time.Time, token int) bool { clocked_rate_limiter.go
40 > return l.rateLimiter.AllowN(now, token)
41 > }
42
43 // ClockedReservation wraps a rate.Reservation with a clockwork.Clock. It is used to ensure that the reservation
go.temporal.io/server/common/quotas/rate_limiter_impl.go 12 covered LOC · 1 range

Open complete file

24 // NewRateLimiter returns a new rate limiter that can handle dynamic
25 // configuration updates
26 > func NewRateLimiter(newRPS float64, newBurst int) *RateLimiterImpl { rate_limiter_impl.go
27 > limiter := rate.NewLimiter(rate.Limit(newRPS), newBurst)
28 > ts := clock.NewRealTimeSource()
29 > rl := &RateLimiterImpl{
30 > rps: newRPS,
31 > burst: newBurst,
32 > timeSource: ts,
33 > ClockedRateLimiter: NewClockedRateLimiter(limiter, ts),
34 > }
35 >
36 > return rl
37 > }
38
39 // SetRPS sets the rate of the rate limiter
go.temporal.io/server/common/clock/time_source.go 6 covered LOC · 2 ranges

Open complete file

31
32 // NewRealTimeSource returns a timeSource that uses the real wall timeSource time.
33 > func NewRealTimeSource() RealTimeSource { time_source.go
34 > return RealTimeSource{}
35 > }
36
37 // Now returns the current time, with the location set to UTC.
38 > func (ts RealTimeSource) Now() time.Time { time_source.go
39 > return time.Now().UTC()
40 > }
41
42 // Since returns the time elapsed since t
go.temporal.io/server/common/log/with_logger.go 4 covered LOC · 2 ranges

Open complete file

14 // With returns Logger instance that prepend every log entry with tags. If logger implements
15 // WithLogger it is used, otherwise every log call will be intercepted.
16 > func With(logger Logger, tags ...tag.Tag) Logger { with_logger.go
17 > if wl, ok := logger.(WithLogger); ok {
18 > return wl.With(tags...) with_logger.go
19 > }
20 return newWithLogger(logger, tags...)
21 }