30165018659

Committed 25 Jul 2026 04:08PM UTC coverage: 59.313% (-7.3%) from 66.572%

Build # 30165018659

Build Type

push

github

Committed by

sapslaj

Commit Message

chore(deps): bump @opentelemetry/propagator-jaeger and @pulumi/pulumi

Removes [@opentelemetry/propagator-jaeger](https://github.com/open-telemetry/opentelemetry-js). It's no longer used after updating ancestor dependency [@pulumi/pulumi](https://github.com/pulumi/pulumi/tree/HEAD/sdk/nodejs). These dependencies need to be updated together.


Removes `@opentelemetry/propagator-jaeger`

Updates `@pulumi/pulumi` from 3.250.0 to 3.254.0
- [Release notes](https://github.com/pulumi/pulumi/releases)
- [Changelog](https://github.com/pulumi/pulumi/blob/master/CHANGELOG.md)
- [Commits](https://github.com/pulumi/pulumi/commits/v3.254.0/sdk/nodejs)

---
updated-dependencies:
- dependency-name: "@opentelemetry/propagator-jaeger"
  dependency-version:
  dependency-type: indirect
- dependency-name: "@pulumi/pulumi"
  dependency-version: 3.254.0
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>

Coverage Stats

7706 of 12992 relevant lines covered (59.31%)

570.19 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

28.21

/pkg/syncmap/syncmap.go

// VERY slim wrapper around sync.Map with Go generics for that sweet sweet type safety
package syncmap

import (
        "iter"
        "sync"
)

type Map[K comparable, V any] struct {
        InnerMap     sync.Map
        DefaultValue V
}

func FromRegularMap[K comparable, V any](m map[K]V) *Map[K, V] {
        syncMap := Map[K, V]{}
        for key, value := range m {
                syncMap.Store(key, value)
        }
        return &syncMap
}

func (m *Map[K, V]) Clear() {
        m.InnerMap.Clear()
}

func (m *Map[K, V]) Delete(key K) {
        m.InnerMap.Delete(key)
}

func (m *Map[K, V]) Load(key K) (value V, loaded bool) {
        v, loaded := m.InnerMap.Load(key)
        value, ok := v.(V)
        if !ok {
                return m.DefaultValue, loaded
        }
        return
}

func (m *Map[K, V]) LoadAndDelete(key K) (value V, loaded bool) {
        v, loaded := m.InnerMap.LoadAndDelete(key)
        value, ok := v.(V)
        if !ok {
                return m.DefaultValue, loaded
        }
        return
}

func (m *Map[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool) {
        v, loaded := m.InnerMap.LoadOrStore(key, value)
        actual, ok := v.(V)
        if !ok {
                return m.DefaultValue, loaded
        }
        return
}

func (m *Map[K, V]) Range(f func(key K, value V) bool) {
        m.InnerMap.Range(func(key, value any) bool {
                return f(key.(K), value.(V))
        })
}

func (m *Map[K, V]) Items() iter.Seq2[K, V] {
        return func(yield func(K, V) bool) {
                m.Range(func(key K, value V) bool {
                        return yield(key, value)
                })
        }
}

func (m *Map[K, V]) Store(key K, value V) {
        m.InnerMap.Store(key, value)
}

func (m *Map[K, V]) Swap(key K, value V) (previous V, loaded bool) {
        v, loaded := m.InnerMap.Swap(key, value)
        previous, ok := v.(V)
        if !ok {
                return m.DefaultValue, loaded
        }
        return
}

func (m *Map[K, V]) ToRegularMap() map[K]V {
        newMap := map[K]V{}
        m.Range(func(key K, value V) bool {
                newMap[key] = value
                return true
        })
        return newMap
}

func (m *Map[K, V]) Length() int {
        l := 0
        m.Range(func(key K, value V) bool {
                l += 1
                return true
        })
        return l
}

type ComparableMap[K comparable, V comparable] struct {
        Map[K, V]
}

func ComparableFromRegularMap[K comparable, V comparable](m map[K]V) *ComparableMap[K, V] {
        syncMap := ComparableMap[K, V]{}
        for key, value := range m {
                syncMap.Store(key, value)
        }
        return &syncMap
}

func (m *ComparableMap[K, V]) CompareAndDelete(key K, old V) bool {
        return m.InnerMap.CompareAndDelete(key, old)
}

func (m *ComparableMap[K, V]) CompareAndSwap(key K, old V, new V) bool {
        return m.InnerMap.CompareAndSwap(key, old, new)
}

1	// VERY slim wrapper around sync.Map with Go generics for that sweet sweet type safety
2	package syncmap
3
4	import (
5	"iter"
6	"sync"
7	)
8
9	type Map[K comparable, V any] struct {
10	InnerMap sync.Map
11	DefaultValue V
12	}
13
14	func FromRegularMap[K comparable, V any](m map[K]V) *Map[K, V] {	×
15	syncMap := Map[K, V]{}	×
16	for key, value := range m {	×
17	syncMap.Store(key, value)	×
18	}	×
19	return &syncMap	×
20	}
21
22	func (m *Map[K, V]) Clear() {	×
23	m.InnerMap.Clear()	×
24	}	×
25
26	func (m *Map[K, V]) Delete(key K) {	×
27	m.InnerMap.Delete(key)	×
28	}	×
29
30	func (m *Map[K, V]) Load(key K) (value V, loaded bool) {	438✔
31	v, loaded := m.InnerMap.Load(key)	438✔
32	value, ok := v.(V)	438✔
33	if !ok {	438✔
34	return m.DefaultValue, loaded	×
35	}	×
36	return	438✔
37	}
38
39	func (m *Map[K, V]) LoadAndDelete(key K) (value V, loaded bool) {	×
40	v, loaded := m.InnerMap.LoadAndDelete(key)	×
41	value, ok := v.(V)	×
42	if !ok {	×
43	return m.DefaultValue, loaded	×
44	}	×
45	return	×
46	}
47
48	func (m *Map[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool) {	508✔
49	v, loaded := m.InnerMap.LoadOrStore(key, value)	508✔
50	actual, ok := v.(V)	508✔
51	if !ok {	508✔
52	return m.DefaultValue, loaded	×
53	}	×
54	return	508✔
55	}
56
57	func (m *Map[K, V]) Range(f func(key K, value V) bool) {	75✔
58	m.InnerMap.Range(func(key, value any) bool {	589✔
59	return f(key.(K), value.(V))	514✔
60	})	514✔
61	}
62
63	func (m *Map[K, V]) Items() iter.Seq2[K, V] {	75✔
64	return func(yield func(K, V) bool) {	150✔
65	m.Range(func(key K, value V) bool {	589✔
66	return yield(key, value)	514✔
67	})	514✔
68	}
69	}
70
71	func (m *Map[K, V]) Store(key K, value V) {	516✔
72	m.InnerMap.Store(key, value)	516✔
73	}	516✔
74
75	func (m *Map[K, V]) Swap(key K, value V) (previous V, loaded bool) {	×
76	v, loaded := m.InnerMap.Swap(key, value)	×
77	previous, ok := v.(V)	×
78	if !ok {	×
79	return m.DefaultValue, loaded	×
80	}	×
81	return	×
82	}
83
84	func (m *Map[K, V]) ToRegularMap() map[K]V {	×
85	newMap := map[K]V{}	×
86	m.Range(func(key K, value V) bool {	×
87	newMap[key] = value	×
88	return true	×
89	})	×
90	return newMap	×
91	}
92
93	func (m *Map[K, V]) Length() int {	×
94	l := 0	×
95	m.Range(func(key K, value V) bool {	×
96	l += 1	×
97	return true	×
98	})	×
99	return l	×
100	}
101
102	type ComparableMap[K comparable, V comparable] struct {
103	Map[K, V]
104	}
105
106	func ComparableFromRegularMap[K comparable, V comparable](m map[K]V) *ComparableMap[K, V] {	×
107	syncMap := ComparableMap[K, V]{}	×
108	for key, value := range m {	×
109	syncMap.Store(key, value)	×
110	}	×
111	return &syncMap	×
112	}
113
114	func (m *ComparableMap[K, V]) CompareAndDelete(key K, old V) bool {	×
115	return m.InnerMap.CompareAndDelete(key, old)	×
116	}	×
117
118	func (m *ComparableMap[K, V]) CompareAndSwap(key K, old V, new V) bool {	×
119	return m.InnerMap.CompareAndSwap(key, old, new)	×
120	}	×

sapslaj / mid / 30165018659

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous