| 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
| Branch | True | False | Total |
| : 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| if (!e) return 0; |
0 |
28 |
28 |
|
| 57 |
28 |
▶ | if (otel_h(aTHX_ e, "time_unix_nano")) |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| if (!e) return; |
0 |
4 |
4 |
|
| 73 |
4 |
▶ | if ((v = otel_h(aTHX_ e, "time_unix_nano"))) |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| SSize_t i, c = ex ? av_len(ex) + 1 : 0; |
0 |
42 |
42 |
|
| 94 |
42 |
▶ | for (i = 0; i < c; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| c = ex ? av_len(ex) + 1 : 0; |
0 |
7 |
7 |
|
| 118 |
7 |
▶ | for (i = 0; i < c; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| SSize_t i, c = ex ? av_len(ex) + 1 : 0; |
24 |
18 |
42 |
|
| 155 |
66 |
▶ | for (i = 0; i < c; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| c = ex ? av_len(ex) + 1 : 0; |
4 |
3 |
7 |
|
| 190 |
11 |
▶ | for (i = 0; i < c; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| *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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| ? 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| ? 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| c = dps ? av_len(dps) + 1 : 0; |
16 |
0 |
16 |
|
| 395 |
32 |
▶ | for (i = 0; i < c; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| c = ms ? av_len(ms) + 1 : 0; |
48 |
0 |
48 |
|
| 422 |
96 |
▶ | for (i = 0; i < c; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| c = ms ? av_len(ms) + 1 : 0; |
16 |
0 |
16 |
|
| 447 |
32 |
▶ | for (i = 0; i < c; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| c = sms ? av_len(sms) + 1 : 0; |
32 |
0 |
32 |
|
| 472 |
64 |
▶ | for (i = 0; i < c; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| c = sms ? av_len(sms) + 1 : 0; |
16 |
0 |
16 |
|
| 495 |
32 |
▶ | for (i = 0; i < c; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| otel_buf_init(&b, total ? total : 64); |
16 |
2 |
18 |
|
| 521 |
34 |
▶ | for (i = 0; i < c; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| c = rs ? av_len(rs) + 1 : 0; |
15 |
0 |
15 |
|
| 604 |
36 |
▶ | for (i = 0; i < c; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| c = rs ? av_len(rs) + 1 : 0; |
5 |
0 |
5 |
|
| 629 |
12 |
▶ | for (i = 0; i < c; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| otel_buf_init(&b, total ? total : 64); |
5 |
2 |
7 |
|
| 676 |
12 |
▶ | for (i = 0; i < c; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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 */ |