Eksporter Microsoft OpenTelemetry dla usługi Azure Monitor

Eksporter usługi Azure Monitor umożliwia eksportowanie danych przy użyciu zestawu OpenTelemetry SDK i wysyłanie danych telemetrycznych do usługi Azure Monitor dla aplikacji napisanych w języku Python.

Kod | źródłowyPakiet (PyPi) | Dokumentacja referencyjna interfejsu | APIDokumentacja | produktuPróbki | Changelog

Wprowadzenie

Instalowanie pakietu

Zainstaluj eksportera Microsoft OpenTelemetry dla usługi Azure Monitor przy użyciu narzędzia pip:

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

Wymagania wstępne

Aby użyć tego pakietu, musisz mieć następujące elementy:

• Subskrypcja platformy Azure — można utworzyć bezpłatne konto
• Azure Monitor — jak używać usługi Application Insights
• Zestaw SDK OpenTelemetry — zestaw OpenTelemetry SDK dla języka Python
• Python 3.7 lub nowszy — instalowanie języka Python

Tworzenie wystąpienia klienta

Interakcja z eksporterem usługi Azure Monitor rozpoczyna się od wystąpienia klasy do śledzenia rozproszonego AzureMonitorTraceExporter , AzureMonitorLogExporter rejestrowania i AzureMonitorMetricExporter metryk. Do utworzenia wystąpienia obiektu będzie potrzebny connection_string . Zapoznaj się z poniższymi przykładami, aby pokazać, jak utworzyć eksportera przy użyciu parametry połączenia.

Rejestrowanie (eksperymentalne)

UWAGA: Sygnał rejestrowania dla elementu AzureMonitorLogExporter jest obecnie w stanie EKSPERYMENTALNYM. Możliwe zmiany powodujące niezgodność mogą pojawić się w przyszłości.

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

Metryki

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

Śledzenie

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

Możesz również utworzyć wystąpienie eksportera bezpośrednio za pośrednictwem konstruktora. W takim przypadku parametry połączenia zostaną automatycznie wypełnione ze zmiennej środowiskowejAPPLICATIONINSIGHTS_CONNECTION_STRING.

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

Kluczowe pojęcia

Oto niektóre kluczowe pojęcia dotyczące eksportera usługi Azure Monitor:

• OpenTelemetry: OpenTelemetry to zestaw bibliotek używanych do zbierania i eksportowania danych telemetrycznych (metryk, dzienników i śladów) do analizy w celu zrozumienia wydajności i zachowania oprogramowania.

• Instrumentacja: możliwość wywoływania interfejsu API OpenTelemetry bezpośrednio przez dowolną aplikację jest ułatwiana przez instrumentację. Biblioteka, która umożliwia obserwowanie biblioteki OpenTelemetry dla innej biblioteki, jest nazywana biblioteką instrumentacji.

• Dziennik: dziennik odnosi się do przechwytywania rejestrowania, wyjątków i zdarzeń.

• LogRecord: reprezentuje rekord dziennika emitowany z obsługiwanej biblioteki rejestrowania.

• Rejestrator: konwertuje element LogRecord na czytelny LogDataelement i zostanie wypchnięty przez zestaw SDK do wyeksportowania.

• Dostawca rejestratora: udostępnia Logger dla danej biblioteki instrumentacji.

• LogRecordProcessor: interfejs umożliwiający podłączanie rekordu dziennika emitujących akcję.

• LoggingHandler: klasa obsługi, która zapisuje rekordy rejestrowania w formacie OpenTelemetry ze standardowej biblioteki języka Python logging .

• AzureMonitorLogExporter: jest to klasa zainicjowana do wysyłania danych telemetrycznych związanych z rejestrowaniem do usługi Azure Monitor.

• Metryka: Metric odnosi się do rejestrowania nieprzetworzonych pomiarów przy użyciu wstępnie zdefiniowanej agregacji i zestawów atrybutów przez okres w czasie.

• Pomiar: reprezentuje punkt danych zarejestrowany w punkcie w czasie.

• Instrument: Instrumenty są używane do raportowania Measurements.

• Miernik: Element Meter jest odpowiedzialny za utworzenie elementu Instruments.

• Dostawca miernika: udostępnia Meter bibliotekę instrumentacji dla danej biblioteki instrumentacji.

• Czytelnik metryk: obiekt implementacji zestawu SDK, który udostępnia typowe konfigurowalne aspekty zestawu SDK metryk OpenTelemetry, takie jak zbieranie, opróżnianie i zamykanie.

• AzureMonitorMetricExporter: jest to klasa zainicjowana do wysyłania danych telemetrycznych powiązanych z metryki do usługi Azure Monitor.

• Ślad: ślad odwołuje się do śledzenia rozproszonego. Ślad rozproszony to zestaw zdarzeń wyzwalanych w wyniku pojedynczej operacji logicznej, skonsolidowanej między różnymi składnikami aplikacji. W szczególności ślad można traktować jako skierowany graf acykliczny (DAG) spans, gdzie krawędzie między zakresami są definiowane jako relacja nadrzędna/podrzędna.

• Zakres: reprezentuje pojedynczą operację w obiekcie Trace. Można zagnieżdżać w celu utworzenia drzewa śledzenia. Każdy ślad zawiera zakres główny, który zazwyczaj opisuje całą operację i opcjonalnie co najmniej jedno przedziały podrzędne dla jego podrzędnych operacji.

• Tracer: odpowiedzialny za tworzenie Spanelementów s.

• Dostawca tracer: udostępnia element Tracer do użycia przez daną bibliotekę instrumentacji.

• Procesor span: procesor zakresu umożliwia zaczepienia wywołań metody początkowej i końcowej Span zestawu SDK. Aby uzyskać więcej informacji, postępuj zgodnie z linkiem.

• AzureMonitorTraceExporter: jest to klasa zainicjowana do wysyłania danych telemetrycznych powiązanych ze śledzeniem do usługi Azure Monitor.

• Próbkowanie: Próbkowanie to mechanizm sterowania szumem i obciążeniem wprowadzonym przez program OpenTelemetry przez zmniejszenie liczby próbek zebranych i wysłanych do zaplecza.

• ApplicationInsightsSampler: próbkator specyficzny dla usługi Application Insights używany do spójnego próbkowania w zestawach SDK usługi Application Insights i zestawach SDK opartych na protokole OpenTelemetry wysyłających dane do usługi Application Insights. Ten przykładnik MUSI być używany za każdym razem, gdy AzureMonitorTraceExporter jest używany.

Aby uzyskać więcej informacji na temat tych zasobów, zobacz Co to jest usługa Azure Monitor?.

Konfigurowanie

Wszystkie opcje konfiguracji można przekazać za pośrednictwem konstruktorów eksporterów za pośrednictwem kwargspolecenia . Poniżej znajduje się lista konfigurowalnych opcji.

• connection_string: parametry połączenia używany dla zasobu usługi Application Insights.
• disable_offline_storage: wartość logiczna określająca, czy wyłączyć przechowywanie nieudanych rekordów telemetrycznych na potrzeby ponawiania próby. Wartość domyślna to False.
• storage_directory: katalog magazynu, w którym mają być przechowywane pliki ponawiania prób. Wartość domyślna to <tempfile.gettempdir()>/Microsoft/AzureMonitor/opentelemetry-python-<your-instrumentation-key>.
• credential: poświadczenia tokenu, takie jak ManagedIdentityCredential lub ClientSecretCredential, używane do uwierzytelniania usługi Azure Active Directory (AAD). Domyślnie wartość Brak. Zobacz przykłady .

Przykłady

Rejestrowanie (eksperymentalne)

UWAGA: Sygnał rejestrowania dla elementu AzureMonitorLogExporter jest obecnie w stanie EKSPERYMENTALNYM. Możliwe zmiany powodujące niezgodność mogą pojawić się w przyszłości.

W poniższych sekcjach przedstawiono kilka fragmentów kodu obejmujących niektóre z najbardziej typowych zadań, w tym:

• Eksportowanie rekordu dziennika
• Eksportowanie skorelowanego rekordu dziennika
• Eksportowanie rekordu dziennika z właściwościami niestandardowymi
• Eksportowanie rekordu dziennika wyjątków

Zapoznaj się z zestawem SDK rejestrowania OpenTelemetry, aby dowiedzieć się, jak zbierać dzienniki za pomocą składników OpenTelemetry.

Eksportowanie dziennika Hello world

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

Eksportowanie skorelowanego dziennika

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

Eksportowanie dziennika właściwości niestandardowych

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

Eksportowanie dziennika wyjątków

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

Metryki

W poniższych sekcjach przedstawiono kilka fragmentów kodu obejmujących niektóre z najbardziej typowych zadań, w tym:

• Korzystanie z różnych instrumentów metrycznych
• Dostosowywanie wyjściowych metryk za pomocą widoków
• Rejestrowanie instrumentów z atrybutami

Zapoznaj się z zestawem SDK metryk OpenTelemetry, aby dowiedzieć się, jak zbierać metryki za pomocą składników OpenTelemetry.

Użycie instrumentów metryk

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

Widoki niestandardowe metryk

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

Więcej przykładów z zestawem SDK metryk Views można znaleźć tutaj.

Atrybuty rekordów metryk

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

Śledzenie

W poniższych sekcjach przedstawiono kilka fragmentów kodu obejmujących niektóre z najbardziej typowych zadań, w tym:

• Eksportowanie zakresu niestandardowego
• Śledzenie biblioteki przy użyciu instrumentacji
• Włączanie próbkowania w celu ograniczenia ilości wysłanych danych telemetrycznych

Zapoznaj się z zestawem SDK śledzenia OpenTelemetry, aby dowiedzieć się, jak zbierać dzienniki przy użyciu składników OpenTelemetry.

Eksportowanie śledzenia Hello world

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

Instrumentacja za pomocą biblioteki żądań

Biblioteka OpenTelemetry obsługuje również kilka instrumentacji, które umożliwiają instrumentację za pomocą bibliotek innych firm.

Aby uzyskać listę instrumentacji dostępnych w usłudze OpenTelemetry, odwiedź dokumentację usługi contrib.

W tym przykładzie pokazano, jak instrumentować za pomocą biblioteki żądań .

• Zainstaluj pakiet instrumentacji żądań przy użyciu narzędzia 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/")

Włączanie próbkowania

Możesz włączyć próbkowanie, aby ograniczyć liczbę odbieranych rekordów telemetrii. Aby włączyć poprawne próbkowanie w usłudze Application Insights, użyj elementu , ApplicationInsightsSampler jak pokazano poniżej.

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

Zachowanie opróżniania/zamykania

W przypadku wszystkich aplikacji skonfigurowanych za pomocą zestawu OpenTelemetry SDK i eksporterów usługi Azure Monitor dane telemetryczne są automatycznie opróżniane po zamknięciu aplikacji. Należy pamiętać, że nie obejmuje to nagłego zakończenia aplikacji lub awarii z powodu nieuchwyconego wyjątku.

Rozwiązywanie problemów

Eksporter zgłasza wyjątki zdefiniowane w usłudze Azure Core.

Następne kroki

Więcej przykładów kodu

Więcej przykładów można znaleźć w katalogu samples demonstrujących typowe scenariusze.

Dodatkowa dokumentacja

Aby uzyskać bardziej obszerną dokumentację dotyczącą usługi Azure Monitor, zobacz dokumentację usługi Azure Monitor dotyczącą docs.microsoft.com.

Aby uzyskać szczegółowe omówienie usługi OpenTelemetry, odwiedź ich stronę przeglądu .

Oficjalna dokumentacja języka Python OpenTelemetry i sposób włączania innych scenariuszy telemetrii można znaleźć w oficjalnej witrynie internetowej OpenTelemetry.

Aby uzyskać więcej informacji na temat dystrybucji OpenTelemetry usługi Azure Monitor, która jest pakietem przydatnych, wstępnie utworzonych składników (jednym z nich jest ten bieżący pakiet), które umożliwiają scenariusze telemetrii za pomocą usługi Azure Monitor, odwiedź plik README.

Współtworzenie

W tym projekcie zachęcamy do współtworzenia i zgłaszania sugestii. Współtworzenie w większości przypadków wymaga zgody na umowę licencyjną dotyczącą współautorów (CLA, Contributor License Agreement), zgodnie z którą współautor ma prawo udzielić i faktycznie udziela nam praw do używania wytworzonej przez siebie zawartości. Aby uzyskać szczegółowe informacje, odwiedź stronę https://cla.microsoft.com.

Po przesłaniu żądania ściągnięcia robot CLA automatycznie określi, czy musisz przekazać umowę CLA, i doda odpowiednie informacje do tego żądania (na przykład etykietę czy komentarz). Po prostu postępuj zgodnie z instrukcjami robota. Wystarczy zrobić to raz dla wszystkich repozytoriów, w przypadku których jest używana nasza umowa CLA.

W tym projekcie przyjęto Kodeks postępowania oprogramowania Open Source firmy Microsoft. Aby uzyskać więcej informacji, zobacz Często zadawane pytania dotyczące kodeksu postępowania lub skontaktuj się z opencode@microsoft.com dodatkowymi pytaniami lub komentarzami.