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()
