Merge branch 'main' into fix-batchlogprocessor-gc

Author: jomcgi

.github/workflows/misc_0.yml

@@ -236,8 +236,8 @@ jobs:
       - name: Check github workflows are up to date
         run: git diff --exit-code || (echo 'Generated workflows are out of date, run "tox -e generate-workflows" and commit the changes in this PR.' && exit 1)
 
-  ruff:
-    name: ruff
+  precommit:
+    name: precommit
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repo @ SHA - ${{ github.sha }}
@@ -252,4 +252,4 @@ jobs:
         run: pip install tox
 
       - name: Run tests
-        run: tox -e ruff
+        run: tox -e precommit

.pre-commit-config.yaml

@@ -1,10 +1,15 @@
 repos:
-- repo: https://github.com/astral-sh/ruff-pre-commit
-  # Ruff version.
-  rev: v0.6.9
-  hooks:
-    # Run the linter.
-    - id: ruff
-      args: ["--fix", "--show-fixes"]
-    # Run the formatter.
-    - id: ruff-format
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    # Ruff version.
+    rev: v0.6.9
+    hooks:
+      # Run the linter.
+      - id: ruff
+        args: ["--fix", "--show-fixes"]
+      # Run the formatter.
+      - id: ruff-format
+  - repo: https://github.com/astral-sh/uv-pre-commit
+    # uv version.
+    rev: 0.6.0
+    hooks:
+      - id: uv-lock

CONTRIBUTING.md

@@ -45,7 +45,7 @@ some aspects of development, including testing against multiple Python versions.
 To install `tox`, run:
 
 ```console
-$ pip install tox
+pip install tox
 ```
 
 You can run `tox` with the following arguments:
@@ -60,19 +60,36 @@ You can run `tox` with the following arguments:
 - `tox -e lint-some-package` to run lint checks on `some-package`
 - `tox -e generate-workflows` to run creation of new CI workflows if tox environments have been updated
 - `tox -e ruff` to run ruff linter and formatter checks against the entire codebase
+- `tox -e precommit` to run all `pre-commit` actions
 
 `ruff check` and `ruff format` are executed when `tox -e ruff` is run. We strongly recommend you to configure [pre-commit](https://pre-commit.com/) locally to run `ruff` automatically before each commit by installing it as git hooks. You just need to [install pre-commit](https://pre-commit.com/#install) in your environment:
 
 ```console
-$ pip install pre-commit -c dev-requirements.txt
+pip install pre-commit -c dev-requirements.txt
 ```
 
 and run this command inside the git repository:
 
 ```console
-$ pre-commit install
+pre-commit install
 ```
 
+### Virtual Environment
+
+You can also create a single virtual environment to make it easier to run local tests.
+
+For that, you'll need to install [`uv`](https://docs.astral.sh/uv/getting-started/installation/).
+
+After installing `uv`, you can run the following command:
+
+```sh
+uv sync
+```
+
+This will create a virtual environment in the `.venv` directory and install all the necessary dependencies.
+
+### Public Symbols
+
 We try to keep the amount of _public symbols_ in our code minimal. A public symbol is any Python identifier that does not start with an underscore.
 Every public symbol is something that has to be kept in order to maintain backwards compatibility, so we try to have as few as possible.
 
@@ -107,7 +124,7 @@ See
 [`tox.ini`](https://github.com/open-telemetry/opentelemetry-python/blob/main/tox.ini)
 for more detail on available tox commands.
 
-#### Contrib repo
+### Contrib repo
 
 Some of the `tox` targets install packages from the [OpenTelemetry Python Contrib Repository](https://github.com/open-telemetry/opentelemetry-python.git) via
 pip. The version of the packages installed defaults to the `main` branch in that repository when `tox` is run locally. It is possible to install packages tagged
@@ -153,31 +170,45 @@ pull requests (PRs).
 To create a new PR, fork the project in GitHub and clone the upstream repo:
 
 ```console
-$ git clone https://github.com/open-telemetry/opentelemetry-python.git
-$ cd opentelemetry-python
+git clone https://github.com/open-telemetry/opentelemetry-python.git
+cd opentelemetry-python
 ```
 
 Add your fork as an origin:
 
 ```console
-$ git remote add fork https://github.com/YOUR_GITHUB_USERNAME/opentelemetry-python.git
+git remote add fork https://github.com/YOUR_GITHUB_USERNAME/opentelemetry-python.git
 ```
 
-Run tests:
+Make sure you have all supported versions of Python installed, install tox only for the first time:
 
 ```sh
-# make sure you have all supported versions of Python installed
-$ pip install tox  # only first time.
-$ tox  # execute in the root of the repository
+pip install tox
+```
+
+Run tests in the root of the repository (this will run all tox environments and may take some time):
+
+```sh
+tox
 ```
 
 Check out a new branch, make modifications and push the branch to your fork:
 
 ```sh
-$ git checkout -b feature
-# edit files
-$ git commit
-$ git push fork feature
+git checkout -b feature
+```
+
+After you edit the files, stage changes in the current directory:
+
+```sh
+git add .
+```
+
+Then run the following to commit the changes:
+
+```sh
+git commit
+git push fork feature
 ```
 
 Open a pull request against the main `opentelemetry-python` repo.

README.md

@@ -97,7 +97,7 @@ Meeting notes are available as a public [Google doc](https://docs.google.com/doc
 
 Approvers ([@open-telemetry/python-approvers](https://github.com/orgs/open-telemetry/teams/python-approvers)):
 
-- [Emídio Neto](https://github.com/emdneto), Zenvia
+- [Emídio Neto](https://github.com/emdneto), PicPay
 - [Jeremy Voss](https://github.com/jeremydvoss), Microsoft
 - [Owais Lone](https://github.com/owais), Splunk
 - [Pablo Collins](https://github.com/pmcollins), Splunk

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/benchmarks/test_baggage.py

@@ -0,0 +1,69 @@
+# pylint: disable=redefined-outer-name, invalid-name
+import pytest
+
+from opentelemetry import trace
+from opentelemetry.baggage import (
+    clear,
+    get_all,
+    get_baggage,
+    remove_baggage,
+    set_baggage,
+)
+
+tracer = trace.get_tracer(__name__)
+
+
+@pytest.fixture(params=[10, 100, 1000, 10000])
+def baggage_size(request):
+    return request.param
+
+
+def set_baggage_operation(size=10):
+    with tracer.start_span(name="root span"):
+        ctx = get_all()
+        for i in range(size):
+            ctx = set_baggage(f"foo{i}", f"bar{i}", context=ctx)
+    return ctx
+
+
+def test_set_baggage(benchmark, baggage_size):
+    ctx = benchmark(set_baggage_operation, baggage_size)
+    result = get_all(ctx)
+    assert len(result) == baggage_size
+
+
+def test_get_baggage(benchmark, baggage_size):
+    ctx = set_baggage_operation(baggage_size)
+
+    def get_baggage_operation():
+        return [get_baggage(f"foo{i}", ctx) for i in range(baggage_size)]
+
+    result = benchmark(get_baggage_operation)
+    assert result == [f"bar{i}" for i in range(baggage_size)]
+
+
+def test_remove_baggage(benchmark, baggage_size):
+    ctx = set_baggage_operation(baggage_size)
+
+    def remove_operation():
+        tmp_ctx = ctx
+        for i in range(baggage_size):
+            tmp_ctx = remove_baggage(f"foo{i}", tmp_ctx)
+        return tmp_ctx
+
+    cleared_context = benchmark(remove_operation)
+    result = get_all(cleared_context)
+    # After removing all baggage items, it should be empty.
+    assert len(result) == 0
+
+
+def test_clear_baggage(benchmark, baggage_size):
+    ctx = set_baggage_operation(baggage_size)
+
+    def clear_operation():
+        return clear(ctx)
+
+    cleared_context = benchmark(clear_operation)
+    result = get_all(cleared_context)
+    # After clearing the baggage should be empty.
+    assert len(result) == 0