Microsoft OpenTelemetry-exporteur voor Azure Monitor

Met de export voor Azure Monitor kunt u gegevens exporteren met behulp van de OpenTelemetry SDK en telemetriegegevens verzenden naar Azure Monitor voor toepassingen die zijn geschreven in Python.

Broncode | Pakket (PyPi) | API-referentiedocumentatie | Productdocumentatie | Monsters | Changelog

Aan de slag

Het pakket installeren

Installeer de Microsoft OpenTelemetry-exporteur voor Azure Monitor met pip:

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

Vereisten

Als u dit pakket wilt gebruiken, hebt u het volgende nodig:

• Azure-abonnement: maak een gratis account
• Azure Monitor - Application Insights gebruiken
• OpenTelemetry SDK - OpenTelemetry SDK voor Python
• Python 3.7 of hoger - Python installeren

Een instantie maken voor de client

Interactie met Azure Monitor-exporteur begint met een exemplaar van de AzureMonitorTraceExporter klasse voor gedistribueerde tracering, AzureMonitorLogExporter voor logboekregistratie en AzureMonitorMetricExporter voor metrische gegevens. U hebt een connection_string nodig om het object te instantiëren. Hieronder vindt u de voorbeelden die zijn gekoppeld om te laten zien hoe de exporteur moet worden gebouwd met behulp van een verbindingsreeks.

Logboekregistratie (experimenteel)

OPMERKING: Het logboekregistratiesignaal voor de AzureMonitorLogExporter heeft momenteel de status EXPERIMENTEEL. Mogelijke wijzigingen die fouten veroorzaken, kunnen in de toekomst optreden.

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

Metrische gegevens

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

Tracering

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

U kunt de exportexporteur ook rechtstreeks instantiëren via de constructor. In dit geval wordt de verbindingsreeks automatisch ingevuld vanuit de APPLICATIONINSIGHTS_CONNECTION_STRING omgevingsvariabele.

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

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

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

Belangrijkste concepten

Enkele van de belangrijkste concepten voor de Azure Monitor-exporteur zijn:

• OpenTelemetry: OpenTelemetry is een set bibliotheken die wordt gebruikt voor het verzamelen en exporteren van telemetriegegevens (metrische gegevens, logboeken en traceringen) voor analyse om inzicht te krijgen in de prestaties en het gedrag van uw software.

• Instrumentatie: de mogelijkheid om de OpenTelemetry-API rechtstreeks door een toepassing aan te roepen, wordt mogelijk gemaakt door instrumentatie. Een bibliotheek die de waarneembaarheid van OpenTelemetry voor een andere bibliotheek mogelijk maakt, wordt een instrumentatiebibliotheek genoemd.

• Logboek: Logboek verwijst naar het vastleggen van logboekregistratie, uitzonderingen en gebeurtenissen.

• LogRecord: Vertegenwoordigt een logboekrecord die is verzonden vanuit een ondersteunde logboekbibliotheek.

• Logboekregistratie: converteert een LogRecord naar een leesbare LogData, en wordt via de SDK gepusht om te worden geëxporteerd.

• Loggerprovider: biedt een Logger voor de opgegeven instrumentatiebibliotheek.

• LogRecordProcessor: Interface voor het koppelen van de logboekrecord die actie verzendt.

• LoggingHandler: een handlerklasse die logboekregistratierecords in OpenTelemetry-indeling schrijft vanuit de standaard Python-bibliotheek logging .

• AzureMonitorLogExporter: dit is de klasse die is geïnitialiseerd voor het verzenden van telemetriegegevens met betrekking tot logboekregistratie naar Azure Monitor.

• Metrische waarde: Metric verwijst naar het vastleggen van onbewerkte metingen met vooraf gedefinieerde aggregatie en sets kenmerken gedurende een bepaalde periode.

• Meting: Vertegenwoordigt een gegevenspunt dat is vastgelegd op een bepaald tijdstip.

• Instrument: Instrumenten worden gebruikt om s te rapporteren Measurement.

• Meter: de Meter is verantwoordelijk voor het maken van Instruments.

• Meterprovider: biedt een Meter voor de opgegeven instrumentatiebibliotheek.

• Metrische lezer: een SDK-implementatieobject dat de algemene configureerbare aspecten van de OpenTelemetry Metrics SDK biedt, zoals verzameling, leegmaken en afsluiten.

• AzureMonitorMetricExporter: dit is de klasse die is geïnitialiseerd voor het verzenden van telemetriegegevens naar Azure Monitor.

• Traceren: Traceren verwijst naar gedistribueerde tracering. Een gedistribueerde tracering is een reeks gebeurtenissen, geactiveerd als gevolg van één logische bewerking, geconsolideerd over verschillende onderdelen van een toepassing. Een tracering kan met name worden beschouwd als een gerichte acyclische grafiek (DAG) van Spans, waarbij de randen tussen Spans worden gedefinieerd als een bovenliggende/onderliggende relatie.

• Span: Vertegenwoordigt één bewerking binnen een Trace. Kan worden genest om een traceringsstructuur te vormen. Elke tracering bevat een hoofdbereik, dat doorgaans de hele bewerking beschrijft en, optioneel, een of meer subbereiken voor de subbewerkingen.

• Tracer: verantwoordelijk voor het maken van Spans.

• Tracerprovider: biedt een Tracer voor gebruik door de opgegeven instrumentatiebibliotheek.

• Span Processor: met een spanprocessor kunt u hooks gebruiken voor de aanroepen van Span de begin- en eindmethode van de SDK. Volg de koppeling voor meer informatie.

• AzureMonitorTraceExporter: dit is de klasse die is geïnitialiseerd voor het verzenden van traceringsgerelateerde telemetrie naar Azure Monitor.

• Steekproeven: Steekproeven zijn een mechanisme voor het beheren van de ruis en overhead die door OpenTelemetry worden geïntroduceerd door het aantal steekproeven van traceringen te verminderen dat wordt verzameld en verzonden naar de back-end.

• ApplicationInsightsSampler: Application Insights-specifieke sampler die wordt gebruikt voor consistente steekproeven in Application Insights-SDK's en Op OpenTelemetry gebaseerde SDK's die gegevens verzenden naar Application Insights. Deze sampler MOET worden gebruikt wanneer AzureMonitorTraceExporter wordt gebruikt.

Zie Wat is Azure Monitor? voor meer informatie over deze resources.

Configuratie

Alle configuratieopties kunnen worden doorgegeven via de constructors van exporteurs via kwargs. Hieronder vindt u een lijst met configureerbare opties.

• connection_string: De verbindingsreeks gebruikt voor uw Application Insights-resource.
• disable_offline_storage: Booleaanse waarde om te bepalen of het opslaan van mislukte telemetrierecords voor nieuwe pogingen moet worden uitgeschakeld. De standaardwaarde is False.
• storage_directory: Opslagmap waarin bestanden voor nieuwe pogingen moeten worden opgeslagen. De standaardwaarde is <tempfile.gettempdir()>/Microsoft/AzureMonitor/opentelemetry-python-<your-instrumentation-key>.
• credential: Tokenreferentie, zoals ManagedIdentityCredential of ClientSecretCredential, gebruikt voor AAD-verificatie (Azure Active Directory). De standaardwaarde is Geen. Zie voorbeelden voor voorbeelden.

Voorbeelden

Logboekregistratie (experimenteel)

OPMERKING: Het logboekregistratiesignaal voor de AzureMonitorLogExporter heeft momenteel de status EXPERIMENTEEL. Mogelijke wijzigingen die fouten veroorzaken, kunnen in de toekomst optreden.

De volgende secties bevatten verschillende codefragmenten voor enkele van de meest voorkomende taken, waaronder:

• Een logboekrecord exporteren
• Gecorreleerde logboekrecord exporteren
• Logboekrecord exporteren met aangepaste eigenschappen
• Een uitzonderingslogboekrecord exporteren

Raadpleeg de OpenTelemetry Logging SDK voor meer informatie over het gebruik van OpenTelemetry-onderdelen om logboeken te verzamelen.

Hallo wereld logboek exporteren

"""
An example to show an application using Opentelemetry logging sdk. Logging calls to the standard Python
logging library are tracked and telemetry is exported to application insights with the AzureMonitorLogExporter.
"""
import os
import logging

from opentelemetry.sdk._logs import (
    LoggerProvider,
    LoggingHandler,
    set_logger_provider,
)
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor

from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter

logger_provider = LoggerProvider()
set_logger_provider(logger_provider)

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

logger_provider.add_log_record_processor(BatchLogRecordProcessor(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!")

# Telemetry records are flushed automatically upon application exit
# If you would like to flush records manually yourself, you can call force_flush()
logger_provider.force_flush()

Gecorreleerd logboek exporteren

"""
An example showing how to include context correlation information in logging telemetry.
"""
import os
import logging

from opentelemetry import trace
from opentelemetry.sdk._logs import (
    LoggerProvider,
    LoggingHandler,
    set_logger_provider,
)
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.sdk.trace import TracerProvider

from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter

trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)
logger_provider = LoggerProvider()
set_logger_provider(logger_provider)

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

logger_provider.add_log_record_processor(BatchLogRecordProcessor(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")

Logboek met aangepaste eigenschappen exporteren

"""
An example showing how to add custom properties to logging telemetry.
"""
import os
import logging

from opentelemetry.sdk._logs import (
    LoggerProvider,
    LoggingHandler,
    set_logger_provider,
)
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor

from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter

logger_provider = LoggerProvider()
set_logger_provider(logger_provider)

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

logger_provider.add_log_record_processor(BatchLogRecordProcessor(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"})

Uitzonderingenlogboek exporteren

"""
An example showing how to export exception telemetry using the AzureMonitorLogExporter.
"""
import os
import logging

from opentelemetry._logs import (
    get_logger_provider,
    set_logger_provider,
)
from opentelemetry.sdk._logs import (
    LoggerProvider,
    LoggingHandler,
)
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor

from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter

set_logger_provider(LoggerProvider())
exporter = AzureMonitorLogExporter(
    connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
get_logger_provider().add_log_record_processor(BatchLogRecordProcessor(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)

Metrische gegevens

De volgende secties bevatten verschillende codefragmenten voor enkele van de meest voorkomende taken, waaronder:

• Verschillende metrische instrumenten gebruiken
• Metrische uitvoer aanpassen met weergaven
• Opnameinstrumenten met kenmerken

Raadpleeg de OpenTelemetry Metrics SDK voor meer informatie over het gebruik van OpenTelemetry-onderdelen om metrische gegevens te verzamelen.

Gebruik van metrische instrumenten

"""
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])

# Upon application exit, one last collection is made and telemetry records are
# flushed automatically. # If you would like to flush records manually yourself,
# you can call force_flush()
meter_provider.force_flush()

Aangepaste weergaven voor metrische gegevens

"""
This example shows how to customize the metrics that are output by the SDK using Views. Metrics created
and recorded using the sdk are tracked and telemetry is exported to application insights with the
AzureMonitorMetricsExporter.
"""
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)

Meer voorbeelden met de SDK voor metrische gegevens Views vindt u hier.

Kenmerken van metrische records

"""
An example to show an application using different attributes with 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 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)

Tracering

De volgende secties bevatten verschillende codefragmenten voor enkele van de meest voorkomende taken, waaronder:

• Een aangepast bereik exporteren
• Een bibliotheek bijhouden met behulp van een instrumentatie
• Steekproeven inschakelen om de hoeveelheid verzonden telemetrie te beperken

Raadpleeg de OpenTelemetry Tracing SDK voor meer informatie over het gebruik van OpenTelemetry-onderdelen om logboeken te verzamelen.

Hallo wereld-trace exporteren

"""
An example to show an application using Opentelemetry tracing api and sdk. Custom dependencies are
tracked via spans and telemetry is exported to application insights with the AzureMonitorTraceExporter.
"""
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

tracer_provider = TracerProvider()
trace.set_tracer_provider(tracer_provider)
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!")

# Telemetry records are flushed automatically upon application exit
# If you would like to flush records manually yourself, you can call force_flush()
tracer_provider.force_flush()

Instrumentatie met aanvraagbibliotheek

OpenTelemetry ondersteunt ook verschillende instrumentaties waarmee u kunt instrumenteren met bibliotheken van derden.

Ga naar de contrib-documentatie voor een lijst met instrumentaties die beschikbaar zijn in OpenTelemetry.

In dit voorbeeld ziet u hoe u instrumenteer met de aanvraagbibliotheek .

• Installeer het instrumentatiepakket aanvragen met behulp van pip install opentelemetry-instrumentation-requests.

"""
An example to show an application instrumented with the OpenTelemetry requests instrumentation.
Calls made with the requests library will be automatically tracked and telemetry is exported to 
application insights with the AzureMonitorTraceExporter.
See more info on the requests instrumentation here:
https://github.com/open-telemetry/opentelemetry-python-contrib/tree/main/instrumentation/opentelemetry-instrumentation-requests
"""
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/")

Steekproeven inschakelen

U kunt steekproeven inschakelen om het aantal telemetrierecords dat u ontvangt te beperken. Als u de juiste steekproeven in Application Insights wilt inschakelen, gebruikt u de ApplicationInsightsSampler zoals hieronder wordt weergegeven.

"""
An example to show an application using the ApplicationInsightsSampler to enable sampling for your telemetry.
Specify a sampling rate for the sampler to limit the amount of telemetry records you receive. Custom dependencies
 are tracked via spans and telemetry is exported to application insights with the AzureMonitorTraceExporter.
"""
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!")

Gedrag van leegmaken/afsluiten

Voor alle toepassingen die zijn ingesteld met OpenTelemetry SDK en Azure Monitor-exporteurs, wordt telemetrie automatisch leeggemaakt wanneer de toepassing wordt afgesloten. Houd er rekening mee dat dit niet geldt wanneer de toepassing abrupt wordt beëindigd of vastloopt vanwege een niet-beladen uitzondering.

Problemen oplossen

De exporteur genereert uitzonderingen die zijn gedefinieerd in Azure Core.

Volgende stappen

Meer voorbeeldcode

Meer voorbeelden vindt u in de map met voorbeelden waarin veelvoorkomende scenario's worden gedemonstreerd.

Aanvullende documentatie

Zie de Azure Monitor-documentatie op docs.microsoft.com voor uitgebreidere documentatie over de Azure Monitor-service .

Ga naar hun overzichtspagina voor een gedetailleerd overzicht van OpenTelemetry.

Ga voor de officiële OpenTelemetry Python-documentatie en het inschakelen van andere telemetriescenario's naar de officiële OpenTelemetry-website.

Ga voor meer informatie over de Azure Monitor OpenTelemetry-distributie, een bundel nuttige, vooraf samengestelde onderdelen (waaronder dit huidige pakket) die telemetriescenario's met Azure Monitor mogelijk maken, naar leesmij.

Bijdragen

Wij verwelkomen bijdragen en suggesties voor dit project. Voor de meeste bijdragen moet u instemmen met een licentieovereenkomst voor bijdragers (CLA: Contributor License Agreement) waarin u verklaart dat u gerechtigd bent ons het recht te geven uw bijdrage te gebruiken, en dat u dit ook doet. Ga naar https://cla.microsoft.com voor meer informatie.

Wanneer u een pull-aanvraag indient, wordt met een CLA-bot automatisch bepaald of u een CLA moet verschaffen en wordt de pull-aanvraag dienovereenkomstig opgemaakt (bijvoorbeeld met een label of commentaar). Volg gewoon de instructies van de bot. U hoeft dit maar eenmaal te doen voor alle repo's waar gebruik wordt gemaakt van onze CLA.

Op dit project is de Microsoft Open Source Code of Conduct (Microsoft Open Source-gedragscode) van toepassing. Zie de Veelgestelde vragen over de gedragscode voor meer informatie of neem contact op opencode@microsoft.com met eventuele aanvullende vragen of opmerkingen.