|
15 | 15 | import os
|
16 | 16 | from collections import OrderedDict
|
17 | 17 | from unittest import TestCase
|
18 |
| -from unittest.mock import patch |
| 18 | +from unittest.mock import Mock, patch |
19 | 19 |
|
20 | 20 | from grpc import ChannelCredentials
|
21 | 21 |
|
|
41 | 41 | from opentelemetry.proto.resource.v1.resource_pb2 import (
|
42 | 42 | Resource as OTLPResource,
|
43 | 43 | )
|
44 |
| -from opentelemetry.sdk.metrics import Counter, MeterProvider |
| 44 | +from opentelemetry.sdk.metrics import ( |
| 45 | + Counter, |
| 46 | + MeterProvider, |
| 47 | + SumObserver, |
| 48 | + UpDownCounter, |
| 49 | + UpDownSumObserver, |
| 50 | +) |
45 | 51 | from opentelemetry.sdk.metrics.export import ExportRecord
|
46 | 52 | from opentelemetry.sdk.metrics.export.aggregate import SumAggregator
|
47 | 53 | from opentelemetry.sdk.resources import Resource as SDKResource
|
|
50 | 56 |
|
51 | 57 |
|
52 | 58 | class TestOTLPMetricExporter(TestCase):
|
53 |
| - @patch("opentelemetry.sdk.metrics.export.aggregate.time_ns") |
54 |
| - def setUp(self, mock_time_ns): # pylint: disable=arguments-differ |
55 |
| - mock_time_ns.configure_mock(**{"return_value": 1}) |
| 59 | + def setUp(self): # pylint: disable=arguments-differ |
56 | 60 | self.exporter = OTLPMetricsExporter(insecure=True)
|
57 |
| - resource = SDKResource(OrderedDict([("a", 1), ("b", False)])) |
58 |
| - |
59 |
| - self.counter_export_record = ExportRecord( |
60 |
| - Counter( |
61 |
| - "c", |
62 |
| - "d", |
63 |
| - "e", |
64 |
| - int, |
65 |
| - MeterProvider(resource=resource,).get_meter("name", "version"), |
66 |
| - ("f",), |
67 |
| - ), |
68 |
| - [("g", "h")], |
69 |
| - SumAggregator(), |
70 |
| - resource, |
| 61 | + self.resource = SDKResource(OrderedDict([("a", 1), ("b", False)])) |
| 62 | + self.meter = MeterProvider(resource=self.resource,).get_meter( |
| 63 | + "name", "version" |
71 | 64 | )
|
72 |
| - |
73 | 65 | Configuration._reset() # pylint: disable=protected-access
|
74 | 66 |
|
75 | 67 | def tearDown(self):
|
@@ -102,12 +94,20 @@ def test_no_credentials_error(self):
|
102 | 94 | with self.assertRaises(ValueError):
|
103 | 95 | OTLPMetricsExporter()
|
104 | 96 |
|
105 |
| - def test_translate_metrics(self): |
106 |
| - # pylint: disable=no-member |
| 97 | + @patch("opentelemetry.sdk.metrics.export.aggregate.time_ns") |
| 98 | + def test_translate_counter_export_record(self, mock_time_ns): |
| 99 | + mock_time_ns.configure_mock(**{"return_value": 1}) |
| 100 | + |
| 101 | + counter_export_record = ExportRecord( |
| 102 | + Counter("c", "d", "e", int, self.meter, ("f",),), |
| 103 | + [("g", "h")], |
| 104 | + SumAggregator(), |
| 105 | + self.resource, |
| 106 | + ) |
107 | 107 |
|
108 |
| - self.counter_export_record.aggregator.checkpoint = 1 |
109 |
| - self.counter_export_record.aggregator.initial_checkpoint_timestamp = 1 |
110 |
| - self.counter_export_record.aggregator.last_update_timestamp = 1 |
| 108 | + counter_export_record.aggregator.checkpoint = 1 |
| 109 | + counter_export_record.aggregator.initial_checkpoint_timestamp = 1 |
| 110 | + counter_export_record.aggregator.last_update_timestamp = 1 |
111 | 111 |
|
112 | 112 | expected = ExportMetricsServiceRequest(
|
113 | 113 | resource_metrics=[
|
@@ -157,6 +157,203 @@ def test_translate_metrics(self):
|
157 | 157 | )
|
158 | 158 |
|
159 | 159 | # pylint: disable=protected-access
|
160 |
| - actual = self.exporter._translate_data([self.counter_export_record]) |
| 160 | + actual = self.exporter._translate_data([counter_export_record]) |
| 161 | + |
| 162 | + self.assertEqual(expected, actual) |
| 163 | + |
| 164 | + @patch("opentelemetry.sdk.metrics.export.aggregate.time_ns") |
| 165 | + def test_translate_sum_observer_export_record(self, mock_time_ns): |
| 166 | + mock_time_ns.configure_mock(**{"return_value": 1}) |
| 167 | + counter_export_record = ExportRecord( |
| 168 | + SumObserver(Mock(), "c", "d", "e", int, self.meter, ("f",),), |
| 169 | + [("g", "h")], |
| 170 | + SumAggregator(), |
| 171 | + self.resource, |
| 172 | + ) |
| 173 | + |
| 174 | + counter_export_record.aggregator.checkpoint = 1 |
| 175 | + counter_export_record.aggregator.initial_checkpoint_timestamp = 1 |
| 176 | + counter_export_record.aggregator.last_update_timestamp = 1 |
| 177 | + |
| 178 | + expected = ExportMetricsServiceRequest( |
| 179 | + resource_metrics=[ |
| 180 | + ResourceMetrics( |
| 181 | + resource=OTLPResource( |
| 182 | + attributes=[ |
| 183 | + KeyValue(key="a", value=AnyValue(int_value=1)), |
| 184 | + KeyValue( |
| 185 | + key="b", value=AnyValue(bool_value=False) |
| 186 | + ), |
| 187 | + ] |
| 188 | + ), |
| 189 | + instrumentation_library_metrics=[ |
| 190 | + InstrumentationLibraryMetrics( |
| 191 | + instrumentation_library=InstrumentationLibrary( |
| 192 | + name="name", version="version", |
| 193 | + ), |
| 194 | + metrics=[ |
| 195 | + OTLPMetric( |
| 196 | + name="c", |
| 197 | + description="d", |
| 198 | + unit="e", |
| 199 | + int_sum=IntSum( |
| 200 | + data_points=[ |
| 201 | + IntDataPoint( |
| 202 | + labels=[ |
| 203 | + StringKeyValue( |
| 204 | + key="g", value="h" |
| 205 | + ) |
| 206 | + ], |
| 207 | + value=1, |
| 208 | + time_unix_nano=1, |
| 209 | + start_time_unix_nano=1, |
| 210 | + ) |
| 211 | + ], |
| 212 | + aggregation_temporality=( |
| 213 | + AggregationTemporality.AGGREGATION_TEMPORALITY_CUMULATIVE |
| 214 | + ), |
| 215 | + is_monotonic=True, |
| 216 | + ), |
| 217 | + ) |
| 218 | + ], |
| 219 | + ) |
| 220 | + ], |
| 221 | + ) |
| 222 | + ] |
| 223 | + ) |
| 224 | + |
| 225 | + # pylint: disable=protected-access |
| 226 | + actual = self.exporter._translate_data([counter_export_record]) |
| 227 | + |
| 228 | + self.assertEqual(expected, actual) |
| 229 | + |
| 230 | + @patch("opentelemetry.sdk.metrics.export.aggregate.time_ns") |
| 231 | + def test_translate_updowncounter_export_record(self, mock_time_ns): |
| 232 | + mock_time_ns.configure_mock(**{"return_value": 1}) |
| 233 | + |
| 234 | + counter_export_record = ExportRecord( |
| 235 | + UpDownCounter("c", "d", "e", int, self.meter), |
| 236 | + [("g", "h")], |
| 237 | + SumAggregator(), |
| 238 | + self.resource, |
| 239 | + ) |
| 240 | + |
| 241 | + counter_export_record.aggregator.checkpoint = 1 |
| 242 | + counter_export_record.aggregator.initial_checkpoint_timestamp = 1 |
| 243 | + counter_export_record.aggregator.last_update_timestamp = 1 |
| 244 | + |
| 245 | + expected = ExportMetricsServiceRequest( |
| 246 | + resource_metrics=[ |
| 247 | + ResourceMetrics( |
| 248 | + resource=OTLPResource( |
| 249 | + attributes=[ |
| 250 | + KeyValue(key="a", value=AnyValue(int_value=1)), |
| 251 | + KeyValue( |
| 252 | + key="b", value=AnyValue(bool_value=False) |
| 253 | + ), |
| 254 | + ] |
| 255 | + ), |
| 256 | + instrumentation_library_metrics=[ |
| 257 | + InstrumentationLibraryMetrics( |
| 258 | + instrumentation_library=InstrumentationLibrary( |
| 259 | + name="name", version="version", |
| 260 | + ), |
| 261 | + metrics=[ |
| 262 | + OTLPMetric( |
| 263 | + name="c", |
| 264 | + description="d", |
| 265 | + unit="e", |
| 266 | + int_sum=IntSum( |
| 267 | + data_points=[ |
| 268 | + IntDataPoint( |
| 269 | + labels=[ |
| 270 | + StringKeyValue( |
| 271 | + key="g", value="h" |
| 272 | + ) |
| 273 | + ], |
| 274 | + value=1, |
| 275 | + time_unix_nano=1, |
| 276 | + start_time_unix_nano=1, |
| 277 | + ) |
| 278 | + ], |
| 279 | + aggregation_temporality=( |
| 280 | + AggregationTemporality.AGGREGATION_TEMPORALITY_CUMULATIVE |
| 281 | + ), |
| 282 | + ), |
| 283 | + ) |
| 284 | + ], |
| 285 | + ) |
| 286 | + ], |
| 287 | + ) |
| 288 | + ] |
| 289 | + ) |
| 290 | + |
| 291 | + # pylint: disable=protected-access |
| 292 | + actual = self.exporter._translate_data([counter_export_record]) |
| 293 | + |
| 294 | + self.assertEqual(expected, actual) |
| 295 | + |
| 296 | + @patch("opentelemetry.sdk.metrics.export.aggregate.time_ns") |
| 297 | + def test_translate_updownsum_observer_export_record(self, mock_time_ns): |
| 298 | + mock_time_ns.configure_mock(**{"return_value": 1}) |
| 299 | + counter_export_record = ExportRecord( |
| 300 | + UpDownSumObserver(Mock(), "c", "d", "e", int, self.meter, ("f",),), |
| 301 | + [("g", "h")], |
| 302 | + SumAggregator(), |
| 303 | + self.resource, |
| 304 | + ) |
| 305 | + |
| 306 | + counter_export_record.aggregator.checkpoint = 1 |
| 307 | + counter_export_record.aggregator.initial_checkpoint_timestamp = 1 |
| 308 | + counter_export_record.aggregator.last_update_timestamp = 1 |
| 309 | + |
| 310 | + expected = ExportMetricsServiceRequest( |
| 311 | + resource_metrics=[ |
| 312 | + ResourceMetrics( |
| 313 | + resource=OTLPResource( |
| 314 | + attributes=[ |
| 315 | + KeyValue(key="a", value=AnyValue(int_value=1)), |
| 316 | + KeyValue( |
| 317 | + key="b", value=AnyValue(bool_value=False) |
| 318 | + ), |
| 319 | + ] |
| 320 | + ), |
| 321 | + instrumentation_library_metrics=[ |
| 322 | + InstrumentationLibraryMetrics( |
| 323 | + instrumentation_library=InstrumentationLibrary( |
| 324 | + name="name", version="version", |
| 325 | + ), |
| 326 | + metrics=[ |
| 327 | + OTLPMetric( |
| 328 | + name="c", |
| 329 | + description="d", |
| 330 | + unit="e", |
| 331 | + int_sum=IntSum( |
| 332 | + data_points=[ |
| 333 | + IntDataPoint( |
| 334 | + labels=[ |
| 335 | + StringKeyValue( |
| 336 | + key="g", value="h" |
| 337 | + ) |
| 338 | + ], |
| 339 | + value=1, |
| 340 | + time_unix_nano=1, |
| 341 | + start_time_unix_nano=1, |
| 342 | + ) |
| 343 | + ], |
| 344 | + aggregation_temporality=( |
| 345 | + AggregationTemporality.AGGREGATION_TEMPORALITY_CUMULATIVE |
| 346 | + ), |
| 347 | + ), |
| 348 | + ) |
| 349 | + ], |
| 350 | + ) |
| 351 | + ], |
| 352 | + ) |
| 353 | + ] |
| 354 | + ) |
| 355 | + |
| 356 | + # pylint: disable=protected-access |
| 357 | + actual = self.exporter._translate_data([counter_export_record]) |
161 | 358 |
|
162 | 359 | self.assertEqual(expected, actual)
|
0 commit comments