GitHub

otlp_logger

API reference for otlp_logger.

Exporting logs over OTLP/HTTP (Effect's OtlpLogger): a logger whose entries become OTLP log records with their level, message, annotations, cause, fiber id, log spans and the current trace and span ids.

Classes

Functions

log_level_to_severity_number

log_level_to_severity_number(level) -> int

The OTLP severity number of a level; ALL and NONE are 0 (unspecified).

ParameterTypeDescription
levelLogLevel

Returns int

def log_level_to_severity_number(level: LogLevel) -> int:
    """The OTLP severity number of a level; ``ALL`` and ``NONE`` are 0
    (unspecified)."""
    return _SEVERITIES.get(level, 0)

make

make(*, url, resource=None, headers=None, compression='none', export_interval=None, max_batch_size=None, shutdown_timeout=None, exclude_log_spans=False) -> Effect[Logger[None], Never, Flusher | OtlpSerialization | HttpClient | Scope]

A logger exporting each entry to url as an OTLP log record, in batches of max_batch_size (1000) every export_interval (1 second), flushed for at most shutdown_timeout (3 seconds) when the scope closes. exclude_log_spans leaves out the effect.log_span.<label> attributes.

ParameterTypeDescription
urlstr
resourceResourceOptions | None = None
headers_headers.Input | None = None
compressionCompression = 'none'
export_intervalDurationInput | None = None
max_batch_sizeint | None = None
shutdown_timeoutDurationInput | None = None
exclude_log_spansbool = False

Returns Effect[Logger[None], Never, Flusher | OtlpSerialization | HttpClient | Scope]

def make(
    *,
    url: str,
    resource: ResourceOptions | None = None,
    headers: _headers.Input | None = None,
    compression: Compression = "none",
    export_interval: DurationInput | None = None,
    max_batch_size: int | None = None,
    shutdown_timeout: DurationInput | None = None,
    exclude_log_spans: bool = False,
) -> Effect[Logger[None], Never, Flusher | OtlpSerialization | HttpClient | Scope]:
    """A logger exporting each entry to ``url`` as an OTLP log record, in
    batches of ``max_batch_size`` (1000) every ``export_interval`` (1
    second), flushed for at most ``shutdown_timeout`` (3 seconds) when the
    scope closes. ``exclude_log_spans`` leaves out the
    ``effect.log_span.<label>`` attributes."""

    @gen
    def build():
        serialization = yield from OtlpSerialization()
        otel_resource = yield from from_options(resource)
        scope = instrumentation_scope()

        def body(records: list[Any]) -> tuple[Any, Effect[None]]:
            data: LogsData = {
                "resourceLogs": [
                    {
                        "resource": otel_resource,
                        "scopeLogs": [{"scope": scope, "logRecords": records}],
                    }
                ]
            }
            return serialization.logs(data), succeed(None)

        made = yield from exporter.make(
            label="OtlpLogger",
            url=url,
            headers=headers,
            compression=compression,
            max_batch_size=1000 if max_batch_size is None else max_batch_size,
            export_interval="1 second" if export_interval is None else export_interval,
            body=body,
            shutdown_timeout="3 seconds" if shutdown_timeout is None else shutdown_timeout,
        )
        clock = yield from Clock()
        return Logger(lambda options: made.push(_log_record(options, exclude_log_spans, clock)))

    return build

layer

layer(*, url, resource=None, headers=None, compression='none', export_interval=None, max_batch_size=None, shutdown_timeout=None, exclude_log_spans=False, merge_with_existing=True) -> Layer[Flusher, Never, HttpClient | OtlpSerialization]

Installs make's logger next to the current loggers (instead of them with merge_with_existing=False), with the shared layer_flusher.

ParameterTypeDescription
urlstr
resourceResourceOptions | None = None
headers_headers.Input | None = None
compressionCompression = 'none'
export_intervalDurationInput | None = None
max_batch_sizeint | None = None
shutdown_timeoutDurationInput | None = None
exclude_log_spansbool = False
merge_with_existingbool = True

Returns Layer[Flusher, Never, HttpClient | OtlpSerialization]

def layer(
    *,
    url: str,
    resource: ResourceOptions | None = None,
    headers: _headers.Input | None = None,
    compression: Compression = "none",
    export_interval: DurationInput | None = None,
    max_batch_size: int | None = None,
    shutdown_timeout: DurationInput | None = None,
    exclude_log_spans: bool = False,
    merge_with_existing: bool = True,
) -> Layer[Flusher, Never, HttpClient | OtlpSerialization]:
    """Installs ``make``'s logger next to the current loggers (instead of
    them with ``merge_with_existing=False``), with the shared
    ``layer_flusher``."""
    logger = make(
        url=url,
        resource=resource,
        headers=headers,
        compression=compression,
        export_interval=export_interval,
        max_batch_size=max_batch_size,
        shutdown_timeout=shutdown_timeout,
        exclude_log_spans=exclude_log_spans,
    )
    return logger_layer([logger], merge_with_existing=merge_with_existing).pipe(
        _layer.provide_merge(exporter.layer_flusher)
    )

layer_from_config

layer_from_config(*, resource=None, headers=None, exclude_log_spans=False, merge_with_existing=True) -> Layer[Flusher, Never, HttpClient | OtlpSerialization]

layer configured from the OpenTelemetry environment: nothing but the flusher unless OTEL_LOGS_EXPORTER lists otlp, an endpoint is set and OTEL_SDK_DISABLED is not true. Reads the compression, OTEL_EXPORTER_OTLP_(LOGS_)TIMEOUT / OTEL_BLRP_EXPORT_TIMEOUT (shutdown), OTEL_BLRP_SCHEDULE_DELAY and OTEL_BLRP_MAX_EXPORT_BATCH_SIZE. Invalid configuration is a defect.

ParameterTypeDescription
resourceResourceOptions | None = None
headers_headers.Input | None = None
exclude_log_spansbool = False
merge_with_existingbool = True

Returns Layer[Flusher, Never, HttpClient | OtlpSerialization]

def layer_from_config(
    *,
    resource: ResourceOptions | None = None,
    headers: _headers.Input | None = None,
    exclude_log_spans: bool = False,
    merge_with_existing: bool = True,
) -> Layer[Flusher, Never, HttpClient | OtlpSerialization]:
    """``layer`` configured from the OpenTelemetry environment: nothing
    but the flusher unless ``OTEL_LOGS_EXPORTER`` lists ``otlp``, an
    endpoint is set and ``OTEL_SDK_DISABLED`` is not true. Reads the
    compression, ``OTEL_EXPORTER_OTLP_(LOGS_)TIMEOUT`` /
    ``OTEL_BLRP_EXPORT_TIMEOUT`` (shutdown), ``OTEL_BLRP_SCHEDULE_DELAY``
    and ``OTEL_BLRP_MAX_EXPORT_BATCH_SIZE``. Invalid configuration is a
    defect."""

    @gen
    def build():
        disabled = yield from config.boolean("OTEL_SDK_DISABLED").with_default(False)
        endpoint = yield from env.endpoint("LOGS")
        exporters = yield from env.exporters("LOGS")
        if disabled or endpoint is None or "otlp" not in exporters:
            return exporter.layer_flusher
        compression = yield from env.compression("LOGS")
        base_timeout = yield from env.millis("OTEL_EXPORTER_OTLP_TIMEOUT")
        logs_timeout = yield from env.millis("OTEL_EXPORTER_OTLP_LOGS_TIMEOUT")
        export_timeout = yield from env.millis("OTEL_BLRP_EXPORT_TIMEOUT")
        schedule_delay = yield from env.millis("OTEL_BLRP_SCHEDULE_DELAY")
        max_batch_size = yield from config.integer("OTEL_BLRP_MAX_EXPORT_BATCH_SIZE").with_default(
            None
        )
        signal_headers = headers if headers is not None else (yield from env.headers("LOGS"))
        return layer(
            url=str(endpoint),
            resource=resource,
            headers=signal_headers,
            compression=compression,
            export_interval=schedule_delay,
            max_batch_size=max_batch_size,
            shutdown_timeout=env.first_of(logs_timeout, base_timeout, export_timeout),
            exclude_log_spans=exclude_log_spans,
            merge_with_existing=merge_with_existing,
        )

    return _layer.unwrap(build.or_die())