Classes
This class is an implementation of a generic context.
This class in an implementation of a generic scope that has something to
execute when the scope finishes.
A class that represents an Annotation resource.
Trait which provides helper methods for converting DateTime input formats.
This implementation of the SpanEventHandlerInterface does nothing.
This interface defines events that are triggered when a Span is updated.
This implementation of the ExporterInterface uses
print_r to output
the trace's representation to stdout.
The ExporterInterface allows you to swap out the Trace reporting mechanism
This implementation of the ExporterInterface appends a JSON
representation of the trace to a file.
This implementation of the ExporterInterface sends log messages to a
configurable PSR-3 logger.
This implementation of the ExporterInterface does nothing.
Trait which provides helper methods for generating trace identifiers.
This class handles instrumenting curl requests using the opencensus extension.
This class handles instrumenting the Doctrine ORM queries using the opencensus extension.
This class handles instrumenting the Eloquent ORM queries using the opencensus extension.
This class handles instrumenting grpc requests using the opencensus extension.
This class handles instrumenting Guzzle http synchronous requests using the opencensus extension.
This class handles integration with GuzzleHttp 5. Attaching this EventSubscriber to
your Guzzle client, will enable distrubted tracing by passing along the trace context
header and will also create trace spans for all outgoing requests.
This class handles integration with GuzzleHttp 6. Adding this middleware to
your Guzzle client, will enable distrubted tracing by passing along the trace context
header and will also create trace spans for all outgoing requests.
Common interface for enabling Trace integration for various frameworks and libraries.
This class handles instrumenting the Laravel framework's standard stack using the opencensus extension.
This class handles instrumenting memcache requests using the opencensus extension.
This class handles instrumenting memcache requests using the opencensus extension.
This class handles instrumenting mysql requests using the opencensus extension.
This class handles instrumenting PDO requests using the opencensus extension.
This class handles instrumenting postgres requests using the opencensus extension.
This class handles instrumenting the Symfony framework's standard stack using the opencensus extension.
This class handles instrumenting the Wordpress framework's standard stack using the opencensus extension.
A class that represents a Link resource.
A class that represents a MessageEvent resource.
This propagator contains the method for serializaing and deserializing
SpanContext over a binary format.
This format using a human readable string encoding to propagate SpanContext.
This interface lets us define serialization strategies for SpanContext.
This propagator contains the logic for propagating SpanContext over
grpc using its request metadata. It will default to using the BinaryFormatter
to serialize/deserialize SpanContext.
This propagator uses HTTP headers to propagate SpanContext over HTTP.
This interface lets us define separate SpanContext Propagator formats. This
interface is responsible for parsing and propagating the SpanContext to
upstream and downstream requests.
This format using a human readable string encoding to propagate SpanContext.
This class manages the logic for sampling and reporting a trace within a
single request. It is not meant to be used directly -- instead, it should
be managed by the Tracer as its singleton instance.
This implementation of the SamplerInterface always returns false. Use this
sampler to attempt to trace all requests. You may be throttled by the server.
This implementation of the SamplerInterface wraps any number of child
SamplerInterface implementations. All provided implementations must return
true in order for the request to be sampled.
This implementation of the SamplerInterface always returns false. Use this
sampler to disable all tracing.
This implementation of the SamplerInterface uses a pseudo-random number generator
to sample a percentage of requests.
This implementation of the SamplerInterface uses a cache to limit sampling to
the a certain number of queries per second. It requires a PSR-6 cache implementation.
This interface lets us customize the sampling logic.
This plain PHP class represents a single timed event within a Trace. Spans can
be nested and form a trace tree. Often, a trace contains a root span that
describes the end-to-end latency of an operation and, optionally, one or more subspans
for its suboperations. Spans do not need to be contiguous. There may be
gaps between spans in a trace.
SpanContext encapsulates your current context within your request's trace. It includes
3 fields: the
traceId, the current spanId, and an enabled flag which indicates whether
or not the request is being traced.
This plain PHP class represents a read-only version of a single timed event
within a Trace. Spans can be nested and form a trace tree. Often, a trace
contains a root span that describes the end-to-end latency of an operation
and, optionally, one or more subspans for its suboperations. Spans do not
need to be contiguous. There may be gaps between spans in a trace.
The
Status type defines a logical error model that is suitable for
different programming environments, including REST APIs and RPC APIs. It is
used by gRPC.
An abstract class that represents a TimeEvent resource.
This class provides static functions to give you access to the current
request's singleton tracer. You should use this class to instrument your code.
This implementation of the TracerInterface manages your trace context throughout
the request. It maintains a stack of
Span records that are currently open
allowing you to know the current context at any moment.
This implementation of the TracerInterface utilizes the opencensus extension
to manage span context. The opencensus extension augments user created spans and
adds automatic tracing to several commonly desired events.
This implementation of the TracerInterface is the null object implementation.
This interface allows you to use the null object pattern for your tracer.
This class provides a constant for the current version of this library.