Partilhar via

Usar OpenTelemetry com o Azure Functions

  • Artigo

Importante

O suporte a OpenTelemetry para o Azure Functions está atualmente em pré-visualização e a sua aplicação tem de estar alojada num plano de Consumo Flexível para utilizar OpenTelemetry.

Este artigo mostra como configurar seu aplicativo de função para exportar dados de log e rastreamento em um formato OpenTelemetry . O Azure Functions gera dados de telemetria em suas execuções de função a partir do processo de host do Functions e do processo de trabalho específico do idioma no qual seu código de função é executado. Por padrão, esses dados de telemetria são enviados para o Application Insights usando o SDK do Application Insights. No entanto, você pode optar por exportar esses dados usando a semântica OpenTelemetria. Embora você ainda possa usar um formato OpenTelemetry para enviar seus dados para o Application Insights, agora você também pode exportar os mesmos dados para qualquer outro ponto de extremidade compatível com OpenTelemetry.

Gorjeta

Como este artigo é direcionado para a linguagem de desenvolvimento de sua escolha, lembre-se de escolher a linguagem correta na parte superior do artigo.

Atualmente, não há suporte OpenTelemetry otimizado para clientes para aplicativos Java.

Atualmente, o OpenTelemetry não é suportado para aplicativos em processo em C#.

Você pode obter esses benefícios ativando o OpenTelemetry em seu aplicativo de função:

  • Correlação entre rastreamentos e logs que estão sendo gerados no host e no código do aplicativo.
  • Geração consistente e baseada em padrões de dados de telemetria exportáveis.
  • Integra-se com outros provedores que podem consumir dados compatíveis com OpenTeleletry.

O OpenTelemetry é habilitado no nível do aplicativo de função, tanto na configuração do host (host.json) quanto no seu projeto de código. O Functions também fornece uma experiência otimizada para o cliente exportar dados OpenTelemetry do código de função que está sendo executado em um processo de trabalho específico do idioma.

1. Habilite o OpenTelemetry no host Functions

Quando você habilita a saída OpenTelemetry no arquivo host.json do aplicativo funcional, seu host exporta a saída OpenTelemetry independentemente da pilha de idiomas usada pelo aplicativo.

Para habilitar a saída OpenTelemetry do host Functions, atualize o arquivo host.json em seu projeto de código para adicionar um "telemetryMode": "openTelemetry" elemento à coleção raiz. Com o OpenTelemetry ativado, seu arquivo host.json pode ter esta aparência:

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

2. Definir configurações do aplicativo

Quando o OpenTelemetry está habilitado no arquivo host.json, os pontos de extremidade para os quais os dados são enviados são determinados com base nas configurações do aplicativo suportado pelo OpenTelemetry que estão disponíveis nas variáveis de ambiente do seu aplicativo.

Crie configurações específicas do aplicativo em seu aplicativo de função com base no destino de saída do OpenTelemetry . Quando as configurações de conexão são fornecidas para o Application Insights e um exportador do protocolo OpenTelemetry (OTLP), os dados do OpenTelemetry são enviados para ambos os pontos de extremidade.

APPLICATIONINSIGHTS_CONNECTION_STRING: a cadeia de conexão para um espaço de trabalho do Application Insights. Quando essa configuração existe, os dados do OpenTelemetry são enviados para esse espaço de trabalho. Essa configuração é a mesma usada para se conectar ao Application Insights sem o OpenTelemetry habilitado. Se seu aplicativo ainda não tiver essa configuração, talvez seja necessário habilitar a integração do Application Insights.

3. Habilite o OpenTelemetry em seu aplicativo

Com o host Functions configurado para usar OpenTelemetry, você também deve atualizar o código do aplicativo para produzir dados OpenTelemetry . Habilitar o OpenTelemetry no host e no código do aplicativo permite uma melhor correlação entre rastreamentos e logs emitidos pelo processo de host do Functions e pelo processo de trabalho de linguagem.

A maneira como você instrumenta seu aplicativo para usar o OpenTelemetry depende do seu ponto de extremidade OpenTelemetry de destino:

  1. Execute estes comandos para instalar os assemblies necessários em seu aplicativo:

    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. No seu arquivo de projeto Program.cs, adicione esta using instrução:

    using Azure.Monitor.OpenTelemetry.AspNetCore;

  3. ConfigureServices No delegado, adicione esta configuração de serviço:

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

    Para exportar para ambos os pontos de extremidade OpenTelemetria, chame ambos e UseAzureMonitor UseOtlpExporter.

As otimizações de trabalho Java ainda não estão disponíveis para OpenTelemetry, portanto, não há nada para configurar em seu código Java.

  1. Instale estes pacotes npm em seu projeto:

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

  1. Crie um arquivo de código em seu projeto, copie e cole o seguinte código neste novo arquivo e salve o arquivo 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. Atualize o main campo no arquivo package.json para incluir esse novo src/index.js arquivo, que pode ter esta aparência:

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

  1. Crie um arquivo de código em seu projeto, copie e cole o seguinte código neste novo arquivo e salve o arquivo 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. Atualize o main campo no arquivo package.json para incluir a saída desse novo src/index.ts arquivo, que pode ter esta aparência:

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

Importante

A saída OpenTelemetry para o Application Insights do operador de idiomas não é suportada atualmente para aplicativos PowerShell. Em vez disso, você pode querer usar um ponto de extremidade de exportador OTLP. Quando seu host é configurado para saída OpenTelemetry para Application Insights, os logs gerados pelo processo de trabalho do PowerShell ainda são encaminhados, mas o rastreamento distribuído não é suportado no momento.

Estas instruções aplicam-se apenas a um exportador OTLP:

  1. Adicione uma configuração de aplicativo nomeada OTEL_FUNCTIONS_WORKER_ENABLED com o valor de True.

  2. Crie uma pasta no nível Modules do aplicativo na raiz do seu aplicativo e execute o seguinte comando:

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

    Isso instala o módulo necessário AzureFunctions.PowerShell.OpenTelemetry.SDK diretamente em seu aplicativo. Não é possível usar o requirements.psd1 arquivo para instalar automaticamente essa dependência porque as dependências gerenciadas não são suportadas atualmente na visualização do plano Flex Consumption.

  3. Adicione este código ao seu ficheiro profile.ps1:

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

  1. Adicione esta entrada ao seu requirements.txt ficheiro:

    azure.monitor.opentelemetry

  2. Adicione este código ao seu function_app.py arquivo de ponto de entrada principal:

    from azure.monitor.opentelemetry import configure_azure_monitor 
configure_azure_monitor()

Considerações para OpenTelemetry

Ao exportar seus dados usando OpenTelemetry, tenha estas considerações atuais em mente.

  • Quando o host é configurado para usar OpenTelemetry, somente logs e rastreamentos são exportados. As métricas do host não são exportadas no momento.

  • No momento, você não pode executar seu projeto de aplicativo localmente usando as Ferramentas Principais quando o OpenTelemetry está habilitado no host. No momento, você precisa implantar seu código no Azure para validar suas atualizações relacionadas ao OpenTelemetry.

  • No momento, apenas gatilhos HTTP e baseados no SDK do Azure são suportados com saídas OpenTelemetry .

Conteúdos relacionados

Monitorar o plano de consumo do Azure FunctionsFlex