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:

Uma conta New Relic: Cadastre-se para obter uma conta gratuita se ainda não tiver uma.
Python 3.8 ou superior e pip (incluído no Python versão 3.4 e posterior): se você ainda não os possui, consulte estas opções de download.

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.

Aplicativo de pré-instrumento: Execute nosso aplicativo de demonstração de pré-instrumento para ver rapidamente os dados em nossa interface.
Agente OpenTelemetry Python: monitor nosso aplicativo de demonstração com o agente OpenTelemetry Python.
Configuração manual: instrumento nosso aplicativo de demonstração manualmente.

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.

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
```
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
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
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
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.
Vá para one.newrelic.com > All capabilities > APM & services.
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.
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:

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

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.
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

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

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
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.
Agora que você enviou alguns dados para o New Relic, veja nossas instruções sobre como visualizar os dados na interface.
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:

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
```
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

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

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

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.

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

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

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

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!

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
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.
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.

Vá para
one.newrelic.com > All capabilities > APM & services
.
Clique na sua nova entidade (serviço) chamada getting-started-python (ou qualquer nome que você forneceu).
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:

In the left pane's
Monitor
section, click
Distributed tracing
, and then click the /fibonacci trace group.
From there, find a trace with an error and click to open it:
Once you have the trace open, click Show in-process spans, and then click on the resulting span, which will open up a details panel to the right. To see the exception you recorded when a user input is invalid, click on 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.

No painel esquerdo, selecione Data > Metrics explorer e selecione fibonacci.invocations.
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:

OTEL_EXPORTER_OTLP_HEADERS=api-key=YOUR_LICENSE_KEY

Cabeçalhos: determina para qual conta New Relic seus dados serão enviados. Substitua YOUR_LICENSE_KEY pelo seu
.

OTEL_EXPORTER_OTLP_ENDPOINT=https://otlp.nr-data.net (Para os EUA)

Este é o endpoint para o qual a telemetria do seu aplicativo será exportada. Exporte dados para o endpoint OTLP da New Relic. Se você estiver na UE, use este endpoint: OTEL_EXPORTER_OTLP_ENDPOINT=https://otlp.eu01.nr-data.net

OTEL_SERVICE_NAME=getting-started-python

Este é o nome que associa a telemetria do seu aplicativo a uma entidade no New Relic. Neste tutorial vamos chamá-lo de getting-started-python, mas você pode chamá-lo do que quiser.

OTEL_RESOURCE_ATTRIBUTES=service.instance.id=INSERT_YOUR_OWN_ID_HERE

Substitua INSERT_YOUR_OWN_ID_HERE por um ID de instância exclusivo. Por exemplo, você poderia usar 1234. Para obter mais detalhes, consulte Convenções semânticas de recursos do OpenTelemetry.

OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT=4095

Definir um limite para o comprimento máximo do valor do atributo impedirá que os dados do intervalo sejam descartados se excederem o limite do atributo.

OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE=Delta

A New Relic suporta métrica na temporalidade delta em vez do padrão cumulativo.

OTEL_EXPORTER_OTLP_METRICS_DEFAULT_HISTOGRAM_AGGREGATION=base2_exponential_bucket_histogram

Agregação de histograma (recomendada): use o histograma exponencial em vez do histograma de intervalo explícito padrão para melhor compactação de dados.

OTEL_LOGS_EXPORTER=otlp

Habilite a exportação de log por OTLP. A exportação de log está desabilitada por padrão.

OTEL_EXPORTER_OTLP_COMPRESSION=gzip

(Recomendado) Definir a compactação gzip permite maximizar a quantidade de dados que você pode enviar por solicitação. Nosso tamanho máximo de carga útil permitido é 1 MB (10 ^ 6 bytes). A compactação Gzip tem bom desempenho e reduz a saída de dados.

OTEL_EXPERIMENTAL_EXPORTER_OTLP_RETRY_ENABLED=true

(Recomendado) Ative a nova tentativa de exportação experimental para ajudar a lidar com a falta de confiabilidade da Internet.

OTEL_EXPERIMENTAL_RESOURCE_DISABLED_KEYS=process.command_line

(Recomendado) Isso desativa o atributo de recurso process.command_line , que geralmente excede o limite máximo de comprimento do atributo New Relic e pode conter informações confidenciais.

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

Tutorial 2: monitor o aplicativo de demonstração com o agente OpenTelemetry Python
Tutorial 3: Configure o aplicativo de demonstração manualmente

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.

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

Tutoriais OpenTelemetry: instrumento um exemplo de aplicativo Python

Requisitos

Tutoriais

Dica

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

Dica

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

Dica

Dica

Configure o aplicativo de demonstração manualmente

Baixe o aplicativo de demonstração

Instale a biblioteca necessária

Configurar o SDK

Adicionar biblioteca de instrumentação: trace

Adicionar biblioteca de instrumentação: métrica

Adicionar biblioteca de instrumentação: log

Adicionar instrumentação Flask

Instrumentação trace customizada: Crie um intervalo customizado

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

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

Instrumentação de log customizada

Exercite o aplicativo para gerar algum tráfego

Dica

Veja seus dados de demonstração no New Relic

Dica

Traces

Métrica

Explorador de métricas

Registro

Referência: Variáveis de ambiente

Clique aqui para abrir a lista de variáveis de ambiente

Qual é o próximo?

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

Tutoriais OpenTelemetry: instrumento um exemplo de aplicativo Python

Requisitos .css-21sua1{background:none;border:none;width:0;padding:0;}

Tutoriais

Dica

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

Dica

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

Dica

Dica

Configure o aplicativo de demonstração manualmente

Baixe o aplicativo de demonstração

Instale a biblioteca necessária

Configurar o SDK

Adicionar biblioteca de instrumentação: trace

Adicionar biblioteca de instrumentação: métrica

Adicionar biblioteca de instrumentação: log

Adicionar instrumentação Flask

Instrumentação trace customizada: Crie um intervalo customizado

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

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

Instrumentação de log customizada

Exercite o aplicativo para gerar algum tráfego

Dica

Veja seus dados de demonstração no New Relic

Dica

Traces

Métrica

Explorador de métricas

Registro

Referência: Variáveis de ambiente

Qual é o próximo?

Requisitos