aboutsummaryrefslogtreecommitdiff
path: root/.venv/lib/python3.12/site-packages/opentelemetry/_logs
diff options
context:
space:
mode:
Diffstat (limited to '.venv/lib/python3.12/site-packages/opentelemetry/_logs')
-rw-r--r--.venv/lib/python3.12/site-packages/opentelemetry/_logs/__init__.py59
-rw-r--r--.venv/lib/python3.12/site-packages/opentelemetry/_logs/_internal/__init__.py292
-rw-r--r--.venv/lib/python3.12/site-packages/opentelemetry/_logs/py.typed0
-rw-r--r--.venv/lib/python3.12/site-packages/opentelemetry/_logs/severity/__init__.py115
4 files changed, 466 insertions, 0 deletions
diff --git a/.venv/lib/python3.12/site-packages/opentelemetry/_logs/__init__.py b/.venv/lib/python3.12/site-packages/opentelemetry/_logs/__init__.py
new file mode 100644
index 00000000..aaf29e5f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/opentelemetry/_logs/__init__.py
@@ -0,0 +1,59 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+The OpenTelemetry logging API describes the classes used to generate logs and events.
+
+The :class:`.LoggerProvider` provides users access to the :class:`.Logger`.
+
+This module provides abstract (i.e. unimplemented) classes required for
+logging, and a concrete no-op implementation :class:`.NoOpLogger` that allows applications
+to use the API package alone without a supporting implementation.
+
+To get a logger, you need to provide the package name from which you are
+calling the logging APIs to OpenTelemetry by calling `LoggerProvider.get_logger`
+with the calling module name and the version of your package.
+
+The following code shows how to obtain a logger using the global :class:`.LoggerProvider`::
+
+ from opentelemetry._logs import get_logger
+
+ logger = get_logger("example-logger")
+
+.. versionadded:: 1.15.0
+"""
+
+from opentelemetry._logs._internal import (
+ Logger,
+ LoggerProvider,
+ LogRecord,
+ NoOpLogger,
+ NoOpLoggerProvider,
+ get_logger,
+ get_logger_provider,
+ set_logger_provider,
+)
+from opentelemetry._logs.severity import SeverityNumber, std_to_otel
+
+__all__ = [
+ "Logger",
+ "LoggerProvider",
+ "LogRecord",
+ "NoOpLogger",
+ "NoOpLoggerProvider",
+ "get_logger",
+ "get_logger_provider",
+ "set_logger_provider",
+ "SeverityNumber",
+ "std_to_otel",
+]
diff --git a/.venv/lib/python3.12/site-packages/opentelemetry/_logs/_internal/__init__.py b/.venv/lib/python3.12/site-packages/opentelemetry/_logs/_internal/__init__.py
new file mode 100644
index 00000000..f20bd850
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/opentelemetry/_logs/_internal/__init__.py
@@ -0,0 +1,292 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+The OpenTelemetry logging API describes the classes used to generate logs and events.
+
+The :class:`.LoggerProvider` provides users access to the :class:`.Logger`.
+
+This module provides abstract (i.e. unimplemented) classes required for
+logging, and a concrete no-op implementation :class:`.NoOpLogger` that allows applications
+to use the API package alone without a supporting implementation.
+
+To get a logger, you need to provide the package name from which you are
+calling the logging APIs to OpenTelemetry by calling `LoggerProvider.get_logger`
+with the calling module name and the version of your package.
+
+The following code shows how to obtain a logger using the global :class:`.LoggerProvider`::
+
+ from opentelemetry._logs import get_logger
+
+ logger = get_logger("example-logger")
+
+.. versionadded:: 1.15.0
+"""
+
+from abc import ABC, abstractmethod
+from logging import getLogger
+from os import environ
+from time import time_ns
+from typing import Any, Optional, cast
+
+from opentelemetry._logs.severity import SeverityNumber
+from opentelemetry.environment_variables import _OTEL_PYTHON_LOGGER_PROVIDER
+from opentelemetry.trace.span import TraceFlags
+from opentelemetry.util._once import Once
+from opentelemetry.util._providers import _load_provider
+from opentelemetry.util.types import Attributes
+
+_logger = getLogger(__name__)
+
+
+class LogRecord(ABC):
+ """A LogRecord instance represents an event being logged.
+
+ LogRecord instances are created and emitted via `Logger`
+ every time something is logged. They contain all the information
+ pertinent to the event being logged.
+ """
+
+ def __init__(
+ self,
+ timestamp: Optional[int] = None,
+ observed_timestamp: Optional[int] = None,
+ trace_id: Optional[int] = None,
+ span_id: Optional[int] = None,
+ trace_flags: Optional["TraceFlags"] = None,
+ severity_text: Optional[str] = None,
+ severity_number: Optional[SeverityNumber] = None,
+ body: Optional[Any] = None,
+ attributes: Optional["Attributes"] = None,
+ ):
+ self.timestamp = timestamp
+ if observed_timestamp is None:
+ observed_timestamp = time_ns()
+ self.observed_timestamp = observed_timestamp
+ self.trace_id = trace_id
+ self.span_id = span_id
+ self.trace_flags = trace_flags
+ self.severity_text = severity_text
+ self.severity_number = severity_number
+ self.body = body # type: ignore
+ self.attributes = attributes
+
+
+class Logger(ABC):
+ """Handles emitting events and logs via `LogRecord`."""
+
+ def __init__(
+ self,
+ name: str,
+ version: Optional[str] = None,
+ schema_url: Optional[str] = None,
+ attributes: Optional[Attributes] = None,
+ ) -> None:
+ super().__init__()
+ self._name = name
+ self._version = version
+ self._schema_url = schema_url
+ self._attributes = attributes
+
+ @abstractmethod
+ def emit(self, record: "LogRecord") -> None:
+ """Emits a :class:`LogRecord` representing a log to the processing pipeline."""
+
+
+class NoOpLogger(Logger):
+ """The default Logger used when no Logger implementation is available.
+
+ All operations are no-op.
+ """
+
+ def emit(self, record: "LogRecord") -> None:
+ pass
+
+
+class ProxyLogger(Logger):
+ def __init__( # pylint: disable=super-init-not-called
+ self,
+ name: str,
+ version: Optional[str] = None,
+ schema_url: Optional[str] = None,
+ attributes: Optional[Attributes] = None,
+ ):
+ self._name = name
+ self._version = version
+ self._schema_url = schema_url
+ self._attributes = attributes
+ self._real_logger: Optional[Logger] = None
+ self._noop_logger = NoOpLogger(name)
+
+ @property
+ def _logger(self) -> Logger:
+ if self._real_logger:
+ return self._real_logger
+
+ if _LOGGER_PROVIDER:
+ self._real_logger = _LOGGER_PROVIDER.get_logger(
+ self._name,
+ self._version,
+ self._schema_url,
+ self._attributes,
+ )
+ return self._real_logger
+ return self._noop_logger
+
+ def emit(self, record: LogRecord) -> None:
+ self._logger.emit(record)
+
+
+class LoggerProvider(ABC):
+ """
+ LoggerProvider is the entry point of the API. It provides access to Logger instances.
+ """
+
+ @abstractmethod
+ def get_logger(
+ self,
+ name: str,
+ version: Optional[str] = None,
+ schema_url: Optional[str] = None,
+ attributes: Optional[Attributes] = None,
+ ) -> Logger:
+ """Returns a `Logger` for use by the given instrumentation library.
+
+ For any two calls it is undefined whether the same or different
+ `Logger` instances are returned, even for different library names.
+
+ This function may return different `Logger` types (e.g. a no-op logger
+ vs. a functional logger).
+
+ Args:
+ name: The name of the instrumenting module.
+ ``__name__`` may not be used as this can result in
+ different logger names if the loggers are in different files.
+ It is better to use a fixed string that can be imported where
+ needed and used consistently as the name of the logger.
+
+ This should *not* be the name of the module that is
+ instrumented but the name of the module doing the instrumentation.
+ E.g., instead of ``"requests"``, use
+ ``"opentelemetry.instrumentation.requests"``.
+
+ version: Optional. The version string of the
+ instrumenting library. Usually this should be the same as
+ ``importlib.metadata.version(instrumenting_library_name)``.
+
+ schema_url: Optional. Specifies the Schema URL of the emitted telemetry.
+ """
+
+
+class NoOpLoggerProvider(LoggerProvider):
+ """The default LoggerProvider used when no LoggerProvider implementation is available."""
+
+ def get_logger(
+ self,
+ name: str,
+ version: Optional[str] = None,
+ schema_url: Optional[str] = None,
+ attributes: Optional[Attributes] = None,
+ ) -> Logger:
+ """Returns a NoOpLogger."""
+ return NoOpLogger(
+ name, version=version, schema_url=schema_url, attributes=attributes
+ )
+
+
+class ProxyLoggerProvider(LoggerProvider):
+ def get_logger(
+ self,
+ name: str,
+ version: Optional[str] = None,
+ schema_url: Optional[str] = None,
+ attributes: Optional[Attributes] = None,
+ ) -> Logger:
+ if _LOGGER_PROVIDER:
+ return _LOGGER_PROVIDER.get_logger(
+ name,
+ version=version,
+ schema_url=schema_url,
+ attributes=attributes,
+ )
+ return ProxyLogger(
+ name,
+ version=version,
+ schema_url=schema_url,
+ attributes=attributes,
+ )
+
+
+_LOGGER_PROVIDER_SET_ONCE = Once()
+_LOGGER_PROVIDER: Optional[LoggerProvider] = None
+_PROXY_LOGGER_PROVIDER = ProxyLoggerProvider()
+
+
+def get_logger_provider() -> LoggerProvider:
+ """Gets the current global :class:`~.LoggerProvider` object."""
+ global _LOGGER_PROVIDER # pylint: disable=global-variable-not-assigned
+ if _LOGGER_PROVIDER is None:
+ if _OTEL_PYTHON_LOGGER_PROVIDER not in environ:
+ return _PROXY_LOGGER_PROVIDER
+
+ logger_provider: LoggerProvider = _load_provider( # type: ignore
+ _OTEL_PYTHON_LOGGER_PROVIDER, "logger_provider"
+ )
+ _set_logger_provider(logger_provider, log=False)
+
+ # _LOGGER_PROVIDER will have been set by one thread
+ return cast("LoggerProvider", _LOGGER_PROVIDER)
+
+
+def _set_logger_provider(logger_provider: LoggerProvider, log: bool) -> None:
+ def set_lp() -> None:
+ global _LOGGER_PROVIDER # pylint: disable=global-statement
+ _LOGGER_PROVIDER = logger_provider
+
+ did_set = _LOGGER_PROVIDER_SET_ONCE.do_once(set_lp)
+
+ if log and not did_set:
+ _logger.warning("Overriding of current LoggerProvider is not allowed")
+
+
+def set_logger_provider(logger_provider: LoggerProvider) -> None:
+ """Sets the current global :class:`~.LoggerProvider` object.
+
+ This can only be done once, a warning will be logged if any further attempt
+ is made.
+ """
+ _set_logger_provider(logger_provider, log=True)
+
+
+def get_logger(
+ instrumenting_module_name: str,
+ instrumenting_library_version: str = "",
+ logger_provider: Optional[LoggerProvider] = None,
+ schema_url: Optional[str] = None,
+ attributes: Optional[Attributes] = None,
+) -> "Logger":
+ """Returns a `Logger` for use within a python process.
+
+ This function is a convenience wrapper for
+ opentelemetry.sdk._logs.LoggerProvider.get_logger.
+
+ If logger_provider param is omitted the current configured one is used.
+ """
+ if logger_provider is None:
+ logger_provider = get_logger_provider()
+ return logger_provider.get_logger(
+ instrumenting_module_name,
+ instrumenting_library_version,
+ schema_url,
+ attributes,
+ )
diff --git a/.venv/lib/python3.12/site-packages/opentelemetry/_logs/py.typed b/.venv/lib/python3.12/site-packages/opentelemetry/_logs/py.typed
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/opentelemetry/_logs/py.typed
diff --git a/.venv/lib/python3.12/site-packages/opentelemetry/_logs/severity/__init__.py b/.venv/lib/python3.12/site-packages/opentelemetry/_logs/severity/__init__.py
new file mode 100644
index 00000000..1daaa19f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/opentelemetry/_logs/severity/__init__.py
@@ -0,0 +1,115 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import enum
+
+
+class SeverityNumber(enum.Enum):
+ """Numerical value of severity.
+
+ Smaller numerical values correspond to less severe events
+ (such as debug events), larger numerical values correspond
+ to more severe events (such as errors and critical events).
+
+ See the `Log Data Model`_ spec for more info and how to map the
+ severity from source format to OTLP Model.
+
+ .. _Log Data Model: https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/logs/data-model.md#field-severitynumber
+ """
+
+ UNSPECIFIED = 0
+ TRACE = 1
+ TRACE2 = 2
+ TRACE3 = 3
+ TRACE4 = 4
+ DEBUG = 5
+ DEBUG2 = 6
+ DEBUG3 = 7
+ DEBUG4 = 8
+ INFO = 9
+ INFO2 = 10
+ INFO3 = 11
+ INFO4 = 12
+ WARN = 13
+ WARN2 = 14
+ WARN3 = 15
+ WARN4 = 16
+ ERROR = 17
+ ERROR2 = 18
+ ERROR3 = 19
+ ERROR4 = 20
+ FATAL = 21
+ FATAL2 = 22
+ FATAL3 = 23
+ FATAL4 = 24
+
+
+_STD_TO_OTEL = {
+ 10: SeverityNumber.DEBUG,
+ 11: SeverityNumber.DEBUG2,
+ 12: SeverityNumber.DEBUG3,
+ 13: SeverityNumber.DEBUG4,
+ 14: SeverityNumber.DEBUG4,
+ 15: SeverityNumber.DEBUG4,
+ 16: SeverityNumber.DEBUG4,
+ 17: SeverityNumber.DEBUG4,
+ 18: SeverityNumber.DEBUG4,
+ 19: SeverityNumber.DEBUG4,
+ 20: SeverityNumber.INFO,
+ 21: SeverityNumber.INFO2,
+ 22: SeverityNumber.INFO3,
+ 23: SeverityNumber.INFO4,
+ 24: SeverityNumber.INFO4,
+ 25: SeverityNumber.INFO4,
+ 26: SeverityNumber.INFO4,
+ 27: SeverityNumber.INFO4,
+ 28: SeverityNumber.INFO4,
+ 29: SeverityNumber.INFO4,
+ 30: SeverityNumber.WARN,
+ 31: SeverityNumber.WARN2,
+ 32: SeverityNumber.WARN3,
+ 33: SeverityNumber.WARN4,
+ 34: SeverityNumber.WARN4,
+ 35: SeverityNumber.WARN4,
+ 36: SeverityNumber.WARN4,
+ 37: SeverityNumber.WARN4,
+ 38: SeverityNumber.WARN4,
+ 39: SeverityNumber.WARN4,
+ 40: SeverityNumber.ERROR,
+ 41: SeverityNumber.ERROR2,
+ 42: SeverityNumber.ERROR3,
+ 43: SeverityNumber.ERROR4,
+ 44: SeverityNumber.ERROR4,
+ 45: SeverityNumber.ERROR4,
+ 46: SeverityNumber.ERROR4,
+ 47: SeverityNumber.ERROR4,
+ 48: SeverityNumber.ERROR4,
+ 49: SeverityNumber.ERROR4,
+ 50: SeverityNumber.FATAL,
+ 51: SeverityNumber.FATAL2,
+ 52: SeverityNumber.FATAL3,
+ 53: SeverityNumber.FATAL4,
+}
+
+
+def std_to_otel(levelno: int) -> SeverityNumber:
+ """
+ Map python log levelno as defined in https://docs.python.org/3/library/logging.html#logging-levels
+ to OTel log severity number as defined here: https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/logs/data-model.md#field-severitynumber
+ """
+ if levelno < 10:
+ return SeverityNumber.UNSPECIFIED
+ if levelno > 53:
+ return SeverityNumber.FATAL4
+ return _STD_TO_OTEL[levelno]