Tutoriales de OpenTelemetry: instrumentación de una aplicación Python de muestra

Pruebe cualquiera de estos tutoriales de Python para ver qué puede hacer la plataforma New Relic con sus datos OTLP. Tenemos tres tutoriales entre los que puede elegir, cada uno de los cuales utiliza la misma aplicación de demostración Flask. La aplicación calcula el enésimo número de la secuencia de Fibonacci y genera traza, métrica y log.

Al seguir cualquiera de estos tutoriales, puede aprender habilidades que le ayudarán a configurar su propia aplicación con OpenTelemetry y New Relic.

Después de terminar cualquiera de estos tutoriales, podrá ver la amplitud métrica en gráficos como estos.

Requisitos

Antes de comenzar, asegúrese de tener lo siguiente:

Una cuenta New Relic: Regístrese para obtener una cuenta gratuita si aún no tiene una.
Python 3.8 o superior y pip (incluido en la versión 3.4 y posterior de Python): si aún no los tiene, consulte estas opciones de descarga.

Tutoriales

Aunque cada tutorial utiliza la misma aplicación de demostración, tienen diferentes enfoques para ayudarlo a familiarizarse con OpenTelemetry y New Relic.

Aplicación pre-instrumentada: ejecute nuestra aplicación de demostración pre-instrumentada para ver rápidamente los datos en nuestra UI.
Agente OpenTelemetry Python: monitor nuestra aplicación de demostración con el agente OpenTelemetry Python.
Configuración manual: instrumente nuestra aplicación de demostración manualmente.

Haga clic en la pestaña a continuación para ver el tutorial que desea completar.

Sugerencia

Cuando utilice OpenTelemetry, tendrá dos opciones para exportar datos desde su aplicación a New Relic a través de OTLP:

Directamente desde tu aplicación a New Relic
Su aplicación envía datos a un recopilador OpenTelemetry donde luego se exporta a New Relic
Estos tutoriales cubren la primera opción. Si desea exportar sus datos a través de un recopilador, consulte esta documentación del recopilador para obtener más detalles.

Ejecute la aplicación de demostración pre-instrumentada

Esta es una excelente opción si desea que hagamos la instrumentación para que pueda ver rápidamente cómo es enviar datos a New Relic y verlos en nuestra UI.

En su terminal, ejecute lo siguiente para clonar la aplicación de demostración y navegue hasta el directorio python/Instrumented de las Guías de introducción.
```
git clone https://github.com/newrelic/newrelic-opentelemetry-examples.git
cd newrelic-opentelemetry-examples/getting-started-guides/python/Instrumented
```
Configure estas variables de entorno para enviar datos a su cuenta New Relic:
- Asegúrate de utilizar tu .
- Si la región de su centro de datos New Relic es la UE y no los EE. UU., configure el extremo en: 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
Establezca esta variable de entorno para nombrar el servicio; así es como identificarás tu servicio en tu cuenta New Relic:
- OTEL_SERVICE_NAME=getting-started-python
En el mismo directorio getting-started-guides/python/Instrumented/ , cree y active un entorno virtual, instale la biblioteca requerida y ejecute la aplicación:
- Mac OS:
  python3 -m venv venv source venv/bin/activate pip install -r requirements.txt python3 app.py
- Potencia Shell:
  python -m venv venv .\venv\Scripts\Activate.ps1 pip install -r requirements.txt python app.py
Abra una nueva pestaña de terminal, cambie al directorio getting-started-guides/python/Instrumented y ejecute el siguiente comando para generar algo de tráfico a la aplicación:
- Mac OS:
  ./load-generator.sh
- Potencia Shell:
  .\load-generator.ps1
Sugerencia
Alternativamente, puede llegar al extremo en el browser en esta URL: http://localhost:8080/fibonacci?n=INSERT_A_VALUE. Reemplace INSERT_A_VALUE con un valor de 1 a 90. Para generar un error, inserte un número entero fuera del rango válido.
Vaya a one.newrelic.com > All capabilities > APM & services.
Haga clic en su nueva entidad (servicio) llamada getting-started-python y explore la UI. Para obtener más consejos sobre qué buscar en la UI, consulte Ver sus datos en New Relic.
Cuando haya terminado de ver sus datos en la UI, cierre la aplicación presionando CONTROL+C en ambas sesiones de terminal.

Monitor la aplicación de demostración con el agente OpenTelemetry Python

Aquí hay un tutorial diferente que también usa la misma aplicación de demostración, pero en este caso, usará el agente OpenTelemetry Python para monitor automáticamente la aplicación de demostración. No es necesario modificar el código fuente de Python. Al utilizar el agente, puede comenzar rápidamente a exportar datos de muestra a New Relic.

Sin embargo, tenga en cuenta que deberá agregar instrumentación personalizada para capturar niveles más profundos de información sobre la aplicación, como registros y métricas personalizadas.

El agente de instrumentación automática es un paquete PyPI de serie que inyecta dinámicamente código de bytes para capturar telemetría de bibliotecas y marcos populares. También puede usarlo para capturar datos como solicitudes entrantes, llamadas HTTP salientes y llamadas de base de datos. Se puede adjuntar a cualquier aplicación Python 3.

Sugerencia

Consulte la documentación oficial del agente OpenTelemetry Python para obtener opciones de configuración adicionales.

Para monitor nuestra aplicación de demostración con el agente OpenTelemetry Python:

Ejecute estos dos comandos para descargar el repositorio de la aplicación de demostración y cambiar al siguiente directorio:

git clone https://github.com/newrelic/newrelic-opentelemetry-examples.git
cd newrelic-opentelemetry-examples/getting-started-guides/python/Uninstrumented

Vaya a nuestra sección de referencia de variables de entorno a continuación para ver qué variables necesita exportar y luego volver a estos pasos.
Luego, en el mismo directorio getting-started-guides/python/Uninstrumented/ , cree y active un entorno virtual:
- Mac OS:
  python3 -m venv venv source venv/bin/activate
- Potencia Shell:
  python -m venv venv .\venv\Scripts\Activate.ps1

Ahora está listo para instalar la biblioteca requerida:

pip install flask
pip install opentelemetry-instrumentation-flask
pip install opentelemetry-exporter-otlp
pip install opentelemetry-distro

Continúe en getting-started-guides/python/Uninstrumented/ para lanzar el agente con la aplicación:
- Mac OS:
  opentelemetry-instrument python3 app.py
- Potencia Shell:
  opentelemetry-instrument python app.py
Genere tráfico a la aplicación abriendo una nueva terminal en el directorio getting-started-guides/python/Uninstrumented y ejecutando el generador de carga:
- Mac OS:
  ./load-generator.sh
- Potencia Shell:
  .\load-generator.ps1
  Sugerencia
  Alternativamente, puede llegar al extremo en el browser en esta URL: http://localhost:8080/fibonacci?n=INSERT_A_VALUE. Reemplace INSERT_A_VALUE con un valor de 1 a 90. Para generar un error, inserte un número entero fuera del rango válido.
Ahora que ha enviado algunos datos a New Relic, consulte nuestras instrucciones sobre cómo ver los datos en la UI.
Cuando haya terminado de ver sus datos en la UI, cierre la aplicación presionando CONTROL+C en ambas sesiones de terminal.

Configure la aplicación de demostración manualmente

El tutorial anterior le ayudó a explorar la instrumentación automática con el agente OpenTelemetry Python. Este tutorial le mostrará cómo utilizar instrumentación personalizada para tener más control sobre la telemetría que recopila. Luego, verá cómo configurar el SDK de OpenTelemetry para exportar los datos a New Relic.

Descargue la aplicación de demostración

Ejecute lo siguiente para descargar nuestra aplicación de demostración:

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

Instalar la biblioteca requerida

Para agregar la biblioteca requerida:

Vaya al directorio de la aplicación no instrumentada como punto de partida para este tutorial. Al final de este tutorial, el código debería verse como el del directorio Instrumented .
```
cd newrelic-opentelemetry-examples/getting-started-guides/python/Uninstrumented
```
Cree y active un entorno virtual en el directorio Uninstrumented :
- Mac OS:
  python3 -m venv venv source venv/bin/activate
- Potencia Shell:
  python -m venv venv .\venv\Scripts\Activate.ps1

Instale lo siguiente:

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 el SDK

En app.py, agregue las líneas resaltadas a continuación al top of the file. Cambie el valor del atributo personalizado environment según sea necesario.

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

Vaya a nuestra sección de referencia de variables de entorno a continuación para ver qué variables necesita exportar y luego avance al siguiente paso para agregar la biblioteca de instrumentación.

Añadir instrumentación biblioteca: traza

En app.py, inserte lo siguiente después del OpenTelemetry Settings que agregó:

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

Agregar biblioteca de instrumentación: métrica

En app.py agregue lo siguiente después de la sección Traces que agregó en el Paso 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.")

Agregar biblioteca de instrumentación: log

En app.py, agregue lo siguiente después de la sección Metrics . Esto importará el módulo de registro y establecerá el nivel de registro basicConfig en 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()))))

Agregar instrumentación de matraz

En app.py agregue las líneas resaltadas a continuación, después de la sección Logs . Esto ayuda a vincular tramos para rastreo distribuido y contexto de inicio de sesión:

#####################
# Flask Application #
#####################
from flask import Flask, jsonify, request
from opentelemetry.instrumentation.flask import FlaskInstrumentor

app = Flask(__name__)
FlaskInstrumentor().instrument_app(app)

Traza instrumentación personalizada: Crear un tramo personalizado

Puede crear los intervalos que desee y depende de usted anotar sus intervalos con atributos en operaciones específicas. El atributo que establezca proporcionará contexto adicional sobre la operación específica que está rastreando, como resultados o propiedades de la operación.

En app.py, inserte las líneas resaltadas a continuación para iniciar un nuevo intervalo llamado /fibonacci que hace lo siguiente:

Captura datos sobre la ejecución de este método.

Establece un atributo que almacena el valor de n de la solicitud del usuario.

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

Instrumentación de traza personalizada: Registrar una excepción

Es posible que desee registrar las excepciones a medida que ocurren. Le recomendamos hacer esto junto con la configuración del estado del intervalo.

Para establecer el código de estado del intervalo en ERROR cuando se produce una excepción, utilizará los módulos Status y StatusCode del opentelemetry.trace.status package que agregó en el paso 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

A continuación, inserte las líneas resaltadas a continuación para registrar la excepción, que se mostrará como un evento de intervalo en New Relic, y establezca el estado del intervalo en 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)

Instrumentación métrica personalizada: Añadir un contador métrica personalizada

Las métricas son un tipo telemetry data que son realmente útiles porque combinan mediciones individuales en agregaciones y producen datos que son constantes en función de la carga del sistema. Puede utilizar estos datos junto con intervalos para ayudar a detectar tendencias y proporcionar telemetría en tiempo de ejecución de la aplicación. También puede anotar cualquier métrica con un atributo para ayudar a describir qué subdivisión de las medidas representa la métrica.

La API de OpenTelemetry métrica define una serie de instrumentados, que registran mediciones que son agregadas por el SDK de métrica y exportadas fuera de proceso. Hay dos tipos de instrumentado:

Síncrono: Estos instrumentados registran las mediciones a medida que ocurren.
Asincrónico: Estos instrumentados registran un callback, el cual se invoca solo una vez por colección y no tiene contexto asociado

En el paso E, agregó la línea resaltada a continuación, que creará un 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 continuación, agregue las líneas resaltadas a continuación para usar el contador que acaba de crear para medir:

El número de veces que esta función se ejecuta correctamente

El número de veces que no se ejecuta

Tenga en cuenta que el contador se restablecerá a 0 cada vez que reinicie su aplicación.

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

Instrumentación log personalizados

El estado de la señal de registro en OpenTelemetry Python es actualmente experimental.

En app.py, agregue las líneas resaltadas a continuación para:

Registre un log de nivel INFO para los valores de entrada y salida.

Registre un log de nivel ERROR cuando el valor de entrada esté fuera del rango 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)

Ejercite la aplicación para generar algo de tráfico.

¡Estás listo para enviar algunos datos a New Relic!

En la terminal, confirma que estás en el directorio getting-started-guides/python/Uninstrumented y luego ejecuta la aplicación:
- Mac OS:
  python3 app.py
- Potencia Shell:
  python app.py
Genere tráfico a la aplicación abriendo una nueva pestaña de terminal en el directorio getting-started-guides/python/Uninstrumented y ejecutando el generador de carga:
- Mac OS:
  ./load-generator.sh
- Potencia Shell:
  .\load-generator.ps1
Sugerencia
Alternativamente, puede llegar al extremo en el browser en esta URL: http://localhost:8080/fibonacci?n=INSERT_A_VALUE. Reemplace INSERT_A_VALUE con un valor de 1 a 90. Para generar un error, inserte un número entero fuera del rango válido.
Ahora que ha enviado algunos datos a New Relic, consulte nuestras instrucciones sobre cómo ver los datos en la UI.

Vea los datos de su demostración en New Relic

No importa qué tutorial haya completado, puede seguir los consejos a continuación para encontrar sus datos en la UI de New Relic.

Tenga en cuenta que si siguió el Tutorial 2: monitor la aplicación de demostración con el agente OpenTelemetry Python:, no verá los datos personalizados (como la métrica personalizada y el registro), ya que necesita agregar manualmente instrumentación personalizada para capturar datos más granulares.

Vaya a
one.newrelic.com > All capabilities > APM & services
.
Haga clic en su nueva entidad (servicio) llamada getting-started-python (o cualquier nombre que haya proporcionado).
Consulte los detalles en las secciones para cada tipo de datos.

Sugerencia

Si está utilizando Microsoft Windows y no ve datos en su cuenta New Relic, verifique que haya permitido el tráfico a través del firewall.

Traza

Una vez que hayas llegado a la entidad getting-started-python en New Relic:

En la sección
Monitor
del panel izquierdo, haga clic en
Distributed tracing
y luego haga clic en el grupo de trazas /fibonacci .
Desde allí, busca una traza con un error y haz clic para abrirla:
Una vez que tenga la traza abierta, haga clic en Show in-process spans y luego haga clic en el tramo resultante, lo que abrirá un panel de detalles a la derecha. Para ver la excepción que registró cuando la entrada de un usuario no es válida, haga clic en View span events:

Si completó el tutorial de instrumentación manual, así es como se verá la excepción que registró como un lapso en New Relic:

Para ver detalles adicionales que configuró, como el atributo de intervalo, el nombre del intervalo y el código de estado, haga clic en la pestaña Attributes . En este panel también puede ver metadatos adicionales que recopila automáticamente la biblioteca de instrumentación que utilizó en esta guía, así como los metadatos adjuntos de New Relic:

Para obtener más detalles sobre cómo ver sus datos, consulte OpenTelemetry en la UIde New Relic

Métrica

Una vez que haya llegado a la entidad getting-started-python en New Relic, podrá ver una lista de todas las métricas recopiladas, como su atributo de contador personalizado.

Explorador métrico

Esta es una herramienta que te permite ver una lista de tus métricas.

En el panel izquierdo, seleccione Data > Metrics explorer y luego seleccione fibonacci.invocations.
En Dimensions, vea el atributo que recopiló junto con su métrica personalizada y luego haga clic en fibonacci.valid.n.

Conozca más en nuestra documentación sobre la vista del explorador métrica.

Registro

Aquí es donde acceder a su registro:

También verás iniciar sesión en tu terminal:

De vuelta en su vista de registro, seleccione un log y verá un panel abierto con el mensaje de registro y los atributos adicionales que se recopilaron, como el intervalo asociado y los identificadores de traza, así como los metadatos inyectados por New Relic:

Puedes navegar al rastreo distribuido correlacionado haciendo clic en este pequeño icono azul:

Esto abrirá un panel que muestra la traza correlacionada, donde podrá ver más detalles sobre la traza. Para obtener más información sobre esta página, consulte OpenTelemetry en la UI: página de rastreo distribuido y Comprender y utilizar la UIde rastreo distribuido:

También puede encontrar el log correlacionado desde la vista de rastreo distribuido. Cuando selecciones una traza que tenga su correspondiente log, lo verás indicado como una pestaña, y podrás visualizar el log directamente desde la traza sin tener que cambiar de vista:

Obtenga más información sobre la vista de registro aquí.

Referencia: variables de entorno

Esta es una lista de las variables de entorno que debes exportar si estás realizando el tutorial 2 o 3. Una vez que termine de exportar las variables, regrese a los tutoriales utilizando los enlaces que siguen a la lista de variables:

OTEL_EXPORTER_OTLP_HEADERS=api-key=YOUR_LICENSE_KEY

Encabezados: Esto determina a qué cuenta de New Relic se enviarán sus datos. Reemplace YOUR_LICENSE_KEY con su
.

OTEL_EXPORTER_OTLP_ENDPOINT=https://otlp.nr-data.net (Para EE. UU.)

Este es el extremo al que se exportará la telemetría de su aplicación. Exportar datos al extremo OTLP de New Relic. Si estás en la UE, utiliza este extremo: OTEL_EXPORTER_OTLP_ENDPOINT=https://otlp.eu01.nr-data.net

OTEL_SERVICE_NAME=getting-started-python

Este es el nombre que asocia la telemetría de su aplicación con una entidad en New Relic. En este tutorial lo llamamos getting-started-python, pero puedes llamarlo como quieras.

OTEL_RESOURCE_ATTRIBUTES=service.instance.id=INSERT_YOUR_OWN_ID_HERE

Reemplace INSERT_YOUR_OWN_ID_HERE con un ID único de la instancia. Por ejemplo, podrías usar 1234. Para obtener más detalles, consulte Convenciones semánticas de recursos de OpenTelemetry.

OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT=4095

Establecer un límite en la longitud máxima del valor del atributo evitará que los datos de extensión se eliminen si exceden el límite de New Relic.

OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE=Delta

New Relic admite métrica en temporalidad delta en lugar del valor predeterminado de acumulativa.

OTEL_EXPORTER_OTLP_METRICS_DEFAULT_HISTOGRAM_AGGREGATION=base2_exponential_bucket_histogram

(Recomendado) Agregación de histogramas: utilice un histograma exponencial en lugar del histograma de depósito explícito predeterminado para una mejor compresión de datos.

OTEL_LOGS_EXPORTER=otlp

Habilite la exportación log a través de OTLP. La exportación log está deshabilitada de forma predeterminada.

OTEL_EXPORTER_OTLP_COMPRESSION=gzip

(Recomendado) Configurar la compresión gzip le permite maximizar la cantidad de datos que puede enviar por solicitud. Nuestro tamaño de carga útil máximo permitido es 1 MB (10^6 bytes). La compresión Gzip tiene un buen rendimiento y reduce la salida de datos.

OTEL_EXPERIMENTAL_EXPORTER_OTLP_RETRY_ENABLED=true

(Recomendado) Habilite el reintento de exportación experimental para ayudar a hacer frente a la falta de confiabilidad de Internet.

OTEL_EXPERIMENTAL_RESOURCE_DISABLED_KEYS=process.command_line

(Recomendado) Esto deshabilita el atributo de recurso process.command_line , que a menudo excede el límite de longitud máxima del atributo New Relic y puede contener información confidencial.

Una vez que haya exportado las variables de entorno enumeradas en el colapsador anterior, regrese al tutorial y complete la configuración:

Tutorial 2: monitor la aplicación de demostración con el agente OpenTelemetry Python
Tutorial 3: configurar la aplicación de demostración manualmente

¿Que sigue?

Ahora que ha experimentado con la instrumentación de OpenTelemetry y la configuración del SDK, puede aplicar lo que ha aprendido para configurar su propia aplicación o servicio con OpenTelemetry y New Relic. Para obtener más información, consulte Configure su propia aplicación o servicio con OpenTelemetry.

Te ofrecemos esta traducción automática para facilitar la lectura.

Tutoriales de OpenTelemetry: instrumentación de una aplicación Python de muestra

Requisitos

Tutoriales

Sugerencia

Ejecute la aplicación de demostración pre-instrumentada

Sugerencia

Monitor la aplicación de demostración con el agente OpenTelemetry Python

Sugerencia

Sugerencia

Configure la aplicación de demostración manualmente

Descargue la aplicación de demostración

Instalar la biblioteca requerida

Configurar el SDK

Añadir instrumentación biblioteca: traza

Agregar biblioteca de instrumentación: métrica

Agregar biblioteca de instrumentación: log

Agregar instrumentación de matraz

Traza instrumentación personalizada: Crear un tramo personalizado

Instrumentación de traza personalizada: Registrar una excepción

Instrumentación métrica personalizada: Añadir un contador métrica personalizada

Instrumentación log personalizados

Ejercite la aplicación para generar algo de tráfico.

Sugerencia

Vea los datos de su demostración en New Relic

Sugerencia

Traza

Métrica

Explorador métrico

Registro

Referencia: variables de entorno

Haga clic aquí para abrir la lista de variables de entorno.

¿Que sigue?

Te ofrecemos esta traducción automática para facilitar la lectura.

Tutoriales de OpenTelemetry: instrumentación de una aplicación Python de muestra

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

Tutoriales

Sugerencia

Ejecute la aplicación de demostración pre-instrumentada

Sugerencia

Monitor la aplicación de demostración con el agente OpenTelemetry Python

Sugerencia

Sugerencia

Configure la aplicación de demostración manualmente

Descargue la aplicación de demostración

Instalar la biblioteca requerida

Configurar el SDK

Añadir instrumentación biblioteca: traza

Agregar biblioteca de instrumentación: métrica

Agregar biblioteca de instrumentación: log

Agregar instrumentación de matraz

Traza instrumentación personalizada: Crear un tramo personalizado

Instrumentación de traza personalizada: Registrar una excepción

Instrumentación métrica personalizada: Añadir un contador métrica personalizada

Instrumentación log personalizados

Ejercite la aplicación para generar algo de tráfico.

Sugerencia

Vea los datos de su demostración en New Relic

Sugerencia

Traza

Métrica

Explorador métrico

Registro

Referencia: variables de entorno

¿Que sigue?

Requisitos