018965f0-fdaa-4535-a39b-924d1b4fe28b

Committed 17 Jul 2023 10:20PM UTC coverage: 57.058% (-0.09%) from 57.146%

Build # 018965f0-fdaa-4535-a39b-924d1b4fe28b

Build Type

push

buildkite

Committed by

web-flow

Commit Message

[dynamic config] add Filters method to dynamic config Key (#5346)

What changed?

Add Filters method to Key interface
Add implementations on most keys by parsing the comments on keys (assuming they are correct)
Why?

This is needed to know what dynamic config is domain specific. And this could possible simplify the collection struct by consolidating all GetPropertyFilterBy** methods.

How did you test it?

Potential risks

no risk since the method will be read only in non-critical path

Release notes

Documentation Changes

Run Details

21 of 21 new or added lines in 1 file covered. (100.0%)

87154 of 152745 relevant lines covered (57.06%)

2500.48 hits per line

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

94.64

/common/persistence/statsComputer.go

// Copyright (c) 2017-2020 Uber Technologies, Inc.
// Portions of the Software are attributed to Copyright (c) 2020 Temporal Technologies Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

package persistence

type (
        // statsComputer is to computing struct sizes after serialization
        statsComputer struct{}
)

func (sc *statsComputer) computeMutableStateStats(req *InternalGetWorkflowExecutionResponse) *MutableStateStats {
        executionInfoSize := computeExecutionInfoSize(req.State.ExecutionInfo)

        activityInfoCount := 0
        activityInfoSize := 0
        for _, ai := range req.State.ActivityInfos {
                activityInfoCount++
                activityInfoSize += computeActivityInfoSize(ai)
        }

        timerInfoCount := 0
        timerInfoSize := 0
        for _, ti := range req.State.TimerInfos {
                timerInfoCount++
                timerInfoSize += computeTimerInfoSize(ti)
        }

        childExecutionInfoCount := 0
        childExecutionInfoSize := 0
        for _, ci := range req.State.ChildExecutionInfos {
                childExecutionInfoCount++
                childExecutionInfoSize += computeChildInfoSize(ci)
        }

        signalInfoCount := 0
        signalInfoSize := 0
        for _, si := range req.State.SignalInfos {
                signalInfoCount++
                signalInfoSize += computeSignalInfoSize(si)
        }

        bufferedEventsCount := 0
        bufferedEventsSize := 0

        for _, be := range req.State.BufferedEvents {
                bufferedEventsCount++
                bufferedEventsSize += len(be.Data)
        }

        requestCancelInfoCount := len(req.State.RequestCancelInfos)

        totalSize := executionInfoSize
        totalSize += activityInfoSize
        totalSize += timerInfoSize
        totalSize += childExecutionInfoSize
        totalSize += signalInfoSize
        totalSize += bufferedEventsSize

        return &MutableStateStats{
                MutableStateSize:       totalSize,
                ExecutionInfoSize:      executionInfoSize,
                ActivityInfoSize:       activityInfoSize,
                TimerInfoSize:          timerInfoSize,
                ChildInfoSize:          childExecutionInfoSize,
                SignalInfoSize:         signalInfoSize,
                BufferedEventsSize:     bufferedEventsSize,
                ActivityInfoCount:      activityInfoCount,
                TimerInfoCount:         timerInfoCount,
                ChildInfoCount:         childExecutionInfoCount,
                SignalInfoCount:        signalInfoCount,
                BufferedEventsCount:    bufferedEventsCount,
                RequestCancelInfoCount: requestCancelInfoCount,
        }
}

func (sc *statsComputer) computeMutableStateUpdateStats(req *InternalUpdateWorkflowExecutionRequest) *MutableStateUpdateSessionStats {
        if req.NewWorkflowSnapshot != nil {
                return mergeMutableStateUpdateSessionStats(sc.computeWorkflowMutationStats(&req.UpdateWorkflowMutation), sc.computeWorkflowSnapshotStats(req.NewWorkflowSnapshot))
        }
        return sc.computeWorkflowMutationStats(&req.UpdateWorkflowMutation)
}

func (sc *statsComputer) computeMutableStateCreateStats(req *InternalCreateWorkflowExecutionRequest) *MutableStateUpdateSessionStats {
        return sc.computeWorkflowSnapshotStats(&req.NewWorkflowSnapshot)
}

func (sc *statsComputer) computeMutableStateConflictResolveStats(req *InternalConflictResolveWorkflowExecutionRequest) *MutableStateUpdateSessionStats {
        mss := sc.computeWorkflowSnapshotStats(&req.ResetWorkflowSnapshot)
        if req.NewWorkflowSnapshot != nil {
                mss = mergeMutableStateUpdateSessionStats(mss, sc.computeWorkflowSnapshotStats(req.NewWorkflowSnapshot))
        }
        if req.CurrentWorkflowMutation != nil {
                mss = mergeMutableStateUpdateSessionStats(mss, sc.computeWorkflowMutationStats(req.CurrentWorkflowMutation))
        }
        return mss
}

func (sc *statsComputer) computeWorkflowMutationStats(req *InternalWorkflowMutation) *MutableStateUpdateSessionStats {
        executionInfoSize := computeExecutionInfoSize(req.ExecutionInfo)

        activityInfoCount := 0
        activityInfoSize := 0
        for _, ai := range req.UpsertActivityInfos {
                activityInfoCount++
                activityInfoSize += computeActivityInfoSize(ai)
        }

        timerInfoCount := 0
        timerInfoSize := 0
        for _, ti := range req.UpsertTimerInfos {
                timerInfoCount++
                timerInfoSize += computeTimerInfoSize(ti)
        }

        childExecutionInfoCount := 0
        childExecutionInfoSize := 0
        for _, ci := range req.UpsertChildExecutionInfos {
                childExecutionInfoCount++
                childExecutionInfoSize += computeChildInfoSize(ci)
        }

        signalInfoCount := 0
        signalInfoSize := 0
        for _, si := range req.UpsertSignalInfos {
                signalInfoCount++
                signalInfoSize += computeSignalInfoSize(si)
        }

        bufferedEventsSize := 0
        if req.NewBufferedEvents != nil {
                bufferedEventsSize = len(req.NewBufferedEvents.Data)
        }

        requestCancelInfoCount := len(req.UpsertRequestCancelInfos)

        deleteActivityInfoCount := len(req.DeleteActivityInfos)

        deleteTimerInfoCount := len(req.DeleteTimerInfos)

        deleteChildInfoCount := len(req.DeleteChildExecutionInfos)

        deleteSignalInfoCount := len(req.DeleteSignalInfos)

        deleteRequestCancelInfoCount := len(req.DeleteRequestCancelInfos)

        transferTasksCount := len(req.TransferTasks)
        crossClusterTasksCount := len(req.CrossClusterTasks)
        timerTasksCount := len(req.TimerTasks)
        replicationTasksCount := len(req.ReplicationTasks)

        totalSize := executionInfoSize
        totalSize += activityInfoSize
        totalSize += timerInfoSize
        totalSize += childExecutionInfoSize
        totalSize += signalInfoSize
        totalSize += bufferedEventsSize

        return &MutableStateUpdateSessionStats{
                MutableStateSize:             totalSize,
                ExecutionInfoSize:            executionInfoSize,
                ActivityInfoSize:             activityInfoSize,
                TimerInfoSize:                timerInfoSize,
                ChildInfoSize:                childExecutionInfoSize,
                SignalInfoSize:               signalInfoSize,
                BufferedEventsSize:           bufferedEventsSize,
                ActivityInfoCount:            activityInfoCount,
                TimerInfoCount:               timerInfoCount,
                ChildInfoCount:               childExecutionInfoCount,
                SignalInfoCount:              signalInfoCount,
                RequestCancelInfoCount:       requestCancelInfoCount,
                DeleteActivityInfoCount:      deleteActivityInfoCount,
                DeleteTimerInfoCount:         deleteTimerInfoCount,
                DeleteChildInfoCount:         deleteChildInfoCount,
                DeleteSignalInfoCount:        deleteSignalInfoCount,
                DeleteRequestCancelInfoCount: deleteRequestCancelInfoCount,
                TransferTasksCount:           transferTasksCount,
                CrossClusterTaskCount:        crossClusterTasksCount,
                TimerTasksCount:              timerTasksCount,
                ReplicationTasksCount:        replicationTasksCount,
        }
}

func (sc *statsComputer) computeWorkflowSnapshotStats(req *InternalWorkflowSnapshot) *MutableStateUpdateSessionStats {
        executionInfoSize := computeExecutionInfoSize(req.ExecutionInfo)

        activityInfoCount := 0
        activityInfoSize := 0
        for _, ai := range req.ActivityInfos {
                activityInfoCount++
                activityInfoSize += computeActivityInfoSize(ai)
        }

        timerInfoCount := 0
        timerInfoSize := 0
        for _, ti := range req.TimerInfos {
                timerInfoCount++
                timerInfoSize += computeTimerInfoSize(ti)
        }

        childExecutionInfoCount := 0
        childExecutionInfoSize := 0
        for _, ci := range req.ChildExecutionInfos {
                childExecutionInfoCount++
                childExecutionInfoSize += computeChildInfoSize(ci)
        }

        signalInfoCount := 0
        signalInfoSize := 0
        for _, si := range req.SignalInfos {
                signalInfoCount++
                signalInfoSize += computeSignalInfoSize(si)
        }

        requestCancelInfoCount := len(req.RequestCancelInfos)

        transferTasksCount := len(req.TransferTasks)
        crossClusterTasksCount := len(req.CrossClusterTasks)
        timerTasksCount := len(req.TimerTasks)
        replicationTasksCount := len(req.ReplicationTasks)

        totalSize := executionInfoSize
        totalSize += activityInfoSize
        totalSize += timerInfoSize
        totalSize += childExecutionInfoSize
        totalSize += signalInfoSize

        return &MutableStateUpdateSessionStats{
                MutableStateSize:       totalSize,
                ExecutionInfoSize:      executionInfoSize,
                ActivityInfoSize:       activityInfoSize,
                TimerInfoSize:          timerInfoSize,
                ChildInfoSize:          childExecutionInfoSize,
                SignalInfoSize:         signalInfoSize,
                ActivityInfoCount:      activityInfoCount,
                TimerInfoCount:         timerInfoCount,
                ChildInfoCount:         childExecutionInfoCount,
                SignalInfoCount:        signalInfoCount,
                RequestCancelInfoCount: requestCancelInfoCount,
                TransferTasksCount:     transferTasksCount,
                CrossClusterTaskCount:  crossClusterTasksCount,
                TimerTasksCount:        timerTasksCount,
                ReplicationTasksCount:  replicationTasksCount,
        }
}

func mergeMutableStateUpdateSessionStats(stats ...*MutableStateUpdateSessionStats) *MutableStateUpdateSessionStats {
        result := &MutableStateUpdateSessionStats{}
        for _, s := range stats {
                result.MutableStateSize += s.MutableStateSize

                result.ExecutionInfoSize += s.ExecutionInfoSize
                result.ActivityInfoSize += s.ActivityInfoSize
                result.TimerInfoSize += s.TimerInfoSize
                result.ChildInfoSize += s.ChildInfoSize
                result.SignalInfoSize += s.SignalInfoSize
                result.BufferedEventsSize += s.BufferedEventsSize

                result.ActivityInfoCount += s.ActivityInfoCount
                result.TimerInfoCount += s.TimerInfoCount
                result.ChildInfoCount += s.ChildInfoCount
                result.SignalInfoCount += s.SignalInfoCount
                result.RequestCancelInfoCount += s.RequestCancelInfoCount

                result.DeleteActivityInfoCount += s.DeleteActivityInfoCount
                result.DeleteTimerInfoCount += s.DeleteTimerInfoCount
                result.DeleteChildInfoCount += s.DeleteChildInfoCount
                result.DeleteSignalInfoCount += s.DeleteSignalInfoCount
                result.DeleteRequestCancelInfoCount += s.DeleteRequestCancelInfoCount

                result.TransferTasksCount += s.TransferTasksCount
                result.CrossClusterTaskCount += s.CrossClusterTaskCount
                result.TimerInfoCount += s.TimerInfoCount
                result.ReplicationTasksCount += s.ReplicationTasksCount
        }
        return result
}

func computeExecutionInfoSize(executionInfo *InternalWorkflowExecutionInfo) int {
        size := len(executionInfo.WorkflowID)
        size += len(executionInfo.TaskList)
        size += len(executionInfo.WorkflowTypeName)
        size += len(executionInfo.ParentWorkflowID)

        return size
}

func computeActivityInfoSize(ai *InternalActivityInfo) int {
        size := len(ai.ActivityID)
        if ai.ScheduledEvent != nil {
                size += len(ai.ScheduledEvent.Data)
        }
        if ai.StartedEvent != nil {
                size += len(ai.StartedEvent.Data)
        }
        size += len(ai.Details)

        return size
}

func computeTimerInfoSize(ti *TimerInfo) int {
        size := len(ti.TimerID)

        return size
}

func computeChildInfoSize(ci *InternalChildExecutionInfo) int {
        size := 0
        if ci.InitiatedEvent != nil {
                size += len(ci.InitiatedEvent.Data)
        }
        if ci.StartedEvent != nil {
                size += len(ci.StartedEvent.Data)
        }
        return size
}

func computeSignalInfoSize(si *SignalInfo) int {
        size := len(si.SignalName)
        size += len(si.Input)
        size += len(si.Control)

        return size
}

1	// Copyright (c) 2017-2020 Uber Technologies, Inc.
2	// Portions of the Software are attributed to Copyright (c) 2020 Temporal Technologies Inc.
3	//
4	// Permission is hereby granted, free of charge, to any person obtaining a copy
5	// of this software and associated documentation files (the "Software"), to deal
6	// in the Software without restriction, including without limitation the rights
7	// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8	// copies of the Software, and to permit persons to whom the Software is
9	// furnished to do so, subject to the following conditions:
10	//
11	// The above copyright notice and this permission notice shall be included in
12	// all copies or substantial portions of the Software.
13	//
14	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15	// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16	// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17	// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18	// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19	// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20	// THE SOFTWARE.
21
22	package persistence
23
24	type (
25	// statsComputer is to computing struct sizes after serialization
26	statsComputer struct{}
27	)
28
29	func (sc statsComputer) computeMutableStateStats(req InternalGetWorkflowExecutionResponse) *MutableStateStats {	741✔
30	executionInfoSize := computeExecutionInfoSize(req.State.ExecutionInfo)	741✔
31		741✔
32	activityInfoCount := 0	741✔
33	activityInfoSize := 0	741✔
34	for _, ai := range req.State.ActivityInfos {	848✔
35	activityInfoCount++	107✔
36	activityInfoSize += computeActivityInfoSize(ai)	107✔
37	}	107✔
38
39	timerInfoCount := 0	741✔
40	timerInfoSize := 0	741✔
41	for _, ti := range req.State.TimerInfos {	742✔
42	timerInfoCount++	1✔
43	timerInfoSize += computeTimerInfoSize(ti)	1✔
44	}	1✔
45
46	childExecutionInfoCount := 0	741✔
47	childExecutionInfoSize := 0	741✔
48	for _, ci := range req.State.ChildExecutionInfos {	745✔
49	childExecutionInfoCount++	4✔
50	childExecutionInfoSize += computeChildInfoSize(ci)	4✔
51	}	4✔
52
53	signalInfoCount := 0	741✔
54	signalInfoSize := 0	741✔
55	for _, si := range req.State.SignalInfos {	741✔
56	signalInfoCount++	×
57	signalInfoSize += computeSignalInfoSize(si)	×
58	}	×
59
60	bufferedEventsCount := 0	741✔
61	bufferedEventsSize := 0	741✔
62		741✔
63	for _, be := range req.State.BufferedEvents {	744✔
64	bufferedEventsCount++	3✔
65	bufferedEventsSize += len(be.Data)	3✔
66	}	3✔
67
68	requestCancelInfoCount := len(req.State.RequestCancelInfos)	741✔
69		741✔
70	totalSize := executionInfoSize	741✔
71	totalSize += activityInfoSize	741✔
72	totalSize += timerInfoSize	741✔
73	totalSize += childExecutionInfoSize	741✔
74	totalSize += signalInfoSize	741✔
75	totalSize += bufferedEventsSize	741✔
76		741✔
77	return &MutableStateStats{	741✔
78	MutableStateSize: totalSize,	741✔
79	ExecutionInfoSize: executionInfoSize,	741✔
80	ActivityInfoSize: activityInfoSize,	741✔
81	TimerInfoSize: timerInfoSize,	741✔
82	ChildInfoSize: childExecutionInfoSize,	741✔
83	SignalInfoSize: signalInfoSize,	741✔
84	BufferedEventsSize: bufferedEventsSize,	741✔
85	ActivityInfoCount: activityInfoCount,	741✔
86	TimerInfoCount: timerInfoCount,	741✔
87	ChildInfoCount: childExecutionInfoCount,	741✔
88	SignalInfoCount: signalInfoCount,	741✔
89	BufferedEventsCount: bufferedEventsCount,	741✔
90	RequestCancelInfoCount: requestCancelInfoCount,	741✔
91	}	741✔
92	}
93
94	func (sc statsComputer) computeMutableStateUpdateStats(req InternalUpdateWorkflowExecutionRequest) *MutableStateUpdateSessionStats {	4,393✔
95	if req.NewWorkflowSnapshot != nil {	4,570✔
96	return mergeMutableStateUpdateSessionStats(sc.computeWorkflowMutationStats(&req.UpdateWorkflowMutation), sc.computeWorkflowSnapshotStats(req.NewWorkflowSnapshot))	177✔
97	}	177✔
98	return sc.computeWorkflowMutationStats(&req.UpdateWorkflowMutation)	4,219✔
99	}
100
101	func (sc statsComputer) computeMutableStateCreateStats(req InternalCreateWorkflowExecutionRequest) *MutableStateUpdateSessionStats {	504✔
102	return sc.computeWorkflowSnapshotStats(&req.NewWorkflowSnapshot)	504✔
103	}	504✔
104
105	func (sc statsComputer) computeMutableStateConflictResolveStats(req InternalConflictResolveWorkflowExecutionRequest) *MutableStateUpdateSessionStats {	3✔
106	mss := sc.computeWorkflowSnapshotStats(&req.ResetWorkflowSnapshot)	3✔
107	if req.NewWorkflowSnapshot != nil {	3✔
108	mss = mergeMutableStateUpdateSessionStats(mss, sc.computeWorkflowSnapshotStats(req.NewWorkflowSnapshot))	×
109	}	×
110	if req.CurrentWorkflowMutation != nil {	3✔
111	mss = mergeMutableStateUpdateSessionStats(mss, sc.computeWorkflowMutationStats(req.CurrentWorkflowMutation))	×
112	}	×
113	return mss	3✔
114	}
115
116	func (sc statsComputer) computeWorkflowMutationStats(req InternalWorkflowMutation) *MutableStateUpdateSessionStats {	4,394✔
117	executionInfoSize := computeExecutionInfoSize(req.ExecutionInfo)	4,394✔
118		4,394✔
119	activityInfoCount := 0	4,394✔
120	activityInfoSize := 0	4,394✔
121	for _, ai := range req.UpsertActivityInfos {	5,621✔
122	activityInfoCount++	1,227✔
123	activityInfoSize += computeActivityInfoSize(ai)	1,227✔
124	}	1,227✔
125
126	timerInfoCount := 0	4,394✔
127	timerInfoSize := 0	4,394✔
128	for _, ti := range req.UpsertTimerInfos {	4,430✔
129	timerInfoCount++	36✔
130	timerInfoSize += computeTimerInfoSize(ti)	36✔
131	}	36✔
132
133	childExecutionInfoCount := 0	4,394✔
134	childExecutionInfoSize := 0	4,394✔
135	for _, ci := range req.UpsertChildExecutionInfos {	4,437✔
136	childExecutionInfoCount++	43✔
137	childExecutionInfoSize += computeChildInfoSize(ci)	43✔
138	}	43✔
139
140	signalInfoCount := 0	4,394✔
141	signalInfoSize := 0	4,394✔
142	for _, si := range req.UpsertSignalInfos {	4,410✔
143	signalInfoCount++	16✔
144	signalInfoSize += computeSignalInfoSize(si)	16✔
145	}	16✔
146
147	bufferedEventsSize := 0	4,394✔
148	if req.NewBufferedEvents != nil {	5,037✔
149	bufferedEventsSize = len(req.NewBufferedEvents.Data)	643✔
150	}	643✔
151
152	requestCancelInfoCount := len(req.UpsertRequestCancelInfos)	4,394✔
153		4,394✔
154	deleteActivityInfoCount := len(req.DeleteActivityInfos)	4,394✔
155		4,394✔
156	deleteTimerInfoCount := len(req.DeleteTimerInfos)	4,394✔
157		4,394✔
158	deleteChildInfoCount := len(req.DeleteChildExecutionInfos)	4,394✔
159		4,394✔
160	deleteSignalInfoCount := len(req.DeleteSignalInfos)	4,394✔
161		4,394✔
162	deleteRequestCancelInfoCount := len(req.DeleteRequestCancelInfos)	4,394✔
163		4,394✔
164	transferTasksCount := len(req.TransferTasks)	4,394✔
165	crossClusterTasksCount := len(req.CrossClusterTasks)	4,394✔
166	timerTasksCount := len(req.TimerTasks)	4,394✔
167	replicationTasksCount := len(req.ReplicationTasks)	4,394✔
168		4,394✔
169	totalSize := executionInfoSize	4,394✔
170	totalSize += activityInfoSize	4,394✔
171	totalSize += timerInfoSize	4,394✔
172	totalSize += childExecutionInfoSize	4,394✔
173	totalSize += signalInfoSize	4,394✔
174	totalSize += bufferedEventsSize	4,394✔
175		4,394✔
176	return &MutableStateUpdateSessionStats{	4,394✔
177	MutableStateSize: totalSize,	4,394✔
178	ExecutionInfoSize: executionInfoSize,	4,394✔
179	ActivityInfoSize: activityInfoSize,	4,394✔
180	TimerInfoSize: timerInfoSize,	4,394✔
181	ChildInfoSize: childExecutionInfoSize,	4,394✔
182	SignalInfoSize: signalInfoSize,	4,394✔
183	BufferedEventsSize: bufferedEventsSize,	4,394✔
184	ActivityInfoCount: activityInfoCount,	4,394✔
185	TimerInfoCount: timerInfoCount,	4,394✔
186	ChildInfoCount: childExecutionInfoCount,	4,394✔
187	SignalInfoCount: signalInfoCount,	4,394✔
188	RequestCancelInfoCount: requestCancelInfoCount,	4,394✔
189	DeleteActivityInfoCount: deleteActivityInfoCount,	4,394✔
190	DeleteTimerInfoCount: deleteTimerInfoCount,	4,394✔
191	DeleteChildInfoCount: deleteChildInfoCount,	4,394✔
192	DeleteSignalInfoCount: deleteSignalInfoCount,	4,394✔
193	DeleteRequestCancelInfoCount: deleteRequestCancelInfoCount,	4,394✔
194	TransferTasksCount: transferTasksCount,	4,394✔
195	CrossClusterTaskCount: crossClusterTasksCount,	4,394✔
196	TimerTasksCount: timerTasksCount,	4,394✔
197	ReplicationTasksCount: replicationTasksCount,	4,394✔
198	}	4,394✔
199	}
200
201	func (sc statsComputer) computeWorkflowSnapshotStats(req InternalWorkflowSnapshot) *MutableStateUpdateSessionStats {	679✔
202	executionInfoSize := computeExecutionInfoSize(req.ExecutionInfo)	679✔
203		679✔
204	activityInfoCount := 0	679✔
205	activityInfoSize := 0	679✔
206	for _, ai := range req.ActivityInfos {	702✔
207	activityInfoCount++	23✔
208	activityInfoSize += computeActivityInfoSize(ai)	23✔
209	}	23✔
210
211	timerInfoCount := 0	679✔
212	timerInfoSize := 0	679✔
213	for _, ti := range req.TimerInfos {	683✔
214	timerInfoCount++	4✔
215	timerInfoSize += computeTimerInfoSize(ti)	4✔
216	}	4✔
217
218	childExecutionInfoCount := 0	679✔
219	childExecutionInfoSize := 0	679✔
220	for _, ci := range req.ChildExecutionInfos {	684✔
221	childExecutionInfoCount++	5✔
222	childExecutionInfoSize += computeChildInfoSize(ci)	5✔
223	}	5✔
224
225	signalInfoCount := 0	679✔
226	signalInfoSize := 0	679✔
227	for _, si := range req.SignalInfos {	680✔
228	signalInfoCount++	1✔
229	signalInfoSize += computeSignalInfoSize(si)	1✔
230	}	1✔
231
232	requestCancelInfoCount := len(req.RequestCancelInfos)	679✔
233		679✔
234	transferTasksCount := len(req.TransferTasks)	679✔
235	crossClusterTasksCount := len(req.CrossClusterTasks)	679✔
236	timerTasksCount := len(req.TimerTasks)	679✔
237	replicationTasksCount := len(req.ReplicationTasks)	679✔
238		679✔
239	totalSize := executionInfoSize	679✔
240	totalSize += activityInfoSize	679✔
241	totalSize += timerInfoSize	679✔
242	totalSize += childExecutionInfoSize	679✔
243	totalSize += signalInfoSize	679✔
244		679✔
245	return &MutableStateUpdateSessionStats{	679✔
246	MutableStateSize: totalSize,	679✔
247	ExecutionInfoSize: executionInfoSize,	679✔
248	ActivityInfoSize: activityInfoSize,	679✔
249	TimerInfoSize: timerInfoSize,	679✔
250	ChildInfoSize: childExecutionInfoSize,	679✔
251	SignalInfoSize: signalInfoSize,	679✔
252	ActivityInfoCount: activityInfoCount,	679✔
253	TimerInfoCount: timerInfoCount,	679✔
254	ChildInfoCount: childExecutionInfoCount,	679✔
255	SignalInfoCount: signalInfoCount,	679✔
256	RequestCancelInfoCount: requestCancelInfoCount,	679✔
257	TransferTasksCount: transferTasksCount,	679✔
258	CrossClusterTaskCount: crossClusterTasksCount,	679✔
259	TimerTasksCount: timerTasksCount,	679✔
260	ReplicationTasksCount: replicationTasksCount,	679✔
261	}	679✔
262	}
263
264	func mergeMutableStateUpdateSessionStats(stats ...MutableStateUpdateSessionStats) MutableStateUpdateSessionStats {	177✔
265	result := &MutableStateUpdateSessionStats{}	177✔
266	for _, s := range stats {	528✔
267	result.MutableStateSize += s.MutableStateSize	351✔
268		351✔
269	result.ExecutionInfoSize += s.ExecutionInfoSize	351✔
270	result.ActivityInfoSize += s.ActivityInfoSize	351✔
271	result.TimerInfoSize += s.TimerInfoSize	351✔
272	result.ChildInfoSize += s.ChildInfoSize	351✔
273	result.SignalInfoSize += s.SignalInfoSize	351✔
274	result.BufferedEventsSize += s.BufferedEventsSize	351✔
275		351✔
276	result.ActivityInfoCount += s.ActivityInfoCount	351✔
277	result.TimerInfoCount += s.TimerInfoCount	351✔
278	result.ChildInfoCount += s.ChildInfoCount	351✔
279	result.SignalInfoCount += s.SignalInfoCount	351✔
280	result.RequestCancelInfoCount += s.RequestCancelInfoCount	351✔
281		351✔
282	result.DeleteActivityInfoCount += s.DeleteActivityInfoCount	351✔
283	result.DeleteTimerInfoCount += s.DeleteTimerInfoCount	351✔
284	result.DeleteChildInfoCount += s.DeleteChildInfoCount	351✔
285	result.DeleteSignalInfoCount += s.DeleteSignalInfoCount	351✔
286	result.DeleteRequestCancelInfoCount += s.DeleteRequestCancelInfoCount	351✔
287		351✔
288	result.TransferTasksCount += s.TransferTasksCount	351✔
289	result.CrossClusterTaskCount += s.CrossClusterTaskCount	351✔
290	result.TimerInfoCount += s.TimerInfoCount	351✔
291	result.ReplicationTasksCount += s.ReplicationTasksCount	351✔
292	}	351✔
293	return result	177✔
294	}
295
296	func computeExecutionInfoSize(executionInfo *InternalWorkflowExecutionInfo) int {	5,810✔
297	size := len(executionInfo.WorkflowID)	5,810✔
298	size += len(executionInfo.TaskList)	5,810✔
299	size += len(executionInfo.WorkflowTypeName)	5,810✔
300	size += len(executionInfo.ParentWorkflowID)	5,810✔
301		5,810✔
302	return size	5,810✔
303	}	5,810✔
304
305	func computeActivityInfoSize(ai *InternalActivityInfo) int {	1,353✔
306	size := len(ai.ActivityID)	1,353✔
307	if ai.ScheduledEvent != nil {	1,353✔
308	size += len(ai.ScheduledEvent.Data)	×
309	}	×
310	if ai.StartedEvent != nil {	1,353✔
311	size += len(ai.StartedEvent.Data)	×
312	}	×
313	size += len(ai.Details)	1,353✔
314		1,353✔
315	return size	1,353✔
316	}
317
318	func computeTimerInfoSize(ti *TimerInfo) int {	41✔
319	size := len(ti.TimerID)	41✔
320		41✔
321	return size	41✔
322	}	41✔
323
324	func computeChildInfoSize(ci *InternalChildExecutionInfo) int {	52✔
325	size := 0	52✔
326	if ci.InitiatedEvent != nil {	52✔
327	size += len(ci.InitiatedEvent.Data)	×
328	}	×
329	if ci.StartedEvent != nil {	52✔
330	size += len(ci.StartedEvent.Data)	×
331	}	×
332	return size	52✔
333	}
334
335	func computeSignalInfoSize(si *SignalInfo) int {	19✔
336	size := len(si.SignalName)	19✔
337	size += len(si.Input)	19✔
338	size += len(si.Control)	19✔
339		19✔
340	return size	19✔
341	}	19✔

uber / cadence / 018965f0-fdaa-4535-a39b-924d1b4fe28b

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