Microsoft OpenTelemetry-exportőr az Azure Monitorhoz

  • Cikk

Az Azure Monitor exportőre lehetővé teszi, hogy az OpenTelemetry SDK használatával exportálja az adatokat, és telemetriai adatokat küldjön az Azure Monitornak a Pythonban írt alkalmazásokhoz.

Forráskód | Csomag (PyPi) | API-referenciadokumentáció | Termékdokumentáció | Minták | Változatlan

Első lépések

A csomag telepítése

Telepítse az Azure Monitorhoz készült Microsoft OpenTelemetry-exportőrt a pip használatával:

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

Előfeltételek

A csomag használatához a következőket kell tennie:

Az ügyfél példányosítása

Az Azure Monitor-exportőrrel való interakció az elosztott nyomkövetés, AzureMonitorLogExporter a naplózás és AzureMonitorMetricExporter a AzureMonitorTraceExporter metrikák osztályának egy példányával kezdődik. Az objektum példányosításához szüksége lesz egy connection_string . Az alábbiakban csatolt mintákat talál az exportőr kapcsolati karakterlánc használatával történő felépítésének bemutatásához.

Naplózás (kísérleti)

MEGJEGYZÉS: A naplózási AzureMonitorLogExporter jel jelenleg KÍSÉRLETI állapotban van. Lehetséges törési változások a jövőben következhetnek be.

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

Mérőszámok

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

Nyomkövetés

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

Az exportőrt közvetlenül a konstruktoron keresztül is létrehozhatja. Ebben az esetben a kapcsolati karakterlánc automatikusan ki lesz töltve a APPLICATIONINSIGHTS_CONNECTION_STRING környezeti változóból.

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

Fő fogalmak

Az Azure Monitor-exportőr néhány fő fogalma a következők:

  • OpenTelemetry: Az OpenTelemetry a telemetriai adatok (metrikák, naplók és nyomkövetések) elemzésre való gyűjtésére és exportálására használt kódtárak készlete a szoftver teljesítményének és viselkedésének megértéséhez.

  • Rendszerállapot: Az OpenTelemetry API bármely alkalmazás általi közvetlen meghívásának lehetőségét a rendszerállapot teszi lehetővé. Az OpenTelemetry megfigyelhetőségét egy másik kódtár esetében eszközkódtárnak nevezzük.

  • Napló: A napló a naplózás, a kivétel és az események rögzítésére utal.

  • LogRecord: Egy támogatott naplózási kódtárból kibocsátott naplórekordot jelöl.

  • Naplózó: Az a-t LogRecord olvashatóvá LogDataalakítja, és az exportálandó SDK-on keresztül lesz leküldve.

  • Naplózószolgáltató: Az adott rendszerállapot-kódtárhoz biztosít egy Logger elemet.

  • LogRecordProcessor: A naplórekord-kibocsátó művelet összekapcsolásához használható felület.

  • LoggingHandler: Egy kezelőosztály, amely a naplózási rekordokat OpenTelemetry formátumban írja a standard Python-kódtárból logging .

  • AzureMonitorLogExporter: Ez az a osztály, amely inicializálva van a naplózással kapcsolatos telemetriai adatok Azure Monitorba való küldéséhez.

  • Metrika: Metric a nyers mérések előre definiált aggregációval és attribútumkészletekkel történő rögzítésére vonatkozik egy adott időszakra vonatkozóan.

  • Mérés: Egy adott időpontban rögzített adatpontot jelöl.

  • Eszköz: Az eszközök az s jelentésére Measurementszolgálnak.

  • Mérő: A Meter felelős a létrehozásért Instruments.

  • Fogyasztásmérő-szolgáltató: A megadott rendszerállapot-kódtárhoz biztosít egy Meter értéket.

  • Metrikaolvasó: Egy SDK-implementációs objektum, amely az OpenTelemetry Metrics SDK általános konfigurálható szempontjait biztosítja, például a gyűjteményt, a kiürítést és a leállítást.

  • AzureMonitorMetricExporter: Ez az a osztály, amely inicializálva van a metrikával kapcsolatos telemetriai adatok Azure Monitorba való küldéséhez.

  • Nyomkövetés: A nyomkövetés elosztott nyomkövetésre utal. Az elosztott nyomkövetés egy olyan eseménykészlet, amely egyetlen logikai művelet eredményeként aktiválódik, és egy alkalmazás különböző összetevőire van összevonva. A Nyomkövetés különösen a Spans irányított aciklikus gráfjaként (DAG) tekinthető, ahol a spanok közötti élek szülő-gyermek kapcsolatként vannak definiálva.

  • Span: Egyetlen műveletet jelöl egy adott műveleten Tracebelül. Beágyazható egy nyomkövetési fa létrehozásához. Minden nyomkövetés tartalmaz egy gyökértartományt, amely általában a teljes műveletet írja le, és opcionálisan egy vagy több altartományt az alműveleteihez.

  • Tracer: Felelős az s létrehozásához Span.

  • Nyomkövetési szolgáltató: Az Tracer adott eszközkódtár számára használható.

  • Span Processor: A span processzor lehetővé teszi az SDK Span kezdő és záró metódusának meghívását. További információért kövesse a hivatkozást.

  • AzureMonitorTraceExporter: Ez az a osztály, amely inicializálva van a nyomkövetéssel kapcsolatos telemetriai adatok Azure Monitorba való küldéséhez.

  • Mintavételezés: A mintavételezés az OpenTelemetry által okozott zaj és többletterhelés szabályozására szolgáló mechanizmus, amely csökkenti a háttérrendszerbe gyűjtött és elküldött nyomkövetési minták számát.

  • ApplicationInsightsSampler: Az Application Insights SDK-k és az Application Insightsba adatokat küldő OpenTelemetry-alapú SDK-k konzisztens mintavételezéséhez használt Application Insights-specifikus mintavevő. Ezt a mintavevőt minden alkalommal AzureMonitorTraceExporter használni kell.

További információ ezekről az erőforrásokról: Mi az az Azure Monitor?.

Konfiguráció

Az összes konfigurációs lehetőség átadható az exportőrök konstruktorain keresztül.kwargs Az alábbiakban a konfigurálható beállítások listája látható.

  • connection_string: Az Application Insights-erőforráshoz használt kapcsolati karakterlánc.
  • disable_offline_storage: Logikai érték annak meghatározásához, hogy le szeretné-e tiltani a sikertelen telemetriai rekordok újrapróbálkozáshoz való tárolását. Alapértelmezés szerint a értékre van kapcsolva False.
  • storage_directory: Tárkönyvtár, amelyben újrapróbálkozó fájlokat tárolhat. Alapértelmezés szerint a értékre van kapcsolva <tempfile.gettempdir()>/Microsoft/AzureMonitor/opentelemetry-python-<your-instrumentation-key>.
  • credential: Jogkivonat-hitelesítő adatok, például ManagedIdentityCredential vagy ClientSecretCredential, azure Active Directory-hitelesítéshez (AAD) használva. Alapértelmezés szerint Nincs. Példákért tekintse meg a példákat .

Példák

Naplózás (kísérleti)

MEGJEGYZÉS: A naplózási AzureMonitorLogExporter jel jelenleg KÍSÉRLETI állapotban van. Lehetséges törési változások a jövőben következhetnek be.

A következő szakaszok számos kódrészletet biztosítanak, amelyek a leggyakoribb feladatok némelyikét tartalmazzák, többek között:

Tekintse át az OpenTelemetry Logging SDK-t , és ismerje meg, hogyan gyűjthet naplókat az OpenTelemetry-összetevőkkel.

"Helló világ!" alkalmazás-napló exportálása

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

Korrelált napló exportálása

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

Egyéni tulajdonságok naplójának exportálása

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

Kivételnapló exportálása

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

Mérőszámok

A következő szakaszok számos kódrészletet biztosítanak, amelyek a leggyakoribb feladatok némelyikét tartalmazzák, többek között:

Tekintse át az OpenTelemetry Metrics SDK-t , és ismerje meg, hogyan gyűjthet metrikákat az OpenTelemetry-összetevőkkel.

Metrikaeszköz-használat

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

Egyéni nézetek metrikái

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

A metrikák Views SDK-jával kapcsolatos további példákat itt talál.

Metrikarekord-attribútumok

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

Nyomkövetés

A következő szakaszok számos kódrészletet biztosítanak, amelyek a leggyakoribb feladatok némelyikét tartalmazzák, többek között:

Tekintse át az OpenTelemetry Tracing SDK-t , és ismerje meg, hogyan gyűjthet naplókat az OpenTelemetry-összetevőkkel.

"Helló világ!" alkalmazás nyomkövetés exportálása

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

Rendszerállapot kéréstárral

Az OpenTelemetry számos olyan kialakítást is támogat, amelyek lehetővé teszik a külső kódtárakkal való rendszerezést.

Az OpenTelemetryben elérhető kialakítások listáját a contrib dokumentációjában találja.

Ez a példa bemutatja, hogyan alakíthatja ki a kéréstárat .

  • Telepítse a requests instrumentation csomagot a pip install opentelemetry-instrumentation-requests paranccsal.
"""
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/")

Mintavételezés engedélyezése

Engedélyezheti a mintavételezést a kapott telemetriai rekordok mennyiségének korlátozásához. A helyes mintavételezés az Application Insightsban való engedélyezéséhez használja az ApplicationInsightsSampler alábbit.

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

Kiürítési/leállítási viselkedés

Az OpenTelemetry SDK-val és az Azure Monitor-exportőrökkel beállított összes alkalmazás esetében a rendszer automatikusan kiüríti a telemetriát az alkalmazásból való kilépéskor. Vegye figyelembe, hogy ez nem vonatkozik arra az esetre, ha az alkalmazás hirtelen véget ér, vagy váratlan kivétel miatt összeomlik.

Hibaelhárítás

Az exportőr kivételeket emel ki az Azure Core-ban.

Következő lépések

További mintakód

További példákat a gyakori forgatókönyveket bemutató mintakönyvtárban talál.

További dokumentáció

Az Azure Monitor szolgáltatással kapcsolatos részletesebb dokumentációért tekintse meg az Azure Monitor dokumentációját a docs.microsoft.com.

Az OpenTelemetry részletes áttekintését az áttekintési oldalon találja.

A hivatalos OpenTelemetry Python-dokumentációért és az egyéb telemetriai forgatókönyvek engedélyezéséhez látogasson el a hivatalos OpenTelemetry webhelyre.

Az Azure Monitor OpenTelemetry disztribúcióról, amely hasznos, előre összeállított összetevők (ezek egyike az aktuális csomag) csomagja, amely lehetővé teszi a telemetriai forgatókönyveket az Azure Monitorral, látogasson el a README webhelyre.

Közreműködés

A projektben szívesen fogadjuk a hozzájárulásokat és a javaslatokat. A legtöbb hozzájáruláshoz el kell fogadnia egy Közreműködői licencszerződést (CLA-t), amelyben kijelenti, hogy jogosult arra, hogy ránk ruházza hozzájárulása felhasználási jogát, és ezt ténylegesen meg is teszi. További részletekért lásd: https://cla.microsoft.com.

A lekéréses kérelmek elküldésekor egy CLA-robot automatikusan meghatározza, hogy kell-e biztosítania CLA-t, és megfelelően kitölti a lekéréses kérelmet (például címke, megjegyzés). Egyszerűen csak kövesse a robot által megadott utasításokat. Ezt csak egyszer kell elvégeznie az összes olyan tárházban, amely a CLA-t használja.

A projekt a Microsoft nyílt forráskódú projekteket szabályozó etikai kódexe, a Microsoft Open Source Code of Conduct hatálya alá esik. További információkért lásd a viselkedési szabályzattal kapcsolatos gyakori kérdéseket , vagy vegye fel a kapcsolatot opencode@microsoft.com az esetleges további kérdésekkel vagy megjegyzésekkel.