.. role:: raw-html-m2r(raw)
   :format: html


Microsoft OpenTelemetry exporter for Azure Monitor
==================================================


.. image:: https://img.shields.io/gitter/room/Microsoft/azure-monitor-python
   :target: https://gitter.im/Azure/azure-sdk-for-python
   :alt: Gitter chat


The exporter for Azure Monitor allows you to export data utilizing the OpenTelemetry SDK and send telemetry data to Azure Monitor for applications written in Python.

`Source code <https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/monitor/azure-monitor-opentelemetry-exporter>`_ | `Package (PyPi) <https://pypi.org/project/azure-monitor-opentelemetry-exporter/>`_ | `API reference documentation <https://azuresdkdocs.blob.core.windows.net/$web/python/azure-opentelemetry-exporter-azuremonitor/1.0.0b2/index.html>`_ | `Product documentation <https://docs.microsoft.com/azure/azure-monitor/overview>`_ | `Samples <https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/monitor/azure-monitor-opentelemetry-exporter/samples>`_ | `Changelog <https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/monitor/azure-monitor-opentelemetry-exporter/CHANGELOG.md>`_

Getting started
---------------

Install the package
^^^^^^^^^^^^^^^^^^^

Install the Microsoft OpenTelemetry exporter for Azure Monitor with `pip <https://pypi.org/project/pip/>`_\ :

.. code-block:: Bash

   pip install azure-monitor-opentelemetry-exporter --pre

Prerequisites
^^^^^^^^^^^^^

To use this package, you must have:


* Azure subscription - `Create a free account <https://azure.microsoft.com/free/>`_
* Azure Monitor - `How to use application insights <https://docs.microsoft.com/azure/azure-monitor/app/app-insights-overview#how-do-i-use-application-insights>`_
* OpenTelemetry SDK - `OpenTelemetry SDK for Python <https://github.com/open-telemetry/opentelemetry-python>`_
* Python 3.6 or later - `Install Python <https://www.python.org/downloads/>`_

Instantiate the client
^^^^^^^^^^^^^^^^^^^^^^

Interaction with Azure monitor exporter starts with an instance of the ``AzureMonitorTraceExporter`` class for distributed tracing, ``AzureMonitorLogExporter`` for logging and ``AzureMonitorMetricExporter`` for metrics. You will need a **connection_string** to instantiate the object.
Please find the samples linked below for demonstration as to how to construct the exporter using a connection string.

Logging (experimental)
~~~~~~~~~~~~~~~~~~~~~~

NOTE: The logging signal for the ``AzureMonitorLogExporter`` is currently in an EXPERIMENTAL state. Possible breaking changes may ensue in the future.

.. code-block:: Python

   from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter
   exporter = AzureMonitorLogExporter(
       connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
   )

Metrics
~~~~~~~

.. code-block:: Python

   from azure.monitor.opentelemetry.exporter import AzureMonitorMetricExporter
   exporter = AzureMonitorMetricExporter(
       connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
   )

Tracing
~~~~~~~

.. code-block:: Python

   from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter
   exporter = AzureMonitorTraceExporter(
       connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
   )

You can also instantiate the exporter directly via the constructor. In this case, the connection string will be automatically populated from the ``APPLICATIONINSIGHTS_CONNECTION_STRING`` environment variable.

.. code-block:: python

   from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter
   exporter = AzureMonitorLogExporter()

.. code-block:: python

   from azure.monitor.opentelemetry.exporter import AzureMonitorMetricExporter
   exporter = AzureMonitorMetricExporter()

.. code-block:: python

   from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter
   exporter = AzureMonitorTraceExporter()

Key concepts
------------

Some of the key concepts for the Azure monitor exporter include:


* 
  `OpenTelemetry <https://opentelemetry.io/>`_\ : OpenTelemetry is a set of libraries used to collect and export telemetry data (metrics, logs, and traces) for analysis in order to understand your software's performance and behavior.

* 
  `Instrumentation <https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/overview.md#instrumentation-libraries>`_\ : The ability to call the OpenTelemetry API directly by any application is facilitated by instrumentation. A library that enables OpenTelemetry observability for another library is called an instrumentation Library.

* 
  `Log <https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/overview.md#log-signal>`_\ : Log refers to capturing of logging, exception and events.

* 
  `LogRecord <https://opentelemetry-python.readthedocs.io/en/stable/sdk/logs.html#opentelemetry.sdk._logs.LogRecord>`_\ : Represents a log record emitted from a supported logging library.

* 
  `LogEmitter <https://opentelemetry-python.readthedocs.io/en/stable/sdk/logs.html#opentelemetry.sdk._logs.LogEmitter>`_\ : Converts a ``LogRecord`` into a readable ``LogData``\ , and will be pushed through the SDK to be exported.

* 
  `LogEmitter Provider <https://opentelemetry-python.readthedocs.io/en/stable/sdk/logs.html#opentelemetry.sdk._logs.LogEmitterProvider>`_\ : Provides a ``LogEmitter`` for the given instrumentation library.

* 
  `LogProcessor <https://opentelemetry-python.readthedocs.io/en/stable/sdk/logs.html#opentelemetry.sdk._logs.LogProcessor>`_\ : Interface to hook the log record emitting action.

* 
  `LoggingHandler <https://opentelemetry-python.readthedocs.io/en/stable/sdk/logs.html#opentelemetry.sdk._logs.LoggingHandler>`_\ : A handler class which writes logging records in OpenTelemetry format from the standard Python ``logging`` library.

* 
  `AzureMonitorLogExporter <https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/monitor/azure-monitor-opentelemetry-exporter/azure/monitor/opentelemetry/exporter/export/logs/_exporter.py>`_\ : This is the class that is initialized to send logging related telemetry to Azure Monitor.

* 
  `Metric <https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/overview.md#metric-signal>`_\ : ``Metric`` refers to recording raw measurements with predefined aggregation and sets of attributes for a period in time.

* 
  `Measurement <https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#measurement>`_\ : Represents a data point recorded at a point in time.

* 
  `Instrument <https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#instrument>`_\ : Instruments are used to report ``Measurement``\ s.

* 
  `Meter <https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#meter>`_\ : The ``Meter`` is responsible for creating ``Instruments``.

* 
  `Meter Provider <https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#meterprovider>`_\ : Provides a ``Meter`` for the given instrumentation library.

* 
  `Metric Reader <https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk.md#metricreader>`_\ : An SDK implementation object that provides the common configurable aspects of the OpenTelemetry Metrics SDK such as collection, flushing and shutdown.

* 
  `AzureMonitorMetricExporter <https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/monitor/azure-monitor-opentelemetry-exporter/azure/monitor/opentelemetry/exporter/export/metrics/_exporter.py>`_\ : This is the class that is initialized to send metric related telemetry to Azure Monitor.

* 
  `Trace <https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/overview.md#tracing-signal>`_\ : Trace refers to distributed tracing. A distributed trace is a set of events, triggered as a result of a single logical operation, consolidated across various components of an application. In particular, a Trace can be thought of as a directed acyclic graph (DAG) of Spans, where the edges between Spans are defined as parent/child relationship.

* 
  `Span <https://opentelemetry-python.readthedocs.io/en/stable/api/trace.html?highlight=TracerProvider#opentelemetry.trace.Span>`_\ : Represents a single operation within a ``Trace``. Can be nested to form a trace tree. Each trace contains a root span, which typically describes the entire operation and, optionally, one ore more sub-spans for its sub-operations.

* 
  `Tracer <https://opentelemetry-python.readthedocs.io/en/stable/api/trace.html?highlight=TracerProvider#opentelemetry.trace.Tracer>`_\ : Responsible for creating ``Span``\ s.

* 
  `Tracer Provider <https://opentelemetry-python.readthedocs.io/en/stable/api/trace.html?highlight=TracerProvider#opentelemetry.trace.TracerProvider>`_\ : Provides a ``Tracer`` for use by the given instrumentation library.

* 
  `Span Processor <https://opentelemetry-python.readthedocs.io/en/stable/_modules/opentelemetry/sdk/trace.html?highlight=SpanProcessor#>`_\ : A span processor allows hooks for SDK's ``Span`` start and end method invocations. Follow the link for more information.

* 
  `AzureMonitorTraceExporter <https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/monitor/azure-monitor-opentelemetry-exporter/azure/monitor/opentelemetry/exporter/export/trace/_exporter.py>`_\ : This is the class that is initialized to send tracing related telemetry to Azure Monitor.

* 
  `Sampling <https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/trace/sdk.md#sampling>`_\ : Sampling is a mechanism to control the noise and overhead introduced by OpenTelemetry by reducing the number of samples of traces collected and sent to the backend.

* 
  ApplicationInsightsSampler: Application Insights specific sampler used for consistent sampling across Application Insights SDKs and OpenTelemetry-based SDKs sending data to Application Insights. This sampler MUST be used whenever ``AzureMonitorTraceExporter`` is used.

For more information about these resources, see `What is Azure Monitor? <https://docs.microsoft.com/azure/azure-monitor/overview>`_.

Examples
--------

Logging (experimental)
^^^^^^^^^^^^^^^^^^^^^^

NOTE: The logging signal for the ``AzureMonitorLogExporter`` is currently in an EXPERIMENTAL state. Possible breaking changes may ensue in the future.

The following sections provide several code snippets covering some of the most common tasks, including:


* `Exporting a log record <#export-hello-world-log>`_
* `Exporting correlated log record <#export-correlated-log>`_
* `Exporting log record with custom properties <#export-custom-properties-log>`_
* `Exporting an exceptions log record <#export-exceptions-log>`_

Export Hello World Log
~~~~~~~~~~~~~~~~~~~~~~

.. code-block:: Python

   import os
   import logging

   from opentelemetry.sdk._logs import (
       LogEmitterProvider,
       LoggingHandler,
       set_log_emitter_provider,
   )
   from opentelemetry.sdk._logs.export import BatchLogProcessor

   from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter

   log_emitter_provider = LogEmitterProvider()
   set_log_emitter_provider(log_emitter_provider)

   exporter = AzureMonitorLogExporter(
       connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
   )

   log_emitter_provider.add_log_processor(BatchLogProcessor(exporter))
   handler = LoggingHandler()

   # Attach LoggingHandler to root logger
   logging.getLogger().addHandler(handler)
   logging.getLogger().setLevel(logging.NOTSET)

   logger = logging.getLogger(__name__)

   logger.warning("Hello World!")

Export Correlated Log
~~~~~~~~~~~~~~~~~~~~~

.. code-block:: Python

   import os
   import logging

   from opentelemetry import trace
   from opentelemetry.sdk._logs import (
       LogEmitterProvider,
       LoggingHandler,
       set_log_emitter_provider,
   )
   from opentelemetry.sdk._logs.export import BatchLogProcessor
   from opentelemetry.sdk.trace import TracerProvider

   from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter

   trace.set_tracer_provider(TracerProvider())
   tracer = trace.get_tracer(__name__)
   log_emitter_provider = LogEmitterProvider()
   set_log_emitter_provider(log_emitter_provider)

   exporter = AzureMonitorLogExporter(
       connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
   )

   log_emitter_provider.add_log_processor(BatchLogProcessor(exporter))
   handler = LoggingHandler()

   # Attach LoggingHandler to root logger
   logging.getLogger().addHandler(handler)
   logging.getLogger().setLevel(logging.NOTSET)

   logger = logging.getLogger(__name__)

   logger.info("INFO: Outside of span")
   with tracer.start_as_current_span("foo"):
       logger.warning("WARNING: Inside of span")
   logger.error("ERROR: After span")

Export Custom Properties Log
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

.. code-block:: Python

   import os
   import logging

   from opentelemetry.sdk._logs import (
       LogEmitterProvider,
       LoggingHandler,
       set_log_emitter_provider,
   )
   from opentelemetry.sdk._logs.export import BatchLogProcessor

   from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter

   log_emitter_provider = LogEmitterProvider()
   set_log_emitter_provider(log_emitter_provider)

   exporter = AzureMonitorLogExporter(
       connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
   )

   log_emitter_provider.add_log_processor(BatchLogProcessor(exporter))
   handler = LoggingHandler()

   # Attach LoggingHandler to root logger
   logging.getLogger().addHandler(handler)
   logging.getLogger().setLevel(logging.NOTSET)

   logger = logging.getLogger(__name__)

   # Custom properties
   logger.debug("DEBUG: Debug with properties", extra={"debug": "true"})

Export Exceptions Log
~~~~~~~~~~~~~~~~~~~~~

.. code-block:: Python

   # Copyright (c) Microsoft Corporation. All rights reserved.
   # Licensed under the MIT License.
   """
   An example showing how to export exception telemetry using the AzureMonitorLogExporter.
   """
   import os
   import logging

   from opentelemetry.sdk._logs import (
       LogEmitterProvider,
       LoggingHandler,
       get_log_emitter_provider,
       set_log_emitter_provider,
   )
   from opentelemetry.sdk._logs.export import BatchLogProcessor

   from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter

   set_log_emitter_provider(LogEmitterProvider())
   exporter = AzureMonitorLogExporter(
       connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
   )
   get_log_emitter_provider().add_log_processor(BatchLogProcessor(exporter))

   # Attach LoggingHandler to namespaced logger
   handler = LoggingHandler()
   logger = logging.getLogger(__name__)
   logger.addHandler(handler)
   logger.setLevel(logging.NOTSET)

   # The following code will generate two pieces of exception telemetry
   # that are identical in nature
   try:
       val = 1 / 0
       print(val)
   except ZeroDivisionError:
       logger.exception("Error: Division by zero")

   try:
       val = 1 / 0
       print(val)
   except ZeroDivisionError:
       logger.error("Error: Division by zero", stack_info=True, exc_info=True)

Metrics
^^^^^^^

The following sections provide several code snippets covering some of the most common tasks, including:


* `Using different metric instruments <#metric-instrument-usage>`_
* `Customizing outputted metrics with views <#metric-custom-views>`_
* `Recording instruments with attributes <#metric-record-attributes>`_

Metric instrument usage
~~~~~~~~~~~~~~~~~~~~~~~

.. code-block:: python

   # Copyright (c) Microsoft Corporation. All rights reserved.
   # Licensed under the MIT License.
   """
   An example to show an application using all instruments in the OpenTelemetry SDK. Metrics created
   and recorded using the sdk are tracked and telemetry is exported to application insights with the
   AzureMonitorMetricsExporter.
   """
   import os
   from typing import Iterable

   from opentelemetry import metrics
   from opentelemetry.metrics import CallbackOptions, Observation
   from opentelemetry.sdk.metrics import MeterProvider
   from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader

   from azure.monitor.opentelemetry.exporter import AzureMonitorMetricExporter

   exporter = AzureMonitorMetricExporter(
       connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
   )
   reader = PeriodicExportingMetricReader(exporter, export_interval_millis=5000)
   metrics.set_meter_provider(MeterProvider(metric_readers=[reader]))

   # Create a namespaced meter
   meter = metrics.get_meter_provider().get_meter("sample")

   # Callback functions for observable instruments
   def observable_counter_func(options: CallbackOptions) -> Iterable[Observation]:
       yield Observation(1, {})


   def observable_up_down_counter_func(
       options: CallbackOptions,
   ) -> Iterable[Observation]:
       yield Observation(-10, {})


   def observable_gauge_func(options: CallbackOptions) -> Iterable[Observation]:
       yield Observation(9, {})

   # Counter
   counter = meter.create_counter("counter")
   counter.add(1)

   # Async Counter
   observable_counter = meter.create_observable_counter(
       "observable_counter", [observable_counter_func]
   )

   # UpDownCounter
   up_down_counter = meter.create_up_down_counter("up_down_counter")
   up_down_counter.add(1)
   up_down_counter.add(-5)

   # Async UpDownCounter
   observable_up_down_counter = meter.create_observable_up_down_counter(
       "observable_up_down_counter", [observable_up_down_counter_func]
   )

   # Histogram
   histogram = meter.create_histogram("histogram")
   histogram.record(99.9)

   # Async Gauge
   gauge = meter.create_observable_gauge("gauge", [observable_gauge_func])

Metric custom views
~~~~~~~~~~~~~~~~~~~

.. code-block:: python

   import os

   from opentelemetry import metrics
   from opentelemetry.sdk.metrics import Counter, MeterProvider
   from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
   from opentelemetry.sdk.metrics.view import View

   from azure.monitor.opentelemetry.exporter import AzureMonitorMetricExporter

   exporter = AzureMonitorMetricExporter.from_connection_string(
       os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
   )
   # Create a view matching the counter instrument `my.counter`
   # and configure the new name `my.counter.total` for the result metrics stream
   change_metric_name_view = View(
       instrument_type=Counter,
       instrument_name="my.counter",
       name="my.counter.total",
   )

   reader = PeriodicExportingMetricReader(exporter, export_interval_millis=5000)
   provider = MeterProvider(
       metric_readers=[
           reader,
       ],
       views=[
           change_metric_name_view,
       ],
   )
   metrics.set_meter_provider(provider)

   meter = metrics.get_meter_provider().get_meter("view-name-change")
   my_counter = meter.create_counter("my.counter")
   my_counter.add(100)

Metric record attributes
~~~~~~~~~~~~~~~~~~~~~~~~

.. code-block:: python

   import os

   from opentelemetry import metrics
   from opentelemetry.sdk.metrics import MeterProvider
   from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader

   from azure.monitor.opentelemetry.exporter import AzureMonitorMetricExporter

   exporter = AzureMonitorMetricExporter.from_connection_string(
       os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
   )
   reader = PeriodicExportingMetricReader(exporter, export_interval_millis=5000)
   metrics.set_meter_provider(MeterProvider(metric_readers=[reader]))

   attribute_set1 = {
       "key1": "val1"
   }
   attribute_set2 = {
       "key2": "val2"
   }
   large_attribute_set = {}
   for i in range(20):
       key = "key{}".format(i)
       val = "val{}".format(i)
       large_attribute_set[key] = val

   meter = metrics.get_meter_provider().get_meter("sample")

   # Counter
   counter = meter.create_counter("attr1_counter")
   counter.add(1, attribute_set1)

   # Counter2
   counter2 = meter.create_counter("attr2_counter")
   counter2.add(10, attribute_set1)
   counter2.add(30, attribute_set2)

   # Counter3
   counter3 = meter.create_counter("large_attr_counter")
   counter3.add(100, attribute_set1)
   counter3.add(200, large_attribute_set)

Tracing
^^^^^^^

The following sections provide several code snippets covering some of the most common tasks, including:


* `Exporting a custom span <#export-hello-world-trace>`_
* `Using an instrumentation to track a library <#instrumentation-with-requests-library>`_
* `Enabling sampling to limit the amount of telemetry sent <#enabling-sampling>`_

Export Hello World Trace
~~~~~~~~~~~~~~~~~~~~~~~~

.. code-block:: Python

   import os
   from opentelemetry import trace
   from opentelemetry.sdk.trace import TracerProvider
   from opentelemetry.sdk.trace.export import BatchSpanProcessor
   from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter

   trace.set_tracer_provider(TracerProvider())
   tracer = trace.get_tracer(__name__)
   # This is the exporter that sends data to Application Insights
   exporter = AzureMonitorTraceExporter(
       connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
   )
   span_processor = BatchSpanProcessor(exporter)
   trace.get_tracer_provider().add_span_processor(span_processor)

   with tracer.start_as_current_span("hello"):
       print("Hello, World!")

Instrumentation with requests library
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

OpenTelemetry also supports several instrumentations which allows to instrument with third party libraries.

This example shows how to instrument with the `requests <https://pypi.org/project/requests/>`_ library.


* Install the requests integration package using pip install opentelemetry-instrumentation-requests.

.. code-block:: Python

   import os
   import requests
   from opentelemetry import trace
   from opentelemetry.instrumentation.requests import RequestsInstrumentor
   from opentelemetry.sdk.trace import TracerProvider
   from opentelemetry.sdk.trace.export import BatchSpanProcessor
   from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter

   # This line causes your calls made with the requests library to be tracked.
   RequestsInstrumentor().instrument()

   trace.set_tracer_provider(TracerProvider())
   tracer = trace.get_tracer(__name__)
   exporter = AzureMonitorTraceExporter(
       connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
   )
   span_processor = BatchSpanProcessor(exporter)
   trace.get_tracer_provider().add_span_processor(span_processor)

   # This request will be traced
   response = requests.get(url="https://azure.microsoft.com/")

Enabling sampling
~~~~~~~~~~~~~~~~~

.. code-block:: Python

   import os
   from opentelemetry import trace
   from opentelemetry.sdk.trace import TracerProvider
   from opentelemetry.sdk.trace.export import BatchSpanProcessor
   from azure.monitor.opentelemetry.exporter import (
       ApplicationInsightsSampler,
       AzureMonitorTraceExporter,
   )

   # Sampler expects a sample rate of between 0 and 1 inclusive
   # A rate of 0.75 means approximately 75% of your telemetry will be sent
   sampler = ApplicationInsightsSampler(0.75)
   trace.set_tracer_provider(TracerProvider(sampler=sampler))
   tracer = trace.get_tracer(__name__)
   exporter = AzureMonitorTraceExporter(
       connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
   )
   span_processor = BatchSpanProcessor(exporter)
   trace.get_tracer_provider().add_span_processor(span_processor)

   for i in range(100):
       # Approximately 25% of these spans should be sampled out
       with tracer.start_as_current_span("hello"):
           print("Hello, World!")

Troubleshooting
---------------

The exporter raises exceptions defined in `Azure Core <https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/core/azure-core/README.md#azure-core-library-exceptions>`_.

Next steps
----------

More sample code
^^^^^^^^^^^^^^^^

Please find further examples in the `samples <https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/monitor/azure-monitor-opentelemetry-exporter/samples>`_ directory demonstrating common scenarios.

Additional documentation
^^^^^^^^^^^^^^^^^^^^^^^^

For more extensive documentation on the Azure Monitor service, see the `Azure Monitor documentation <https://docs.microsoft.com/azure/azure-monitor/overview>`_ on docs.microsoft.com.

For detailed overview of OpenTelemetry, visit their `overview <https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/overview.md>`_ page.

Contributing
------------

This project welcomes contributions and suggestions.  Most contributions require you to agree to a
Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
the rights to use your contribution. For details, visit https://cla.microsoft.com.

When you submit a pull request, a CLA-bot will automatically determine whether you need to provide
a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions
provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the `Microsoft Open Source Code of Conduct <https://opensource.microsoft.com/codeofconduct/>`_.
For more information see the `Code of Conduct FAQ <https://opensource.microsoft.com/codeofconduct/faq/>`_ or
contact `opencode@microsoft.com <mailto:opencode@microsoft.com>`_ with any additional questions or comments.

:raw-html-m2r:`<!-- LINKS -->`


Indices and tables
------------------

* :ref:`genindex`
* :ref:`modindex`
* :ref:`search`

.. toctree::
  :maxdepth: 5
  :glob:
  :caption: Developer Documentation

  azure.monitor.opentelemetry.exporter.rst