def test_meter_provider_override_warning(self): """metrics.set_meter_provider should throw a warning when overridden""" metrics.set_meter_provider(MeterProvider()) with self.assertLogs(level=WARNING) as test: metrics.set_meter_provider(MeterProvider()) self.assertEqual( test.output, [("WARNING:opentelemetry.metrics:Overriding of current " "MeterProvider is not allowed")], )
def _test_metrics(self, observer_name, expected): reader = InMemoryMetricReader() meter_provider = MeterProvider(metric_readers=[reader]) system_metrics = SystemMetricsInstrumentor() system_metrics.instrument(meter_provider=meter_provider) self._assert_metrics(observer_name, reader, expected)
def setUp(self): # pylint: disable=arguments-differ self.exporter = OTLPMetricsExporter(insecure=True) self.resource = SDKResource(OrderedDict([("a", 1), ("b", False)])) self.meter = MeterProvider(resource=self.resource,).get_meter( "name", "version" ) Configuration._reset() # pylint: disable=protected-access
def test_system_metrics_instrument(self): reader = InMemoryMetricReader() meter_provider = MeterProvider(metric_readers=[reader]) system_metrics = SystemMetricsInstrumentor() system_metrics.instrument(meter_provider=meter_provider) metric_names = [] for resource_metrics in reader.get_metrics_data().resource_metrics: for scope_metrics in resource_metrics.scope_metrics: for metric in scope_metrics.metrics: metric_names.append(metric.name) self.assertEqual(len(metric_names), 17) observer_names = [ "system.cpu.time", "system.cpu.utilization", "system.memory.usage", "system.memory.utilization", "system.swap.usage", "system.swap.utilization", "system.disk.io", "system.disk.operations", "system.disk.time", "system.network.dropped_packets", "system.network.packets", "system.network.errors", "system.network.io", "system.network.connections", f"runtime.{self.implementation}.memory", f"runtime.{self.implementation}.cpu_time", f"runtime.{self.implementation}.gc_count", ] for observer in metric_names: self.assertIn(observer, observer_names) observer_names.remove(observer)
def mock_meter(stateful: Optional[bool] = None): # create an autospec of Meter from an instance in order to capture instance # variables (meter.processor) meter = MeterProvider(stateful).get_meter(__name__) meter_mock = mock.create_autospec(meter, spec_set=True) meter_mock.processor.stateful = meter.processor.stateful return meter_mock
def setUpClass(cls): # pylint: disable=protected-access cls._resource_labels = { "key_with_str_value": "some string", "key_with_int_val": 321, "key_with_true": True, } metrics.set_meter_provider( MeterProvider(resource=Resource(cls._resource_labels))) cls._meter = metrics.get_meter(__name__) cls._labels = {"environment": "staging", "number": 321} cls._key_labels = get_dict_as_key(cls._labels)
def create_meter_provider(**kwargs): """Helper to create a configured meter provider Creates a `MeterProvider` and an `InMemoryMetricsExporter`. Returns: A list with the meter provider in the first element and the in-memory metrics exporter in the second """ meter_provider = MeterProvider(**kwargs) memory_exporter = InMemoryMetricsExporter() return meter_provider, memory_exporter
def setUpClass(cls): metrics.set_meter_provider(MeterProvider()) cls._meter = metrics.get_meter(__name__) cls._test_metric = cls._meter.create_metric("testname", "testdesc", "unit", int, Counter, ["environment"]) testing_labels = {"environment": "testing"} cls._test_metric.add(5, testing_labels) cls._instrumentation_key = "99c42f65-1656-4c41-afde-bd86b709a4a7" cls._manager = None cls._ping = None cls._post = None cls._span_processor = AzureMetricsSpanProcessor()
def setUpClass(cls): metrics.set_meter_provider(MeterProvider()) cls._meter = metrics.get_meter(__name__) cls._test_metric = cls._meter.create_metric("testname", "testdesc", "unit", int, Counter, ["environment"]) testing_labels = {"environment": "testing"} cls._test_metric.add(5, testing_labels) cls._instrumentation_key = "12345678-1234-5678-abcd-12345678abcd" cls._manager = None cls._ping = None cls._post = None cls._span_processor = AzureMetricsSpanProcessor()
def setUp(self): self.exporter = OTLPMetricsExporter() resource = SDKResource(OrderedDict([("a", 1), ("b", False)])) self.counter_metric_record = MetricRecord( Counter( "a", "b", "c", int, MeterProvider(resource=resource, ).get_meter(__name__), ("d", ), ), OrderedDict([("e", "f")]), SumAggregator(), resource, )
def setUp(self): self.exporter = OTLPMetricsExporter(insecure=True) resource = SDKResource(OrderedDict([("a", 1), ("b", False)])) self.counter_metric_record = MetricRecord( Counter( "c", "d", "e", int, MeterProvider(resource=resource, ).get_meter(__name__), ("f", ), ), [("g", "h")], SumAggregator(), resource, ) Configuration._reset() # pylint: disable=protected-access
def setUpClass(cls): cls._instrumentation_key = "12345678-1234-5678-abcd-12345678abcd" metrics.set_meter_provider(MeterProvider()) cls._meter = metrics.get_meter(__name__) cls._test_metric = cls._meter.create_metric("testname", "testdesc", "unit", int, Counter, ["environment"]) cls._test_metric2 = cls._meter.create_metric("testname", "testdesc", "unit", int, ValueRecorder, ["environment"]) cls._test_obs = cls._meter.register_observer( lambda x: x, "testname", "testdesc", "unit", int, ValueObserver, ["environment"], ) cls._test_labels = tuple({"environment": "staging"}.items()) cls._span_processor = AzureMetricsSpanProcessor()
def setUpClass(cls): os.environ[ "APPINSIGHTS_INSTRUMENTATIONKEY"] = "1234abcd-5678-4efa-8abc-1234567890ab" cls._exporter = AzureMonitorMetricsExporter(storage_path=STORAGE_PATH) metrics.set_meter_provider(MeterProvider()) cls._meter = metrics.get_meter(__name__) cls._test_metric = cls._meter.create_metric("testname", "testdesc", "unit", int, Counter, ["environment"]) cls._test_value_recorder = cls._meter.create_metric( "testname", "testdesc", "unit", int, ValueRecorder, ["environment"]) cls._test_obs = cls._meter.register_observer( lambda x: x, "testname", "testdesc", "unit", int, ValueObserver, ["environment"], ) cls._test_labels = tuple({"environment": "staging"}.items())
""" This example shows how the Observer metric instrument can be used to capture asynchronous metrics data. """ import psutil from opentelemetry import metrics from opentelemetry.sdk.metrics import LabelSet, MeterProvider from opentelemetry.sdk.metrics.export import ConsoleMetricsExporter from opentelemetry.sdk.metrics.export.batcher import UngroupedBatcher from opentelemetry.sdk.metrics.export.controller import PushController # Configure a stateful batcher batcher = UngroupedBatcher(stateful=True) metrics.set_preferred_meter_provider_implementation(lambda _: MeterProvider()) meter = metrics.get_meter(__name__) # Exporter to export metrics to the console exporter = ConsoleMetricsExporter() # Configure a push controller controller = PushController(meter=meter, exporter=exporter, interval=2) # Callback to gather cpu usage def get_cpu_usage_callback(observer): for (number, percent) in enumerate(psutil.cpu_percent(percpu=True)): label_set = meter.get_label_set({"cpu_number": str(number)}) observer.observe(percent, label_set)
def setUpClass(cls): # pylint: disable=protected-access metrics.set_meter_provider(MeterProvider()) cls._meter = metrics.get_meter(__name__) kvp = {"environment": "staging"} cls._test_label_set = cls._meter.get_label_set(kvp)
trace.set_tracer_provider(TracerProvider(resource=resource)) tracer = trace.get_tracer(__name__) OTEL_AGENT = os.getenv('OTEL_AGENT', "otel-agent") otlp_exporter = OTLPSpanExporter(endpoint=OTEL_AGENT + ":4317", insecure=True) span_processor = BatchExportSpanProcessor(otlp_exporter) trace.get_tracer_provider().add_span_processor(span_processor) metric_exporter = OpenCensusMetricsExporter( endpoint=OTEL_AGENT + ":55678", service_name="service1", ) # Meter is responsible for creating and recording metrics metrics.set_meter_provider(MeterProvider(resource=resource)) meter = metrics.get_meter(__name__) # controller collects metrics created from meter and exports it via the # exporter every interval controller = PushController(meter, metric_exporter, 5) requests_counter = meter.create_counter( name="requests_count", description="number of requests", unit="1", value_type=int, ) # Labels are used to identify key-values that are associated with a specific # metric that you want to record. These are useful for pre-aggregation and can # be used to store custom dimensions pertaining to a metric labels = {"service_id": "service1"}
# Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. # pylint: disable=import-error # pylint: disable=no-member # pylint: disable=no-name-in-module import time import requests from opentelemetry import metrics from opentelemetry.instrumentation.requests import RequestsInstrumentor from opentelemetry.sdk.metrics import MeterProvider from azure_monitor import AzureMonitorMetricsExporter # Use the default sdk implementation metrics.set_meter_provider(MeterProvider(stateful=False)) # Track telemetry from the requests library RequestsInstrumentor().instrument() meter = RequestsInstrumentor().meter exporter = AzureMonitorMetricsExporter( connection_string="InstrumentationKey=<INSTRUMENTATION KEY HERE>") # Export standard metrics from requests library to Azure Monitor metrics.get_meter_provider().start_pipeline(meter, exporter, 5) for x in range(10): for y in range(10): requests.get("http://example.com") time.sleep(2) time.sleep(5)
def enable_metrics() -> None: from opentelemetry.metrics import set_meter_provider from opentelemetry.sdk.metrics import MeterProvider set_meter_provider(MeterProvider())
def setUpClass(cls): # pylint: disable=protected-access metrics.set_meter_provider(MeterProvider()) cls._meter = metrics.get_meter(__name__) cls._labels = {"environment": "staging"} cls._key_labels = get_labels_as_key(cls._labels)
def setUpClass(cls): metrics.set_meter_provider(MeterProvider()) cls._meter = metrics.get_meter(__name__) cls._test_labels = tuple({"environment": "staging"}.items())
# limitations under the License. # """ This example shows how to export metrics to the OT collector. """ from opentelemetry import metrics from opentelemetry.ext.otcollector.metrics_exporter import ( CollectorMetricsExporter, ) from opentelemetry.sdk.metrics import Counter, MeterProvider from opentelemetry.sdk.metrics.export.controller import PushController exporter = CollectorMetricsExporter(service_name="basic-service", endpoint="localhost:55678") metrics.set_meter_provider(MeterProvider()) meter = metrics.get_meter(__name__) controller = PushController(meter, exporter, 5) requests_counter = meter.create_metric( name="requests", description="number of requests", unit="1", value_type=int, metric_type=Counter, label_keys=("environment", ), ) staging_label_set = meter.get_label_set({"environment": "staging"}) requests_counter.add(25, staging_label_set)
def setUpClass(cls): metrics.set_meter_provider(MeterProvider()) cls._meter = metrics.get_meter(__name__) cls._test_labels = {"environment": "staging"} cls._span_processor = AzureMetricsSpanProcessor()