Do not load resource on sdk import (#3447)

CHANGELOG.md

@@ -15,6 +15,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   ([#3428](https://github.com/open-telemetry/opentelemetry-python/pull/3428))
 - Allow instrument names to have '/' and up to 255 characters
   ([#3442](https://github.com/open-telemetry/opentelemetry-python/pull/3442))
+- Do not load Resource on sdk import
+  ([#3447](https://github.com/open-telemetry/opentelemetry-python/pull/3447))
 
 ## Version 1.20.0/0.41b0 (2023-09-04)
 

opentelemetry-sdk/src/opentelemetry/sdk/_logs/_internal/__init__.py

@@ -581,14 +581,17 @@ def emit(self, record: LogRecord):
 class LoggerProvider(APILoggerProvider):
     def __init__(
         self,
-        resource: Resource = Resource.create(),
+        resource: Resource = None,
         shutdown_on_exit: bool = True,
         multi_log_record_processor: Union[
             SynchronousMultiLogRecordProcessor,
             ConcurrentMultiLogRecordProcessor,
         ] = None,
     ):
-        self._resource = resource
+        if resource is None:
+            self._resource = Resource.create({})
+        else:
+            self._resource = resource
         self._multi_log_record_processor = (
             multi_log_record_processor or SynchronousMultiLogRecordProcessor()
         )

opentelemetry-sdk/src/opentelemetry/sdk/metrics/_internal/__init__.py

@@ -341,13 +341,15 @@ def __init__(
         metric_readers: Sequence[
             "opentelemetry.sdk.metrics.export.MetricReader"
         ] = (),
-        resource: Resource = Resource.create({}),
+        resource: Resource = None,
         shutdown_on_exit: bool = True,
         views: Sequence["opentelemetry.sdk.metrics.view.View"] = (),
     ):
         self._lock = Lock()
         self._meter_lock = Lock()
         self._atexit_handler = None
+        if resource is None:
+            resource = Resource.create({})
         self._sdk_config = SdkConfiguration(
             resource=resource,
             metric_readers=metric_readers,

opentelemetry-sdk/src/opentelemetry/sdk/trace/__init__.py

@@ -351,7 +351,7 @@ def __init__(
         name: str = None,
         context: trace_api.SpanContext = None,
         parent: Optional[trace_api.SpanContext] = None,
-        resource: Resource = Resource.create({}),
+        resource: Resource = None,
         attributes: types.Attributes = None,
         events: Sequence[Event] = (),
         links: Sequence[trace_api.Link] = (),
@@ -373,7 +373,10 @@ def __init__(
         self._attributes = attributes
         self._events = events
         self._links = links
-        self._resource = resource
+        if resource is None:
+            self._resource = Resource.create({})
+        else:
+            self._resource = resource
         self._status = status
 
     @property
@@ -745,7 +748,7 @@ def __init__(
         parent: Optional[trace_api.SpanContext] = None,
         sampler: Optional[sampling.Sampler] = None,
         trace_config: None = None,  # TODO
-        resource: Resource = Resource.create({}),
+        resource: Resource = None,
         attributes: types.Attributes = None,
         events: Sequence[Event] = None,
         links: Sequence[trace_api.Link] = (),
@@ -757,6 +760,8 @@ def __init__(
         limits=_UnsetLimits,
         instrumentation_scope: InstrumentationScope = None,
     ) -> None:
+        if resource is None:
+            resource = Resource.create({})
         super().__init__(
             name=name,
             context=context,
@@ -1128,7 +1133,7 @@ class TracerProvider(trace_api.TracerProvider):
     def __init__(
         self,
         sampler: sampling.Sampler = None,
-        resource: Resource = Resource.create({}),
+        resource: Resource = None,
         shutdown_on_exit: bool = True,
         active_span_processor: Union[
             SynchronousMultiSpanProcessor, ConcurrentMultiSpanProcessor
@@ -1143,7 +1148,10 @@ def __init__(
             self.id_generator = RandomIdGenerator()
         else:
             self.id_generator = id_generator
-        self._resource = resource
+        if resource is None:
+            self._resource = Resource.create({})
+        else:
+            self._resource = resource
         if not sampler:
             sampler = sampling._get_from_env_or_default()
         self.sampler = sampler

opentelemetry-sdk/tests/logs/test_logs.py

@@ -15,8 +15,12 @@
 # pylint: disable=protected-access
 
 import unittest
+from unittest.mock import patch
 
 from opentelemetry.sdk._logs import LoggerProvider
+from opentelemetry.sdk._logs._internal import (
+    SynchronousMultiLogRecordProcessor,
+)
 from opentelemetry.sdk.resources import Resource
 
 
@@ -29,7 +33,7 @@ def test_resource(self):
         logger_provider_0 = LoggerProvider()
         logger_provider_1 = LoggerProvider()
 
-        self.assertIs(
+        self.assertEqual(
             logger_provider_0.resource,
             logger_provider_1.resource,
         )
@@ -56,3 +60,16 @@ def test_get_logger(self):
         self.assertEqual(
             logger._instrumentation_scope.schema_url, "schema_url"
         )
+
+    @patch.object(Resource, "create")
+    def test_logger_provider_init(self, resource_patch):
+        logger_provider = LoggerProvider()
+        resource_patch.assert_called_once()
+        self.assertIsNotNone(logger_provider._resource)
+        self.assertTrue(
+            isinstance(
+                logger_provider._multi_log_record_processor,
+                SynchronousMultiLogRecordProcessor,
+            )
+        )
+        self.assertIsNotNone(logger_provider._at_exit_handler)

opentelemetry-sdk/tests/metrics/test_metrics.py

@@ -30,6 +30,7 @@
     ObservableUpDownCounter,
     UpDownCounter,
 )
+from opentelemetry.sdk.metrics._internal import SynchronousMeasurementConsumer
 from opentelemetry.sdk.metrics.export import (
     Metric,
     MetricExporter,
@@ -63,6 +64,21 @@ def tearDown(self):
 
         MeterProvider._all_metric_readers = set()
 
+    @patch.object(Resource, "create")
+    def test_init_default(self, resource_patch):
+        meter_provider = MeterProvider()
+        resource_mock = resource_patch.return_value
+        resource_patch.assert_called_once()
+        self.assertIsNotNone(meter_provider._sdk_config)
+        self.assertEqual(meter_provider._sdk_config.resource, resource_mock)
+        self.assertTrue(
+            isinstance(
+                meter_provider._measurement_consumer,
+                SynchronousMeasurementConsumer,
+            )
+        )
+        self.assertIsNotNone(meter_provider._atexit_handler)
+
     def test_register_metric_readers(self):
         mock_exporter = Mock()
         mock_exporter._preferred_temporality = None
@@ -88,7 +104,7 @@ def test_resource(self):
         meter_provider_0 = MeterProvider()
         meter_provider_1 = MeterProvider()
 
-        self.assertIs(
+        self.assertEqual(
             meter_provider_0._sdk_config.resource,
             meter_provider_1._sdk_config.resource,
         )

opentelemetry-sdk/tests/trace/test_trace.py

@@ -23,7 +23,7 @@
 from time import time_ns
 from typing import Optional
 from unittest import mock
-from unittest.mock import Mock
+from unittest.mock import Mock, patch
 
 from opentelemetry import trace as trace_api
 from opentelemetry.context import Context
@@ -1942,3 +1942,19 @@ def test_child_parent_span_exception(self):
         self.assertTrue(parent_span.status.is_ok)
         self.assertIsNone(parent_span.status.description)
         self.assertTupleEqual(parent_span.events, ())
+
+
+# pylint: disable=protected-access
+class TestTracerProvider(unittest.TestCase):
+    @patch("opentelemetry.sdk.trace.sampling._get_from_env_or_default")
+    @patch.object(Resource, "create")
+    def test_tracer_provider_init_default(self, resource_patch, sample_patch):
+        tracer_provider = trace.TracerProvider()
+        self.assertTrue(
+            isinstance(tracer_provider.id_generator, RandomIdGenerator)
+        )
+        resource_patch.assert_called_once()
+        self.assertIsNotNone(tracer_provider._resource)
+        sample_patch.assert_called_once()
+        self.assertIsNotNone(tracer_provider._span_limits)
+        self.assertIsNotNone(tracer_provider._atexit_handler)