logger

log_level_to_severity_number(level) -> SeverityNumber

def log_level_to_severity_number(level: LogLevel) -> SeverityNumber:
    """The OpenTelemetry severity of a level (1 to 24); ``ALL`` and ``NONE``
    are ``UNSPECIFIED``."""
    return _SEVERITIES.get(level, SeverityNumber.UNSPECIFIED)

make()

@gen
def make():
    """A logger emitting each log as a record through the
    ``OtelLoggerProvider``: the log annotations, ``effect.fiberId``, the
    span ids, each log span's elapsed milliseconds
    (``effect.log_span.<label>``) and the cause's first error
    (``exception.*``) as attributes."""
    provider = yield from OtelLoggerProvider()
    clock = yield from Clock()
    return _logger(provider, clock)

layer(*, merge_with_existing=True) -> Layer[Never, Never, OtelLoggerProvider]

def layer(*, merge_with_existing: bool = True) -> Layer[Never, Never, OtelLoggerProvider]:
    """Installs ``make``'s logger, next to the current loggers (or instead
    of them, with ``merge_with_existing=False``)."""
    return logger_layer([make], merge_with_existing=merge_with_existing)

layer_logger_provider(processors, *, shutdown_timeout=DEFAULT_SHUTDOWN_TIMEOUT) -> Layer[OtelLoggerProvider, Never, OtelResource]

def layer_logger_provider(
    processors: sdk_logs.LogRecordProcessor | Sequence[sdk_logs.LogRecordProcessor],
    *,
    shutdown_timeout: Duration = DEFAULT_SHUTDOWN_TIMEOUT,
) -> Layer[OtelLoggerProvider, Never, OtelResource]:
    """An SDK logger provider with the ``OtelResource`` and ``processors``,
    flushed (for at most ``shutdown_timeout``) and shut down when the layer
    is released."""
    given = [processors] if isinstance(processors, sdk_logs.LogRecordProcessor) else processors

    def acquire(resource: Resource) -> sdk_logs.LoggerProvider:
        provider = sdk_logs.LoggerProvider(resource=resource, shutdown_on_exit=False)
        for processor in given:
            provider.add_log_record_processor(processor)
        return provider

    return _layer.effect(
        OtelLoggerProvider,
        OtelResource().flat_map(
            lambda resource: acquire_release(
                sync(lambda: acquire(resource)),
                lambda provider, _exit: flush_and_shut_down(provider, shutdown_timeout),
            )
        ),
    )