Jaeger Client PHP

https://github.com/jonahgeorge/jaeger-client-php
Admin
A client-side library for instrumenting PHP applications to send distributed traces to Jaeger,...
Tokens:33,217
Snippets:411
Trust Score:9.1
License:MIT
Update:2 months ago
Show doc for...
Tokens:
Raw
### Initialize Tracer Instance

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Tracer.md

Example showing the instantiation of a Tracer with a reporter, sampler, and custom configuration tags.

```php
use Jaeger\Tracer;
use Jaeger\Reporter\JaegerReporter;
use Jaeger\Sampler\ConstSampler;

$reporter = new JaegerReporter($sender);
$sampler = new ConstSampler(true);

$tracer = new Tracer(
    'my-service',
    $reporter,
    $sampler,
    true,
    $logger,
    null,
    'uber-trace-id',
    'uberctx-',
    'jaeger-debug-id',
    ['environment' => 'production']
);
```

--------------------------------

### Initialize Tracer

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/README.md

Demonstrates tracer setup using the recommended configuration object or direct class instantiation.

```php
// Via Config (recommended)
$config = new Config($configArray, 'service-name', $logger, $cache);
$tracer = $config->initializeTracer();

// Direct instantiation
$tracer = new Tracer(
    'service-name',
    $reporter,
    $sampler,
    true,
    $logger
);
```

--------------------------------

### LoggingReporter Usage Example

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Reporters.md

Example of initializing a LoggingReporter with a custom PSR-3 logger.

```php
use Jaeger\Reporter\LoggingReporter;
use Psr\Log\LoggerInterface;

class MyLogger implements LoggerInterface { /* ... */ }

$logger = new MyLogger();
$loggingReporter = new LoggingReporter($logger);
```

--------------------------------

### Install project dependencies

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/tests/README.md

Install the required PHPUnit dependency using Composer from the project root.

```bash
# run this command from project root
$ composer install
```

--------------------------------

### Initialize and use Tracer

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Tracer.md

Demonstrates initializing the tracer via Config, starting active spans, extracting context, and flushing the tracer before shutdown.

```php
use Jaeger\Config;
use OpenTracing\GlobalTracer;

// Initialize via Config
$config = new Config([
    'sampler' => ['type' => 'const', 'param' => true],
], 'my-service');
$config->initializeTracer();

// Get the tracer
$tracer = GlobalTracer::get();

// Create and use spans
$scope = $tracer->startActiveSpan('request.handler', [
    'tags' => ['http.method' => 'GET'],
]);

$span = $scope->getSpan();
$span->setTag('http.status_code', 200);

// Extract trace context from incoming request
$incomingContext = $tracer->extract(HTTP_HEADERS, $_SERVER);
if ($incomingContext) {
    // Inherit parent trace
    $span->getContext()->withBaggageItem('user_id', '123');
}

$span->finish();
$scope->close();

// Before shutdown
$tracer->flush();
```

--------------------------------

### Start a span with Tracer

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Tracer.md

Demonstrates creating simple spans, spans with tags, and spans with parent references.

```php
// Simple span
$span = $tracer->startSpan('database.query');

// With tags and options
$span = $tracer->startSpan('http.request', [
    'tags' => [
        'http.method' => 'GET',
        'http.url' => '/api/users',
    ],
]);

// With parent span
$parentSpan = $tracer->startSpan('parent');
$childSpan = $tracer->startSpan('child', [
    'child_of' => $parentSpan->getContext(),
]);
```

--------------------------------

### Initialize and Use Jaeger Tracer

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/README.md

Basic setup for initializing the tracer and starting a span in a PHP application.

```php
<?php

require_once 'vendor/autoload.php';

use Jaeger\Config;
use OpenTracing\GlobalTracer;

$config = new Config(
    [
        'sampler' => [
            'type' => Jaeger\SAMPLER_TYPE_CONST,
            'param' => true,
        ],
        'logging' => true,
    ],
    'your-app-name'
);
$config->initializeTracer();

$tracer = GlobalTracer::get();

$scope = $tracer->startActiveSpan('TestSpan', []);
$scope->close();

$tracer->flush();
```

--------------------------------

### JaegerReporterFactory Usage Example

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Factories.md

Demonstrates initializing a JaegerReporterFactory with a configuration object and creating a reporter.

```php
use Jaeger\Config;
use Jaeger\ReporterFactory\JaegerReporterFactory;

$config = new Config(
    [
        'dispatch_mode' => Config::JAEGER_OVER_BINARY_UDP,
        'local_agent' => [
            'reporting_host' => 'jaeger-agent',
            'reporting_port' => 6832,
        ],
    ],
    'my-service'
);

$factory = new JaegerReporterFactory($config);
$reporter = $factory->createReporter();
```

--------------------------------

### Configure Jaeger Client Dispatch Mode

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/README.md

Example configuration array demonstrating how to set the dispatch_mode and other client settings.

```php
// config.php

use Jaeger\Config;

return [
    'sampler' => [
        'type' => Jaeger\SAMPLER_TYPE_CONST,
        'param' => true,
    ],
    'logging' => true,
    "tags" => [
        // process. prefix works only with JAEGER_OVER_HTTP, JAEGER_OVER_BINARY
        // otherwise it will be shown as simple global tag
        "process.process-tag-key-1" => "process-value-1", // all tags with `process.` prefix goes to process section
        "process.process-tag-key-2" => "process-value-2", // all tags with `process.` prefix goes to process section
        "global-tag-key-1" => "global-tag-value-1", // this tag will be appended to all spans
        "global-tag-key-2" => "global-tag-value-2", // this tag will be appended to all spans
    ],
    "local_agent" => [
        "reporting_host" => "localhost", 
//        You can override port by setting local_agent.reporting_port value   
        "reporting_port" => 6832
    ],
//     Different ways to send data to Jaeger. Config::ZIPKIN_OVER_COMPACT - default):
    'dispatch_mode' => Config::JAEGER_OVER_BINARY_UDP,
];
```

--------------------------------

### Install Jaeger Client via Composer

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/README.md

Use Composer to add the library to your project dependencies.

```bash
composer require jonahgeorge/jaeger-client-php
```

--------------------------------

### CompositeReporter Usage Example

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Reporters.md

Example of combining multiple reporters using CompositeReporter.

```php
use Jaeger\Reporter\CompositeReporter;
use Jaeger\Reporter\JaegerReporter;
use Jaeger\Reporter\LoggingReporter;

$jaegerReporter = new JaegerReporter($sender);
$loggingReporter = new LoggingReporter($logger);

$composite = new CompositeReporter($jaegerReporter, $loggingReporter);
// Spans are sent to both Jaeger and logged
```

--------------------------------

### Baggage Headers Format

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Codecs.md

Example of baggage headers using the default prefix.

```text
uberctx-user_id: user123
uberctx-request_id: req456
uberctx-session: abc123def456
```

--------------------------------

### Start an active span

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Tracer.md

Creates a span and automatically sets it as the current active span in the scope manager.

```php
// Active span is automatically set as current
$scope = $tracer->startActiveSpan('request.handler');
$currentSpan = $tracer->getActiveSpan();  // Returns the same span

// Scope can be closed to restore previous scope
$scope->close();
```

--------------------------------

### Scope Management in Request Handlers

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/ScopeManager.md

Example of extracting context from incoming headers and managing scope within a request handler.

```php
class RequestHandler
{
    public function handle(Request $request): Response
    {
        // Extract parent context from incoming request
        $parentContext = GlobalTracer::get()->extract(HTTP_HEADERS, $_SERVER);
        
        $scope = GlobalTracer::get()->startActiveSpan('http.request', [
            'child_of' => $parentContext,
            'tags' => [
                'http.method' => $request->getMethod(),
                'http.url' => $request->getUri(),
            ],
        ]);
        
        try {
            $result = $this->processRequest($request);
            $scope->getSpan()->setTag('http.status_code', 200);
            return $result;
        } catch (Exception $e) {
            $scope->getSpan()->setTag('error', true);
            $scope->getSpan()->log([
                'event' => 'error',
                'message' => $e->getMessage(),
            ]);
            throw $e;
        } finally {
            $scope->close();
        }
    }
}
```

--------------------------------

### Initialize Tracer with Full Configuration

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Config.md

Configures the tracer with sampler settings, dispatch mode, logging, tags, and agent connection details.

```php
use Jaeger\Config;
use Jaeger\SAMPLER_TYPE_PROBABILISTIC;

$config = new Config(
    [
        'sampler' => [
            'type' => SAMPLER_TYPE_PROBABILISTIC,
            'param' => 0.1,  // 10% of traces
        ],
        'dispatch_mode' => Config::JAEGER_OVER_BINARY_UDP,
        'logging' => true,
        'tags' => [
            'process.version' => '1.0.0',
            'process.environment' => 'production',
            'app.feature' => 'checkout',
        ],
        'local_agent' => [
            'reporting_host' => 'jaeger-agent.internal',
            'reporting_port' => 6832,
        ],
        'max_buffer_length' => 100000,
        'one_span_per_rpc' => true,
    ],
    'payment-service'
);

$tracer = $config->initializeTracer();
```

--------------------------------

### Trace ID Header Format

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Codecs.md

Example of the uber-trace-id header structure.

```text
uber-trace-id: 1a2b3c:4d5e6f:7g8h9i:1
```

--------------------------------

### Initialize tracer with sampler

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Samplers.md

Manually instantiates a ProbabilisticSampler and attaches it to the tracer.

```php
use Jaeger\Tracer;
use Jaeger\Sampler\ProbabilisticSampler;
use Jaeger\Reporter\RemoteReporter;
// ...

$sampler = new ProbabilisticSampler(0.01);
$tracer = new Tracer('my-service', $reporter, $sampler);
```

--------------------------------

### Initialize and manage a span in PHP

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Span.md

Demonstrates initializing the tracer, creating a span with initial tags, updating tags during execution, and handling errors with logging.

```php
use Jaeger\Config;
use OpenTracing\GlobalTracer;
use OpenTracing\Tags\SPAN_KIND_RPC_CLIENT;

$config = new Config([...], 'my-service');
$config->initializeTracer();
$tracer = GlobalTracer::get();

// Create a span
$span = $tracer->startSpan('database.query', [
    'tags' => [
        'component' => 'postgres',
        'db.type' => 'sql',
        'db.instance' => 'mydb',
    ],
]);

// Set tags
$span->setTag('db.statement', 'SELECT * FROM users WHERE id = 42');
$span->setTag('peer.service', 'postgres-primary');
$span->setTag('peer.ipv4', '10.0.1.50');
$span->setTag('peer.port', 5432);

try {
    // ... execute query ...
    $rows = 1;
    $span->setTag('db.rows_affected', $rows);
} catch (Exception $e) {
    // Log error
    $span->setTag('error', true);
    $span->log([
        'event' => 'error',
        'message' => $e->getMessage(),
        'stack' => $e->getTraceAsString(),
    ]);
    throw $e;
} finally {
    $span->finish();
}
```

--------------------------------

### RemoteReporter Shutdown Example

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Reporters.md

Ensures all buffered spans are flushed before the application terminates.

```php
register_shutdown_function(function() {
    $tracer->flush();  // Calls reporter->close()
});
```

--------------------------------

### Configure Jaeger Tracer Instance

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Config.md

Demonstrates how to instantiate the Config class with sampler settings, dispatch mode, and service identification.

```php
use Jaeger\Config;
use Jaeger\SAMPLER_TYPE_CONST;

$config = new Config(
    [
        'sampler' => [
            'type' => SAMPLER_TYPE_CONST,
            'param' => true,
        ],
        'dispatch_mode' => Config::JAEGER_OVER_BINARY_UDP,
        'logging' => true,
    ],
    'my-service'
);
```

--------------------------------

### Get active span

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Tracer.md

Retrieves the currently active span if one exists.

```php
$activeSpan = $tracer->getActiveSpan();
if ($activeSpan) {
    $activeSpan->setTag('key', 'value');
}
```

--------------------------------

### Configure Development Sampler

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/README.md

Use this configuration to capture all traces during development.

```php
$config = new Config(
    [
        'sampler' => ['type' => 'const', 'param' => true],
        'logging' => true,
    ],
    'my-app'
);
```

--------------------------------

### RateLimiter::initialize

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Advanced.md

Sets up the rate limiter's token generation and burst parameters.

```APIDOC
## public function initialize(float $creditsPerNanosecond, float $maxBalance): void

### Description
Sets up the rate limiter's token generation and burst parameters.

### Parameters
- **$creditsPerNanosecond** (float) - Required - Token generation rate (calculated from traces/second)
- **$maxBalance** (float) - Required - Maximum token balance (burst allowance)
```

--------------------------------

### Config::__construct

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Config.md

Initializes a new instance of the Jaeger tracer configuration.

```APIDOC
## __construct

### Description
Initializes and configures the Jaeger tracer. This constructor handles the setup of samplers, reporters, and dispatch modes.

### Signature
`public function __construct(array $config, ?string $serviceName = null, ?LoggerInterface $logger = null, ?CacheItemPoolInterface $cache = null)`

### Parameters
- **$config** (array) - Required - Configuration array containing sampler, reporter, and dispatch settings.
- **$serviceName** (string|null) - Optional - The name of the service. Can also be defined within the $config array.
- **$logger** (LoggerInterface|null) - Optional - A PSR-3 logger instance for tracing logs.
- **$cache** (CacheItemPoolInterface|null) - Optional - A PSR-6 cache pool used for rate-limiting sampler state.

### Throws
- **Exception** - Thrown if the service_name is not provided in the configuration or as a parameter.

### Example
```php
use Jaeger\Config;
use Jaeger\SAMPLER_TYPE_CONST;

$config = new Config(
    [
        'sampler' => [
            'type' => SAMPLER_TYPE_CONST,
            'param' => true,
        ],
        'dispatch_mode' => Config::JAEGER_OVER_BINARY_UDP,
        'logging' => true,
    ],
    'my-service'
);
```
```

--------------------------------

### Configure Production Tracer

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/configuration.md

Use probabilistic sampling for production environments to reduce overhead.

```php
use Jaeger\Config;
use Jaeger\SAMPLER_TYPE_PROBABILISTIC;

$config = new Config(
    [
        'sampler' => [
            'type' => SAMPLER_TYPE_PROBABILISTIC,
            'param' => 0.01,  // 1% sampling
        ],
        'dispatch_mode' => Config::JAEGER_OVER_BINARY_UDP,
        'local_agent' => [
            'reporting_host' => getenv('JAEGER_AGENT_HOST') ?: 'localhost',
            'reporting_port' => intval(getenv('JAEGER_AGENT_PORT') ?: 6832),
        ],
        'tags' => [
            'environment' => 'production',
            'version' => '1.2.3',
            'process.machine' => gethostname(),
        ],
    ],
    'payment-service'
);

$tracer = $config->initializeTracer();
```

--------------------------------

### Instantiate ProbabilisticSampler

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Samplers.md

Initialize the sampler with a specific probability rate between 0.0 and 1.0.

```php
use Jaeger\Sampler\ProbabilisticSampler;

// Sample 10% of traces
$sampler = new ProbabilisticSampler(0.1);

// Sample 100% of traces
$sampler = new ProbabilisticSampler(1.0);

// Sample 0% of traces (can be useful for testing)
$sampler = new ProbabilisticSampler(0.0);
```

--------------------------------

### Recover with Valid Time Types

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/errors.md

Shows valid time formats including integer, float, and DateTime objects for span start times.

```php
use DateTime;

// Use valid time types
$span = $tracer->startSpan('op', [
    'start_time' => time(),  // int (seconds)
    // OR
    'start_time' => microtime(true),  // float (seconds)
    // OR
    'start_time' => new DateTime(),  // DateTime
]);
```

--------------------------------

### Initialize RateLimiter with PHP

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Advanced.md

Configures the token generation rate and burst capacity for the rate limiter.

```php
$rateLimiter = new RateLimiter($cache, 'rate.balance', 'rate.tick');

// For 100 traces per second with burst of 1.0
$maxTracesPerSecond = 100;
$creditsPerNanosecond = $maxTracesPerSecond / 1000000000.0;
$maxBalance = $maxTracesPerSecond > 1.0 ? 1.0 : $maxTracesPerSecond;

$rateLimiter->initialize($creditsPerNanosecond, $maxBalance);
```

--------------------------------

### Initialize ConstSampler

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Samplers.md

Creates a sampler that consistently returns the same decision for all traces.

```php
public function __construct(bool $decision = true)
```

```php
use Jaeger\
Sampler\\ConstSampler;

// Sample all traces
$sampler = new ConstSampler(true);

// Sample no traces (debug only)
$sampler = new ConstSampler(false);
```

--------------------------------

### Configure Tracer with JaegerReporterFactory

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Reporters.md

Initializes a tracer using the Jaeger binary UDP dispatch mode.

```php
$config = new Config([
    'dispatch_mode' => Config::JAEGER_OVER_BINARY_UDP,  // Uses JaegerReporterFactory
    'local_agent' => [
        'reporting_host' => 'localhost',
        'reporting_port' => 6832,
    ],
], 'my-service');

$tracer = $config->initializeTracer();
```

--------------------------------

### Create a Tracer Instance

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Config.md

Creates a tracer instance using explicit reporter and sampler dependencies.

```php
$reporter = new JaegerReporter($sender);
$sampler = new ConstSampler(true);
$tracer = $config->createTracer($reporter, $sampler);
```

--------------------------------

### Configure RateLimitingSampler via Config

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Samplers.md

Set up the rate-limiting sampler using a PSR-6 cache pool for state persistence.

```php
use Jaeger\Config;
use Cache\Adapter\Apc\ApcCachePool;

$cache = new ApcCachePool();

$config = new Config(
    [
        'sampler' => [
            'type' => SAMPLER_TYPE_RATE_LIMITING,
            'param' => 100,  // 100 traces/second
            'cache' => [
                'currentBalanceKey' => 'jaeger.rate.balance',
                'lastTickKey' => 'jaeger.rate.tick',
            ],
        ],
    ],
    'my-service',
    null,
    $cache
);
```

--------------------------------

### Configure ConstSampler via Config

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Samplers.md

Sets up the constant sampler using the main configuration object.

```php
$config = new Config([
    'sampler' => [
        'type' => SAMPLER_TYPE_CONST,
        'param' => true,  // or false
    ],
], 'my-service');
```

--------------------------------

### Tracer::__construct

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Tracer.md

Initializes a new instance of the Tracer class with the required reporter, sampler, and optional configuration settings.

```APIDOC
## Constructor

### Description
Initializes a new Tracer instance to coordinate span creation and reporting.

### Signature
`public function __construct(string $serviceName, ReporterInterface $reporter, SamplerInterface $sampler, bool $oneSpanPerRpc = true, ?LoggerInterface $logger = null, ?ScopeManager $scopeManager = null, string $traceIdHeader = TRACE_ID_HEADER, string $baggageHeaderPrefix = BAGGAGE_HEADER_PREFIX, string $debugIdHeader = DEBUG_ID_HEADER_KEY, ?array $tags = null)`

### Parameters
- **$serviceName** (string) - Required - Service identifier for this tracer instance
- **$reporter** (ReporterInterface) - Required - Span reporter (handles span transmission)
- **$sampler** (SamplerInterface) - Required - Sampling decision maker
- **$oneSpanPerRpc** (bool) - Optional - Use Zipkin-style one-span-per-RPC model (default: true)
- **$logger** (LoggerInterface|null) - Optional - PSR-3 logger (default: null)
- **$scopeManager** (ScopeManager|null) - Optional - Scope manager (default: null)
- **$traceIdHeader** (string) - Optional - HTTP header name for trace ID
- **$baggageHeaderPrefix** (string) - Optional - Prefix for baggage headers
- **$debugIdHeader** (string) - Optional - HTTP header name for debug ID
- **$tags** (array|null) - Optional - Global tags attached to all spans
```

--------------------------------

### Execute unit tests

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/tests/README.md

Run the full test suite using the configured Composer command.

```bash
$ composer test
```

--------------------------------

### Configure Production Sampler

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/README.md

Use this configuration for high-volume production environments with probabilistic sampling.

```php
$config = new Config(
    [
        'sampler' => ['type' => 'probabilistic', 'param' => 0.01],
        'dispatch_mode' => Config::JAEGER_OVER_BINARY_UDP,
        'local_agent' => [
            'reporting_host' => 'jaeger-agent',
            'reporting_port' => 6832,
        ],
        'tags' => ['environment' => 'production'],
    ],
    'my-service'
);
```

--------------------------------

### Define Version and Metadata Tags

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/types.md

Tracer version and hostname tags.

```php
const JAEGER_CLIENT_VERSION = 'PHP-' . PHP_VERSION;
const JAEGER_VERSION_TAG_KEY = 'jaeger.version';
const JAEGER_HOSTNAME_TAG_KEY = 'jaeger.hostname';
```

--------------------------------

### Configure Development Tracer

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/configuration.md

Use constant sampling to capture all traces during development.

```php
use Jaeger\Config;
use Jaeger\SAMPLER_TYPE_CONST;

$config = new Config(
    [
        'sampler' => [
            'type' => SAMPLER_TYPE_CONST,
            'param' => true,  // Sample everything
        ],
        'logging' => true,  // Log all spans for visibility
    ],
    'my-app'
);

$tracer = $config->initializeTracer();
```

--------------------------------

### Implement SamplerInterface

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Samplers.md

Defines the contract for all sampler implementations.

```php
interface SamplerInterface
{
    public function isSampled(string $traceId, string $operation): array;
    public function close(): void;
}
```

--------------------------------

### Tracer Constructor Signature

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Tracer.md

The constructor requires a service name, reporter, and sampler, with optional parameters for configuration and logging.

```php
public function __construct(
    string $serviceName,
    ReporterInterface $reporter,
    SamplerInterface $sampler,
    bool $oneSpanPerRpc = true,
    ?LoggerInterface $logger = null,
    ?ScopeManager $scopeManager = null,
    string $traceIdHeader = TRACE_ID_HEADER,
    string $baggageHeaderPrefix = BAGGAGE_HEADER_PREFIX,
    string $debugIdHeader = DEBUG_ID_HEADER_KEY,
    ?array $tags = null
)
```

--------------------------------

### RateLimiter::__construct

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Samplers.md

Initializes the RateLimiter utility with a PSR-6 cache backend.

```APIDOC
## public function __construct(CacheItemPoolInterface $cache, string $currentBalanceKey, string $lastTickKey)

### Description
Initializes the RateLimiter utility to manage rate-limiting state using a PSR-6 cache backend.

### Parameters
- **$cache** (CacheItemPoolInterface) - Required - PSR-6 cache pool
- **$currentBalanceKey** (string) - Required - Cache key for balance
- **$lastTickKey** (string) - Required - Cache key for last tick time
```

--------------------------------

### Project File Structure

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/INDEX.md

The directory layout for the documentation files.

```text
/output/
├── INDEX.md                    # This file
├── README.md                   # Quick start and overview
├── configuration.md            # Configuration options and examples
├── types.md                    # Constants and type definitions
├── errors.md                   # Exception and error reference
└── api-reference/
    ├── Config.md              # Tracer configuration
    ├── Tracer.md              # Main tracer class
    ├── Span.md                # Span implementation
    ├── SpanContext.md         # Span context and identity
    ├── ScopeManager.md        # Scope lifecycle management
    ├── Samplers.md            # Sampling strategies
    ├── Reporters.md           # Span reporting backends
    ├── Codecs.md              # Trace propagation
    ├── Factories.md           # Reporter factories
    └── Advanced.md            # Advanced components
```

--------------------------------

### Manually Initialize Tracer with ReporterFactory

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Factories.md

Instantiate a reporter and tracer manually using the JaegerReporterFactory. This approach is typically reserved for advanced configurations where automatic initialization is insufficient.

```php
use Jaeger\Config;
use Jaeger\ReporterFactory\JaegerReporterFactory;
use Jaeger\Sampler\ConstSampler;
use Jaeger\Tracer;

// Create config (but don't auto-initialize)
$config = new Config([...], 'my-service');

// Manually create reporter using factory
$reporterFactory = new JaegerReporterFactory($config);
$reporter = $reporterFactory->createReporter();

// Create sampler
$sampler = new ConstSampler(true);

// Create tracer manually
$tracer = new Tracer('my-service', $reporter, $sampler);

// Use tracer
$span = $tracer->startSpan('operation');
$span->finish();

// Manual cleanup
$tracer->flush();
```

--------------------------------

### Initialize RateLimiter

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Samplers.md

Constructor for the RateLimiter utility requiring a PSR-6 cache pool and cache keys.

```php
public function __construct(
    CacheItemPoolInterface $cache,
    string $currentBalanceKey,
    string $lastTickKey
)
```

--------------------------------

### Automatic Scope Management

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/ScopeManager.md

Recommended pattern using startActiveSpan to handle span creation and activation automatically.

```php
$tracer = GlobalTracer::get();

// Creates span and activates it in one call
$scope = $tracer->startActiveSpan('http.request', [
    'tags' => ['http.method' => 'GET'],
]);

try {
    // $tracer->getActiveSpan() returns this span
    $span = $tracer->getActiveSpan();
    $span->setTag('http.status_code', 200);
    
    // Child spans automatically inherit parent
    $dbScope = $tracer->startActiveSpan('db.query');
    try {
        // ... query ...
    } finally {
        $dbScope->close();
    }
} finally {
    // Closes and finishes the span
    $scope->close();
}
```

--------------------------------

### Implement Custom Sampler

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Advanced.md

Create a custom sampling strategy by implementing SamplerInterface to control trace sampling rates per operation.

```php
use Jaeger\Sampler\SamplerInterface;

class CustomSampler implements SamplerInterface
{
    private $operationRates = [];
    
    public function __construct(array $operationRates = [])
    {
        $this->operationRates = $operationRates;
    }
    
    public function isSampled(string $traceId, string $operation = ''): array
    {
        $rate = $this->operationRates[$operation] ?? 0.1;
        $sampled = (random_int(0, 100) / 100) <= $rate;
        
        return [$sampled, [
            'sampler.type' => 'custom',
            'sampler.operation' => $operation,
        ]];
    }
    
    public function close()
    {
        // Cleanup
    }
}

// Use custom sampler
$sampler = new CustomSampler([
    'database.query' => 0.05,  // 5% for database
    'http.request' => 0.1,      // 10% for HTTP
]);

$tracer = new Tracer('my-service', $reporter, $sampler);
```

--------------------------------

### Implement Graceful Degradation for Tracer Initialization

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/errors.md

Use a try-catch block to fall back to a no-op tracer if the primary Jaeger configuration fails to initialize.

```php
use Jaeger\Config;
use Jaeger\Reporter\NullReporter;
use Jaeger\Sampler\ConstSampler;

try {
    $config = new Config([...], 'my-service', $logger, $cache);
    $tracer = $config->initializeTracer();
} catch (Exception $e) {
    // Fall back to no-op tracing
    $logger->error('Failed to initialize Jaeger tracer', ['error' => $e]);
    
    $noop = new Tracer(
        'my-service',
        new NullReporter(),
        new ConstSampler(false),
    );
    GlobalTracer::set($noop);
}
```

--------------------------------

### Enable Logging Reporter

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Reporters.md

Configures the tracer to use a Zipkin reporter wrapped in a CompositeReporter with logging enabled.

```php
$config = new Config([
    'dispatch_mode' => Config::ZIPKIN_OVER_COMPACT_UDP,
    'logging' => true,  // Wraps reporter in CompositeReporter with LoggingReporter
], 'my-service', $logger);
```

--------------------------------

### initializeTracer()

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Config.md

Initializes the Jaeger tracer and registers it as the global tracer via OpenTracing\GlobalTracer::set().

```APIDOC
## initializeTracer()

### Description
Initializes the Jaeger tracer and registers it as the global tracer via `OpenTracing\GlobalTracer::set()`.

### Returns
- **Tracer|null** - Returns `null` if tracer was already initialized.

### Throws
- **Exception** - on invalid configuration or missing cache for rate-limiting sampler.
```

--------------------------------

### Create Zipkin Reporter with ZipkinReporterFactory

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Factories.md

Instantiates a reporter configured for the Zipkin Thrift protocol using compact UDP transport.

```php
use Jaeger\Config;
use Jaeger\ReporterFactory\ZipkinReporterFactory;

$config = new Config(
    [
        'dispatch_mode' => Config::ZIPKIN_OVER_COMPACT_UDP,
        'local_agent' => [
            'reporting_host' => 'zipkin-collector',
            'reporting_port' => 5775,
        ],
    ],
    'my-service'
);

$factory = new ZipkinReporterFactory($config);
$reporter = $factory->createReporter();
```

--------------------------------

### Accessing and Propagating SpanContext in PHP

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/SpanContext.md

Demonstrates initializing the tracer, accessing span context properties, managing baggage items, and injecting context into headers.

```php
use Jaeger\Config;
use Jaeger\SAMPLER_FLAG;
use OpenTracing\GlobalTracer;

$config = new Config([...], 'my-service');
$config->initializeTracer();
$tracer = GlobalTracer::get();

// Create a span
$span = $tracer->startSpan('process.message');
$context = $span->getContext();

// Access context properties
echo "Trace ID: " . $context->getTraceId() . "\n";
echo "Span ID: " . $context->getSpanId() . "\n";
echo "Sampled: " . (($context->getFlags() & SAMPLED_FLAG) ? 'yes' : 'no') . "\n";

// Add baggage and create new context
$contextWithBaggage = $context->withBaggageItem('user_id', 'user123');
$contextWithBaggage = $contextWithBaggage->withBaggageItem('request_id', 'req456');

// Iterate over baggage
foreach ($contextWithBaggage as $key => $value) {
    echo "Baggage: $key => $value\n";
}

// Propagate to downstream service
$headers = [];
$tracer->inject($context, HTTP_HEADERS, $headers);
// $headers contains uber-trace-id, uberctx-user_id, uberctx-request_id
```

--------------------------------

### Tracer Inject Usage

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Codecs.md

Demonstrates using format constants with the tracer inject method.

```php
use const OpenTracing\Formats\HTTP_HEADERS;
use const OpenTracing\Formats\TEXT_MAP;
use const OpenTracing\Formats\BINARY;

$tracer->inject($context, HTTP_HEADERS, $headers);
$tracer->inject($context, TEXT_MAP, $map);
$tracer->inject($context, BINARY, $buffer);
```

--------------------------------

### Configure Rate-Limited Tracer

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/configuration.md

Implement rate-limiting using a cache adapter to control trace volume.

```php
use Jaeger\Config;
use Jaeger\SAMPLER_TYPE_RATE_LIMITING;
use Cache\Adapter\Apc\ApcCachePool;

$cache = new ApcCachePool();

$config = new Config(
    [
        'sampler' => [
            'type' => SAMPLER_TYPE_RATE_LIMITING,
            'param' => 100,  // 100 traces per second
            'cache' => [
                'currentBalanceKey' => 'jaeger.rate.balance',
                'lastTickKey' => 'jaeger.rate.tick',
            ],
        ],
        'dispatch_mode' => Config::JAEGER_OVER_BINARY_HTTP,
        'local_agent' => [
            'reporting_host' => 'jaeger-collector.internal',
            'reporting_port' => 14268,
        ],
        'logging' => false,
    ],
    'critical-service',
    $logger,
    $cache
);

$tracer = $config->initializeTracer();
```

--------------------------------

### startActiveSpan

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Tracer.md

Creates a span and automatically activates it in the scope manager.

```APIDOC
## startActiveSpan(string $operationName, array|StartSpanOptions $options = [])

### Description
Creates a span and automatically activates it in the scope manager.

### Parameters
- **$operationName** (string) - Required - Operation name
- **$options** (array|StartSpanOptions) - Optional - Span options

### Returns
- **Scope** - An active scope wrapping the span
```

--------------------------------

### Override Configuration via Environment Variables

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/configuration.md

Use environment variables to define tracer settings, which take precedence over code-based configuration.

```php
// Set environment variables
putenv('JAEGER_SERVICE_NAME=my-service');
putenv('JAEGER_SAMPLER_TYPE=probabilistic');
putenv('JAEGER_SAMPLER_PARAM=0.1');
putenv('JAEGER_AGENT_HOST=jaeger-agent');
putenv('JAEGER_AGENT_PORT=6832');

// Config reads from environment
$config = new Config([], 'fallback-service');  // Service name from env takes precedence

$tracer = $config->initializeTracer();
```

--------------------------------

### Define Sampler Configuration Defaults

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/types.md

Default values for sampling strategies.

```php
const DEFAULT_SAMPLING_PROBABILITY = 0.001;
const DEFAULT_LOWER_BOUND = 1.0 / (10.0 * 60.0);
const DEFAULT_SAMPLING_INTERVAL = 60;
const DEFAULT_MAX_OPERATIONS = 2000;
```

--------------------------------

### Initialize the Jaeger Tracer

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Config.md

Initializes the tracer and registers it as the global tracer. Returns null if the tracer has already been initialized.

```php
$config = new Config([...], 'my-service');
$tracer = $config->initializeTracer();

// Now accessible globally
$globalTracer = \OpenTracing\GlobalTracer::get();
```

--------------------------------

### Implementing a Custom Reporter Factory

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Factories.md

Implement ReporterFactoryInterface to create custom reporter logic, then pass the factory instance to the tracer configuration.

```php
use Jaeger\Reporter\ReporterInterface;
use Jaeger\ReporterFactory\ReporterFactoryInterface;
use Jaeger\Config;

class CustomReporterFactory implements ReporterFactoryInterface
{
    private $config;
    
    public function __construct(Config $config)
    {
        $this->config = $config;
    }
    
    public function createReporter(): ReporterInterface
    {
        // Create custom reporter based on config
        return new CustomReporter(
            $this->config->getServiceName(),
            $this->config->getLogger()
        );
    }
}

class CustomReporter implements ReporterInterface
{
    private $serviceName;
    private $logger;
    private $spans = [];
    
    public function __construct($serviceName, $logger)
    {
        $this->serviceName = $serviceName;
        $this->logger = $logger;
    }
    
    public function reportSpan(Span $span): void
    {
        $this->spans[] = $span;
        
        // Send immediately or batch
        if (count($this->spans) >= 10) {
            $this->flush();
        }
    }
    
    public function close(): void
    {
        $this->flush();
    }
    
    private function flush()
    {
        foreach ($this->spans as $span) {
            // Send span to custom backend
            $this->logger->info('Span: ' . $span->getOperationName());
        }
        $this->spans = [];
    }
}

// Usage
$factory = new CustomReporterFactory($config);
$reporter = $factory->createReporter();
$tracer = $config->createTracer($reporter, $sampler);
```

--------------------------------

### Configuration Getters

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Config.md

Methods to retrieve current configuration settings for the tracer.

```APIDOC
## Configuration Getters

### Methods
- **getServiceName()**: string - Returns the service name configured.
- **getDispatchMode()**: string - Returns the dispatch mode.
- **getMaxBufferLength()**: int - Returns the maximum UDP buffer length for span transmission (default 64000).
- **getLocalAgentReportingHost()**: string - Returns hostname or IP of Jaeger agent (default 'localhost').
- **getLocalAgentReportingPort()**: int - Returns the reporting port for the Jaeger agent.
- **getLogger()**: LoggerInterface - Returns the configured PSR-3 logger.
- **ipProtocolVersion()**: string - Returns either 'IPv4' or 'IPv6'.
```

--------------------------------

### Handle Already Initialized Tracer Warning

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/errors.md

Calling initializeTracer multiple times on the same instance logs a warning and returns null instead of throwing an exception.

```php
$config = new Config([...], 'my-service', $logger);
$tracer1 = $config->initializeTracer();
$tracer2 = $config->initializeTracer();  // Returns null, logs warning

assert($tracer2 === null);
```

--------------------------------

### Configure sampler via array

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Samplers.md

Defines sampler settings within the configuration array for the tracer.

```php
$config = new Config([
    'sampler' => [
        'type' => SAMPLER_TYPE_PROBABILISTIC,
        'param' => 0.1,
    ],
], 'my-service');
```

--------------------------------

### createTracer()

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Config.md

Creates a Tracer instance with explicit reporter and sampler dependencies.

```APIDOC
## createTracer(ReporterInterface $reporter, SamplerInterface $sampler)

### Description
Creates a `Tracer` instance with explicit reporter and sampler dependencies.

### Parameters
- **$reporter** (ReporterInterface) - Required - Span reporter implementation
- **$sampler** (SamplerInterface) - Required - Sampling decision maker

### Returns
- **Tracer** - configured tracer instance
```

--------------------------------

### TextCodec Constructor

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Codecs.md

Initializes the TextCodec with optional custom header names and URL encoding settings.

```php
public function __construct(
    bool $urlEncoding = false,
    string $traceIdHeader = TRACE_ID_HEADER,
    string $baggageHeaderPrefix = BAGGAGE_HEADER_PREFIX,
    string $debugIdHeader = DEBUG_ID_HEADER_KEY
)
```

--------------------------------

### Manual Scope Management

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/ScopeManager.md

Demonstrates manual activation of a span without automatic finishing.

```php
$tracer = GlobalTracer::get();
$span = $tracer->startSpan('operation');

// Manually activate without auto-finish
$scope = $tracer->getScopeManager()->activate($span, false);

try {
    // ... do work ...
    // Track duration manually
    $span->setTag('duration_ms', elapsed());
    $span->finish();
} finally {
    $scope->close();  // Restore previous scope
}
```

--------------------------------

### Configure IPv6 Support

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/configuration.md

Set the IP version to IPv6 for environments requiring non-IPv4 connectivity.

```php
use Jaeger\Config;

$config = new Config(
    [
        'sampler' => ['type' => 'const', 'param' => true],
        'ip_version' => Config::IPV6,  // or 'IPv6'
        'local_agent' => [
            'reporting_host' => '::1',  // IPv6 localhost
        ],
    ],
    'my-app'
);

$tracer = $config->initializeTracer();
```

--------------------------------

### RateLimiter Usage

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Advanced.md

Demonstrates how to use the RateLimiter utility to control the frequency of expensive operations.

```APIDOC
## RateLimiter::checkCredit

### Description
Checks if there is sufficient credit available to perform an operation based on configured rate limits.

### Usage
```php
if ($limiter->checkCredit(1.0)) {
    processRequest();
} else {
    http_response_code(429);
}
```
```

--------------------------------

### Configure Samplers

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/README.md

Configuration arrays for different sampling strategies supported by the Jaeger client.

```php
'sampler' => [
    'type' => Jaeger\SAMPLER_TYPE_CONST,
    'param' => true, // boolean wheter to trace or not
],
```

```php
'sampler' => [
    'type' => Jaeger\SAMPLER_TYPE_PROBABILISTIC,
    'param' => 0.5, // float [0.0, 1.0]
],
```

```php
'sampler' => [
    'type' => Jaeger\SAMPLER_TYPE_RATE_LIMITING,
    'param' => 100 // integer maximum number of traces per second,
    'cache' => [
        'currentBalanceKey' => 'rate.currentBalance' // string
        'lastTickKey' => 'rate.lastTick' // string
    ]
],
```

--------------------------------

### startSpan

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Tracer.md

Creates and returns a new span instance.

```APIDOC
## startSpan(string $operationName, array|StartSpanOptions $options = [])

### Description
Creates and returns a new span. Options include tags, start time, and parent references.

### Parameters
- **$operationName** (string) - Required - Name of the operation being traced
- **$options** (array|StartSpanOptions) - Optional - Span options (tags, references, start time)

### Returns
- **Span** - A new span instance
```

--------------------------------

### Configure Jaeger via Environment Variables

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/README.md

List of environment variables used to configure the tracer, which can be overridden by a configuration array in the code.

```text
JAEGER_SERVICE_NAME=my-service
JAEGER_SAMPLER_TYPE=probabilistic
JAEGER_SAMPLER_PARAM=0.1
JAEGER_AGENT_HOST=localhost
JAEGER_AGENT_PORT=6832
JAEGER_DISPATCH_MODE=jaeger_over_binary_udp
JAEGER_REPORTER_LOG_SPANS=false
JAEGER_REPORTER_MAX_QUEUE_SIZE=64000
JAEGER_TAGS=env=prod,version=1.0
IP_VERSION=IPv4
```

--------------------------------

### Retrieve service name

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Tracer.md

Returns the configured service name as a string.

```php
public function getServiceName(): string
```

--------------------------------

### Configure IPv6 for Jaeger Tracer

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/README.md

Initialize the Jaeger tracer with IPv6 support using either the 'ip_version' key or the Config::IP_VERSION constant.

```php
use Jaeger\Config;

$config = new Config(
    [
        "ip_version" => Config::IPV6, // <-- or use Config::IP_VERSION constant
        'logging' => true,
        'dispatch_mode' => Config::JAEGER_OVER_BINARY_UDP,
    ],
    'serviceNameExample',
);
$config->initializeTracer();
```

```php
use Jaeger\Config;

$config = new Config(
    [
        Config::IP_VERSION => Config::IPV6, // <--
        'logging' => true,
        'dispatch_mode' => Config::JAEGER_OVER_BINARY_UDP,
    ],
    'serviceNameExample',
);
$config->initializeTracer();
```

--------------------------------

### Configure Rate-Limited Sampler

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/README.md

Use this configuration for services requiring rate-limited sampling. Requires a logger and cache instance.

```php
$config = new Config(
    [
        'sampler' => [
            'type' => 'ratelimiting',
            'param' => 100,
            'cache' => [
                'currentBalanceKey' => 'jaeger.balance',
                'lastTickKey' => 'jaeger.tick',
            ],
        ],
    ],
    'critical-service',
    $logger,
    $cache  // Required for rate limiting
);
```

--------------------------------

### Run tests via Docker

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/tests/README.md

Execute tests against specific PHP versions using a Docker container.

```bash
$ docker run --rm -it -v $(pwd):/usr/app php:7.0 ./usr/app/tests/php-test.sh

$ docker run --rm -it -v $(pwd):/usr/app php:7.1 ./usr/app/tests/php-test.sh

$ docker run --rm -it -v $(pwd):/usr/app php:7.2 ./usr/app/tests/php-test.sh
```

--------------------------------

### Test Tracer Implementation

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/README.md

Uses an InMemoryReporter to verify span creation and operation names during unit testing.

```php
use Jaeger\Reporter\InMemoryReporter;

$reporter = new InMemoryReporter();
$tracer = new Tracer('test-service', $reporter, new ConstSampler(true));

// Create spans...
$spans = $reporter->getSpans();
assert(count($spans) === 1);
assert($spans[0]->getOperationName() === 'test-op');
```

--------------------------------

### HttpAgentClient::__construct

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Advanced.md

Initializes a new instance of the HttpAgentClient to communicate with the Jaeger collector via HTTP.

```APIDOC
## __construct

### Description
Initializes the HTTP transport client for the Jaeger collector.

### Signature
`public function __construct(string $host, int $port = 14268, string $scheme = 'http')`

### Parameters
- **$host** (string) - Required - Collector hostname or IP
- **$port** (int) - Optional - Collector port (default: 14268)
- **$scheme** (string) - Optional - HTTP or HTTPS (default: 'http')
```

--------------------------------

### Initialize HttpAgentClient

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Advanced.md

Configures the HTTP transport for the Jaeger collector, typically used when dispatch_mode is set to JAEGER_OVER_BINARY_HTTP.

```php
public function __construct(
    string $host,
    int $port = 14268,
    string $scheme = 'http'
)
```

--------------------------------

### BinaryCodec Constructor

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Codecs.md

Initializes the BinaryCodec for binary span context encoding.

```php
public function __construct()
```

--------------------------------

### RateLimiter::initialize

Source: https://github.com/jonahgeorge/jaeger-client-php/blob/master/_autodocs/api-reference/Samplers.md

Sets the cost model for the rate limiter.

```APIDOC
## public function initialize(float $creditsPerNanosecond, float $maxBalance): void

### Description
Initializes the limiter's cost model by defining the credit generation rate and maximum balance.

### Parameters
- **$creditsPerNanosecond** (float) - Required - Credit generation rate
- **$maxBalance** (float) - Required - Maximum credit balance (burst allowance)
```
Tokens:
Raw