Uso de OpenTelemetry con Azure Functions

Importante

La compatibilidad con OpenTelemetry para Azure Functions está actualmente en versión preliminar.

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

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.

Application Insights

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.

Exportar OTLP

OTEL_EXPORTER_OTLP_ENDPOINT: una dirección URL del punto de conexión del exportador de OTLP.

OTEL_EXPORTER_OTLP_HEADERS: (Opcional) lista de encabezados que se aplicarán a todos los datos salientes. Muchos puntos de conexión lo usan para pasar una clave de API.

Si el punto de conexión requiere que establezca otras variables de entorno, también debe agregarlas a la configuración de la aplicación. Para obtener más información, consulte la Documentación de configuración del exportador de OTLP.

Debe quitar la configuración APPLICATIONINSIGHTS_CONNECTION_STRING, a menos que también desee que la salida de OpenTelemetry del host se envíe a 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:

   Application Insights

   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  
   

   Exportar OTLP

   dotnet add package Microsoft.Azure.Functions.Worker.OpenTelemetry --version 1.0.0-preview1 
   dotnet add package OpenTelemetry.Extensions.Hosting 
   dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol   
   

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

   Application Insights

   using Azure.Monitor.OpenTelemetry.AspNetCore; 
   

   Exportar OTLP

   using OpenTelemetry; 
   

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

   Application Insights

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

   Exportar OTLP

   services.AddOpenTelemetry()
   .UseFunctionsWorkerDefaults()
   .UseOtlpExporter();
   

   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:

   Application Insights

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

   Exportar OTLP

   npm install @opentelemetry/api 
   npm install @opentelemetry/auto-instrumentations-node 
   npm install @opentelemetry/exporter-logs-otlp-http 
   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:

   Application Insights

   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()],
   });
   

   Exportar OTLP

   const { AzureFunctionsInstrumentation } = require('@azure/functions-opentelemetry-instrumentation');
   const { getNodeAutoInstrumentations, getResourceDetectors } = require('@opentelemetry/auto-instrumentations-node');
   const { OTLPLogExporter } = require('@opentelemetry/exporter-logs-otlp-http');
   const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
   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 OTLPTraceExporter()));
   tracerProvider.register();
   
   const loggerProvider = new LoggerProvider({ resource });
   loggerProvider.addLogRecordProcessor(new SimpleLogRecordProcessor(new OTLPLogExporter()));
   
   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:

   Application Insights

   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()],
   });
   

   Exportar OTLP

   import { AzureFunctionsInstrumentation } from '@azure/functions-opentelemetry-instrumentation';
   import { getNodeAutoInstrumentations, getResourceDetectors } from '@opentelemetry/auto-instrumentations-node';
   import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
   import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
   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 OTLPTraceExporter()));
   tracerProvider.register();
   
   const loggerProvider = new LoggerProvider({ resource });
   loggerProvider.addLogRecordProcessor(new SimpleLogRecordProcessor(new OTLPLogExporter()));
   
   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 :

   Application Insights

   azure.monitor.opentelemetry
   

   Exportar OTLP

   opentelemetry-api
   opentelemetry-sdk
   opentelemetry-exporter-otlp
   opentelemetry-instrumentation-logging
   

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

   Application Insights

   from azure.monitor.opentelemetry import configure_azure_monitor 
   configure_azure_monitor() 
   

   Exportar OTLP

   Los seguimientos, las métricas y los registros que se exportan mediante OpenTelemetry deben configurarse manualmente. Para obtener más información, consulte Instrumentación para Python.

   Se trata de una implementación sencilla para exportar registros:

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

   Revise SDK de registro de OpenTelemetry para aprender a usar componentes de OpenTelemetry para recopilar registros.

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