Filtrar o OpenTelemetry do Azure Monitor para aplicativos .NET, Java, Node.js e Python

Muitas bibliotecas de instrumentação fornecem uma opção de filtro. Para obter diretrizes, confira os arquivos leiame correspondentes:

¹ Incluímos a instrumentação SqlClient em nosso pacote enquanto ainda está em versão beta. Quando ele atinge uma versão estável, nós o incluímos como uma referência de pacote padrão. Até lá, para personalizar a instrumentação SQLClient, adicione a referência do pacote OpenTelemetry.Instrumentation.SqlClient ao seu projeto e use sua API pública.

dotnet add package --prerelease OpenTelemetry.Instrumentation.SqlClient

builder.Services.AddOpenTelemetry().UseAzureMonitor().WithTracing(builder =>
{
    builder.AddSqlClientInstrumentation(options =>
    {
        options.SetDbStatementForStoredProcedure = false;
    });
});

Observação

Este exemplo é específico para instrumentações HTTP. Para outros tipos de sinal, atualmente não há mecanismo específico disponível para filtrar a telemetria. Em vez disso, é necessário um processador de intervalo personalizado.

O seguinte exemplo mostra como excluir uma determinada URL do rastreamento usando a biblioteca de instrumentação HTTP/HTTPS:

// Import the useAzureMonitor function and the ApplicationInsightsOptions class from the @azure/monitor-opentelemetry package.
const { useAzureMonitor, ApplicationInsightsOptions } = require("@azure/monitor-opentelemetry");

// Import the HttpInstrumentationConfig class from the @opentelemetry/instrumentation-http package.
const { HttpInstrumentationConfig }= require("@opentelemetry/instrumentation-http");

// Import the IncomingMessage and RequestOptions classes from the http and https packages, respectively.
const { IncomingMessage } = require("http");
const { RequestOptions } = require("https");

// Create a new HttpInstrumentationConfig object.
const httpInstrumentationConfig: HttpInstrumentationConfig = {
    enabled: true,
    ignoreIncomingRequestHook: (request: IncomingMessage) => {
    // Ignore OPTIONS incoming requests.
    if (request.method === 'OPTIONS') {
        return true;
    }
    return false;
    },
    ignoreOutgoingRequestHook: (options: RequestOptions) => {
    // Ignore outgoing requests with the /test path.
    if (options.path === '/test') {
        return true;
    }
    return false;
    }
};

// Create a new ApplicationInsightsOptions object.
const config: ApplicationInsightsOptions = {
    instrumentationOptions: {
    http: {
        httpInstrumentationConfig
    }
    }
};

// Enable Azure Monitor integration using the useAzureMonitor function and the ApplicationInsightsOptions object.
useAzureMonitor(config);

Observação

Este exemplo é específico para instrumentações HTTP. Para outros tipos de sinal, atualmente não há mecanismo específico disponível para filtrar a telemetria. Em vez disso, é necessário um processador de intervalo personalizado.

O exemplo a seguir mostra como excluir uma determinada URL de ser rastreada usando a variável de ambiente OTEL_PYTHON_EXCLUDED_URLS:

export OTEL_PYTHON_EXCLUDED_URLS="http://localhost:8080/ignore"

Isso exclui o ponto de extremidade mostrado no exemplo de Flask a seguir:

...
# Import the Flask and Azure Monitor OpenTelemetry SDK libraries.
import flask
from azure.monitor.opentelemetry import configure_azure_monitor

# Configure OpenTelemetry to use Azure Monitor with the specified connection string.
# Replace `<your-connection-string>` with the connection string to your Azure Monitor Application Insights resource.
configure_azure_monitor(
    connection_string="<your-connection-string>",
)

# Create a Flask application.
app = flask.Flask(__name__)

# Define a route. Requests sent to this endpoint will not be tracked due to
# flask_config configuration.
@app.route("/ignore")
def ignore():
    return "Request received but not tracked."
...

Usar um processador personalizado:

Dica

Adicione o processador mostrado aqui antes de adicionar o Azure Monitor.

// Create an ASP.NET Core application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry tracer provider to add a new processor named ActivityFilteringProcessor.
builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => builder.AddProcessor(new ActivityFilteringProcessor()));
// Configure the OpenTelemetry tracer provider to add a new source named "ActivitySourceName".
builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => builder.AddSource("ActivitySourceName"));
// Add the Azure Monitor telemetry service to the application. This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core application.
var app = builder.Build();

// Start the ASP.NET Core application.
app.Run();

Adicione ActivityFilteringProcessor.cs ao seu projeto com o seguinte código:

public class ActivityFilteringProcessor : BaseProcessor<Activity>
{
    // The OnStart method is called when an activity is started. This is the ideal place to filter activities.
    public override void OnStart(Activity activity)
    {
        // prevents all exporters from exporting internal activities
        if (activity.Kind == ActivityKind.Internal)
        {
            activity.IsAllDataRequested = false;
        }
    }
}

Se uma fonte específica não for explicitamente adicionada usando AddSource("ActivitySourceName"), nenhuma das atividades criadas usando essa fonte será exportada.

Usar um processador personalizado:

// Create an OpenTelemetry tracer provider builder.
// It is important to keep the TracerProvider instance active throughout the process lifetime.
using var tracerProvider = Sdk.CreateTracerProviderBuilder()
        .AddSource("OTel.AzureMonitor.Demo") // Add a source named "OTel.AzureMonitor.Demo".
        .AddProcessor(new ActivityFilteringProcessor()) // Add a new processor named ActivityFilteringProcessor.
        .AddAzureMonitorTraceExporter() // Add the Azure Monitor trace exporter.
        .Build();

Adicione ActivityFilteringProcessor.cs ao seu projeto com o seguinte código:

public class ActivityFilteringProcessor : BaseProcessor<Activity>
{
    // The OnStart method is called when an activity is started. This is the ideal place to filter activities.
    public override void OnStart(Activity activity)
    {
        // prevents all exporters from exporting internal activities
        if (activity.Kind == ActivityKind.Internal)
        {
            activity.IsAllDataRequested = false;
        }
    }
}

Se uma fonte específica não for explicitamente adicionada usando AddSource("ActivitySourceName"), nenhuma das atividades criadas usando essa fonte será exportada.

Você pode usar um processador de span personalizado para excluir determinadas extensões de serem exportadas. Para marcar intervalos para que não sejam exportados, defina TraceFlag como DEFAULT.

Use o exemplo de propriedade personalizada, mas substitua as seguintes linhas de código:

// Import the necessary packages.
const { SpanKind, TraceFlags } = require("@opentelemetry/api");
const { ReadableSpan, Span, SpanProcessor } = require("@opentelemetry/sdk-trace-base");

// Create a new SpanEnrichingProcessor class.
class SpanEnrichingProcessor implements SpanProcessor {
    forceFlush(): Promise<void> {
        return Promise.resolve();
    }

    shutdown(): Promise<void> {
        return Promise.resolve();
    }

    onStart(_span: Span): void {}

    onEnd(span) {
        // If the span is an internal span, set the trace flags to NONE.
        if(span.kind == SpanKind.INTERNAL){
        span.spanContext().traceFlags = TraceFlags.NONE;
        }
    }
}

Você pode usar um processador de span personalizado para excluir determinadas extensões de serem exportadas. Para marcar intervalos para que não sejam exportados, defina TraceFlag como DEFAULT:

...
# Import the necessary libraries.
from azure.monitor.opentelemetry import configure_azure_monitor
from opentelemetry import trace

# Configure OpenTelemetry to use Azure Monitor with the specified connection string.
# Replace `<your-connection-string>` with the connection string to your Azure Monitor Application Insights resource.
configure_azure_monitor(
    connection_string="<your-connection-string>",
    # Configure the custom span processors to include span filter processor.
    span_processors=[span_filter_processor],
)

...

Adicione SpanFilteringProcessor ao seu projeto com o seguinte código:

# Import the necessary libraries.
from opentelemetry.trace import SpanContext, SpanKind, TraceFlags
from opentelemetry.sdk.trace import SpanProcessor

# Define a custom span processor called `SpanFilteringProcessor`.
class SpanFilteringProcessor(SpanProcessor):

    # Prevents exporting spans from internal activities.
    def on_start(self, span, parent_context):
        # Check if the span is an internal activity.
        if span._kind is SpanKind.INTERNAL:
            # Create a new span context with the following properties:
            #   * The trace ID is the same as the trace ID of the original span.
            #   * The span ID is the same as the span ID of the original span.
            #   * The is_remote property is set to `False`.
            #   * The trace flags are set to `DEFAULT`.
            #   * The trace state is the same as the trace state of the original span.
            span._context = SpanContext(
                span.context.trace_id,
                span.context.span_id,
                span.context.is_remote,
                TraceFlags(TraceFlags.DEFAULT),
                span.context.trace_state,
            )

Para configurar ainda mais a Distribuição do OpenTelemetry, confira Configuração do OpenTelemetry do Azure Monitor.
Para revisar o código-fonte, acesse o repositório do GitHub AspNetCore do Azure Monitor.
Para instalar o pacote NuGet, verificar se há atualizações ou exibir as notas de versão, consulte a página Pacote NuGet AspNetCore do Azure Monitor.
Para se familiarizar com o Application Insights do Azure Monitor e o OpenTelemetry, confira o Aplicativo de exemplo do Azure Monitor.
Para saber mais sobre o OpenTelemetry e a respectiva comunidade, confira o Repositório GitHub do .NET do OpenTelemetry.
Para habilitar experiências de usuário, habilite o monitoramento de usuário de navegador ou da Web.
Para revisar perguntas frequentes, etapas de solução de problemas, opções de suporte ou fornecer comentários do OpenTelemetry, veja a ajuda, o suporte e o comentários do OpenTelemetry para o Azure Monitor Application Insights.

Para revisar o código-fonte, acesse o repositório do GitHub do OpenTelemetry do Azure Monitor.
Para instalar o pacote npm e verificar se há atualizações, confira a página @azure/monitor-opentelemetry Pacote npm.
Para se familiarizar com o Application Insights do Azure Monitor e o OpenTelemetry, confira oAplicativo de exemplo do Azure Monitor.
Para saber mais sobre o OpenTelemetry e a respectiva comunidade, confira o repositório de GitHub em JavaScript para OpenTelemetry .
Para habilitar experiências de usuário, habilite o monitoramento de usuário de navegador ou da Web.
Para revisar perguntas frequentes, etapas de solução de problemas, opções de suporte ou fornecer comentários do OpenTelemetry, veja a ajuda, o suporte e o comentários do OpenTelemetry para o Azure Monitor Application Insights.

Compartilhar via

Filtrar a telemetria usando bibliotecas de instrumentação

Filtrar telemetria usando processadores de intervalo

Próximas etapas

Comentários

Recursos adicionais