@@ -1046,39 +1046,85 @@ mod tests {
1046
1046
test_context. flush_metrics ( ) ;
1047
1047
1048
1048
// Assert
1049
- let histogram = test_context. get_aggregation :: < data:: Histogram < u64 > > ( "my_histogram" , None ) ;
1049
+ let histogram_data =
1050
+ test_context. get_aggregation :: < data:: Histogram < u64 > > ( "my_histogram" , None ) ;
1050
1051
// Expecting 2 time-series.
1051
- assert_eq ! ( histogram . data_points. len( ) , 2 ) ;
1052
+ assert_eq ! ( histogram_data . data_points. len( ) , 2 ) ;
1052
1053
if let Temporality :: Cumulative = temporality {
1053
1054
assert_eq ! (
1054
- histogram . temporality,
1055
+ histogram_data . temporality,
1055
1056
Temporality :: Cumulative ,
1056
1057
"Should produce cumulative"
1057
1058
) ;
1058
1059
} else {
1059
1060
assert_eq ! (
1060
- histogram . temporality,
1061
+ histogram_data . temporality,
1061
1062
Temporality :: Delta ,
1062
1063
"Should produce delta"
1063
1064
) ;
1064
1065
}
1065
1066
1066
1067
// find and validate key1=value2 datapoint
1067
1068
let data_point1 =
1068
- find_histogram_datapoint_with_key_value ( & histogram . data_points , "key1" , "value1" )
1069
+ find_histogram_datapoint_with_key_value ( & histogram_data . data_points , "key1" , "value1" )
1069
1070
. expect ( "datapoint with key1=value1 expected" ) ;
1070
1071
assert_eq ! ( data_point1. count, values_kv1. len( ) as u64 ) ;
1071
1072
assert_eq ! ( data_point1. sum, values_kv1. iter( ) . sum:: <u64 >( ) ) ;
1072
1073
assert_eq ! ( data_point1. min. unwrap( ) , * values_kv1. iter( ) . min( ) . unwrap( ) ) ;
1073
1074
assert_eq ! ( data_point1. max. unwrap( ) , * values_kv1. iter( ) . max( ) . unwrap( ) ) ;
1074
1075
1075
1076
let data_point2 =
1076
- find_histogram_datapoint_with_key_value ( & histogram . data_points , "key1" , "value2" )
1077
+ find_histogram_datapoint_with_key_value ( & histogram_data . data_points , "key1" , "value2" )
1077
1078
. expect ( "datapoint with key1=value2 expected" ) ;
1078
1079
assert_eq ! ( data_point2. count, values_kv2. len( ) as u64 ) ;
1079
1080
assert_eq ! ( data_point2. sum, values_kv2. iter( ) . sum:: <u64 >( ) ) ;
1080
1081
assert_eq ! ( data_point2. min. unwrap( ) , * values_kv2. iter( ) . min( ) . unwrap( ) ) ;
1081
1082
assert_eq ! ( data_point2. max. unwrap( ) , * values_kv2. iter( ) . max( ) . unwrap( ) ) ;
1083
+
1084
+ // Reset and report more measurements
1085
+ test_context. reset_metrics ( ) ;
1086
+ for value in values_kv1. iter ( ) {
1087
+ histogram. record ( * value, & [ KeyValue :: new ( "key1" , "value1" ) ] ) ;
1088
+ }
1089
+
1090
+ for value in values_kv2. iter ( ) {
1091
+ histogram. record ( * value, & [ KeyValue :: new ( "key1" , "value2" ) ] ) ;
1092
+ }
1093
+
1094
+ test_context. flush_metrics ( ) ;
1095
+
1096
+ let histogram_data =
1097
+ test_context. get_aggregation :: < data:: Histogram < u64 > > ( "my_histogram" , None ) ;
1098
+ assert_eq ! ( histogram_data. data_points. len( ) , 2 ) ;
1099
+ let data_point1 =
1100
+ find_histogram_datapoint_with_key_value ( & histogram_data. data_points , "key1" , "value1" )
1101
+ . expect ( "datapoint with key1=value1 expected" ) ;
1102
+ if temporality == Temporality :: Cumulative {
1103
+ assert_eq ! ( data_point1. count, 2 * ( values_kv1. len( ) as u64 ) ) ;
1104
+ assert_eq ! ( data_point1. sum, 2 * ( values_kv1. iter( ) . sum:: <u64 >( ) ) ) ;
1105
+ assert_eq ! ( data_point1. min. unwrap( ) , * values_kv1. iter( ) . min( ) . unwrap( ) ) ;
1106
+ assert_eq ! ( data_point1. max. unwrap( ) , * values_kv1. iter( ) . max( ) . unwrap( ) ) ;
1107
+ } else {
1108
+ assert_eq ! ( data_point1. count, values_kv1. len( ) as u64 ) ;
1109
+ assert_eq ! ( data_point1. sum, values_kv1. iter( ) . sum:: <u64 >( ) ) ;
1110
+ assert_eq ! ( data_point1. min. unwrap( ) , * values_kv1. iter( ) . min( ) . unwrap( ) ) ;
1111
+ assert_eq ! ( data_point1. max. unwrap( ) , * values_kv1. iter( ) . max( ) . unwrap( ) ) ;
1112
+ }
1113
+
1114
+ let data_point1 =
1115
+ find_histogram_datapoint_with_key_value ( & histogram_data. data_points , "key1" , "value2" )
1116
+ . expect ( "datapoint with key1=value1 expected" ) ;
1117
+ if temporality == Temporality :: Cumulative {
1118
+ assert_eq ! ( data_point1. count, 2 * ( values_kv2. len( ) as u64 ) ) ;
1119
+ assert_eq ! ( data_point1. sum, 2 * ( values_kv2. iter( ) . sum:: <u64 >( ) ) ) ;
1120
+ assert_eq ! ( data_point1. min. unwrap( ) , * values_kv2. iter( ) . min( ) . unwrap( ) ) ;
1121
+ assert_eq ! ( data_point1. max. unwrap( ) , * values_kv2. iter( ) . max( ) . unwrap( ) ) ;
1122
+ } else {
1123
+ assert_eq ! ( data_point1. count, values_kv2. len( ) as u64 ) ;
1124
+ assert_eq ! ( data_point1. sum, values_kv2. iter( ) . sum:: <u64 >( ) ) ;
1125
+ assert_eq ! ( data_point1. min. unwrap( ) , * values_kv2. iter( ) . min( ) . unwrap( ) ) ;
1126
+ assert_eq ! ( data_point1. max. unwrap( ) , * values_kv2. iter( ) . max( ) . unwrap( ) ) ;
1127
+ }
1082
1128
}
1083
1129
1084
1130
fn counter_aggregation_helper ( temporality : Temporality ) {
@@ -1122,12 +1168,44 @@ mod tests {
1122
1168
let data_point1 = find_datapoint_with_key_value ( & sum. data_points , "key1" , "value2" )
1123
1169
. expect ( "datapoint with key1=value2 expected" ) ;
1124
1170
assert_eq ! ( data_point1. value, 3 ) ;
1171
+
1172
+ // Reset and report more measurements
1173
+ test_context. reset_metrics ( ) ;
1174
+ counter. add ( 1 , & [ KeyValue :: new ( "key1" , "value1" ) ] ) ;
1175
+ counter. add ( 1 , & [ KeyValue :: new ( "key1" , "value1" ) ] ) ;
1176
+ counter. add ( 1 , & [ KeyValue :: new ( "key1" , "value1" ) ] ) ;
1177
+ counter. add ( 1 , & [ KeyValue :: new ( "key1" , "value1" ) ] ) ;
1178
+ counter. add ( 1 , & [ KeyValue :: new ( "key1" , "value1" ) ] ) ;
1179
+
1180
+ counter. add ( 1 , & [ KeyValue :: new ( "key1" , "value2" ) ] ) ;
1181
+ counter. add ( 1 , & [ KeyValue :: new ( "key1" , "value2" ) ] ) ;
1182
+ counter. add ( 1 , & [ KeyValue :: new ( "key1" , "value2" ) ] ) ;
1183
+
1184
+ test_context. flush_metrics ( ) ;
1185
+
1186
+ let sum = test_context. get_aggregation :: < data:: Sum < u64 > > ( "my_counter" , None ) ;
1187
+ assert_eq ! ( sum. data_points. len( ) , 2 ) ;
1188
+ let data_point1 = find_datapoint_with_key_value ( & sum. data_points , "key1" , "value1" )
1189
+ . expect ( "datapoint with key1=value1 expected" ) ;
1190
+ if temporality == Temporality :: Cumulative {
1191
+ assert_eq ! ( data_point1. value, 10 ) ;
1192
+ } else {
1193
+ assert_eq ! ( data_point1. value, 5 ) ;
1194
+ }
1195
+
1196
+ let data_point1 = find_datapoint_with_key_value ( & sum. data_points , "key1" , "value2" )
1197
+ . expect ( "datapoint with key1=value2 expected" ) ;
1198
+ if temporality == Temporality :: Cumulative {
1199
+ assert_eq ! ( data_point1. value, 6 ) ;
1200
+ } else {
1201
+ assert_eq ! ( data_point1. value, 3 ) ;
1202
+ }
1125
1203
}
1126
1204
1127
1205
fn updown_counter_aggregation_helper ( temporality : Temporality ) {
1128
1206
// Arrange
1129
1207
let mut test_context = TestContext :: new ( temporality) ;
1130
- let counter = test_context. i64_up_down_counter ( "test" , "my_counter " , None ) ;
1208
+ let counter = test_context. i64_up_down_counter ( "test" , "my_updown_counter " , None ) ;
1131
1209
1132
1210
// Act
1133
1211
counter. add ( 1 , & [ KeyValue :: new ( "key1" , "value1" ) ] ) ;
@@ -1143,7 +1221,7 @@ mod tests {
1143
1221
test_context. flush_metrics ( ) ;
1144
1222
1145
1223
// Assert
1146
- let sum = test_context. get_aggregation :: < data:: Sum < i64 > > ( "my_counter " , None ) ;
1224
+ let sum = test_context. get_aggregation :: < data:: Sum < i64 > > ( "my_updown_counter " , None ) ;
1147
1225
// Expecting 2 time-series.
1148
1226
assert_eq ! ( sum. data_points. len( ) , 2 ) ;
1149
1227
assert ! (
@@ -1168,6 +1246,38 @@ mod tests {
1168
1246
let data_point1 = find_datapoint_with_key_value ( & sum. data_points , "key1" , "value2" )
1169
1247
. expect ( "datapoint with key1=value2 expected" ) ;
1170
1248
assert_eq ! ( data_point1. value, 3 ) ;
1249
+
1250
+ // Reset and report more measurements
1251
+ test_context. reset_metrics ( ) ;
1252
+ counter. add ( 1 , & [ KeyValue :: new ( "key1" , "value1" ) ] ) ;
1253
+ counter. add ( 1 , & [ KeyValue :: new ( "key1" , "value1" ) ] ) ;
1254
+ counter. add ( 1 , & [ KeyValue :: new ( "key1" , "value1" ) ] ) ;
1255
+ counter. add ( 1 , & [ KeyValue :: new ( "key1" , "value1" ) ] ) ;
1256
+ counter. add ( 1 , & [ KeyValue :: new ( "key1" , "value1" ) ] ) ;
1257
+
1258
+ counter. add ( 1 , & [ KeyValue :: new ( "key1" , "value2" ) ] ) ;
1259
+ counter. add ( 1 , & [ KeyValue :: new ( "key1" , "value2" ) ] ) ;
1260
+ counter. add ( 1 , & [ KeyValue :: new ( "key1" , "value2" ) ] ) ;
1261
+
1262
+ test_context. flush_metrics ( ) ;
1263
+
1264
+ let sum = test_context. get_aggregation :: < data:: Sum < i64 > > ( "my_updown_counter" , None ) ;
1265
+ assert_eq ! ( sum. data_points. len( ) , 2 ) ;
1266
+ let data_point1 = find_datapoint_with_key_value ( & sum. data_points , "key1" , "value1" )
1267
+ . expect ( "datapoint with key1=value1 expected" ) ;
1268
+ if temporality == Temporality :: Cumulative {
1269
+ assert_eq ! ( data_point1. value, 10 ) ;
1270
+ } else {
1271
+ assert_eq ! ( data_point1. value, 5 ) ;
1272
+ }
1273
+
1274
+ let data_point1 = find_datapoint_with_key_value ( & sum. data_points , "key1" , "value2" )
1275
+ . expect ( "datapoint with key1=value2 expected" ) ;
1276
+ if temporality == Temporality :: Cumulative {
1277
+ assert_eq ! ( data_point1. value, 6 ) ;
1278
+ } else {
1279
+ assert_eq ! ( data_point1. value, 3 ) ;
1280
+ }
1171
1281
}
1172
1282
1173
1283
fn find_datapoint_with_key_value < ' a , T > (
0 commit comments