diff --git a/CHANGELOG.md b/CHANGELOG.md index 19a3434190e..55f0138fbcd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## Unreleased +- Remove `Events` from the API/SDK completely. An `Event` is now simply a `LogRecord` with the `EventName` field set. - Update OTLP gRPC/HTTP exporters: the export timeout is now inclusive of all retries and backoffs. A +/-20% jitter was added to all backoffs. A pointless 32 second sleep that occurred after all retries had completed/failed was removed. diff --git a/opentelemetry-api/src/opentelemetry/_events/__init__.py b/opentelemetry-api/src/opentelemetry/_events/__init__.py deleted file mode 100644 index f073b223345..00000000000 --- a/opentelemetry-api/src/opentelemetry/_events/__init__.py +++ /dev/null @@ -1,224 +0,0 @@ -# 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. - -from abc import ABC, abstractmethod -from logging import getLogger -from os import environ -from typing import Optional, cast - -from opentelemetry._logs import LogRecord -from opentelemetry._logs.severity import SeverityNumber -from opentelemetry.environment_variables import ( - _OTEL_PYTHON_EVENT_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 AnyValue, _ExtendedAttributes - -_logger = getLogger(__name__) - - -class Event(LogRecord): - def __init__( - self, - name: str, - timestamp: Optional[int] = None, - trace_id: Optional[int] = None, - span_id: Optional[int] = None, - trace_flags: Optional["TraceFlags"] = None, - body: Optional[AnyValue] = None, - severity_number: Optional[SeverityNumber] = None, - attributes: Optional[_ExtendedAttributes] = None, - ): - attributes = attributes or {} - event_attributes = { - **attributes, - "event.name": name, - } - super().__init__( - timestamp=timestamp, - trace_id=trace_id, - span_id=span_id, - trace_flags=trace_flags, - body=body, - severity_number=severity_number, - attributes=event_attributes, - ) - self.name = name - - -class EventLogger(ABC): - def __init__( - self, - name: str, - version: Optional[str] = None, - schema_url: Optional[str] = None, - attributes: Optional[_ExtendedAttributes] = None, - ): - self._name = name - self._version = version - self._schema_url = schema_url - self._attributes = attributes - - @abstractmethod - def emit(self, event: "Event") -> None: - """Emits a :class:`Event` representing an event.""" - - -class NoOpEventLogger(EventLogger): - def emit(self, event: Event) -> None: - pass - - -class ProxyEventLogger(EventLogger): - def __init__( - self, - name: str, - version: Optional[str] = None, - schema_url: Optional[str] = None, - attributes: Optional[_ExtendedAttributes] = None, - ): - super().__init__( - name=name, - version=version, - schema_url=schema_url, - attributes=attributes, - ) - self._real_event_logger: Optional[EventLogger] = None - self._noop_event_logger = NoOpEventLogger(name) - - @property - def _event_logger(self) -> EventLogger: - if self._real_event_logger: - return self._real_event_logger - - if _EVENT_LOGGER_PROVIDER: - self._real_event_logger = _EVENT_LOGGER_PROVIDER.get_event_logger( - self._name, - self._version, - self._schema_url, - self._attributes, - ) - return self._real_event_logger - return self._noop_event_logger - - def emit(self, event: Event) -> None: - self._event_logger.emit(event) - - -class EventLoggerProvider(ABC): - @abstractmethod - def get_event_logger( - self, - name: str, - version: Optional[str] = None, - schema_url: Optional[str] = None, - attributes: Optional[_ExtendedAttributes] = None, - ) -> EventLogger: - """Returns an EventLoggerProvider for use.""" - - -class NoOpEventLoggerProvider(EventLoggerProvider): - def get_event_logger( - self, - name: str, - version: Optional[str] = None, - schema_url: Optional[str] = None, - attributes: Optional[_ExtendedAttributes] = None, - ) -> EventLogger: - return NoOpEventLogger( - name, version=version, schema_url=schema_url, attributes=attributes - ) - - -class ProxyEventLoggerProvider(EventLoggerProvider): - def get_event_logger( - self, - name: str, - version: Optional[str] = None, - schema_url: Optional[str] = None, - attributes: Optional[_ExtendedAttributes] = None, - ) -> EventLogger: - if _EVENT_LOGGER_PROVIDER: - return _EVENT_LOGGER_PROVIDER.get_event_logger( - name, - version=version, - schema_url=schema_url, - attributes=attributes, - ) - return ProxyEventLogger( - name, - version=version, - schema_url=schema_url, - attributes=attributes, - ) - - -_EVENT_LOGGER_PROVIDER_SET_ONCE = Once() -_EVENT_LOGGER_PROVIDER: Optional[EventLoggerProvider] = None -_PROXY_EVENT_LOGGER_PROVIDER = ProxyEventLoggerProvider() - - -def get_event_logger_provider() -> EventLoggerProvider: - global _EVENT_LOGGER_PROVIDER # pylint: disable=global-variable-not-assigned - if _EVENT_LOGGER_PROVIDER is None: - if _OTEL_PYTHON_EVENT_LOGGER_PROVIDER not in environ: - return _PROXY_EVENT_LOGGER_PROVIDER - - event_logger_provider: EventLoggerProvider = _load_provider( # type: ignore - _OTEL_PYTHON_EVENT_LOGGER_PROVIDER, "event_logger_provider" - ) - - _set_event_logger_provider(event_logger_provider, log=False) - - return cast("EventLoggerProvider", _EVENT_LOGGER_PROVIDER) - - -def _set_event_logger_provider( - event_logger_provider: EventLoggerProvider, log: bool -) -> None: - def set_elp() -> None: - global _EVENT_LOGGER_PROVIDER # pylint: disable=global-statement - _EVENT_LOGGER_PROVIDER = event_logger_provider - - did_set = _EVENT_LOGGER_PROVIDER_SET_ONCE.do_once(set_elp) - - if log and not did_set: - _logger.warning( - "Overriding of current EventLoggerProvider is not allowed" - ) - - -def set_event_logger_provider( - event_logger_provider: EventLoggerProvider, -) -> None: - _set_event_logger_provider(event_logger_provider, log=True) - - -def get_event_logger( - name: str, - version: Optional[str] = None, - schema_url: Optional[str] = None, - attributes: Optional[_ExtendedAttributes] = None, - event_logger_provider: Optional[EventLoggerProvider] = None, -) -> "EventLogger": - if event_logger_provider is None: - event_logger_provider = get_event_logger_provider() - return event_logger_provider.get_event_logger( - name, - version, - schema_url, - attributes, - ) diff --git a/opentelemetry-api/src/opentelemetry/_events/py.typed b/opentelemetry-api/src/opentelemetry/_events/py.typed deleted file mode 100644 index e69de29bb2d..00000000000 diff --git a/opentelemetry-api/src/opentelemetry/environment_variables/__init__.py b/opentelemetry-api/src/opentelemetry/environment_variables/__init__.py index bd8ed1cbfbb..c15b96be14a 100644 --- a/opentelemetry-api/src/opentelemetry/environment_variables/__init__.py +++ b/opentelemetry-api/src/opentelemetry/environment_variables/__init__.py @@ -81,8 +81,3 @@ """ .. envvar:: OTEL_PYTHON_LOGGER_PROVIDER """ - -_OTEL_PYTHON_EVENT_LOGGER_PROVIDER = "OTEL_PYTHON_EVENT_LOGGER_PROVIDER" -""" -.. envvar:: OTEL_PYTHON_EVENT_LOGGER_PROVIDER -""" diff --git a/opentelemetry-api/tests/events/test_event.py b/opentelemetry-api/tests/events/test_event.py deleted file mode 100644 index 227dcf5b1ff..00000000000 --- a/opentelemetry-api/tests/events/test_event.py +++ /dev/null @@ -1,21 +0,0 @@ -import unittest - -from opentelemetry._events import Event - - -class TestEvent(unittest.TestCase): - def test_event(self): - event = Event("example", 123, attributes={"key": "value"}) - self.assertEqual(event.name, "example") - self.assertEqual(event.timestamp, 123) - self.assertEqual( - event.attributes, {"key": "value", "event.name": "example"} - ) - - def test_event_name_copied_in_attributes(self): - event = Event("name", 123) - self.assertEqual(event.attributes, {"event.name": "name"}) - - def test_event_name_has_precedence_over_attributes(self): - event = Event("name", 123, attributes={"event.name": "attr value"}) - self.assertEqual(event.attributes, {"event.name": "name"}) diff --git a/opentelemetry-api/tests/events/test_event_logger_provider.py b/opentelemetry-api/tests/events/test_event_logger_provider.py deleted file mode 100644 index 425697bfa39..00000000000 --- a/opentelemetry-api/tests/events/test_event_logger_provider.py +++ /dev/null @@ -1,61 +0,0 @@ -# type:ignore -import unittest -from unittest.mock import Mock, patch - -import opentelemetry._events as events -from opentelemetry._events import ( - get_event_logger_provider, - set_event_logger_provider, -) -from opentelemetry.test.globals_test import EventsGlobalsTest - - -class TestGlobals(EventsGlobalsTest, unittest.TestCase): - @patch("opentelemetry._events._logger") - def test_set_event_logger_provider(self, logger_mock): - elp_mock = Mock() - # pylint: disable=protected-access - self.assertIsNone(events._EVENT_LOGGER_PROVIDER) - set_event_logger_provider(elp_mock) - self.assertIs(events._EVENT_LOGGER_PROVIDER, elp_mock) - self.assertIs(get_event_logger_provider(), elp_mock) - logger_mock.warning.assert_not_called() - - # pylint: disable=no-self-use - @patch("opentelemetry._events._logger") - def test_set_event_logger_provider_will_warn_second_call( - self, logger_mock - ): - elp_mock = Mock() - set_event_logger_provider(elp_mock) - set_event_logger_provider(elp_mock) - - logger_mock.warning.assert_called_once_with( - "Overriding of current EventLoggerProvider is not allowed" - ) - - def test_get_event_logger_provider(self): - # pylint: disable=protected-access - self.assertIsNone(events._EVENT_LOGGER_PROVIDER) - - self.assertIsInstance( - get_event_logger_provider(), events.ProxyEventLoggerProvider - ) - - events._EVENT_LOGGER_PROVIDER = None - - with patch.dict( - "os.environ", - { - "OTEL_PYTHON_EVENT_LOGGER_PROVIDER": "test_event_logger_provider" - }, - ): - with patch("opentelemetry._events._load_provider", Mock()): - with patch( - "opentelemetry._events.cast", - Mock(**{"return_value": "test_event_logger_provider"}), - ): - self.assertEqual( - get_event_logger_provider(), - "test_event_logger_provider", - ) diff --git a/opentelemetry-api/tests/events/test_proxy_event.py b/opentelemetry-api/tests/events/test_proxy_event.py deleted file mode 100644 index 44121a97d46..00000000000 --- a/opentelemetry-api/tests/events/test_proxy_event.py +++ /dev/null @@ -1,50 +0,0 @@ -# pylint: disable=W0212,W0222,W0221 -import typing -import unittest - -import opentelemetry._events as events -from opentelemetry.test.globals_test import EventsGlobalsTest -from opentelemetry.util.types import _ExtendedAttributes - - -class TestProvider(events.NoOpEventLoggerProvider): - def get_event_logger( - self, - name: str, - version: typing.Optional[str] = None, - schema_url: typing.Optional[str] = None, - attributes: typing.Optional[_ExtendedAttributes] = None, - ) -> events.EventLogger: - return LoggerTest(name) - - -class LoggerTest(events.NoOpEventLogger): - def emit(self, event: events.Event) -> None: - pass - - -class TestProxy(EventsGlobalsTest, unittest.TestCase): - def test_proxy_logger(self): - provider = events.get_event_logger_provider() - # proxy provider - self.assertIsInstance(provider, events.ProxyEventLoggerProvider) - - # provider returns proxy logger - event_logger = provider.get_event_logger("proxy-test") - self.assertIsInstance(event_logger, events.ProxyEventLogger) - - # set a real provider - events.set_event_logger_provider(TestProvider()) - - # get_logger_provider() now returns the real provider - self.assertIsInstance(events.get_event_logger_provider(), TestProvider) - - # logger provider now returns real instance - self.assertIsInstance( - events.get_event_logger_provider().get_event_logger("fresh"), - LoggerTest, - ) - - # references to the old provider still work but return real logger now - real_logger = provider.get_event_logger("proxy-test") - self.assertIsInstance(real_logger, LoggerTest) diff --git a/opentelemetry-sdk/src/opentelemetry/sdk/_configuration/__init__.py b/opentelemetry-sdk/src/opentelemetry/sdk/_configuration/__init__.py index 745a83385f9..b25f452f20b 100644 --- a/opentelemetry-sdk/src/opentelemetry/sdk/_configuration/__init__.py +++ b/opentelemetry-sdk/src/opentelemetry/sdk/_configuration/__init__.py @@ -27,7 +27,6 @@ from typing_extensions import Literal -from opentelemetry._events import set_event_logger_provider from opentelemetry._logs import set_logger_provider from opentelemetry.environment_variables import ( OTEL_LOGS_EXPORTER, @@ -36,7 +35,6 @@ OTEL_TRACES_EXPORTER, ) from opentelemetry.metrics import set_meter_provider -from opentelemetry.sdk._events import EventLoggerProvider from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler from opentelemetry.sdk._logs.export import BatchLogRecordProcessor, LogExporter from opentelemetry.sdk.environment_variables import ( @@ -249,9 +247,6 @@ def _init_logging( BatchLogRecordProcessor(exporter_class(**exporter_args)) ) - event_logger_provider = EventLoggerProvider(logger_provider=provider) - set_event_logger_provider(event_logger_provider) - if setup_logging_handler: _patch_basic_config() diff --git a/opentelemetry-sdk/src/opentelemetry/sdk/_events/__init__.py b/opentelemetry-sdk/src/opentelemetry/sdk/_events/__init__.py deleted file mode 100644 index c427a48e2f8..00000000000 --- a/opentelemetry-sdk/src/opentelemetry/sdk/_events/__init__.py +++ /dev/null @@ -1,89 +0,0 @@ -# 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 logging -from time import time_ns -from typing import Optional - -from opentelemetry import trace -from opentelemetry._events import Event -from opentelemetry._events import EventLogger as APIEventLogger -from opentelemetry._events import EventLoggerProvider as APIEventLoggerProvider -from opentelemetry._logs import NoOpLogger, SeverityNumber, get_logger_provider -from opentelemetry.sdk._logs import Logger, LoggerProvider, LogRecord -from opentelemetry.util.types import _ExtendedAttributes - -_logger = logging.getLogger(__name__) - - -class EventLogger(APIEventLogger): - def __init__( - self, - logger_provider: LoggerProvider, - name: str, - version: Optional[str] = None, - schema_url: Optional[str] = None, - attributes: Optional[_ExtendedAttributes] = None, - ): - super().__init__( - name=name, - version=version, - schema_url=schema_url, - attributes=attributes, - ) - self._logger: Logger = logger_provider.get_logger( - name, version, schema_url, attributes - ) - - def emit(self, event: Event) -> None: - if isinstance(self._logger, NoOpLogger): - # Do nothing if SDK is disabled - return - span_context = trace.get_current_span().get_span_context() - log_record = LogRecord( - timestamp=event.timestamp or time_ns(), - observed_timestamp=None, - trace_id=event.trace_id or span_context.trace_id, - span_id=event.span_id or span_context.span_id, - trace_flags=event.trace_flags or span_context.trace_flags, - severity_text=None, - severity_number=event.severity_number or SeverityNumber.INFO, - body=event.body, - resource=getattr(self._logger, "resource", None), - attributes=event.attributes, - ) - self._logger.emit(log_record) - - -class EventLoggerProvider(APIEventLoggerProvider): - def __init__(self, logger_provider: Optional[LoggerProvider] = None): - self._logger_provider = logger_provider or get_logger_provider() - - def get_event_logger( - self, - name: str, - version: Optional[str] = None, - schema_url: Optional[str] = None, - attributes: Optional[_ExtendedAttributes] = None, - ) -> EventLogger: - if not name: - _logger.warning("EventLogger created with invalid name: %s", name) - return EventLogger( - self._logger_provider, name, version, schema_url, attributes - ) - - def shutdown(self): - self._logger_provider.shutdown() - - def force_flush(self, timeout_millis: int = 30000) -> bool: - self._logger_provider.force_flush(timeout_millis) diff --git a/opentelemetry-sdk/tests/events/__init__.py b/opentelemetry-sdk/tests/events/__init__.py deleted file mode 100644 index b0a6f428417..00000000000 --- a/opentelemetry-sdk/tests/events/__init__.py +++ /dev/null @@ -1,13 +0,0 @@ -# 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. diff --git a/opentelemetry-sdk/tests/events/test_events.py b/opentelemetry-sdk/tests/events/test_events.py deleted file mode 100644 index 7b8d42ff316..00000000000 --- a/opentelemetry-sdk/tests/events/test_events.py +++ /dev/null @@ -1,202 +0,0 @@ -# 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. - -# pylint: disable=protected-access,no-self-use - -import unittest -from unittest.mock import Mock, patch - -from opentelemetry._events import Event -from opentelemetry._logs import SeverityNumber, set_logger_provider -from opentelemetry.sdk._events import EventLoggerProvider -from opentelemetry.sdk._logs import LoggerProvider -from opentelemetry.sdk._logs._internal import Logger, NoOpLogger -from opentelemetry.sdk.environment_variables import OTEL_SDK_DISABLED - - -class TestEventLoggerProvider(unittest.TestCase): - def test_event_logger_provider(self): - logger_provider = LoggerProvider() - event_logger_provider = EventLoggerProvider( - logger_provider=logger_provider - ) - - self.assertEqual( - event_logger_provider._logger_provider, - logger_provider, - ) - - def test_event_logger_provider_default(self): - logger_provider = LoggerProvider() - set_logger_provider(logger_provider) - event_logger_provider = EventLoggerProvider() - - self.assertEqual( - event_logger_provider._logger_provider, - logger_provider, - ) - - def test_get_event_logger(self): - logger_provider = LoggerProvider() - event_logger = EventLoggerProvider(logger_provider).get_event_logger( - "name", - version="version", - schema_url="schema_url", - attributes={"key": "value"}, - ) - self.assertTrue( - event_logger._logger, - Logger, - ) - logger = event_logger._logger - self.assertEqual(logger._instrumentation_scope.name, "name") - self.assertEqual(logger._instrumentation_scope.version, "version") - self.assertEqual( - logger._instrumentation_scope.schema_url, "schema_url" - ) - self.assertEqual( - logger._instrumentation_scope.attributes, {"key": "value"} - ) - - @patch.dict("os.environ", {OTEL_SDK_DISABLED: "true"}) - def test_get_event_logger_with_sdk_disabled(self): - logger_provider = LoggerProvider() - event_logger = EventLoggerProvider(logger_provider).get_event_logger( - "name", - version="version", - schema_url="schema_url", - attributes={"key": "value"}, - ) - self.assertIsInstance(event_logger._logger, NoOpLogger) - - def test_force_flush(self): - logger_provider = Mock() - event_logger = EventLoggerProvider(logger_provider) - event_logger.force_flush(1000) - logger_provider.force_flush.assert_called_once_with(1000) - - def test_shutdown(self): - logger_provider = Mock() - event_logger = EventLoggerProvider(logger_provider) - event_logger.shutdown() - logger_provider.shutdown.assert_called_once() - - @patch("opentelemetry.sdk._logs._internal.LoggerProvider.get_logger") - def test_event_logger(self, logger_mock): - logger_provider = LoggerProvider() - logger_mock_inst = Mock() - logger_mock.return_value = logger_mock_inst - EventLoggerProvider(logger_provider).get_event_logger( - "name", - version="version", - schema_url="schema_url", - attributes={"key": "value"}, - ) - logger_mock.assert_called_once_with( - "name", "version", "schema_url", {"key": "value"} - ) - - @patch("opentelemetry.sdk._events.LogRecord") - @patch("opentelemetry.sdk._logs._internal.LoggerProvider.get_logger") - def test_event_logger_emit(self, logger_mock, log_record_mock): - logger_provider = LoggerProvider() - logger_mock_inst = Mock() - logger_mock.return_value = logger_mock_inst - event_logger = EventLoggerProvider(logger_provider).get_event_logger( - "name", - version="version", - schema_url="schema_url", - attributes={"key": "value"}, - ) - logger_mock.assert_called_once_with( - "name", "version", "schema_url", {"key": "value"} - ) - now = Mock() - trace_id = Mock() - span_id = Mock() - trace_flags = Mock() - event = Event( - name="test_event", - timestamp=now, - trace_id=trace_id, - span_id=span_id, - trace_flags=trace_flags, - body="test body", - severity_number=SeverityNumber.ERROR, - attributes={ - "key": "val", - "foo": "bar", - "event.name": "not this one", - }, - ) - log_record_mock_inst = Mock() - log_record_mock.return_value = log_record_mock_inst - event_logger.emit(event) - log_record_mock.assert_called_once_with( - timestamp=now, - observed_timestamp=None, - trace_id=trace_id, - span_id=span_id, - trace_flags=trace_flags, - severity_text=None, - severity_number=SeverityNumber.ERROR, - body="test body", - resource=event_logger._logger.resource, - attributes={ - "key": "val", - "foo": "bar", - "event.name": "test_event", - }, - ) - logger_mock_inst.emit.assert_called_once_with(log_record_mock_inst) - - @patch("opentelemetry.sdk._events.LogRecord") - @patch("opentelemetry.sdk._logs._internal.LoggerProvider.get_logger") - def test_event_logger_emit_sdk_disabled( - self, logger_mock, log_record_mock - ): - logger_provider = LoggerProvider() - logger_mock_inst = Mock(spec=NoOpLogger) - logger_mock.return_value = logger_mock_inst - event_logger = EventLoggerProvider(logger_provider).get_event_logger( - "name", - version="version", - schema_url="schema_url", - attributes={"key": "value"}, - ) - logger_mock.assert_called_once_with( - "name", "version", "schema_url", {"key": "value"} - ) - now = Mock() - trace_id = Mock() - span_id = Mock() - trace_flags = Mock() - event = Event( - name="test_event", - timestamp=now, - trace_id=trace_id, - span_id=span_id, - trace_flags=trace_flags, - body="test body", - severity_number=SeverityNumber.ERROR, - attributes={ - "key": "val", - "foo": "bar", - "event.name": "not this one", - }, - ) - log_record_mock_inst = Mock() - log_record_mock.return_value = log_record_mock_inst - event_logger.emit(event) - logger_mock_inst.emit.assert_not_called() diff --git a/opentelemetry-sdk/tests/test_configurator.py b/opentelemetry-sdk/tests/test_configurator.py index 9fda75b66f0..42f454d1431 100644 --- a/opentelemetry-sdk/tests/test_configurator.py +++ b/opentelemetry-sdk/tests/test_configurator.py @@ -590,32 +590,14 @@ def setUp(self): "opentelemetry.sdk._configuration.set_logger_provider" ) - self.event_logger_provider_instance_mock = Mock() - self.event_logger_provider_patch = patch( - "opentelemetry.sdk._configuration.EventLoggerProvider", - return_value=self.event_logger_provider_instance_mock, - ) - self.set_event_logger_provider_patch = patch( - "opentelemetry.sdk._configuration.set_event_logger_provider" - ) - self.processor_mock = self.processor_patch.start() self.provider_mock = self.provider_patch.start() self.set_provider_mock = self.set_provider_patch.start() - self.event_logger_provider_mock = ( - self.event_logger_provider_patch.start() - ) - self.set_event_logger_provider_mock = ( - self.set_event_logger_provider_patch.start() - ) - def tearDown(self): self.processor_patch.stop() self.set_provider_patch.stop() self.provider_patch.stop() - self.event_logger_provider_patch.stop() - self.set_event_logger_provider_patch.stop() root_logger = getLogger("root") root_logger.handlers = [ handler @@ -638,12 +620,6 @@ def test_logging_init_empty(self): provider.resource.attributes.get("telemetry.auto.version"), "auto-version", ) - self.event_logger_provider_mock.assert_called_once_with( - logger_provider=provider - ) - self.set_event_logger_provider_mock.assert_called_once_with( - self.event_logger_provider_instance_mock - ) @patch.dict( environ, diff --git a/tests/opentelemetry-test-utils/src/opentelemetry/test/globals_test.py b/tests/opentelemetry-test-utils/src/opentelemetry/test/globals_test.py index c373658222b..ed210f27973 100644 --- a/tests/opentelemetry-test-utils/src/opentelemetry/test/globals_test.py +++ b/tests/opentelemetry-test-utils/src/opentelemetry/test/globals_test.py @@ -14,7 +14,6 @@ import unittest -from opentelemetry import _events as events_api from opentelemetry import trace as trace_api from opentelemetry._logs import _internal as logging_api from opentelemetry.metrics import _internal as metrics_api @@ -46,16 +45,6 @@ def reset_logging_globals() -> None: logging_api._PROXY_LOGGER_PROVIDER = logging_api.ProxyLoggerProvider() # type: ignore[attr-defined] -# pylint: disable=protected-access -def reset_event_globals() -> None: - """WARNING: only use this for tests.""" - events_api._EVENT_LOGGER_PROVIDER_SET_ONCE = Once() # type: ignore[attr-defined] - events_api._EVENT_LOGGER_PROVIDER = None # type: ignore[attr-defined] - events_api._PROXY_EVENT_LOGGER_PROVIDER = ( - events_api.ProxyEventLoggerProvider() - ) # type: ignore[attr-defined] - - class TraceGlobalsTest(unittest.TestCase): """Resets trace API globals in setUp/tearDown @@ -99,18 +88,3 @@ def setUp(self) -> None: def tearDown(self) -> None: super().tearDown() reset_logging_globals() - - -class EventsGlobalsTest(unittest.TestCase): - """Resets logging API globals in setUp/tearDown - - Use as a base class or mixin for your test that modifies logging API globals. - """ - - def setUp(self) -> None: - super().setUp() - reset_event_globals() - - def tearDown(self) -> None: - super().tearDown() - reset_event_globals()