Application Real-Time Monitoring Service:Report trace data from PHP applications through OpenTelemetry

Obtener un endpoint

1. Inicie sesión en la consola de ARMS.

2. En el panel de navegación izquierdo, haga clic en Integration Center.

3. En la sección Server-side Applications, haga clic en la tarjeta OpenTelemetry.

4. En el panel OpenTelemetry, haga clic en la pestaña Start Integration y seleccione una región.

   La primera vez que accede a una región, los recursos se inicializan automáticamente en ella.

5. Establezca Connection Type y Export Protocol, y luego copie el endpoint.

   Parámetro	Opciones	Guía
   Connection Type	Alibaba Cloud VPC Network, Public Network	Use VPC si su servicio se ejecuta en la misma región de Alibaba Cloud. De lo contrario, use Public Network.
   Export Protocol	HTTP (recomendado), gRPC	Elija la opción según el protocolo que admita su cliente.

   

Paso 1: Crear la aplicación

1. Inicialice el proyecto:

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

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

2. Cree un archivo index.php en el directorio del proyecto:

      <?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. Compruebe que la aplicación se ejecuta correctamente: abra http://localhost:8080/rolldice en un navegador. Debería ver un número aleatorio entre 1 y 6.

      php -S localhost:8080

Paso 2: Compilar la extensión de PHP de OpenTelemetry

1. Instale las dependencias de compilación:

   • macOS:

     brew install gcc make autoconf

   • Linux (apt):

     sudo apt-get install gcc make autoconf

2. Compile e instale la extensión con PECL. Una compilación correcta finaliza con una salida similar a la siguiente:

      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) Si la salida no incluye Extension opentelemetry enabled in php.ini, agregue manualmente la extensión a su archivo php.ini:

      [opentelemetry]
      extension=opentelemetry.so

4. Compruebe que la extensión se cargó. Salida esperada: También puede ejecutar php --ri opentelemetry para obtener información detallada de la extensión:

      php -m | grep opentelemetry

      opentelemetry

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

Paso 3: Instalar las dependencias de instrumentación

# 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

Paso 4: Ejecutar la aplicación instrumentada

Inicie la aplicación con variables de entorno que configuran el SDK de 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

Reemplace los siguientes marcadores de posición con sus valores:

Comprobar

1. Abra http://localhost:8080/rolldice en un navegador. Cada solicitud genera una traza automáticamente.

2. Inicie sesión en la consola de Managed Service for OpenTelemetry.

3. En la página Applications, busque su aplicación y haga clic en su nombre para consultar las trazas.

Las trazas pueden tardar unos minutos en aparecer en la consola. Si siguen sin mostrarse, compruebe que la extensión de OpenTelemetry está cargada ( php -m | grep opentelemetry ) y que su endpoint y token son correctos.

Paso 1: Crear la aplicación

Siga los mismos pasos descritos en la sección Instrumentación automática > Paso 1 para crear la aplicación de lanzamiento de dados basada en Slim.

Paso 2: Instalar las dependencias del SDK de OpenTelemetry

Instale la biblioteca del cliente HTTP y los paquetes del SDK de OpenTelemetry. Seleccione la pestaña que corresponda a su protocolo de exportación.

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

Paso 3: Escribir el código de inicialización

Cree un archivo opentelemetry_util.php en el mismo directorio que index.php. Este archivo configura TracerProvider, el exportador y el sampler.

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

Paso 4: Agregar la instrumentación a la aplicación

Actualice index.php para inicializar OpenTelemetry y crear spans.

1. Importe los paquetes obligatorios e inicialice OpenTelemetry al inicio de 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. Cree un span en la ruta /rolldice para capturar el seguimiento a nivel de solicitud:

      $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. Cree spans anidados para rastrear operaciones de varios pasos. A continuación se muestra la ruta /rolltwodices, que ilustra una relación de span padre-hijo:

      $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 excepciones en los spans. La siguiente ruta /error muestra cómo manejar errores:

      $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;
          }
      });

Paso 5: Ejecutar y comprobar

1. Inicie la aplicación:

      php -S localhost:8080

2. Envíe solicitudes para generar datos de trazas:

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

3. Inicie sesión en la consola de Managed Service for OpenTelemetry. En la página Applications, busque su aplicación y haga clic en su nombre para consultar las trazas.

Las trazas pueden tardar unos minutos en aparecer en la consola. Si siguen sin mostrarse, compruebe que su endpoint y token sean correctos, y que su servidor pueda alcanzar el endpoint a través de la red.