Upgrade ruff to 0.16 (open-telemetry#5471)

* Upgrade ruff

* Change ruff stuff

Author: DylanRussell

.pre-commit-config.yaml

@@ -1,13 +1,18 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.14.1
+    rev: v0.16.0
     hooks:
       # Run the linter.
       - id: ruff
         args: ["--fix", "--show-fixes"]
       # Run the formatter.
       - id: ruff-format
+      - id: ruff-format
+        name: ruff-format (markdown & towncrier)
+        types_or: [python, pyi, jupyter, markdown, text]
+        files: \.(md|added|changed|deprecated|removed|fixed)$
+        args: ["--preview"]
   - repo: https://github.com/astral-sh/uv-pre-commit
     # uv version.
     rev: 0.6.0

CHANGELOG.md

@@ -545,24 +545,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
     ```python
     # Before
     from opentelemetry.sdk._logs import LogData
-    def export(self, batch: Sequence[LogData]) -> LogRecordExportResult:
-        ...
+
+
+    def export(self, batch: Sequence[LogData]) -> LogRecordExportResult: ...
+
 
     # After
     from opentelemetry.sdk._logs import ReadableLogRecord
-    def export(self, batch: Sequence[ReadableLogRecord]) -> LogRecordExportResult:
-        ...
+
+
+    def export(
+        self, batch: Sequence[ReadableLogRecord]
+    ) -> LogRecordExportResult: ...
     ```
 
   - **For Log Processors:** Use `ReadWriteLogRecord` for processing, `ReadableLogRecord` for exporting
     ```python
     # Before
     from opentelemetry.sdk._logs import LogData
-    def on_emit(self, log_data: LogData):
-        ...
+
+
+    def on_emit(self, log_data: LogData): ...
+
 
     # After
     from opentelemetry.sdk._logs import ReadWriteLogRecord, ReadableLogRecord
+
+
     def on_emit(self, log_record: ReadWriteLogRecord):
         # Convert to ReadableLogRecord before exporting
         readable = ReadableLogRecord(

dev-requirements.txt

@@ -17,4 +17,4 @@ asgiref==3.7.2
 psutil==7.2.2
 GitPython==3.1.52
 pre-commit==3.7.0
-ruff==0.14.1
+ruff==0.16.0

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

@@ -332,73 +332,120 @@ def create_observable_counter(
         For example, an observable counter could be used to report system CPU
         time periodically. Here is a basic implementation::
 
-            def cpu_time_callback(options: CallbackOptions) -> Iterable[Observation]:
+            def cpu_time_callback(
+                options: CallbackOptions,
+            ) -> Iterable[Observation]:
                 observations = []
                 with open("/proc/stat") as procstat:
                     procstat.readline()  # skip the first line
                     for line in procstat:
-                        if not line.startswith("cpu"): break
+                        if not line.startswith("cpu"):
+                            break
                         cpu, *states = line.split()
-                        observations.append(Observation(int(states[0]) // 100, {"cpu": cpu, "state": "user"}))
-                        observations.append(Observation(int(states[1]) // 100, {"cpu": cpu, "state": "nice"}))
-                        observations.append(Observation(int(states[2]) // 100, {"cpu": cpu, "state": "system"}))
+                        observations.append(
+                            Observation(
+                                int(states[0]) // 100,
+                                {"cpu": cpu, "state": "user"},
+                            )
+                        )
+                        observations.append(
+                            Observation(
+                                int(states[1]) // 100,
+                                {"cpu": cpu, "state": "nice"},
+                            )
+                        )
+                        observations.append(
+                            Observation(
+                                int(states[2]) // 100,
+                                {"cpu": cpu, "state": "system"},
+                            )
+                        )
                         # ... other states
                 return observations
 
+
             meter.create_observable_counter(
                 "system.cpu.time",
                 callbacks=[cpu_time_callback],
                 unit="s",
-                description="CPU time"
+                description="CPU time",
             )
 
         To reduce memory usage, you can use generator callbacks instead of
         building the full list::
 
-            def cpu_time_callback(options: CallbackOptions) -> Iterable[Observation]:
+            def cpu_time_callback(
+                options: CallbackOptions,
+            ) -> Iterable[Observation]:
                 with open("/proc/stat") as procstat:
                     procstat.readline()  # skip the first line
                     for line in procstat:
-                        if not line.startswith("cpu"): break
+                        if not line.startswith("cpu"):
+                            break
                         cpu, *states = line.split()
-                        yield Observation(int(states[0]) // 100, {"cpu": cpu, "state": "user"})
-                        yield Observation(int(states[1]) // 100, {"cpu": cpu, "state": "nice"})
+                        yield Observation(
+                            int(states[0]) // 100,
+                            {"cpu": cpu, "state": "user"},
+                        )
+                        yield Observation(
+                            int(states[1]) // 100,
+                            {"cpu": cpu, "state": "nice"},
+                        )
                         # ... other states
 
         Alternatively, you can pass a sequence of generators directly instead of a sequence of
         callbacks, which each should return iterables of :class:`~opentelemetry.metrics.Observation`::
 
-            def cpu_time_callback(states_to_include: set[str]) -> Iterable[Iterable[Observation]]:
+            def cpu_time_callback(
+                states_to_include: set[str],
+            ) -> Iterable[Iterable[Observation]]:
                 # accept options sent in from OpenTelemetry
                 options = yield
                 while True:
                     observations = []
                     with open("/proc/stat") as procstat:
                         procstat.readline()  # skip the first line
                         for line in procstat:
-                            if not line.startswith("cpu"): break
+                            if not line.startswith("cpu"):
+                                break
                             cpu, *states = line.split()
                             if "user" in states_to_include:
-                                observations.append(Observation(int(states[0]) // 100, {"cpu": cpu, "state": "user"}))
+                                observations.append(
+                                    Observation(
+                                        int(states[0]) // 100,
+                                        {"cpu": cpu, "state": "user"},
+                                    )
+                                )
                             if "nice" in states_to_include:
-                                observations.append(Observation(int(states[1]) // 100, {"cpu": cpu, "state": "nice"}))
+                                observations.append(
+                                    Observation(
+                                        int(states[1]) // 100,
+                                        {"cpu": cpu, "state": "nice"},
+                                    )
+                                )
                             # ... other states
                     # yield the observations and receive the options for next iteration
                     options = yield observations
 
+
             meter.create_observable_counter(
                 "system.cpu.time",
                 callbacks=[cpu_time_callback({"user", "system"})],
                 unit="s",
-                description="CPU time"
+                description="CPU time",
             )
 
         The :class:`~opentelemetry.metrics.CallbackOptions` contain a timeout which the
         callback should respect. For example if the callback does asynchronous work, like
         making HTTP requests, it should respect the timeout::
 
-            def scrape_http_callback(options: CallbackOptions) -> Iterable[Observation]:
-                r = requests.get('http://scrapethis.com', timeout=options.timeout_millis / 10**3)
+            def scrape_http_callback(
+                options: CallbackOptions,
+            ) -> Iterable[Observation]:
+                r = requests.get(
+                    "http://scrapethis.com",
+                    timeout=options.timeout_millis / 10**3,
+                )
                 for value in r.json():
                     yield Observation(value)
 

opentelemetry-api/src/opentelemetry/propagate/__init__.py

@@ -32,22 +32,24 @@
     def get_header_from_flask_request(request, key):
         return request.headers.get_all(key)
 
-    def set_header_into_requests_request(request: requests.Request,
-                                            key: str, value: str):
+
+    def set_header_into_requests_request(
+        request: requests.Request, key: str, value: str
+    ):
         request.headers[key] = value
 
+
     def example_route():
         context = PROPAGATOR.extract(
-            get_header_from_flask_request,
-            flask.request
+            get_header_from_flask_request, flask.request
         )
         request_to_downstream = requests.Request(
             "GET", "http://httpbin.org/get"
         )
         PROPAGATOR.inject(
             set_header_into_requests_request,
             request_to_downstream,
-            context=context
+            context=context,
         )
         session = requests.Session()
         session.send(request_to_downstream.prepare())

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

@@ -355,8 +355,8 @@ def start_as_current_span(
                 with tracer.start_as_current_span("two") as child:
                     child.add_event("child's event")
                     trace.get_current_span()  # returns child
-                trace.get_current_span()      # returns parent
-            trace.get_current_span()          # returns previously active span
+                trace.get_current_span()  # returns parent
+            trace.get_current_span()  # returns previously active span
 
         This is a convenience method for creating spans attached to the
         tracer's context. Applications that need more control over the span
@@ -374,8 +374,8 @@ def start_as_current_span(
         This can also be used as a decorator::
 
             @tracer.start_as_current_span("name")
-            def function():
-                ...
+            def function(): ...
+
 
             function()
 

opentelemetry-configuration/src/opentelemetry/configuration/__init__.py

@@ -13,15 +13,17 @@
 programmatic use:
 
 >>> from opentelemetry.configuration import (
-...     load_config_file, configure_sdk,
+...     load_config_file,
+...     configure_sdk,
 ... )
 >>> config = load_config_file("otel-config.yaml")
 >>> configure_sdk(config)
 
 Construct a configuration programmatically and apply it:
 
 >>> from opentelemetry.configuration import (
-...     OpenTelemetryConfiguration, configure_sdk,
+...     OpenTelemetryConfiguration,
+...     configure_sdk,
 ... )
 >>> configure_sdk(OpenTelemetryConfiguration(file_format="1.0-rc.1"))
 

opentelemetry-configuration/src/opentelemetry/configuration/_sdk.py

@@ -85,7 +85,8 @@ def configure_sdk(config: OpenTelemetryConfiguration) -> None:
 
     Example:
         >>> from opentelemetry.configuration.file import (
-        ...     load_config_file, configure_sdk,
+        ...     load_config_file,
+        ...     configure_sdk,
         ... )
         >>> config = load_config_file("otel-config.yaml")
         >>> configure_sdk(config)

opentelemetry-configuration/src/opentelemetry/configuration/file/_env_substitution.py

@@ -29,12 +29,12 @@ def substitute_env_vars(text: str) -> str:
         Text with environment variables substituted.
 
     Examples:
-        >>> os.environ['SERVICE_NAME'] = 'my-service'
-        >>> substitute_env_vars('name: ${SERVICE_NAME}')
+        >>> os.environ["SERVICE_NAME"] = "my-service"
+        >>> substitute_env_vars("name: ${SERVICE_NAME}")
         'name: my-service'
-        >>> substitute_env_vars('name: ${MISSING:-default}')
+        >>> substitute_env_vars("name: ${MISSING:-default}")
         'name: default'
-        >>> substitute_env_vars('price: $$100')
+        >>> substitute_env_vars("price: $$100")
         'price: $100'
     """
     # Pattern matches $$ (escape sequence) or ${VAR_NAME} / ${VAR_NAME:-default_value}

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

@@ -25,19 +25,23 @@
 
     trace.set_tracer_provider(
         TracerProvider(
-            resource=Resource.create({
-                "service.name": "shoppingcart",
-                "service.instance.id": "instance-12",
-            }),
+            resource=Resource.create(
+                {
+                    "service.name": "shoppingcart",
+                    "service.instance.id": "instance-12",
+                }
+            ),
         ),
     )
     print(trace.get_tracer_provider().resource.attributes)
 
-    {'telemetry.sdk.language': 'python',
-    'telemetry.sdk.name': 'opentelemetry',
-    'telemetry.sdk.version': '0.13.dev0',
-    'service.name': 'shoppingcart',
-    'service.instance.id': 'instance-12'}
+    {
+        "telemetry.sdk.language": "python",
+        "telemetry.sdk.name": "opentelemetry",
+        "telemetry.sdk.version": "0.13.dev0",
+        "service.name": "shoppingcart",
+        "service.instance.id": "instance-12",
+    }
 
 Note that the OpenTelemetry project documents certain `"standard attributes"
 <https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/resource/semantic_conventions/README.md>`_