def test_counter_to_prometheus(self):
meter = get_meter_provider().get_meter(__name__)
metric = meter.create_counter(
"test@name",
"testdesc",
"unit",
int,
)
labels = {"environment@": "staging", "os": "Windows"}
key_labels = get_dict_as_key(labels)
aggregator = SumAggregator()
aggregator.update(123)
aggregator.take_checkpoint()
record = ExportRecord(metric, key_labels, aggregator,
get_meter_provider().resource)
collector = CustomCollector("testprefix")
collector.add_metrics_data([record])
for prometheus_metric in collector.collect():
self.assertEqual(type(prometheus_metric), CounterMetricFamily)
self.assertEqual(prometheus_metric.name, "testprefix_test_name")
self.assertEqual(prometheus_metric.documentation, "testdesc")
self.assertTrue(len(prometheus_metric.samples) == 1)
self.assertEqual(prometheus_metric.samples[0].value, 123)
self.assertTrue(len(prometheus_metric.samples[0].labels) == 2)
self.assertEqual(
prometheus_metric.samples[0].labels["environment_"], "staging")
self.assertEqual(prometheus_metric.samples[0].labels["os"],
"Windows")
def test_metric_to_envelope(self):
aggregator = SumAggregator()
aggregator.update(123)
aggregator.take_checkpoint()
record = MetricRecord(self._test_metric, self._test_labels, aggregator)
exporter = self._exporter
envelope = exporter._metric_to_envelope(record)
self.assertIsInstance(envelope, Envelope)
self.assertEqual(envelope.ver, 1)
self.assertEqual(envelope.name, "Microsoft.ApplicationInsights.Metric")
self.assertEqual(envelope.time,
ns_to_iso_str(aggregator.last_update_timestamp))
self.assertEqual(envelope.sample_rate, None)
self.assertEqual(envelope.seq, None)
self.assertEqual(envelope.ikey, "1234abcd-5678-4efa-8abc-1234567890ab")
self.assertEqual(envelope.flags, None)
self.assertIsInstance(envelope.data, Data)
self.assertIsInstance(envelope.data.base_data, MetricData)
self.assertEqual(envelope.data.base_data.ver, 2)
self.assertEqual(len(envelope.data.base_data.metrics), 1)
self.assertIsInstance(envelope.data.base_data.metrics[0], DataPoint)
self.assertEqual(envelope.data.base_data.metrics[0].ns, "testdesc")
self.assertEqual(envelope.data.base_data.metrics[0].name, "testname")
self.assertEqual(envelope.data.base_data.metrics[0].value, 123)
self.assertEqual(envelope.data.base_data.properties["environment"],
"staging")
self.assertIsNotNone(envelope.tags["ai.cloud.role"])
self.assertIsNotNone(envelope.tags["ai.cloud.roleInstance"])
self.assertIsNotNone(envelope.tags["ai.device.id"])
self.assertIsNotNone(envelope.tags["ai.device.locale"])
self.assertIsNotNone(envelope.tags["ai.device.osVersion"])
self.assertIsNotNone(envelope.tags["ai.device.type"])
self.assertIsNotNone(envelope.tags["ai.internal.sdkVersion"])
def test_create_timeseries(self):
def create_label(name, value):
label = Label()
label.name = name
label.value = value
return label
sum_aggregator = SumAggregator()
sum_aggregator.update(5)
sum_aggregator.take_checkpoint()
export_record = ExportRecord(
Counter("testname", "testdesc", "testunit", int, None),
get_dict_as_key({"record_name": "record_value"}),
sum_aggregator,
Resource({"resource_name": "resource_value"}),
)
expected_timeseries = TimeSeries()
expected_timeseries.labels.append(create_label("__name__", "testname"))
expected_timeseries.labels.append(
create_label("resource_name", "resource_value"))
expected_timeseries.labels.append(
create_label("record_name", "record_value"))
sample = expected_timeseries.samples.add()
sample.timestamp = int(sum_aggregator.last_update_timestamp / 1000000)
sample.value = 5.0
timeseries = self.exporter._create_timeseries(export_record,
"testname", 5.0)
self.assertEqual(timeseries, expected_timeseries)
def test_live_metric_envelope_documents(self):
aggregator = SumAggregator()
aggregator.update(123)
aggregator.take_checkpoint()
record = MetricRecord(self._test_metric, self._test_labels, aggregator)
exporter = LiveMetricsExporter(
instrumentation_key=self._instrumentation_key,
span_processor=self._span_processor,
)
request_data = RemoteDependency(
name="testName",
id="",
result_code="testResultCode",
duration="testDuration",
success=True,
properties={},
measurements={},
)
request_data.properties["test_property1"] = "test_property1Value"
request_data.properties["test_property2"] = "test_property2Value"
request_data.measurements[
"test_measurement1"] = "test_measurement1Value"
request_data.measurements[
"test_measurement2"] = "test_measurement2Value"
test_envelope = Envelope(data=Data(base_type="RemoteDependencyData",
base_data=request_data))
self._span_processor.documents.append(test_envelope)
envelope = exporter._metric_to_live_metrics_envelope([record])
self.assertIsInstance(envelope, LiveMetricEnvelope)
self.assertEqual(len(envelope.documents), 1)
self.assertEqual(
envelope.documents[0].quickpulse_type,
"DependencyTelemetryDocument",
)
self.assertEqual(envelope.documents[0].document_type,
"RemoteDependency")
self.assertEqual(envelope.documents[0].version, "1.0")
self.assertEqual(envelope.documents[0].operation_id, "")
self.assertEqual(len(envelope.documents[0].properties), 4)
self.assertEqual(
envelope.documents[0].properties["test_measurement1"],
"test_measurement1Value",
)
self.assertEqual(
envelope.documents[0].properties["test_measurement2"],
"test_measurement2Value",
)
self.assertEqual(
envelope.documents[0].properties["test_property1"],
"test_property1Value",
)
self.assertEqual(
envelope.documents[0].properties["test_property2"],
"test_property2Value",
)
def test_concurrent_update(self):
sum_agg = SumAggregator()
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
fut1 = executor.submit(self.call_update, sum_agg)
fut2 = executor.submit(self.call_update, sum_agg)
updapte_total = fut1.result() + fut2.result()
sum_agg.take_checkpoint()
self.assertEqual(updapte_total, sum_agg.checkpoint)
def test_concurrent_update_and_checkpoint(self):
sum_agg = SumAggregator()
checkpoint_total = 0
with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
fut = executor.submit(self.call_update, sum_agg)
while not fut.done():
sum_agg.take_checkpoint()
checkpoint_total += sum_agg.checkpoint
sum_agg.take_checkpoint()
checkpoint_total += sum_agg.checkpoint
self.assertEqual(fut.result(), checkpoint_total)
def test_live_metric_envelope_counter(self):
aggregator = SumAggregator()
aggregator.update(123)
aggregator.take_checkpoint()
record = MetricRecord(self._test_metric, self._test_labels, aggregator)
exporter = LiveMetricsExporter(
instrumentation_key=self._instrumentation_key,
span_processor=self._span_processor,
)
envelope = exporter._metric_to_live_metrics_envelope([record])
self.assertIsInstance(envelope, LiveMetricEnvelope)
self.assertEqual(envelope.documents, [])
self.assertEqual(envelope.metrics[0].name, "testname")
self.assertEqual(envelope.metrics[0].value, 123)
self.assertEqual(envelope.metrics[0].weight, 1)
def test_checkpoint(self):
sum_agg = SumAggregator()
sum_agg.update(2.0)
sum_agg.take_checkpoint()
self.assertEqual(sum_agg.current, 0)
self.assertEqual(sum_agg.checkpoint, 2.0)
