• EnglishEspañol日本語한국어Português
  • EntrarComeçar agora

Esta tradução de máquina é fornecida para sua comodidade.

In the event of any inconsistency between the English version and the translated version, the English versionwill take priority. Please visit this page for more information.

Criar um problema

Tutoriais OpenTelemetry: instrumento um exemplo de aplicativo Python

Experimente qualquer um desses tutoriais Python para ver o que a plataforma New Relic pode fazer com seus dados OTLP. Temos três tutoriais para você escolher, cada um usando o mesmo aplicativo de demonstração Flask. O aplicativo calcula o enésimo número na sequência de Fibonacci e gera rastreamento, métrica e log.

Ao trabalhar em qualquer um desses tutoriais, você pode aprender habilidades para ajudá-lo a configurar seu próprio aplicativo com OpenTelemetry e New Relic.

Depois de concluir qualquer um desses tutoriais, você poderá visualizar a métrica de amplitude em gráficos como estes.

Requisitos

Antes de começar, certifique-se de ter o seguinte:

Tutoriais

Embora cada tutorial use o mesmo aplicativo de demonstração, eles têm abordagens diferentes para ajudá-lo a se familiarizar com o OpenTelemetry e o New Relic.

Clique na guia abaixo do tutorial que deseja concluir.

Dica

Ao usar o OpenTelemetry, você terá duas opções para exportar dados do seu aplicativo para o New Relic via OTLP:

  • Diretamente do seu aplicativo para o New Relic

  • Seu aplicativo envia dados para um coletor OpenTelemetry, onde são exportados para o New Relic

    Esses tutoriais cobrem a primeira opção. Se você deseja exportar seus dados por meio de um coletor, consulte a documentação do coletor para obter detalhes.

Execute o aplicativo de demonstração pré-instrumento

Esta é uma ótima opção se você deseja que façamos a instrumentação para que você possa ver rapidamente como é enviar dados para o New Relic e visualizá-los em nossa interface.

  1. Em seu terminal, execute o seguinte para clonar o aplicativo de demonstração e navegue até o diretório python/Instrumented dos Guias de primeiros passos.

    git clone https://github.com/newrelic/newrelic-opentelemetry-examples.git
    cd newrelic-opentelemetry-examples/getting-started-guides/python/Instrumented
  2. Defina estas variáveis de ambiente para enviar dados para sua conta New Relic:

    • Certifique-se de usar seu .

    • Se a região do seu data center New Relic for a UE e não os EUA, defina o endpoint como: https://otlp.eu01.nr-data.net

      • OTEL_EXPORTER_OTLP_HEADERS=api-key=INSERT_YOUR_NEW_RELIC_LICENSE_KEY
      • OTEL_EXPORTER_OTLP_ENDPOINT=https://otlp.nr-data.net
  3. Defina esta variável de ambiente para nomear o serviço; é assim que você identificará seu serviço em sua conta New Relic:

    • OTEL_SERVICE_NAME=getting-started-python
  4. No mesmo diretório getting-started-guides/python/Instrumented/ , crie e ative um ambiente virtual, instale a biblioteca necessária e execute o aplicativo:

    • Mac OS:

      python3 -m venv venv
      source venv/bin/activate
      pip install -r requirements.txt
      python3 app.py
    • PowerShell:

      python -m venv venv
      .\venv\Scripts\Activate.ps1
      pip install -r requirements.txt
      python app.py
  5. Abra uma nova guia do terminal, alterne para o diretório getting-started-guides/python/Instrumented e execute o seguinte comando para gerar tráfego para o aplicativo:

    • Mac OS:

      ./load-generator.sh
    • PowerShell:

      .\load-generator.ps1

    Dica

    Alternativamente, você pode acessar o endpoint no browser neste URL: http://localhost:8080/fibonacci?n=INSERT_A_VALUE. Substitua INSERT_A_VALUE por um valor de 1 a 90. Para gerar um erro, insira um número inteiro fora do intervalo válido.

  6. Vá para one.newrelic.com > All capabilities > APM & services.

  7. Clique na sua nova entidade (serviço) chamada getting-started-python e explore a interface. Para obter mais dicas sobre o que procurar na interface, consulte Visualizar seus dados no New Relic.

  8. Quando terminar de visualizar seus dados na interface, encerre o aplicativo pressionando CONTROL+C em ambas as sessões do terminal.

Monitor o aplicativo de demonstração com o agente OpenTelemetry Python

Aqui está um tutorial diferente que também usa o mesmo aplicativo de demonstração, mas neste caso, você usará o agente OpenTelemetry Python para monitor automaticamente o aplicativo de demonstração. Você não precisa modificar o código-fonte do Python. Ao usar o agente, você pode começar rapidamente a exportar dados de amostra para o New Relic.

Observe, entretanto, que você precisará adicionar instrumentação personalizada para capturar níveis mais profundos de informações sobre o aplicativo, como log e métrica personalizada.

O agente de instrumentação automática é um pacote PyPI em série que injeta bytecode dinamicamente para capturar telemetria de bibliotecas e estruturas populares. Você também pode usá-lo para capturar dados como solicitações de entrada, chamadas HTTP de saída e chamadas de banco de dados. Ele pode ser anexado a qualquer aplicativo Python 3.

Dica

Consulte a documentação oficial do agente OpenTelemetry Python para opções de configuração adicionais.

Para monitor nosso aplicativo de demonstração com o agente OpenTelemetry Python:

  1. Execute estes dois comandos para baixar o repositório do aplicativo de demonstração e mudar para o seguinte diretório:

    git clone https://github.com/newrelic/newrelic-opentelemetry-examples.git
    cd newrelic-opentelemetry-examples/getting-started-guides/python/Uninstrumented
  2. Vá para nossa seção de referência de variáveis de ambiente abaixo para ver quais variáveis você precisa exportar e depois retorne a estas etapas.

  3. Em seguida, no mesmo diretório getting-started-guides/python/Uninstrumented/ , crie e ative um ambiente virtual:

    • Mac OS:

      python3 -m venv venv
      source venv/bin/activate
    • PowerShell:

      python -m venv venv
      .\venv\Scripts\Activate.ps1
  4. Agora você está pronto para instalar a biblioteca necessária:

    pip install flask
    pip install opentelemetry-instrumentation-flask
    pip install opentelemetry-exporter-otlp
    pip install opentelemetry-distro
  5. Continue em getting-started-guides/python/Uninstrumented/ para lançar o agente com o aplicativo:

    • Mac OS:

      opentelemetry-instrument python3 app.py
    • PowerShell:

      opentelemetry-instrument python app.py
  6. Gere tráfego para o aplicativo abrindo um novo terminal no diretório getting-started-guides/python/Uninstrumented e executando o gerador de carga:

    • Mac OS:

      ./load-generator.sh
    • PowerShell:

      .\load-generator.ps1

      Dica

      Alternativamente, você pode acessar o endpoint no browser neste URL: http://localhost:8080/fibonacci?n=INSERT_A_VALUE. Substitua INSERT_A_VALUE por um valor de 1 a 90. Para gerar um erro, insira um número inteiro fora do intervalo válido.

  7. Agora que você enviou alguns dados para o New Relic, veja nossas instruções sobre como visualizar os dados na interface.

  8. Quando terminar de visualizar seus dados na interface, encerre o aplicativo pressionando CONTROL+C em ambas as sessões do terminal.

Configure o aplicativo de demonstração manualmente

O tutorial anterior ajudou você a explorar a instrumentação automática com o agente OpenTelemetry Python. Este tutorial mostrará como usar instrumentação personalizada para ter mais controle sobre a telemetria coletada. A seguir, você verá como configurar o OpenTelemetry SDK para exportar os dados para o New Relic.

Baixe o aplicativo de demonstração

Execute o seguinte para baixar nosso aplicativo de demonstração:

git clone https://github.com/newrelic/newrelic-opentelemetry-examples.git

Instale a biblioteca necessária

Para adicionar a biblioteca necessária:

  1. Acesse o diretório do aplicativo não instrumentado como ponto de partida para este tutorial. Ao final deste tutorial, o código deverá ser semelhante ao do diretório Instrumented .

    cd newrelic-opentelemetry-examples/getting-started-guides/python/Uninstrumented
  2. Crie e ative um ambiente virtual no diretório Uninstrumented :

    • Mac OS:

      python3 -m venv venv
      source venv/bin/activate
    • PowerShell:

      python -m venv venv
      .\venv\Scripts\Activate.ps1
  3. Instale o seguinte:

    pip install opentelemetry-api
    pip install opentelemetry-sdk
    pip install flask
    pip install opentelemetry-instrumentation-logging
    pip install opentelemetry-instrumentation-flask
    pip install opentelemetry-exporter-otlp
    pip install opentelemetry-distro

Configurar o SDK

  1. Em app.py, adicione as linhas destacadas abaixo ao top of the file. Altere o valor do atributo personalizado environment conforme necessário.

    ##########################
    # OpenTelemetry Settings #
    ##########################
    from opentelemetry.sdk.resources import Resource
    import uuid
    OTEL_RESOURCE_ATTRIBUTES = {
    "service.instance.id": str(uuid.uuid1()),
    "environment": "local"
    }
    from flask import Flask, jsonify, request
    app = Flask(__name__)
  2. Vá para nossa seção de referência de variáveis de ambiente abaixo para ver quais variáveis você precisa exportar e, em seguida, avance para a próxima etapa para adicionar a biblioteca de instrumentação.

Adicionar biblioteca de instrumentação: trace

Em app.py, insira o seguinte após o OpenTelemetry Settings que você adicionou:

##########
# Traces #
##########
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.trace.status import Status, StatusCode
# Initialize tracing and an exporter that can send data to an OTLP endpoint
# SELECT * FROM Span WHERE instrumentation.provider='opentelemetry'
trace.set_tracer_provider(TracerProvider(resource=Resource.create(OTEL_RESOURCE_ATTRIBUTES)))
trace.get_tracer_provider().add_span_processor(BatchSpanProcessor(OTLPSpanExporter()))

Adicionar biblioteca de instrumentação: métrica

Em app.py adicione o seguinte após a seção Traces adicionada na Etapa D:

###########
# Metrics #
###########
from opentelemetry import metrics
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
# Initialize metering and an exporter that can send data to an OTLP endpoint
# SELECT count(`http.server.active_requests`) FROM Metric FACET `service.name` TIMESERIES
metrics.set_meter_provider(MeterProvider(resource=Resource.create(OTEL_RESOURCE_ATTRIBUTES), metric_readers=[PeriodicExportingMetricReader(OTLPMetricExporter())]))
metrics.get_meter_provider()
fib_counter = metrics.get_meter("opentelemetry.instrumentation.custom").create_counter("fibonacci.invocations", unit="1", description="Measures the number of times the fibonacci method is invoked.")

Adicionar biblioteca de instrumentação: log

Em app.py, adicione o seguinte após a seção Metrics . Isso importará o módulo de registro e definirá o nível de registro basicConfig como DEBUG:

########
# Logs # - OpenTelemetry Logs are still in the experimental state, so function names may change in the future
########
import logging
logging.basicConfig(level=logging.DEBUG)
from opentelemetry import _logs
from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
# Initialize logging and an exporter that can send data to an OTLP endpoint by attaching OTLP handler to root logger
# SELECT * FROM Log WHERE instrumentation.provider='opentelemetry'
_logs.set_logger_provider(LoggerProvider(resource=Resource.create(OTEL_RESOURCE_ATTRIBUTES)))
logging.getLogger().addHandler(LoggingHandler(logger_provider=_logs.get_logger_provider().add_log_record_processor(BatchLogRecordProcessor(OTLPLogExporter()))))

Adicionar instrumentação Flask

Em app.py adicione as linhas destacadas abaixo, após a seção Logs . Isso ajuda a vincular períodos para distributed tracing e contexto de login:

#####################
# Flask Application #
#####################
from flask import Flask, jsonify, request
from opentelemetry.instrumentation.flask import FlaskInstrumentor
app = Flask(__name__)
FlaskInstrumentor().instrument_app(app)

Instrumentação trace customizada: Crie um intervalo customizado

Você pode criar os spans que desejar e cabe a você anotar seus spans com atributos em operações específicas. O atributo definido fornecerá contexto adicional sobre a operação específica que você está acompanhando, como resultados ou propriedades da operação.

Em app.py, insira as linhas destacadas abaixo para iniciar um novo intervalo chamado /fibonacci que faz o seguinte:

  • Captura dados sobre a execução deste método

  • Define um atributo que armazena o valor de n da solicitação do usuário

    @app.route("/fibonacci")
    @trace.get_tracer("opentelemetry.instrumentation.custom").start_as_current_span("/fibonacci")
    def fibonacci():
    args = request.args
    x = int(args.get("n"))
    error_message = "n must be 1 <= n <= 90."
    trace.get_current_span().set_attribute("fibonacci.n", x)
    try:
    assert 1 <= x <= 90
    array = [0, 1]
    for n in range(2, x + 1):
    array.append(array[n - 1] + array[n - 2])
    trace.get_current_span().set_attribute("fibonacci.result", array[x])
    return jsonify(n=x, result=array[x])
    except AssertionError:
    return jsonify({"message": error_message})
    app.run(host='0.0.0.0', port=8080)

Instrumentação trace customizada: Registrar uma exceção

Você pode querer registrar as exceções à medida que elas acontecem. Recomendamos que você faça isso em conjunto com a configuração do status do intervalo.

  1. Para definir o código de status do intervalo como ERROR quando ocorrer uma exceção, você usará os módulos Status e StatusCode do opentelemetry.trace.status package adicionado na etapa D:

    ##########
    # Traces #
    ##########
    from opentelemetry import trace
    from opentelemetry.sdk.trace import TracerProvider
    from opentelemetry.sdk.trace.export import BatchSpanProcessor
    from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
    from opentelemetry.trace.status import Status, StatusCode
  2. Em seguida, insira as linhas destacadas abaixo para registrar a exceção, que aparecerá como um evento span no New Relic, e defina o status do span como ERROR:

    @app.route("/fibonacci")
    @trace.get_tracer("opentelemetry.instrumentation.custom").start_as_current_span("/fibonacci")
    def fibonacci():
    args = request.args
    x = int(args.get("n"))
    error_message = "n must be 1 <= n <= 90."
    trace.get_current_span().set_attribute("fibonacci.n", x)
    try:
    assert 1 <= x <= 90
    array = [0, 1]
    for n in range(2, x + 1):
    array.append(array[n - 1] + array[n - 2])
    trace.get_current_span().set_attribute("fibonacci.result", array[x])
    return jsonify(n=x, result=array[x])
    except AssertionError:
    trace.get_current_span().record_exception(exception=Exception, attributes={"exception.type": "AssertionError", "exception.message": error_message})
    trace.get_current_span().set_status(Status(StatusCode.ERROR, error_message))
    return jsonify({"message": error_message})
    app.run(host='0.0.0.0', port=8080)

Instrumentação métrica personalizada: Adicionar um contador de métrica personalizado

Métricas são um tipo de dados de telemetria realmente úteis porque combinam medições individuais em agregações e produzem dados constantes em função da carga do sistema. Você pode usar esses dados em conjunto com períodos para ajudar a identificar tendências e fornecer telemetria de tempo de execução do aplicativo. Você também pode anotar qualquer métrica com um atributo para ajudar a descrever qual subdivisão das medidas a métrica representa.

A API OpenTelemetry métrica define uma série de instrumentos, que registram medidas que são agregadas pelo SDK métrica e exportadas fora do processo. Existem dois tipos de instrumento:

  • Síncrono: Este instrumento registra as medições à medida que ocorrem
  • Assíncrono: Este instrumento registra um retorno de chamada, que é invocado apenas uma vez por coleta e não possui contexto associado
  1. Na etapa E, você adicionou a linha destacada abaixo, que criará um contador:

    ###########
    # Metrics #
    ###########
    from opentelemetry import metrics
    from opentelemetry.sdk.metrics import MeterProvider
    from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
    from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
    # Initialize metering and an exporter that can send data to an OTLP endpoint
    # SELECT count(`http.server.active_requests`) FROM Metric FACET `service.name` TIMESERIES
    metrics.set_meter_provider(MeterProvider(resource=Resource.create(OTEL_RESOURCE_ATTRIBUTES), metric_readers=[PeriodicExportingMetricReader(OTLPMetricExporter())]))
    metrics.get_meter_provider()
    fib_counter = metrics.get_meter("opentelemetry.instrumentation.custom").create_counter("fibonacci.invocations", unit="1", description="Measures the number of times the fibonacci method is invoked.")
  2. A seguir, adicione as linhas destacadas abaixo para usar o contador que você acabou de criar para medir:

  • O número de vezes que esta função é executada com sucesso

  • O número de vezes que ele falha ao executar

    Observe que o contador será zerado sempre que você reiniciar o aplicativo.

    @app.route("/fibonacci")
    @trace.get_tracer("opentelemetry.instrumentation.custom").start_as_current_span("/fibonacci")
    def fibonacci():
    args = request.args
    x = int(args.get("n"))
    error_message = "n must be 1 <= n <= 90."
    trace.get_current_span().set_attribute("fibonacci.n", x)
    try:
    assert 1 <= x <= 90
    array = [0, 1]
    for n in range(2, x + 1):
    array.append(array[n - 1] + array[n - 2])
    trace.get_current_span().set_attribute("fibonacci.result", array[x])
    fib_counter.add(1, {"fibonacci.valid.n": "true"})
    return jsonify(n=x, result=array[x])
    except AssertionError:
    trace.get_current_span().record_exception(exception=Exception, attributes={"exception.type": "AssertionError", "exception.message": error_message})
    trace.get_current_span().set_status(Status(StatusCode.ERROR, error_message))
    fib_counter.add(1, {"fibonacci.valid.n": "false"})
    return jsonify({"message": error_message})
    app.run(host='0.0.0.0', port=8080)

Instrumentação de log customizada

O status do sinal de log no OpenTelemetry Python é atualmente experimental.

Em app.py, adicione as linhas destacadas abaixo para:

  • Registre um log de nível INFO para os valores de entrada e saída

  • Registre um log de nível ERROR quando o valor de entrada estiver fora do intervalo válido

    @app.route("/fibonacci")
    @trace.get_tracer("opentelemetry.instrumentation.custom").start_as_current_span("/fibonacci")
    def fibonacci():
    args = request.args
    x = int(args.get("n"))
    error_message = "n must be 1 <= n <= 90."
    trace.get_current_span().set_attribute("fibonacci.n", x)
    try:
    assert 1 <= x <= 90
    array = [0, 1]
    for n in range(2, x + 1):
    array.append(array[n - 1] + array[n - 2])
    trace.get_current_span().set_attribute("fibonacci.result", array[x])
    fib_counter.add(1, {"fibonacci.valid.n": "true"})
    logging.info("Compute fibonacci(" + str(x) + ") = " + str(array[x]))
    return jsonify(n=x, result=array[x])
    except AssertionError:
    trace.get_current_span().record_exception(exception=Exception, attributes={"exception.type": "AssertionError", "exception.message": error_message})
    trace.get_current_span().set_status(Status(StatusCode.ERROR, error_message))
    fib_counter.add(1, {"fibonacci.valid.n": "false"})
    logging.error("Failed to compute fibonacci(" + str(x) + ")")
    return jsonify({"message": error_message})
    app.run(host='0.0.0.0', port=8080)

Exercite o aplicativo para gerar algum tráfego

Você está pronto para enviar alguns dados para a New Relic!

  1. No terminal, confirme que você está no diretório getting-started-guides/python/Uninstrumented e execute o aplicativo:

    • Mac OS:

      python3 app.py
    • PowerShell:

      python app.py
  2. Gere tráfego para o aplicativo abrindo uma nova guia de terminal no diretório getting-started-guides/python/Uninstrumented e executando o gerador de carga:

    • Mac OS:

      ./load-generator.sh
    • PowerShell:

      .\load-generator.ps1

    Dica

    Alternativamente, você pode acessar o endpoint no browser neste URL: http://localhost:8080/fibonacci?n=INSERT_A_VALUE. Substitua INSERT_A_VALUE por um valor de 1 a 90. Para gerar um erro, insira um número inteiro fora do intervalo válido.

  3. Agora que você enviou alguns dados para o New Relic, veja nossas instruções sobre como visualizar os dados na interface.

Veja seus dados de demonstração no New Relic

Não importa qual tutorial você concluiu, você pode seguir as dicas abaixo para encontrar seus dados na interface do New Relic.

Observe que se você seguiu o Tutorial 2: monitor o aplicativo demo com o agente OpenTelemetry Python:, você não verá os dados personalizados (como a métrica personalizada e o log), pois precisará adicionar manualmente a instrumentação personalizada para capturar dados mais granulares.

  1. Vá para

    one.newrelic.com > All capabilities > APM & services

    .

  2. Clique na sua nova entidade (serviço) chamada getting-started-python (ou qualquer nome que você forneceu).

  3. Confira os detalhes nas seções de cada tipo de dados.

Dica

Se você estiver usando o Microsoft Windows e não vir os dados em sua conta New Relic, verifique se você permitiu o tráfego através do firewall.

Traces

Depois de chegar à entidade getting-started-python no New Relic:

  1. Na seção

    Monitor

    do painel esquerdo, clique em

    Distributed tracing

    e depois clique no grupo trace /fibonacci.

  2. A partir daí, encontre um trace com erro e clique para abri-lo:

  3. Depois de abrir o trace , clique em Show in-process spans e, em seguida, clique no intervalo resultante, que abrirá um painel de detalhes à direita. Para ver a exceção que você registrou quando uma entrada do usuário é inválida, clique em View span events:

Se você concluiu o tutorial de instrumentação manual, veja como será a aparência da exceção registrada como um intervalo no New Relic:

Para visualizar detalhes adicionais definidos, como o atributo do intervalo, o nome do intervalo e o código de status, clique na guia Attributes . Este painel também é onde você pode visualizar metadados adicionais que são coletados automaticamente pela biblioteca de instrumentação usada neste guia, bem como metadados anexados pela New Relic:

Para obter mais detalhes sobre como visualizar seus dados, consulte OpenTelemetry na interface do New Relic

Métrica

Depois de chegar à entidade getting-started-python no New Relic, você poderá ver uma lista de todas as métricas coletadas, como seu atributo de contador personalizado.

Explorador de métricas

Esta é uma ferramenta que permite ver uma lista das suas métricas.

  1. No painel esquerdo, selecione Data > Metrics explorer e selecione fibonacci.invocations.

  2. Em Dimensions, visualize o atributo que você coletou junto com sua métrica personalizada e clique em fibonacci.valid.n.

Saiba mais em nossa documentação sobre a visualização do explorador métrico.

Registro

Aqui é onde acessar seu log:

Você também verá o login em seu terminal:

De volta à sua visualização de logs, selecione um log e você verá um painel aberto com a mensagem do log e atributos adicionais que foram coletados, como os span e trace ids associados, bem como os metadados injetados pelo New Relic:

Você pode navegar até o distributed trace correlacionado clicando neste pequeno ícone azul:

Isso abrirá um painel que exibe o trace correlacionado, onde você poderá visualizar mais detalhes sobre o trace. Para obter mais informações sobre esta página, consulte OpenTelemetry na interface: página distributed tracing e Compreenda e use a interface distributed tracing :

Você também pode localizar o log correlacionado na visualização de rastreio distribuído. Ao selecionar um trace que possui um log correspondente, você o verá indicado como uma guia e poderá visualizar o log diretamente do trace sem precisar alternar as visualizações:

Saiba mais sobre a visualização de log aqui.

Referência: Variáveis de ambiente

Esta é uma lista de variáveis de ambiente que você deve exportar se estiver fazendo o tutorial 2 ou 3. Após terminar de exportar as variáveis, retorne aos tutoriais usando os links que seguem a lista de variáveis:

Depois de exportar as variáveis de ambiente listadas no recolhido acima, retorne ao tutorial e conclua a configuração:

Qual é o próximo?

Agora que você experimentou a instrumentação do OpenTelemetry e a configuração do SDK, você pode aplicar o que aprendeu para configurar seu próprio aplicativo ou serviço com o OpenTelemetry e o New Relic. Para saber mais, consulte Configurar seu próprio aplicativo ou serviço com OpenTelemetry.

Copyright © 2024 New Relic Inc.

This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.