import (
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
    "go.opentelemetry.io/otel/sdk/resource"
    "go.opentelemetry.io/otel/sdk/trace"
    semconv "go.opentelemetry.io/otel/semconv/v1.21.0"
)

func initTracer(ctx context.Context) (*trace.TracerProvider, error) {
    exporter, err := otlptracehttp.New(ctx,
        otlptracehttp.WithEndpoint("localhost:4318"),
        otlptracehttp.WithInsecure(),
    )
    if err != nil {
        return nil, err
    }

    res, err := resource.New(ctx,
        resource.WithAttributes(
            semconv.ServiceName("user-api"),
            semconv.ServiceVersion("1.2.3"),
            semconv.DeploymentEnvironment("production"),
        ),
    )
    if err != nil {
        return nil, err
    }

    tp := trace.NewTracerProvider(
        trace.WithBatcher(exporter),
        trace.WithResource(res),
        trace.WithSampler(trace.TraceIDRatioBased(0.1)), // 10%
    )
    otel.SetTracerProvider(tp)
    otel.SetTextMapPropagator(propagation.TraceContext{})
    return tp, nil
}

<?php
declare(strict_types=1);

use OpenTelemetry\API\Globals;
use OpenTelemetry\SDK\Resource\ResourceInfo;
use OpenTelemetry\SDK\Resource\ResourceInfoFactory;
use OpenTelemetry\SDK\Trace\SpanProcessor\BatchSpanProcessor;
use OpenTelemetry\SDK\Trace\Sampler\TraceIdRatioBasedSampler;
use OpenTelemetry\SDK\Trace\Sampler\ParentBased;
use OpenTelemetry\SDK\Trace\TracerProvider;
use OpenTelemetry\Contrib\Otlp\SpanExporter;
use OpenTelemetry\Contrib\Otlp\OtlpHttpTransportFactory;
use OpenTelemetry\SemConv\ResourceAttributes;

$transport = (new OtlpHttpTransportFactory())->create('http://localhost:4318/v1/traces', 'application/x-protobuf');
$exporter = new SpanExporter($transport);

$resource = ResourceInfoFactory::defaultResource()->merge(
    ResourceInfo::create(\OpenTelemetry\SDK\Common\Attribute\Attributes::create([
        ResourceAttributes::SERVICE_NAME => 'user-api',
        ResourceAttributes::SERVICE_VERSION => '1.2.3',
        ResourceAttributes::DEPLOYMENT_ENVIRONMENT => 'production',
    ])),
);

$tracerProvider = TracerProvider::builder()
    ->addSpanProcessor(new BatchSpanProcessor($exporter, \OpenTelemetry\API\Common\Time\Clock::getDefault()))
    ->setResource($resource)
    ->setSampler(new ParentBased(new TraceIdRatioBasedSampler(0.1))) // 10%
    ->build();

Globals::registerInitializer(static fn ($builder) => $builder->withTracerProvider($tracerProvider));

В PHP индустриальный пакет - open-telemetry/sdk. Bootstrap делается один раз при старте приложения (в Symfony - через bundle open-telemetry/opentelemetry-auto-symfony либо вручную в config/services.php).

tracer := otel.Tracer("user-api")

func handleRequest(ctx context.Context) error {
    ctx, span := tracer.Start(ctx, "handleRequest")
    defer span.End()

    span.SetAttributes(
        attribute.String("user.id", userID),
        attribute.Int("query.limit", 100),
    )

    // Дочерний span для БД
    if err := queryDB(ctx); err != nil {
        span.RecordError(err)
        span.SetStatus(codes.Error, err.Error())
        return err
    }
    return nil
}

func queryDB(ctx context.Context) error {
    ctx, span := tracer.Start(ctx, "db.query",
        trace.WithSpanKind(trace.SpanKindClient),
    )
    defer span.End()

    span.SetAttributes(
        attribute.String("db.system", "postgresql"),
        attribute.String("db.statement", "SELECT id FROM users WHERE ..."),
    )
    // ... выполнение запроса
    return nil
}

<?php
declare(strict_types=1);

use OpenTelemetry\API\Globals;
use OpenTelemetry\API\Trace\SpanKind;
use OpenTelemetry\API\Trace\StatusCode;
use OpenTelemetry\SemConv\TraceAttributes;

final class UserHandler
{
    public function handle(string $userId): void
    {
        $tracer = Globals::tracerProvider()->getTracer('user-api');

        $span = $tracer->spanBuilder('handleRequest')->startSpan();
        $scope = $span->activate();

        try {
            $span->setAttribute('user.id', $userId);
            $span->setAttribute('query.limit', 100);

            $this->queryDb($tracer);
        } catch (\Throwable $e) {
            $span->recordException($e);
            $span->setStatus(StatusCode::STATUS_ERROR, $e->getMessage());
            throw $e;
        } finally {
            $scope->detach();
            $span->end();
        }
    }

    private function queryDb($tracer): void
    {
        $span = $tracer->spanBuilder('db.query')
            ->setSpanKind(SpanKind::KIND_CLIENT)
            ->startSpan();
        $scope = $span->activate();

        try {
            $span->setAttribute(TraceAttributes::DB_SYSTEM, 'postgresql');
            $span->setAttribute(TraceAttributes::DB_STATEMENT, 'SELECT id FROM users WHERE ...');
            // ... выполнение запроса
        } finally {
            $scope->detach();
            $span->end();
        }
    }
}

В PHP нет context.Context - активный span хранится в глобальном Context::getCurrent(). Чтобы открыть child span, используется паттерн activate() с Scope: пока scope живёт, span - активный.

// На стороне клиента (исходящий запрос)
client := &http.Client{
    Transport: otelhttp.NewTransport(http.DefaultTransport),
}
req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
resp, _ := client.Do(req) // traceparent автоматически добавится

// На стороне сервера (входящий запрос)
http.Handle("/users", otelhttp.NewHandler(
    http.HandlerFunc(usersHandler),
    "users-endpoint",
))

<?php
declare(strict_types=1);

use OpenTelemetry\API\Globals;
use OpenTelemetry\Context\Context;
use OpenTelemetry\Context\Propagation\ArrayAccessGetterSetter;

// Сервер: извлечь parent-context из входящих заголовков
final class IncomingTraceExtractor
{
    public function extract(array $headers): Context
    {
        $propagator = Globals::propagator();
        return $propagator->extract($headers, ArrayAccessGetterSetter::getInstance());
    }
}

// Клиент: вшить traceparent в исходящий запрос (Symfony HttpClient)
final class TracingHttpClient
{
    public function __construct(
        private readonly \Symfony\Contracts\HttpClient\HttpClientInterface $inner,
    ) {}

    public function get(string $url): \Symfony\Contracts\HttpClient\ResponseInterface
    {
        $carrier = [];
        Globals::propagator()->inject($carrier, ArrayAccessGetterSetter::getInstance());

        return $this->inner->request('GET', $url, ['headers' => $carrier]);
    }
}

В Symfony с open-telemetry/opentelemetry-auto-symfony инструментирование HTTP-входов и HttpClient-исходящих делается автоматически. Если нужно вручную - используются propagators OTel SDK.

// Условный sampler: всегда сохранять ошибки
type errorSampler struct{}

func (e errorSampler) ShouldSample(p trace.SamplingParameters) trace.SamplingResult {
    // На старте мы не знаем про ошибку - это работает только для tail-based
    return trace.SamplingResult{Decision: trace.RecordAndSample}
}

<?php
declare(strict_types=1);

use OpenTelemetry\Context\ContextInterface;
use OpenTelemetry\SDK\Trace\SamplerInterface;
use OpenTelemetry\SDK\Trace\SamplingResult;

final class AlwaysRecordSampler implements SamplerInterface
{
    public function shouldSample(
        ContextInterface $parentContext,
        string $traceId,
        string $spanName,
        int $spanKind,
        \OpenTelemetry\SDK\Common\Attribute\AttributesInterface $attributes,
        array $links,
    ): SamplingResult {
        // На старте ничего не знаем про итоговый статус: решение по ошибкам
        // делается в tail-based sampling на OpenTelemetry Collector
        return new SamplingResult(SamplingResult::RECORD_AND_SAMPLE);
    }

    public function getDescription(): string
    {
        return 'AlwaysRecordSampler';
    }
}

В PHP SDK кастомный sampler - класс, реализующий SamplerInterface.

import "go.opentelemetry.io/otel/baggage"

// Сервис A: положить tenant_id в baggage
mem, _ := baggage.NewMember("tenant_id", tenantID)
bag, _ := baggage.New(mem)
ctx = baggage.ContextWithBaggage(ctx, bag)

// Делаем HTTP-запрос с otelhttp - baggage уходит в заголовке baggage:
client := &http.Client{Transport: otelhttp.NewTransport(http.DefaultTransport)}
req, _ := http.NewRequestWithContext(ctx, "GET", "http://service-b/api", nil)
client.Do(req)

// Сервис B: получить tenant_id
b := baggage.FromContext(ctx)
tenantID := b.Member("tenant_id").Value()

<?php
declare(strict_types=1);

use OpenTelemetry\API\Baggage\Baggage;
use OpenTelemetry\Context\Context;

// Сервис A: положить tenant_id в baggage
$baggage = Baggage::getBuilder()
    ->set('tenant_id', $tenantId)
    ->build();
$scope = Context::storage()->attach($baggage->storeInContext(Context::getCurrent()));

try {
    // Любой HTTP-запрос через autoinstrumented HttpClient автоматически
    // пробросит заголовок baggage: tenant_id=...
    $this->httpClient->request('GET', 'http://service-b/api');
} finally {
    $scope->detach();
}

// Сервис B: получить tenant_id из активного контекста
$tenantId = Baggage::fromContext(Context::getCurrent())->getValue('tenant_id');

В PHP SDK Baggage хранится в текущем Context. Activate-pattern такой же, как для span: пока scope живёт, baggage активен; на propagate его автоматически подхватит W3C-пропагатор и положит в заголовок baggage:.

// Producer
ctx, producerSpan := tracer.Start(ctx, "kafka.produce")
defer producerSpan.End()

// Сохраняем span context в headers сообщения
headers := propagation.HeaderCarrier{}
otel.GetTextMapPropagator().Inject(ctx, headers)
sendToKafka(topic, message, headers)

// Consumer (минуты или часы позже)
producerCtx := otel.GetTextMapPropagator().Extract(ctx, headers)
producerSpanCtx := trace.SpanContextFromContext(producerCtx)

// Создаём span с link на producer
ctx, consumerSpan := tracer.Start(
    context.Background(),
    "kafka.consume",
    trace.WithLinks(trace.Link{SpanContext: producerSpanCtx}),
)
defer consumerSpan.End()

<?php
declare(strict_types=1);

use OpenTelemetry\API\Globals;
use OpenTelemetry\API\Trace\SpanContext;
use OpenTelemetry\API\Trace\Span;
use OpenTelemetry\Context\Context;
use OpenTelemetry\Context\Propagation\ArrayAccessGetterSetter;

// Producer (отправка сообщения в очередь)
$tracer = Globals::tracerProvider()->getTracer('kafka-producer');
$producerSpan = $tracer->spanBuilder('kafka.produce')->startSpan();
$scope = $producerSpan->activate();
try {
    $headers = [];
    Globals::propagator()->inject($headers, ArrayAccessGetterSetter::getInstance());
    $this->kafkaProducer->send($topic, $message, $headers);
} finally {
    $scope->detach();
    $producerSpan->end();
}

// Consumer (минуты/часы позже)
$producerContext = Globals::propagator()->extract($message->headers, ArrayAccessGetterSetter::getInstance());
$producerSpanContext = Span::fromContext($producerContext)->getContext();

$consumerSpan = $tracer->spanBuilder('kafka.consume')
    ->addLink($producerSpanContext)
    ->startSpan();
$consumerSpan->end();

В Symfony Messenger sender/receiver - аналогичные роли. Producer вшивает trace-headers в message stamps; consumer достаёт их и линкует child-span к producer-span.

import semconv "go.opentelemetry.io/otel/semconv/v1.21.0"

res, _ := resource.New(ctx,
    resource.WithAttributes(
        semconv.ServiceName("user-api"),
        semconv.ServiceVersion(buildVersion),
        semconv.ServiceInstanceID(hostname),
        semconv.DeploymentEnvironment(env), // production/staging/dev
        semconv.K8SPodName(os.Getenv("POD_NAME")),
        semconv.K8SNamespaceName(os.Getenv("POD_NAMESPACE")),
        semconv.K8SNodeName(os.Getenv("NODE_NAME")),
    ),
)

<?php
declare(strict_types=1);

use OpenTelemetry\SDK\Resource\ResourceInfo;
use OpenTelemetry\SDK\Common\Attribute\Attributes;
use OpenTelemetry\SemConv\ResourceAttributes;

$resource = ResourceInfo::create(Attributes::create([
    ResourceAttributes::SERVICE_NAME => 'user-api',
    ResourceAttributes::SERVICE_VERSION => $buildVersion,
    ResourceAttributes::SERVICE_INSTANCE_ID => gethostname() ?: 'unknown',
    ResourceAttributes::DEPLOYMENT_ENVIRONMENT => $_SERVER['APP_ENV'] ?? 'dev',
    ResourceAttributes::K8S_POD_NAME => $_SERVER['POD_NAME'] ?? '',
    ResourceAttributes::K8S_NAMESPACE_NAME => $_SERVER['POD_NAMESPACE'] ?? '',
    ResourceAttributes::K8S_NODE_NAME => $_SERVER['NODE_NAME'] ?? '',
]));

В PHP SDK semconv-константы лежат в пакете open-telemetry/sem-conv (класс ResourceAttributes).