Nástroj pro export OpenTelemetry microsoftu pro Azure Monitor

Exportér pro Azure Monitor umožňuje exportovat data s využitím sady OpenTelemetry SDK a odesílat telemetrická data do služby Azure Monitor pro aplikace napsané v Pythonu.

Zdrojový kód | Balíček (PyPi) | Referenční dokumentace k | rozhraní APIDokumentace k | produktuVzorky | Changelog

Začínáme

Instalace balíčku

Nainstalujte nástroj pro export Microsoft OpenTelemetry pro Azure Monitor pomocí nástroje pip:

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

Požadavky

Pokud chcete tento balíček použít, musíte mít:

• Předplatné Azure – Vytvoření bezplatného účtu
• Azure Monitor – Jak používat Application Insights
• OpenTelemetry SDK – OpenTelemetry SDK pro Python
• Python 3.7 nebo novější – Instalace Pythonu

Vytvoření instance klienta

Interakce s nástrojem pro export služby Azure Monitor začíná instancí AzureMonitorTraceExporter třídy pro distribuované trasování, AzureMonitorLogExporter protokolování a AzureMonitorMetricExporter metriky. K vytvoření instance objektu budete potřebovat connection_string . Níže uvedené ukázky vám předvedou, jak sestavit vývozce pomocí připojovací řetězec.

Protokolování (experimentální)

POZNÁMKA: Signál protokolování pro je AzureMonitorLogExporter aktuálně ve stavu EXPERIMENTAL. V budoucnu může dojít k možným změnám způsobujícím chybu.

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

Metriky

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

Trasování

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

Můžete také vytvořit instanci exportéru přímo prostřednictvím konstruktoru. V takovém případě se připojovací řetězec automaticky vyplní z APPLICATIONINSIGHTS_CONNECTION_STRING proměnné prostředí.

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

Klíčové koncepty

Mezi klíčové koncepty exportéru Azure Monitoru patří:

• OpenTelemetry: OpenTelemetry je sada knihoven, které slouží ke shromažďování a exportu telemetrických dat (metrik, protokolů a trasování) pro účely analýzy, aby bylo možné porozumět výkonu a chování vašeho softwaru.

• Instrumentace: Možnost volat rozhraní API OpenTelemetry přímo libovolnou aplikací je usnadněna instrumentací. Knihovna, která umožňuje pozorovatelnost OpenTelemetry pro jinou knihovnu, se nazývá knihovna instrumentace.

• Protokol: Protokol označuje zachytávání protokolování, výjimek a událostí.

• Záznam protokolu: Představuje záznam protokolu vygenerovaný z podporované knihovny protokolování.

• Protokolovací nástroj: Převede soubor na LogRecord čitelný LogDataa bude nabízen prostřednictvím sady SDK k exportu.

• Zprostředkovatel protokolovacího nástroje: Poskytuje pro danou instrumentační knihovnu Logger .

• LogRecordProcessor: Rozhraní pro připojení akce generování záznamu protokolu.

• LoggingHandler: Třída obslužné rutiny, která zapisuje záznamy protokolování ve formátu OpenTelemetry ze standardní knihovny Pythonu logging .

• AzureMonitorLogExporter: Toto je třída, která se inicializuje za účelem odesílání telemetrie související s protokolováním do služby Azure Monitor.

• Metrika: Metric Označuje záznam nezpracovaných měření s předdefinovanou agregací a sadami atributů pro určité období v čase.

• Měření: Představuje datový bod zaznamenaný v určitém bodu v čase.

• Instrument: Nástroje se používají k hlášení Measurements.

• Měřič: Zodpovídá Meter za vytvoření Instruments.

• Poskytovatel měřiče: Poskytuje pro danou knihovnu Meter instrumentace hodnotu .

• Čtenář metrik: Objekt implementace sady SDK, který poskytuje běžné konfigurovatelné aspekty sady SDK metrik OpenTelemetry, jako je shromažďování, vyprazdňování a vypínání.

• AzureMonitorMetricExporter: Toto je třída, která se inicializuje pro odesílání telemetrických dat souvisejících s metrikou do služby Azure Monitor.

• Trasování: Trasování odkazuje na distribuované trasování. Distribuované trasování je sada událostí, které se aktivují jako výsledek jedné logické operace a konsolidují se napříč různými komponentami aplikace. Trasování si lze konkrétně představit jako orientovaný acyklický graf (DAG) spanů, kde jsou hrany mezi spany definovány jako vztah nadřazenosti a podřízenosti.

• Span: Představuje jednu operaci v rámci objektu Trace. Lze vnořit a vytvořit tak strom trasování. Každé trasování obsahuje kořenový rozsah, který obvykle popisuje celou operaci a volitelně jeden nebo více dílčích rozsahů pro její dílčí operace.

• Tracer: Zodpovídá za vytváření Spans.

• Zprostředkovatel trasování: Poskytuje nástroj Tracer pro použití danou knihovnou instrumentace.

• Procesor Span: Procesor span umožňuje volání počáteční a koncové metody sady SDK Span . Další informace najdete na odkazu.

• AzureMonitorTraceExporter: Toto je třída, která se inicializuje pro odesílání telemetrických dat souvisejících s trasováním do služby Azure Monitor.

• Vzorkování: Vzorkování je mechanismus pro kontrolu šumu a režie, které OpenTelemetry zavádí, snížením počtu vzorků trasování shromážděných a odesílaných do back-endu.

• ApplicationInsightsSampler: Vzorkovač specifický pro Application Insights používaný k konzistentnímu vzorkování napříč sadami SDK application Insights a sadami SDK založenými na OpenTelemetry, které odesílají data do Application Insights. Tento vzorkovník musí být použit vždy, když AzureMonitorTraceExporter se použije.

Další informace o těchto prostředcích najdete v tématu Co je Azure Monitor?.

Konfigurace

Všechny možnosti konfigurace mohou být předány prostřednictvím konstruktorů exportérů prostřednictvím kwargs. Níže je seznam konfigurovatelných možností.

• connection_string: Připojovací řetězec použitý pro prostředek Application Insights.
• disable_offline_storage: Logická hodnota určující, jestli se má zakázat ukládání neúspěšných telemetrických záznamů pro opakování. Výchozí hodnota je False.
• storage_directory: Adresář úložiště, do kterého se mají ukládat soubory opakování. Výchozí hodnota je <tempfile.gettempdir()>/Microsoft/AzureMonitor/opentelemetry-python-<your-instrumentation-key>.
• credential: Přihlašovací údaje tokenu, například ManagedIdentityCredential nebo ClientSecretCredential, které se používají k ověřování Azure Active Directory (AAD). Výchozí hodnota je Žádná. Příklady najdete v ukázkách .

Příklady

Protokolování (experimentální)

POZNÁMKA: Signál protokolování pro je AzureMonitorLogExporter aktuálně ve stavu EXPERIMENTAL. V budoucnu může dojít k možným změnám způsobujícím chybu.

Následující části obsahují několik fragmentů kódu, které pokrývají některé z nejběžnějších úloh, mezi které patří:

• Export záznamu protokolu
• Export korelovaného záznamu protokolu
• Export záznamu protokolu s vlastními vlastnostmi
• Export záznamu protokolu výjimek

Projděte si sadu SDK pro protokolování OpenTelemetry , kde se dozvíte, jak pomocí komponent OpenTelemetry shromažďovat protokoly.

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

Exportovat korelovaný protokol

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

Export protokolu vlastních vlastností

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

Export protokolu výjimek

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

Metriky

Následující části obsahují několik fragmentů kódu, které pokrývají některé z nejběžnějších úloh, mezi které patří:

• Použití různých metrických nástrojů
• Přizpůsobení výstupních metrik pomocí zobrazení
• Nahrávací nástroje s atributy

Projděte si sadu OpenTelemetry Metrics SDK , kde se dozvíte, jak pomocí komponent OpenTelemetry shromažďovat metriky.

Využití nástroje metrik

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

Vlastní zobrazení metriky

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

Další příklady se sadou SDK pro metriky Views najdete tady.

Atributy záznamu metriky

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

Trasování

Následující části obsahují několik fragmentů kódu, které pokrývají některé z nejběžnějších úloh, mezi které patří:

• Export vlastního rozsahu
• Použití instrumentace ke sledování knihovny
• Povolení vzorkování za účelem omezení množství odesílané telemetrie

Projděte si sadu SDK pro trasování OpenTelemetry , kde se dozvíte, jak pomocí komponent OpenTelemetry shromažďovat protokoly.

Trasování Hello World exportu

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

Instrumentace s využitím knihovny požadavků

OpenTelemetry také podporuje několik instrumentací, které umožňují instrumentovat knihovny třetích stran.

Seznam instrumentací dostupných v OpenTelemetry najdete v dokumentaci contrib.

Tento příklad ukazuje, jak instrumentovat pomocí knihovny požadavků .

• Nainstalujte balíček instrumentace žádostí pomocí příkazu 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/")

Povolení vzorkování

Můžete povolit vzorkování, abyste omezili množství záznamů telemetrie, které obdržíte. Pokud chcete povolit správné vzorkování v Application Insights, použijte ApplicationInsightsSampler následující příklad.

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

Chování při vyprázdnění/vypnutí

U všech aplikací nastavených pomocí sady OpenTelemetry SDK a exportérů služby Azure Monitor se telemetrie vyprazdní automaticky při ukončení aplikace. Všimněte si, že nezahrnuje náhlé ukončení aplikace nebo chybové ukončení kvůli nezachycené výjimce.

Řešení potíží

Vývozce vyvolává výjimky definované v Azure Core.

Další kroky

Další vzorový kód

Další příklady pro běžné scénáře najdete v adresáři ukázek .

Další dokumentace

Podrobnější dokumentaci ke službě Azure Monitor najdete v dokumentaci ke službě Azure Monitor na docs.microsoft.com.

Podrobný přehled OpenTelemetry najdete na stránce s přehledem opentelemetry.

Oficiální dokumentaci k OpenTelemetry Pythonu a informace o tom, jak povolit další scénáře telemetrie, najdete na oficiálním webu OpenTelemetry.

Další informace o distribuci OpenTelemetry služby Azure Monitor, což je sada užitečných předem sestavených komponent (jedním z nich je aktuální balíček), které umožňují scénáře telemetrie se službou Azure Monitor, najdete v souboru README.

Přispívání

Tento projekt vítá příspěvky a návrhy. Většina příspěvků vyžaduje souhlas s licenční smlouvou s přispěvatelem (CLA), která stanoví, že máte právo udělit nám práva k používání vašeho příspěvku a skutečně tak činíte. Podrobnosti najdete tady: https://cla.microsoft.com

Při odesílání žádosti o přijetí změn robot CLA automaticky určí, jestli je potřeba poskytnout smlouvu CLA, a příslušným způsobem žádost o přijetí změn upraví (např. přidáním jmenovky nebo komentáře). Stačí postupovat podle pokynů robota. Pro všechna úložiště používající naši smlouvu CLA to stačí udělat jenom jednou.

Tento projekt přijal pravidla chování pro Microsoft Open Source. Další informace najdete v nejčastějších dotazech k pravidlům chování nebo kontaktujte s opencode@microsoft.com případnými dalšími dotazy nebo připomínkami.