include/otel_signal_pb.h

filter: Statementstmt 96.3% 451 / 468 Branchbran 73.0% 244 / 334 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 86.6% 695 / 802 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« xs/instrument.xs ↑ Summary include/otel_metric.h »
1 /* otel_signal_pb.h - the metrics and logs message trees, in protobuf.
2 *
3 * Same two-pass shape as otel_trace.h: a size_ function beside every write_
4 * function, agreeing byte for byte, checked by OTEL_PB_CHECK in an author
5 * build.
6 *
7 * Both take the payload the SDK already produces - Meter::collect and the log
8 * record list - so nothing has to be reshaped between collecting and sending.
9 */
10  
11 #ifndef OTEL_SIGNAL_PB_H
12 #define OTEL_SIGNAL_PB_H
13  
14 #include "otel_pb.h"
15 #include "otel_proto.h"
16 #include "otel_trace.h" /* otel_h / otel_h_hv / otel_h_av / otel_id */
17 #include "otel_value.h"
18  
19 /* The internal temporality constants are numbered the OTHER WAY ROUND from
20 * the OTLP enum (internal: cumulative 1, delta 2; OTLP: delta 1,
21 * cumulative 2). Emitting the internal value would label every series as its
22 * opposite, which a backend accepts and then draws completely wrongly. */
23 96 static int otel_pb_temporality(IV internal) {
24 return internal == 2 /* OTEL_TEMP_DELTA */ ? PB_TEMPORALITY_DELTA
25 96 ▶ : PB_TEMPORALITY_CUMULATIVE;
Branch: 1 branch
BranchTrueFalseTotal
: PB_TEMPORALITY_CUMULATIVE; 18 78 96
26 }
27  
28 /* ---- an IV list out of an AV, bounded --------------------------------- */
29 81 static int otel_iv_list(pTHX_ AV *av, IV *out, int cap) {
30 81 ▶ SSize_t i, n = av ? av_len(av) + 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
SSize_t i, n = av ? av_len(av) + 1 : 0; 81 0 81
31 81 int c = 0;
32 2268 ▶ for (i = 0; i < n && c < cap; i++) {
Branch: 2 branches
BranchTrueFalseTotal
for (i = 0; i < n && c < cap; i++) { 2187 81 2268
for (i = 0; i < n && c < cap; i++) { 2187 0 2187
33 2187 SV **e = av_fetch(av, i, 0);
34 2187 ▶ out[c++] = (e && *e) ? SvIV(*e) : 0;
Branch: 2 branches
BranchTrueFalseTotal
out[c++] = (e && *e) ? SvIV(*e) : 0; 2187 0 2187
out[c++] = (e && *e) ? SvIV(*e) : 0; 2187 0 2187
35 }
36 81 return c;
37 }
38 49 static int otel_nv_list(pTHX_ AV *av, double *out, int cap) {
39 49 ▶ SSize_t i, n = av ? av_len(av) + 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
SSize_t i, n = av ? av_len(av) + 1 : 0; 49 0 49
40 49 int c = 0;
41 651 ▶ for (i = 0; i < n && c < cap; i++) {
Branch: 2 branches
BranchTrueFalseTotal
for (i = 0; i < n && c < cap; i++) { 602 49 651
for (i = 0; i < n && c < cap; i++) { 602 0 602
42 602 SV **e = av_fetch(av, i, 0);
43 602 ▶ out[c++] = (e && *e) ? SvNV(*e) : 0;
Branch: 2 branches
BranchTrueFalseTotal
out[c++] = (e && *e) ? SvNV(*e) : 0; 602 0 602
out[c++] = (e && *e) ? SvNV(*e) : 0; 602 0 602
44 }
45 49 return c;
46 }
47  
48 #define OTEL_PB_MAX_BUCKETS 256
49  
50 /* ---- Exemplar ----------------------------------------------------------- */
51  
52 28 static size_t otel_pb_exemplar_size(pTHX_ HV *e) {
53 28 size_t n = 0;
54 char t16[16], s8[8];
55 STRLEN tl, sl;
56 28 ▶ if (!e) return 0;
Branch: 1 branch
BranchTrueFalseTotal
if (!e) return 0; 0 28 28
57 28 ▶ if (otel_h(aTHX_ e, "time_unix_nano"))
Branch: 1 branch
BranchTrueFalseTotal
if (otel_h(aTHX_ e, "time_unix_nano")) 28 0 28
58 28 n += otel_pb_fixed64_size(PB_EXEMPLAR_TIME);
59 28 n += otel_pb_double_size(PB_EXEMPLAR_AS_DOUBLE);
60 28 ▶ if (otel_id(aTHX_ e, "span_id", 8, &sl, s8))
Branch: 1 branch
BranchTrueFalseTotal
if (otel_id(aTHX_ e, "span_id", 8, &sl, s8)) 28 0 28
61 28 n += otel_pb_bytes_size(PB_EXEMPLAR_SPAN_ID, sl);
62 28 ▶ if (otel_id(aTHX_ e, "trace_id", 16, &tl, t16))
Branch: 1 branch
BranchTrueFalseTotal
if (otel_id(aTHX_ e, "trace_id", 16, &tl, t16)) 28 0 28
63 28 n += otel_pb_bytes_size(PB_EXEMPLAR_TRACE_ID, tl);
64 28 return n;
65 }
66  
67 4 static void otel_pb_exemplar_write(pTHX_ otel_buf *b, HV *e) {
68 SV *v;
69 char t16[16], s8[8];
70 STRLEN tl, sl;
71 const char *p;
72 4 ▶ if (!e) return;
Branch: 1 branch
BranchTrueFalseTotal
if (!e) return; 0 4 4
73 4 ▶ if ((v = otel_h(aTHX_ e, "time_unix_nano")))
Branch: 1 branch
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ e, "time_unix_nano"))) 4 0 4
74 4 otel_pb_fixed64(b, PB_EXEMPLAR_TIME, (U64TYPE)SvUV(v));
75 4 v = otel_h(aTHX_ e, "value");
76 4 ▶ otel_pb_double(b, PB_EXEMPLAR_AS_DOUBLE, v ? SvNV(v) : 0);
Branch: 1 branch
BranchTrueFalseTotal
otel_pb_double(b, PB_EXEMPLAR_AS_DOUBLE, v ? SvNV(v) : 0); 4 0 4
77 4 ▶ if ((p = otel_id(aTHX_ e, "span_id", 8, &sl, s8)))
Branch: 1 branch
BranchTrueFalseTotal
if ((p = otel_id(aTHX_ e, "span_id", 8, &sl, s8))) 4 0 4
78 4 otel_pb_bytes(b, PB_EXEMPLAR_SPAN_ID, p, sl);
79 4 ▶ if ((p = otel_id(aTHX_ e, "trace_id", 16, &tl, t16)))
Branch: 1 branch
BranchTrueFalseTotal
if ((p = otel_id(aTHX_ e, "trace_id", 16, &tl, t16))) 4 0 4
80 4 otel_pb_bytes(b, PB_EXEMPLAR_TRACE_ID, p, tl);
81 }
82  
83 /* ---- data points -------------------------------------------------------- */
84  
85 42 static size_t otel_pb_ndp_size(pTHX_ HV *dp) {
86 42 size_t n = otel_attrs_size(aTHX_ otel_h_hv(aTHX_ dp, "attributes"),
87 PB_NDP_ATTRIBUTES);
88 42 n += otel_pb_fixed64_size(PB_NDP_START_TIME);
89 42 n += otel_pb_fixed64_size(PB_NDP_TIME);
90 42 n += otel_pb_double_size(PB_NDP_AS_DOUBLE);
91 {
92 42 AV *ex = otel_h_av(aTHX_ dp, "exemplars");
93 42 ▶ SSize_t i, c = ex ? av_len(ex) + 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
SSize_t i, c = ex ? av_len(ex) + 1 : 0; 0 42 42
94 42 ▶ for (i = 0; i < c; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < c; i++) { 0 42 42
95 0 SV **e = av_fetch(ex, i, 0);
96 0 ▶ n += otel_pb_msg_size(PB_NDP_EXEMPLARS,
Branch: 1 branch
BranchTrueFalseTotal
n += otel_pb_msg_size(PB_NDP_EXEMPLARS, 0 0 0
97 otel_pb_exemplar_size(aTHX_ otel_hv_of(aTHX_ (e?*e:NULL))));
98 }
99 }
100 42 return n;
101 }
102  
103 7 static void otel_pb_ndp_write(pTHX_ otel_buf *b, HV *dp) {
104 SV *v;
105 AV *ex;
106 SSize_t i, c;
107 7 otel_attrs_write(aTHX_ b, otel_h_hv(aTHX_ dp, "attributes"),
108 PB_NDP_ATTRIBUTES);
109 7 v = otel_h(aTHX_ dp, "start_time_unix_nano");
110 7 ▶ otel_pb_fixed64(b, PB_NDP_START_TIME, v ? (U64TYPE)SvUV(v) : 0);
Branch: 1 branch
BranchTrueFalseTotal
otel_pb_fixed64(b, PB_NDP_START_TIME, v ? (U64TYPE)SvUV(v) : 0); 6 1 7
111 7 v = otel_h(aTHX_ dp, "time_unix_nano");
112 7 ▶ otel_pb_fixed64(b, PB_NDP_TIME, v ? (U64TYPE)SvUV(v) : 0);
Branch: 1 branch
BranchTrueFalseTotal
otel_pb_fixed64(b, PB_NDP_TIME, v ? (U64TYPE)SvUV(v) : 0); 6 1 7
113 7 v = otel_h(aTHX_ dp, "value");
114 7 ▶ if (!v) v = otel_h(aTHX_ dp, "sum");
Branch: 1 branch
BranchTrueFalseTotal
if (!v) v = otel_h(aTHX_ dp, "sum"); 1 6 7
115 7 ▶ otel_pb_double(b, PB_NDP_AS_DOUBLE, v ? SvNV(v) : 0);
Branch: 1 branch
BranchTrueFalseTotal
otel_pb_double(b, PB_NDP_AS_DOUBLE, v ? SvNV(v) : 0); 7 0 7
116 7 ex = otel_h_av(aTHX_ dp, "exemplars");
117 7 ▶ c = ex ? av_len(ex) + 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
c = ex ? av_len(ex) + 1 : 0; 0 7 7
118 7 ▶ for (i = 0; i < c; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < c; i++) { 0 7 7
119 0 SV **e = av_fetch(ex, i, 0);
120 0 ▶ HV *eh = otel_hv_of(aTHX_ (e ? *e : NULL));
Branch: 1 branch
BranchTrueFalseTotal
HV *eh = otel_hv_of(aTHX_ (e ? *e : NULL)); 0 0 0
121 0 size_t s = otel_pb_exemplar_size(aTHX_ eh), mark;
122 0 otel_pb_msg_head(b, PB_NDP_EXEMPLARS, s);
123 0 mark = b->len;
124 0 otel_pb_exemplar_write(aTHX_ b, eh);
125 OTEL_PB_CHECK(b, mark, s, "Exemplar");
126 }
127 7 }
128  
129 42 static size_t otel_pb_hdp_size(pTHX_ HV *dp) {
130 IV bk[OTEL_PB_MAX_BUCKETS];
131 double bd[OTEL_PB_MAX_BUCKETS];
132 42 int nb = otel_iv_list(aTHX_ otel_h_av(aTHX_ dp, "bucket_counts"),
133 bk, OTEL_PB_MAX_BUCKETS);
134 42 int nd = otel_nv_list(aTHX_ otel_h_av(aTHX_ dp, "explicit_bounds"),
135 bd, OTEL_PB_MAX_BUCKETS);
136 42 size_t n = otel_attrs_size(aTHX_ otel_h_hv(aTHX_ dp, "attributes"),
137 PB_HDP_ATTRIBUTES);
138 42 n += otel_pb_fixed64_size(PB_HDP_START_TIME);
139 42 n += otel_pb_fixed64_size(PB_HDP_TIME);
140 42 n += otel_pb_fixed64_size(PB_HDP_COUNT);
141 42 n += otel_pb_double_size(PB_HDP_SUM);
142 /* PACKED VARINTS. OTLP declares bucket_counts `repeated uint64`, and a
143 * uint64 in proto3 is a varint - the fixed64 writer beside it encodes a
144 * different wire type entirely, so a conformant receiver reads eight
145 * bytes where one was meant and every bucket comes out wrong. The
146 * exponential histogram's buckets, which are the same proto type, used
147 * the varint writer all along. */
148 42 ▶ if (nb) n += otel_pb_packed_varint_size(PB_HDP_BUCKET_COUNTS, bk, nb);
Branch: 1 branch
BranchTrueFalseTotal
if (nb) n += otel_pb_packed_varint_size(PB_HDP_BUCKET_COUNTS, bk, nb); 42 0 42
149 42 ▶ if (nd) n += otel_pb_packed_double_size(PB_HDP_EXPLICIT_BOUNDS, nd);
Branch: 1 branch
BranchTrueFalseTotal
if (nd) n += otel_pb_packed_double_size(PB_HDP_EXPLICIT_BOUNDS, nd); 42 0 42
150 42 ▶ if (otel_h(aTHX_ dp, "min")) n += otel_pb_double_size(PB_HDP_MIN);
Branch: 1 branch
BranchTrueFalseTotal
if (otel_h(aTHX_ dp, "min")) n += otel_pb_double_size(PB_HDP_MIN); 36 6 42
151 42 ▶ if (otel_h(aTHX_ dp, "max")) n += otel_pb_double_size(PB_HDP_MAX);
Branch: 1 branch
BranchTrueFalseTotal
if (otel_h(aTHX_ dp, "max")) n += otel_pb_double_size(PB_HDP_MAX); 36 6 42
152 {
153 42 AV *ex = otel_h_av(aTHX_ dp, "exemplars");
154 42 ▶ SSize_t i, c = ex ? av_len(ex) + 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
SSize_t i, c = ex ? av_len(ex) + 1 : 0; 24 18 42
155 66 ▶ for (i = 0; i < c; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < c; i++) { 24 42 66
156 24 SV **e = av_fetch(ex, i, 0);
157 24 ▶ n += otel_pb_msg_size(PB_HDP_EXEMPLARS,
Branch: 1 branch
BranchTrueFalseTotal
n += otel_pb_msg_size(PB_HDP_EXEMPLARS, 24 0 24
158 otel_pb_exemplar_size(aTHX_ otel_hv_of(aTHX_ (e?*e:NULL))));
159 }
160 }
161 42 return n;
162 }
163  
164 7 static void otel_pb_hdp_write(pTHX_ otel_buf *b, HV *dp) {
165 IV bk[OTEL_PB_MAX_BUCKETS];
166 double bd[OTEL_PB_MAX_BUCKETS];
167 7 int nb = otel_iv_list(aTHX_ otel_h_av(aTHX_ dp, "bucket_counts"),
168 bk, OTEL_PB_MAX_BUCKETS);
169 7 int nd = otel_nv_list(aTHX_ otel_h_av(aTHX_ dp, "explicit_bounds"),
170 bd, OTEL_PB_MAX_BUCKETS);
171 SV *v;
172 AV *ex;
173 SSize_t i, c;
174 7 otel_attrs_write(aTHX_ b, otel_h_hv(aTHX_ dp, "attributes"),
175 PB_HDP_ATTRIBUTES);
176 7 v = otel_h(aTHX_ dp, "start_time_unix_nano");
177 7 ▶ otel_pb_fixed64(b, PB_HDP_START_TIME, v ? (U64TYPE)SvUV(v) : 0);
Branch: 1 branch
BranchTrueFalseTotal
otel_pb_fixed64(b, PB_HDP_START_TIME, v ? (U64TYPE)SvUV(v) : 0); 6 1 7
178 7 v = otel_h(aTHX_ dp, "time_unix_nano");
179 7 ▶ otel_pb_fixed64(b, PB_HDP_TIME, v ? (U64TYPE)SvUV(v) : 0);
Branch: 1 branch
BranchTrueFalseTotal
otel_pb_fixed64(b, PB_HDP_TIME, v ? (U64TYPE)SvUV(v) : 0); 7 0 7
180 7 v = otel_h(aTHX_ dp, "count");
181 7 ▶ otel_pb_fixed64(b, PB_HDP_COUNT, v ? (U64TYPE)SvUV(v) : 0);
Branch: 1 branch
BranchTrueFalseTotal
otel_pb_fixed64(b, PB_HDP_COUNT, v ? (U64TYPE)SvUV(v) : 0); 7 0 7
182 7 v = otel_h(aTHX_ dp, "sum");
183 7 ▶ otel_pb_double(b, PB_HDP_SUM, v ? SvNV(v) : 0);
Branch: 1 branch
BranchTrueFalseTotal
otel_pb_double(b, PB_HDP_SUM, v ? SvNV(v) : 0); 7 0 7
184 7 ▶ if (nb) otel_pb_packed_varint(b, PB_HDP_BUCKET_COUNTS, bk, nb);
Branch: 1 branch
BranchTrueFalseTotal
if (nb) otel_pb_packed_varint(b, PB_HDP_BUCKET_COUNTS, bk, nb); 7 0 7
185 7 ▶ if (nd) otel_pb_packed_double(b, PB_HDP_EXPLICIT_BOUNDS, bd, nd);
Branch: 1 branch
BranchTrueFalseTotal
if (nd) otel_pb_packed_double(b, PB_HDP_EXPLICIT_BOUNDS, bd, nd); 7 0 7
186 7 ▶ if ((v = otel_h(aTHX_ dp, "min"))) otel_pb_double(b, PB_HDP_MIN, SvNV(v));
Branch: 1 branch
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ dp, "min"))) otel_pb_double(b, PB_HDP_MIN, SvNV(v)); 6 1 7
187 7 ▶ if ((v = otel_h(aTHX_ dp, "max"))) otel_pb_double(b, PB_HDP_MAX, SvNV(v));
Branch: 1 branch
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ dp, "max"))) otel_pb_double(b, PB_HDP_MAX, SvNV(v)); 6 1 7
188 7 ex = otel_h_av(aTHX_ dp, "exemplars");
189 7 ▶ c = ex ? av_len(ex) + 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
c = ex ? av_len(ex) + 1 : 0; 4 3 7
190 11 ▶ for (i = 0; i < c; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < c; i++) { 4 7 11
191 4 SV **e = av_fetch(ex, i, 0);
192 4 ▶ HV *eh = otel_hv_of(aTHX_ (e ? *e : NULL));
Branch: 1 branch
BranchTrueFalseTotal
HV *eh = otel_hv_of(aTHX_ (e ? *e : NULL)); 4 0 4
193 4 size_t s = otel_pb_exemplar_size(aTHX_ eh), mark;
194 4 otel_pb_msg_head(b, PB_HDP_EXEMPLARS, s);
195 4 mark = b->len;
196 4 otel_pb_exemplar_write(aTHX_ b, eh);
197 OTEL_PB_CHECK(b, mark, s, "Exemplar");
198 }
199 7 }
200  
201 /* the positive/negative Buckets sub-message */
202 28 static size_t otel_pb_buckets_size(pTHX_ HV *side) {
203 IV bk[OTEL_PB_MAX_BUCKETS];
204 int n;
205 28 size_t sz = 0;
206 SV *off;
207 28 ▶ if (!side) return 0;
Branch: 1 branch
BranchTrueFalseTotal
if (!side) return 0; 0 28 28
208 28 n = otel_iv_list(aTHX_ otel_h_av(aTHX_ side, "bucket_counts"),
209 bk, OTEL_PB_MAX_BUCKETS);
210 28 off = otel_h(aTHX_ side, "offset");
211 42 ▶ if (off && SvIV(off)) sz += otel_pb_int32_size(PB_BUCKETS_OFFSET,
Branch: 2 branches
BranchTrueFalseTotal
if (off && SvIV(off)) sz += otel_pb_int32_size(PB_BUCKETS_OFFSET, 28 0 28
if (off && SvIV(off)) sz += otel_pb_int32_size(PB_BUCKETS_OFFSET, 14 14 28
212 14 (int)SvIV(off));
213 28 ▶ if (n) sz += otel_pb_packed_varint_size(PB_BUCKETS_COUNTS, bk, n);
Branch: 1 branch
BranchTrueFalseTotal
if (n) sz += otel_pb_packed_varint_size(PB_BUCKETS_COUNTS, bk, n); 14 14 28
214 28 return sz;
215 }
216 4 static void otel_pb_buckets_write(pTHX_ otel_buf *b, HV *side) {
217 IV bk[OTEL_PB_MAX_BUCKETS];
218 int n;
219 SV *off;
220 4 ▶ if (!side) return;
Branch: 1 branch
BranchTrueFalseTotal
if (!side) return; 0 4 4
221 4 n = otel_iv_list(aTHX_ otel_h_av(aTHX_ side, "bucket_counts"),
222 bk, OTEL_PB_MAX_BUCKETS);
223 4 off = otel_h(aTHX_ side, "offset");
224 4 ▶ if (off && SvIV(off)) otel_pb_int32(b, PB_BUCKETS_OFFSET, (int)SvIV(off));
Branch: 2 branches
BranchTrueFalseTotal
if (off && SvIV(off)) otel_pb_int32(b, PB_BUCKETS_OFFSET, (int)SvIV(off)); 4 0 4
if (off && SvIV(off)) otel_pb_int32(b, PB_BUCKETS_OFFSET, (int)SvIV(off)); 2 2 4
225 4 ▶ if (n) otel_pb_packed_varint(b, PB_BUCKETS_COUNTS, bk, n);
Branch: 1 branch
BranchTrueFalseTotal
if (n) otel_pb_packed_varint(b, PB_BUCKETS_COUNTS, bk, n); 2 2 4
226 }
227  
228 12 static size_t otel_pb_edp_size(pTHX_ HV *dp) {
229 12 size_t n = otel_attrs_size(aTHX_ otel_h_hv(aTHX_ dp, "attributes"),
230 PB_EDP_ATTRIBUTES);
231 12 HV *pos = otel_h_hv(aTHX_ dp, "positive");
232 12 HV *neg = otel_h_hv(aTHX_ dp, "negative");
233 SV *v;
234 12 n += otel_pb_fixed64_size(PB_EDP_START_TIME);
235 12 n += otel_pb_fixed64_size(PB_EDP_TIME);
236 12 n += otel_pb_fixed64_size(PB_EDP_COUNT);
237 12 n += otel_pb_double_size(PB_EDP_SUM);
238 12 ▶ if ((v = otel_h(aTHX_ dp, "scale")))
Branch: 1 branch
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ dp, "scale"))) 12 0 12
239 12 n += otel_pb_int32_size(PB_EDP_SCALE, (int)SvIV(v));
240 12 ▶ if ((v = otel_h(aTHX_ dp, "zero_count")) && SvUV(v))
Branch: 2 branches
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ dp, "zero_count")) && SvUV(v)) 12 0 12
if ((v = otel_h(aTHX_ dp, "zero_count")) && SvUV(v)) 0 12 12
241 0 n += otel_pb_fixed64_size(PB_EDP_ZERO_COUNT);
242 12 ▶ if (pos) n += otel_pb_msg_size(PB_EDP_POSITIVE,
Branch: 1 branch
BranchTrueFalseTotal
if (pos) n += otel_pb_msg_size(PB_EDP_POSITIVE, 12 0 12
243 otel_pb_buckets_size(aTHX_ pos));
244 12 ▶ if (neg) n += otel_pb_msg_size(PB_EDP_NEGATIVE,
Branch: 1 branch
BranchTrueFalseTotal
if (neg) n += otel_pb_msg_size(PB_EDP_NEGATIVE, 12 0 12
245 otel_pb_buckets_size(aTHX_ neg));
246 12 return n;
247 }
248  
249 2 static void otel_pb_edp_write(pTHX_ otel_buf *b, HV *dp) {
250 2 HV *pos = otel_h_hv(aTHX_ dp, "positive");
251 2 HV *neg = otel_h_hv(aTHX_ dp, "negative");
252 SV *v;
253 2 otel_attrs_write(aTHX_ b, otel_h_hv(aTHX_ dp, "attributes"),
254 PB_EDP_ATTRIBUTES);
255 2 v = otel_h(aTHX_ dp, "start_time_unix_nano");
256 2 ▶ otel_pb_fixed64(b, PB_EDP_START_TIME, v ? (U64TYPE)SvUV(v) : 0);
Branch: 1 branch
BranchTrueFalseTotal
otel_pb_fixed64(b, PB_EDP_START_TIME, v ? (U64TYPE)SvUV(v) : 0); 2 0 2
257 2 v = otel_h(aTHX_ dp, "time_unix_nano");
258 2 ▶ otel_pb_fixed64(b, PB_EDP_TIME, v ? (U64TYPE)SvUV(v) : 0);
Branch: 1 branch
BranchTrueFalseTotal
otel_pb_fixed64(b, PB_EDP_TIME, v ? (U64TYPE)SvUV(v) : 0); 2 0 2
259 2 v = otel_h(aTHX_ dp, "count");
260 2 ▶ otel_pb_fixed64(b, PB_EDP_COUNT, v ? (U64TYPE)SvUV(v) : 0);
Branch: 1 branch
BranchTrueFalseTotal
otel_pb_fixed64(b, PB_EDP_COUNT, v ? (U64TYPE)SvUV(v) : 0); 2 0 2
261 2 v = otel_h(aTHX_ dp, "sum");
262 2 ▶ otel_pb_double(b, PB_EDP_SUM, v ? SvNV(v) : 0);
Branch: 1 branch
BranchTrueFalseTotal
otel_pb_double(b, PB_EDP_SUM, v ? SvNV(v) : 0); 2 0 2
263 2 ▶ if ((v = otel_h(aTHX_ dp, "scale")))
Branch: 1 branch
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ dp, "scale"))) 2 0 2
264 2 otel_pb_int32(b, PB_EDP_SCALE, (int)SvIV(v));
265 2 ▶ if ((v = otel_h(aTHX_ dp, "zero_count")) && SvUV(v))
Branch: 2 branches
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ dp, "zero_count")) && SvUV(v)) 2 0 2
if ((v = otel_h(aTHX_ dp, "zero_count")) && SvUV(v)) 0 2 2
266 0 otel_pb_fixed64(b, PB_EDP_ZERO_COUNT, (U64TYPE)SvUV(v));
267 2 ▶ if (pos) {
Branch: 1 branch
BranchTrueFalseTotal
if (pos) { 2 0 2
268 2 size_t s = otel_pb_buckets_size(aTHX_ pos), mark;
269 2 otel_pb_msg_head(b, PB_EDP_POSITIVE, s);
270 2 mark = b->len;
271 2 otel_pb_buckets_write(aTHX_ b, pos);
272 OTEL_PB_CHECK(b, mark, s, "Buckets");
273 }
274 2 ▶ if (neg) {
Branch: 1 branch
BranchTrueFalseTotal
if (neg) { 2 0 2
275 2 size_t s = otel_pb_buckets_size(aTHX_ neg), mark;
276 2 otel_pb_msg_head(b, PB_EDP_NEGATIVE, s);
277 2 mark = b->len;
278 2 otel_pb_buckets_write(aTHX_ b, neg);
279 OTEL_PB_CHECK(b, mark, s, "Buckets");
280 }
281 2 }
282  
283 /* ---- Metric ------------------------------------------------------------- */
284  
285 /* the data-type wrapper a metric's aggregation implies */
286 160 static void otel_pb_metric_kind(pTHX_ HV *m, int *field, int *dp_field,
287 int *temporality_field, int *monotonic) {
288 160 IV agg = 0;
289 160 SV *v = otel_h(aTHX_ m, "aggregation");
290 160 ▶ if (v) agg = SvIV(v);
Branch: 1 branch
BranchTrueFalseTotal
if (v) agg = SvIV(v); 160 0 160
291 160 *monotonic = 0;
292 160 switch (agg) {
293 0 case 2: /* last value -> Gauge, which has no temporality */
294 0 *field = PB_METRIC_GAUGE; *dp_field = PB_GAUGE_DATA_POINTS;
295 0 *temporality_field = 0;
296 0 break;
297 70 case 3:
298 70 *field = PB_METRIC_HISTOGRAM; *dp_field = PB_HIST_DATA_POINTS;
299 70 *temporality_field = PB_HIST_TEMPORALITY;
300 70 break;
301 20 case 4:
302 20 *field = PB_METRIC_EXP_HISTOGRAM; *dp_field = PB_EXPO_DATA_POINTS;
303 20 *temporality_field = PB_EXPO_TEMPORALITY;
304 20 break;
305 70 default:
306 70 *field = PB_METRIC_SUM; *dp_field = PB_SUM_DATA_POINTS;
307 70 *temporality_field = PB_SUM_TEMPORALITY;
308 70 v = otel_h(aTHX_ m, "monotonic");
309 70 ▶ *monotonic = (v && SvTRUE(v)) ? 1 : 0;
Branch: 2 branches
BranchTrueFalseTotal
*monotonic = (v && SvTRUE(v)) ? 1 : 0; 60 10 70
*monotonic = (v && SvTRUE(v)) ? 1 : 0; 60 0 60
310 70 break;
311 }
312 160 }
313  
314 96 static size_t otel_pb_dp_size(pTHX_ HV *dp, IV agg) {
315 96 ▶ if (agg == 3) return otel_pb_hdp_size(aTHX_ dp);
Branch: 1 branch
BranchTrueFalseTotal
if (agg == 3) return otel_pb_hdp_size(aTHX_ dp); 42 54 96
316 54 ▶ if (agg == 4) return otel_pb_edp_size(aTHX_ dp);
Branch: 1 branch
BranchTrueFalseTotal
if (agg == 4) return otel_pb_edp_size(aTHX_ dp); 12 42 54
317 42 return otel_pb_ndp_size(aTHX_ dp);
318 }
319 16 static void otel_pb_dp_write(pTHX_ otel_buf *b, HV *dp, IV agg) {
320 16 ▶ if (agg == 3) otel_pb_hdp_write(aTHX_ b, dp);
Branch: 1 branch
BranchTrueFalseTotal
if (agg == 3) otel_pb_hdp_write(aTHX_ b, dp); 7 9 16
321 9 ▶ else if (agg == 4) otel_pb_edp_write(aTHX_ b, dp);
Branch: 1 branch
BranchTrueFalseTotal
else if (agg == 4) otel_pb_edp_write(aTHX_ b, dp); 2 7 9
322 7 else otel_pb_ndp_write(aTHX_ b, dp);
323 16 }
324  
325 80 static size_t otel_pb_metric_body_size(pTHX_ HV *m) {
326 int field, dpf, tf, mono;
327 80 IV agg = otel_h(aTHX_ m, "aggregation")
328 80 ▶ ? SvIV(otel_h(aTHX_ m, "aggregation")) : 1;
Branch: 1 branch
BranchTrueFalseTotal
? SvIV(otel_h(aTHX_ m, "aggregation")) : 1; 80 0 80
329 80 AV *dps = otel_h_av(aTHX_ m, "data_points");
330 80 ▶ SSize_t i, c = dps ? av_len(dps) + 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
SSize_t i, c = dps ? av_len(dps) + 1 : 0; 80 0 80
331 80 size_t inner = 0;
332 80 otel_pb_metric_kind(aTHX_ m, &field, &dpf, &tf, &mono);
333 160 ▶ for (i = 0; i < c; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < c; i++) { 80 80 160
334 80 SV **e = av_fetch(dps, i, 0);
335 80 ▶ inner += otel_pb_msg_size(dpf,
Branch: 1 branch
BranchTrueFalseTotal
inner += otel_pb_msg_size(dpf, 80 0 80
336 otel_pb_dp_size(aTHX_ otel_hv_of(aTHX_ (e?*e:NULL)), agg));
337 }
338 80 ▶ if (tf) {
Branch: 1 branch
BranchTrueFalseTotal
if (tf) { 80 0 80
339 80 SV *t = otel_h(aTHX_ m, "temporality");
340 80 ▶ inner += otel_pb_int32_size(tf, otel_pb_temporality(t ? SvIV(t) : 1));
Branch: 1 branch
BranchTrueFalseTotal
inner += otel_pb_int32_size(tf, otel_pb_temporality(t ? SvIV(t) : 1)); 75 5 80
341 }
342 80 ▶ if (mono) inner += otel_pb_bool_size(PB_SUM_IS_MONOTONIC);
Branch: 1 branch
BranchTrueFalseTotal
if (mono) inner += otel_pb_bool_size(PB_SUM_IS_MONOTONIC); 30 50 80
343 80 return inner;
344 }
345  
346 64 static size_t otel_pb_metric_size(pTHX_ HV *m) {
347 64 size_t n = 0;
348 SV *v;
349 int field, dpf, tf, mono;
350 64 ▶ if ((v = otel_h(aTHX_ m, "name"))) {
Branch: 1 branch
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ m, "name"))) { 64 0 64
351 STRLEN l; (void)SvPV_const(v, l);
352 64 n += otel_pb_bytes_size(PB_METRIC_NAME, l);
353 }
354 64 ▶ if ((v = otel_h(aTHX_ m, "description"))) {
Branch: 1 branch
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ m, "description"))) { 0 64 64
355 STRLEN l; (void)SvPV_const(v, l);
356 0 n += otel_pb_bytes_size(PB_METRIC_DESCRIPTION, l);
357 }
358 64 ▶ if ((v = otel_h(aTHX_ m, "unit"))) {
Branch: 1 branch
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ m, "unit"))) { 8 56 64
359 STRLEN l; (void)SvPV_const(v, l);
360 8 n += otel_pb_bytes_size(PB_METRIC_UNIT, l);
361 }
362 64 otel_pb_metric_kind(aTHX_ m, &field, &dpf, &tf, &mono);
363 64 n += otel_pb_msg_size(field, otel_pb_metric_body_size(aTHX_ m));
364 64 return n;
365 }
366  
367 16 static void otel_pb_metric_write(pTHX_ otel_buf *b, HV *m) {
368 SV *v;
369 int field, dpf, tf, mono;
370 16 IV agg = otel_h(aTHX_ m, "aggregation")
371 16 ▶ ? SvIV(otel_h(aTHX_ m, "aggregation")) : 1;
Branch: 1 branch
BranchTrueFalseTotal
? SvIV(otel_h(aTHX_ m, "aggregation")) : 1; 16 0 16
372 AV *dps;
373 SSize_t i, c;
374 size_t inner, mark;
375  
376 16 ▶ if ((v = otel_h(aTHX_ m, "name"))) {
Branch: 1 branch
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ m, "name"))) { 16 0 16
377 16 STRLEN l; const char *s = SvPV_const(v, l);
378 16 otel_pb_bytes(b, PB_METRIC_NAME, s, l);
379 }
380 16 ▶ if ((v = otel_h(aTHX_ m, "description"))) {
Branch: 1 branch
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ m, "description"))) { 0 16 16
381 0 STRLEN l; const char *s = SvPV_const(v, l);
382 0 otel_pb_bytes(b, PB_METRIC_DESCRIPTION, s, l);
383 }
384 16 ▶ if ((v = otel_h(aTHX_ m, "unit"))) {
Branch: 1 branch
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ m, "unit"))) { 2 14 16
385 2 STRLEN l; const char *s = SvPV_const(v, l);
386 2 otel_pb_bytes(b, PB_METRIC_UNIT, s, l);
387 }
388 16 otel_pb_metric_kind(aTHX_ m, &field, &dpf, &tf, &mono);
389 16 inner = otel_pb_metric_body_size(aTHX_ m);
390 16 otel_pb_msg_head(b, field, inner);
391 16 mark = b->len;
392  
393 16 dps = otel_h_av(aTHX_ m, "data_points");
394 16 ▶ c = dps ? av_len(dps) + 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
c = dps ? av_len(dps) + 1 : 0; 16 0 16
395 32 ▶ for (i = 0; i < c; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < c; i++) { 16 16 32
396 16 SV **e = av_fetch(dps, i, 0);
397 16 ▶ HV *dp = otel_hv_of(aTHX_ (e ? *e : NULL));
Branch: 1 branch
BranchTrueFalseTotal
HV *dp = otel_hv_of(aTHX_ (e ? *e : NULL)); 16 0 16
398 16 size_t s = otel_pb_dp_size(aTHX_ dp, agg), m2;
399 16 otel_pb_msg_head(b, dpf, s);
400 16 m2 = b->len;
401 16 otel_pb_dp_write(aTHX_ b, dp, agg);
402 OTEL_PB_CHECK(b, m2, s, "DataPoint");
403 }
404 16 ▶ if (tf) {
Branch: 1 branch
BranchTrueFalseTotal
if (tf) { 16 0 16
405 16 SV *t = otel_h(aTHX_ m, "temporality");
406 16 ▶ otel_pb_int32(b, tf, otel_pb_temporality(t ? SvIV(t) : 1));
Branch: 1 branch
BranchTrueFalseTotal
otel_pb_int32(b, tf, otel_pb_temporality(t ? SvIV(t) : 1)); 15 1 16
407 }
408 16 ▶ if (mono) otel_pb_bool(b, PB_SUM_IS_MONOTONIC, 1);
Branch: 1 branch
BranchTrueFalseTotal
if (mono) otel_pb_bool(b, PB_SUM_IS_MONOTONIC, 1); 6 10 16
409 OTEL_PB_CHECK(b, mark, inner, "Metric body");
410 16 }
411  
412 /* ---- ExportMetricsServiceRequest ---------------------------------------- */
413  
414 48 static size_t otel_pb_scopemetrics_size(pTHX_ HV *sm) {
415 48 size_t n = 0;
416 48 HV *sc = otel_h_hv(aTHX_ sm, "scope");
417 48 AV *ms = otel_h_av(aTHX_ sm, "metrics");
418 SSize_t i, c;
419 48 ▶ if (sc) n += otel_pb_msg_size(PB_SCOPEMETRICS_SCOPE,
Branch: 1 branch
BranchTrueFalseTotal
if (sc) n += otel_pb_msg_size(PB_SCOPEMETRICS_SCOPE, 45 3 48
420 otel_scope_size(aTHX_ sc));
421 48 ▶ c = ms ? av_len(ms) + 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
c = ms ? av_len(ms) + 1 : 0; 48 0 48
422 96 ▶ for (i = 0; i < c; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < c; i++) { 48 48 96
423 48 SV **e = av_fetch(ms, i, 0);
424 48 ▶ n += otel_pb_msg_size(PB_SCOPEMETRICS_METRICS,
Branch: 1 branch
BranchTrueFalseTotal
n += otel_pb_msg_size(PB_SCOPEMETRICS_METRICS, 48 0 48
425 otel_pb_metric_size(aTHX_ otel_hv_of(aTHX_ (e?*e:NULL))));
426 }
427 {
428 48 SV *url = otel_h(aTHX_ sm, "schema_url");
429 48 ▶ if (url) { STRLEN l; (void)SvPV_const(url, l);
Branch: 1 branch
BranchTrueFalseTotal
if (url) { STRLEN l; (void)SvPV_const(url, l); 3 45 48
430 3 n += otel_pb_bytes_size(PB_SCOPEMETRICS_SCHEMA_URL, l); }
431 }
432 48 return n;
433 }
434  
435 16 static void otel_pb_scopemetrics_write(pTHX_ otel_buf *b, HV *sm) {
436 16 HV *sc = otel_h_hv(aTHX_ sm, "scope");
437 16 AV *ms = otel_h_av(aTHX_ sm, "metrics");
438 SSize_t i, c;
439 16 ▶ if (sc) {
Branch: 1 branch
BranchTrueFalseTotal
if (sc) { 15 1 16
440 15 size_t s = otel_scope_size(aTHX_ sc), mark;
441 15 otel_pb_msg_head(b, PB_SCOPEMETRICS_SCOPE, s);
442 15 mark = b->len;
443 15 otel_scope_write(aTHX_ b, sc);
444 OTEL_PB_CHECK(b, mark, s, "Scope");
445 }
446 16 ▶ c = ms ? av_len(ms) + 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
c = ms ? av_len(ms) + 1 : 0; 16 0 16
447 32 ▶ for (i = 0; i < c; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < c; i++) { 16 16 32
448 16 SV **e = av_fetch(ms, i, 0);
449 16 ▶ HV *m = otel_hv_of(aTHX_ (e ? *e : NULL));
Branch: 1 branch
BranchTrueFalseTotal
HV *m = otel_hv_of(aTHX_ (e ? *e : NULL)); 16 0 16
450 16 size_t s = otel_pb_metric_size(aTHX_ m), mark;
451 16 otel_pb_msg_head(b, PB_SCOPEMETRICS_METRICS, s);
452 16 mark = b->len;
453 16 otel_pb_metric_write(aTHX_ b, m);
454 OTEL_PB_CHECK(b, mark, s, "Metric");
455 }
456 {
457 16 SV *url = otel_h(aTHX_ sm, "schema_url");
458 16 ▶ if (url) { STRLEN l; const char *u = SvPV_const(url, l);
Branch: 1 branch
BranchTrueFalseTotal
if (url) { STRLEN l; const char *u = SvPV_const(url, l); 1 15 16
459 1 otel_pb_bytes(b, PB_SCOPEMETRICS_SCHEMA_URL, u, l); }
460 }
461 16 }
462  
463 32 static size_t otel_pb_resourcemetrics_size(pTHX_ HV *rm) {
464 32 size_t n = 0;
465 32 HV *res = otel_h_hv(aTHX_ rm, "resource");
466 32 AV *sms = otel_h_av(aTHX_ rm, "scope_metrics");
467 32 SV *url = otel_h(aTHX_ rm, "schema_url");
468 SSize_t i, c;
469 32 ▶ if (res) n += otel_pb_msg_size(PB_RESOURCEMETRICS_RESOURCE,
Branch: 1 branch
BranchTrueFalseTotal
if (res) n += otel_pb_msg_size(PB_RESOURCEMETRICS_RESOURCE, 30 2 32
470 otel_resource_size(aTHX_ res));
471 32 ▶ c = sms ? av_len(sms) + 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
c = sms ? av_len(sms) + 1 : 0; 32 0 32
472 64 ▶ for (i = 0; i < c; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < c; i++) { 32 32 64
473 32 SV **e = av_fetch(sms, i, 0);
474 32 ▶ n += otel_pb_msg_size(PB_RESOURCEMETRICS_SCOPE_METRICS,
Branch: 1 branch
BranchTrueFalseTotal
n += otel_pb_msg_size(PB_RESOURCEMETRICS_SCOPE_METRICS, 32 0 32
475 otel_pb_scopemetrics_size(aTHX_ otel_hv_of(aTHX_ (e?*e:NULL))));
476 }
477 32 ▶ if (url) { STRLEN l; (void)SvPV_const(url, l);
Branch: 1 branch
BranchTrueFalseTotal
if (url) { STRLEN l; (void)SvPV_const(url, l); 2 30 32
478 2 n += otel_pb_bytes_size(PB_RESOURCEMETRICS_SCHEMA_URL, l); }
479 32 return n;
480 }
481  
482 16 static void otel_pb_resourcemetrics_write(pTHX_ otel_buf *b, HV *rm) {
483 16 HV *res = otel_h_hv(aTHX_ rm, "resource");
484 16 AV *sms = otel_h_av(aTHX_ rm, "scope_metrics");
485 16 SV *url = otel_h(aTHX_ rm, "schema_url");
486 SSize_t i, c;
487 16 ▶ if (res) {
Branch: 1 branch
BranchTrueFalseTotal
if (res) { 15 1 16
488 15 size_t s = otel_resource_size(aTHX_ res), mark;
489 15 otel_pb_msg_head(b, PB_RESOURCEMETRICS_RESOURCE, s);
490 15 mark = b->len;
491 15 otel_resource_write(aTHX_ b, res);
492 OTEL_PB_CHECK(b, mark, s, "Resource");
493 }
494 16 ▶ c = sms ? av_len(sms) + 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
c = sms ? av_len(sms) + 1 : 0; 16 0 16
495 32 ▶ for (i = 0; i < c; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < c; i++) { 16 16 32
496 16 SV **e = av_fetch(sms, i, 0);
497 16 ▶ HV *sm = otel_hv_of(aTHX_ (e ? *e : NULL));
Branch: 1 branch
BranchTrueFalseTotal
HV *sm = otel_hv_of(aTHX_ (e ? *e : NULL)); 16 0 16
498 16 size_t s = otel_pb_scopemetrics_size(aTHX_ sm), mark;
499 16 otel_pb_msg_head(b, PB_RESOURCEMETRICS_SCOPE_METRICS, s);
500 16 mark = b->len;
501 16 otel_pb_scopemetrics_write(aTHX_ b, sm);
502 OTEL_PB_CHECK(b, mark, s, "ScopeMetrics");
503 }
504 16 ▶ if (url) { STRLEN l; const char *s = SvPV_const(url, l);
Branch: 1 branch
BranchTrueFalseTotal
if (url) { STRLEN l; const char *s = SvPV_const(url, l); 1 15 16
505 1 otel_pb_bytes(b, PB_RESOURCEMETRICS_SCHEMA_URL, s, l); }
506 16 }
507  
508 18 static SV *otel_encode_metrics(pTHX_ HV *payload) {
509 otel_buf b;
510 18 AV *rms = otel_h_av(aTHX_ payload, "resource_metrics");
511 18 ▶ SSize_t i, c = rms ? av_len(rms) + 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
SSize_t i, c = rms ? av_len(rms) + 1 : 0; 16 2 18
512 18 size_t total = 0;
513 SV *out;
514 34 ▶ for (i = 0; i < c; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < c; i++) { 16 18 34
515 16 SV **e = av_fetch(rms, i, 0);
516 16 ▶ total += otel_pb_msg_size(PB_EXPORT_METRICS_RESOURCE_METRICS,
Branch: 1 branch
BranchTrueFalseTotal
total += otel_pb_msg_size(PB_EXPORT_METRICS_RESOURCE_METRICS, 16 0 16
517 otel_pb_resourcemetrics_size(aTHX_
518 otel_hv_of(aTHX_ (e ? *e : NULL))));
519 }
520 18 ▶ otel_buf_init(&b, total ? total : 64);
Branch: 1 branch
BranchTrueFalseTotal
otel_buf_init(&b, total ? total : 64); 16 2 18
521 34 ▶ for (i = 0; i < c; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < c; i++) { 16 18 34
522 16 SV **e = av_fetch(rms, i, 0);
523 16 ▶ HV *rm = otel_hv_of(aTHX_ (e ? *e : NULL));
Branch: 1 branch
BranchTrueFalseTotal
HV *rm = otel_hv_of(aTHX_ (e ? *e : NULL)); 16 0 16
524 16 size_t s = otel_pb_resourcemetrics_size(aTHX_ rm), mark;
525 16 otel_pb_msg_head(&b, PB_EXPORT_METRICS_RESOURCE_METRICS, s);
526 16 mark = b.len;
527 16 otel_pb_resourcemetrics_write(aTHX_ &b, rm);
528 OTEL_PB_CHECK(&b, mark, s, "ResourceMetrics");
529 }
530 18 out = newSVpvn(b.buf, b.len);
531 18 otel_buf_free(&b);
532 18 return out;
533 }
534  
535 /* ---- logs --------------------------------------------------------------- */
536  
537 28 static size_t otel_pb_logrecord_size(pTHX_ HV *r) {
538 28 size_t n = 0;
539 SV *v;
540 char t16[16], s8[8];
541 STRLEN tl, sl;
542 28 ▶ if (otel_h(aTHX_ r, "time_unix_nano"))
Branch: 1 branch
BranchTrueFalseTotal
if (otel_h(aTHX_ r, "time_unix_nano")) 24 4 28
543 24 n += otel_pb_fixed64_size(PB_LOGRECORD_TIME);
544 28 ▶ if (otel_h(aTHX_ r, "observed_time_unix_nano"))
Branch: 1 branch
BranchTrueFalseTotal
if (otel_h(aTHX_ r, "observed_time_unix_nano")) 24 4 28
545 24 n += otel_pb_fixed64_size(PB_LOGRECORD_OBSERVED_TIME);
546 28 ▶ if ((v = otel_h(aTHX_ r, "severity_number")))
Branch: 1 branch
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ r, "severity_number"))) 24 4 28
547 24 n += otel_pb_int32_size(PB_LOGRECORD_SEVERITY_NUMBER, (int)SvIV(v));
548 28 ▶ if ((v = otel_h(aTHX_ r, "severity_text"))) {
Branch: 1 branch
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ r, "severity_text"))) { 24 4 28
549 STRLEN l; (void)SvPV_const(v, l);
550 24 n += otel_pb_bytes_size(PB_LOGRECORD_SEVERITY_TEXT, l);
551 }
552 /* the body is an AnyValue, so a structured body is possible - not only a
553 * string, which is what lets a record carry its fields as a map */
554 28 ▶ if ((v = otel_h(aTHX_ r, "body")))
Branch: 1 branch
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ r, "body"))) 28 0 28
555 28 n += otel_pb_msg_size(PB_LOGRECORD_BODY,
556 otel_anyvalue_body_size(aTHX_ v));
557 28 n += otel_attrs_size(aTHX_ otel_h_hv(aTHX_ r, "attributes"),
558 PB_LOGRECORD_ATTRIBUTES);
559 28 ▶ if (otel_id(aTHX_ r, "trace_id", 16, &tl, t16))
Branch: 1 branch
BranchTrueFalseTotal
if (otel_id(aTHX_ r, "trace_id", 16, &tl, t16)) 16 12 28
560 16 n += otel_pb_bytes_size(PB_LOGRECORD_TRACE_ID, tl);
561 28 ▶ if (otel_id(aTHX_ r, "span_id", 8, &sl, s8))
Branch: 1 branch
BranchTrueFalseTotal
if (otel_id(aTHX_ r, "span_id", 8, &sl, s8)) 16 12 28
562 16 n += otel_pb_bytes_size(PB_LOGRECORD_SPAN_ID, sl);
563 28 return n;
564 }
565  
566 7 static void otel_pb_logrecord_write(pTHX_ otel_buf *b, HV *r) {
567 SV *v;
568 char t16[16], s8[8];
569 STRLEN tl, sl;
570 const char *p;
571 7 ▶ if ((v = otel_h(aTHX_ r, "time_unix_nano")))
Branch: 1 branch
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ r, "time_unix_nano"))) 6 1 7
572 6 otel_pb_fixed64(b, PB_LOGRECORD_TIME, (U64TYPE)SvUV(v));
573 7 ▶ if ((v = otel_h(aTHX_ r, "observed_time_unix_nano")))
Branch: 1 branch
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ r, "observed_time_unix_nano"))) 6 1 7
574 6 otel_pb_fixed64(b, PB_LOGRECORD_OBSERVED_TIME, (U64TYPE)SvUV(v));
575 7 ▶ if ((v = otel_h(aTHX_ r, "severity_number")))
Branch: 1 branch
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ r, "severity_number"))) 6 1 7
576 6 otel_pb_int32(b, PB_LOGRECORD_SEVERITY_NUMBER, (int)SvIV(v));
577 7 ▶ if ((v = otel_h(aTHX_ r, "severity_text"))) {
Branch: 1 branch
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ r, "severity_text"))) { 6 1 7
578 6 STRLEN l; const char *s = SvPV_const(v, l);
579 6 otel_pb_bytes(b, PB_LOGRECORD_SEVERITY_TEXT, s, l);
580 }
581 7 ▶ if ((v = otel_h(aTHX_ r, "body"))) {
Branch: 1 branch
BranchTrueFalseTotal
if ((v = otel_h(aTHX_ r, "body"))) { 7 0 7
582 7 size_t s = otel_anyvalue_body_size(aTHX_ v), mark;
583 7 otel_pb_msg_head(b, PB_LOGRECORD_BODY, s);
584 7 mark = b->len;
585 7 otel_anyvalue_body_write(aTHX_ b, v);
586 OTEL_PB_CHECK(b, mark, s, "LogRecord.body");
587 }
588 7 otel_attrs_write(aTHX_ b, otel_h_hv(aTHX_ r, "attributes"),
589 PB_LOGRECORD_ATTRIBUTES);
590 7 ▶ if ((p = otel_id(aTHX_ r, "trace_id", 16, &tl, t16)))
Branch: 1 branch
BranchTrueFalseTotal
if ((p = otel_id(aTHX_ r, "trace_id", 16, &tl, t16))) 4 3 7
591 4 otel_pb_bytes(b, PB_LOGRECORD_TRACE_ID, p, tl);
592 7 ▶ if ((p = otel_id(aTHX_ r, "span_id", 8, &sl, s8)))
Branch: 1 branch
BranchTrueFalseTotal
if ((p = otel_id(aTHX_ r, "span_id", 8, &sl, s8))) 4 3 7
593 4 otel_pb_bytes(b, PB_LOGRECORD_SPAN_ID, p, sl);
594 7 }
595  
596 15 static size_t otel_pb_scopelogs_size(pTHX_ HV *sl) {
597 15 size_t n = 0;
598 15 HV *sc = otel_h_hv(aTHX_ sl, "scope");
599 15 AV *rs = otel_h_av(aTHX_ sl, "log_records");
600 SSize_t i, c;
601 15 ▶ if (sc) n += otel_pb_msg_size(PB_SCOPELOGS_SCOPE,
Branch: 1 branch
BranchTrueFalseTotal
if (sc) n += otel_pb_msg_size(PB_SCOPELOGS_SCOPE, 12 3 15
602 otel_scope_size(aTHX_ sc));
603 15 ▶ c = rs ? av_len(rs) + 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
c = rs ? av_len(rs) + 1 : 0; 15 0 15
604 36 ▶ for (i = 0; i < c; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < c; i++) { 21 15 36
605 21 SV **e = av_fetch(rs, i, 0);
606 21 ▶ n += otel_pb_msg_size(PB_SCOPELOGS_RECORDS,
Branch: 1 branch
BranchTrueFalseTotal
n += otel_pb_msg_size(PB_SCOPELOGS_RECORDS, 21 0 21
607 otel_pb_logrecord_size(aTHX_ otel_hv_of(aTHX_ (e?*e:NULL))));
608 }
609 {
610 15 SV *url = otel_h(aTHX_ sl, "schema_url");
611 15 ▶ if (url) { STRLEN l; (void)SvPV_const(url, l);
Branch: 1 branch
BranchTrueFalseTotal
if (url) { STRLEN l; (void)SvPV_const(url, l); 3 12 15
612 3 n += otel_pb_bytes_size(PB_SCOPELOGS_SCHEMA_URL, l); }
613 }
614 15 return n;
615 }
616  
617 5 static void otel_pb_scopelogs_write(pTHX_ otel_buf *b, HV *sl) {
618 5 HV *sc = otel_h_hv(aTHX_ sl, "scope");
619 5 AV *rs = otel_h_av(aTHX_ sl, "log_records");
620 SSize_t i, c;
621 5 ▶ if (sc) {
Branch: 1 branch
BranchTrueFalseTotal
if (sc) { 4 1 5
622 4 size_t s = otel_scope_size(aTHX_ sc), mark;
623 4 otel_pb_msg_head(b, PB_SCOPELOGS_SCOPE, s);
624 4 mark = b->len;
625 4 otel_scope_write(aTHX_ b, sc);
626 OTEL_PB_CHECK(b, mark, s, "Scope");
627 }
628 5 ▶ c = rs ? av_len(rs) + 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
c = rs ? av_len(rs) + 1 : 0; 5 0 5
629 12 ▶ for (i = 0; i < c; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < c; i++) { 7 5 12
630 7 SV **e = av_fetch(rs, i, 0);
631 7 ▶ HV *r = otel_hv_of(aTHX_ (e ? *e : NULL));
Branch: 1 branch
BranchTrueFalseTotal
HV *r = otel_hv_of(aTHX_ (e ? *e : NULL)); 7 0 7
632 7 size_t s = otel_pb_logrecord_size(aTHX_ r), mark;
633 7 otel_pb_msg_head(b, PB_SCOPELOGS_RECORDS, s);
634 7 mark = b->len;
635 7 otel_pb_logrecord_write(aTHX_ b, r);
636 OTEL_PB_CHECK(b, mark, s, "LogRecord");
637 }
638 {
639 5 SV *url = otel_h(aTHX_ sl, "schema_url");
640 5 ▶ if (url) { STRLEN l; const char *u = SvPV_const(url, l);
Branch: 1 branch
BranchTrueFalseTotal
if (url) { STRLEN l; const char *u = SvPV_const(url, l); 1 4 5
641 1 otel_pb_bytes(b, PB_SCOPELOGS_SCHEMA_URL, u, l); }
642 }
643 5 }
644  
645 7 static SV *otel_encode_logs(pTHX_ HV *payload) {
646 otel_buf b;
647 7 AV *rls = otel_h_av(aTHX_ payload, "resource_logs");
648 7 ▶ SSize_t i, c = rls ? av_len(rls) + 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
SSize_t i, c = rls ? av_len(rls) + 1 : 0; 5 2 7
649 7 size_t total = 0;
650 SV *out;
651  
652 12 ▶ for (i = 0; i < c; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < c; i++) { 5 7 12
653 5 SV **e = av_fetch(rls, i, 0);
654 5 ▶ HV *rl = otel_hv_of(aTHX_ (e ? *e : NULL));
Branch: 1 branch
BranchTrueFalseTotal
HV *rl = otel_hv_of(aTHX_ (e ? *e : NULL)); 5 0 5
655 5 HV *res = otel_h_hv(aTHX_ rl, "resource");
656 5 AV *sls = otel_h_av(aTHX_ rl, "scope_logs");
657 5 size_t inner = 0;
658 5 ▶ SSize_t j, d = sls ? av_len(sls) + 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
SSize_t j, d = sls ? av_len(sls) + 1 : 0; 5 0 5
659 5 ▶ if (res) inner += otel_pb_msg_size(PB_RESOURCELOGS_RESOURCE,
Branch: 1 branch
BranchTrueFalseTotal
if (res) inner += otel_pb_msg_size(PB_RESOURCELOGS_RESOURCE, 4 1 5
660 otel_resource_size(aTHX_ res));
661 10 ▶ for (j = 0; j < d; j++) {
Branch: 1 branch
BranchTrueFalseTotal
for (j = 0; j < d; j++) { 5 5 10
662 5 SV **s = av_fetch(sls, j, 0);
663 5 ▶ inner += otel_pb_msg_size(PB_RESOURCELOGS_SCOPE_LOGS,
Branch: 1 branch
BranchTrueFalseTotal
inner += otel_pb_msg_size(PB_RESOURCELOGS_SCOPE_LOGS, 5 0 5
664 otel_pb_scopelogs_size(aTHX_
665 otel_hv_of(aTHX_ (s ? *s : NULL))));
666 }
667 {
668 5 SV *url = otel_h(aTHX_ rl, "schema_url");
669 5 ▶ if (url) { STRLEN l; (void)SvPV_const(url, l);
Branch: 1 branch
BranchTrueFalseTotal
if (url) { STRLEN l; (void)SvPV_const(url, l); 1 4 5
670 1 inner += otel_pb_bytes_size(PB_RESOURCELOGS_SCHEMA_URL, l); }
671 }
672 5 total += otel_pb_msg_size(PB_EXPORT_LOGS_RESOURCE_LOGS, inner);
673 }
674  
675 7 ▶ otel_buf_init(&b, total ? total : 64);
Branch: 1 branch
BranchTrueFalseTotal
otel_buf_init(&b, total ? total : 64); 5 2 7
676 12 ▶ for (i = 0; i < c; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < c; i++) { 5 7 12
677 5 SV **e = av_fetch(rls, i, 0);
678 5 ▶ HV *rl = otel_hv_of(aTHX_ (e ? *e : NULL));
Branch: 1 branch
BranchTrueFalseTotal
HV *rl = otel_hv_of(aTHX_ (e ? *e : NULL)); 5 0 5
679 5 HV *res = otel_h_hv(aTHX_ rl, "resource");
680 5 AV *sls = otel_h_av(aTHX_ rl, "scope_logs");
681 5 size_t inner = 0, mark;
682 5 ▶ SSize_t j, d = sls ? av_len(sls) + 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
SSize_t j, d = sls ? av_len(sls) + 1 : 0; 5 0 5
683 5 ▶ if (res) inner += otel_pb_msg_size(PB_RESOURCELOGS_RESOURCE,
Branch: 1 branch
BranchTrueFalseTotal
if (res) inner += otel_pb_msg_size(PB_RESOURCELOGS_RESOURCE, 4 1 5
684 otel_resource_size(aTHX_ res));
685 10 ▶ for (j = 0; j < d; j++) {
Branch: 1 branch
BranchTrueFalseTotal
for (j = 0; j < d; j++) { 5 5 10
686 5 SV **s = av_fetch(sls, j, 0);
687 5 ▶ inner += otel_pb_msg_size(PB_RESOURCELOGS_SCOPE_LOGS,
Branch: 1 branch
BranchTrueFalseTotal
inner += otel_pb_msg_size(PB_RESOURCELOGS_SCOPE_LOGS, 5 0 5
688 otel_pb_scopelogs_size(aTHX_
689 otel_hv_of(aTHX_ (s ? *s : NULL))));
690 }
691 {
692 5 SV *url = otel_h(aTHX_ rl, "schema_url");
693 5 ▶ if (url) { STRLEN l; (void)SvPV_const(url, l);
Branch: 1 branch
BranchTrueFalseTotal
if (url) { STRLEN l; (void)SvPV_const(url, l); 1 4 5
694 1 inner += otel_pb_bytes_size(PB_RESOURCELOGS_SCHEMA_URL, l); }
695 }
696 5 otel_pb_msg_head(&b, PB_EXPORT_LOGS_RESOURCE_LOGS, inner);
697 5 mark = b.len;
698 5 ▶ if (res) {
Branch: 1 branch
BranchTrueFalseTotal
if (res) { 4 1 5
699 4 size_t rs = otel_resource_size(aTHX_ res), m2;
700 4 otel_pb_msg_head(&b, PB_RESOURCELOGS_RESOURCE, rs);
701 4 m2 = b.len;
702 4 otel_resource_write(aTHX_ &b, res);
703 OTEL_PB_CHECK(&b, m2, rs, "Resource");
704 }
705 10 ▶ for (j = 0; j < d; j++) {
Branch: 1 branch
BranchTrueFalseTotal
for (j = 0; j < d; j++) { 5 5 10
706 5 SV **s = av_fetch(sls, j, 0);
707 5 ▶ HV *sl = otel_hv_of(aTHX_ (s ? *s : NULL));
Branch: 1 branch
BranchTrueFalseTotal
HV *sl = otel_hv_of(aTHX_ (s ? *s : NULL)); 5 0 5
708 5 size_t ss = otel_pb_scopelogs_size(aTHX_ sl), m2;
709 5 otel_pb_msg_head(&b, PB_RESOURCELOGS_SCOPE_LOGS, ss);
710 5 m2 = b.len;
711 5 otel_pb_scopelogs_write(aTHX_ &b, sl);
712 OTEL_PB_CHECK(&b, m2, ss, "ScopeLogs");
713 }
714 {
715 5 SV *url = otel_h(aTHX_ rl, "schema_url");
716 5 ▶ if (url) { STRLEN l; const char *u = SvPV_const(url, l);
Branch: 1 branch
BranchTrueFalseTotal
if (url) { STRLEN l; const char *u = SvPV_const(url, l); 1 4 5
717 1 otel_pb_bytes(&b, PB_RESOURCELOGS_SCHEMA_URL, u, l); }
718 }
719 OTEL_PB_CHECK(&b, mark, inner, "ResourceLogs");
720 }
721 7 out = newSVpvn(b.buf, b.len);
722 7 otel_buf_free(&b);
723 7 return out;
724 }
725  
726 #endif /* OTEL_SIGNAL_PB_H */
« xs/instrument.xs ↑ Summary include/otel_metric.h »