Application Real-Time Monitoring Service:Reportar dados de rastreamento de aplicações PHP via OpenTelemetry

Obter um endpoint

1. Faça login no console do ARMS.

2. No painel de navegação à esquerda, clique em Integration Center.

3. Na seção Server-side Applications, clique no cartão OpenTelemetry.

4. No painel OpenTelemetry, clique na aba Start Integration e selecione uma região.

   Ao acessar uma região pela primeira vez, os recursos são inicializados automaticamente nesse local.

5. Defina o Connection Type e o Export Protocol e copie o endpoint.

   Parâmetro	Opções	Orientação
   Connection Type	Alibaba Cloud VPC Network, Public Network	Use VPC se seu service estiver na mesma região da Alibaba Cloud. Caso contrário, use Public Network.
   Export Protocol	http (recomendado), gRPC	Escolha com base no suporte de protocolo do seu cliente.

   

Passo 1: Crie a aplicação

1. Inicialize o projeto:

      mkdir <project-name> && cd <project-name>

      composer init \
        --no-interaction \
        --stability beta \
        --require slim/slim:"^4" \
        --require slim/psr7:"^1"
      composer update

2. Crie um arquivo index.php no diretório do projeto:

      <?php
      use Psr\Http\Message\ResponseInterface as Response;
      use Psr\Http\Message\ServerRequestInterface as Request;
      use Slim\Factory\AppFactory;
   
      require __DIR__ . '/vendor/autoload.php';
   
      $app = AppFactory::create();
   
      $app->get('/rolldice', function (Request $request, Response $response) {
          $result = random_int(1,6);
          $response->getBody()->write(strval($result));
          return $response;
      });
   
      $app->run();

3. Verifique se a aplicação está funcionando: Abra http://localhost:8080/rolldice no navegador. Um número aleatório entre 1 e 6 deve ser exibido.

      php -S localhost:8080

Passo 2: Compilar a extensão OpenTelemetry para PHP

1. Instale as dependências de compilação:

   • macOS:

     brew install gcc make autoconf

   • Linux (apt):

     sudo apt-get install gcc make autoconf

2. Compile e instale a extensão com o PECL: Uma compilação bem-sucedida termina com uma saída semelhante a:

      pecl install opentelemetry

      Build process completed successfully
      Installing '/opt/homebrew/Cellar/php/8.2.8/pecl/20220829/opentelemetry.so'
      install ok: channel://pecl.php.net/opentelemetry-1.0.0beta6
      Extension opentelemetry enabled in php.ini

3. (Opcional) Se a saída não incluir Extension opentelemetry enabled in php.ini, adicione manualmente a extensão ao seu arquivo php.ini:

      [opentelemetry]
      extension=opentelemetry.so

4. Verifique se a extensão foi carregada: Saída esperada: Alternativamente, execute php --ri opentelemetry para obter informações detalhadas sobre a extensão:

      php -m | grep opentelemetry

      opentelemetry

      opentelemetry
      opentelemetry support => enabled
      extension version => 1.0.0beta6

Passo 3: Instale dependências de instrumentação

# Install the gRPC extension (may take several minutes)
pecl install grpc

composer config allow-plugins.php-http/discovery false
composer require \
  open-telemetry/sdk \
  open-telemetry/opentelemetry-auto-slim \
  open-telemetry/exporter-otlp \
  php-http/guzzle7-adapter \
  open-telemetry/transport-grpc

Passo 4: Execute a aplicação instrumentada

Inicie a aplicação definindo variáveis de ambiente que configuram o sdk do OpenTelemetry:

env OTEL_PHP_AUTOLOAD_ENABLED=true \
    OTEL_SERVICE_NAME=<your-service-name> \
    OTEL_TRACES_EXPORTER=otlp \
    OTEL_METRICS_EXPORTER=none \
    OTEL_LOGS_EXPORTER=none \
    OTEL_EXPORTER_OTLP_PROTOCOL=grpc \
    OTEL_EXPORTER_OTLP_ENDPOINT=<endpoint> \
    OTEL_EXPORTER_OTLP_HEADERS=Authentication=<token> \
    OTEL_PROPAGATORS=baggage,tracecontext \
    php -S localhost:8080

Substitua os placeholders abaixo pelos seus valores:

Verifique

1. Acesse http://localhost:8080/rolldice no navegador. Cada requisição gera um rastreamento automaticamente.

2. Faça login no console do Managed Service for OpenTelemetry.

3. Na página Applications, localize sua aplicação e clique em nome dela para visualizar os rastreamentos.

Pode levar alguns minutos até que os rastreamentos apareçam no console. Se eles ainda não forem exibidos, verifique se a extensão OpenTelemetry está carregada ( php -m | grep opentelemetry ) e confirme se o endpoint e o token estão corretos.

Passo 1: Crie a aplicação

Siga os mesmos passos descritos na seção Instrumentação automática > Passo 1 para criar a aplicação de rolagem de dados baseada no Slim.

Passo 2: Instale dependências do sdk do OpenTelemetry

Instale a biblioteca de cliente http e os pacotes do sdk do OpenTelemetry. Selecione a aba correspondente ao seu protocolo de exportação.

composer require guzzlehttp/guzzle

composer require \
  open-telemetry/sdk \
  open-telemetry/exporter-otlp

# Install the gRPC extension if not already installed
pecl install grpc
composer require open-telemetry/transport-grpc

composer require guzzlehttp/guzzle

composer require \
  open-telemetry/sdk \
  open-telemetry/exporter-otlp

Passo 3: Escrever o código de inicialização

Crie um arquivo opentelemetry_util.php no mesmo diretório do index.php. Este arquivo configura o TracerProvider, o exportador e o amostrador.

<?php
use OpenTelemetry\API\Common\Instrumentation\Globals;
use OpenTelemetry\API\Trace\Propagation\TraceContextPropagator;
use OpenTelemetry\Contrib\Otlp\SpanExporter;
use OpenTelemetry\SDK\Common\Attribute\Attributes;
use OpenTelemetry\SDK\Common\Export\Stream\StreamTransportFactory;
use OpenTelemetry\SDK\Resource\ResourceInfo;
use OpenTelemetry\SDK\Resource\ResourceInfoFactory;
use OpenTelemetry\SDK\Sdk;
use OpenTelemetry\SDK\Trace\Sampler\AlwaysOnSampler;
use OpenTelemetry\SDK\Trace\Sampler\ParentBased;
use OpenTelemetry\SDK\Trace\SpanProcessor\SimpleSpanProcessor;
use OpenTelemetry\SDK\Trace\SpanProcessor\BatchSpanProcessorBuilder;
use OpenTelemetry\SDK\Trace\TracerProvider;
use OpenTelemetry\SemConv\ResourceAttributes;
use OpenTelemetry\Contrib\Grpc\GrpcTransportFactory;
use OpenTelemetry\Contrib\Otlp\OtlpUtil;
use OpenTelemetry\API\Signals;

function initOpenTelemetry()
{
    // 1. Define the service resource
    $resource = ResourceInfoFactory::emptyResource()->merge(ResourceInfo::create(Attributes::create([
        ResourceAttributes::SERVICE_NAME => '<your-service-name>',  // Required
        ResourceAttributes::HOST_NAME => '<your-host-name>'         // Optional
    ])));

    // 2. Create a SpanExporter that sends data over gRPC
    $headers = [
        'Authentication' => '<your-token>',
    ];
    $transport = (new GrpcTransportFactory())->create(
        '<grpc-endpoint>' . OtlpUtil::method(Signals::TRACE),
        'application/x-protobuf',
        $headers
    );
    $spanExporter = new SpanExporter($transport);

    // 3. Build and register the global TracerProvider
    $tracerProvider = TracerProvider::builder()
        ->addSpanProcessor(
            (new BatchSpanProcessorBuilder($spanExporter))->build()
        )
        ->setResource($resource)
        ->setSampler(new ParentBased(new AlwaysOnSampler()))
        ->build();

    Sdk::builder()
        ->setTracerProvider($tracerProvider)
        ->setPropagator(TraceContextPropagator::getInstance())
        ->setAutoShutdown(true)   // Flush pending spans on shutdown
        ->buildAndRegisterGlobal();
}
?>

<?php
use OpenTelemetry\API\Common\Instrumentation\Globals;
use OpenTelemetry\API\Trace\Propagation\TraceContextPropagator;
use OpenTelemetry\Contrib\Otlp\SpanExporter;
use OpenTelemetry\SDK\Common\Attribute\Attributes;
use OpenTelemetry\SDK\Common\Export\Stream\StreamTransportFactory;
use OpenTelemetry\SDK\Resource\ResourceInfo;
use OpenTelemetry\SDK\Resource\ResourceInfoFactory;
use OpenTelemetry\SDK\Sdk;
use OpenTelemetry\SDK\Trace\Sampler\AlwaysOnSampler;
use OpenTelemetry\SDK\Trace\Sampler\ParentBased;
use OpenTelemetry\SDK\Trace\SpanProcessor\SimpleSpanProcessor;
use OpenTelemetry\SDK\Trace\SpanProcessor\BatchSpanProcessorBuilder;
use OpenTelemetry\SDK\Trace\TracerProvider;
use OpenTelemetry\SemConv\ResourceAttributes;
use OpenTelemetry\Contrib\Otlp\OtlpHttpTransportFactory;
use OpenTelemetry\SDK\Common\Export\TransportFactoryInterface;

function initOpenTelemetry()
{
    // 1. Define the service resource
    $resource = ResourceInfoFactory::emptyResource()->merge(ResourceInfo::create(Attributes::create([
        ResourceAttributes::SERVICE_NAME => '<your-service-name>',  // Required
        ResourceAttributes::HOST_NAME => '<your-host-name>'         // Optional
    ])));

    // 2. Create a SpanExporter that sends data over HTTP
    $transport = (new OtlpHttpTransportFactory())->create(
        '<http-endpoint>',
        'application/x-protobuf'
    );
    $spanExporter = new SpanExporter($transport);

    // 3. Build and register the global TracerProvider
    $tracerProvider = TracerProvider::builder()
        ->addSpanProcessor(
            (new BatchSpanProcessorBuilder($spanExporter))->build()
        )
        ->setResource($resource)
        ->setSampler(new ParentBased(new AlwaysOnSampler()))
        ->build();

    Sdk::builder()
        ->setTracerProvider($tracerProvider)
        ->setPropagator(TraceContextPropagator::getInstance())
        ->setAutoShutdown(true)   // Flush pending spans on shutdown
        ->buildAndRegisterGlobal();
}
?>

Passo 4: Adicionar instrumentação à aplicação

Atualize o index.php para inicializar o OpenTelemetry e criar spans.

1. Importe os pacotes necessários e inicialize o OpenTelemetry no início do index.php:

      <?php
      use OpenTelemetry\API\Common\Instrumentation\Globals;
      use OpenTelemetry\SDK\Common\Attribute\Attributes;
      use OpenTelemetry\SDK\Trace\TracerProvider;
   
      require __DIR__ . '/opentelemetry_util.php';
   
      // Initialize OpenTelemetry: configure service name, exporter, and global TracerProvider
      initOpenTelemetry();

2. Crie um span na rota /rolldice para capturar o rastreamento no nível da requisição:

      $app->get('/rolldice', function (Request $request, Response $response) {
          // Get a tracer instance
          $tracer = \OpenTelemetry\API\Globals::tracerProvider()->getTracer('my-tracer');
   
          // Start a span for this operation
          $span = $tracer->spanBuilder("/rolldice")->startSpan();
          $span->setAttribute("http.method", "GET");
          $span->addEvent("Init");
   
          // Configure events with attributes
          $eventAttributes = Attributes::create([
              "key1" => "value",
              "key2" => 3.14159,
          ]);
   
          // Business logic
          $result = random_int(1,6);
          $response->getBody()->write(strval($result));
   
          $span->addEvent("End");
          $span->end();
   
          return $response;
      });

3. Crie spans aninhados para rastrear operações com múltiplas etapas. A rota /rolltwodices abaixo demonstra uma relação de span pai-filho:

      $app->get('/rolltwodices', function (Request $request, Response $response) {
          $tracer = \OpenTelemetry\API\Globals::tracerProvider()->getTracer('my-tracer');
   
          // Create a parent span
          $parentSpan = $tracer->spanBuilder("/rolltwodices/parent")->startSpan();
          $scope = $parentSpan->activate();
   
          $value1 = random_int(1,6);
   
          // Create a child span within the parent scope
          $childSpan = $tracer->spanBuilder("/rolltwodices/parent/child")->startSpan();
   
          // Business logic
          $value2 = random_int(1,6);
          $result = "dice1: " . $value1 . ", dice2: " . $value2;
   
          // End spans and detach scope
          $childSpan->end();
          $parentSpan->end();
          $scope->detach();
   
          $response->getBody()->write(strval($result));
          return $response;
      });

4. Registre exceções nos spans. A rota /error a seguir exemplifica o tratamento de erros:

      $app->get('/error', function (Request $request, Response $response) {
          $tracer = \OpenTelemetry\API\Globals::tracerProvider()->getTracer('my-tracer');
          $span3 = $tracer->spanBuilder("/error")->startSpan();
   
          try {
              // Simulate an exception
              throw new \Exception('exception!');
          } catch (\Throwable $t) {
              // Mark the span as an error
              $span3->setStatus(\OpenTelemetry\API\Trace\StatusCode::STATUS_ERROR, "exception in span3!");
              // Record the exception with stack trace
              $span3->recordException($t, ['exception.escaped' => true]);
          } finally {
              $span3->end();
              $response->getBody()->write("error");
              return $response;
          }
      });

Passo 5: Execute e verifique

1. Inicie a aplicação:

      php -S localhost:8080

2. Envie requisições para gerar dados de rastreamento:

      http://localhost:8080/rolldice
      http://localhost:8080/rolltwodices
      http://localhost:8080/error

3. Faça login no console do Managed Service for OpenTelemetry. Na página Applications, localize sua aplicação e clique em nome dela para visualizar os rastreamentos.

Pode levar alguns minutos até que os rastreamentos apareçam no console. Se eles ainda não forem exibidos, verifique se o endpoint e o token estão corretos e confirme se o servidor consegue alcançar o endpoint pela rede.