Compartir a través de

Uso de OpenTelemetry con Azure Functions

  • Artículo

Importante

La compatibilidad con OpenTelemetry para Azure Functions está actualmente en versión preliminar y la aplicación debe hospedarse en un Plan Consumo flexible para usar OpenTelemetry.

En este artículo se muestra cómo configurar la aplicación de funciones para exportar datos de registro y seguimiento en un formato OpenTelemetry. Azure Functions genera datos de telemetría en las ejecuciones de funciones tanto del proceso de host de Functions como del proceso de trabajo específico del lenguaje en el que se ejecuta el código de función. De manera predeterminada, estos datos de telemetría se envían a Application Insights mediante el SDK de Application Insights. Sin embargo, puede optar por exportar estos datos mediante la semántica de OpenTelemetry. Aunque todavía puede usar un formato OpenTelemetry para enviar los datos a Application Insights, ahora también puede exportar los mismos datos a cualquier otro punto de conexión compatible con OpenTelemetry.

Sugerencia

Dado que este artículo está dirigido al lenguaje de desarrollo que prefiera, recuerde elegir el idioma correcto en la parte superior del artículo.

Actualmente, no hay compatibilidad con OpenTelemetry optimizada para cliente para aplicaciones Java.

Actualmente, OpenTelemetry no es compatible con las aplicaciones en proceso de C#.

Puede obtener estas ventajas habilitando OpenTelemetry en la aplicación de funciones:

  • Correlación entre seguimientos y registros que se generan tanto en el host como en el código de la aplicación.
  • Generación coherente basada en estándares de datos de telemetría exportables.
  • Se integra con otros proveedores que pueden consumir datos compatibles con OpenTeleletry.

OpenTelemetry está habilitado en el nivel de aplicación de funciones, tanto en la configuración del host (host.json) como en el proyecto de código. Functions también proporciona una experiencia optimizada para el cliente para exportar datos de OpenTelemetry desde el código de función que se ejecuta en un proceso de trabajo específico del lenguaje.

1. Habilitación de OpenTelemetry en el host de Functions

Al habilitar la salida de OpenTelemetry en el archivo host.json de la aplicación de funciones, el host exporta la salida de OpenTelemetry independientemente de la pila de idioma que usa la aplicación.

Para habilitar la salida de OpenTelemetry desde el host de Functions, actualice el archivo host.json en el proyecto de código para agregar un elemento "telemetryMode": "openTelemetry" a la colección raíz. Con OpenTelemetry habilitado, el archivo host.json podría tener este aspecto:

{
    "version": "2.0",
    "logging": {
        "applicationInsights": {
            "samplingSettings": {
                "isEnabled": true,
                "excludedTypes": "Request"
            },
            "enableLiveMetricsFilters": true
        }
    },
    "telemetryMode": "openTelemetry"
}

2. Configuración de la aplicación

Cuando OpenTelemetry está habilitado en el archivo host.json, los puntos de conexión a los que se envían los datos se determinan en función de la configuración de la aplicación compatible con OpenTelemetry disponibles en las variables de entorno de la aplicación.

Cree una configuración de aplicación específica en la aplicación de funciones en función del destino de salida de OpenTelemetry. Cuando se proporciona la configuración de conexión para Application Insights y un exportador del protocolo OpenTelemetry (OTLP), los datos de OpenTelemetry se envían a ambos puntos de conexión.

APPLICATIONINSIGHTS_CONNECTION_STRING: la cadena de conexión de un área de trabajo de Application Insights. Cuando esta configuración existe, los datos de OpenTelemetry se envían a esa área de trabajo. Esta configuración es la misma que se usa para conectarse a Application Insights sin OpenTelemetry habilitado. Si la aplicación aún no tiene esta configuración, es posible que tenga que Habilitar la integración de Application Insights.

3. Habilitación de OpenTelemetry en la aplicación

Con el host de Functions configurado para usar OpenTelemetry, también debe actualizar el código de la aplicación para generar datos de OpenTelemetry. Habilitar OpenTelemetry tanto en el host como en el código de la aplicación permite una mejor correlación entre seguimientos y registros emitidos tanto por el proceso de host de Functions como por el proceso de trabajo del lenguaje.

La forma en que instrumenta la aplicación para usar OpenTelemetry depende del punto de conexión de OpenTelemetry de destino:

  1. Ejecute estos comandos para instalar los ensamblados necesarios en la aplicación:

    dotnet add package Microsoft.Azure.Functions.Worker.OpenTelemetry --version 1.0.0-preview1 
dotnet add package OpenTelemetry.Extensions.Hosting 
dotnet add package Azure.Monitor.OpenTelemetry.AspNetCore

  2. En el archivo de proyecto de Program.cs, agregue esta instrucción using:

    using Azure.Monitor.OpenTelemetry.AspNetCore;

  3. En el delegado ConfigureServices, agregue esta configuración de servicio:

    services.AddOpenTelemetry()
.UseFunctionsWorkerDefaults()
.UseAzureMonitor();

    Para exportar a ambos puntos de conexión de OpenTelemetry, llame tanto a UseAzureMonitor como a UseOtlpExporter.

Las optimizaciones de trabajo de Java aún no están disponibles para OpenTelemetry, por lo que no hay nada que configurar en el código Java.

  1. Instale estos paquetes de npm en el proyecto:

    npm install @opentelemetry/api 
npm install @opentelemetry/auto-instrumentations-node 
npm install @azure/monitor-opentelemetry-exporter 
npm install @azure/functions-opentelemetry-instrumentation

  1. Cree un archivo de código en el proyecto, copie y pegue el código siguiente en este nuevo archivo y guarde el archivo como src/index.js:

    const { AzureFunctionsInstrumentation } = require('@azure/functions-opentelemetry-instrumentation');
const { AzureMonitorLogExporter, AzureMonitorTraceExporter } = require('@azure/monitor-opentelemetry-exporter');
const { getNodeAutoInstrumentations, getResourceDetectors } = require('@opentelemetry/auto-instrumentations-node');
const { registerInstrumentations } = require('@opentelemetry/instrumentation');
const { detectResourcesSync } = require('@opentelemetry/resources');
const { LoggerProvider, SimpleLogRecordProcessor } = require('@opentelemetry/sdk-logs');
const { NodeTracerProvider, SimpleSpanProcessor } = require('@opentelemetry/sdk-trace-node');

const resource = detectResourcesSync({ detectors: getResourceDetectors() });

const tracerProvider = new NodeTracerProvider({ resource });
tracerProvider.addSpanProcessor(new SimpleSpanProcessor(new AzureMonitorTraceExporter()));
tracerProvider.register();

const loggerProvider = new LoggerProvider({ resource });
loggerProvider.addLogRecordProcessor(new SimpleLogRecordProcessor(new AzureMonitorLogExporter()));

registerInstrumentations({
    tracerProvider,
    loggerProvider,
    instrumentations: [getNodeAutoInstrumentations(), new AzureFunctionsInstrumentation()],
});

  2. Actualice el campo main del archivo package.json para incluir este nuevo archivo src/index.js, que podría tener este aspecto:

    "main": "src/{index.js,functions/*.js}"

  1. Cree un archivo de código en el proyecto, copie y pegue el código siguiente en este nuevo archivo y guarde el archivo como src/index.ts:

    import { AzureFunctionsInstrumentation } from '@azure/functions-opentelemetry-instrumentation';
import { AzureMonitorLogExporter, AzureMonitorTraceExporter } from '@azure/monitor-opentelemetry-exporter';
import { getNodeAutoInstrumentations, getResourceDetectors } from '@opentelemetry/auto-instrumentations-node';
import { registerInstrumentations } from '@opentelemetry/instrumentation';
import { detectResourcesSync } from '@opentelemetry/resources';
import { LoggerProvider, SimpleLogRecordProcessor } from '@opentelemetry/sdk-logs';
import { NodeTracerProvider, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-node';

const resource = detectResourcesSync({ detectors: getResourceDetectors() });

const tracerProvider = new NodeTracerProvider({ resource });
tracerProvider.addSpanProcessor(new SimpleSpanProcessor(new AzureMonitorTraceExporter()));
tracerProvider.register();

const loggerProvider = new LoggerProvider({ resource });
loggerProvider.addLogRecordProcessor(new SimpleLogRecordProcessor(new AzureMonitorLogExporter()));

registerInstrumentations({
    tracerProvider,
    loggerProvider,
    instrumentations: [getNodeAutoInstrumentations(), new AzureFunctionsInstrumentation()],
});

  2. Actualice el campo main del archivo package.json para incluir la salida de este nuevo archivo de src/index.ts, que podría tener este aspecto:

    "main": "dist/src/{index.js,functions/*.js}"

Importante

La salida de OpenTelemetry a Application Insights desde el trabajo de lenguaje no se admite actualmente para las aplicaciones de PowerShell. Es posible que quiera usar un punto de conexión de exportador de OTLP. Cuando el host está configurado para la salida de OpenTelemetry en Application Insights, los registros generados por el proceso de trabajo de PowerShell se siguen reenviando, pero el seguimiento distribuido no se admite en este momento.

Estas instrucciones solo se aplican a un exportador de OTLP:

  1. Agregue una configuración de aplicación denominada OTEL_FUNCTIONS_WORKER_ENABLED con el valor de True.

  2. Cree una carpeta a Modulesnivel de aplicación en la raíz de su aplicación y ejecute el siguiente comando:

    Save-Module -Name AzureFunctions.PowerShell.OpenTelemetry.SDK

    Esto instala el módulo AzureFunctions.PowerShell.OpenTelemetry.SDK necesario directamente en la aplicación. No puede usar el archivo requirements.psd1 para instalar automáticamente esta dependencia porque las dependencias administradas no se admiten actualmente en la versión preliminar del plan de consumo flexible.

  3. Agregue este código al archivo profile.ps1:

    Import-Module AzureFunctions.PowerShell.OpenTelemetry.SDK -Force -ErrorAction Stop 
Initialize-FunctionsOpenTelemetry

  1. Agregue esta entrada en el archivo requirements.txt :

    azure.monitor.opentelemetry

  2. Agregue este código al archivo de punto de entrada principal de function_app.py :

    from azure.monitor.opentelemetry import configure_azure_monitor 
configure_azure_monitor()

Consideraciones para OpenTelemetry

Al exportar los datos mediante OpenTelemetry, tenga en cuenta estas consideraciones actuales.

  • Cuando el host está configurado para usar OpenTelemetry, solo se exportan los registros y seguimientos. Las métricas de host no se exportan actualmente.

  • Actualmente no se puede ejecutar el proyecto de aplicación localmente mediante Core Tools cuando tenga OpenTelemetry habilitado en el host. Actualmente, debe implementar el código en Azure para validar las actualizaciones relacionadas con OpenTelemetry.

  • En este momento, solo se admiten desencadenadores HTTP y desencadenadores basados en EL SDK de Azure con salidas de OpenTelemetry.

Contenido relacionado

Supervisión de Azure FunctionsPlan de consumo flexible