Add optional type hinting to arguments (open-telemetry#4455)

* Add optional to arguments that are optional

* Add Optional type hint in all places where arguments are optional

* Update some to use | syntax rather than Optional

* Fix some more type formatting for Optional

---------

Co-authored-by: Riccardo Magliocchetti <[email protected]>

Author: DominicOram

exporter/opentelemetry-exporter-otlp-proto-common/src/opentelemetry/exporter/otlp/proto/common/_internal/metrics_encoder/__init__.py

@@ -11,6 +11,8 @@
 # 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 __future__ import annotations
+
 import logging
 from os import environ
 from typing import Dict, List
@@ -66,8 +68,9 @@
 class OTLPMetricExporterMixin:
     def _common_configuration(
         self,
-        preferred_temporality: Dict[type, AggregationTemporality] = None,
-        preferred_aggregation: Dict[type, Aggregation] = None,
+        preferred_temporality: dict[type, AggregationTemporality]
+        | None = None,
+        preferred_aggregation: dict[type, Aggregation] | None = None,
     ) -> None:
         MetricExporter.__init__(
             self,

exporter/opentelemetry-exporter-otlp-proto-grpc/src/opentelemetry/exporter/otlp/proto/grpc/metric_exporter/__init__.py

@@ -11,10 +11,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from dataclasses import replace
 from logging import getLogger
 from os import environ
-from typing import Dict, Iterable, List, Optional, Tuple, Union
+from typing import Iterable, List, Tuple, Union
 from typing import Sequence as TypingSequence
 
 from grpc import ChannelCredentials, Compression
@@ -92,17 +94,17 @@ class OTLPMetricExporter(
 
     def __init__(
         self,
-        endpoint: Optional[str] = None,
-        insecure: Optional[bool] = None,
-        credentials: Optional[ChannelCredentials] = None,
-        headers: Optional[
-            Union[TypingSequence[Tuple[str, str]], Dict[str, str], str]
-        ] = None,
-        timeout: Optional[int] = None,
-        compression: Optional[Compression] = None,
-        preferred_temporality: Dict[type, AggregationTemporality] = None,
-        preferred_aggregation: Dict[type, Aggregation] = None,
-        max_export_batch_size: Optional[int] = None,
+        endpoint: str | None = None,
+        insecure: bool | None = None,
+        credentials: ChannelCredentials | None = None,
+        headers: Union[TypingSequence[Tuple[str, str]], dict[str, str], str]
+        | None = None,
+        timeout: int | None = None,
+        compression: Compression | None = None,
+        preferred_temporality: dict[type, AggregationTemporality]
+        | None = None,
+        preferred_aggregation: dict[type, Aggregation] | None = None,
+        max_export_batch_size: int | None = None,
     ):
         if insecure is None:
             insecure = environ.get(OTEL_EXPORTER_OTLP_METRICS_INSECURE)
@@ -146,7 +148,7 @@ def __init__(
             compression=compression,
         )
 
-        self._max_export_batch_size: Optional[int] = max_export_batch_size
+        self._max_export_batch_size: int | None = max_export_batch_size
 
     def _translate_data(
         self, data: MetricsData

exporter/opentelemetry-exporter-otlp-proto-http/src/opentelemetry/exporter/otlp/proto/http/metric_exporter/__init__.py

@@ -10,6 +10,7 @@
 # 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 __future__ import annotations
 
 import gzip
 import logging
@@ -23,7 +24,6 @@
     Dict,
     List,
     Mapping,
-    Optional,
     Sequence,
 )
 
@@ -101,16 +101,17 @@ class OTLPMetricExporter(MetricExporter, OTLPMetricExporterMixin):
 
     def __init__(
         self,
-        endpoint: Optional[str] = None,
-        certificate_file: Optional[str] = None,
-        client_key_file: Optional[str] = None,
-        client_certificate_file: Optional[str] = None,
-        headers: Optional[Dict[str, str]] = None,
-        timeout: Optional[int] = None,
-        compression: Optional[Compression] = None,
-        session: Optional[requests.Session] = None,
-        preferred_temporality: Dict[type, AggregationTemporality] = None,
-        preferred_aggregation: Dict[type, Aggregation] = None,
+        endpoint: str | None = None,
+        certificate_file: str | None = None,
+        client_key_file: str | None = None,
+        client_certificate_file: str | None = None,
+        headers: dict[str, str] | None = None,
+        timeout: int | None = None,
+        compression: Compression | None = None,
+        session: requests.Session | None = None,
+        preferred_temporality: dict[type, AggregationTemporality]
+        | None = None,
+        preferred_aggregation: dict[type, Aggregation] | None = None,
     ):
         self._endpoint = endpoint or environ.get(
             OTEL_EXPORTER_OTLP_METRICS_ENDPOINT,

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

@@ -17,11 +17,13 @@
 OpenTelemetry SDK Configurator for Easy Instrumentation with Distros
 """
 
+from __future__ import annotations
+
 import logging
 import os
 from abc import ABC, abstractmethod
 from os import environ
-from typing import Callable, Dict, List, Optional, Sequence, Tuple, Type, Union
+from typing import Callable, Sequence, Type, Union
 
 from typing_extensions import Literal
 
@@ -91,8 +93,8 @@
 
 
 def _import_config_components(
-    selected_components: List[str], entry_point_name: str
-) -> Sequence[Tuple[str, object]]:
+    selected_components: list[str], entry_point_name: str
+) -> Sequence[tuple[str, object]]:
     component_implementations = []
 
     for selected_component in selected_components:
@@ -123,7 +125,7 @@ def _import_config_components(
     return component_implementations
 
 
-def _get_sampler() -> Optional[str]:
+def _get_sampler() -> str | None:
     return environ.get(OTEL_TRACES_SAMPLER, None)
 
 
@@ -190,10 +192,10 @@ def _get_exporter_names(
 
 
 def _init_tracing(
-    exporters: Dict[str, Type[SpanExporter]],
-    id_generator: IdGenerator = None,
-    sampler: Sampler = None,
-    resource: Resource = None,
+    exporters: dict[str, Type[SpanExporter]],
+    id_generator: IdGenerator | None = None,
+    sampler: Sampler | None = None,
+    resource: Resource | None = None,
 ):
     provider = TracerProvider(
         id_generator=id_generator,
@@ -210,10 +212,10 @@ def _init_tracing(
 
 
 def _init_metrics(
-    exporters_or_readers: Dict[
+    exporters_or_readers: dict[
         str, Union[Type[MetricExporter], Type[MetricReader]]
     ],
-    resource: Resource = None,
+    resource: Resource | None = None,
 ):
     metric_readers = []
 
@@ -234,8 +236,8 @@ def _init_metrics(
 
 
 def _init_logging(
-    exporters: Dict[str, Type[LogExporter]],
-    resource: Resource = None,
+    exporters: dict[str, Type[LogExporter]],
+    resource: Resource | None = None,
     setup_logging_handler: bool = True,
 ):
     provider = LoggerProvider(resource=resource)
@@ -261,10 +263,10 @@ def _import_exporters(
     trace_exporter_names: Sequence[str],
     metric_exporter_names: Sequence[str],
     log_exporter_names: Sequence[str],
-) -> Tuple[
-    Dict[str, Type[SpanExporter]],
-    Dict[str, Union[Type[MetricExporter], Type[MetricReader]]],
-    Dict[str, Type[LogExporter]],
+) -> tuple[
+    dict[str, Type[SpanExporter]],
+    dict[str, Union[Type[MetricExporter], Type[MetricReader]]],
+    dict[str, Type[LogExporter]],
 ]:
     trace_exporters = {}
     metric_exporters = {}
@@ -315,7 +317,7 @@ def _import_sampler_factory(sampler_name: str) -> Callable[[str], Sampler]:
     return sampler_impl
 
 
-def _import_sampler(sampler_name: str) -> Optional[Sampler]:
+def _import_sampler(sampler_name: str) -> Sampler | None:
     if not sampler_name:
         return None
     try:
@@ -360,14 +362,14 @@ def _import_id_generator(id_generator_name: str) -> IdGenerator:
 
 
 def _initialize_components(
-    auto_instrumentation_version: Optional[str] = None,
-    trace_exporter_names: Optional[List[str]] = None,
-    metric_exporter_names: Optional[List[str]] = None,
-    log_exporter_names: Optional[List[str]] = None,
-    sampler: Optional[Sampler] = None,
-    resource_attributes: Optional[Attributes] = None,
-    id_generator: IdGenerator = None,
-    setup_logging_handler: Optional[bool] = None,
+    auto_instrumentation_version: str | None = None,
+    trace_exporter_names: list[str] | None = None,
+    metric_exporter_names: list[str] | None = None,
+    log_exporter_names: list[str] | None = None,
+    sampler: Sampler | None = None,
+    resource_attributes: Attributes | None = None,
+    id_generator: IdGenerator | None = None,
+    setup_logging_handler: bool | None = None,
 ):
     if trace_exporter_names is None:
         trace_exporter_names = []

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

@@ -11,6 +11,7 @@
 # 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 __future__ import annotations
 
 import abc
 import atexit
@@ -23,7 +24,7 @@
 from os import environ
 from threading import Lock
 from time import time_ns
-from typing import Any, Callable, Optional, Tuple, Union  # noqa
+from typing import Any, Callable, Tuple, Union  # noqa
 
 from opentelemetry._logs import Logger as APILogger
 from opentelemetry._logs import LoggerProvider as APILoggerProvider
@@ -105,8 +106,8 @@ class LogLimits:
 
     def __init__(
         self,
-        max_attributes: Optional[int] = None,
-        max_attribute_length: Optional[int] = None,
+        max_attributes: int | None = None,
+        max_attribute_length: int | None = None,
     ):
         # attribute count
         global_max_attributes = self._from_env_if_absent(
@@ -129,8 +130,8 @@ def __repr__(self):
 
     @classmethod
     def _from_env_if_absent(
-        cls, value: Optional[int], env_var: str, default: Optional[int] = None
-    ) -> Optional[int]:
+        cls, value: int | None, env_var: str, default: int | None = None
+    ) -> int | None:
         if value == cls.UNSET:
             return None
 
@@ -172,17 +173,17 @@ class LogRecord(APILogRecord):
 
     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[AnyValue] = None,
-        resource: Optional[Resource] = None,
-        attributes: Optional[Attributes] = None,
-        limits: Optional[LogLimits] = _UnsetLogLimits,
+        timestamp: int | None = None,
+        observed_timestamp: int | None = None,
+        trace_id: int | None = None,
+        span_id: int | None = None,
+        trace_flags: TraceFlags | None = None,
+        severity_text: str | None = None,
+        severity_number: SeverityNumber | None = None,
+        body: AnyValue | None = None,
+        resource: Resource | None = None,
+        attributes: Attributes | None = None,
+        limits: LogLimits | None = _UnsetLogLimits,
     ):
         super().__init__(
             **{
@@ -217,7 +218,7 @@ def __eq__(self, other: object) -> bool:
             return NotImplemented
         return self.__dict__ == other.__dict__
 
-    def to_json(self, indent: Optional[int] = 4) -> str:
+    def to_json(self, indent: int | None = 4) -> str:
         return json.dumps(
             {
                 "body": self.body,
@@ -602,12 +603,11 @@ def emit(self, record: LogRecord):
 class LoggerProvider(APILoggerProvider):
     def __init__(
         self,
-        resource: Resource = None,
+        resource: Resource | None = None,
         shutdown_on_exit: bool = True,
-        multi_log_record_processor: Union[
-            SynchronousMultiLogRecordProcessor,
-            ConcurrentMultiLogRecordProcessor,
-        ] = None,
+        multi_log_record_processor: SynchronousMultiLogRecordProcessor
+        | ConcurrentMultiLogRecordProcessor
+        | None = None,
     ):
         if resource is None:
             self._resource = Resource.create({})
@@ -631,9 +631,9 @@ def resource(self):
     def _get_logger_no_cache(
         self,
         name: str,
-        version: Optional[str] = None,
-        schema_url: Optional[str] = None,
-        attributes: Optional[Attributes] = None,
+        version: str | None = None,
+        schema_url: str | None = None,
+        attributes: Attributes | None = None,
     ) -> Logger:
         return Logger(
             self._resource,
@@ -649,8 +649,8 @@ def _get_logger_no_cache(
     def _get_logger_cached(
         self,
         name: str,
-        version: Optional[str] = None,
-        schema_url: Optional[str] = None,
+        version: str | None = None,
+        schema_url: str | None = None,
     ) -> Logger:
         with self._logger_cache_lock:
             key = (name, version, schema_url)
@@ -665,9 +665,9 @@ def _get_logger_cached(
     def get_logger(
         self,
         name: str,
-        version: Optional[str] = None,
-        schema_url: Optional[str] = None,
-        attributes: Optional[Attributes] = None,
+        version: str | None = None,
+        schema_url: str | None = None,
+        attributes: Attributes | None = None,
     ) -> Logger:
         if self._disabled:
             return NoOpLogger(

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

@@ -11,6 +11,7 @@
 # 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 __future__ import annotations
 
 import abc
 import collections
@@ -165,16 +166,16 @@ class BatchLogRecordProcessor(LogRecordProcessor):
     """
 
     _queue: Deque[LogData]
-    _flush_request: Optional[_FlushRequest]
-    _log_records: List[Optional[LogData]]
+    _flush_request: _FlushRequest | None
+    _log_records: List[LogData | None]
 
     def __init__(
         self,
         exporter: LogExporter,
-        schedule_delay_millis: float = None,
-        max_export_batch_size: int = None,
-        export_timeout_millis: float = None,
-        max_queue_size: int = None,
+        schedule_delay_millis: float | None = None,
+        max_export_batch_size: int | None = None,
+        export_timeout_millis: float | None = None,
+        max_queue_size: int | None = None,
     ):
         if max_queue_size is None:
             max_queue_size = BatchLogRecordProcessor._default_max_queue_size()