fix(async-processor): concurrent exports actually serialised (#3028)

Co-authored-by: Cijo Thomas <cijo.thomas@gmail.com>

.cargo/config.toml

@@ -0,0 +1,3 @@
+[resolver]
+# https://doc.rust-lang.org/cargo/reference/config.html#resolverincompatible-rust-versions
+incompatible-rust-versions = "fallback"

.cspell.json

@@ -0,0 +1,148 @@
+// http://cspell.org/configuration/
+{
+    "version": "0.2",
+    "language": "en,en-US",
+    "useGitignore": true,
+    "minWordLength": 4,
+    "ignorePaths": [
+        "target/**"
+    ],
+    // list of words to be ignored.  unlike `words` below, these won't be
+    // suggested as corrections for misspelled words.
+    "ignoreWords": [
+        "otel",
+        "rustdoc",
+        "rustfilt",
+        "webkpi"
+    ],
+    // these are words that are always considered incorrect.
+    "flagWords": [
+        "recieve",
+        "reciever",
+        "seperate",
+        "hte",
+        "teh"
+    ],
+    // these are words that are always correct and can be thought of as our
+    // workspace dictionary.
+    "words": [
+        "actix",
+        "Antonsson",
+        "anyvalue",
+        "appender",
+        "appenders",
+        "autobenches",
+        "Bhasin",
+        "Björn",
+        "BLRP",
+        "chrono",
+        "Cijo",
+        "clippy",
+        "clonable",
+        "codecov",
+        "dashmap",
+        "datapoint",
+        "deque",
+        "Dirkjan",
+        "docsrs",
+        "Dwarnings",
+        "eprintln",
+        "EPYC",
+        "flamegraph",
+        "Gerring",
+        "grpcio",
+        "Grübel",
+        "hasher",
+        "impls",
+        "isahc",
+        "Isobel",
+        "jaegertracing",
+        "Kühle",
+        "Kumar",
+        "Lalit",
+        "LIBCLANG",
+        "logrecord",
+        "MILLIS",
+        "mpsc",
+        "msrv",
+        "mykey",
+        "myunit",
+        "myvalue",
+        "nocapture",
+        "Ochtman",
+        "opentelemetry",
+        "openzipkin",
+        "otcorrelations",
+        "OTELCOL",
+        "OTLP",
+        "periodicreader",
+        "Pillai",
+        "pprof",
+        "protos",
+        "prost",
+        "protoc",
+        "quantile",
+        "quantiles",
+        "Redelmeier",
+        "reqwest",
+        "rstest",
+        "runtimes",
+        "rustc",
+        "rustls",
+        "schemars",
+        "semconv",
+        "serde",
+        "shoppingcart",
+        "struct",
+        "Tescher",
+        "testcontainers",
+        "testresults",
+        "thiserror",
+        "traceparent",
+        "Traceparent",
+        "tracerprovider",
+        "tracestate",
+        "UCUM",
+        "Umesan",
+        "unsampled",
+        "updown",
+        "urlencoding",
+        "usize",
+        "Utkarsh",
+        "webpki",
+        "Zhongyang",
+        "zipkin"
+    ],
+    "enabledLanguageIds": [
+        "jsonc",
+        "markdown",
+        "plaintext",
+        "rust",
+        "shellscript"
+    ],
+    "languageSettings": [
+        {
+            "languageId": "jsonc",
+            "includeRegExpList": [
+                "CStyleComment"
+            ]
+        },
+        {
+            "languageId": "markdown",
+            "caseSensitive": false
+        },
+        {
+            "languageId": "rust",
+            "includeRegExpList": [
+                "CStyleComment",
+                "strings"
+            ]
+        },
+        {
+            "languageId": "shellscript",
+            "includeRegExpList": [
+                "/#.*/g"
+            ]
+        }
+    ]
+}

.github/CODEOWNERS

@@ -0,0 +1,7 @@
+# Code owners file
+
+## This file controls who is tagged for review for any given pull request.
+
+## For anything not explicitly taken by someone else
+
+* @open-telemetry/rust-approvers

.github/ISSUE_TEMPLATE/BUG-REPORT.yml

@@ -0,0 +1,52 @@
+name: Bug Report
+description: File a bug report
+title: "[Bug]: "
+labels: ["bug", "triage:todo"]
+projects: ["open-telemetry/opentelemetry-rust"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report!
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: What happened?
+      description: Also tell us, what did you expect to happen?
+      placeholder: Tell us what you see!
+      value: "A bug happened!"
+    validations:
+      required: true
+  - type: textarea
+    id: api-version
+    attributes:
+      label: OpenTelemetry API Version (i.e version of `opentelemetry` crate)
+      description: What version of the `opentelemetry` crate are you using?
+      placeholder: 0.x, 1.x, etc.
+    validations:
+      required: true
+  - type: textarea
+    id: sdk-version
+    attributes:
+      label: OpenTelemetry SDK Version (i.e version of `opentelemetry_sdk` crate)
+      description: What version of the `opentelemetry_sdk` crate are you using?
+      placeholder: 0.x, 1.x, etc.
+    validations:
+      required: true
+  - type: dropdown
+    id: browsers
+    attributes:
+      label: What Exporter(s) are you seeing the problem on?
+      multiple: true
+      options:
+        - stdout
+        - OTLP
+        - Zipkin
+        - Prometheus
+        - N/A
+  - type: textarea
+    id: logs
+    attributes:
+      label: Relevant log output
+      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
+      render: shell

.github/ISSUE_TEMPLATE/FEATURE-REQUEST.yml

@@ -0,0 +1,48 @@
+---
+name: "Feature Request"
+description: Request a feature for the OpenTelemetry Rust implementation.
+title: "[Feature]: "
+labels: ["enhancement", "triage:todo"]
+projects: ["open-telemetry/opentelemetry-rust"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for using our library and trying to make it better!
+
+        Before opening a feature request against this repo, consider whether the feature
+        should/could be implemented in the [other OpenTelemetry client
+        libraries](https://github.com/open-telemetry/). If so, please [open an issue on
+        opentelemetry-specification](https://github.com/open-telemetry/opentelemetry-specification/issues/new) first.
+  - type: textarea
+    id: related-problem
+    attributes:
+      label: Related Problems?
+      description: Is your feature request related to a problem? If so, provide a concise description of the problem.
+      placeholder: Include the Issue ID from this or other repos.
+    validations:
+      required: false
+  - type: textarea
+    id: solution
+    attributes:
+      label: "Describe the solution you'd like:"
+      description: What do you want to happen instead? What is the expected behavior?
+      placeholder: I'd like the api to ...
+    validations:
+      required: true
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: Considered Alternatives
+      description: Which alternative solutions or features have you considered?
+      placeholder: Some potential solutions
+    validations:
+      required: false
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional Context
+      description: Add any other context about the feature request here.
+      placeholder: Some related requests in other project or upstream spec proposals.
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,11 @@
+contact_links:
+  - name: GitHub Discussions
+    url: https://github.com/open-telemetry/opentelemetry-rust/discussions/new/choose
+    about: Please ask questions here.
+  - name: Slack
+    url: https://cloud-native.slack.com/archives/C03GDP0H023
+    about: Or the `#otel-rust` channel in the CNCF Slack instance.
+  - name: "⚠️ Report a security vulnerability"
+    url: "https://github.com/open-telemetry/opentelemetry-rust/security/advisories/new"
+    about: "Report a security vulnerability."
+

.github/codecov.yaml

@@ -13,18 +13,15 @@ coverage:
 
 ignore:
   - "opentelemetry/src/testing" # test harnesses
-  - "opentelemetry-jaeger/src/testing" # test harness
-  - "opentelemetry-jaeger/src/exporter/thrift" # auto generated files
   - "opentelemetry-otlp/src/proto" # auto generated files
   - "opentelemetry-proto/src/proto" # auto generated files
   # examples below
   - "examples"
-  - "opentelemetry-jaeger/examples"
   - "opentelemetry-zipkin/examples"
   - "opentelemetry-otlp/examples"
-  - "opentelemetry-aws/examples"
-  - "opentelemetry-datadog/examples"
-  - "opentelemetry-dynatrace/examples"
   - "opentelemetry-http/examples"
   - "opentelemetry-prometheus/examples"
-  - "opentelemetry-zpages/examples"
+  - "opentelemetry-appender-tracing/examples"
+  - "opentelemetry-appender-log/examples"
+  # stress test
+  - "stress"

.github/dependabot.yml

@@ -0,0 +1,15 @@
+version: 2
+updates:
+  - package-ecosystem: "cargo"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+    open-pull-requests-limit: 10
+  - package-ecosystem: "docker"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "monthly"

.github/workflows/benchmark.yml

@@ -0,0 +1,59 @@
+# This workflow runs a Criterion benchmark on a PR and compares the results against the base branch.
+# It is triggered on a PR or a push to main.
+#
+# The workflow is gated on the presence of the "performance" label on the PR.
+#
+# The workflow runs on a self-hosted runner pool. We can't use the shared runners for this,
+# because they are only permitted to run on the default branch to preserve resources. 
+#
+# In the future, we might like to consider using bencher.dev or the framework used by otel-golang here. 
+on: 
+  pull_request:
+  push:
+    branches:
+      - main
+name: benchmark pull requests
+permissions:
+  contents: read
+jobs:
+  runBenchmark:
+    name: run benchmark
+    permissions:
+      pull-requests: write
+
+    # If we're running on main, use our oracle bare-metal runner for accuracy. 
+    # If we're running on a PR, use github's shared workers to save resources.
+    runs-on: ${{ github.event_name == 'pull_request' && 'ubuntu-latest' || 'oracle-bare-metal-64cpu-512gb-x86-64' }}
+    if: ${{ (github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'performance')) || github.event_name == 'push' }}
+    container:
+      image: rust:slim-bullseye
+    env:
+      # For PRs, compare against the base branch - e.g., 'main'. 
+      # For pushes to main, compare against the previous commit
+      BRANCH_NAME: ${{ github.event_name == 'pull_request' && github.base_ref || github.event.before }}
+      GIT_DISCOVERY_ACROSS_FILESYSTEM: 1
+    steps:
+      - name: Harden the runner (Audit all outbound calls)
+        uses: step-security/harden-runner@6c439dc8bdf85cadbbce9ed30d1c7b959517bc49 # v2.12.2
+        with:
+          egress-policy: audit
+
+      - name: Setup container environment
+        run: |
+          apt-get update && apt-get install --fix-missing -y unzip cmake build-essential pkg-config curl git
+          cargo install cargo-criterion
+
+      - name: Make repo safe for Git inside container
+        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
+
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 10 # Fetch a bit of history so we can do perf diffs
+
+      - uses: arduino/setup-protoc@c65c819552d16ad3c9b72d9dfd5ba5237b9c906b # v3.0.0
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - uses: boa-dev/criterion-compare-action@adfd3a94634fe2041ce5613eb7df09d247555b87 # v3.2.4
+        with:
+          branchName: ${{ env.BRANCH_NAME }}

.github/workflows/ci.yml

@@ -1,103 +1,185 @@
 name: CI
 env:
   CI: true
+permissions:
+  contents: read
 on:
   pull_request:
   push:
     branches:
     - main
+    paths-ignore:
+    - '**.md'
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 jobs:
   test:
     strategy:
       matrix:
+        # test both stable and beta versions of Rust on ubuntu-latest
+        os: [ubuntu-latest]
         rust: [stable, beta]
-    runs-on: ubuntu-latest
+        # test only stable version of Rust on Windows and MacOS
+        include:
+          - rust: stable
+            os: windows-latest
+          - rust: stable
+            os: macos-latest
+          - rust: stable
+            os: ubuntu-22.04-arm
+    runs-on: ${{ matrix.os }}
+    continue-on-error: ${{ matrix.rust == 'beta' }}
     steps:
-    - uses: actions/checkout@v1
+    - name: Harden the runner (Audit all outbound calls)
+      uses: step-security/harden-runner@6c439dc8bdf85cadbbce9ed30d1c7b959517bc49 # v2.12.2
+      with:
+        egress-policy: audit
+
+    - name: Free disk space
+      if: ${{ matrix.os == 'ubuntu-latest'}}
+      run: |
+        df -h
+        sudo rm -rf /usr/local/lib/android
+        sudo rm -rf /usr/share/dotnet
+        df -h
+    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         submodules: true
-    - uses: actions-rs/toolchain@v1
+    - uses: dtolnay/rust-toolchain@b3b07ba8b418998c39fb20f53e8b695cdcc8de1b
       with:
         toolchain: ${{ matrix.rust }}
         components: rustfmt
-        profile: minimal
-    - uses: arduino/setup-protoc@v1
+    - name: "Set rustup profile"
+      run: rustup set profile minimal
+    - uses: arduino/setup-protoc@c65c819552d16ad3c9b72d9dfd5ba5237b9c906b # v3.0.0
+      with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
     - name: Test
-      run: ./scripts/test.sh
+      run: bash ./scripts/test.sh
   lint:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v1
+    - name: Harden the runner (Audit all outbound calls)
+      uses: step-security/harden-runner@6c439dc8bdf85cadbbce9ed30d1c7b959517bc49 # v2.12.2
+      with:
+        egress-policy: audit
+
+    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       with:
         submodules: true
-    - uses: actions-rs/toolchain@v1
+    - uses: dtolnay/rust-toolchain@b3b07ba8b418998c39fb20f53e8b695cdcc8de1b
       with:
         toolchain: stable
-        components: rustfmt
-        profile: minimal
-    - uses: arduino/setup-protoc@v1
-    - uses: actions-rs/cargo@v1
+        components: rustfmt, clippy
+    - uses: taiki-e/install-action@0eee80d37f55e834144deec670972c19e81a85b0 # v2.56.0
       with:
-        command: fmt
-        args: --all -- --check
+          tool: cargo-hack
+    - uses: arduino/setup-protoc@c65c819552d16ad3c9b72d9dfd5ba5237b9c906b # v3.0.0
+      with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+    - name: Format
+      run: cargo fmt --all -- --check
     - name: Lint
-      run: ./scripts/lint.sh
-  non-default-examples:
+      run: bash ./scripts/lint.sh
+  external-types:
     strategy:
       matrix:
-        example: [opentelemetry-otlp/examples/external-otlp-grpcio-async-std]
-    runs-on: ubuntu-latest
+        member: [opentelemetry, opentelemetry-sdk, opentelemetry-otlp, opentelemetry-zipkin]
+    runs-on: ubuntu-latest # TODO: Check if this could be covered for Windows. The step used currently fails on Windows.
     steps:
-    - uses: actions/checkout@v1
-      with:
-        submodules: true
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: stable
-        components: rustfmt
-        profile: minimal
-    - uses: arduino/setup-protoc@v1
-    - name: Build
-      run: |
-        cd ${{ matrix.example }}
-        cargo build --verbose
+      - name: Harden the runner (Audit all outbound calls)
+        uses: step-security/harden-runner@6c439dc8bdf85cadbbce9ed30d1c7b959517bc49 # v2.12.2
+        with:
+          egress-policy: audit
+
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: dtolnay/rust-toolchain@b3b07ba8b418998c39fb20f53e8b695cdcc8de1b
+        with:
+          # Rust version should be kept in sync with the one the release was tested with
+          # https://github.com/awslabs/cargo-check-external-types/releases
+          toolchain: nightly-2025-05-04
+          components: rustfmt
+      - uses: taiki-e/install-action@0eee80d37f55e834144deec670972c19e81a85b0 # v2.56.0
+        with:
+          tool: cargo-check-external-types@0.2.0
+      - name: external-type-check
+        working-directory: ${{ matrix.member }}
+        run: cargo check-external-types --all-features --config allowed-external-types.toml
   msrv:
-    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        os: [windows-latest, ubuntu-latest]
+    runs-on: ${{ matrix.os }}
+    continue-on-error: true
     steps:
-    - uses: actions/checkout@v1
-      with:
-        submodules: true
-    - uses: actions-rs/toolchain@v1
-      with:
-        profile: minimal
-        toolchain: 1.60.0
-        override: true
-    - name: Patch dependencies versions # some dependencies bump MSRV without major version bump
-      run: ./scripts/patch_dependencies.sh
-    - name: Run tests
-      run: cargo --version &&
-        cargo test --manifest-path=opentelemetry/Cargo.toml --features trace,metrics,rt-tokio,testing &&
-        cargo test --manifest-path=opentelemetry-jaeger/Cargo.toml --features rt-tokio &&
-        cargo test --manifest-path=opentelemetry-zipkin/Cargo.toml
+      - name: Harden the runner (Audit all outbound calls)
+        uses: step-security/harden-runner@6c439dc8bdf85cadbbce9ed30d1c7b959517bc49 # v2.12.2
+        with:
+          egress-policy: audit
+
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          submodules: true
+      - uses: dtolnay/rust-toolchain@b3b07ba8b418998c39fb20f53e8b695cdcc8de1b
+        with:
+          toolchain: stable
+      - uses: taiki-e/install-action@0eee80d37f55e834144deec670972c19e81a85b0 # v2.56.0
+        with:
+          tool: cargo-msrv
+      - uses: arduino/setup-protoc@c65c819552d16ad3c9b72d9dfd5ba5237b9c906b # v3.0.0
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Check MSRV for all crates
+        run: bash ./scripts/msrv.sh
   cargo-deny:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-latest # This uses the step `EmbarkStudios/cargo-deny-action@v1` which is only supported on Linux
     continue-on-error: true # Prevent sudden announcement of a new advisory from failing ci
     steps:
-      - uses: actions/checkout@v2
-      - uses: EmbarkStudios/cargo-deny-action@v1
+      - name: Harden the runner (Audit all outbound calls)
+        uses: step-security/harden-runner@6c439dc8bdf85cadbbce9ed30d1c7b959517bc49 # v2.12.2
+        with:
+          egress-policy: audit
+
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+
+      - name: Check advisories
+        uses: EmbarkStudios/cargo-deny-action@30f817c6f72275c6d54dc744fbca09ebc958599f # v2.0.12
         with:
           command: check advisories
+
+      - name: Check licenses
+        uses: EmbarkStudios/cargo-deny-action@30f817c6f72275c6d54dc744fbca09ebc958599f # v2.0.12
+        with:
+          command: check licenses
+
+      - name: Check bans
+        uses: EmbarkStudios/cargo-deny-action@30f817c6f72275c6d54dc744fbca09ebc958599f # v2.0.12
+        with:
+          command: check bans
+      
+      - name: Check sources
+        uses: EmbarkStudios/cargo-deny-action@30f817c6f72275c6d54dc744fbca09ebc958599f # v2.0.12
+        with:
+          command: check sources
+
   docs:
     continue-on-error: true
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
+      - name: Harden the runner (Audit all outbound calls)
+        uses: step-security/harden-runner@6c439dc8bdf85cadbbce9ed30d1c7b959517bc49 # v2.12.2
         with:
-          toolchain: nightly
+          egress-policy: audit
+
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: dtolnay/rust-toolchain@b3b07ba8b418998c39fb20f53e8b695cdcc8de1b
+        with:
+          toolchain: stable
           components: rustfmt
-          override: true
-      - uses: arduino/setup-protoc@v1
+      - uses: arduino/setup-protoc@c65c819552d16ad3c9b72d9dfd5ba5237b9c906b # v3.0.0
+        with:
+            repo-token: ${{ secrets.GITHUB_TOKEN }}
       - name: doc
         run: cargo doc --no-deps --all-features
         env:
@@ -106,24 +188,74 @@ jobs:
   coverage:
     continue-on-error: true
     runs-on: ubuntu-latest
+    if: ${{ ! contains(github.event.pull_request.labels.*.name, 'dependencies') }}
     steps:
-      - uses: actions/checkout@v3
+      - name: Harden the runner (Audit all outbound calls)
+        uses: step-security/harden-runner@6c439dc8bdf85cadbbce9ed30d1c7b959517bc49 # v2.12.2
+        with:
+          egress-policy: audit
+
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           submodules: true
-      - uses: actions-rs/toolchain@v1
+      - uses: dtolnay/rust-toolchain@b3b07ba8b418998c39fb20f53e8b695cdcc8de1b
         with:
           toolchain: stable
           components: rustfmt,llvm-tools-preview
-          override: true
-      - uses: arduino/setup-protoc@v1
-      - name: cargo install cargo-llvm-cov
-        uses: taiki-e/install-action@cargo-llvm-cov
+      - uses: arduino/setup-protoc@c65c819552d16ad3c9b72d9dfd5ba5237b9c906b # v3.0.0
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Install cargo-llvm-cov
+        uses: taiki-e/install-action@0eee80d37f55e834144deec670972c19e81a85b0 # v2.56.0
+        with:
+          tool: cargo-llvm-cov
       - name: cargo generate-lockfile
         if: hashFiles('Cargo.lock') == ''
         run: cargo generate-lockfile
       - name: cargo llvm-cov
-        run: cargo llvm-cov --locked --all-features --workspace --lcov --output-path lcov.info
+        run: cargo llvm-cov --locked --all-features --workspace --lcov --lib --output-path lcov.info
       - name: Upload to codecov.io
-        uses: codecov/codecov-action@v3
+        uses: codecov/codecov-action@18283e04ce6e62d37312384ff67231eb8fd56d24 # v5.4.3
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
         with:
           fail_ci_if_error: true
+  build-examples:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: dtolnay/rust-toolchain@b3b07ba8b418998c39fb20f53e8b695cdcc8de1b # stable
+        with:
+          toolchain: stable
+          components: rustfmt
+      - uses: arduino/setup-protoc@c65c819552d16ad3c9b72d9dfd5ba5237b9c906b # v3.0.0
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Build examples
+        run: |
+          for example in examples/*; do
+            if [ -d "$example" ]; then
+              echo "Building $example"
+              cargo build
+            fi
+          done
+  cargo-machete:
+    continue-on-error: true
+    runs-on: ubuntu-latest
+    steps:
+      - name: Harden the runner (Audit all outbound calls)
+        uses: step-security/harden-runner@6c439dc8bdf85cadbbce9ed30d1c7b959517bc49 # v2.12.2
+        with:
+          egress-policy: audit
+
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          submodules: true
+      - uses: dtolnay/rust-toolchain@b3b07ba8b418998c39fb20f53e8b695cdcc8de1b
+        with:
+          toolchain: stable
+      - uses: taiki-e/install-action@0eee80d37f55e834144deec670972c19e81a85b0 # v2.56.0
+        with:
+          tool: cargo-machete
+      - name: cargo machete
+        run: cargo machete

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,45 @@
+name: "CodeQL Analysis"
+
+env:    
+    CODEQL_ENABLE_EXPERIMENTAL_FEATURES : true # CodeQL support for Rust is experimental
+
+permissions:
+  contents: read
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write # for github/codeql-action/autobuild to send a status report
+
+    strategy:
+      fail-fast: false
+
+    steps:
+    - name: Harden the runner (Audit all outbound calls)
+      uses: step-security/harden-runner@6c439dc8bdf85cadbbce9ed30d1c7b959517bc49 # v2.12.2
+      with:
+        egress-policy: audit
+
+    - name: Checkout repository
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      with:
+        submodules: true
+
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@181d5eefc20863364f96762470ba6f862bdef56b # v3.29.2
+      with:
+        languages: rust
+
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@181d5eefc20863364f96762470ba6f862bdef56b # v3.29.2
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@181d5eefc20863364f96762470ba6f862bdef56b # v3.29.2

.github/workflows/fossa.yml

@@ -0,0 +1,25 @@
+name: FOSSA scanning
+
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+
+jobs:
+  fossa:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Harden the runner (Audit all outbound calls)
+        uses: step-security/harden-runner@6c439dc8bdf85cadbbce9ed30d1c7b959517bc49 # v2.12.2
+        with:
+          egress-policy: audit
+
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+
+      - uses: fossas/fossa-action@3ebcea1862c6ffbd5cf1b4d0bd6b3fe7bd6f2cac # v1.7.0
+        with:
+          api-key: ${{secrets.FOSSA_API_KEY}}
+          team: OpenTelemetry

.github/workflows/integration_tests.yml

@@ -5,13 +5,34 @@ on:
   pull_request:
     types: [ labeled, synchronize, opened, reopened ]
 
+permissions:
+  contents: read
+
 jobs:
   integration_tests:
     runs-on: ubuntu-latest
     timeout-minutes: 10
-    if: ${{ github.event.label.name == 'integration tests' || contains(github.event.pull_request.labels.*.name, 'integration tests') }}
     steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Run integration tests using docker compose
+      - name: Harden the runner (Audit all outbound calls)
+        uses: step-security/harden-runner@6c439dc8bdf85cadbbce9ed30d1c7b959517bc49 # v2.12.2
+        with:
+          egress-policy: audit
+
+      - name: Free disk space
+        run: |
+          df -h
+          sudo rm -rf /usr/local/lib/android
+          sudo rm -rf /usr/share/dotnet
+          df -h
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          submodules: true
+      - uses: dtolnay/rust-toolchain@b3b07ba8b418998c39fb20f53e8b695cdcc8de1b
+        with:
+          toolchain: stable
+          components: rustfmt
+      - uses: arduino/setup-protoc@c65c819552d16ad3c9b72d9dfd5ba5237b9c906b # v3.0.0
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Run integration tests
         run: ./scripts/integration_tests.sh

.github/workflows/markdown-link-check.yml

@@ -0,0 +1,33 @@
+name: Markdown link check
+
+on:
+  pull_request:
+  push:
+    branches:
+    - main
+    paths:
+      - '**/*.md'
+
+permissions:
+  contents: read
+
+jobs:
+  markdown-link-check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Harden the runner (Audit all outbound calls)
+        uses: step-security/harden-runner@6c439dc8bdf85cadbbce9ed30d1c7b959517bc49 # v2.12.2
+        with:
+          egress-policy: audit
+
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+
+      - name: Install markdown-link-check
+        run: npm install -g "git://github.com/tcort/markdown-link-check.git#ef7e09486e579ba7479700b386e7ca90f34cbd0a" # v3.13.7
+
+      - name: Run markdown-link-check
+        run: |
+          find . -type f \
+                 -name '*.md' \
+                 -not -path '**/CHANGELOG.md' \
+               | xargs ./scripts/markdown-link-check-with-retry.sh

.github/workflows/ossf-scorecard.yml

@@ -0,0 +1,53 @@
+name: OSSF Scorecard
+
+on:
+  push:
+    branches:
+      - main
+  schedule:
+    - cron: "50 3 * * 0" # once a week
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  analysis:
+    runs-on: ubuntu-latest
+    permissions:
+      # Needed for Code scanning upload
+      security-events: write
+      # Needed for GitHub OIDC token if publish_results is true
+      id-token: write
+    steps:
+      - name: Harden the runner (Audit all outbound calls)
+        uses: step-security/harden-runner@6c439dc8bdf85cadbbce9ed30d1c7b959517bc49 # v2.12.2
+        with:
+          egress-policy: audit
+
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          persist-credentials: false
+
+      - uses: ossf/scorecard-action@05b42c624433fc40578a4040d5cf5e36ddca8cde # v2.4.2
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          publish_results: true
+
+      # Upload the results as artifacts (optional). Commenting out will disable
+      # uploads of run results in SARIF format to the repository Actions tab.
+      # https://docs.github.com/en/actions/advanced-guides/storing-workflow-data-as-artifacts
+      - name: "Upload artifact"
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: SARIF file
+          path: results.sarif
+          retention-days: 5
+
+      # Upload the results to GitHub's code scanning dashboard (optional).
+      # Commenting out will disable upload of results to your repo's Code Scanning dashboard
+      - name: "Upload to code-scanning"
+        uses: github/codeql-action/upload-sarif@181d5eefc20863364f96762470ba6f862bdef56b # v3.29.2
+        with:
+          sarif_file: results.sarif

.github/workflows/pr_naming.yml

@@ -0,0 +1,23 @@
+name: PR Conventional Commit Validation
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, edited]
+
+permissions:
+  contents: read
+
+jobs:
+  validate-pr-title:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Harden the runner (Audit all outbound calls)
+        uses: step-security/harden-runner@6c439dc8bdf85cadbbce9ed30d1c7b959517bc49 # v2.12.2
+        with:
+          egress-policy: audit
+
+      - name: PR Conventional Commit Validation
+        uses:  ytanikin/pr-conventional-commits@8267db1bacc237419f9ed0228bb9d94e94271a1d # 1.4.1
+        with:
+          task_types: '["build","chore","ci","docs","feat","fix","perf","refactor","revert","test"]'
+          add_label: 'false'

.github/workflows/semver.yml

@@ -0,0 +1,29 @@
+name: Semver compliance
+env:
+  CI: true
+permissions:
+  contents: read
+on:
+  pull_request:
+    types: [ labeled, synchronize, opened, reopened ]
+jobs:
+  semver-compliance: # This job uses the latest published crate as baseline for comparison.
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    if: ${{ github.event.label.name == 'semver-check' || contains(github.event.pull_request.labels.*.name, 'semver-check') }}
+    steps:
+      - name: Harden the runner (Audit all outbound calls)
+        uses: step-security/harden-runner@6c439dc8bdf85cadbbce9ed30d1c7b959517bc49 # v2.12.2
+        with:
+          egress-policy: audit
+
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          submodules: true
+      - name: Install stable
+        uses: dtolnay/rust-toolchain@b3b07ba8b418998c39fb20f53e8b695cdcc8de1b
+        with:
+          toolchain: stable
+          components: rustfmt
+      - name: cargo-semver-checks
+        uses: obi1kenobi/cargo-semver-checks-action@5b298c9520f7096a4683c0bd981a7ac5a7e249ae # v2.8

.gitignore

@@ -1,4 +1,10 @@
+/.vscode/
 /target/
 */target/
 **/*.rs.bk
 Cargo.lock
+/.idea/
+
+.cosine
+
+opentelemetry-otlp/tests/integration_test/result.json

.gitmodules

@@ -1,4 +1,4 @@
 [submodule "opentelemetry-proto/src/proto/opentelemetry-proto"]
 	path = opentelemetry-proto/src/proto/opentelemetry-proto
 	url = https://github.com/open-telemetry/opentelemetry-proto
-	branch = tags/v1.0.0
+	branch = tags/v1.5.0

CODEOWNERS

@@ -1,5 +0,0 @@
-# Code owners file.
-# This file controls who is tagged for review for any given pull request.
-
-# For anything not explicitly taken by someone else:
-*  @open-telemetry/rust-approvers

CONTRIBUTING.md

@@ -1,27 +1,47 @@
 # Contributing to opentelemetry-rust
 
-The Rust special interest group (SIG) meets regularly. See the
-OpenTelemetry
-[community](https://github.com/open-telemetry/community#implementation-sigs)
-repo for information on this and other language SIGs.
+The Rust special interest group (SIG) meets weekly on Tuesdays at 9 AM Pacific
+Time. The meeting is subject to change depending on contributors'
+availability. Check the [OpenTelemetry community
+calendar](https://github.com/open-telemetry/community?tab=readme-ov-file#calendar)
+for specific dates and for Zoom meeting links. "OTel Rust SIG" is the name of
+meeting for this group.
 
-See the [public meeting
-notes](https://docs.google.com/document/d/1tGKuCsSnyT2McDncVJrMgg74_z8V06riWZa0Sr79I_4/edit)
-for a summary description of past meetings. To request edit access,
-join the meeting or get in touch on
+Meeting notes are available as a public [Google
+doc](https://docs.google.com/document/d/12upOzNk8c3SFTjsL6IRohCWMgzLKoknSCOOdMakbWo4/edit).
+If you have trouble accessing the doc, please get in touch on
 [Slack](https://cloud-native.slack.com/archives/C03GDP0H023).
 
+The meeting is open for all to join. We invite everyone to join our meeting,
+regardless of your experience level. Whether you're a seasoned OpenTelemetry
+developer, just starting your journey, or simply curious about the work we do,
+you're more than welcome to participate!
+
+Even though, anybody can contribute, there are benefits of being a member of our
+community. See to the [community membership
+document](https://github.com/open-telemetry/community/blob/main/guides/contributor/membership.md)
+on how to become a
+[**Member**](https://github.com/open-telemetry/community/blob/main/guides/contributor/membership.md#member),
+[**Approver**](https://github.com/open-telemetry/community/blob/main/guides/contributor/membership.md#approver)
+and
+[**Maintainer**](https://github.com/open-telemetry/community/blob/main/guides/contributor/membership.md#maintainer).
+
 ## Pull Requests
 
 ### Prerequisites
 
-Crate `opentelemetry-otlp` uses gRPC + Protocol Buffers.<br>
+Crate `opentelemetry-otlp` uses gRPC + Protocol Buffers.
 You can provide the protocol compiler protoc path programmatically (only works with tonic) or build it from source
 
 ```sh
 export PROTOC=$(which protoc)
 ```
 
+It is recommended to use "3.15" or newer of protoc, as some of the proto
+definitions include "optional" fields, that are not supported in older versions,
+resulting in errors as shown
+[here](https://github.com/open-telemetry/opentelemetry-proto/issues/451).
+
 Prerequisites to build the protocol compiler protoc from source
 
 - [protoc](https://github.com/protocolbuffers/protobuf)
@@ -34,13 +54,13 @@ Everyone is welcome to contribute code to `opentelemetry-rust` via
 GitHub pull requests (PRs).
 
 ```sh
-$ git clone --recurse-submodule https://github.com/open-telemetry/opentelemetry-rust
+git clone --recurse-submodule https://github.com/open-telemetry/opentelemetry-rust
 ```
 
 Enter the newly created directory and add your fork as a new remote:
 
 ```sh
-$ git remote add <YOUR_FORK> git@github.com:<YOUR_GITHUB_USERNAME>/opentelemetry-rust
+git remote add <YOUR_FORK> git@github.com:<YOUR_GITHUB_USERNAME>/opentelemetry-rust
 ```
 
 Check out a new branch, make modifications, run linters and tests, and
@@ -58,26 +78,42 @@ Open a pull request against the main
 [opentelemetry-rust](https://github.com/open-telemetry/opentelemetry-rust)
 repo.
 
+Your pull request should be named according to the
+[conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) standard. This ensures that
+when the PR is squashed into `main`, the resulting commit message is consistent and makes it easier
+for us to generate a changelog  standard. 
+
 > **Note**
-> It is recommended to run [pre-commit script](precommit.sh) from the root of
-the repo to catch any issues locally.
+> It is recommended to run [pre-commit script](scripts/precommit.sh) to catch any issues locally.
 
 ### How to Receive Comments
 
-* If the PR is not ready for review, please put `[WIP]` in the title,
-  tag it as `work-in-progress`, or mark it as
-  [`draft`](https://github.blog/2019-02-14-introducing-draft-pull-requests/).
-* Make sure CLA is signed and CI is clear.
+- If the PR is not ready for review, please put `[WIP]` in the title or mark it
+  as [`draft`](https://github.blog/2019-02-14-introducing-draft-pull-requests/).
+- Make sure CLA is signed and all required CI checks are clear.
+- Submit small, focused PRs addressing a single concern/issue.
+- Make sure the PR title reflects the contribution.
+- Write a summary that helps understand the change.
+- Include usage examples in the summary, where applicable.
+- Include benchmarks (before/after) in the summary, for contributions that are
+  performance enhancements.
 
 ### How to Get PRs Merged
 
 A PR is considered to be **ready to merge** when:
 
-* It has received approval from Collaborators/Maintainers.
-* Major feedback is resolved.
+- It has received approval from
+  [Approvers](https://github.com/open-telemetry/community/blob/main/guides/contributor/membership.md#approver).
+  /
+  [Maintainers](https://github.com/open-telemetry/community/blob/main/guides/contributor/membership.md#maintainer).
+- Major feedbacks are resolved.
 
-Any Collaborator/Maintainer can merge the PR once it is **ready to
-merge**.
+Any Maintainer can merge the PR once it is **ready to merge**. Note, that some
+PRs may not be merged immediately if the repo is in the process of a release and
+the maintainers decided to defer the PR to the next release train. Also,
+maintainers may decide to wait for more than one approval for certain PRs,
+particularly ones that are affecting multiple areas, or topics that may warrant
+more discussion.
 
 ## Design Choices
 
@@ -102,57 +138,67 @@ language rather than conform to specific API names or argument
 patterns in the spec.
 
 For a deeper discussion, see:
-https://github.com/open-telemetry/opentelemetry-specification/issues/165
+<https://github.com/open-telemetry/opentelemetry-specification/issues/165>
 
 ### Error Handling
-Currently, the Opentelemetry Rust SDK has two ways to handle errors. In the situation where errors are not allowed to return. One should call global error handler to process the errors. Otherwise, one should return the errors. 
 
-The Opentelemetry Rust SDK comes with an error type `openetelemetry::Error`. For different function, one error has been defined. All error returned by trace module MUST be wrapped in `opentelemetry::trace::TraceError`. All errors returned by metrics module MUST be wrapped in `opentelemetry::metrics::MetricsError`. 
+Currently, the Opentelemetry Rust SDK has two ways to handle errors. In the situation where errors are not allowed to return. One should call global error handler to process the errors. Otherwise, one should return the errors.
 
-For users that want to implement their own exporters. It's RECOMMENDED to wrap all errors from the exporter into a crate-level error type, and implement `ExporterError` trait.  
+The Opentelemetry Rust SDK comes with an error type `opentelemetry::Error`. For different function, one error has been defined. All error returned by trace module MUST be wrapped in `opentelemetry::trace::TraceError`. All errors returned by metrics module MUST be wrapped in `opentelemetry::metrics::MetricError`. All errors returned by logs module MUST be wrapped in `opentelemetry::logs::LogsError`.
+
+For users that want to implement their own exporters. It's RECOMMENDED to wrap all errors from the exporter into a crate-level error type, and implement `ExporterError` trait.
+
+### Priority of configurations
+
+OpenTelemetry supports multiple ways to configure the API, SDK and other components. The priority of configurations is as follows:
+
+- Environment variables
+- Compiling time configurations provided in the source code
+
+### Experimental/Unstable features
+
+Use `otel_unstable` feature flag for implementation of specification with [experimental](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.27.0/specification/document-status.md) status. This approach ensures clear demarcation and safe integration of new or evolving features. Utilize the following structure:
+
+```rust
+#[cfg(feature = "otel_unstable")]
+{
+    // Your feature implementation
+}
+```
+
+It's important to regularly review and remove the `otel_unstable` flag from the code once the feature becomes stable. This cleanup process is crucial to maintain the overall code quality and to ensure that stable features are accurately reflected in the main build.
+
+### Optional features
+
+The potential features include:
+
+- Stable and non-experimental features that are compliant with the specification and have a feature flag to minimize compilation size. Example: feature flags for signals (like `logs`, `traces`, `metrics`) and runtimes (`rt-tokio`, `rt-tokio-current-thread`).
+- Stable and non-experimental features, although not part of the specification, are crucial for enhancing the tracing/log crate's functionality or boosting performance. These features are also subject to discussion and approval by the OpenTelemetry Rust Maintainers.
+
+All such features should adhere to naming convention  `<signal>_<feature_name>`
 
 ## Style Guide
 
-* Run `cargo clippy --all` - this will catch common mistakes and improve
+- Run `cargo clippy --all` - this will catch common mistakes and improve
 your Rust code
-* Run `cargo fmt` - this will find and fix code formatting
+- Run `cargo fmt` - this will find and fix code formatting
 issues.
 
 ## Testing and Benchmarking
 
-* Run `cargo test --all` - this will execute code and doc tests for all
+- Run `cargo test --all` - this will execute code and doc tests for all
 projects in this workspace.
-* Run `cargo bench` - this will run benchmarks to show performance 
+- Run `cargo bench` - this will run benchmarks to show performance
+- Run `cargo bench` - this will run benchmarks to show performance
 regressions
 
-## Approvers and Maintainers
-
-For GitHub groups see the [code owners](CODEOWNERS) file.
-
-### Maintainers
-
-* [Dirkjan Ochtman](https://github.com/djc)
-* [Julian Tescher](https://github.com/jtescher)
-* [Zhongyang Wu](https://github.com/TommyCpp)
-
-### Approvers
-
-* [Harold Dost](https://github.com/hdost)
-
-### Emeritus
-
-* [Jan Kühle](https://github.com/frigus02)
-* [Isobel Redelmeier](https://github.com/iredelmeier)
-
-### Become an Approver or a Maintainer
-
-See the [community membership document in OpenTelemetry community
-repo](https://github.com/open-telemetry/community/blob/master/community-membership.md).
-
-### Thanks to all the people who have contributed
-
-[![contributors](https://contributors-img.web.app/image?repo=open-telemetry/opentelemetry-rust)](https://github.com/open-telemetry/opentelemetry-rust/graphs/contributors)
-
 ## FAQ
+
 ### Where should I put third party propagators/exporters, contrib or standalone crates?
-As of now, the specification classify the propagators into three categories: Fully opened standards, platform-specific standards, proprietary headers. The conclusion is only the fully opened standards should live in SDK packages/repos. So here, only fully opened standards should live as independent crate. For more detail and discussion, see [this pr](https://github.com/open-telemetry/opentelemetry-specification/pull/1144).  
+
+As of now, the specification classify the propagators into three categories:
+Fully opened standards, platform-specific standards, proprietary headers. The
+conclusion is only the fully opened standards should live in SDK packages/repos.
+So here, only fully opened standards should live as independent crate. For more
+detail and discussion, see [this
+pr](https://github.com/open-telemetry/opentelemetry-specification/pull/1144).

Cargo.toml

@@ -1,41 +1,94 @@
 [workspace]
 members = [
     "opentelemetry",
-    "opentelemetry-api",
-    "opentelemetry-aws",
-    "opentelemetry-contrib",
-    "opentelemetry-datadog",
-    "opentelemetry-dynatrace",
-    "opentelemetry-http",
-    "opentelemetry-jaeger",
-    "opentelemetry-jaeger/examples/actix-udp",
-    "opentelemetry-jaeger/examples/remote-sampler",
-    "opentelemetry-appender-log",
-    "opentelemetry-appender-tracing",
-    "opentelemetry-otlp",
-    "opentelemetry-prometheus",
-    "opentelemetry-proto",
-    "opentelemetry-sdk",
-    "opentelemetry-semantic-conventions",
-    "opentelemetry-stackdriver",
-    "opentelemetry-stdout",
-    "opentelemetry-user-events-logs",
-    "opentelemetry-user-events-metrics",
-    "opentelemetry-zipkin",
-    "opentelemetry-zpages",
-    "opentelemetry-otlp/examples/basic-otlp",
-    "opentelemetry-otlp/examples/basic-otlp-http",
-    "opentelemetry-otlp/examples/external-otlp-grpcio-async-std",
-    "examples/metrics-basic",
-    "examples/metrics-advanced",
-    "examples/logs-basic",
-    "examples/traceresponse",
-    "examples/tracing-grpc",
+    "opentelemetry-*",
+    "opentelemetry-*/examples/*",
+    "opentelemetry-otlp/tests/*",
+    "examples/*",
     "stress",
 ]
+resolver = "2"
+# Avoid applying patch to force use of workspace members for this
+# not actively maintained crate
+exclude = ["opentelemetry-prometheus"]
 
 [profile.bench]
 # https://doc.rust-lang.org/cargo/reference/profiles.html#bench
 # See function names in profiling reports.
 # 2/true is too much, 0 is not enough, 1 is just right for back traces
 debug = 1
+
+[workspace.dependencies]
+async-trait = "0.1"
+bytes = "1"
+criterion = "0.5"
+futures-core = "0.3"
+futures-executor = "0.3"
+futures-util = { version = "0.3", default-features = false }
+http = { version = "1.1", default-features = false, features = ["std"] }
+http-body-util = "0.1"
+hyper = { version = "1.3", default-features = false }
+hyper-util = "0.1"
+log = "0.4.21"
+once_cell = "1.13"
+pin-project-lite = "0.2"
+prost = "0.13"
+prost-build = "0.13"
+prost-types = "0.13"
+rand = { version = "0.9", default-features = false }
+reqwest = { version = "0.12", default-features = false }
+serde = { version = "1.0", default-features = false }
+serde_json = "1.0"
+temp-env = "0.3.6"
+thiserror = { version = "2", default-features = false }
+tonic = { version = "0.13", default-features = false }
+tonic-build = "0.13"
+tokio = { version = "1", default-features = false }
+tokio-stream = "0.1"
+# Using `tracing 0.1.40` because 0.1.39 (which is yanked) introduces the ability to set event names in macros,
+# required for OpenTelemetry's internal logging macros.
+tracing = { version = ">=0.1.40", default-features = false }
+# `tracing-core >=0.1.33` is required for compatibility with `tracing >=0.1.40`.
+tracing-core = { version = ">=0.1.33", default-features = false }
+tracing-subscriber = { version = "0.3", default-features = false }
+url = { version = "2.5", default-features = false }
+anyhow = "1.0.94"
+base64 = "0.22.1"
+chrono = { version = "0.4.34", default-features = false }
+ctor = "0.2.9"
+ctrlc = "3.2.5"
+futures-channel = "0.3"
+futures-sink = "0.3"
+const-hex = "1.14.1"
+lazy_static = "1.4.0"
+num-format = "0.4.4"
+num_cpus = "1.15.0"
+opentelemetry-appender-tracing = { path = "opentelemetry-appender-tracing", default-features = false }
+opentelemetry-otlp = { path = "opentelemetry-otlp" }
+opentelemetry-stdout = { path = "opentelemetry-stdout" }
+percent-encoding = "2.0"
+rstest = "0.23.0"
+schemars = "0.8"
+sysinfo = "0.32"
+tempfile = "3.3.0"
+testcontainers = "0.23.1"
+tracing-log = "0.2"
+tracing-opentelemetry = "0.31"
+typed-builder = "0.20"
+uuid = "1.3"
+
+# Aviod use of crates.io version of these crates through the tracing-opentelemetry dependencies
+[patch.crates-io]
+opentelemetry = { path = "opentelemetry" }
+opentelemetry_sdk = { path = "opentelemetry-sdk" }
+opentelemetry-stdout = { path = "opentelemetry-stdout" }
+
+[workspace.lints.rust]
+rust_2024_compatibility = { level = "warn", priority = -1 }
+# No need to enable those, because it either not needed or results in ugly syntax
+edition_2024_expr_fragment_specifier = "allow"
+if_let_rescope = "allow"
+tail_expr_drop_order = "allow"
+
+[workspace.lints.clippy]
+all = { level = "warn", priority = 1 }

LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright The OpenTelemetry Authors
+   Copyright [yyyy] [name of copyright owner]
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

README.md

@@ -1,22 +1,15 @@
-![OpenTelemetry — An observability framework for cloud-native software.][splash]
-
-[splash]: https://raw.githubusercontent.com/open-telemetry/opentelemetry-rust/main/assets/logo-text.png
-
 # OpenTelemetry Rust
 
 The Rust [OpenTelemetry](https://opentelemetry.io/) implementation.
 
 [![Crates.io: opentelemetry](https://img.shields.io/crates/v/opentelemetry.svg)](https://crates.io/crates/opentelemetry)
-[![Documentation](https://docs.rs/opentelemetry/badge.svg)](https://docs.rs/opentelemetry)
 [![LICENSE](https://img.shields.io/crates/l/opentelemetry)](./LICENSE)
 [![GitHub Actions CI](https://github.com/open-telemetry/opentelemetry-rust/workflows/CI/badge.svg)](https://github.com/open-telemetry/opentelemetry-rust/actions?query=workflow%3ACI+branch%3Amain)
+[![Documentation](https://docs.rs/opentelemetry/badge.svg)](https://docs.rs/opentelemetry)
 [![codecov](https://codecov.io/gh/open-telemetry/opentelemetry-rust/branch/main/graph/badge.svg)](https://codecov.io/gh/open-telemetry/opentelemetry-rust)
+[![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/open-telemetry/opentelemetry-rust/badge)](https://scorecard.dev/viewer/?uri=github.com/open-telemetry/opentelemetry-rust)
 [![Slack](https://img.shields.io/badge/slack-@cncf/otel/rust-brightgreen.svg?logo=slack)](https://cloud-native.slack.com/archives/C03GDP0H023)
 
-[Website](https://opentelemetry.io/) |
-[Slack](https://cloud-native.slack.com/archives/C03GDP0H023) |
-[Documentation](https://docs.rs/opentelemetry)
-
 ## Overview
 
 OpenTelemetry is a collection of tools, APIs, and SDKs used to instrument,
@@ -25,150 +18,134 @@ analysis in order to understand your software's performance and behavior. You
 can export and analyze them using [Prometheus], [Jaeger], and other
 observability tools.
 
-*Compiler support: [requires `rustc` 1.60+][msrv]*
+*[Supported Rust Versions](#supported-rust-versions)*
 
 [Prometheus]: https://prometheus.io
 [Jaeger]: https://www.jaegertracing.io
-[msrv]: #supported-rust-versions
-
 
 ## Project Status
 
-| Signal  | Status     |
-| ------- | ---------- |
-| Logs    | Alpha*     |
-| Metrics | Alpha      |
-| Traces  | Beta       |
+The table below summarizes the overall status of each component. Some components
+include unstable features, which are documented in their respective crate
+documentation.
+
+| Signal/Component      | Overall Status     |
+| --------------------  | ------------------ |
+| Context               | Beta               |
+| Baggage               | RC                 |
+| Propagators           | Beta               |
+| Logs-API              | Stable*            |
+| Logs-SDK              | Stable             |
+| Logs-OTLP Exporter    | RC                 |
+| Logs-Appender-Tracing | Stable             |
+| Metrics-API           | Stable             |
+| Metrics-SDK           | Stable             |
+| Metrics-OTLP Exporter | RC                 |
+| Traces-API            | Beta               |
+| Traces-SDK            | Beta               |
+| Traces-OTLP Exporter  | Beta               |
 
 *OpenTelemetry Rust is not introducing a new end user callable Logging API.
 Instead, it provides [Logs Bridge
-API](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/logs/bridge-api.md),
+API](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/logs/api.md),
 that allows one to write log appenders that can bridge existing logging
 libraries to the OpenTelemetry log data model. The following log appenders are
 available:
 
 * [opentelemetry-appender-log](opentelemetry-appender-log/README.md)
 * [opentelemetry-appender-tracing](opentelemetry-appender-tracing/README.md)
-* opentelemetry-appender-slog // TODO: Add link once available
 
 If you already use the logging APIs from above, continue to use them, and use
 the appenders above to bridge the logs to OpenTelemetry. If you are using a
 library not listed here, feel free to contribute a new appender for the same.
 
-If you are starting fresh, then consider using
+If you are starting fresh, we recommend using
 [tracing](https://github.com/tokio-rs/tracing) as your logging API. It supports
-structured logging and is actively maintained.
+structured logging and is actively maintained. `OpenTelemetry` itself uses
+`tracing` for its internal logging.
 
 Project versioning information and stability guarantees can be found
 [here](VERSIONING.md).
 
 ## Getting Started
 
-```rust
-use opentelemetry::{
-    global,
-    sdk::trace::TracerProvider,
-    trace::{Tracer, TracerProvider as _},
-};
+If you are new to OpenTelemetry, start with the [Stdout
+Example](./opentelemetry-stdout/examples/basic.rs). This example demonstrates
+how to use OpenTelemetry for logs, metrics, and traces, and display
+telemetry data on your console.
 
-fn main() {
-    // Create a new trace pipeline that prints to stdout
-    let provider = TracerProvider::builder()
-        .with_simple_exporter(opentelemetry_stdout::SpanExporter::default())
-        .build();
-    let tracer = provider.tracer("readme_example");
+For those using OTLP, the recommended OpenTelemetry Exporter for production
+scenarios, refer to the [OTLP Example -
+HTTP](./opentelemetry-otlp/examples/basic-otlp-http/README.md) and the [OTLP
+Example - gRPC](./opentelemetry-otlp/examples/basic-otlp/README.md).
 
-    tracer.in_span("doing_work", |cx| {
-        // Traced app logic here...
-    });
+Additional examples for various integration patterns can be found in the
+[examples](./examples) directory.
 
-    // Shutdown trace pipeline
-    global::shutdown_tracer_provider();
-}
-```
+## Overview of crates
 
-See the [examples](./examples) directory for different integration patterns.
+The following crates are maintained in this repo:
 
-## Ecosystem
-
-### Related Crates
-
-In addition to `opentelemetry`, the [`open-telemetry/opentelemetry-rust`]
-repository contains several additional crates designed to be used with the
-`opentelemetry` ecosystem. This includes a collection of trace `SpanExporter`
-and metrics pull and push controller implementations, as well as utility and
-adapter crates to assist in propagating state and instrumenting applications.
-
-In particular, the following crates are likely to be of interest:
-
-- [`opentelemetry-aws`] provides unofficial propagators for AWS X-ray.
-- [`opentelemetry-datadog`] provides additional exporters to [`Datadog`].
-- [`opentelemetry-dynatrace`] provides additional exporters to Dynatrace.
-- [`opentelemetry-contrib`] provides additional exporters and propagators that
-  are experimental.
-- [`opentelemetry-http`] provides an interface for injecting and extracting
-  trace information from [`http`] headers.
-- [`opentelemetry-jaeger`] provides a pipeline and exporter for sending trace
-  information to [`Jaeger`].
-- [`opentelemetry-otlp`] exporter for sending trace and metric data in the OTLP
-  format to the OpenTelemetry collector.
-- [`opentelemetry-prometheus`] provides a pipeline and exporter for sending
-  metrics information to [`Prometheus`].
-- [`opentelemetry-semantic-conventions`] provides standard names and semantic
+* [`opentelemetry`] This is the OpenTelemetry API crate, and is the crate
+  required to instrument libraries and applications. It contains Context API,
+  Baggage API, Propagators API, Logging Bridge API, Metrics API, and Tracing
+  API.
+* [`opentelemetry-sdk`] This is the OpenTelemetry SDK crate, and contains the
+  official OpenTelemetry SDK implementation. It contains Logging SDK, Metrics
+  SDK, and Tracing SDK. It also contains propagator implementations.
+* [`opentelemetry-otlp`] - exporter to send telemetry (logs, metrics and traces)
+  in the [OTLP
+  format](https://github.com/open-telemetry/opentelemetry-specification/tree/main/specification/protocol)
+  to an endpoint accepting OTLP. This could be the [OTel
+  Collector](https://github.com/open-telemetry/opentelemetry-collector),
+  telemetry backends like [Jaeger](https://www.jaegertracing.io/),
+  [Prometheus](https://prometheus.io/docs/prometheus/latest/feature_flags/#otlp-receiver)
+  or [vendor specific endpoints](https://opentelemetry.io/ecosystem/vendors/).
+* [`opentelemetry-stdout`] exporter for sending logs, metrics and traces to
+  stdout, for learning/debugging purposes.  
+* [`opentelemetry-http`] This crate contains utility functions to help with
+  exporting telemetry, propagation, over [`http`].
+* [`opentelemetry-appender-log`] This crate provides logging appender to route
+  logs emitted using the [log](https://docs.rs/log/latest/log/) crate to
+  opentelemetry.
+* [`opentelemetry-appender-tracing`] This crate provides logging appender to
+  route logs emitted using the [tracing](https://crates.io/crates/tracing) crate
+  to opentelemetry.  
+* [`opentelemetry-jaeger-propagator`] provides context propagation using [jaeger
+  propagation
+  format](https://www.jaegertracing.io/docs/1.18/client-libraries/#propagation-format).
+* [`opentelemetry-prometheus`] provides a pipeline and exporter for sending
+  metrics to [`Prometheus`].
+* [`opentelemetry-semantic-conventions`] provides standard names and semantic
   otel conventions.
-- [`opentelemetry-stackdriver`] provides an exporter for Google's [Cloud Trace]
-  (which used to be called StackDriver).
-- [`opentelemetry-zipkin`] provides a pipeline and exporter for sending trace
-  information to [`Zipkin`].
+* [`opentelemetry-zipkin`] provides a pipeline and exporter for sending traces
+  to [`Zipkin`].
 
-Additionally, there are also several third-party crates which are not
-maintained by the `opentelemetry` project. These include:
+In addition, there are several other useful crates in the [OTel Rust Contrib
+repo](https://github.com/open-telemetry/opentelemetry-rust-contrib). A lot of
+crates maintained outside OpenTelemetry owned repos can be found in the
+[OpenTelemetry
+Registry](https://opentelemetry.io/ecosystem/registry/?language=rust).
 
-- [`tracing-opentelemetry`] provides integration for applications instrumented
-  using the [`tracing`] API and ecosystem.
-- [`actix-web-opentelemetry`] provides integration for the [`actix-web`] web
-  server and ecosystem.
-- [`opentelemetry-application-insights`] provides an unofficial [Azure
-  Application Insights] exporter.
-- [`opentelemetry-tide`] provides integration for the [`Tide`] web server and
-  ecosystem.
-
-If you're the maintainer of an `opentelemetry` ecosystem crate not listed
-above, please let us know! We'd love to add your project to the list!
-
-[`open-telemetry/opentelemetry-rust`]: https://github.com/open-telemetry/opentelemetry-rust
-[`opentelemetry-jaeger`]: https://crates.io/crates/opentelemetry-jaeger
-[`Jaeger`]: https://www.jaegertracing.io
-[`opentelemetry-otlp`]: https://crates.io/crates/opentelemetry-otlp
+[`opentelemetry`]: https://crates.io/crates/opentelemetry
+[`opentelemetry-sdk`]: https://crates.io/crates/opentelemetry-sdk
+[`opentelemetry-appender-log`]: https://crates.io/crates/opentelemetry-appender-log
+[`opentelemetry-appender-tracing`]: https://crates.io/crates/opentelemetry-appender-tracing
 [`opentelemetry-http`]: https://crates.io/crates/opentelemetry-http
+[`opentelemetry-otlp`]: https://crates.io/crates/opentelemetry-otlp
+[`opentelemetry-stdout`]: https://crates.io/crates/opentelemetry-stdout
+[`opentelemetry-jaeger-propagator`]: https://crates.io/crates/opentelemetry-jaeger-propagator
 [`opentelemetry-prometheus`]: https://crates.io/crates/opentelemetry-prometheus
-[`opentelemetry-aws`]: https://crates.io/crates/opentelemetry-aws
 [`Prometheus`]: https://prometheus.io
 [`opentelemetry-zipkin`]: https://crates.io/crates/opentelemetry-zipkin
 [`Zipkin`]: https://zipkin.io
-[`opentelemetry-contrib`]: https://crates.io/crates/opentelemetry-contrib
-[`Datadog`]: https://www.datadoghq.com
-[`opentelemetry-datadog`]: https://crates.io/crates/opentelemetry-datadog
-[`Dynatrace`]: https://www.dynatrace.com/
-[`opentelemetry-dynatrace`]: https://crates.io/crates/opentelemetry-dynatrace
 [`opentelemetry-semantic-conventions`]: https://crates.io/crates/opentelemetry-semantic-conventions
 [`http`]: https://crates.io/crates/http
 
-[`tracing-opentelemetry`]: https://crates.io/crates/tracing-opentelemetry
-[`tracing`]: https://crates.io/crates/tracing
-[`actix-web-opentelemetry`]: https://crates.io/crates/actix-web-opentelemetry
-[`actix-web`]: https://crates.io/crates/actix-web
-[`opentelemetry-application-insights`]: https://crates.io/crates/opentelemetry-application-insights
-[Azure Application Insights]: https://docs.microsoft.com/en-us/azure/azure-monitor/app/app-insights-overview
-[`opentelemetry-tide`]: https://crates.io/crates/opentelemetry-tide
-[`Tide`]: https://crates.io/crates/tide
-[`opentelemetry-stackdriver`]: https://crates.io/crates/opentelemetry-stackdriver
-[Cloud Trace]: https://cloud.google.com/trace/
-
 ## Supported Rust Versions
 
 OpenTelemetry is built against the latest stable release. The minimum supported
-version is 1.60. The current OpenTelemetry version is not guaranteed to build
+version is 1.75. The current OpenTelemetry version is not guaranteed to build
 on Rust versions earlier than the minimum supported version.
 
 The current stable Rust compiler and the three most recent minor versions
@@ -183,14 +160,14 @@ this policy.
 See the [contributing file](CONTRIBUTING.md).
 
 The Rust special interest group (SIG) meets weekly on Tuesdays at 9 AM Pacific
-Time (16:00 UTC). The meeting is subject to change depending on contributors'
-availability. Check the [OpenTelemetry community
-calendar](https://calendar.google.com/calendar/embed?src=google.com_b79e3e90j7bbsa2n2p5an5lf60%40group.calendar.google.com)
+Time. The meeting is subject to change depending on contributors' availability.
+Check the [OpenTelemetry community
+calendar](https://github.com/open-telemetry/community?tab=readme-ov-file#calendar)
 for specific dates and for Zoom meeting links. "OTel Rust SIG" is the name of
 meeting for this group.
 
 Meeting notes are available as a public [Google
-doc](https://docs.google.com/document/d/1tGKuCsSnyT2McDncVJrMgg74_z8V06riWZa0Sr79I_4/edit).
+doc](https://docs.google.com/document/d/12upOzNk8c3SFTjsL6IRohCWMgzLKoknSCOOdMakbWo4/edit).
 If you have trouble accessing the doc, please get in touch on
 [Slack](https://cloud-native.slack.com/archives/C03GDP0H023).
 
@@ -198,3 +175,38 @@ The meeting is open for all to join. We invite everyone to join our meeting,
 regardless of your experience level. Whether you're a seasoned OpenTelemetry
 developer, just starting your journey, or simply curious about the work we do,
 you're more than welcome to participate!
+
+## Approvers and Maintainers
+
+### Maintainers
+
+* [Cijo Thomas](https://github.com/cijothomas), Microsoft
+* [Harold Dost](https://github.com/hdost)
+* [Lalit Kumar Bhasin](https://github.com/lalitb), Microsoft
+* [Utkarsh Umesan Pillai](https://github.com/utpilla), Microsoft
+* [Zhongyang Wu](https://github.com/TommyCpp)
+
+For more information about the maintainer role, see the [community repository](https://github.com/open-telemetry/community/blob/main/guides/contributor/membership.md#maintainer).
+
+### Approvers
+
+* [Anton Grübel](https://github.com/gruebel), Baz
+* [Björn Antonsson](https://github.com/bantonsson), Datadog
+* [Scott Gerring](https://github.com/scottgerring), Datadog
+* [Shaun Cox](https://github.com/shaun-cox), Microsoft
+
+For more information about the approver role, see the [community repository](https://github.com/open-telemetry/community/blob/main/guides/contributor/membership.md#approver).
+
+### Emeritus
+
+* [Dirkjan Ochtman](https://github.com/djc)
+* [Isobel Redelmeier](https://github.com/iredelmeier)
+* [Jan Kühle](https://github.com/frigus02)
+* [Julian Tescher](https://github.com/jtescher)
+* [Mike Goldsmith](https://github.com/MikeGoldsmith)
+
+For more information about the emeritus role, see the [community repository](https://github.com/open-telemetry/community/blob/main/guides/contributor/membership.md#emeritus-maintainerapprovertriager).
+
+### Thanks to all the people who have contributed
+
+[![contributors](https://contributors-img.web.app/image?repo=open-telemetry/opentelemetry-rust)](https://github.com/open-telemetry/opentelemetry-rust/graphs/contributors)

deny.toml

@@ -1,20 +1,39 @@
-exclude=[
-    "actix-http",
-    "actix-http-tracing",
-    "actix-udp",
-    "actix-udp-example",
-    "tracing-grpc",
-    "http"
-]
+[graph]
+exclude=[]
 
 [licenses]
-unlicensed = "deny"
 allow = [
     "MIT",
     "Apache-2.0",
     "ISC",
     "BSD-3-Clause",
-    "OpenSSL"
+]
+
+exceptions = [
+    { allow = ["CDLA-Permissive-2.0"], crate = "webpki-roots" }, # This crate is a dependency of `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "icu_collections" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "icu_locid" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "icu_locid_transform" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "icu_locid_transform_data" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "icu_locale_core" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "icu_normalizer" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "icu_normalizer_data" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "icu_properties" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "icu_properties_data" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "icu_provider" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "icu_provider_macros" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "potential_utf" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "litemap" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "tinystr" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "writeable" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "unicode-ident" }, # This crate gets used transitively by `reqwest` and other crates.
+    { allow = ["Unicode-3.0"], crate = "yoke" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "yoke-derive" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "zerovec" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "zerotrie" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "zerovec-derive" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "zerofrom" }, # This crate gets used transitively by `reqwest`.
+    { allow = ["Unicode-3.0"], crate = "zerofrom-derive" }, # This crate gets used transitively by `reqwest`.
 ]
 
 [licenses.private]
@@ -28,11 +47,31 @@ license-files = [
     { path = "LICENSE", hash = 0xbd0eed23 }
 ]
 
+# This section is considered when running `cargo deny check advisories`
+# More documentation for the advisories section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/advisories/cfg.html
 [advisories]
-ignore = [
-    # unsoundness in indirect dependencies without a safe upgrade below
-    "RUSTSEC-2021-0145",
-    "RUSTSEC-2019-0036"
-]
-unmaintained = "allow"
-yanked = "allow"
+unmaintained = "none"
+yanked = "deny"
+
+# This section is considered when running `cargo deny check bans`.
+# More documentation about the 'bans' section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/bans/cfg.html
+[bans]
+# Lint level for when multiple versions of the same crate are detected
+multiple-versions = "warn"
+# Lint level for when a crate version requirement is `*`
+wildcards = "warn"
+# The graph highlighting used when creating dotgraphs for crates
+# with multiple versions
+# * lowest-version - The path to the lowest versioned duplicate is highlighted
+# * simplest-path - The path to the version with the fewest edges is highlighted
+# * all - Both lowest-version and simplest-path are used
+highlight = "all"
+
+# This section is considered when running `cargo deny check sources`.
+# More documentation about the 'sources' section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/sources/cfg.html
+[sources]
+unknown-registry = "deny"
+unknown-git = "deny"

docs/adr/001_error_handling.md

@@ -0,0 +1,175 @@
+# Error handling patterns in public API interfaces
+## Date
+27 Feb 2025 
+
+## Summary
+
+This ADR describes the general pattern we will follow when modelling errors in public API interfaces - that is, APIs that are exposed to users of the project's published crates. It summarizes the discussion and final option from [#2571](https://github.com/open-telemetry/opentelemetry-rust/issues/2571); for more context check out that issue. 
+
+We will focus on the exporter traits in this example, but the outcome should be applied to _all_ public traits and their fallible operations. 
+
+These include [SpanExporter](https://github.com/open-telemetry/opentelemetry-rust/blob/eca1ce87084c39667061281e662d5edb9a002882/opentelemetry-sdk/src/trace/export.rs#L18), [LogExporter](https://github.com/open-telemetry/opentelemetry-rust/blob/eca1ce87084c39667061281e662d5edb9a002882/opentelemetry-sdk/src/logs/export.rs#L115), and [PushMetricExporter](https://github.com/open-telemetry/opentelemetry-rust/blob/eca1ce87084c39667061281e662d5edb9a002882/opentelemetry-sdk/src/metrics/exporter.rs#L11) which form part of the API surface of `opentelemetry-sdk`.
+
+There are various ways to handle errors on trait methods, including swallowing them and logging, panicking, returning a shared global error, or returning a method-specific error. We strive for consistency, and we want to be sure that we've put enough thought into what this looks like that we don't have to make breaking interface changes unnecessarily in the future.
+
+## Design Guidance
+
+### 1. No panics from SDK APIs
+Failures during regular operation should not panic, instead returning errors to the caller where appropriate, _or_ logging an error if not appropriate.
+Some of the opentelemetry SDK interfaces are dictated by the specification in way such that they may not return errors. 
+
+### 2. Consolidate error types within a trait where we can, let them diverge when we can't**
+
+We aim to consolidate error types where possible _without indicating a function may return more errors than it can actually return_. 
+
+**Don't do this** - each function's signature indicates that it returns errors it will _never_ return, forcing the caller to write handlers for dead paths:
+```rust
+enum MegaError {
+  TooBig,
+  TooSmall,
+  TooLong,
+  TooShort
+}
+
+trait MyTrait {
+
+  // Will only ever return TooBig,TooSmall errors
+  fn action_one() -> Result<(), MegaError>;
+
+  // These will only ever return TooLong,TooShort errors
+  fn action_two() -> Result<(), MegaError>;
+  fn action_three() -> Result<(), MegaError>;
+}
+```
+
+**Instead, do this** - each function's signature indicates only the errors it can return, providing an accurate contract to the caller:
+
+```rust
+enum ErrorOne {
+  TooBig,
+  TooSmall,
+}
+
+enum ErrorTwo {
+  TooLong,
+  TooShort
+}
+
+trait MyTrait {
+  fn action_one() -> Result<(), ErrorOne>;
+
+  // Action two and three share the same error type. 
+  // We do not introduce a common error MyTraitError for all operations, as this would
+  // force all methods on the trait to indicate they return errors they do not return,
+  // complicating things for the caller.  
+  fn action_two() -> Result<(), ErrorTwo>;
+  fn action_three() -> Result<(), ErrorTwo>;
+}
+```
+
+## 3. Consolidate error types between signals where we can, let them diverge where we can't
+
+Consider the `Exporter`s mentioned earlier. Each of them has the same failure indicators - as dictated by the OpenTelemetry spec  - and we will
+share the error types accordingly: 
+
+**Don't do this** - each signal has its own error type, despite having exactly the same failure cases: 
+
+```rust
+#[derive(Error, Debug)]
+pub enum OtelTraceError {
+    #[error("Shutdown already invoked")]
+    AlreadyShutdown,
+    
+    #[error("Operation failed: {0}")]
+    InternalFailure(String),
+
+    /** ... additional errors ... **/ 
+}
+
+#[derive(Error, Debug)]
+pub enum OtelLogError {
+    #[error("Shutdown already invoked")]
+    AlreadyShutdown,
+    
+    #[error("Operation failed: {0}")]
+    InternalFailure(String),
+
+    /** ... additional errors ... **/ 
+}
+```
+
+**Instead, do this** - error types are consolidated between signals where this can be done appropriately:
+
+```rust
+
+/// opentelemetry-sdk::error
+
+#[derive(Error, Debug)]
+pub enum OTelSdkError {
+    #[error("Shutdown already invoked")]
+    AlreadyShutdown,
+    
+    #[error("Operation failed: {0}")]
+    InternalFailure(String),
+
+    /** ... additional errors ... **/ 
+}
+
+pub type OTelSdkResult = Result<(), OTelSdkError>;
+
+/// signal-specific exporter traits all share the same 
+/// result types for the exporter operations.
+
+// pub trait LogExporter {
+// pub trait SpanExporter {
+pub trait PushMetricExporter {
+    fn export(&self, /* ... */) -> OtelSdkResult;
+    fn force_flush(&self, /* ... */ ) -> OTelSdkResult;
+    fn shutdown(&self, /* ... */ ) -> OTelSdkResult;
+```
+
+If this were _not_ the case - if we needed to mark an extra error for instance for `LogExporter` that the caller could reasonably handle - 
+we would let that error traits diverge at that point. 
+
+### 4. Box custom errors where a savvy caller may be able to handle them, stringify them if not
+
+Note above that we do not box any `Error` into `InternalFailure`. Our rule here is that if the caller cannot reasonably be expected to handle a particular error variant, we will use a simplified interface that returns only a descriptive string. In the concrete example we are using with the exporters, we have a [strong signal in the opentelemetry-specification](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/logs/sdk.md#export) that indicates that the error types _are not actionable_ by the caller. 
+
+If the caller may potentially recover from an error, we will follow the generally-accepted best practice (e.g., see [canonical's guide](https://canonical.github.io/rust-best-practices/error-and-panic-discipline.html) and instead preserve the nested error:
+
+**Don't do this if the OtherError is potentially recoverable by a savvy caller**:
+```rust
+
+#[derive(Debug, Error)]
+pub enum MyError {
+    #[error("Error one occurred")]
+    ErrorOne, 
+
+    #[error("Operation failed: {0}")]
+    OtherError(String),
+```
+
+**Instead, do this**, allowing the caller to match on the nested error:
+
+```rust
+#[derive(Debug, Error)]
+pub enum MyError {
+    #[error("Error one occurred")]
+    ErrorOne, 
+
+    #[error("Operation failed: {source}")]
+    OtherError {
+        #[from]
+        source: Box<dyn Error + Send + Sync>,
+    },
+}
+```
+
+Note that at the time of writing, there is no instance we have identified within the project that has required this. 
+
+### 5. Use thiserror by default
+We will use [thiserror](https://docs.rs/thiserror/latest/thiserror/) by default to implement Rust's [error trait](https://doc.rust-lang.org/core/error/trait.Error.html).
+This keeps our code clean, and as it does not appear in our interface, we can choose to replace any particular usage with a hand-rolled implementation should we need to.
+
+### 6. Don't use `#[non_exhaustive]` by default
+If an `Error` response set is closed - if we can confidently say it is very unlikely to gain new variants in the future - we should not annotate it with `#[non_exhaustive]`. By way of example, the variants of the exporter error types described above are exhaustively documented in the OpenTelemetry Specification, and we can confidently say that we do not expect new variants.

docs/adr/README.md

@@ -0,0 +1,5 @@
+# Architectural Decision Records
+
+This directory contains architectural decision records made for the opentelemetry-rust project. These allow us to consolidate discussion, options, and outcomes, around key architectural decisions. 
+
+* [001 - Error Handling](001_error_handling.md)

docs/design/logs.md

@@ -0,0 +1,378 @@
+# OpenTelemetry Rust Logs Design
+
+Status:
+[Development](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/document-status.md)
+
+## Overview
+
+[OpenTelemetry (OTel)
+Logs](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/logs/README.md)
+support differs from Metrics and Traces as it does not introduce a new logging
+API for end users. Instead, OTel recommends leveraging existing logging
+libraries such as [log](https://crates.io/crates/log) and
+[tracing](https://crates.io/crates/tracing), while providing bridges (appenders)
+to route logs through OpenTelemetry.
+
+OTel took this different approach due to the long history of existing logging
+solutions. In Rust, these are [log](https://crates.io/crates/log) and
+[tracing](https://crates.io/crates/tracing), and have been embraced in the
+community for some time. OTel Rust maintains appenders for these libraries,
+allowing users to seamlessly integrate with OpenTelemetry without changing their
+existing logging instrumentation.
+
+The `tracing` appender is particularly optimized for performance due to its
+widespread adoption and the fact that `tracing` itself has a bridge from the
+`log` crate. Notably, OpenTelemetry Rust itself is instrumented using `tracing`
+for internal logs. Additionally, when OTel began supporting logging as a signal,
+the `log` crate lacked structured logging support, reinforcing the decision to
+prioritize `tracing`.
+
+## Benefits of OpenTelemetry Logs
+
+- **Unified configuration** across Traces, Metrics, and Logs.
+- **Automatic correlation** with Traces.
+- **Consistent Resource attributes** across signals.
+- **Multiple destinations support**: Logs can continue flowing to existing
+  destinations like stdout etc. while also being sent to an
+  OpenTelemetry-capable backend, typically via an OTLP Exporter or exporters
+  that export to operating system native systems like `Windows ETW` or `Linux
+  user_events`.
+- **Standalone logging support** for applications that use OpenTelemetry as
+  their primary logging mechanism.
+
+## Key Design Principles
+
+- High performance - no locks/contention in the hot path with minimal/no heap
+  allocation where possible.
+- Capped resource (memory) usage - well-defined behavior when overloaded.
+- Self-observable - exposes telemetry about itself to aid in troubleshooting
+  etc.
+- Robust error handling, returning Result where possible instead of panicking.
+- Minimal public API, exposing based on need only.
+
+## Architecture Overview
+
+```mermaid
+graph TD
+    subgraph Application
+        A1[Application Code]
+    end
+    subgraph Logging Libraries
+        B1[log crate]
+        B2[tracing crate]
+    end
+    subgraph OpenTelemetry
+        C1[OpenTelemetry Appender for log]
+        C2[OpenTelemetry Appender for tracing]
+        C3[OpenTelemetry Logs API]
+        C4[OpenTelemetry Logs SDK]
+        C5[OTLP Exporter]
+    end
+    subgraph Observability Backend
+        D1[OTLP-Compatible Backend]
+    end
+    A1 --> |Emits Logs| B1
+    A1 --> |Emits Logs| B2
+    B1 --> |Bridged by| C1
+    B2 --> |Bridged by| C2
+    C1 --> |Sends to| C3
+    C2 --> |Sends to| C3
+    C3 --> |Processes with| C4
+    C4 --> |Exports via| C5
+    C5 --> |Sends to| D1
+```
+
+## Logs API
+
+Logs API is part of the [opentelemetry](https://crates.io/crates/opentelemetry)
+crate.
+
+The OTel Logs API is not intended for direct end-user usage. Instead, it is
+designed for appender/bridge authors to integrate existing logging libraries
+with OpenTelemetry. However, there is nothing preventing it from being used by
+end-users.
+
+### API Components
+
+1. **Key-Value Structs**: Used in `LogRecord`, where `Key` struct is shared
+   across signals but `Value` struct differ from Metrics and Traces. This is
+   because values in Logs can contain more complex structures than those in
+   Traces and Metrics.
+2. **Traits**:
+    - `LoggerProvider` - provides methods to obtain Logger.
+    - `Logger` - provides methods to create LogRecord and emit the created
+      LogRecord.
+    - `LogRecord` - provides methods to populate LogRecord.
+3. **No-Op Implementations**: By default, the API performs no operations until
+   an SDK is attached.
+
+### Logs Flow
+
+1. Obtain a `LoggerProvider` implementation.
+2. Use the `LoggerProvider` to create `Logger` instances, specifying a scope
+   name (module/component emitting logs). Optional attributes and version are
+   also supported.
+3. Use the `Logger` to create an empty `LogRecord` instance.
+4. Populate the `LogRecord` with body, timestamp, attributes, etc.
+5. Call `Logger.emit(LogRecord)` to process and export the log.
+
+If only the Logs API is used (without an SDK), all the above steps result in no
+operations, following OpenTelemetry’s philosophy of separating API from SDK. The
+official Logs SDK provides real implementations to process and export logs.
+Users or vendors can also provide alternative SDK implementations.
+
+## Logs SDK
+
+Logs SDK is part of the
+[opentelemetry_sdk](https://crates.io/crates/opentelemetry_sdk) crate.
+
+The OpenTelemetry Logs SDK provides an OTel specification-compliant
+implementation of the Logs API, handling log processing and export.
+
+### Core Components
+
+#### `SdkLoggerProvider`
+
+This is the implementation of the `LoggerProvider` and deals with concerns such
+as processing and exporting Logs.
+
+- Implements the `LoggerProvider` trait.
+- Creates and manages `SdkLogger` instances.
+- Holds logging configuration, including `Resource` and processors.
+- Does not retain a list of created loggers. Instead, it passes an owned clone
+  of itself to each logger created. This is done so that loggers get a hold of
+  the configuration (like which processor to invoke).
+- Uses an `Arc<LoggerProviderInner>` and delegates all configuration to
+  `LoggerProviderInner`. This allows cheap cloning of itself and ensures all
+  clones point to the same underlying configuration.
+- As `SdkLoggerProvider` only holds an `Arc` of its inner, it can only take
+  `&self` in its methods like flush and shutdown. Else it needs to rely on
+  interior mutability that comes with runtime performance costs. Since methods
+  like shutdown usually need to mutate interior state, but this component can
+  only take `&self`, it defers to components like exporter to use interior
+  mutability to handle shutdown. (More on this in the exporter section)
+- An alternative design was to let `SdkLogger` hold a `Weak` reference to the
+  `SdkLoggerProvider`. This would be a `weak->arc` upgrade in every log
+  emission, significantly affecting throughput.
+- `LoggerProviderInner` implements `Drop`, triggering `shutdown()` when no
+  references remain. However, in practice, loggers are often stored statically
+  inside appenders (like tracing-appender), so explicit shutdown by the user is
+  required.
+
+#### `SdkLogger`
+
+This is an implementation of the `Logger`, and contains functionality to create
+and emit logs.
+
+- Implements the `Logger` trait.
+- Creates `SdkLogRecord` instances and emits them.
+- Calls `OnEmit()` on all registered processors when emitting logs.
+- Passes mutable references to each processor (`&mut log_record`), i.e.,
+  ownership is not passed to the processor. This ensures that the logger avoids
+  cloning costs. Since a mutable reference is passed, processors can modify the
+  log, and it will be visible to the next processor in the chain.
+- Since the processor only gets a reference to the log, it cannot store it
+  beyond the `OnEmit()`. If a processor needs to buffer logs, it must explicitly
+  copy them to the heap.
+- This design allows for stack-only log processing when exporting to operating
+  system native facilities like `Windows ETW` or `Linux user_events`.
+- OTLP Exporting requires network calls (HTTP/gRPC) and batching of logs for
+  efficiency purposes. These exporters buffer log records by copying them to the
+  heap. (More on this in the BatchLogRecordProcessor section)
+
+#### `LogRecord`
+
+- Holds log data, including attributes.
+- Uses an inline array for up to 5 attributes to optimize stack usage.
+- Falls back to a heap-allocated `Vec` if more attributes are required.
+- Inspired by Go’s `slog` library for efficiency.
+
+#### LogRecord Processors
+
+`SdkLoggerProvider` allows being configured with any number of LogProcessors.
+They get called in the order of registration. Log records are passed to the
+`OnEmit` method of LogProcessor. LogProcessors can be used to process the log
+records, enrich them, filter them, and export to destinations by leveraging
+LogRecord Exporters.
+
+Similar to [LoggerProvider](#sdkloggerprovider), methods on the `LogProcessor`
+trait also takes a immutable self (`&self`) only, forcing the need to use
+interior mutability, if any mutation is required. The exception to this is
+`set_resource`, which takes a `&mut self`. This is acceptable as `set_resource`
+is called by the `SdkLoggerProvider` during build() method only, and is not
+required after that.
+
+Following built-in Log processors are provided in the Log SDK:
+
+##### SimpleLogProcessor
+
+This processor is designed to be used for exporting purposes. Export is handled
+by an Exporter (which is a separate component). SimpleLogProcessor is "simple"
+in the sense that it does not attempt to do any processing - it just calls the
+exporter and passes the log record to it. To comply with OTel specification, it
+synchronizes calls to the `Export()` method, i.e., only one `Export()` call will
+be done at any given time.
+
+SimpleLogProcessor is only used for test/learning purposes and is often used
+along with a `stdout` exporter.
+
+##### BatchLogProcessor
+
+This is another "exporting" processor. As with SimpleLogProcessor, a different
+component named LogExporter handles the actual export logic. BatchLogProcessor
+buffers/batches the logs it receives into an in-memory buffer. It invokes the
+exporter every 1 second or when 512 items are in the batch (customizable). It
+uses a background thread to do the export, and communication between the user
+thread (where logs are emitted) and the background thread occurs with `mpsc`
+channels.
+
+The max amount of items the buffer holds is 2048 (customizable). Once the limit
+is reached, any *new* logs are dropped. It *does not* apply back-pressure to the
+user thread and instead drops logs.
+
+As with SimpleLogProcessor, this component also ensures only one export is
+active at a given time. A modified version of this is required to achieve higher
+throughput in some environments.
+
+In this design, at most 2048+512 logs can be in memory at any given point. In
+other words, that many logs can be lost if the app crashes in the middle.
+
+## LogExporters
+
+LogExporters are responsible for exporting logs to a destination.
+`SdkLoggerProvider` does not have a direct knowledge of the `LogExporter`, as it
+only deals with `LogProcessors`. It is the `LogProcessor`s that invokes
+`LogExporter` methods. Most methods on `LogExporter` trait also only takes
+`&self`, following the same reasoning as [LogProcessors](#logrecord-processors)
+
+Some of the exporters are:
+
+1. **InMemoryExporter** - exports to an in-memory list, primarily for
+   unit-testing. This is used extensively in the repo itself, and external users
+   are also encouraged to use this.
+2. **Stdout exporter** - prints telemetry to stdout. Only for debugging/learning
+   purposes. The output format is not defined and also is not performance
+   optimized. A production-recommended version with a standardized output format
+   is in the plan.
+3. **OTLP Exporter** - OTel's official exporter which uses the OTLP protocol
+   that is designed with the OTel data model in mind. Both HTTP and gRPC-based
+   exporting is offered.
+4. **Exporters to OS Kernel facilities** - These exporters are not maintained in
+   the core repo but listed for completion. They export telemetry to Windows ETW
+   or Linux user_events. They are designed for high-performance workloads. Due
+   to their nature of synchronous exporting, they do not require
+   buffering/batching. This allows logs to operate entirely on the stack and can
+   scale easily with the number of CPU cores. (Kernel uses per-CPU buffers for
+   the events, ensuring no contention)
+
+## `tracing` Log Appender
+
+Tracing appender is part of the
+[opentelemetry-appender-tracing](https://crates.io/crates/opentelemetry-appender-tracing)
+crate.
+
+The `tracing` appender bridges `tracing` logs to OpenTelemetry. Logs emitted via
+`tracing` macros (`info!`, `warn!`, etc.) are forwarded to OpenTelemetry through
+this integration.
+
+- `tracing` is designed for high performance, using *layers* or *subscribers* to
+  handle emitted logs (events).
+- The appender implements a `Layer`, receiving logs from `tracing`.
+- Uses the OTel Logs API to create `LogRecord`, populate it, and emit it via
+  `Logger.emit(LogRecord)`.
+- If no Logs SDK is present, the process is a no-op.
+
+Note on terminology: Within OpenTelemetry, "tracing" refers to distributed
+tracing (i.e creation of Spans) and not in-process structured logging and
+execution traces. The crate "tracing" has notion of creating Spans as well as
+Events. The events from "tracing" crate is what gets converted to OTel Logs,
+when using this appender. Spans created using "tracing" crate is not handled by
+this crate.
+
+## Performance
+
+// Call out things done specifically for performance
+// Rough draft
+
+1. `LogRecord` is stack allocated and not Boxed unless required by the component
+needing to store it beyond the logging call. (eg: BatchProcessor)
+2. LogRecords's Attribute storage is specially designed struct, that holds up to
+five attributes in stack.
+3. When passing `LogRecord`s to processor, a mutable ref is passed. This allows
+calling multiple processors one after another, without the need for cloning.
+4. `Logger` provides a `Enabled` check which can optimize performance when
+no-one is interested in the log. The check is passed from `Logger` to the
+processor, which may consult its exporter to make the decision. An example use
+case - an ETW or user-events exporter can check for the presence of listener and
+convey that decision back to logger, allowing appender to avoid even the cost of
+creating a `LogRecord` in the first place if there is no listener. This check is
+done for each log emission, and can react dynamically to changes in interest, by
+enabling/disabling ETW/user-event listener.
+5. `tracing` has a notion of "target", which is expected to be mapped to OTel's
+concept of Instrumentation Scope for Logs, when `OpenTelemetry-Tracing-Appender`
+bridges `tracing` to OpenTelemetry. Since scopes are tied to Loggers, a naive
+approach would require creating a separate logger for each unique target. This
+would necessitate an RWLock-protected HashMap lookup, introducing contention and
+reducing throughput. To avoid this, `OpenTelemetry-Tracing-Appender` instead
+stores the target directly in the LogRecord as a top-level field, ensuring fast
+access in the hot path. Components processing the LogRecord can retrieve the
+target via LogRecord.target(), treating it as the scope. The OTLP Exporter
+already handles this automatically, so end-users will see “target” reflected in
+the Instrumentation Scope. An alternative design would be to use thread-local
+HashMaps - but it can cause increased memory usage, as there can be 100s of
+unique targets. (because `tracing` defaults to using module path as target).
+
+### Perf test - benchmarks
+
+// Share ~~ numbers
+
+### Perf test - stress test
+
+// Share ~~ numbers
+
+## Internal logs
+
+OTel itself is instrumented with `tracing` crate to emit internal logs about its
+operations. This is feature gated under "internal-logs", and is enabled by
+default for all components. The `opentelemetry` provide few helper macros
+`otel_warn` etc., which in turn invokes various `tracing` macros like `warn!`
+etc. The cargo package name will be set as `target` when using `tracing`. For
+example, logs from `opentelemetry-otlp` will have target set to
+"opentelemetry-otlp".
+
+The helper macros are part of public API, so can be used by anyone. But it is
+only meant for OTel components itself and anyone writing extensions like custom
+Exporters etc.
+
+// TODO: Document the principles followed when selecting severity for internal
+logs
+
+When OpenTelemetry components generate logs that could potentially feed back
+into OpenTelemetry, this can result in what is known as "telemetry-induced
+telemetry." To address this, OpenTelemetry provides a mechanism to suppress such
+telemetry using the `Context`. Components are expected to mark telemetry as
+suppressed within a specific `Context` by invoking
+`Context::enter_telemetry_suppressed_scope()`. The Logs SDK implementation
+checks this flag in the current `Context` and ignores logs if suppression is
+enabled.
+
+This mechanism relies on proper in-process propagation of the `Context`.
+However, external libraries like `hyper` and `tonic`, which are used by
+OpenTelemetry in its OTLP Exporters, do not propagate OpenTelemetry's `Context`.
+As a result, the suppression mechanism does not work out-of-the-box to suppress
+logs originating from these libraries.
+
+// TODO: Document how OTLP can solve this issue without asking external
+crates to respect and propagate OTel Context.
+
+## Summary
+
+- OpenTelemetry Logs does not provide a user-facing logging API.
+- Instead, it integrates with existing logging libraries (`log`, `tracing`).
+- The Logs API defines key traits but performs no operations unless an SDK is
+  installed.
+- The Logs SDK enables log processing, transformation, and export.
+- The Logs SDK is performance optimized to minimize copying and heap allocation,
+  wherever feasible.
+- The `tracing` appender efficiently routes logs to OpenTelemetry without
+  modifying existing logging workflows.

docs/design/metrics.md

@@ -0,0 +1,6 @@
+# OpenTelemetry Rust Metrics Design
+
+Status:
+[Development](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/document-status.md)
+
+TODO:

docs/design/traces.md

@@ -0,0 +1,6 @@
+# OpenTelemetry Rust Traces Design
+
+Status:
+[Development](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/document-status.md)
+
+TODO:

docs/metrics.md

@@ -0,0 +1,767 @@
+# OpenTelemetry Rust Metrics
+
+Status: **Work-In-Progress**
+
+<details>
+<summary>Table of Contents</summary>
+
+* [Introduction](#introduction)
+* [Best Practices](#best-practices)
+* [Metrics API](#metrics-api)
+  * [Meter](#meter)
+  * [Instruments](#instruments)
+  * [Reporting measurements - use array slices for
+    attributes](#reporting-measurements---use-array-slices-for-attributes)
+  * [Reporting measurements via synchronous
+    instruments](#reporting-measurements-via-synchronous-instruments)
+  * [Reporting measurements via asynchronous
+    instruments](#reporting-measurements-via-asynchronous-instruments)
+* [MeterProvider Management](#meterprovider-management)
+* [Memory Management](#memory-management)
+  * [Example](#example)
+  * [Pre-Aggregation](#pre-aggregation)
+    * [Pre-Aggregation Benefits](#pre-aggregation-benefits)
+  * [Cardinality Limits](#cardinality-limits)
+    * [Cardinality Limits - Implications](#cardinality-limits---implications)
+    * [Cardinality Limits - Example](#cardinality-limits---example)
+  * [Memory Preallocation](#memory-preallocation)
+* [Metrics Correlation](#metrics-correlation)
+* [Modelling Metric Attributes](#modelling-metric-attributes)
+* [Common Issues Leading to Missing
+  Metrics](#common-issues-that-lead-to-missing-metrics)
+
+</details>
+
+## Introduction
+
+This document provides comprehensive guidance on leveraging OpenTelemetry
+metrics in Rust applications. Whether you're tracking request counts, monitoring
+response times, or analyzing resource utilization, this guide equips you with
+the knowledge to implement robust and efficient metrics collection.
+
+It covers best practices, API usage patterns, memory management techniques, and
+advanced topics to help you design effective metrics solutions while steering
+clear of common challenges.
+
+## Best Practices
+
+// TODO: Add link to the examples, once they are modified to show best
+practices.
+
+## Metrics API
+
+### Meter
+
+[Meter](https://docs.rs/opentelemetry/latest/opentelemetry/metrics/struct.Meter.html)
+provides the ability to create instruments for recording measurements or
+accepting callbacks to report measurements.
+
+:stop_sign: You should avoid creating duplicate
+[`Meter`](https://docs.rs/opentelemetry/latest/opentelemetry/metrics/struct.Meter.html)
+instances with the same name. `Meter` is fairly expensive and meant to be reused
+throughout the application. For most applications, a `Meter` should be obtained
+from `global` and saved for re-use.
+
+> [!IMPORTANT] Create your `Meter` instance once at initialization time and
+> store it for reuse throughout your application's lifecycle.
+
+The fully qualified module name might be a good option for the Meter name.
+Optionally, one may create a meter with version, schema_url, and additional
+meter-level attributes as well. Both approaches are demonstrated below.
+
+```rust
+use opentelemetry::global;
+use opentelemetry::InstrumentationScope;
+use opentelemetry::KeyValue;
+
+let scope = InstrumentationScope::builder("my_company.my_product.my_library")
+        .with_version("0.17")
+        .with_schema_url("https://opentelemetry.io/schema/1.2.0")
+        .with_attributes([KeyValue::new("key", "value")])
+        .build();
+
+// creating Meter with InstrumentationScope, comprising of
+// name, version, schema and attributes.
+let meter = global::meter_with_scope(scope);
+
+// creating Meter with just name
+let meter = global::meter("my_company.my_product.my_library");
+```
+
+### Instruments
+
+OpenTelemetry defines several types of metric instruments, each optimized for
+specific usage patterns. The following table maps OpenTelemetry Specification
+instruments to their corresponding Rust SDK types.
+
+:heavy_check_mark: You should understand and pick the right instrument type.
+
+> [!NOTE] Picking the right instrument type for your use case is crucial to
+> ensure the correct semantics and performance. Check the [Instrument
+Selection](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/supplementary-guidelines.md#instrument-selection)
+section from the supplementary guidelines for more information.
+
+| OpenTelemetry Specification | OpenTelemetry Rust Instrument Type |
+| --------------------------- | -------------------- |
+| [Asynchronous Counter](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#asynchronous-counter) | [`ObservableCounter`](https://docs.rs/opentelemetry/latest/opentelemetry/metrics/struct.ObservableCounter.html) |
+| [Asynchronous Gauge](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#asynchronous-gauge) | [`ObservableGauge`](https://docs.rs/opentelemetry/latest/opentelemetry/metrics/struct.ObservableGauge.html) |
+| [Asynchronous UpDownCounter](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#asynchronous-updowncounter) | [`ObservableUpDownCounter`](https://docs.rs/opentelemetry/latest/opentelemetry/metrics/struct.ObservableUpDownCounter.html) |
+| [Counter](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#counter) | [`Counter`](https://docs.rs/opentelemetry/latest/opentelemetry/metrics/struct.Counter.html) |
+| [Gauge](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#gauge) | [`Gauge`](https://docs.rs/opentelemetry/latest/opentelemetry/metrics/struct.Gauge.html) |
+| [Histogram](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#histogram) | [`Histogram`](https://docs.rs/opentelemetry/latest/opentelemetry/metrics/struct.Histogram.html) |
+| [UpDownCounter](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#updowncounter) | [`UpDownCounter`](https://docs.rs/opentelemetry/latest/opentelemetry/metrics/struct.UpDownCounter.html) |
+
+:stop_sign: You should avoid creating duplicate instruments (e.g., `Counter`)
+with the same name. Instruments are fairly expensive and meant to be reused
+throughout the application. For most applications, an instrument should be
+created once and saved for re-use. Instruments can also be cloned to create
+multiple handles to the same instrument, but cloning should not occur on the hot
+path. Instead, the cloned instance should be stored and reused.
+
+:stop_sign: Do NOT use invalid instrument names.
+
+> [!NOTE] OpenTelemetry will not collect metrics from instruments that are using
+> invalid names. Refer to the [OpenTelemetry
+  Specification](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#instrument-name-syntax)
+  for the valid syntax.
+
+:stop_sign: You should avoid changing the order of attributes while reporting
+measurements.
+
+> [!WARNING] The last line of code has bad performance since the attributes are
+> not following the same order as before:
+
+```rust
+let counter = meter.u64_counter("fruits_sold").build();
+counter.add(2, &[KeyValue::new("color", "red"), KeyValue::new("name", "apple")]);
+counter.add(3, &[KeyValue::new("color", "green"), KeyValue::new("name", "lime")]);
+counter.add(5, &[KeyValue::new("color", "yellow"), KeyValue::new("name", "lemon")]);
+counter.add(8, &[KeyValue::new("name", "lemon"), KeyValue::new("color", "yellow")]); // bad performance
+```
+
+:heavy_check_mark: If feasible, provide the attributes sorted by `Key`s in
+ascending order to minimize memory usage within the Metrics SDK. Using
+consistent attribute ordering allows the SDK to efficiently reuse internal data
+structures.
+
+```rust
+// Good practice: Consistent attribute ordering
+let counter = meter.u64_counter("fruits_sold").build();
+counter.add(2, &[KeyValue::new("color", "red"), KeyValue::new("name", "apple")]);
+```
+
+### Reporting measurements - use array slices for attributes
+
+:heavy_check_mark:  When reporting measurements, use array slices for attributes
+rather than creating vectors. Arrays are more efficient as they avoid
+unnecessary heap allocations on the measurement path. This is true for both
+synchronous and observable instruments.
+
+```rust
+// Good practice: Using an array slice directly
+counter.add(2, &[KeyValue::new("color", "red"), KeyValue::new("name", "apple")]);
+
+// Observable instrument
+let _observable_counter = meter
+        .u64_observable_counter("request_count")
+        .with_description("Counts HTTP requests")
+        .with_unit("requests")  // Optional: Adding units improves context
+        .with_callback(|observer| {
+            // Good practice: Using an array slice directly
+            observer.observe(
+                100,
+                &[KeyValue::new("endpoint", "/api")]
+            )
+        })
+        .build();
+
+// Avoid this: Creating a Vec is unnecessary, and it allocates on the heap each time
+// counter.add(2, &vec![KeyValue::new("color", "red"), KeyValue::new("name", "apple")]);
+```
+
+### Reporting measurements via synchronous instruments
+
+:heavy_check_mark: Use synchronous Counter when you need to increment counts at
+specific points in your code:
+
+```rust
+// Example: Using Counter when incrementing at specific code points
+use opentelemetry::KeyValue;
+
+fn process_item(counter: &opentelemetry::metrics::Counter<u64>, item_type: &str) {
+    // Process item...
+    
+    // Increment the counter with the item type as an attribute
+    counter.add(1, &[KeyValue::new("type", item_type)]);
+}
+```
+
+### Reporting measurements via asynchronous instruments
+
+Asynchronous instruments like `ObservableCounter` are ideal for reporting
+metrics that are already being tracked or stored elsewhere in your application.
+These instruments allow you to observe and report the current state of such
+metric.
+
+:heavy_check_mark: Use `ObservableCounter` when you already have a variable
+tracking a count:
+
+```rust
+// Example: Using ObservableCounter when you already have a variable tracking counts
+use opentelemetry::KeyValue;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+// An existing variable in your application
+static REQUEST_COUNT: AtomicU64 = AtomicU64::new(0);
+
+// In your application code, you update this directly
+fn handle_request() {
+    // Process request...
+    REQUEST_COUNT.fetch_add(1, Ordering::SeqCst);
+}
+
+// When setting up metrics, register an observable counter that reads from your variable
+fn setup_metrics(meter: &opentelemetry::metrics::Meter) {
+    let _observable_counter = meter
+        .u64_observable_counter("request_count")
+        .with_description("Number of requests processed")
+        .with_unit("requests")
+        .with_callback(|observer| {
+            // Read the current value from your existing counter
+            observer.observe(
+                REQUEST_COUNT.load(Ordering::SeqCst), 
+                &[KeyValue::new("endpoint", "/api")]
+            )
+        })
+        .build();
+}
+```
+
+> [!NOTE] The callbacks in the Observable instruments are invoked by the SDK
+> during each export cycle.
+
+## MeterProvider Management
+
+Most use-cases require you to create ONLY one instance of MeterProvider. You
+should NOT create multiple instances of MeterProvider unless you have some
+unusual requirement of having different export strategies within the same
+application. Using multiple instances of MeterProvider requires users to
+exercise caution.
+
+// TODO: Mention about creating per-thread MeterProvider // as shown in
+[this](https://github.com/open-telemetry/opentelemetry-rust/pull/2659) // PR
+
+:heavy_check_mark: Properly manage the lifecycle of `MeterProvider` instances if
+you create them. Creating a MeterProvider is typically done at application
+startup. Follow these guidelines:
+
+* **Cloning**: A `MeterProvider` is a handle to an underlying provider. Cloning
+  it creates a new handle pointing to the same provider. Clone the
+  `MeterProvider` when necessary, but re-use the cloned instead of repeatedly
+  cloning.
+
+* **Set as Global Provider**: Use `opentelemetry::global::set_meter_provider` to
+  set a clone of the `MeterProvider` as the global provider. This ensures
+  consistent usage across the application, allowing applications and libraries
+  to obtain `Meter` from the global instance.
+
+* **Shutdown**: Explicitly call `shutdown` on the `MeterProvider` at the end of
+  your application to ensure all metrics are properly flushed and exported.
+
+> [!NOTE] If you did not use `opentelemetry::global::set_meter_provider` to set
+> a clone of the `MeterProvider` as the global provider, then you should be
+> aware that dropping the last instance of `MeterProvider` implicitly calls
+> shutdown on the provider.
+
+:heavy_check_mark: Always call `shutdown` on the `MeterProvider` at the end of
+your application to ensure proper cleanup.
+
+## Memory Management
+
+In OpenTelemetry,
+[measurements](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#measurement)
+are reported via the metrics API. The SDK
+[aggregates](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk.md#aggregation)
+metrics using certain algorithms and memory management strategies to achieve
+good performance and efficiency. Here are the rules which OpenTelemetry Rust
+follows while implementing the metrics aggregation logic:
+
+1. [**Pre-Aggregation**](#pre-aggregation): aggregation occurs within the SDK.
+2. [**Cardinality Limits**](#cardinality-limits): the aggregation logic respects
+   [cardinality
+   limits](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk.md#cardinality-limits),
+   so the SDK does not use an indefinite amount of memory in the event of a
+   cardinality explosion.
+3. [**Memory Preallocation**](#memory-preallocation): SDK tries to pre-allocate
+   the memory it needs at each instrument creation time.
+
+### Example
+
+Let us take the following example of OpenTelemetry Rust metrics being used to
+track the number of fruits sold:
+
+* During the time range (T0, T1]:
+  * value = 1, color = `red`, name = `apple`
+  * value = 2, color = `yellow`, name = `lemon`
+* During the time range (T1, T2]:
+  * no fruit has been sold
+* During the time range (T2, T3]:
+  * value = 5, color = `red`, name = `apple`
+  * value = 2, color = `green`, name = `apple`
+  * value = 4, color = `yellow`, name = `lemon`
+  * value = 2, color = `yellow`, name = `lemon`
+  * value = 1, color = `yellow`, name = `lemon`
+  * value = 3, color = `yellow`, name = `lemon`
+
+### Example - Cumulative Aggregation Temporality
+
+If we aggregate and export the metrics using [Cumulative Aggregation
+Temporality](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/data-model.md#temporality):
+
+* (T0, T1]
+  * attributes: {color = `red`, name = `apple`}, count: `1`
+  * attributes: {color = `yellow`, name = `lemon`}, count: `2`
+* (T0, T2]
+  * attributes: {color = `red`, name = `apple`}, count: `1`
+  * attributes: {color = `yellow`, name = `lemon`}, count: `2`
+* (T0, T3]
+  * attributes: {color = `red`, name = `apple`}, count: `6`
+  * attributes: {color = `green`, name = `apple`}, count: `2`
+  * attributes: {color = `yellow`, name = `lemon`}, count: `12`
+
+Note that the start time is not advanced, and the exported values are the
+cumulative total of what happened since the beginning.
+
+### Example - Delta Aggregation Temporality
+
+If we aggregate and export the metrics using [Delta Aggregation
+Temporality](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/data-model.md#temporality):
+
+* (T0, T1]
+  * attributes: {color = `red`, name = `apple`}, count: `1`
+  * attributes: {color = `yellow`, name = `lemon`}, count: `2`
+* (T1, T2]
+  * nothing since we do not have any measurement received
+* (T2, T3]
+  * attributes: {color = `red`, name = `apple`}, count: `5`
+  * attributes: {color = `green`, name = `apple`}, count: `2`
+  * attributes: {color = `yellow`, name = `lemon`}, count: `10`
+
+Note that the start time is advanced after each export, and only the delta since
+last export is exported, allowing the SDK to "forget" previous state.
+
+### Pre-Aggregation
+
+Rather than exporting every individual measurement to the backend, OpenTelemetry
+Rust aggregates data locally and only exports the aggregated metrics.
+
+Using the [fruit example](#example), there are six measurements reported during
+the time range `(T2, T3]`. Instead of exporting each individual measurement
+event, the SDK aggregates them and exports only the summarized results. This
+summarization process, illustrated in the following diagram, is known as
+pre-aggregation:
+
+```mermaid
+graph LR
+
+subgraph SDK
+    Instrument --> | Measurements | Pre-Aggregation[Pre-Aggregation]
+end
+
+subgraph Collector
+    Aggregation
+end
+
+Pre-Aggregation --> | Metrics | Aggregation
+```
+
+In addition to the in-process aggregation performed by the OpenTelemetry Rust
+Metrics SDK, further aggregations can be carried out by the Collector and/or the
+metrics backend.
+
+### Pre-Aggregation Benefits
+
+Pre-aggregation offers several advantages:
+
+1. **Reduced Data Volume**: Summarizes measurements before export, minimizing
+   network overhead and improving efficiency.
+2. **Predictable Resource Usage**: Ensures consistent resource consumption by
+   applying [cardinality limits](#cardinality-limits) and [memory
+   preallocation](#memory-preallocation) during SDK initialization. In other
+   words, metrics memory/network usage remains capped, regardless of the volume
+   of measurements being made.This ensures that resource utilization remains
+   stable despite fluctuations in traffic volume.
+3. **Improved Performance**: Reduces serialization costs as we work with
+   aggregated data and not the numerous individual measurements. It also reduces
+   computational load on downstream systems, enabling them to focus on analysis
+   and storage.
+
+> [!NOTE] There is no ability to opt out of pre-aggregation in OpenTelemetry.
+
+### Cardinality Limits
+
+The number of distinct combinations of attributes for a given metric is referred
+to as the cardinality of that metric. Taking the [fruit example](#example), if
+we know that we can only have apple/lemon as the name, red/yellow/green as the
+color, then we can say the cardinality is 6 (i.e., 2 names × 3 colors = 6
+combinations). No matter how many fruits we sell, we can always use the
+following table to summarize the total number of fruits based on the name and
+color.
+
+| Color  | Name  | Count |
+| ------ | ----- | ----- |
+| red    | apple | 6     |
+| yellow | apple | 0     |
+| green  | apple | 2     |
+| red    | lemon | 0     |
+| yellow | lemon | 12    |
+| green  | lemon | 0     |
+
+In other words, we know how much memory and network are needed to collect and
+transmit these metrics, regardless of the traffic pattern or volume.
+
+In real world applications, the cardinality can be extremely high. Imagine if we
+have a long running service and we collect metrics with 7 attributes and each
+attribute can have 30 different values. We might eventually end up having to
+remember the complete set of 30⁷ - or 21.87 billion combinations! This
+cardinality explosion is a well-known challenge in the metrics space. For
+example, it can cause:
+
+* Surprisingly high costs in the observability system
+* Excessive memory consumption in your application
+* Poor query performance in your metrics backend
+* Potential denial-of-service vulnerability that could be exploited by bad
+  actors
+
+[Cardinality
+limit](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk.md#cardinality-limits)
+is a throttling mechanism which allows the metrics collection system to have a
+predictable and reliable behavior when there is a cardinality explosion, be it
+due to a malicious attack or developer making mistakes while writing code.
+
+OpenTelemetry has a default cardinality limit of `2000` per metric. This limit
+can be configured at the individual metric level using the [View
+API](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk.md#view)
+leveraging the
+[`cardinality_limit`](https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/metrics/struct.Stream.html#structfield.cardinality_limit)
+setting.
+
+It's important to understand that this cardinality limit applies only at the
+OpenTelemetry SDK level, not to the ultimate cardinality of the metric as seen
+by the backend system. For example, while a single process might be limited to
+2000 attribute combinations per metric, the actual backend metrics system might
+see much higher cardinality due to:
+
+1. Resource attributes (such as `service.instance.id`, `host.name`, etc.) that
+   can be added to each metric
+2. Multiple process instances running the same application across your
+   infrastructure
+3. The possibility of reporting different key-value pair combinations in each
+   export interval, as the cardinality limit only applies to the number of
+   distinct attribute combinations tracked during a single export interval.
+   (This is only applicable to Delta temporality)
+
+Therefore, the actual cardinality in your metrics backend can be orders of
+magnitude higher than what any single OpenTelemetry SDK process handles in an
+export cycle.
+
+#### Cardinality Limits - Implications
+
+Cardinality limits are enforced for each export interval, meaning the metrics
+aggregation system only allows up to the configured cardinality limit of
+distinct attribute combinations per metric. Understanding how this works in
+practice is important:
+
+* **Cardinality Capping**: When the limit is reached within an export interval,
+  any new attribute combination is not individually tracked but instead folded
+  into a single aggregation with the attribute `{"otel.metric.overflow": true}`.
+  This preserves the overall accuracy of aggregates (such as Sum, Count, etc.)
+  even though information about specific attribute combinations is lost. Every
+  measurement is accounted for - either with its original attributes or within
+  the overflow bucket.
+
+* **Temporality Effects**: The impact of cardinality limits differs based on the
+  temporality mode:
+  
+  * **Delta Temporality**: The SDK "forgets" the state after each
+    collection/export cycle. This means in each new interval, the SDK can track
+    up to the cardinality limit of distinct attribute combinations. Over time,
+    your metrics backend might see far more than the configured limit of
+    distinct combinations from a single process.
+  
+  * **Cumulative Temporality**: Since the SDK maintains state across export
+    intervals, once the cardinality limit is reached, new attribute combinations
+    will continue to be folded into the overflow bucket. The total number of
+    distinct attribute combinations exported cannot exceed the cardinality limit
+    for the lifetime of that metric instrument.
+
+* **Impact on Monitoring**: While cardinality limits protect your system from
+  unbounded resource consumption, they do mean that high-cardinality attributes
+  may not be fully represented in your metrics. Since cardinality capping can
+  cause metrics to be folded into the overflow bucket, it becomes impossible to
+  predict which specific attribute combinations were affected across multiple
+  collection cycles or different service instances.
+
+  This unpredictability creates several important considerations when querying
+  metrics in any backend system:
+  
+  * **Total Accuracy**: OpenTelemetry Metrics always ensures the total
+    aggregation (sum of metric values across all attributes) remains accurate,
+    even when overflow occurs.
+  
+  * **Attribute-Based Query Limitations**: Any metric query based on specific
+    attributes could be misleading, as it's possible that measurements recorded
+    with a superset of those attributes were folded into the overflow bucket due
+    to cardinality capping.
+  
+  * **All Attributes Affected**: When overflow occurs, it's not just
+    high-cardinality attributes that are affected. The entire attribute
+    combination is replaced with the `{"otel.metric.overflow": true}` attribute,
+    meaning queries for any attribute in that combination will miss data points.
+
+#### Cardinality Limits - Example
+
+Extending our fruit sales tracking example, imagine we set a cardinality limit
+of 3 and we're tracking sales with attributes for `name`, `color`, and
+`store_location`:
+
+During a busy sales period at time (T3, T4], we record:
+  
+1. 10 red apples sold at Downtown store
+2. 5 yellow lemons sold at Uptown store
+3. 8 green apples sold at Downtown store
+4. 3 red apples sold at Midtown store (at this point, the cardinality limit is
+    hit, and attributes are replaced with overflow attribute.)
+
+The exported metrics would be:
+  
+* attributes: {color = `red`, name = `apple`, store_location = `Downtown`},
+    count: `10`
+* attributes: {color = `yellow`, name = `lemon`, store_location = `Uptown`},
+    count: `5`
+* attributes: {color = `green`, name = `apple`, store_location = `Downtown`},
+    count: `8`
+* attributes: {`otel.metric.overflow` = `true`}, count: `3` ← Notice this
+  special overflow attribute
+  
+  If we later query "How many red apples were sold?" the answer would be 10, not
+  13, because the Midtown sales were folded into the overflow bucket. Similarly,
+  queries about "How many items were sold in Midtown?" would return 0, not 3.
+  However, the total count across all attributes (i.e How many total fruits were
+  sold in (T3, T4] would correctly give 26) would be accurate.
+
+  This limitation applies regardless of whether the attribute in question is
+  naturally high-cardinality. Even low-cardinality attributes like "color"
+  become unreliable for querying if they were part of attribute combinations
+  that triggered overflow.
+
+  OpenTelemetry's cardinality capping is only applied to attributes provided
+  when reporting measurements via the [Metrics API](#metrics-api). In other
+  words, attributes used to create `Meter` or `Resource` attributes are not
+  subject to this cap.
+
+#### Cardinality Limits - How to Choose the Right Limit
+
+Choosing the right cardinality limit is crucial for maintaining efficient memory
+usage and predictable performance in your metrics system. The optimal limit
+depends on your temporality choice and application characteristics.
+
+Setting the limit incorrectly can have consequences:
+
+* **Limit too high**: Due to the SDK's [memory
+  preallocation](#memory-preallocation) strategy, excess memory will be
+  allocated upfront and remain unused, leading to resource waste.
+* **Limit too low**: Measurements will be folded into the overflow bucket
+  (`{"otel.metric.overflow": true}`), losing granular attribute information and
+  making attribute-based queries unreliable.
+
+Consider these guidelines when determining the appropriate limit:
+
+##### Choosing the Right Limit for Cumulative Temporality
+
+Cumulative metrics retain every unique attribute combination that has *ever*
+been observed since the start of the process.
+
+* You must account for the theoretical maximum number of attribute combinations.
+* This can be estimated by multiplying the number of possible values for each
+  attribute.
+* If certain attribute combinations are invalid or will never occur in practice,
+  you can reduce the limit accordingly.
+
+###### Example - Fruit Sales Scenario
+
+Attributes:
+
+* `name` can be "apple" or "lemon" (2 values)
+* `color` can be "red", "yellow", or "green" (3 values)
+
+The theoretical maximum is 2 × 3 = 6 unique attribute sets.
+
+For this example, the simplest approach is to use the theoretical maximum and **set the cardinality limit to 6**.
+
+However, if you know that certain combinations will never occur (for example, if "red lemons" don't exist in your application domain), you could reduce the limit to only account for valid combinations. In this case, if only 5 combinations are valid, **setting the cardinality limit to 5** would be more memory-efficient.
+
+##### Choosing the Right Limit for Delta Temporality
+
+Delta metrics reset their aggregation state after every export interval. This
+approach enables more efficient memory utilization by focusing only on attributes
+observed during each interval rather than maintaining state for all combinations.
+
+* **When attributes are low-cardinality** (as in the fruit example), use the
+  same calculation method as with cumulative temporality.
+* **When high-cardinality attribute(s) exist** like `user_id`, leverage Delta
+  temporality's "forget state" nature to set a much lower limit based on active
+  usage patterns. This is where Delta temporality truly excels - when the set of
+  active values changes dynamically and only a small subset is active during any
+  given interval.
+
+###### Example - High Cardinality Attribute Scenario
+
+Export interval: 60 sec
+
+Attributes:
+
+* `user_id` (up to 1 million unique users)
+* `success` (true or false, 2 values)
+
+Theoretical limit: 1 million users × 2 = 2 million attribute sets
+
+But if only 10,000 users are typically active during a 60 sec export interval:
+10,000 × 2 = 20,000
+
+**You can set the limit to 20,000, dramatically reducing memory usage during
+normal operation.**
+
+###### Export Interval Tuning
+
+Shorter export intervals further reduce the required cardinality:
+
+* If your interval is halved (e.g., from 60 sec to 30 sec), the number of unique
+  attribute sets seen per interval may also be halved.
+
+> [!NOTE] More frequent exports increase CPU/network overhead due to
+> serialization and transmission costs.
+
+##### Choosing the Right Limit - Backend Considerations
+
+While delta temporality offers certain advantages for cardinality management,
+your choice may be constrained by backend support:
+
+* **Backend Restrictions:** Some metrics backends only support cumulative
+  temporality. For example, Prometheus requires cumulative temporality and
+  cannot directly consume delta metrics.
+* **Collector Conversion:** To leverage delta temporality's memory advantages
+  while maintaining backend compatibility, configure your SDK to use delta
+  temporality and deploy an OpenTelemetry Collector with a delta-to-cumulative
+  conversion processor. This approach pushes the memory overhead from your
+  application to the collector, which can be more easily scaled and managed
+  independently.
+
+TODO: Add the memory cost incurred by each data points, so users can know the
+memory impact of setting a higher limits.
+
+TODO: Add example of how query can be affected when overflow occurs, use
+[Aspire](https://github.com/dotnet/aspire/pull/7784) tool.
+
+### Memory Preallocation
+
+OpenTelemetry Rust SDK aims to avoid memory allocation on the hot code path.
+When this is combined with [proper use of Metrics API](#metrics-api), heap
+allocation can be avoided on the hot code path.
+
+## Metrics Correlation
+
+Including `TraceId` and `SpanId` as attributes in metrics might seem like an
+intuitive way to achieve correlation with traces or logs. However, this approach
+is ineffective and can make metrics practically unusable. Moreover, it can
+quickly lead to cardinality issues, resulting in metrics being capped.
+
+A better alternative is to use a concept in OpenTelemetry called
+[Exemplars](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk.md#exemplar).
+Exemplars provide a mechanism to correlate metrics with traces by sampling
+specific measurements and attaching trace context to them.
+
+> [!NOTE] Currently, exemplars are not yet implemented in the OpenTelemetry Rust
+> SDK.
+
+## Modelling Metric Attributes
+
+When metrics are being collected, they normally get stored in a [time series
+database](https://en.wikipedia.org/wiki/Time_series_database). From storage and
+consumption perspective, metrics can be multi-dimensional. Taking the [fruit
+example](#example), there are two attributes - "name" and "color". For basic
+scenarios, all the attributes can be reported during the [Metrics
+API](#metrics-api) invocation, however, for less trivial scenarios, the
+attributes can come from different sources:
+
+* [Measurements](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#measurement)
+  reported via the [Metrics API](#metrics-api).
+* Additional attributes provided at meter creation time via
+  [`meter_with_scope`](https://docs.rs/opentelemetry/latest/opentelemetry/metrics/trait.MeterProvider.html#tymethod.meter_with_scope).
+* [Resources](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/resource/sdk.md)
+  configured at the `MeterProvider` level.
+* Additional attributes provided by the collector. For example, [jobs and
+  instances](https://prometheus.io/docs/concepts/jobs_instances/) in Prometheus.
+
+### Best Practices for Modeling Attributes
+
+Follow these guidelines when deciding where to attach metric attributes:
+
+* **For static attributes** (constant throughout the process lifetime):
+  * **Resource-level attributes**: If the dimension applies to all metrics
+    (e.g., hostname, datacenter), model it as a Resource attribute, or better
+    yet, let the collector add these automatically.
+
+    ```rust
+    // Example: Setting resource-level attributes
+    let resource = Resource::new(vec![
+        KeyValue::new("service.name", "payment-processor"),
+        KeyValue::new("deployment.environment", "production"),
+    ]);
+    ```
+
+  * **Meter-level attributes**: If the dimension applies only to a subset of
+    metrics (e.g., library version), model it as meter-level attributes via
+    `meter_with_scope`.
+
+    ```rust
+    // Example: Setting meter-level attributes
+    let scope = InstrumentationScope::builder("payment_library")
+        .with_version("1.2.3")
+        .with_attributes([KeyValue::new("payment.gateway", "stripe")])
+        .build();
+    let meter = global::meter_with_scope(scope);
+    ```
+
+* **For dynamic attributes** (values that change during execution):
+  * Report these via the Metrics API with each measurement.
+  * Be mindful that [cardinality limits](#cardinality-limits) apply to these
+    attributes.
+
+    ```rust
+    // Example: Using dynamic attributes with each measurement
+    counter.add(1, &[
+        KeyValue::new("customer.tier", customer.tier),
+        KeyValue::new("transaction.status", status.to_string()),
+    ]);
+    ```
+
+## Common issues that lead to missing metrics
+
+Common pitfalls that can result in missing metrics include:
+
+1. **Invalid instrument names** - OpenTelemetry will not collect metrics from
+   instruments using invalid names. See the [specification for valid
+   syntax](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#instrument-name-syntax).
+
+2. **Not calling `shutdown` on the MeterProvider** - Ensure you properly call
+   `shutdown` at application termination to flush any pending metrics.
+
+3. **Cardinality explosion** - When too many unique attribute combinations are
+   used, some metrics may be placed in the overflow bucket.
+
+// TODO: Add more specific examples
+
+## References
+
+[OTel Metrics Specification - Supplementary Guidelines](https://opentelemetry.io/docs/specs/otel/metrics/supplementary-guidelines/)

docs/migration_0.28.md

@@ -0,0 +1,187 @@
+# Migration guide from 0.27 to 0.28
+
+OpenTelemetry Rust 0.28 introduces a large number of breaking changes that
+impact all signals (logs/metrics/traces). This guide is intended to help with a
+smooth migration for the common use cases of using `opentelemetry`,
+`opentelemetry_sdk` `opentelemetry-otlp`, `opentelemetry-appender-tracing`
+crates. The detailed changelog for each crate that you use can be consulted for
+the full set of changes. This doc covers only the common scenario.
+
+## Tracing Shutdown changes
+
+`opentelemetry::global::shutdown_tracer_provider()` is removed. Now, you should
+explicitly call shutdown() on the created tracer provider.
+
+Before (0.27):
+
+```rust
+opentelemetry::global::shutdown_tracer_provider();
+```
+
+ After (0.28):
+
+```rust
+let tracer_provider = opentelemetry_sdk::trace::SdkTracerProvider::builder()
+    .build();
+
+// Clone and set the tracer provider globally. Retain the original to invoke shutdown later.
+opentelemetry::global::set_tracer_provider(tracer_provider.clone());
+
+// Shutdown the provider when application is exiting.
+tracer_provider.shutdown();
+```
+
+This now makes shutdown consistent across signals.
+
+## Rename SDK Structs
+
+`LoggerProvider`, `TracerProvider` are renamed to `SdkLoggerProvider` and
+`SdkTracerProvider` respectively. `MeterProvider` was already named
+`SdkMeterProvider` and this now ensures consistency across signals.
+
+### Async Runtime Requirements removed
+
+When using OTLP Exporter for Logs, Traces a "batching" exporter is recommended.
+Also, metrics always required a component named `PeriodicReader`. These
+components previously needed user to pass in an async runtime and enable
+appropriate feature flag depending on the runtime.
+
+These components have been re-written to no longer require an async runtime.
+Instead they operate by spawning dedicated background thread, and making
+blocking calls from the same.
+
+PeriodicReader, BatchSpanProcessor, BatchLogProcessor are the components
+affected.
+
+For Logs,Traces replace `.with_batch_exporter(exporter, runtime::Tokio)` with
+`.with_batch_exporter(exporter)`.
+
+For Metrics, replace `let reader =
+PeriodicReader::builder(exporter, runtime::Tokio).build();` with `let reader =
+PeriodicReader::builder(exporter).build();` or more conveniently,
+`.with_periodic_exporter(exporter)`.
+
+Please note the following:
+
+* With the new approach, only the following grpc/http clients are supported in
+   `opentelemetry-otlp`.
+
+   `grpc-tonic` (OTLP
+   Exporter must be created from within a Tokio runtime)
+
+   `reqwest-blocking-client`
+  
+  In other words,
+   `reqwest` and `hyper` are not supported.
+   If using exporters other than `opentelemetry-otlp`, consult the docs
+   for the same to know if there are any restrictions/requirements on async
+   runtime.
+
+* Timeout enforcement is now moved to Exporters. i.e
+BatchProcessor,PeriodicReader does not enforce timeouts. For logs and traces,
+`max_export_timeout` (on Processors) or `OTEL_BLRP_EXPORT_TIMEOUT` or
+`OTEL_BSP_EXPORT_TIMEOUT` is no longer supported. For metrics, `with_timeout` on
+PeriodicReader is no longer supported.
+
+  `OTEL_EXPORTER_OTLP_TIMEOUT` can be used to setup timeout for OTLP Exporters
+  via environment variables, or `.with_tonic().with_timeout()` or
+  `.with_http().with_timeout()` programmatically.
+
+* If you need the old behavior (your application cannot spawn a new thread, or
+need to use another networking client etc.) use appropriate feature flag(s) from
+  below.
+   “experimental_metrics_periodicreader_with_async_runtime”
+  "experimental_logs_batch_log_processor_with_async_runtime"
+  "experimental_trace_batch_span_processor_with_async_runtime"
+
+ **and** adjust the namespace:
+
+ Example, when using Tokio runtime.
+
+ ```rust
+let reader = opentelemetry_sdk::metrics::periodic_reader_with_async_runtime::PeriodicReader::builder(exporter, runtime::Tokio).build();
+let tracer_provider = SdkTracerProvider::builder()
+        .with_span_processor(span_processor_with_async_runtime::BatchSpanProcessor::builder(exporter, runtime::Tokio).build())
+        .build();
+let logger_provider = SdkLoggerProvider::builder()
+.with_log_processor(log_processor_with_async_runtime::BatchLogProcessor::builder(exporter, runtime::Tokio).build())
+.build();
+```
+
+## OTLP Default change
+
+"grpc-tonic" feature flag is no longer enabled by default in
+`opentelemetry-otlp`. "http-proto" and "reqwest-blocking-client" features are
+added as default, to align with the OTel specification.
+
+## Resource Changes
+
+`Resource` creation is moved to a builder pattern, and `Resource::{new, empty,
+from_detectors, new_with_defaults, from_schema_url, merge, default}` are
+replaced with `Resource::builder()`.
+
+Before:
+
+```rust
+Resource::default().with_attributes([
+    KeyValue::new("service.name", "test_service"),
+    KeyValue::new("key", "value"),
+]);
+```
+
+After:
+
+```rust
+Resource::builder()
+    .with_service_name("test_service")
+    .with_attribute(KeyValue::new("key", "value"))
+    .build();
+```
+
+## Improved internal logging
+
+OpenTelemetry internally used `tracing` to emit its internal logs. This is under
+feature-flag "internal-logs" that is enabled by default in all crates. When
+using OTel Logging, care must be taken to avoid OTel's own internal log being
+fed back to OTel, creating an circular dependency. This can be achieved via proper
+filtering. The OTLP Examples in the repo shows how to achieve this. It also
+shows how to send OTel's internal logs to stdout using `tracing::Fmt`.
+
+## Full example
+
+A fully runnable example application using OTLP Exporter is provided in this
+repo. Comparing the 0.27 vs 0.28 of the example would give a good overview of
+the changes required to be made.
+
+[Basic OTLP Example
+(0.27)](https://github.com/open-telemetry/opentelemetry-rust/tree/opentelemetry-otlp-0.27.0/opentelemetry-otlp/examples)
+[Basic OTLP Example
+(0.28)](https://github.com/open-telemetry/opentelemetry-rust/tree/opentelemetry-otlp-0.28.0/opentelemetry-otlp/examples)
+
+This guide covers only the most common breaking changes. If you’re using custom
+exporters or processors (or authoring one), please consult the changelog for
+additional migration details.
+
+## Notes on Breaking Changes and the Path to 1.0
+
+We understand that breaking changes can be challenging, but they are essential
+for the growth and stability of the project. With the release of 0.28, the
+Metric API (`opentelemetry` crate, "metrics" feature flag) and LogBridge API
+(`opentelemetry` crate, "logs" feature flag) are now stable, and we do not
+anticipate further breaking changes for these components.
+
+Moreover, the `opentelemetry_sdk` crate for "logs" and "metrics" will have a
+very high bar for any future breaking changes. Any changes are expected to
+primarily impact those developing custom components, such as custom exporters.
+In the upcoming releases, we aim to bring the "traces" feature to the same level
+of stability as "logs" and "metrics". Additionally, "opentelemetry-otlp", the
+official exporter, will also receive stability guarantees.
+
+We are excited to announce that a 1.0 release, encompassing logs, metrics, and
+traces, is planned for June 2025. We appreciate your patience and support as we
+work towards this milestone. The 1.0 release will cover the API
+(`opentelemetry`), SDK (`opentelemetry_sdk`), OTLP Exporter
+(`opentelemetry-otlp`), and Tracing-Bridge (`opentelemetry-appender-tracing`).
+
+We encourage you to share your feedback via GitHub issues or the OTel-Rust Slack
+channel [here](https://cloud-native.slack.com/archives/C03GDP0H023).

docs/migration_0.29.md

@@ -0,0 +1,92 @@
+# Migration Guide from 0.28 to 0.29
+
+OpenTelemetry Rust 0.29 introduces a few breaking changes. This guide aims to
+facilitate a smooth migration for common use cases involving the
+`opentelemetry`, `opentelemetry_sdk`, `opentelemetry-otlp`, and
+`opentelemetry-appender-tracing` crates. For a comprehensive list of changes,
+please refer to the detailed changelog for each crate. This document covers only
+the most common scenarios. Note that changes that only affect custom
+exporter/processor authors are not mentioned in this doc.
+
+OpenTelemetry Metrics API and Log-Bridge API were declared stable in 0.28, and have
+no breaking changes.
+
+## Baggage Changes
+
+The Baggage API has been redesigned to align with the OpenTelemetry
+specification. While the core API for interacting with Baggage remains the same,
+the accepted data types have changed. Baggage Keys now only allow strings (ASCII
+printable characters), and Baggage values are restricted to strings.
+
+For detailed changes, see the [changelog](../opentelemetry/CHANGELOG.md). With
+version 0.29, the Baggage API has reached "Release Candidate" status, meaning
+further breaking changes will be highly restricted.
+
+## Appender-Tracing Changes
+
+The `opentelemetry-appender-tracing` crate, which bridges `tracing` events to
+OpenTelemetry logs, has been updated to properly map `tracing` data types to the
+OpenTelemetry model. As of version 0.29, this crate is considered "Stable," and
+no further breaking changes will be made without a major version bump.
+
+## Configuration via Environment Variables
+
+The 0.29 release aligns OpenTelemetry Rust with the rest of the OpenTelemetry
+ecosystem by treating any code-based configuration as final (i.e., it cannot be
+overridden by environment variables). This policy was partially true before but
+is now applied consistently. If you prefer to configure your application via
+environment variables, avoid configuring it programmatically.
+
+## Discontinuing Dedicated Prometheus Exporter
+
+The `opentelemetry-prometheus` crate will be discontinued with the 0.29 release.
+Active development on this crate ceased a few months ago. Given that Prometheus
+now natively supports OTLP, and considering that the OpenTelemetry Rust project
+is still working towards a 1.0 release, we need to focus on essential components
+to maintain scope and ensure timely delivery.
+
+Prometheus interoperability remains a key goal for OpenTelemetry. However, the
+current `opentelemetry-prometheus` crate requires a major rewrite to eliminate
+dependencies on unmaintained crates. We may reintroduce a dedicated Prometheus
+exporter in the future once these issues are resolved.
+
+### Migration Guide
+
+For those using Prometheus as a backend, you can integrate with Prometheus using
+the following methods:
+
+1. Use the OTLP Exporter to push metrics directly to Prometheus.
+2. If you require a pull (scrape) model, push metrics to an OpenTelemetry
+   Collector using the OTLP Exporter, and configure Prometheus to scrape the
+   OpenTelemetry Collector.
+
+These alternatives ensure continued Prometheus integration while allowing us to
+focus on achieving a stable 1.0 release for OpenTelemetry Rust.
+
+## Next Release
+
+In the [next
+release](https://github.com/open-telemetry/opentelemetry-rust/milestone/21), we
+expect to stabilize the Metrics SDK and resolve the long-standing question of
+`tokio-tracing` vs. `opentelemetry tracing`, which is a prerequisite before
+stabilizing Distributed Tracing. Additionally, `Context` is also expected to be
+enhanced with the ability to suppress telemetry-induced-telemetry.
+
+## Instrumentation Libraries
+
+Unlike other OpenTelemetry language implementations, OpenTelemetry Rust historically did not
+maintain any instrumentations directly. This has recently changed with a
+[contribution](https://github.com/open-telemetry/opentelemetry-rust-contrib/pull/202)
+from one of the founding members of the OpenTelemetry Rust project to the
+contrib repository, providing an instrumentation library for
+[`actix-web`](https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/opentelemetry-instrumentation-actix-web).
+We expect that this instrumentation will serve as a reference implementation demonstrating best practices for
+creating OpenTelemetry instrumentations in Rust.
+
+We welcome additional contributions of instrumentation libraries to the contrib repository.
+
+## Thanks
+
+Thank you to everyone who contributed to this milestone. Please share your feedback
+through GitHub issues or join the discussion in the OTel-Rust Slack channel
+[here](https://cloud-native.slack.com/archives/C03GDP0H023).

docs/release_0.30.md

@@ -0,0 +1,68 @@
+# Release Notes 0.30
+
+OpenTelemetry Rust 0.30 introduces a few breaking changes to the
+`opentelemetry_sdk` crate in the `metrics` feature. These changes were essential
+to drive the Metrics SDK towards stability. With this release, the Metrics SDK
+is officially declared stable. The Metrics API was declared stable last year,
+and previously, the Logs API, SDK, and OTel-Appender-Tracing were also marked
+stable. Importantly, no breaking changes have been introduced to components
+already marked as stable.
+
+It is worth noting that the `opentelemetry-otlp` crate remains in a
+Release-Candidate state and is not yet considered stable. With the API and SDK
+for Logs and Metrics now stable, the focus will shift towards further refining
+and stabilizing the OTLP Exporters in upcoming releases. Additionally,
+Distributed Tracing is expected to progress towards stability, addressing key
+interoperability challenges.
+
+For detailed changelogs of individual crates, please refer to their respective
+changelog files. This document serves as a summary of the main changes.
+
+## Key Changes
+
+### Metrics SDK Improvements
+
+1. **Stabilized "view" features**: Previously under an experimental feature
+   flag, views can now be used to modify the name, unit, description, and
+   cardinality limit of a metric. Advanced view capabilities, such as changing
+   aggregation or dropping attributes, remain under the experimental feature
+   flag.
+
+2. **Cardinality capping**: Introduced the ability to cap cardinality and
+   configure limits using views.
+
+3. **Polished public API**: Refined the public API to hide implementation
+   details from exporters, enabling future internal optimizations and ensuring
+   consistency. Some APIs related to authoring custom metric readers have been
+   moved behind experimental feature flags. These advanced use cases require
+   more time to finalize the API surface before being included in the stable
+   release.
+
+### Context-Based Suppression
+
+Added the ability to suppress telemetry based on Context. This feature prevents
+telemetry-induced-telemetry scenarios and addresses a long-standing issue. Note
+that suppression relies on proper context propagation. Certain libraries used in
+OTLP Exporters utilize `tracing` but do not adopt OpenTelemetry's context
+propagation. As a result, not all telemetry is automatically suppressed with
+this feature. Improvements in this area are expected in future releases.
+
+## Next Release
+
+In the [next
+release](https://github.com/open-telemetry/opentelemetry-rust/milestone/22), the
+focus will shift to OTLP Exporters and Distributed Tracing, specifically
+resolving
+[interoperability](https://github.com/open-telemetry/opentelemetry-rust/issues/2420)
+issues with `tokio-tracing` and other fixes required to drive Distributed
+Tracing towards stability.
+
+## Acknowledgments
+
+Thank you to everyone who contributed to this milestone. We welcome your
+feedback through GitHub issues or discussions in the OTel-Rust Slack channel
+[here](https://cloud-native.slack.com/archives/C03GDP0H023).
+
+We are also excited to announce that [Anton Grübel](https://github.com/gruebel)
+and [Björn Antonsson](https://github.com/bantonsson) have joined the OTel Rust
+project as Approvers.

examples/README.md

@@ -1,41 +1,67 @@
 # Examples
-This folder contains some examples that should help you get start crates from `opentelemetry-rust`.
+
+This directory contains some examples that should help you get start crates from `opentelemetry-rust`.
 
 ## log-basic
-**Logs**
 
 This example uses following crates from this repo:
+
 - opentelemetry(log)
-- opentelemetry-appender-log
+- opentelemetry-appender-tracing
 - opentelemetry-stdout
 
 Check this example if you want to understand *how to instrument logs using opentelemetry*.
 
 ## metrics-basic
-**Metrics**
 
 This example uses following crates from this repo:
+
 - opentelemetry(metrics)
 - opentelemetry-stdout
 
 Check this example if you want to understand *how to instrument metrics using opentelemetry*.
 
-## traceresponse
-**Tracing**
+## metrics-advanced
 
 This example uses following crates from this repo:
-- opentelemetry(tracing)
-- opentelemetry-http
-- opentelemetry-contrib(TraceContextResponsePropagator)
+
+- opentelemetry(metrics)
 - opentelemetry-stdout
 
+This builds on top of the metrics-basic,
+and shows advanced features in Metrics SDK like using Views.
+
 ## tracing-grpc
-**Tracing**
 
 This example uses following crates from this repo:
+
 - opentelemetry(tracing)
-- opentelemetry-jaeger
+- opentelemetry-stdout
 
 The application is built using `tokio`.
 
-Check this example if you want to understand *how to integrate tracing with opentelemetry*.
+Check this example if you want to understand *how to create spans and
+propagate/restore context in OpenTelemetry* in a gRPC client-server application.
+
+## tracing-http-propagator
+
+This example uses following crates from this repo:
+
+- opentelemetry(tracing)
+- opentelemetry-http
+- opentelemetry-stdout
+
+Check this example if you want to understand *how to create spans and
+propagate/restore context in OpenTelemetry* in an HTTP client-server
+application.
+
+## tracing-jaeger
+
+This example uses following crates from this repo:
+
+- opentelemetry(tracing)
+- opentelemetry-otlp
+
+The application is built using `tokio`.
+
+Check this example if you want to understand *how to use OTLP Exporter to export traces to Jaeger*.

examples/logs-basic/Cargo.toml

@@ -3,11 +3,18 @@ name = "logs-basic"
 version = "0.1.0"
 edition = "2021"
 license = "Apache-2.0"
+rust-version = "1.75.0"
 publish = false
+autobenches = false
+
+[[bin]]
+name = "logs-basic"
+path = "src/main.rs"
+bench = false
 
 [dependencies]
-opentelemetry_api = { path = "../../opentelemetry-api", features = ["logs"] }
 opentelemetry_sdk = { path = "../../opentelemetry-sdk", features = ["logs"] }
-opentelemetry-stdout = { path = "../../opentelemetry-stdout", features = ["logs"]}
-opentelemetry-appender-log = { path = "../../opentelemetry-appender-log"}
-log = {version = "0.4.17"}
+opentelemetry-stdout = { workspace = true, features = ["logs"] }
+opentelemetry-appender-tracing = { workspace = true }
+tracing = { workspace = true, features = ["std"]}
+tracing-subscriber = { workspace = true, features = ["env-filter","registry", "std", "fmt"] }

examples/logs-basic/README.md

@@ -1,16 +1,17 @@
-# Log Appender for API -  Example
+# OpenTelemetry Log Appender for tracing -  Example
 
-This example shows how to use the opentelemetry-appender-log crate, which is a
-[logging appender](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/glossary.md#log-appender--bridge) that bridges logs from the [log crate](https://docs.rs/log/latest/log/) to OpenTelemetry.
-The example setups a LoggerProvider with stdout exporter, so logs are emitted to stdout.
+This example shows how to use the opentelemetry-appender-tracing crate, which is a
+[logging
+appender](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/glossary.md#log-appender--bridge)
+that bridges logs from the [tracing crate](https://tracing.rs/tracing/#events) to
+OpenTelemetry. The example setups a LoggerProvider with stdout exporter, so logs
+are emitted to stdout.
 
 ## Usage
 
-Run the following, and Logs emitted using [log](https://docs.rs/log/latest/log/) will be written out to stdout.
+Run the following, and Logs emitted using [tracing](https://docs.rs/tracing/latest/tracing/)
+will be written out to stdout.
 
 ```shell
-$ cargo run
+cargo run
 ```
-
-
-

examples/logs-basic/src/main.rs

@@ -1,28 +1,53 @@
-use log::{error, Level};
-use opentelemetry_api::KeyValue;
-use opentelemetry_appender_log::OpenTelemetryLogBridge;
-use opentelemetry_sdk::logs::{Config, LoggerProvider};
+use opentelemetry_appender_tracing::layer;
+use opentelemetry_sdk::logs::SdkLoggerProvider;
 use opentelemetry_sdk::Resource;
+use tracing::error;
+use tracing_subscriber::{prelude::*, EnvFilter};
 
 fn main() {
-    // Setup LoggerProvider with a stdout exporter
     let exporter = opentelemetry_stdout::LogExporter::default();
-    let logger_provider = LoggerProvider::builder()
-        .with_config(
-            Config::default().with_resource(Resource::new(vec![KeyValue::new(
-                "service.name",
-                "logs-basic-example",
-            )])),
+    let provider: SdkLoggerProvider = SdkLoggerProvider::builder()
+        .with_resource(
+            Resource::builder()
+                .with_service_name("log-appender-tracing-example")
+                .build(),
         )
         .with_simple_exporter(exporter)
         .build();
 
-    // Setup Log Appender for the log crate.
-    let otel_log_appender = OpenTelemetryLogBridge::new(&logger_provider);
-    log::set_boxed_logger(Box::new(otel_log_appender)).unwrap();
-    log::set_max_level(Level::Error.to_level_filter());
+    // To prevent a telemetry-induced-telemetry loop, OpenTelemetry's own internal
+    // logging is properly suppressed. However, logs emitted by external components
+    // (such as reqwest, tonic, etc.) are not suppressed as they do not propagate
+    // OpenTelemetry context. Until this issue is addressed
+    // (https://github.com/open-telemetry/opentelemetry-rust/issues/2877),
+    // filtering like this is the best way to suppress such logs.
+    //
+    // The filter levels are set as follows:
+    // - Allow `info` level and above by default.
+    // - Completely restrict logs from `hyper`, `tonic`, `h2`, and `reqwest`.
+    //
+    // Note: This filtering will also drop logs from these components even when
+    // they are used outside of the OTLP Exporter.
+    let filter_otel = EnvFilter::new("info")
+        .add_directive("hyper=off".parse().unwrap())
+        .add_directive("tonic=off".parse().unwrap())
+        .add_directive("h2=off".parse().unwrap())
+        .add_directive("reqwest=off".parse().unwrap());
+    let otel_layer = layer::OpenTelemetryTracingBridge::new(&provider).with_filter(filter_otel);
 
-    // Emit logs using macros from the log crate.
-    // These logs gets piped through OpenTelemetry bridge and gets exported to stdout.
-    error!(target: "my-target", "hello from {}. My price is {}", "apple", 2.99);
+    // Create a new tracing::Fmt layer to print the logs to stdout. It has a
+    // default filter of `info` level and above, and `debug` and above for logs
+    // from OpenTelemetry crates. The filter levels can be customized as needed.
+    let filter_fmt = EnvFilter::new("info").add_directive("opentelemetry=debug".parse().unwrap());
+    let fmt_layer = tracing_subscriber::fmt::layer()
+        .with_thread_names(true)
+        .with_filter(filter_fmt);
+
+    tracing_subscriber::registry()
+        .with(otel_layer)
+        .with(fmt_layer)
+        .init();
+
+    error!(name: "my-event-name", target: "my-system", event_id = 20, user_name = "otel", user_email = "otel@opentelemetry.io", message = "This is an example message");
+    let _ = provider.shutdown();
 }

examples/metrics-advanced/Cargo.toml

@@ -3,10 +3,17 @@ name = "metrics-advanced"
 version = "0.1.0"
 edition = "2021"
 license = "Apache-2.0"
+rust-version = "1.75.0"
 publish = false
+autobenches = false
+
+[[bin]]
+name = "metrics-advanced"
+path = "src/main.rs"
+bench = false
 
 [dependencies]
-opentelemetry_api = { path = "../../opentelemetry-api", features = ["metrics"] }
-opentelemetry_sdk = { path = "../../opentelemetry-sdk", features = ["metrics", "rt-tokio"] }
-opentelemetry-stdout = { path = "../../opentelemetry-stdout", features = ["metrics"]}
-tokio = { version = "1.0", features = ["full"] }
+opentelemetry = { path = "../../opentelemetry", features = ["metrics"] }
+opentelemetry_sdk = { path = "../../opentelemetry-sdk" }
+opentelemetry-stdout = { workspace = true, features = ["metrics"] }
+tokio = { workspace = true, features = ["full"] }

examples/metrics-advanced/README.md

@@ -12,6 +12,3 @@ Run the following, and the Metrics will be written out to stdout.
 ```shell
 $ cargo run
 ```
-
-
-

examples/metrics-advanced/src/main.rs

@@ -1,18 +1,19 @@
-use opentelemetry_api::metrics::Unit;
-use opentelemetry_api::Key;
-use opentelemetry_api::{metrics::MeterProvider as _, KeyValue};
-use opentelemetry_sdk::metrics::{Instrument, MeterProvider, PeriodicReader, Stream};
-use opentelemetry_sdk::{runtime, Resource};
+use opentelemetry::global;
+use opentelemetry::KeyValue;
+use opentelemetry_sdk::metrics::{Instrument, SdkMeterProvider, Stream, Temporality};
+use opentelemetry_sdk::Resource;
 use std::error::Error;
 
-fn init_meter_provider() -> MeterProvider {
+fn init_meter_provider() -> opentelemetry_sdk::metrics::SdkMeterProvider {
     // for example 1
     let my_view_rename_and_unit = |i: &Instrument| {
-        if i.name == "my_histogram" {
+        if i.name() == "my_histogram" {
             Some(
-                Stream::new()
-                    .name("my_histogram_renamed")
-                    .unit(Unit::new("milliseconds")),
+                Stream::builder()
+                    .with_name("my_histogram_renamed")
+                    .with_unit("milliseconds")
+                    .build()
+                    .unwrap(),
             )
         } else {
             None
@@ -20,31 +21,41 @@ fn init_meter_provider() -> MeterProvider {
     };
 
     // for example 2
-    let my_view_drop_attributes = |i: &Instrument| {
-        if i.name == "my_counter" {
-            Some(Stream::new().allowed_attribute_keys(vec![Key::from("mykey1")]))
+    let my_view_change_cardinality = |i: &Instrument| {
+        if i.name() == "my_second_histogram" {
+            // Note: If Stream is invalid, build() will return an error. By
+            // calling `.ok()`, any such error is ignored and treated as if the
+            // view does not match the instrument. If this is not the desired
+            // behavior, consider handling the error explicitly.
+            Stream::builder().with_cardinality_limit(2).build().ok()
         } else {
             None
         }
     };
 
-    let exporter = opentelemetry_stdout::MetricsExporter::default();
-    let reader = PeriodicReader::builder(exporter, runtime::Tokio).build();
-    MeterProvider::builder()
-        .with_reader(reader)
-        .with_resource(Resource::new(vec![KeyValue::new(
-            "service.name",
-            "metrics-advanced-example",
-        )]))
+    // Build exporter using Delta Temporality.
+    let exporter = opentelemetry_stdout::MetricExporterBuilder::default()
+        .with_temporality(Temporality::Delta)
+        .build();
+
+    let resource = Resource::builder()
+        .with_service_name("metrics-advanced-example")
+        .build();
+
+    let provider = SdkMeterProvider::builder()
+        .with_periodic_exporter(exporter)
+        .with_resource(resource)
         .with_view(my_view_rename_and_unit)
-        .with_view(my_view_drop_attributes)
-        .build()
+        .with_view(my_view_change_cardinality)
+        .build();
+    global::set_meter_provider(provider.clone());
+    provider
 }
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     let meter_provider = init_meter_provider();
-    let meter = meter_provider.meter("mylibraryname");
+    let meter = global::meter("mylibraryname");
 
     // Example 1 - Rename metric using View.
     // This instrument will be renamed to "my_histogram_renamed",
@@ -52,43 +63,58 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     // using view.
     let histogram = meter
         .f64_histogram("my_histogram")
-        .with_unit(Unit::new("ms"))
+        .with_unit("ms")
         .with_description("My histogram example description")
-        .init();
+        .build();
 
     // Record measurements using the histogram instrument.
     histogram.record(
         10.5,
-        [
+        &[
             KeyValue::new("mykey1", "myvalue1"),
             KeyValue::new("mykey2", "myvalue2"),
             KeyValue::new("mykey3", "myvalue3"),
             KeyValue::new("mykey4", "myvalue4"),
-        ]
-        .as_ref(),
+        ],
     );
 
-    // Example 2 - Drop unwanted attributes using view.
-    let counter = meter.u64_counter("my_counter").init();
+    // Example 2 - Change cardinality using View.
+    let histogram2 = meter
+        .f64_histogram("my_second_histogram")
+        .with_unit("ms")
+        .with_description("My histogram example description")
+        .build();
 
-    // Record measurements using the Counter instrument.
-    // Though we are passing 4 attributes here, only 1 will be used
-    // for aggregation as view is configured to use only "mykey1"
-    // attribute.
-    counter.add(
-        10,
-        [
-            KeyValue::new("mykey1", "myvalue1"),
-            KeyValue::new("mykey2", "myvalue2"),
-            KeyValue::new("mykey3", "myvalue3"),
-            KeyValue::new("mykey4", "myvalue4"),
-        ]
-        .as_ref(),
-    );
+    // Record measurements using the histogram instrument. This metric will have
+    // a cardinality limit of 2, as set in the view. Because of this, only the
+    // first two distinct attribute combinations will be recorded, and the rest
+    // will be folded into the overflow attribute. Any number of measurements
+    // can be recorded as long as they use the same or already-seen attribute
+    // combinations.
+    histogram2.record(1.5, &[KeyValue::new("mykey1", "v1")]);
+    histogram2.record(1.2, &[KeyValue::new("mykey1", "v2")]);
 
-    // Metrics are exported by default every 30 seconds when using stdout exporter,
+    // Repeatedly emitting measurements for "v1" and "v2" will not
+    // trigger overflow, as they are already seen attribute combinations.
+    histogram2.record(1.7, &[KeyValue::new("mykey1", "v1")]);
+    histogram2.record(1.8, &[KeyValue::new("mykey1", "v2")]);
+
+    // Emitting measurements for new attribute combinations will trigger
+    // overflow, as the cardinality limit of 2 has been reached.
+    // All the below measurements will be folded into the overflow attribute.
+    histogram2.record(1.23, &[KeyValue::new("mykey1", "v3")]);
+
+    histogram2.record(1.4, &[KeyValue::new("mykey1", "v4")]);
+
+    histogram2.record(1.6, &[KeyValue::new("mykey1", "v5")]);
+
+    histogram2.record(1.7, &[KeyValue::new("mykey1", "v6")]);
+
+    histogram2.record(1.8, &[KeyValue::new("mykey1", "v7")]);
+
+    // Metrics are exported by default every 60 seconds when using stdout exporter,
     // however shutting down the MeterProvider here instantly flushes
-    // the metrics, instead of waiting for the 30 sec interval.
+    // the metrics, instead of waiting for the 60 sec interval.
     meter_provider.shutdown()?;
     Ok(())
 }

examples/metrics-basic/Cargo.toml

@@ -3,10 +3,18 @@ name = "metrics-basic"
 version = "0.1.0"
 edition = "2021"
 license = "Apache-2.0"
+rust-version = "1.75.0"
 publish = false
+autobenches = false
+
+[[bin]]
+name = "metrics-basic"
+path = "src/main.rs"
+bench = false
 
 [dependencies]
-opentelemetry_api = { path = "../../opentelemetry-api", features = ["metrics"] }
-opentelemetry_sdk = { path = "../../opentelemetry-sdk", features = ["metrics", "rt-tokio"] }
-opentelemetry-stdout = { path = "../../opentelemetry-stdout", features = ["metrics"]}
-tokio = { version = "1.0", features = ["full"] }
+opentelemetry = { path = "../../opentelemetry", features = ["metrics"] }
+opentelemetry_sdk = { path = "../../opentelemetry-sdk", features = ["metrics"] }
+opentelemetry-stdout = { workspace = true, features = ["metrics"] }
+tokio = { workspace = true, features = ["full"] }
+

examples/metrics-basic/README.md

@@ -11,6 +11,3 @@ Run the following, and the Metrics will be written out to stdout.
 ```shell
 $ cargo run
 ```
-
-
-

examples/metrics-basic/src/main.rs

@@ -1,136 +1,176 @@
-use opentelemetry_api::metrics::Unit;
-use opentelemetry_api::{metrics::MeterProvider as _, KeyValue};
-use opentelemetry_sdk::metrics::{MeterProvider, PeriodicReader};
-use opentelemetry_sdk::{runtime, Resource};
+use opentelemetry::{global, KeyValue};
+use opentelemetry_sdk::metrics::SdkMeterProvider;
+use opentelemetry_sdk::Resource;
 use std::error::Error;
+use std::vec;
 
-fn init_meter_provider() -> MeterProvider {
-    let exporter = opentelemetry_stdout::MetricsExporter::default();
-    let reader = PeriodicReader::builder(exporter, runtime::Tokio).build();
-    MeterProvider::builder()
-        .with_reader(reader)
-        .with_resource(Resource::new(vec![KeyValue::new(
-            "service.name",
-            "metrics-basic-example",
-        )]))
-        .build()
+fn init_meter_provider() -> opentelemetry_sdk::metrics::SdkMeterProvider {
+    let exporter = opentelemetry_stdout::MetricExporterBuilder::default()
+        // Build exporter using Delta Temporality (Defaults to Temporality::Cumulative)
+        // .with_temporality(opentelemetry_sdk::metrics::Temporality::Delta)
+        .build();
+    let provider = SdkMeterProvider::builder()
+        .with_periodic_exporter(exporter)
+        .with_resource(
+            Resource::builder()
+                .with_service_name("metrics-basic-example")
+                .build(),
+        )
+        .build();
+    global::set_meter_provider(provider.clone());
+    provider
 }
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+async fn main() -> Result<(), Box<dyn Error>> {
     // Initialize the MeterProvider with the stdout Exporter.
     let meter_provider = init_meter_provider();
 
     // Create a meter from the above MeterProvider.
-    let meter = meter_provider.meter("mylibraryname");
+    let meter = global::meter("mylibraryname");
 
     // Create a Counter Instrument.
-    let counter = meter.u64_counter("my_counter").init();
+    let counter = meter.u64_counter("my_counter").build();
 
     // Record measurements using the Counter instrument.
     counter.add(
         10,
-        [
+        &[
             KeyValue::new("mykey1", "myvalue1"),
             KeyValue::new("mykey2", "myvalue2"),
-        ]
-        .as_ref(),
+        ],
     );
 
     // Create a ObservableCounter instrument and register a callback that reports the measurement.
-    let observable_counter = meter
+    let _observable_counter = meter
         .u64_observable_counter("my_observable_counter")
         .with_description("My observable counter example description")
-        .with_unit(Unit::new("myunit"))
-        .init();
-
-    meter.register_callback(&[observable_counter.as_any()], move |observer| {
-        observer.observe_u64(
-            &observable_counter,
-            100,
-            [
-                KeyValue::new("mykey1", "myvalue1"),
-                KeyValue::new("mykey2", "myvalue2"),
-            ]
-            .as_ref(),
-        )
-    })?;
+        .with_unit("myunit")
+        .with_callback(|observer| {
+            observer.observe(
+                100,
+                &[
+                    KeyValue::new("mykey1", "myvalue1"),
+                    KeyValue::new("mykey2", "myvalue2"),
+                ],
+            )
+        })
+        .build();
 
     // Create a UpCounter Instrument.
-    let updown_counter = meter.i64_up_down_counter("my_updown_counter").init();
+    let updown_counter = meter.i64_up_down_counter("my_updown_counter").build();
 
     // Record measurements using the UpCounter instrument.
     updown_counter.add(
         -10,
-        [
+        &[
             KeyValue::new("mykey1", "myvalue1"),
             KeyValue::new("mykey2", "myvalue2"),
-        ]
-        .as_ref(),
+        ],
     );
 
     // Create a Observable UpDownCounter instrument and register a callback that reports the measurement.
-    let observable_up_down_counter = meter
+    let _observable_up_down_counter = meter
         .i64_observable_up_down_counter("my_observable_updown_counter")
         .with_description("My observable updown counter example description")
-        .with_unit(Unit::new("myunit"))
-        .init();
-
-    meter.register_callback(&[observable_up_down_counter.as_any()], move |observer| {
-        observer.observe_i64(
-            &observable_up_down_counter,
-            100,
-            [
-                KeyValue::new("mykey1", "myvalue1"),
-                KeyValue::new("mykey2", "myvalue2"),
-            ]
-            .as_ref(),
-        )
-    })?;
+        .with_unit("myunit")
+        .with_callback(|observer| {
+            observer.observe(
+                100,
+                &[
+                    KeyValue::new("mykey1", "myvalue1"),
+                    KeyValue::new("mykey2", "myvalue2"),
+                ],
+            )
+        })
+        .build();
 
     // Create a Histogram Instrument.
     let histogram = meter
         .f64_histogram("my_histogram")
         .with_description("My histogram example description")
-        .init();
+        // Setting boundaries is optional. By default, the boundaries are set to
+        // [0.0, 5.0, 10.0, 25.0, 50.0, 75.0, 100.0, 250.0, 500.0, 750.0, 1000.0, 2500.0, 5000.0, 7500.0, 10000.0]
+        .with_boundaries(vec![0.0, 5.0, 10.0, 15.0, 20.0, 25.0])
+        .build();
 
     // Record measurements using the histogram instrument.
     histogram.record(
         10.5,
-        [
+        &[
             KeyValue::new("mykey1", "myvalue1"),
             KeyValue::new("mykey2", "myvalue2"),
-        ]
-        .as_ref(),
+        ],
     );
 
     // Note that there is no ObservableHistogram instrument.
 
-    // Create a ObservableGauge instrument and register a callback that reports the measurement.
+    // Create a Gauge Instrument.
     let gauge = meter
-        .f64_observable_gauge("my_gauge")
+        .f64_gauge("my_gauge")
         .with_description("A gauge set to 1.0")
-        .with_unit(Unit::new("myunit"))
-        .init();
+        .with_unit("myunit")
+        .build();
 
-    // Register a callback that reports the measurement.
-    meter.register_callback(&[gauge.as_any()], move |observer| {
-        observer.observe_f64(
-            &gauge,
-            1.0,
-            [
-                KeyValue::new("mykey1", "myvalue1"),
-                KeyValue::new("mykey2", "myvalue2"),
-            ]
-            .as_ref(),
-        )
-    })?;
+    gauge.record(
+        1.0,
+        &[
+            KeyValue::new("mykey1", "myvalue1"),
+            KeyValue::new("mykey2", "myvalue2"),
+        ],
+    );
 
-    // Note that Gauge only has a Observable version.
+    // Create a ObservableGauge instrument and register a callback that reports the measurement.
+    let _observable_gauge = meter
+        .f64_observable_gauge("my_observable_gauge")
+        .with_description("An observable gauge set to 1.0")
+        .with_unit("myunit")
+        .with_callback(|observer| {
+            observer.observe(
+                1.0,
+                &[
+                    KeyValue::new("mykey1", "myvalue1"),
+                    KeyValue::new("mykey2", "myvalue2"),
+                ],
+            )
+        })
+        .build();
 
-    // Metrics are exported by default every 30 seconds when using stdout exporter,
-    // however shutting down the MeterProvider here instantly flushes
-    // the metrics, instead of waiting for the 30 sec interval.
+    // Metrics are exported by default every 60 seconds when using stdout
+    // exporter, however shutting down the MeterProvider here instantly flushes
+    // the metrics, instead of waiting for the 60 sec interval. Shutdown returns
+    // a result, which is bubbled up to the caller The commented code below
+    // demonstrates handling the shutdown result, instead of bubbling up the
+    // error.
     meter_provider.shutdown()?;
+
+    // let shutdown_result = meter_provider.shutdown();
+
+    // Handle the shutdown result.
+    // match shutdown_result {
+    //     Ok(_) => println!("MeterProvider shutdown successfully"),
+    //     Err(e) => {
+    //         match e {
+    //             opentelemetry_sdk::error::ShutdownError::InternalFailure(message) => {
+    //                 // This indicates some internal failure during shutdown. The
+    //                 // error message is intended for logging purposes only and
+    //                 // should not be used to make programmatic decisions.
+    //                 println!("MeterProvider shutdown failed: {}", message)
+    //             }
+    //             opentelemetry_sdk::error::ShutdownError::AlreadyShutdown => {
+    //                 // This indicates some user code tried to shutdown
+    //                 // elsewhere. user need to review their code to ensure
+    //                 // shutdown is called only once.
+    //                 println!("MeterProvider already shutdown")
+    //             }
+    //             opentelemetry_sdk::error::ShutdownError::Timeout(e) => {
+    //                 // This indicates the shutdown timed out, and a good hint to
+    //                 // user to increase the timeout. (Shutdown method does not
+    //                 // allow custom timeout today, but that is temporary)
+    //                 println!("MeterProvider shutdown timed out after {:?}", e)
+    //             }
+    //         }
+    //     }
+    // }
     Ok(())
 }

examples/traceresponse/Cargo.toml

@@ -1,24 +0,0 @@
-[package]
-name = "traceresponse"
-version = "0.1.0"
-edition = "2021"
-license = "Apache-2.0"
-publish = false
-
-[[bin]] # Bin to run the http server
-name = "http-server"
-path = "src/server.rs"
-doc = false
-
-[[bin]] # Bin to run the client
-name = "http-client"
-path = "src/client.rs"
-doc = false
-
-[dependencies]
-hyper = { version = "0.14", features = ["full"] }
-tokio = { version = "1.0", features = ["full"] }
-opentelemetry = { path = "../../opentelemetry" }
-opentelemetry-http = { path = "../../opentelemetry-http" }
-opentelemetry-contrib = { path = "../../opentelemetry-contrib" }
-opentelemetry-stdout = { path = "../../opentelemetry-stdout", features = ["trace"] }

examples/traceresponse/src/client.rs

@@ -1,71 +0,0 @@
-use hyper::http::HeaderValue;
-use hyper::{body::Body, Client};
-use opentelemetry::global;
-use opentelemetry::propagation::TextMapPropagator;
-use opentelemetry::sdk::propagation::TraceContextPropagator;
-use opentelemetry::sdk::trace::TracerProvider;
-use opentelemetry::trace::SpanKind;
-use opentelemetry::{
-    trace::{TraceContextExt, Tracer},
-    Context, KeyValue,
-};
-use opentelemetry_contrib::trace::propagator::trace_context_response::TraceContextResponsePropagator;
-use opentelemetry_http::{HeaderExtractor, HeaderInjector};
-use opentelemetry_stdout::SpanExporter;
-
-fn init_tracer() {
-    global::set_text_map_propagator(TraceContextPropagator::new());
-    // Install stdout exporter pipeline to be able to retrieve the collected spans.
-    // For the demonstration, use `Sampler::AlwaysOn` sampler to sample all traces. In a production
-    // application, use `Sampler::ParentBased` or `Sampler::TraceIdRatioBased` with a desired ratio.
-    let provider = TracerProvider::builder()
-        .with_simple_exporter(SpanExporter::default())
-        .build();
-
-    global::set_tracer_provider(provider);
-}
-
-#[tokio::main]
-async fn main() -> std::result::Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-    init_tracer();
-
-    let client = Client::new();
-    let tracer = global::tracer("example/client");
-    let span = tracer
-        .span_builder("say hello")
-        .with_kind(SpanKind::Client)
-        .start(&tracer);
-    let cx = Context::current_with_span(span);
-
-    let mut req = hyper::Request::builder().uri("http://127.0.0.1:3000");
-    global::get_text_map_propagator(|propagator| {
-        propagator.inject_context(&cx, &mut HeaderInjector(req.headers_mut().unwrap()))
-    });
-    let res = client.request(req.body(Body::from("Hello!"))?).await?;
-
-    let response_propagator: &dyn TextMapPropagator = &TraceContextResponsePropagator::new();
-
-    let response_cx =
-        response_propagator.extract_with_context(&cx, &HeaderExtractor(res.headers()));
-
-    let response_span = response_cx.span();
-
-    cx.span().add_event(
-        "Got response!".to_string(),
-        vec![
-            KeyValue::new("status", res.status().to_string()),
-            KeyValue::new(
-                "traceresponse",
-                res.headers()
-                    .get("traceresponse")
-                    .unwrap_or(&HeaderValue::from_static(""))
-                    .to_str()
-                    .unwrap()
-                    .to_string(),
-            ),
-            KeyValue::new("child_sampled", response_span.span_context().is_sampled()),
-        ],
-    );
-
-    Ok(())
-}

examples/traceresponse/src/server.rs

@@ -1,63 +0,0 @@
-use hyper::service::{make_service_fn, service_fn};
-use hyper::{Body, Request, Response, Server};
-use opentelemetry::propagation::TextMapPropagator;
-use opentelemetry::sdk::trace::TracerProvider;
-use opentelemetry::trace::{SpanKind, TraceContextExt};
-use opentelemetry::Context;
-use opentelemetry::{global, sdk::propagation::TraceContextPropagator, trace::Tracer};
-use opentelemetry_contrib::trace::propagator::trace_context_response::TraceContextResponsePropagator;
-use opentelemetry_http::{HeaderExtractor, HeaderInjector};
-use opentelemetry_stdout::SpanExporter;
-use std::{convert::Infallible, net::SocketAddr};
-
-async fn handle(req: Request<Body>) -> Result<Response<Body>, Infallible> {
-    let parent_cx = global::get_text_map_propagator(|propagator| {
-        propagator.extract(&HeaderExtractor(req.headers()))
-    });
-    let _cx_guard = parent_cx.attach();
-
-    let tracer = global::tracer("example/server");
-    let span = tracer
-        .span_builder("say hello")
-        .with_kind(SpanKind::Server)
-        .start(&tracer);
-
-    let cx = Context::current_with_span(span);
-
-    cx.span().add_event("handling this...", Vec::new());
-
-    let mut res = Response::new("Hello, World!".into());
-
-    let response_propagator: &dyn TextMapPropagator = &TraceContextResponsePropagator::new();
-    response_propagator.inject_context(&cx, &mut HeaderInjector(res.headers_mut()));
-
-    Ok(res)
-}
-
-fn init_tracer() {
-    global::set_text_map_propagator(TraceContextPropagator::new());
-
-    // Install stdout exporter pipeline to be able to retrieve the collected spans.
-    // For the demonstration, use `Sampler::AlwaysOn` sampler to sample all traces. In a production
-    // application, use `Sampler::ParentBased` or `Sampler::TraceIdRatioBased` with a desired ratio.
-    let provider = TracerProvider::builder()
-        .with_simple_exporter(SpanExporter::default())
-        .build();
-
-    global::set_tracer_provider(provider);
-}
-
-#[tokio::main]
-async fn main() {
-    init_tracer();
-    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
-
-    let make_svc = make_service_fn(|_conn| async { Ok::<_, Infallible>(service_fn(handle)) });
-
-    let server = Server::bind(&addr).serve(make_svc);
-
-    println!("Listening on {addr}");
-    if let Err(e) = server.await {
-        eprintln!("server error: {e}");
-    }
-}

examples/tracing-grpc/Cargo.toml

@@ -3,26 +3,32 @@ name = "tracing-grpc"
 version = "0.1.0"
 edition = "2021"
 license = "Apache-2.0"
+rust-version = "1.75.0"
 publish = false
+autobenches = false
 
 [[bin]] # Bin to run the gRPC server
 name = "grpc-server"
 path = "src/server.rs"
+bench = false
 
 [[bin]] # Bin to run the gRPC client
 name = "grpc-client"
 path = "src/client.rs"
+bench = false
 
 [dependencies]
-opentelemetry = { version = "0.19", features = ["rt-tokio"] }
-opentelemetry-jaeger = { version = "0.18", features = ["rt-tokio"] }
-prost = "0.11"
-tokio = { version = "1.28", features = ["full"] }
-tonic = "0.9.2"
-tracing = "0.1"
-tracing-futures = "0.2"
-tracing-opentelemetry = "0.19"
-tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+opentelemetry = { path = "../../opentelemetry" }
+opentelemetry_sdk = { path = "../../opentelemetry-sdk", features = ["rt-tokio"] }
+opentelemetry-stdout = { workspace = true, features = ["trace"] }
+prost = { workspace = true }
+tokio = { workspace = true, features = ["full"] }
+tonic = { workspace = true, features = ["server", "codegen", "channel", "prost", "router"] }
 
 [build-dependencies]
-tonic-build = "0.9.2"
+tonic-build = { workspace = true }
+
+[package.metadata.cargo-machete]
+ignored = [
+    "prost" # needed for `tonic-build`
+]

examples/tracing-grpc/README.md

@@ -1,24 +1,25 @@
 # GRPC example
 
-Example showing [Tonic] client and server interaction with OpenTelemetry context propagation.  [tracing_opentelemetry](https://docs.rs/tracing-opentelemetry/0.4.0/tracing_opentelemetry/) is used to hook into the [tracing](https://github.com/tokio-rs/tracing) ecosystem, which enables drop-in replacements for [log](https://github.com/rust-lang/log) macros and an `#[instrument]` macro that will automatically add spans to your functions.
+Example showing [Tonic] client and server interaction with OpenTelemetry context
+propagation. Traces are exported to stdout.
 
 [Tonic]: https://github.com/hyperium/tonic
 
-Examples
---------
+## Running the example
 
 ```shell
-# Run jaeger in background
-$ docker run -d -p6831:6831/udp -p6832:6832/udp -p16686:16686 jaegertracing/all-in-one:latest
-
-# Run the server
+# Run the server first
 $ cargo run --bin grpc-server
 
 # Now run the client to make a request to the server
 $ cargo run --bin grpc-client
-
-# View spans (see the image below)
-$ firefox http://localhost:16686/
 ```
 
-![Jaeger UI](trace.png)
+Observe that the traces are exported to stdout, and that they share the same
+TraceId. Also, the server span would be parented to the client span. The example
+demonstrates how to propagate and restore OpenTelemetry context when making
+out-of-process calls, so as to ensure the same trace is continued in the next
+process. The client here initiates the trace by creating the root client span,
+and it propagates its context to the server. The server, extracts the context,
+and creates its own server span using the extracted context, ensuring both spans
+are correlated.

examples/tracing-grpc/src/client.rs

@@ -1,14 +1,28 @@
 use hello_world::greeter_client::GreeterClient;
 use hello_world::HelloRequest;
 use opentelemetry::{global, propagation::Injector};
-use tracing::*;
-use tracing_futures::Instrument;
-use tracing_opentelemetry::OpenTelemetrySpanExt;
-use tracing_subscriber::prelude::*;
+use opentelemetry_sdk::{propagation::TraceContextPropagator, trace as sdktrace};
+use opentelemetry_stdout::SpanExporter;
+
+use opentelemetry::{
+    trace::{SpanKind, TraceContextExt, Tracer},
+    Context, KeyValue,
+};
+
+fn init_tracer() -> sdktrace::SdkTracerProvider {
+    global::set_text_map_propagator(TraceContextPropagator::new());
+    // Install stdout exporter pipeline to be able to retrieve the collected spans.
+    let provider = sdktrace::SdkTracerProvider::builder()
+        .with_simple_exporter(SpanExporter::default())
+        .build();
+
+    global::set_tracer_provider(provider.clone());
+    provider
+}
 
 struct MetadataMap<'a>(&'a mut tonic::metadata::MetadataMap);
 
-impl<'a> Injector for MetadataMap<'a> {
+impl Injector for MetadataMap<'_> {
     /// Set a key and value in the MetadataMap.  Does nothing if the key or value are not valid inputs
     fn set(&mut self, key: &str, value: String) {
         if let Ok(key) = tonic::metadata::MetadataKey::from_bytes(key.as_bytes()) {
@@ -24,46 +38,57 @@ pub mod hello_world {
     tonic::include_proto!("helloworld");
 }
 
-#[instrument]
 async fn greet() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-    let mut client = GreeterClient::connect("http://[::1]:50051")
-        .instrument(info_span!("client connect"))
-        .await?;
+    let tracer = global::tracer("example/client");
+    let span = tracer
+        .span_builder("Greeter/client")
+        .with_kind(SpanKind::Client)
+        .with_attributes([
+            KeyValue::new("rpc.system", "grpc"),
+            KeyValue::new("server.port", 50052),
+            KeyValue::new("rpc.method", "say_hello"),
+        ])
+        .start(&tracer);
+    let cx = Context::current_with_span(span);
+    let mut client = GreeterClient::connect("http://[::1]:50052").await?;
 
     let mut request = tonic::Request::new(HelloRequest {
         name: "Tonic".into(),
     });
 
     global::get_text_map_propagator(|propagator| {
-        propagator.inject_context(
-            &tracing::Span::current().context(),
-            &mut MetadataMap(request.metadata_mut()),
-        )
+        propagator.inject_context(&cx, &mut MetadataMap(request.metadata_mut()))
     });
 
-    let response = client
-        .say_hello(request)
-        .instrument(info_span!("say_hello"))
-        .await?;
+    let response = client.say_hello(request).await;
+
+    let span = cx.span();
+    let status = match response {
+        Ok(_res) => {
+            span.set_attribute(KeyValue::new("response", "OK"));
+            "OK".to_string()
+        }
+        Err(status) => {
+            // Access the status code
+            let status_code = status.code();
+            span.set_attribute(KeyValue::new(
+                "response_code_desc",
+                status_code.description(),
+            ));
+            status_code.to_string()
+        }
+    };
+    span.add_event("Got response!", vec![KeyValue::new("status", status)]);
 
-    info!("Response received: {:?}", response);
     Ok(())
 }
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-    global::set_text_map_propagator(opentelemetry_jaeger::Propagator::new());
-    let tracer = opentelemetry_jaeger::new_agent_pipeline()
-        .with_service_name("grpc-client")
-        .install_simple()?;
-    tracing_subscriber::registry()
-        .with(tracing_subscriber::EnvFilter::new("INFO"))
-        .with(tracing_opentelemetry::layer().with_tracer(tracer))
-        .try_init()?;
-
+    let provider = init_tracer();
     greet().await?;
 
-    opentelemetry::global::shutdown_tracer_provider();
+    provider.shutdown()?;
 
     Ok(())
 }

examples/tracing-grpc/src/server.rs

@@ -1,10 +1,25 @@
 use hello_world::greeter_server::{Greeter, GreeterServer};
 use hello_world::{HelloReply, HelloRequest};
-use opentelemetry::{global, propagation::Extractor};
+use opentelemetry::KeyValue;
+use opentelemetry::{
+    global,
+    propagation::Extractor,
+    trace::{Span, SpanKind, Tracer},
+};
+use opentelemetry_sdk::{propagation::TraceContextPropagator, trace::SdkTracerProvider};
+use opentelemetry_stdout::SpanExporter;
 use tonic::{transport::Server, Request, Response, Status};
-use tracing::*;
-use tracing_opentelemetry::OpenTelemetrySpanExt;
-use tracing_subscriber::prelude::*;
+
+fn init_tracer() -> SdkTracerProvider {
+    global::set_text_map_propagator(TraceContextPropagator::new());
+    // Install stdout exporter pipeline to be able to retrieve the collected spans.
+    let provider = SdkTracerProvider::builder()
+        .with_simple_exporter(SpanExporter::default())
+        .build();
+
+    global::set_tracer_provider(provider.clone());
+    provider
+}
 
 #[allow(clippy::derive_partial_eq_without_eq)] // tonic don't derive Eq for generated types. We shouldn't manually change it.
 pub mod hello_world {
@@ -13,7 +28,7 @@ pub mod hello_world {
 
 struct MetadataMap<'a>(&'a tonic::metadata::MetadataMap);
 
-impl<'a> Extractor for MetadataMap<'a> {
+impl Extractor for MetadataMap<'_> {
     /// Get a value for a key from the MetadataMap.  If the value can't be converted to &str, returns None
     fn get(&self, key: &str) -> Option<&str> {
         self.0.get(key).and_then(|metadata| metadata.to_str().ok())
@@ -31,10 +46,9 @@ impl<'a> Extractor for MetadataMap<'a> {
     }
 }
 
-#[instrument]
-fn expensive_fn(to_print: String) {
+fn expensive_fn<S: Span>(to_print: String, span: &mut S) {
     std::thread::sleep(std::time::Duration::from_millis(20));
-    info!("{}", to_print);
+    span.add_event(to_print, vec![]);
 }
 
 #[derive(Debug, Default)]
@@ -42,17 +56,25 @@ pub struct MyGreeter {}
 
 #[tonic::async_trait]
 impl Greeter for MyGreeter {
-    #[instrument]
     async fn say_hello(
         &self,
         request: Request<HelloRequest>, // Accept request of type HelloRequest
     ) -> Result<Response<HelloReply>, Status> {
         let parent_cx =
             global::get_text_map_propagator(|prop| prop.extract(&MetadataMap(request.metadata())));
-        tracing::Span::current().set_parent(parent_cx);
+        let tracer = global::tracer("example/server");
+        let mut span = tracer
+            .span_builder("Greeter/server")
+            .with_kind(SpanKind::Server)
+            .with_attributes([
+                KeyValue::new("rpc.system", "grpc"),
+                KeyValue::new("server.port", 50052),
+                KeyValue::new("rpc.method", "say_hello"),
+            ])
+            .start_with_context(&tracer, &parent_cx);
 
         let name = request.into_inner().name;
-        expensive_fn(format!("Got name: {name:?}"));
+        expensive_fn(format!("Got name: {name:?}"), &mut span);
 
         // Return an instance of type HelloReply
         let reply = hello_world::HelloReply {
@@ -65,16 +87,9 @@ impl Greeter for MyGreeter {
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-    global::set_text_map_propagator(opentelemetry_jaeger::Propagator::new());
-    let tracer = opentelemetry_jaeger::new_agent_pipeline()
-        .with_service_name("grpc-server")
-        .install_batch(opentelemetry::runtime::Tokio)?;
-    tracing_subscriber::registry()
-        .with(tracing_subscriber::EnvFilter::new("INFO"))
-        .with(tracing_opentelemetry::layer().with_tracer(tracer))
-        .try_init()?;
+    let provider = init_tracer();
 
-    let addr = "[::1]:50051".parse()?;
+    let addr = "[::1]:50052".parse()?;
     let greeter = MyGreeter::default();
 
     Server::builder()
@@ -82,7 +97,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>
         .serve(addr)
         .await?;
 
-    opentelemetry::global::shutdown_tracer_provider();
+    provider.shutdown()?;
 
     Ok(())
 }

examples/tracing-http-propagator/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "tracing-http-propagator"
+version = "0.1.0"
+edition = "2021"
+license = "Apache-2.0"
+rust-version = "1.75.0"
+publish = false
+autobenches = false
+
+[[bin]] # Bin to run the http server
+name = "http-server"
+path = "src/server.rs"
+doc = false
+bench = false
+
+[[bin]] # Bin to run the client
+name = "http-client"
+path = "src/client.rs"
+doc = false
+bench = false
+
+[dependencies]
+http-body-util = { workspace = true }
+hyper = { workspace = true, features = ["full"] }
+hyper-util = { workspace = true, features = ["full"] }
+tokio = { workspace = true, features = ["full"] }
+opentelemetry = { path = "../../opentelemetry" }
+opentelemetry_sdk = { path = "../../opentelemetry-sdk" }
+opentelemetry-http = { path = "../../opentelemetry-http" }
+opentelemetry-stdout = { workspace = true, features = ["trace", "logs"] }
+opentelemetry-semantic-conventions = { path = "../../opentelemetry-semantic-conventions" }
+opentelemetry-appender-tracing = { workspace = true }
+tracing = { workspace = true, features = ["std"]}
+tracing-subscriber = { workspace = true, features = ["env-filter","registry", "std", "fmt"] }

examples/tracing-http-propagator/README.md

@@ -1,19 +1,18 @@
 # HTTP Example
 
 This is a simple example using [hyper] that demonstrates tracing http request
-from client to server, and from the server back to the client using the
-[W3C Trace Context Response] header. The example shows key aspects of tracing
+from client to server. The example shows key aspects of tracing
 such as:
 
 - Root Span (on Client)
 - Child Span from a Remote Parent (on Server)
+- Child Span created on the async function parented by the first level child (on Server)
 - SpanContext Propagation (from Client to Server)
-- SpanContext Propagation (from Server to Client)
 - Span Events
 - Span Attributes
+- Context propagation across async task boundaries.
 
 [hyper]: https://hyper.rs/
-[W3C Trace Context Response]: https://w3c.github.io/trace-context/#traceresponse-header
 
 ## Usage
 

examples/tracing-http-propagator/src/client.rs

@@ -0,0 +1,98 @@
+use http_body_util::Full;
+use hyper_util::{client::legacy::Client, rt::TokioExecutor};
+use opentelemetry::{
+    global,
+    trace::{SpanKind, TraceContextExt, Tracer},
+    Context,
+};
+use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
+use opentelemetry_http::{Bytes, HeaderInjector};
+use opentelemetry_sdk::{
+    logs::SdkLoggerProvider, propagation::TraceContextPropagator, trace::SdkTracerProvider,
+};
+use opentelemetry_stdout::{LogExporter, SpanExporter};
+use tracing::info;
+use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
+
+fn init_tracer() -> SdkTracerProvider {
+    global::set_text_map_propagator(TraceContextPropagator::new());
+    // Install stdout exporter pipeline to be able to retrieve the collected spans.
+    // For the demonstration, use `Sampler::AlwaysOn` sampler to sample all traces.
+    let provider = SdkTracerProvider::builder()
+        .with_simple_exporter(SpanExporter::default())
+        .build();
+
+    global::set_tracer_provider(provider.clone());
+    provider
+}
+
+fn init_logs() -> SdkLoggerProvider {
+    // Setup tracerprovider with stdout exporter
+    // that prints the spans to stdout.
+    let logger_provider = SdkLoggerProvider::builder()
+        .with_simple_exporter(LogExporter::default())
+        .build();
+    let otel_layer = OpenTelemetryTracingBridge::new(&logger_provider);
+    tracing_subscriber::registry()
+        .with(otel_layer)
+        .with(tracing_subscriber::filter::LevelFilter::INFO)
+        .init();
+
+    logger_provider
+}
+
+async fn send_request(
+    url: &str,
+    body_content: &str,
+    span_name: &str,
+) -> std::result::Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+    let client = Client::builder(TokioExecutor::new()).build_http();
+    let tracer = global::tracer("example/client");
+    let span = tracer
+        .span_builder(String::from(span_name))
+        .with_kind(SpanKind::Client)
+        .start(&tracer);
+    let cx = Context::current_with_span(span);
+
+    let mut req = hyper::Request::builder().uri(url);
+    global::get_text_map_propagator(|propagator| {
+        propagator.inject_context(&cx, &mut HeaderInjector(req.headers_mut().unwrap()))
+    });
+    req.headers_mut()
+        .unwrap()
+        .insert("baggage", "is_synthetic=true".parse().unwrap());
+    let res = client
+        .request(req.body(Full::new(Bytes::from(body_content.to_string())))?)
+        .await?;
+
+    info!(name: "ResponseReceived", status = res.status().to_string(), message = "Response received");
+
+    Ok(())
+}
+
+#[tokio::main]
+async fn main() -> std::result::Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+    let tracer_provider = init_tracer();
+    let logger_provider = init_logs();
+
+    send_request(
+        "http://127.0.0.1:3000/health",
+        "Health Request!",
+        "server_health_check",
+    )
+    .await?;
+    send_request(
+        "http://127.0.0.1:3000/echo",
+        "Echo Request!",
+        "server_echo_check",
+    )
+    .await?;
+
+    tracer_provider
+        .shutdown()
+        .expect("Shutdown provider failed");
+    logger_provider
+        .shutdown()
+        .expect("Shutdown provider failed");
+    Ok(())
+}

examples/tracing-http-propagator/src/server.rs

@@ -0,0 +1,204 @@
+use http_body_util::{combinators::BoxBody, BodyExt, Full};
+use hyper::{body::Incoming, service::service_fn, Request, Response, StatusCode};
+use hyper_util::rt::{TokioExecutor, TokioIo};
+use opentelemetry::{
+    baggage::BaggageExt,
+    global::{self, BoxedTracer},
+    logs::LogRecord,
+    propagation::TextMapCompositePropagator,
+    trace::{FutureExt, Span, SpanKind, TraceContextExt, Tracer},
+    Context, InstrumentationScope, KeyValue,
+};
+use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
+use opentelemetry_http::{Bytes, HeaderExtractor};
+use opentelemetry_sdk::{
+    error::OTelSdkResult,
+    logs::{LogProcessor, SdkLogRecord, SdkLoggerProvider},
+    propagation::{BaggagePropagator, TraceContextPropagator},
+    trace::{SdkTracerProvider, SpanProcessor},
+};
+use opentelemetry_semantic_conventions::trace;
+use opentelemetry_stdout::{LogExporter, SpanExporter};
+use std::time::Duration;
+use std::{convert::Infallible, net::SocketAddr, sync::OnceLock};
+use tokio::net::TcpListener;
+use tracing::info;
+use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
+
+fn get_tracer() -> &'static BoxedTracer {
+    static TRACER: OnceLock<BoxedTracer> = OnceLock::new();
+    TRACER.get_or_init(|| global::tracer("example/server"))
+}
+
+// Utility function to extract the context from the incoming request headers
+fn extract_context_from_request(req: &Request<Incoming>) -> Context {
+    global::get_text_map_propagator(|propagator| {
+        propagator.extract(&HeaderExtractor(req.headers()))
+    })
+}
+
+// Separate async function for the handle endpoint
+async fn handle_health_check(
+    _req: Request<Incoming>,
+) -> Result<Response<BoxBody<Bytes, hyper::Error>>, Infallible> {
+    let tracer = get_tracer();
+    let _span = tracer
+        .span_builder("health_check")
+        .with_kind(SpanKind::Internal)
+        .start(tracer);
+    info!(name: "health_check", message = "Health check endpoint hit");
+
+    let res = Response::new(
+        Full::new(Bytes::from_static(b"Server is up and running!"))
+            .map_err(|err| match err {})
+            .boxed(),
+    );
+
+    Ok(res)
+}
+
+// Separate async function for the echo endpoint
+async fn handle_echo(
+    req: Request<Incoming>,
+) -> Result<Response<BoxBody<Bytes, hyper::Error>>, Infallible> {
+    let tracer = get_tracer();
+    let _span = tracer
+        .span_builder("echo")
+        .with_kind(SpanKind::Internal)
+        .start(tracer);
+    info!(name = "echo", message = "Echo endpoint hit");
+
+    let res = Response::new(req.into_body().boxed());
+
+    Ok(res)
+}
+
+async fn router(
+    req: Request<Incoming>,
+) -> Result<Response<BoxBody<Bytes, hyper::Error>>, Infallible> {
+    // Extract the context from the incoming request headers
+    let parent_cx = extract_context_from_request(&req);
+    let response = {
+        // Create a span parenting the remote client span.
+        let tracer = get_tracer();
+        let span = tracer
+            .span_builder("router")
+            .with_kind(SpanKind::Server)
+            .start_with_context(tracer, &parent_cx);
+
+        info!(name = "router", message = "Dispatching request");
+
+        let cx = parent_cx.with_span(span);
+        match (req.method(), req.uri().path()) {
+            (&hyper::Method::GET, "/health") => handle_health_check(req).with_context(cx).await,
+            (&hyper::Method::GET, "/echo") => handle_echo(req).with_context(cx).await,
+            _ => {
+                cx.span()
+                    .set_attribute(KeyValue::new(trace::HTTP_RESPONSE_STATUS_CODE, 404));
+                let mut not_found = Response::new(BoxBody::default());
+                *not_found.status_mut() = StatusCode::NOT_FOUND;
+                Ok(not_found)
+            }
+        }
+    };
+
+    response
+}
+
+/// A custom log processor that enriches LogRecords with baggage attributes.
+/// Baggage information is not added automatically without this processor.
+#[derive(Debug)]
+struct EnrichWithBaggageLogProcessor;
+impl LogProcessor for EnrichWithBaggageLogProcessor {
+    fn emit(&self, data: &mut SdkLogRecord, _instrumentation: &InstrumentationScope) {
+        Context::map_current(|cx| {
+            for (kk, vv) in cx.baggage().iter() {
+                data.add_attribute(kk.clone(), vv.0.clone());
+            }
+        });
+    }
+
+    fn force_flush(&self) -> OTelSdkResult {
+        Ok(())
+    }
+}
+
+/// A custom span processor that enriches spans with baggage attributes. Baggage
+/// information is not added automatically without this processor.
+#[derive(Debug)]
+struct EnrichWithBaggageSpanProcessor;
+impl SpanProcessor for EnrichWithBaggageSpanProcessor {
+    fn force_flush(&self) -> OTelSdkResult {
+        Ok(())
+    }
+
+    fn shutdown_with_timeout(&self, _timeout: Duration) -> OTelSdkResult {
+        Ok(())
+    }
+
+    fn on_start(&self, span: &mut opentelemetry_sdk::trace::Span, cx: &Context) {
+        for (kk, vv) in cx.baggage().iter() {
+            span.set_attribute(KeyValue::new(kk.clone(), vv.0.clone()));
+        }
+    }
+
+    fn on_end(&self, _span: opentelemetry_sdk::trace::SpanData) {}
+}
+
+fn init_tracer() -> SdkTracerProvider {
+    let baggage_propagator = BaggagePropagator::new();
+    let trace_context_propagator = TraceContextPropagator::new();
+    let composite_propagator = TextMapCompositePropagator::new(vec![
+        Box::new(baggage_propagator),
+        Box::new(trace_context_propagator),
+    ]);
+
+    global::set_text_map_propagator(composite_propagator);
+
+    // Setup tracerprovider with stdout exporter
+    // that prints the spans to stdout.
+    let provider = SdkTracerProvider::builder()
+        .with_span_processor(EnrichWithBaggageSpanProcessor)
+        .with_simple_exporter(SpanExporter::default())
+        .build();
+
+    global::set_tracer_provider(provider.clone());
+    provider
+}
+
+fn init_logs() -> SdkLoggerProvider {
+    // Setup tracerprovider with stdout exporter
+    // that prints the spans to stdout.
+    let logger_provider = SdkLoggerProvider::builder()
+        .with_log_processor(EnrichWithBaggageLogProcessor)
+        .with_simple_exporter(LogExporter::default())
+        .build();
+    let otel_layer = OpenTelemetryTracingBridge::new(&logger_provider);
+    tracing_subscriber::registry().with(otel_layer).init();
+
+    logger_provider
+}
+
+#[tokio::main]
+async fn main() {
+    use hyper_util::server::conn::auto::Builder;
+
+    let provider = init_tracer();
+    let logger_provider = init_logs();
+    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
+    let listener = TcpListener::bind(addr).await.unwrap();
+
+    while let Ok((stream, _addr)) = listener.accept().await {
+        if let Err(err) = Builder::new(TokioExecutor::new())
+            .serve_connection(TokioIo::new(stream), service_fn(router))
+            .await
+        {
+            eprintln!("{err}");
+        }
+    }
+
+    provider.shutdown().expect("Shutdown provider failed");
+    logger_provider
+        .shutdown()
+        .expect("Shutdown provider failed");
+}

opentelemetry-api/CHANGELOG.md

@@ -1,40 +0,0 @@
-# Changelog
-
-## v0.20.0
-
-### Added
-
-- Add `new` method to `BoxedTracer` #1009
-- Add js-sys as dependency for api crate when building wasm targets #1078
-- Create tracer using a shared instrumentation library #1129
-- Add `Context::map_current` #1140
-
-### Changed
-
-- `OtelString::Owned` carries `Box<str>` instead of `String` #1096
-
-### Removed
-
-- Drop include_trace_context parameter from Logs API/SDK. [#1133](https://github.com/open-telemetry/opentelemetry-rust/issues/1133)
-- Synchronous instruments no longer accepts `Context` while reporting
-  measurements. [#1076](https://github.com/open-telemetry/opentelemetry-rust/pull/1076).
-
-### Fixed
-
-- Fix `SpanRef::set_attributes` mutability requirement. [#1038](https://github.com/open-telemetry/opentelemetry-rust/pull/1038)
-- Move OrderMap module to root of otel-api crate. [#1061](https://github.com/open-telemetry/opentelemetry-rust/pull/1061)
-- Use the browser-only js-sys workaround only when actually targeting a browser #1008
-
-## v0.19.0
-### Added
-- Add `WithContext` to public api [#893](https://github.com/open-telemetry/opentelemetry-rust/pull/893).
-- Add support for instrumentation scope attributes [#1021](https://github.com/open-telemetry/opentelemetry-rust/pull/1021).
-
-### Changed
-- Implement `Display` on `Baggage` [#921](https://github.com/open-telemetry/opentelemetry-rust/pull/921).
-- Bump MSRV to 1.57 [#953](https://github.com/open-telemetry/opentelemetry-rust/pull/953).
-- Update dependencies and bump MSRV to 1.60 [#969](https://github.com/open-telemetry/opentelemetry-rust/pull/969).
-
-## v0.18.0
-
-- API split from `opentelemetry` crate

opentelemetry-api/CODEOWNERS

@@ -1,5 +0,0 @@
-# Code owners file.
-# This file controls who is tagged for review for any given pull request.
-
-# For anything not explicitly taken by someone else:
-*  @open-telemetry/rust-approvers

opentelemetry-api/Cargo.toml

@@ -1,34 +0,0 @@
-[package]
-name = "opentelemetry_api"
-version = "0.20.0"
-description = "OpenTelemetry is a metrics collection and distributed tracing framework"
-homepage = "https://github.com/open-telemetry/opentelemetry-rust"
-repository = "https://github.com/open-telemetry/opentelemetry-rust"
-readme = "README.md"
-license = "Apache-2.0"
-edition = "2021"
-rust-version = "1.60"
-
-[dependencies]
-futures-channel = "0.3"
-futures-util = { version = "0.3", default-features = false, features = ["std", "sink"] }
-indexmap = "1.8"
-once_cell = "1.12.0"
-pin-project-lite = { version = "0.2", optional = true }
-thiserror = "1"
-urlencoding = "2.1.2"
-
-[target.'cfg(all(target_arch = "wasm32", not(target_os = "wasi")))'.dependencies]
-js-sys = "0.3.63"
-
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]
-
-[features]
-default = ["trace"]
-trace = ["pin-project-lite"]
-metrics = []
-testing = ["trace"]
-logs = []
-logs_level_enabled = ["logs"]

opentelemetry-api/LICENSE

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2023 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.

opentelemetry-api/README.md

@@ -1,28 +0,0 @@
-![OpenTelemetry — An observability framework for cloud-native software.][splash]
-
-[splash]: https://raw.githubusercontent.com/open-telemetry/opentelemetry-rust/main/assets/logo-text.png
-
-# OpenTelemetry Rust API
-
-The Rust [OpenTelemetry](https://opentelemetry.io/) implementation.
-
-[![Crates.io: opentelemetry-api](https://img.shields.io/crates/v/opentelemetry_api.svg)](https://crates.io/crates/opentelemetry_api)
-[![Documentation](https://docs.rs/opentelemetry_api/badge.svg)](https://docs.rs/opentelemetry_api)
-[![LICENSE](https://img.shields.io/crates/l/opentelemetry_api)](./LICENSE)
-[![GitHub Actions CI](https://github.com/open-telemetry/opentelemetry-rust/workflows/CI/badge.svg)](https://github.com/open-telemetry/opentelemetry-rust/actions?query=workflow%3ACI+branch%3Amain)
-[![codecov](https://codecov.io/gh/open-telemetry/opentelemetry-rust/branch/main/graph/badge.svg)](https://codecov.io/gh/open-telemetry/opentelemetry-rust)
-[![Slack](https://img.shields.io/badge/slack-@cncf/otel/rust-brightgreen.svg?logo=slack)](https://cloud-native.slack.com/archives/C03GDP0H023)
-
-## Overview
-
-OpenTelemetry is a collection of tools, APIs, and SDKs used to instrument,
-generate, collect, and export telemetry data (metrics, logs, and traces) for
-analysis in order to understand your software's performance and behavior. You
-can export and analyze them using [Prometheus], [Jaeger], and other
-observability tools.
-
-*Compiler support: [requires `rustc` 1.60+][msrv]*
-
-[Prometheus]: https://prometheus.io
-[Jaeger]: https://www.jaegertracing.io
-[msrv]: #supported-rust-versions

opentelemetry-api/src/common.rs

@@ -1,504 +0,0 @@
-use std::borrow::Cow;
-use std::sync::Arc;
-use std::{fmt, hash};
-
-/// The key part of attribute [KeyValue] pairs.
-///
-/// See the [attribute naming] spec for guidelines.
-///
-/// [attribute naming]: https://github.com/open-telemetry/opentelemetry-specification/blob/v1.9.0/specification/common/attribute-naming.md
-#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct Key(OtelString);
-
-impl Key {
-    /// Create a new `Key`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use opentelemetry_api::Key;
-    /// use std::sync::Arc;
-    ///
-    /// let key1 = Key::new("my_static_str");
-    /// let key2 = Key::new(String::from("my_owned_string"));
-    /// let key3 = Key::new(Arc::from("my_ref_counted_str"));
-    /// ```
-    pub fn new(value: impl Into<Key>) -> Self {
-        value.into()
-    }
-
-    /// Create a new const `Key`.
-    pub const fn from_static_str(value: &'static str) -> Self {
-        Key(OtelString::Static(value))
-    }
-
-    /// Create a `KeyValue` pair for `bool` values.
-    pub fn bool<T: Into<bool>>(self, value: T) -> KeyValue {
-        KeyValue {
-            key: self,
-            value: Value::Bool(value.into()),
-        }
-    }
-
-    /// Create a `KeyValue` pair for `i64` values.
-    pub fn i64(self, value: i64) -> KeyValue {
-        KeyValue {
-            key: self,
-            value: Value::I64(value),
-        }
-    }
-
-    /// Create a `KeyValue` pair for `f64` values.
-    pub fn f64(self, value: f64) -> KeyValue {
-        KeyValue {
-            key: self,
-            value: Value::F64(value),
-        }
-    }
-
-    /// Create a `KeyValue` pair for string-like values.
-    pub fn string(self, value: impl Into<StringValue>) -> KeyValue {
-        KeyValue {
-            key: self,
-            value: Value::String(value.into()),
-        }
-    }
-
-    /// Create a `KeyValue` pair for arrays.
-    pub fn array<T: Into<Array>>(self, value: T) -> KeyValue {
-        KeyValue {
-            key: self,
-            value: Value::Array(value.into()),
-        }
-    }
-
-    /// Returns a reference to the underlying key name
-    pub fn as_str(&self) -> &str {
-        self.0.as_str()
-    }
-}
-
-impl From<&'static str> for Key {
-    /// Convert a `&str` to a `Key`.
-    fn from(key_str: &'static str) -> Self {
-        Key(OtelString::Static(key_str))
-    }
-}
-
-impl From<String> for Key {
-    /// Convert a `String` to a `Key`.
-    fn from(string: String) -> Self {
-        Key(OtelString::Owned(string.into_boxed_str()))
-    }
-}
-
-impl From<Arc<str>> for Key {
-    /// Convert a `String` to a `Key`.
-    fn from(string: Arc<str>) -> Self {
-        Key(OtelString::RefCounted(string))
-    }
-}
-
-impl From<Cow<'static, str>> for Key {
-    /// Convert a `Cow<'static, str>` to a `Key`
-    fn from(string: Cow<'static, str>) -> Self {
-        match string {
-            Cow::Borrowed(s) => Key(OtelString::Static(s)),
-            Cow::Owned(s) => Key(OtelString::Owned(s.into_boxed_str())),
-        }
-    }
-}
-
-impl fmt::Debug for Key {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(fmt)
-    }
-}
-
-impl From<Key> for String {
-    fn from(key: Key) -> Self {
-        match key.0 {
-            OtelString::Owned(s) => s.to_string(),
-            OtelString::Static(s) => s.to_string(),
-            OtelString::RefCounted(s) => s.to_string(),
-        }
-    }
-}
-
-impl fmt::Display for Key {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match &self.0 {
-            OtelString::Owned(s) => s.fmt(fmt),
-            OtelString::Static(s) => s.fmt(fmt),
-            OtelString::RefCounted(s) => s.fmt(fmt),
-        }
-    }
-}
-
-#[derive(Clone, Debug, Eq)]
-enum OtelString {
-    Owned(Box<str>),
-    Static(&'static str),
-    RefCounted(Arc<str>),
-}
-
-impl OtelString {
-    fn as_str(&self) -> &str {
-        match self {
-            OtelString::Owned(s) => s.as_ref(),
-            OtelString::Static(s) => s,
-            OtelString::RefCounted(s) => s.as_ref(),
-        }
-    }
-}
-
-impl PartialOrd for OtelString {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        self.as_str().partial_cmp(other.as_str())
-    }
-}
-
-impl Ord for OtelString {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.as_str().cmp(other.as_str())
-    }
-}
-
-impl PartialEq for OtelString {
-    fn eq(&self, other: &Self) -> bool {
-        self.as_str().eq(other.as_str())
-    }
-}
-
-impl hash::Hash for OtelString {
-    fn hash<H: hash::Hasher>(&self, state: &mut H) {
-        self.as_str().hash(state)
-    }
-}
-
-/// A [Value::Array] containing homogeneous values.
-#[derive(Clone, Debug, PartialEq)]
-pub enum Array {
-    /// Array of bools
-    Bool(Vec<bool>),
-    /// Array of integers
-    I64(Vec<i64>),
-    /// Array of floats
-    F64(Vec<f64>),
-    /// Array of strings
-    String(Vec<StringValue>),
-}
-
-impl fmt::Display for Array {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Array::Bool(values) => display_array_str(values, fmt),
-            Array::I64(values) => display_array_str(values, fmt),
-            Array::F64(values) => display_array_str(values, fmt),
-            Array::String(values) => {
-                write!(fmt, "[")?;
-                for (i, t) in values.iter().enumerate() {
-                    if i > 0 {
-                        write!(fmt, ",")?;
-                    }
-                    write!(fmt, "\"{}\"", t)?;
-                }
-                write!(fmt, "]")
-            }
-        }
-    }
-}
-
-fn display_array_str<T: fmt::Display>(slice: &[T], fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-    write!(fmt, "[")?;
-    for (i, t) in slice.iter().enumerate() {
-        if i > 0 {
-            write!(fmt, ",")?;
-        }
-        write!(fmt, "{}", t)?;
-    }
-    write!(fmt, "]")
-}
-
-macro_rules! into_array {
-    ($(($t:ty, $val:expr),)+) => {
-        $(
-            impl From<$t> for Array {
-                fn from(t: $t) -> Self {
-                    $val(t)
-                }
-            }
-        )+
-    }
-}
-
-into_array!(
-    (Vec<bool>, Array::Bool),
-    (Vec<i64>, Array::I64),
-    (Vec<f64>, Array::F64),
-    (Vec<StringValue>, Array::String),
-);
-
-/// The value part of attribute [KeyValue] pairs.
-#[derive(Clone, Debug, PartialEq)]
-pub enum Value {
-    /// bool values
-    Bool(bool),
-    /// i64 values
-    I64(i64),
-    /// f64 values
-    F64(f64),
-    /// String values
-    String(StringValue),
-    /// Array of homogeneous values
-    Array(Array),
-}
-
-/// Wrapper for string-like values
-#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct StringValue(OtelString);
-
-impl fmt::Debug for StringValue {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-impl fmt::Display for StringValue {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match &self.0 {
-            OtelString::Owned(s) => s.fmt(f),
-            OtelString::Static(s) => s.fmt(f),
-            OtelString::RefCounted(s) => s.fmt(f),
-        }
-    }
-}
-
-impl AsRef<str> for StringValue {
-    fn as_ref(&self) -> &str {
-        self.0.as_str()
-    }
-}
-
-impl StringValue {
-    /// Returns a string slice to this value
-    pub fn as_str(&self) -> &str {
-        self.0.as_str()
-    }
-}
-
-impl From<StringValue> for String {
-    fn from(s: StringValue) -> Self {
-        match s.0 {
-            OtelString::Owned(s) => s.to_string(),
-            OtelString::Static(s) => s.to_string(),
-            OtelString::RefCounted(s) => s.to_string(),
-        }
-    }
-}
-
-impl From<&'static str> for StringValue {
-    fn from(s: &'static str) -> Self {
-        StringValue(OtelString::Static(s))
-    }
-}
-
-impl From<String> for StringValue {
-    fn from(s: String) -> Self {
-        StringValue(OtelString::Owned(s.into_boxed_str()))
-    }
-}
-
-impl From<Arc<str>> for StringValue {
-    fn from(s: Arc<str>) -> Self {
-        StringValue(OtelString::RefCounted(s))
-    }
-}
-
-impl From<Cow<'static, str>> for StringValue {
-    fn from(s: Cow<'static, str>) -> Self {
-        match s {
-            Cow::Owned(s) => StringValue(OtelString::Owned(s.into_boxed_str())),
-            Cow::Borrowed(s) => StringValue(OtelString::Static(s)),
-        }
-    }
-}
-
-impl Value {
-    /// String representation of the `Value`
-    ///
-    /// This will allocate iff the underlying value is not a `String`.
-    pub fn as_str(&self) -> Cow<'_, str> {
-        match self {
-            Value::Bool(v) => format!("{}", v).into(),
-            Value::I64(v) => format!("{}", v).into(),
-            Value::F64(v) => format!("{}", v).into(),
-            Value::String(v) => Cow::Borrowed(v.as_str()),
-            Value::Array(v) => format!("{}", v).into(),
-        }
-    }
-}
-
-macro_rules! from_values {
-   (
-        $(
-            ($t:ty, $val:expr);
-        )+
-    ) => {
-        $(
-            impl From<$t> for Value {
-                fn from(t: $t) -> Self {
-                    $val(t)
-                }
-            }
-        )+
-    }
-}
-
-from_values!(
-    (bool, Value::Bool);
-    (i64, Value::I64);
-    (f64, Value::F64);
-    (StringValue, Value::String);
-);
-
-impl From<&'static str> for Value {
-    fn from(s: &'static str) -> Self {
-        Value::String(s.into())
-    }
-}
-
-impl From<String> for Value {
-    fn from(s: String) -> Self {
-        Value::String(s.into())
-    }
-}
-
-impl From<Arc<str>> for Value {
-    fn from(s: Arc<str>) -> Self {
-        Value::String(s.into())
-    }
-}
-
-impl From<Cow<'static, str>> for Value {
-    fn from(s: Cow<'static, str>) -> Self {
-        Value::String(s.into())
-    }
-}
-
-impl fmt::Display for Value {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Value::Bool(v) => v.fmt(fmt),
-            Value::I64(v) => v.fmt(fmt),
-            Value::F64(v) => v.fmt(fmt),
-            Value::String(v) => fmt.write_str(v.as_str()),
-            Value::Array(v) => v.fmt(fmt),
-        }
-    }
-}
-
-/// A key-value pair describing an attribute.
-#[derive(Clone, Debug, PartialEq)]
-pub struct KeyValue {
-    /// The attribute name
-    pub key: Key,
-
-    /// The attribute value
-    pub value: Value,
-}
-
-impl KeyValue {
-    /// Create a new `KeyValue` pair.
-    pub fn new<K, V>(key: K, value: V) -> Self
-    where
-        K: Into<Key>,
-        V: Into<Value>,
-    {
-        KeyValue {
-            key: key.into(),
-            value: value.into(),
-        }
-    }
-}
-
-/// Marker trait for errors returned by exporters
-pub trait ExportError: std::error::Error + Send + Sync + 'static {
-    /// The name of exporter that returned this error
-    fn exporter_name(&self) -> &'static str;
-}
-
-/// Information about a library or crate providing instrumentation.
-///
-/// An instrumentation library should be named to follow any naming conventions
-/// of the instrumented library (e.g. 'middleware' for a web framework).
-///
-/// See the [instrumentation libraries] spec for more information.
-///
-/// [instrumentation libraries]: https://github.com/open-telemetry/opentelemetry-specification/blob/v1.9.0/specification/overview.md#instrumentation-libraries
-#[derive(Debug, Default, Clone)]
-#[non_exhaustive]
-pub struct InstrumentationLibrary {
-    /// The library name.
-    ///
-    /// This should be the name of the crate providing the instrumentation.
-    pub name: Cow<'static, str>,
-
-    /// The library version.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let library = opentelemetry_api::InstrumentationLibrary::new(
-    ///     "my-crate",
-    ///     Some(env!("CARGO_PKG_VERSION")),
-    ///     Some("https://opentelemetry.io/schemas/1.17.0"),
-    ///     None,
-    /// );
-    /// ```
-    pub version: Option<Cow<'static, str>>,
-
-    /// [Schema url] used by this library.
-    ///
-    /// [Schema url]: https://github.com/open-telemetry/opentelemetry-specification/blob/v1.9.0/specification/schemas/overview.md#schema-url
-    pub schema_url: Option<Cow<'static, str>>,
-
-    /// Specifies the instrumentation scope attributes to associate with emitted telemetry.
-    pub attributes: Vec<KeyValue>,
-}
-
-// Uniqueness for InstrumentationLibrary/InstrumentationScope does not depend on attributes
-impl Eq for InstrumentationLibrary {}
-
-impl PartialEq for InstrumentationLibrary {
-    fn eq(&self, other: &Self) -> bool {
-        self.name == other.name
-            && self.version == other.version
-            && self.schema_url == other.schema_url
-    }
-}
-
-impl hash::Hash for InstrumentationLibrary {
-    fn hash<H: hash::Hasher>(&self, state: &mut H) {
-        self.name.hash(state);
-        self.version.hash(state);
-        self.schema_url.hash(state);
-    }
-}
-
-impl InstrumentationLibrary {
-    /// Create an new instrumentation library.
-    pub fn new(
-        name: impl Into<Cow<'static, str>>,
-        version: Option<impl Into<Cow<'static, str>>>,
-        schema_url: Option<impl Into<Cow<'static, str>>>,
-        attributes: Option<Vec<KeyValue>>,
-    ) -> InstrumentationLibrary {
-        InstrumentationLibrary {
-            name: name.into(),
-            version: version.map(Into::into),
-            schema_url: schema_url.map(Into::into),
-            attributes: attributes.unwrap_or_default(),
-        }
-    }
-}

opentelemetry-api/src/context.rs

@@ -1,396 +0,0 @@
-use std::any::{Any, TypeId};
-use std::cell::RefCell;
-use std::collections::HashMap;
-use std::fmt;
-use std::hash::{BuildHasherDefault, Hasher};
-use std::marker::PhantomData;
-use std::sync::Arc;
-
-thread_local! {
-    static CURRENT_CONTEXT: RefCell<Context> = RefCell::new(Context::default());
-}
-
-/// An execution-scoped collection of values.
-///
-/// A [`Context`] is a propagation mechanism which carries execution-scoped
-/// values across API boundaries and between logically associated execution
-/// units. Cross-cutting concerns access their data in-process using the same
-/// shared context object.
-///
-/// [`Context`]s are immutable, and their write operations result in the creation
-/// of a new context containing the original values and the new specified values.
-///
-/// ## Context state
-///
-/// Concerns can create and retrieve their local state in the current execution
-/// state represented by a context through the [`get`] and [`with_value`]
-/// methods. It is recommended to use application-specific types when storing new
-/// context values to avoid unintentionally overwriting existing state.
-///
-/// ## Managing the current context
-///
-/// Contexts can be associated with the caller's current execution unit on a
-/// given thread via the [`attach`] method, and previous contexts can be restored
-/// by dropping the returned [`ContextGuard`]. Context can be nested, and will
-/// restore their parent outer context when detached on drop. To access the
-/// values of the context, a snapshot can be created via the [`Context::current`]
-/// method.
-///
-/// [`Context::current`]: Context::current()
-/// [`get`]: Context::get()
-/// [`with_value`]: Context::with_value()
-/// [`attach`]: Context::attach()
-///
-/// # Examples
-///
-/// ```
-/// use opentelemetry_api::Context;
-///
-/// // Application-specific `a` and `b` values
-/// #[derive(Debug, PartialEq)]
-/// struct ValueA(&'static str);
-/// #[derive(Debug, PartialEq)]
-/// struct ValueB(u64);
-///
-/// let _outer_guard = Context::new().with_value(ValueA("a")).attach();
-///
-/// // Only value a has been set
-/// let current = Context::current();
-/// assert_eq!(current.get::<ValueA>(), Some(&ValueA("a")));
-/// assert_eq!(current.get::<ValueB>(), None);
-///
-/// {
-///     let _inner_guard = Context::current_with_value(ValueB(42)).attach();
-///     // Both values are set in inner context
-///     let current = Context::current();
-///     assert_eq!(current.get::<ValueA>(), Some(&ValueA("a")));
-///     assert_eq!(current.get::<ValueB>(), Some(&ValueB(42)));
-/// }
-///
-/// // Resets to only the `a` value when inner guard is dropped
-/// let current = Context::current();
-/// assert_eq!(current.get::<ValueA>(), Some(&ValueA("a")));
-/// assert_eq!(current.get::<ValueB>(), None);
-/// ```
-#[derive(Clone, Default)]
-pub struct Context {
-    entries: HashMap<TypeId, Arc<dyn Any + Sync + Send>, BuildHasherDefault<IdHasher>>,
-}
-
-impl Context {
-    /// Creates an empty `Context`.
-    ///
-    /// The context is initially created with a capacity of 0, so it will not
-    /// allocate. Use [`with_value`] to create a new context that has entries.
-    ///
-    /// [`with_value`]: Context::with_value()
-    pub fn new() -> Self {
-        Context::default()
-    }
-
-    /// Returns an immutable snapshot of the current thread's context.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use opentelemetry_api::Context;
-    ///
-    /// #[derive(Debug, PartialEq)]
-    /// struct ValueA(&'static str);
-    ///
-    /// fn do_work() {
-    ///     assert_eq!(Context::current().get(), Some(&ValueA("a")));
-    /// }
-    ///
-    /// let _guard = Context::new().with_value(ValueA("a")).attach();
-    /// do_work()
-    /// ```
-    pub fn current() -> Self {
-        Context::map_current(|cx| cx.clone())
-    }
-
-    /// Applys a function to the current context returning its value.
-    ///
-    /// This can be used to build higher performing algebraic expressions for
-    /// optionally creating a new context without the overhead of cloning the
-    /// current one and dropping it.
-    ///
-    /// Note: This function will panic if you attempt to attach another context
-    /// while the current one is still borrowed.
-    pub fn map_current<T>(f: impl FnOnce(&Context) -> T) -> T {
-        CURRENT_CONTEXT.with(|cx| f(&cx.borrow()))
-    }
-
-    /// Returns a clone of the current thread's context with the given value.
-    ///
-    /// This is a more efficient form of `Context::current().with_value(value)`
-    /// as it avoids the intermediate context clone.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use opentelemetry_api::Context;
-    ///
-    /// // Given some value types defined in your application
-    /// #[derive(Debug, PartialEq)]
-    /// struct ValueA(&'static str);
-    /// #[derive(Debug, PartialEq)]
-    /// struct ValueB(u64);
-    ///
-    /// // You can create and attach context with the first value set to "a"
-    /// let _guard = Context::new().with_value(ValueA("a")).attach();
-    ///
-    /// // And create another context based on the fist with a new value
-    /// let all_current_and_b = Context::current_with_value(ValueB(42));
-    ///
-    /// // The second context now contains all the current values and the addition
-    /// assert_eq!(all_current_and_b.get::<ValueA>(), Some(&ValueA("a")));
-    /// assert_eq!(all_current_and_b.get::<ValueB>(), Some(&ValueB(42)));
-    /// ```
-    pub fn current_with_value<T: 'static + Send + Sync>(value: T) -> Self {
-        let mut new_context = Context::current();
-        new_context
-            .entries
-            .insert(TypeId::of::<T>(), Arc::new(value));
-
-        new_context
-    }
-
-    /// Returns a reference to the entry for the corresponding value type.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use opentelemetry_api::Context;
-    ///
-    /// // Given some value types defined in your application
-    /// #[derive(Debug, PartialEq)]
-    /// struct ValueA(&'static str);
-    /// #[derive(Debug, PartialEq)]
-    /// struct MyUser();
-    ///
-    /// let cx = Context::new().with_value(ValueA("a"));
-    ///
-    /// // Values can be queried by type
-    /// assert_eq!(cx.get::<ValueA>(), Some(&ValueA("a")));
-    ///
-    /// // And return none if not yet set
-    /// assert_eq!(cx.get::<MyUser>(), None);
-    /// ```
-    pub fn get<T: 'static>(&self) -> Option<&T> {
-        self.entries
-            .get(&TypeId::of::<T>())
-            .and_then(|rc| rc.downcast_ref())
-    }
-
-    /// Returns a copy of the context with the new value included.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use opentelemetry_api::Context;
-    ///
-    /// // Given some value types defined in your application
-    /// #[derive(Debug, PartialEq)]
-    /// struct ValueA(&'static str);
-    /// #[derive(Debug, PartialEq)]
-    /// struct ValueB(u64);
-    ///
-    /// // You can create a context with the first value set to "a"
-    /// let cx_with_a = Context::new().with_value(ValueA("a"));
-    ///
-    /// // And create another context based on the fist with a new value
-    /// let cx_with_a_and_b = cx_with_a.with_value(ValueB(42));
-    ///
-    /// // The first context is still available and unmodified
-    /// assert_eq!(cx_with_a.get::<ValueA>(), Some(&ValueA("a")));
-    /// assert_eq!(cx_with_a.get::<ValueB>(), None);
-    ///
-    /// // The second context now contains both values
-    /// assert_eq!(cx_with_a_and_b.get::<ValueA>(), Some(&ValueA("a")));
-    /// assert_eq!(cx_with_a_and_b.get::<ValueB>(), Some(&ValueB(42)));
-    /// ```
-    pub fn with_value<T: 'static + Send + Sync>(&self, value: T) -> Self {
-        let mut new_context = self.clone();
-        new_context
-            .entries
-            .insert(TypeId::of::<T>(), Arc::new(value));
-
-        new_context
-    }
-
-    /// Replaces the current context on this thread with this context.
-    ///
-    /// Dropping the returned [`ContextGuard`] will reset the current context to the
-    /// previous value.
-    ///
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use opentelemetry_api::Context;
-    ///
-    /// #[derive(Debug, PartialEq)]
-    /// struct ValueA(&'static str);
-    ///
-    /// let my_cx = Context::new().with_value(ValueA("a"));
-    ///
-    /// // Set the current thread context
-    /// let cx_guard = my_cx.attach();
-    /// assert_eq!(Context::current().get::<ValueA>(), Some(&ValueA("a")));
-    ///
-    /// // Drop the guard to restore the previous context
-    /// drop(cx_guard);
-    /// assert_eq!(Context::current().get::<ValueA>(), None);
-    /// ```
-    ///
-    /// Guards do not need to be explicitly dropped:
-    ///
-    /// ```
-    /// use opentelemetry_api::Context;
-    ///
-    /// #[derive(Debug, PartialEq)]
-    /// struct ValueA(&'static str);
-    ///
-    /// fn my_function() -> String {
-    ///     // attach a context the duration of this function.
-    ///     let my_cx = Context::new().with_value(ValueA("a"));
-    ///     // NOTE: a variable name after the underscore is **required** or rust
-    ///     // will drop the guard, restoring the previous context _immediately_.
-    ///     let _guard = my_cx.attach();
-    ///
-    ///     // anything happening in functions we call can still access my_cx...
-    ///     my_other_function();
-    ///
-    ///     // returning from the function drops the guard, exiting the span.
-    ///     return "Hello world".to_owned();
-    /// }
-    ///
-    /// fn my_other_function() {
-    ///     // ...
-    /// }
-    /// ```
-    /// Sub-scopes may be created to limit the duration for which the span is
-    /// entered:
-    ///
-    /// ```
-    /// use opentelemetry_api::Context;
-    ///
-    /// #[derive(Debug, PartialEq)]
-    /// struct ValueA(&'static str);
-    ///
-    /// let my_cx = Context::new().with_value(ValueA("a"));
-    ///
-    /// {
-    ///     let _guard = my_cx.attach();
-    ///
-    ///     // the current context can access variables in
-    ///     assert_eq!(Context::current().get::<ValueA>(), Some(&ValueA("a")));
-    ///
-    ///     // exiting the scope drops the guard, detaching the context.
-    /// }
-    ///
-    /// // this is back in the default empty context
-    /// assert_eq!(Context::current().get::<ValueA>(), None);
-    /// ```
-    pub fn attach(self) -> ContextGuard {
-        let previous_cx = CURRENT_CONTEXT
-            .try_with(|current| current.replace(self))
-            .ok();
-
-        ContextGuard {
-            previous_cx,
-            _marker: PhantomData,
-        }
-    }
-}
-
-impl fmt::Debug for Context {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Context")
-            .field("entries", &self.entries.len())
-            .finish()
-    }
-}
-
-/// A guard that resets the current context to the prior context when dropped.
-#[allow(missing_debug_implementations)]
-pub struct ContextGuard {
-    previous_cx: Option<Context>,
-    // ensure this type is !Send as it relies on thread locals
-    _marker: PhantomData<*const ()>,
-}
-
-impl Drop for ContextGuard {
-    fn drop(&mut self) {
-        if let Some(previous_cx) = self.previous_cx.take() {
-            let _ = CURRENT_CONTEXT.try_with(|current| current.replace(previous_cx));
-        }
-    }
-}
-
-/// With TypeIds as keys, there's no need to hash them. They are already hashes
-/// themselves, coming from the compiler. The IdHasher holds the u64 of
-/// the TypeId, and then returns it, instead of doing any bit fiddling.
-#[derive(Clone, Default, Debug)]
-struct IdHasher(u64);
-
-impl Hasher for IdHasher {
-    fn write(&mut self, _: &[u8]) {
-        unreachable!("TypeId calls write_u64");
-    }
-
-    #[inline]
-    fn write_u64(&mut self, id: u64) {
-        self.0 = id;
-    }
-
-    #[inline]
-    fn finish(&self) -> u64 {
-        self.0
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn nested_contexts() {
-        #[derive(Debug, PartialEq)]
-        struct ValueA(&'static str);
-        #[derive(Debug, PartialEq)]
-        struct ValueB(u64);
-        let _outer_guard = Context::new().with_value(ValueA("a")).attach();
-
-        // Only value `a` is set
-        let current = Context::current();
-        assert_eq!(current.get(), Some(&ValueA("a")));
-        assert_eq!(current.get::<ValueB>(), None);
-
-        {
-            let _inner_guard = Context::current_with_value(ValueB(42)).attach();
-            // Both values are set in inner context
-            let current = Context::current();
-            assert_eq!(current.get(), Some(&ValueA("a")));
-            assert_eq!(current.get(), Some(&ValueB(42)));
-
-            assert!(Context::map_current(|cx| {
-                assert_eq!(cx.get(), Some(&ValueA("a")));
-                assert_eq!(cx.get(), Some(&ValueB(42)));
-                true
-            }));
-        }
-
-        // Resets to only value `a` when inner guard is dropped
-        let current = Context::current();
-        assert_eq!(current.get(), Some(&ValueA("a")));
-        assert_eq!(current.get::<ValueB>(), None);
-
-        assert!(Context::map_current(|cx| {
-            assert_eq!(cx.get(), Some(&ValueA("a")));
-            assert_eq!(cx.get::<ValueB>(), None);
-            true
-        }));
-    }
-}

opentelemetry-api/src/global/error_handler.rs

@@ -1,78 +0,0 @@
-use std::sync::PoisonError;
-use std::sync::RwLock;
-
-#[cfg(feature = "logs")]
-use crate::logs::LogError;
-#[cfg(feature = "metrics")]
-use crate::metrics::MetricsError;
-#[cfg(feature = "trace")]
-use crate::trace::TraceError;
-use once_cell::sync::Lazy;
-
-static GLOBAL_ERROR_HANDLER: Lazy<RwLock<Option<ErrorHandler>>> = Lazy::new(|| RwLock::new(None));
-
-/// Wrapper for error from both tracing and metrics part of open telemetry.
-#[derive(thiserror::Error, Debug)]
-#[non_exhaustive]
-pub enum Error {
-    #[cfg(feature = "trace")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "trace")))]
-    #[error(transparent)]
-    /// Failed to export traces.
-    Trace(#[from] TraceError),
-    #[cfg(feature = "metrics")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "metrics")))]
-    #[error(transparent)]
-    /// An issue raised by the metrics module.
-    Metric(#[from] MetricsError),
-
-    #[cfg(feature = "logs")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "logs")))]
-    #[error(transparent)]
-    /// Failed to export logs.
-    Log(#[from] LogError),
-
-    #[error("{0}")]
-    /// Other types of failures not covered by the variants above.
-    Other(String),
-}
-
-impl<T> From<PoisonError<T>> for Error {
-    fn from(err: PoisonError<T>) -> Self {
-        Error::Other(err.to_string())
-    }
-}
-
-struct ErrorHandler(Box<dyn Fn(Error) + Send + Sync>);
-
-/// Handle error using the globally configured error handler.
-///
-/// Writes to stderr if unset.
-pub fn handle_error<T: Into<Error>>(err: T) {
-    match GLOBAL_ERROR_HANDLER.read() {
-        Ok(handler) if handler.is_some() => (handler.as_ref().unwrap().0)(err.into()),
-        _ => match err.into() {
-            #[cfg(feature = "metrics")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "metrics")))]
-            Error::Metric(err) => eprintln!("OpenTelemetry metrics error occurred. {}", err),
-            #[cfg(feature = "trace")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "trace")))]
-            Error::Trace(err) => eprintln!("OpenTelemetry trace error occurred. {}", err),
-            #[cfg(feature = "logs")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "logs")))]
-            Error::Log(err) => eprintln!("OpenTelemetry log error occurred. {}", err),
-            Error::Other(err_msg) => eprintln!("OpenTelemetry error occurred. {}", err_msg),
-        },
-    }
-}
-
-/// Set global error handler.
-pub fn set_error_handler<F>(f: F) -> std::result::Result<(), Error>
-where
-    F: Fn(Error) + Send + Sync + 'static,
-{
-    GLOBAL_ERROR_HANDLER
-        .write()
-        .map(|mut handler| *handler = Some(ErrorHandler(Box::new(f))))
-        .map_err(Into::into)
-}

opentelemetry-api/src/global/logs.rs

@@ -1,136 +0,0 @@
-use std::{
-    borrow::Cow,
-    fmt, mem,
-    sync::{Arc, RwLock},
-};
-
-use once_cell::sync::Lazy;
-
-use crate::{
-    logs::{Logger, LoggerProvider, NoopLoggerProvider},
-    InstrumentationLibrary,
-};
-
-/// Allows a specific [`LoggerProvider`] to be used generically, by mirroring
-/// the interface, and boxing the returned types.
-///
-/// [`LoggerProvider`]: crate::logs::LoggerProvider.
-pub trait ObjectSafeLoggerProvider {
-    /// Creates a versioned named [`Logger`] instance that is a trait object
-    /// through the underlying [`LoggerProvider`].
-    ///
-    /// [`Logger`]: crate::logs::Logger
-    /// [`LoggerProvider`]: crate::logs::LoggerProvider
-    fn boxed_logger(
-        &self,
-        library: Arc<InstrumentationLibrary>,
-    ) -> Box<dyn Logger + Send + Sync + 'static>;
-}
-
-impl<L, P> ObjectSafeLoggerProvider for P
-where
-    L: Logger + Send + Sync + 'static,
-    P: LoggerProvider<Logger = L>,
-{
-    fn boxed_logger(
-        &self,
-        library: Arc<InstrumentationLibrary>,
-    ) -> Box<dyn Logger + Send + Sync + 'static> {
-        Box::new(self.library_logger(library))
-    }
-}
-
-pub struct BoxedLogger(Box<dyn Logger + Send + Sync + 'static>);
-
-impl fmt::Debug for BoxedLogger {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("BoxedLogger")
-    }
-}
-
-impl Logger for BoxedLogger {
-    fn emit(&self, record: crate::logs::LogRecord) {
-        self.0.emit(record)
-    }
-
-    #[cfg(feature = "logs_level_enabled")]
-    fn event_enabled(&self, level: crate::logs::Severity, target: &str) -> bool {
-        self.0.event_enabled(level, target)
-    }
-}
-
-#[derive(Clone)]
-/// Represents the globally configured [`LoggerProvider`] instance.
-pub struct GlobalLoggerProvider {
-    provider: Arc<dyn ObjectSafeLoggerProvider + Send + Sync>,
-}
-
-impl fmt::Debug for GlobalLoggerProvider {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("GlobalLoggerProvider")
-    }
-}
-
-impl GlobalLoggerProvider {
-    fn new<
-        L: Logger + Send + Sync + 'static,
-        P: LoggerProvider<Logger = L> + Send + Sync + 'static,
-    >(
-        provider: P,
-    ) -> Self {
-        GlobalLoggerProvider {
-            provider: Arc::new(provider),
-        }
-    }
-}
-
-impl LoggerProvider for GlobalLoggerProvider {
-    type Logger = BoxedLogger;
-
-    fn library_logger(&self, library: Arc<InstrumentationLibrary>) -> Self::Logger {
-        BoxedLogger(self.provider.boxed_logger(library))
-    }
-}
-
-static GLOBAL_LOGGER_PROVIDER: Lazy<RwLock<GlobalLoggerProvider>> =
-    Lazy::new(|| RwLock::new(GlobalLoggerProvider::new(NoopLoggerProvider::new())));
-
-/// Returns an instance of the currently configured global [`LoggerProvider`]
-/// through [`GlobalLoggerProvider`].
-///
-/// [`LoggerProvider`]: crate::logs::LoggerProvider
-pub fn logger_provider() -> GlobalLoggerProvider {
-    GLOBAL_LOGGER_PROVIDER
-        .read()
-        .expect("GLOBAL_LOGGER_PROVIDER RwLock poisoned")
-        .clone()
-}
-
-/// Creates a named instance of [`Logger`] via the configured
-/// [`GlobalLoggerProvider`].
-///
-/// If `name` is an empty string, the provider will use a default name.
-///
-/// [`Logger`]: crate::logs::Logger
-pub fn logger(name: Cow<'static, str>) -> BoxedLogger {
-    logger_provider().logger(name)
-}
-
-/// Sets the given [`LoggerProvider`] instance as the current global provider,
-/// returning the [`LoggerProvider`] instance that was previously set as global
-/// provider.
-pub fn set_logger_provider<L, P>(new_provider: P) -> GlobalLoggerProvider
-where
-    L: Logger + Send + Sync + 'static,
-    P: LoggerProvider<Logger = L> + Send + Sync + 'static,
-{
-    let mut provider = GLOBAL_LOGGER_PROVIDER
-        .write()
-        .expect("GLOBAL_LOGGER_PROVIDER RwLock poisoned");
-    mem::replace(&mut *provider, GlobalLoggerProvider::new(new_provider))
-}
-
-/// Shut down the current global [`LoggerProvider`].
-pub fn shutdown_logger_provider() {
-    let _ = set_logger_provider(NoopLoggerProvider::new());
-}

opentelemetry-api/src/global/metrics.rs

@@ -1,152 +0,0 @@
-use crate::metrics::{self, Meter, MeterProvider};
-use crate::KeyValue;
-use core::fmt;
-use once_cell::sync::Lazy;
-use std::{
-    borrow::Cow,
-    sync::{Arc, RwLock},
-};
-
-/// The global `Meter` provider singleton.
-static GLOBAL_METER_PROVIDER: Lazy<RwLock<GlobalMeterProvider>> = Lazy::new(|| {
-    RwLock::new(GlobalMeterProvider::new(
-        metrics::noop::NoopMeterProvider::new(),
-    ))
-});
-
-/// Allows a specific [MeterProvider] to be used generically by the
-/// [GlobalMeterProvider] by mirroring the interface and boxing the return types.
-pub trait ObjectSafeMeterProvider {
-    /// Creates a versioned named meter instance that is a trait object through the underlying
-    /// [MeterProvider].
-    fn versioned_meter_cow(
-        &self,
-        name: Cow<'static, str>,
-        version: Option<Cow<'static, str>>,
-        schema_url: Option<Cow<'static, str>>,
-        attributes: Option<Vec<KeyValue>>,
-    ) -> Meter;
-}
-
-impl<P> ObjectSafeMeterProvider for P
-where
-    P: MeterProvider,
-{
-    /// Return a versioned boxed tracer
-    fn versioned_meter_cow(
-        &self,
-        name: Cow<'static, str>,
-        version: Option<Cow<'static, str>>,
-        schema_url: Option<Cow<'static, str>>,
-        attributes: Option<Vec<KeyValue>>,
-    ) -> Meter {
-        self.versioned_meter(name, version, schema_url, attributes)
-    }
-}
-
-/// Represents the globally configured [`MeterProvider`] instance for this
-/// application.
-#[derive(Clone)]
-pub struct GlobalMeterProvider {
-    provider: Arc<dyn ObjectSafeMeterProvider + Send + Sync>,
-}
-
-impl fmt::Debug for GlobalMeterProvider {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("GlobalMeterProvider").finish()
-    }
-}
-
-impl MeterProvider for GlobalMeterProvider {
-    fn versioned_meter(
-        &self,
-        name: impl Into<Cow<'static, str>>,
-        version: Option<impl Into<Cow<'static, str>>>,
-        schema_url: Option<impl Into<Cow<'static, str>>>,
-        attributes: Option<Vec<KeyValue>>,
-    ) -> Meter {
-        self.provider.versioned_meter_cow(
-            name.into(),
-            version.map(Into::into),
-            schema_url.map(Into::into),
-            attributes,
-        )
-    }
-}
-
-impl GlobalMeterProvider {
-    /// Create a new global meter provider
-    pub fn new<P>(provider: P) -> Self
-    where
-        P: MeterProvider + Send + Sync + 'static,
-    {
-        GlobalMeterProvider {
-            provider: Arc::new(provider),
-        }
-    }
-}
-
-/// Sets the given [`MeterProvider`] instance as the current global meter
-/// provider.
-pub fn set_meter_provider<P>(new_provider: P)
-where
-    P: metrics::MeterProvider + Send + Sync + 'static,
-{
-    let mut global_provider = GLOBAL_METER_PROVIDER
-        .write()
-        .expect("GLOBAL_METER_PROVIDER RwLock poisoned");
-    *global_provider = GlobalMeterProvider::new(new_provider);
-}
-
-/// Returns an instance of the currently configured global [`MeterProvider`]
-/// through [`GlobalMeterProvider`].
-pub fn meter_provider() -> GlobalMeterProvider {
-    GLOBAL_METER_PROVIDER
-        .read()
-        .expect("GLOBAL_METER_PROVIDER RwLock poisoned")
-        .clone()
-}
-
-/// Creates a named [`Meter`] via the configured [`GlobalMeterProvider`].
-///
-/// If the name is an empty string, the provider will use a default name.
-///
-/// This is a more convenient way of expressing `global::meter_provider().versioned_meter(name, None, None, None)`.
-pub fn meter(name: impl Into<Cow<'static, str>>) -> Meter {
-    meter_provider().meter(name.into())
-}
-
-/// Creates a [`Meter`] with the name, version and schema url.
-///
-/// - name SHOULD uniquely identify the instrumentation scope, such as the instrumentation library (e.g. io.opentelemetry.contrib.mongodb), package, module or class name.
-/// - version specifies the version of the instrumentation scope if the scope has a version
-/// - schema url specifies the Schema URL that should be recorded in the emitted telemetry.
-///
-/// This is a convenient way of `global::meter_provider().versioned_meter(...)`
-///
-/// # Example
-///
-/// ```
-/// use opentelemetry_api::global::meter_with_version;
-/// use opentelemetry_api::KeyValue;
-///
-/// let meter = meter_with_version(
-///     "io.opentelemetry",
-///     Some("0.17"),
-///     Some("https://opentelemetry.io/schemas/1.2.0"),
-///     Some(vec![KeyValue::new("key", "value")]),
-/// );
-/// ```
-pub fn meter_with_version(
-    name: impl Into<Cow<'static, str>>,
-    version: Option<impl Into<Cow<'static, str>>>,
-    schema_url: Option<impl Into<Cow<'static, str>>>,
-    attributes: Option<Vec<KeyValue>>,
-) -> Meter {
-    meter_provider().versioned_meter(
-        name.into(),
-        version.map(Into::into),
-        schema_url.map(Into::into),
-        attributes,
-    )
-}

opentelemetry-api/src/global/propagation.rs

@@ -1,30 +0,0 @@
-use crate::propagation::TextMapPropagator;
-use crate::trace::noop::NoopTextMapPropagator;
-use once_cell::sync::Lazy;
-use std::sync::RwLock;
-
-/// The current global `TextMapPropagator` propagator.
-static GLOBAL_TEXT_MAP_PROPAGATOR: Lazy<RwLock<Box<dyn TextMapPropagator + Send + Sync>>> =
-    Lazy::new(|| RwLock::new(Box::new(NoopTextMapPropagator::new())));
-
-/// The global default `TextMapPropagator` propagator.
-static DEFAULT_TEXT_MAP_PROPAGATOR: Lazy<NoopTextMapPropagator> =
-    Lazy::new(NoopTextMapPropagator::new);
-
-/// Sets the given [`TextMapPropagator`] propagator as the current global propagator.
-pub fn set_text_map_propagator<P: TextMapPropagator + Send + Sync + 'static>(propagator: P) {
-    let _lock = GLOBAL_TEXT_MAP_PROPAGATOR
-        .write()
-        .map(|mut global_propagator| *global_propagator = Box::new(propagator));
-}
-
-/// Executes a closure with a reference to the current global [`TextMapPropagator`] propagator.
-pub fn get_text_map_propagator<T, F>(mut f: F) -> T
-where
-    F: FnMut(&dyn TextMapPropagator) -> T,
-{
-    GLOBAL_TEXT_MAP_PROPAGATOR
-        .read()
-        .map(|propagator| f(&**propagator))
-        .unwrap_or_else(|_| f(&*DEFAULT_TEXT_MAP_PROPAGATOR as &dyn TextMapPropagator))
-}

opentelemetry-api/src/lib.rs

@@ -1,97 +0,0 @@
-//! OpenTelemetry provides a single set of APIs, libraries, agents, and collector
-//! services to capture distributed traces and metrics from your application. You
-//! can analyze them using [Prometheus], [Jaeger], and other observability tools.
-//!
-//! *Compiler support: [requires `rustc` 1.60+][msrv]*
-//!
-//! [Prometheus]: https://prometheus.io
-//! [Jaeger]: https://www.jaegertracing.io
-//! [msrv]: #supported-rust-versions
-//!
-//! ## Supported Rust Versions
-//!
-//! OpenTelemetry is built against the latest stable release. The minimum
-//! supported version is 1.60. The current OpenTelemetry version is not
-//! guaranteed to build on Rust versions earlier than the minimum supported
-//! version.
-//!
-//! The current stable Rust compiler and the three most recent minor versions
-//! before it will always be supported. For example, if the current stable
-//! compiler version is 1.49, the minimum supported version will not be
-//! increased past 1.46, three minor versions prior. Increasing the minimum
-//! supported compiler version is not considered a semver breaking change as
-//! long as doing so complies with this policy.
-#![warn(
-    future_incompatible,
-    missing_debug_implementations,
-    missing_docs,
-    nonstandard_style,
-    rust_2018_idioms,
-    unreachable_pub,
-    unused
-)]
-#![allow(clippy::needless_doctest_main)]
-#![cfg_attr(
-    docsrs,
-    feature(doc_cfg, doc_auto_cfg),
-    deny(rustdoc::broken_intra_doc_links)
-)]
-#![doc(
-    html_logo_url = "https://raw.githubusercontent.com/open-telemetry/opentelemetry-rust/main/assets/logo.svg"
-)]
-#![cfg_attr(test, deny(warnings))]
-
-pub mod global;
-
-pub mod baggage;
-
-mod context;
-
-pub use context::{Context, ContextGuard};
-
-mod common;
-
-mod order_map;
-
-pub use order_map::OrderMap;
-
-#[cfg(any(feature = "testing", test))]
-#[doc(hidden)]
-pub mod testing;
-
-pub use common::{Array, ExportError, InstrumentationLibrary, Key, KeyValue, StringValue, Value};
-
-#[cfg(feature = "metrics")]
-#[cfg_attr(docsrs, doc(cfg(feature = "metrics")))]
-pub mod metrics;
-
-pub mod propagation;
-
-#[cfg(feature = "trace")]
-#[cfg_attr(docsrs, doc(cfg(feature = "trace")))]
-pub mod trace;
-
-#[cfg(feature = "logs")]
-#[cfg_attr(docsrs, doc(cfg(feature = "logs")))]
-pub mod logs;
-
-#[doc(hidden)]
-#[cfg(any(feature = "metrics", feature = "trace"))]
-pub mod time {
-    use std::time::SystemTime;
-
-    #[doc(hidden)]
-    #[cfg(any(
-        not(target_arch = "wasm32"),
-        all(target_arch = "wasm32", target_os = "wasi")
-    ))]
-    pub fn now() -> SystemTime {
-        SystemTime::now()
-    }
-
-    #[doc(hidden)]
-    #[cfg(all(target_arch = "wasm32", not(target_os = "wasi")))]
-    pub fn now() -> SystemTime {
-        SystemTime::UNIX_EPOCH + std::time::Duration::from_millis(js_sys::Date::now() as u64)
-    }
-}

opentelemetry-api/src/logs/logger.rs

@@ -1,75 +0,0 @@
-use std::{borrow::Cow, sync::Arc};
-
-use crate::{logs::LogRecord, InstrumentationLibrary, KeyValue};
-
-#[cfg(feature = "logs_level_enabled")]
-use super::Severity;
-
-/// The interface for emitting [`LogRecord`]s.
-
-pub trait Logger {
-    /// Emit a [`LogRecord`]. If there is active current thread's [`Context`],
-    ///  the logger will set the record's [`TraceContext`] to the active trace context,
-    ///
-    /// [`Context`]: crate::Context
-    /// [`TraceContext`]: crate::logs::TraceContext
-    fn emit(&self, record: LogRecord);
-
-    #[cfg(feature = "logs_level_enabled")]
-    /// Check if the given log level is enabled.
-    fn event_enabled(&self, level: Severity, target: &str) -> bool;
-}
-
-/// Interfaces that can create [`Logger`] instances.
-pub trait LoggerProvider {
-    /// The [`Logger`] type that this provider will return.
-    type Logger: Logger;
-
-    /// Returns a new versioned logger with a given name.
-    ///
-    /// The `name` should be the application name or the name of the library
-    /// providing instrumentation. If the name is empty, then an
-    /// implementation-defined default name may be used instead.
-    fn versioned_logger(
-        &self,
-        name: impl Into<Cow<'static, str>>,
-        version: Option<Cow<'static, str>>,
-        schema_url: Option<Cow<'static, str>>,
-        attributes: Option<Vec<KeyValue>>,
-    ) -> Self::Logger {
-        self.library_logger(Arc::new(InstrumentationLibrary::new(
-            name, version, schema_url, attributes,
-        )))
-    }
-
-    /// Returns a new versioned logger with the given instrumentation library.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use opentelemetry_api::{global, InstrumentationLibrary, logs::LoggerProvider};
-    ///
-    /// let provider = global::logger_provider();
-    ///
-    /// // logger used in applications/binaries
-    /// let logger = provider.logger("my_app");
-    /// // logger used in libraries/crates that optionally includes version and schema url
-    /// let library = std::sync::Arc::new(InstrumentationLibrary::new(
-    ///     env!("CARGO_PKG_NAME"),
-    ///     Some(env!("CARGO_PKG_VERSION")),
-    ///     Some("https://opentelemetry.io/schema/1.0.0"),
-    ///     None,
-    /// ));
-    /// let logger = provider.library_logger(library);
-    /// ```
-    fn library_logger(&self, library: Arc<InstrumentationLibrary>) -> Self::Logger;
-
-    /// Returns a new logger with the given name.
-    ///
-    /// The `name` should be the application name or the name of the library
-    /// providing instrumentation. If the name is empty, then an
-    /// implementation-defined default name may be used instead.
-    fn logger(&self, name: impl Into<Cow<'static, str>>) -> Self::Logger {
-        self.versioned_logger(name, None, None, None)
-    }
-}

opentelemetry-api/src/logs/mod.rs

@@ -1,72 +0,0 @@
-//! # OpenTelemetry Logs API
-
-use crate::ExportError;
-use futures_channel::{mpsc::TrySendError, oneshot::Canceled};
-use std::time::Duration;
-use thiserror::Error;
-
-mod logger;
-mod noop;
-mod record;
-
-pub use logger::{Logger, LoggerProvider};
-pub use noop::NoopLoggerProvider;
-pub use record::{AnyValue, LogRecord, LogRecordBuilder, Severity, TraceContext};
-
-/// Describe the result of operations in log SDK.
-pub type LogResult<T> = Result<T, LogError>;
-
-#[derive(Error, Debug)]
-#[non_exhaustive]
-/// Errors returned by the log SDK.
-pub enum LogError {
-    /// Export failed with the error returned by the exporter.
-    #[error("Exporter {} encountered the following errors: {0}", .0.exporter_name())]
-    ExportFailed(Box<dyn ExportError>),
-
-    /// Export failed to finish after certain period and processor stopped the export.
-    #[error("Exporter timed out after {} seconds", .0.as_secs())]
-    ExportTimedOut(Duration),
-
-    /// Other errors propagated from log SDK that weren't covered above.
-    #[error(transparent)]
-    Other(#[from] Box<dyn std::error::Error + Send + Sync + 'static>),
-}
-
-impl<T> From<T> for LogError
-where
-    T: ExportError,
-{
-    fn from(err: T) -> Self {
-        LogError::ExportFailed(Box::new(err))
-    }
-}
-
-impl<T> From<TrySendError<T>> for LogError {
-    fn from(err: TrySendError<T>) -> Self {
-        LogError::Other(Box::new(err.into_send_error()))
-    }
-}
-
-impl From<Canceled> for LogError {
-    fn from(err: Canceled) -> Self {
-        LogError::Other(Box::new(err))
-    }
-}
-
-impl From<String> for LogError {
-    fn from(err_msg: String) -> Self {
-        LogError::Other(Box::new(Custom(err_msg)))
-    }
-}
-
-impl From<&'static str> for LogError {
-    fn from(err_msg: &'static str) -> Self {
-        LogError::Other(Box::new(Custom(err_msg.into())))
-    }
-}
-
-/// Wrap type for string
-#[derive(Error, Debug)]
-#[error("{0}")]
-struct Custom(String);

opentelemetry-api/src/logs/noop.rs

@@ -1,47 +0,0 @@
-use std::{borrow::Cow, sync::Arc};
-
-use crate::{
-    logs::{LogRecord, Logger, LoggerProvider},
-    InstrumentationLibrary, KeyValue,
-};
-
-/// A no-op implementation of a [`LoggerProvider`].
-#[derive(Clone, Debug, Default)]
-pub struct NoopLoggerProvider(());
-
-impl NoopLoggerProvider {
-    /// Create a new no-op logger provider.
-    pub fn new() -> Self {
-        NoopLoggerProvider(())
-    }
-}
-
-impl LoggerProvider for NoopLoggerProvider {
-    type Logger = NoopLogger;
-
-    fn library_logger(&self, _library: Arc<InstrumentationLibrary>) -> Self::Logger {
-        NoopLogger(())
-    }
-
-    fn versioned_logger(
-        &self,
-        _name: impl Into<Cow<'static, str>>,
-        _version: Option<Cow<'static, str>>,
-        _schema_url: Option<Cow<'static, str>>,
-        _attributes: Option<Vec<KeyValue>>,
-    ) -> Self::Logger {
-        NoopLogger(())
-    }
-}
-
-/// A no-op implementation of a [`Logger`]
-#[derive(Clone, Debug)]
-pub struct NoopLogger(());
-
-impl Logger for NoopLogger {
-    fn emit(&self, _record: LogRecord) {}
-    #[cfg(feature = "logs_level_enabled")]
-    fn event_enabled(&self, _level: super::Severity, _target: &str) -> bool {
-        true
-    }
-}

opentelemetry-api/src/logs/record.rs

@@ -1,367 +0,0 @@
-use crate::{
-    trace::{SpanContext, SpanId, TraceContextExt, TraceFlags, TraceId},
-    Array, Key, OrderMap, StringValue, Value,
-};
-use std::{borrow::Cow, time::SystemTime};
-
-#[derive(Debug, Clone, Default)]
-#[non_exhaustive]
-/// LogRecord represents all data carried by a log record, and
-/// is provided to `LogExporter`s as input.
-pub struct LogRecord {
-    /// Record timestamp
-    pub timestamp: Option<SystemTime>,
-
-    /// Timestamp for when the record was observed by OpenTelemetry
-    pub observed_timestamp: Option<SystemTime>,
-
-    /// Trace context for logs associated with spans
-    pub trace_context: Option<TraceContext>,
-
-    /// The original severity string from the source
-    pub severity_text: Option<Cow<'static, str>>,
-    /// The corresponding severity value, normalized
-    pub severity_number: Option<Severity>,
-
-    /// Record body
-    pub body: Option<AnyValue>,
-
-    /// Additional attributes associated with this record
-    pub attributes: Option<Vec<(Key, AnyValue)>>,
-}
-
-impl LogRecord {
-    /// Create a [`LogRecordBuilder`] to create a new Log Record
-    pub fn builder() -> LogRecordBuilder {
-        LogRecordBuilder::new()
-    }
-}
-
-/// TraceContext stores the trace data for logs that have an associated
-/// span.
-#[derive(Debug, Clone)]
-#[non_exhaustive]
-pub struct TraceContext {
-    /// Trace id
-    pub trace_id: TraceId,
-    /// Span Id
-    pub span_id: SpanId,
-    /// Trace flags
-    pub trace_flags: Option<TraceFlags>,
-}
-
-impl From<&SpanContext> for TraceContext {
-    fn from(span_context: &SpanContext) -> Self {
-        TraceContext {
-            trace_id: span_context.trace_id(),
-            span_id: span_context.span_id(),
-            trace_flags: Some(span_context.trace_flags()),
-        }
-    }
-}
-
-/// Value types for representing arbitrary values in a log record.
-#[derive(Debug, Clone)]
-pub enum AnyValue {
-    /// An integer value
-    Int(i64),
-    /// A double value
-    Double(f64),
-    /// A string value
-    String(StringValue),
-    /// A boolean value
-    Boolean(bool),
-    /// A byte array
-    Bytes(Vec<u8>),
-    /// An array of `Any` values
-    ListAny(Vec<AnyValue>),
-    /// A map of string keys to `Any` values, arbitrarily nested.
-    Map(OrderMap<Key, AnyValue>),
-}
-
-macro_rules! impl_trivial_from {
-    ($t:ty, $variant:path) => {
-        impl From<$t> for AnyValue {
-            fn from(val: $t) -> AnyValue {
-                $variant(val.into())
-            }
-        }
-    };
-}
-
-impl_trivial_from!(i8, AnyValue::Int);
-impl_trivial_from!(i16, AnyValue::Int);
-impl_trivial_from!(i32, AnyValue::Int);
-impl_trivial_from!(i64, AnyValue::Int);
-
-impl_trivial_from!(u8, AnyValue::Int);
-impl_trivial_from!(u16, AnyValue::Int);
-impl_trivial_from!(u32, AnyValue::Int);
-
-impl_trivial_from!(f64, AnyValue::Double);
-impl_trivial_from!(f32, AnyValue::Double);
-
-impl_trivial_from!(String, AnyValue::String);
-impl_trivial_from!(Cow<'static, str>, AnyValue::String);
-impl_trivial_from!(&'static str, AnyValue::String);
-impl_trivial_from!(StringValue, AnyValue::String);
-
-impl_trivial_from!(bool, AnyValue::Boolean);
-
-impl<T: Into<AnyValue>> FromIterator<T> for AnyValue {
-    /// Creates an [`AnyValue::ListAny`] value from a sequence of `Into<AnyValue>` values.
-    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
-        AnyValue::ListAny(iter.into_iter().map(Into::into).collect())
-    }
-}
-
-impl<K: Into<Key>, V: Into<AnyValue>> FromIterator<(K, V)> for AnyValue {
-    /// Creates an [`AnyValue::Map`] value from a sequence of key-value pairs
-    /// that can be converted into a `Key` and `AnyValue` respectively.
-    fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
-        AnyValue::Map(OrderMap::from_iter(
-            iter.into_iter().map(|(k, v)| (k.into(), v.into())),
-        ))
-    }
-}
-
-impl From<Value> for AnyValue {
-    fn from(value: Value) -> Self {
-        match value {
-            Value::Bool(b) => b.into(),
-            Value::I64(i) => i.into(),
-            Value::F64(f) => f.into(),
-            Value::String(s) => s.into(),
-            Value::Array(a) => match a {
-                Array::Bool(b) => AnyValue::from_iter(b),
-                Array::F64(f) => AnyValue::from_iter(f),
-                Array::I64(i) => AnyValue::from_iter(i),
-                Array::String(s) => AnyValue::from_iter(s),
-            },
-        }
-    }
-}
-
-/// A normalized severity value.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Ord, PartialOrd)]
-pub enum Severity {
-    /// TRACE
-    Trace = 1,
-    /// TRACE2
-    Trace2 = 2,
-    /// TRACE3
-    Trace3 = 3,
-    /// TRACE4
-    Trace4 = 4,
-    /// DEBUG
-    Debug = 5,
-    /// DEBUG2
-    Debug2 = 6,
-    /// DEBUG3
-    Debug3 = 7,
-    /// DEBUG4
-    Debug4 = 8,
-    /// INFO
-    Info = 9,
-    /// INFO2
-    Info2 = 10,
-    /// INFO3
-    Info3 = 11,
-    /// INFO4
-    Info4 = 12,
-    /// WARN
-    Warn = 13,
-    /// WARN2
-    Warn2 = 14,
-    /// WARN3
-    Warn3 = 15,
-    /// WARN4
-    Warn4 = 16,
-    /// ERROR
-    Error = 17,
-    /// ERROR2
-    Error2 = 18,
-    /// ERROR3
-    Error3 = 19,
-    /// ERROR4
-    Error4 = 20,
-    /// FATAL
-    Fatal = 21,
-    /// FATAL2
-    Fatal2 = 22,
-    /// FATAL3
-    Fatal3 = 23,
-    /// FATAL4
-    Fatal4 = 24,
-}
-
-impl Severity {
-    /// Return the string representing the short name for the `Severity`
-    /// value as specified by the OpenTelemetry logs data model.
-    pub const fn name(&self) -> &'static str {
-        match &self {
-            Severity::Trace => "TRACE",
-            Severity::Trace2 => "TRACE2",
-            Severity::Trace3 => "TRACE3",
-            Severity::Trace4 => "TRACE4",
-
-            Severity::Debug => "DEBUG",
-            Severity::Debug2 => "DEBUG2",
-            Severity::Debug3 => "DEBUG3",
-            Severity::Debug4 => "DEBUG4",
-
-            Severity::Info => "INFO",
-            Severity::Info2 => "INFO2",
-            Severity::Info3 => "INFO3",
-            Severity::Info4 => "INFO4",
-
-            Severity::Warn => "WARN",
-            Severity::Warn2 => "WARN2",
-            Severity::Warn3 => "WARN3",
-            Severity::Warn4 => "WARN4",
-
-            Severity::Error => "ERROR",
-            Severity::Error2 => "ERROR2",
-            Severity::Error3 => "ERROR3",
-            Severity::Error4 => "ERROR4",
-
-            Severity::Fatal => "FATAL",
-            Severity::Fatal2 => "FATAL2",
-            Severity::Fatal3 => "FATAL3",
-            Severity::Fatal4 => "FATAL4",
-        }
-    }
-}
-
-/// A builder for [`LogRecord`] values.
-#[derive(Debug, Clone)]
-pub struct LogRecordBuilder {
-    record: LogRecord,
-}
-
-impl LogRecordBuilder {
-    /// Create a new LogRecordBuilder
-    pub fn new() -> Self {
-        Self {
-            record: Default::default(),
-        }
-    }
-
-    /// Assign timestamp
-    pub fn with_timestamp(self, timestamp: SystemTime) -> Self {
-        Self {
-            record: LogRecord {
-                timestamp: Some(timestamp),
-                ..self.record
-            },
-        }
-    }
-
-    /// Assign observed timestamp
-    pub fn with_observed_timestamp(self, timestamp: SystemTime) -> Self {
-        Self {
-            record: LogRecord {
-                observed_timestamp: Some(timestamp),
-                ..self.record
-            },
-        }
-    }
-
-    /// Assign the record's [`TraceContext`]
-    pub fn with_span_context(self, span_context: &SpanContext) -> Self {
-        Self {
-            record: LogRecord {
-                trace_context: Some(TraceContext {
-                    span_id: span_context.span_id(),
-                    trace_id: span_context.trace_id(),
-                    trace_flags: Some(span_context.trace_flags()),
-                }),
-                ..self.record
-            },
-        }
-    }
-
-    /// Assign the record's [`TraceContext`] from a `TraceContextExt` trait
-    pub fn with_context<T>(self, context: &T) -> Self
-    where
-        T: TraceContextExt,
-    {
-        if context.has_active_span() {
-            self.with_span_context(context.span().span_context())
-        } else {
-            self
-        }
-    }
-
-    /// Assign severity text
-    pub fn with_severity_text<T>(self, severity: T) -> Self
-    where
-        T: Into<Cow<'static, str>>,
-    {
-        Self {
-            record: LogRecord {
-                severity_text: Some(severity.into()),
-                ..self.record
-            },
-        }
-    }
-
-    /// Assign severity number
-    pub fn with_severity_number(self, severity: Severity) -> Self {
-        Self {
-            record: LogRecord {
-                severity_number: Some(severity),
-                ..self.record
-            },
-        }
-    }
-
-    /// Assign body
-    pub fn with_body(self, body: AnyValue) -> Self {
-        Self {
-            record: LogRecord {
-                body: Some(body),
-                ..self.record
-            },
-        }
-    }
-
-    /// Assign attributes.
-    /// The SDK doesn't carry on any deduplication on these attributes.
-    pub fn with_attributes(self, attributes: Vec<(Key, AnyValue)>) -> Self {
-        Self {
-            record: LogRecord {
-                attributes: Some(attributes),
-                ..self.record
-            },
-        }
-    }
-
-    /// Set a single attribute for this record.
-    /// The SDK doesn't carry on any deduplication on these attributes.
-    pub fn with_attribute<K, V>(mut self, key: K, value: V) -> Self
-    where
-        K: Into<Key>,
-        V: Into<AnyValue>,
-    {
-        if let Some(ref mut vec) = self.record.attributes {
-            vec.push((key.into(), value.into()));
-        } else {
-            let vec = vec![(key.into(), value.into())];
-            self.record.attributes = Some(vec);
-        }
-
-        self
-    }
-
-    /// Build the record, consuming the Builder
-    pub fn build(self) -> LogRecord {
-        self.record
-    }
-}
-
-impl Default for LogRecordBuilder {
-    fn default() -> Self {
-        Self::new()
-    }
-}

opentelemetry-api/src/metrics/instruments/counter.rs

@@ -1,138 +0,0 @@
-use crate::{
-    metrics::{AsyncInstrument, AsyncInstrumentBuilder, InstrumentBuilder, MetricsError},
-    KeyValue,
-};
-use core::fmt;
-use std::sync::Arc;
-use std::{any::Any, convert::TryFrom};
-
-/// An SDK implemented instrument that records increasing values.
-pub trait SyncCounter<T> {
-    /// Records an increment to the counter.
-    fn add(&self, value: T, attributes: &[KeyValue]);
-}
-
-/// An instrument that records increasing values.
-#[derive(Clone)]
-pub struct Counter<T>(Arc<dyn SyncCounter<T> + Send + Sync>);
-
-impl<T> fmt::Debug for Counter<T>
-where
-    T: fmt::Debug,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_fmt(format_args!("Counter<{}>", std::any::type_name::<T>()))
-    }
-}
-
-impl<T> Counter<T> {
-    /// Create a new counter.
-    pub fn new(inner: Arc<dyn SyncCounter<T> + Send + Sync>) -> Self {
-        Counter(inner)
-    }
-
-    /// Records an increment to the counter.
-    pub fn add(&self, value: T, attributes: &[KeyValue]) {
-        self.0.add(value, attributes)
-    }
-}
-
-impl TryFrom<InstrumentBuilder<'_, Counter<u64>>> for Counter<u64> {
-    type Error = MetricsError;
-
-    fn try_from(builder: InstrumentBuilder<'_, Counter<u64>>) -> Result<Self, Self::Error> {
-        builder.meter.instrument_provider.u64_counter(
-            builder.name,
-            builder.description,
-            builder.unit,
-        )
-    }
-}
-
-impl TryFrom<InstrumentBuilder<'_, Counter<f64>>> for Counter<f64> {
-    type Error = MetricsError;
-
-    fn try_from(builder: InstrumentBuilder<'_, Counter<f64>>) -> Result<Self, Self::Error> {
-        builder.meter.instrument_provider.f64_counter(
-            builder.name,
-            builder.description,
-            builder.unit,
-        )
-    }
-}
-
-/// An async instrument that records increasing values.
-#[derive(Clone)]
-pub struct ObservableCounter<T>(Arc<dyn AsyncInstrument<T>>);
-
-impl<T> ObservableCounter<T> {
-    /// Create a new observable counter.
-    pub fn new(inner: Arc<dyn AsyncInstrument<T>>) -> Self {
-        ObservableCounter(inner)
-    }
-}
-
-impl<T> fmt::Debug for ObservableCounter<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_fmt(format_args!(
-            "ObservableCounter<{}>",
-            std::any::type_name::<T>()
-        ))
-    }
-}
-
-impl<T> ObservableCounter<T> {
-    /// Records an increment to the counter.
-    ///
-    /// It is only valid to call this within a callback. If called outside of the
-    /// registered callback it should have no effect on the instrument, and an
-    /// error will be reported via the error handler.
-    pub fn observe(&self, value: T, attributes: &[KeyValue]) {
-        self.0.observe(value, attributes)
-    }
-
-    /// Used for SDKs to downcast instruments in callbacks.
-    pub fn as_any(&self) -> Arc<dyn Any> {
-        self.0.as_any()
-    }
-}
-
-impl<T> AsyncInstrument<T> for ObservableCounter<T> {
-    fn observe(&self, measurement: T, attributes: &[KeyValue]) {
-        self.0.observe(measurement, attributes)
-    }
-
-    fn as_any(&self) -> Arc<dyn Any> {
-        self.0.as_any()
-    }
-}
-
-impl TryFrom<AsyncInstrumentBuilder<'_, ObservableCounter<u64>, u64>> for ObservableCounter<u64> {
-    type Error = MetricsError;
-
-    fn try_from(
-        builder: AsyncInstrumentBuilder<'_, ObservableCounter<u64>, u64>,
-    ) -> Result<Self, Self::Error> {
-        builder.meter.instrument_provider.u64_observable_counter(
-            builder.name,
-            builder.description,
-            builder.unit,
-            builder.callbacks,
-        )
-    }
-}
-
-impl TryFrom<AsyncInstrumentBuilder<'_, ObservableCounter<f64>, f64>> for ObservableCounter<f64> {
-    type Error = MetricsError;
-
-    fn try_from(
-        builder: AsyncInstrumentBuilder<'_, ObservableCounter<f64>, f64>,
-    ) -> Result<Self, Self::Error> {
-        builder.meter.instrument_provider.f64_observable_counter(
-            builder.name,
-            builder.description,
-            builder.unit,
-            builder.callbacks,
-        )
-    }
-}

opentelemetry-api/src/metrics/instruments/gauge.rs

@@ -1,101 +0,0 @@
-use crate::{
-    metrics::{AsyncInstrument, AsyncInstrumentBuilder, MetricsError},
-    KeyValue,
-};
-use core::fmt;
-use std::sync::Arc;
-use std::{any::Any, convert::TryFrom};
-
-/// An instrument that records independent readings.
-#[derive(Clone)]
-pub struct ObservableGauge<T>(Arc<dyn AsyncInstrument<T>>);
-
-impl<T> fmt::Debug for ObservableGauge<T>
-where
-    T: fmt::Debug,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_fmt(format_args!(
-            "ObservableGauge<{}>",
-            std::any::type_name::<T>()
-        ))
-    }
-}
-
-impl<T> ObservableGauge<T> {
-    /// Records the state of the instrument.
-    ///
-    /// It is only valid to call this within a callback. If called outside of the
-    /// registered callback it should have no effect on the instrument, and an
-    /// error will be reported via the error handler.
-    pub fn observe(&self, measurement: T, attributes: &[KeyValue]) {
-        self.0.observe(measurement, attributes)
-    }
-
-    /// Used by SDKs to downcast instruments in callbacks.
-    pub fn as_any(&self) -> Arc<dyn Any> {
-        self.0.as_any()
-    }
-}
-
-impl<M> AsyncInstrument<M> for ObservableGauge<M> {
-    fn observe(&self, measurement: M, attributes: &[KeyValue]) {
-        self.observe(measurement, attributes)
-    }
-
-    fn as_any(&self) -> Arc<dyn Any> {
-        self.0.as_any()
-    }
-}
-
-impl<T> ObservableGauge<T> {
-    /// Create a new gauge
-    pub fn new(inner: Arc<dyn AsyncInstrument<T>>) -> Self {
-        ObservableGauge(inner)
-    }
-}
-
-impl TryFrom<AsyncInstrumentBuilder<'_, ObservableGauge<u64>, u64>> for ObservableGauge<u64> {
-    type Error = MetricsError;
-
-    fn try_from(
-        builder: AsyncInstrumentBuilder<'_, ObservableGauge<u64>, u64>,
-    ) -> Result<Self, Self::Error> {
-        builder.meter.instrument_provider.u64_observable_gauge(
-            builder.name,
-            builder.description,
-            builder.unit,
-            builder.callbacks,
-        )
-    }
-}
-
-impl TryFrom<AsyncInstrumentBuilder<'_, ObservableGauge<f64>, f64>> for ObservableGauge<f64> {
-    type Error = MetricsError;
-
-    fn try_from(
-        builder: AsyncInstrumentBuilder<'_, ObservableGauge<f64>, f64>,
-    ) -> Result<Self, Self::Error> {
-        builder.meter.instrument_provider.f64_observable_gauge(
-            builder.name,
-            builder.description,
-            builder.unit,
-            builder.callbacks,
-        )
-    }
-}
-
-impl TryFrom<AsyncInstrumentBuilder<'_, ObservableGauge<i64>, i64>> for ObservableGauge<i64> {
-    type Error = MetricsError;
-
-    fn try_from(
-        builder: AsyncInstrumentBuilder<'_, ObservableGauge<i64>, i64>,
-    ) -> Result<Self, Self::Error> {
-        builder.meter.instrument_provider.i64_observable_gauge(
-            builder.name,
-            builder.description,
-            builder.unit,
-            builder.callbacks,
-        )
-    }
-}

opentelemetry-api/src/metrics/instruments/histogram.rs

@@ -1,74 +0,0 @@
-use crate::{
-    metrics::{InstrumentBuilder, MetricsError},
-    KeyValue,
-};
-use core::fmt;
-use std::convert::TryFrom;
-use std::sync::Arc;
-
-/// An SDK implemented instrument that records a distribution of values.
-pub trait SyncHistogram<T> {
-    /// Adds an additional value to the distribution.
-    fn record(&self, value: T, attributes: &[KeyValue]);
-}
-
-/// An instrument that records a distribution of values.
-#[derive(Clone)]
-pub struct Histogram<T>(Arc<dyn SyncHistogram<T> + Send + Sync>);
-
-impl<T> fmt::Debug for Histogram<T>
-where
-    T: fmt::Debug,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_fmt(format_args!("Histogram<{}>", std::any::type_name::<T>()))
-    }
-}
-
-impl<T> Histogram<T> {
-    /// Create a new histogram.
-    pub fn new(inner: Arc<dyn SyncHistogram<T> + Send + Sync>) -> Self {
-        Histogram(inner)
-    }
-
-    /// Adds an additional value to the distribution.
-    pub fn record(&self, value: T, attributes: &[KeyValue]) {
-        self.0.record(value, attributes)
-    }
-}
-
-impl TryFrom<InstrumentBuilder<'_, Histogram<f64>>> for Histogram<f64> {
-    type Error = MetricsError;
-
-    fn try_from(builder: InstrumentBuilder<'_, Histogram<f64>>) -> Result<Self, Self::Error> {
-        builder.meter.instrument_provider.f64_histogram(
-            builder.name,
-            builder.description,
-            builder.unit,
-        )
-    }
-}
-
-impl TryFrom<InstrumentBuilder<'_, Histogram<u64>>> for Histogram<u64> {
-    type Error = MetricsError;
-
-    fn try_from(builder: InstrumentBuilder<'_, Histogram<u64>>) -> Result<Self, Self::Error> {
-        builder.meter.instrument_provider.u64_histogram(
-            builder.name,
-            builder.description,
-            builder.unit,
-        )
-    }
-}
-
-impl TryFrom<InstrumentBuilder<'_, Histogram<i64>>> for Histogram<i64> {
-    type Error = MetricsError;
-
-    fn try_from(builder: InstrumentBuilder<'_, Histogram<i64>>) -> Result<Self, Self::Error> {
-        builder.meter.instrument_provider.i64_histogram(
-            builder.name,
-            builder.description,
-            builder.unit,
-        )
-    }
-}

opentelemetry-api/src/metrics/instruments/mod.rs

@@ -1,342 +0,0 @@
-use crate::metrics::{Meter, MetricsError, Result, Unit};
-use crate::{global, KeyValue};
-use core::fmt;
-use std::any::Any;
-use std::borrow::Cow;
-use std::convert::TryFrom;
-use std::marker;
-use std::sync::Arc;
-
-pub(super) mod counter;
-pub(super) mod gauge;
-pub(super) mod histogram;
-pub(super) mod up_down_counter;
-
-// instrument validation error strings
-const INSTRUMENT_NAME_EMPTY: &str = "instrument name must be non-empty";
-const INSTRUMENT_NAME_LENGTH: &str = "instrument name must be less than 64 characters";
-const INSTRUMENT_NAME_INVALID_CHAR: &str =
-    "characters in instrument name must be ASCII and belong to the alphanumeric characters, '_', '.', and '-'";
-const INSTRUMENT_NAME_FIRST_ALPHABETIC: &str =
-    "instrument name must start with an alphabetic character";
-const INSTRUMENT_UNIT_LENGTH: &str = "instrument unit must be less than 64 characters";
-const INSTRUMENT_UNIT_INVALID_CHAR: &str = "characters in instrument unit must be ASCII";
-
-/// An SDK implemented instrument that records measurements via callback.
-pub trait AsyncInstrument<T>: Send + Sync {
-    /// Observes the state of the instrument.
-    ///
-    /// It is only valid to call this within a callback.
-    fn observe(&self, measurement: T, attributes: &[KeyValue]);
-
-    /// Used for SDKs to downcast instruments in callbacks.
-    fn as_any(&self) -> Arc<dyn Any>;
-}
-
-/// Configuration for building a sync instrument.
-pub struct InstrumentBuilder<'a, T> {
-    meter: &'a Meter,
-    name: Cow<'static, str>,
-    description: Option<Cow<'static, str>>,
-    unit: Option<Unit>,
-    _marker: marker::PhantomData<T>,
-}
-
-impl<'a, T> InstrumentBuilder<'a, T>
-where
-    T: TryFrom<Self, Error = MetricsError>,
-{
-    /// Create a new instrument builder
-    pub(crate) fn new(meter: &'a Meter, name: Cow<'static, str>) -> Self {
-        InstrumentBuilder {
-            meter,
-            name,
-            description: None,
-            unit: None,
-            _marker: marker::PhantomData,
-        }
-    }
-
-    /// Set the description for this instrument
-    pub fn with_description<S: Into<Cow<'static, str>>>(mut self, description: S) -> Self {
-        self.description = Some(description.into());
-        self
-    }
-
-    /// Set the unit for this instrument.
-    ///
-    /// Unit is case sensitive(`kb` is not the same as `kB`).
-    ///
-    /// Unit must be:
-    /// - ASCII string
-    /// - No longer than 63 characters
-    pub fn with_unit(mut self, unit: Unit) -> Self {
-        self.unit = Some(unit);
-        self
-    }
-
-    /// Validate the instrument configuration and creates a new instrument.
-    pub fn try_init(self) -> Result<T> {
-        self.validate_instrument_config()
-            .map_err(MetricsError::InvalidInstrumentConfiguration)?;
-        T::try_from(self)
-    }
-
-    /// Creates a new instrument.
-    ///
-    /// This method reports configuration errors but still returns the instrument.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the instrument cannot be created. Use
-    /// [`try_init`](InstrumentBuilder::try_init) if you want to handle errors.
-    pub fn init(self) -> T {
-        if let Err(err) = self.validate_instrument_config() {
-            global::handle_error(MetricsError::InvalidInstrumentConfiguration(err));
-        }
-
-        T::try_from(self).unwrap()
-    }
-
-    fn validate_instrument_config(&self) -> std::result::Result<(), &'static str> {
-        // validate instrument name
-        if self.name.is_empty() {
-            return Err(INSTRUMENT_NAME_EMPTY);
-        }
-        if self.name.len() > 63 {
-            return Err(INSTRUMENT_NAME_LENGTH);
-        }
-        if self.name.starts_with(|c: char| !c.is_ascii_alphabetic()) {
-            return Err(INSTRUMENT_NAME_FIRST_ALPHABETIC);
-        }
-        if self
-            .name
-            .contains(|c: char| !c.is_ascii_alphanumeric() && c != '_' && c != '.' && c != '-')
-        {
-            return Err(INSTRUMENT_NAME_INVALID_CHAR);
-        }
-
-        // validate instrument unit
-        if let Some(unit) = &self.unit {
-            if unit.as_str().len() > 63 {
-                return Err(INSTRUMENT_UNIT_LENGTH);
-            }
-            if unit.as_str().contains(|c: char| !c.is_ascii()) {
-                return Err(INSTRUMENT_UNIT_INVALID_CHAR);
-            }
-        }
-        Ok(())
-    }
-}
-
-impl<T> fmt::Debug for InstrumentBuilder<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("InstrumentBuilder")
-            .field("name", &self.name)
-            .field("description", &self.description)
-            .field("unit", &self.unit)
-            .field("kind", &std::any::type_name::<T>())
-            .finish()
-    }
-}
-
-/// A function registered with a [Meter] that makes observations for the
-/// instruments it is registered with.
-///
-/// The async instrument parameter is used to record measurement observations
-/// for these instruments.
-///
-/// The function needs to complete in a finite amount of time.
-pub type Callback<T> = Box<dyn Fn(&dyn AsyncInstrument<T>) + Send + Sync>;
-
-/// Configuration for building an async instrument.
-pub struct AsyncInstrumentBuilder<'a, I, M>
-where
-    I: AsyncInstrument<M>,
-{
-    meter: &'a Meter,
-    name: Cow<'static, str>,
-    description: Option<Cow<'static, str>>,
-    unit: Option<Unit>,
-    _inst: marker::PhantomData<I>,
-    callbacks: Vec<Callback<M>>,
-}
-
-impl<'a, I, M> AsyncInstrumentBuilder<'a, I, M>
-where
-    I: TryFrom<Self, Error = MetricsError>,
-    I: AsyncInstrument<M>,
-{
-    /// Create a new instrument builder
-    pub(crate) fn new(meter: &'a Meter, name: Cow<'static, str>) -> Self {
-        AsyncInstrumentBuilder {
-            meter,
-            name,
-            description: None,
-            unit: None,
-            _inst: marker::PhantomData,
-            callbacks: Vec::new(),
-        }
-    }
-
-    /// Set the description for this instrument
-    pub fn with_description<S: Into<Cow<'static, str>>>(mut self, description: S) -> Self {
-        self.description = Some(description.into());
-        self
-    }
-
-    /// Set the unit for this instrument.
-    ///
-    /// Unit is case sensitive(`kb` is not the same as `kB`).
-    ///
-    /// Unit must be:
-    /// - ASCII string
-    /// - No longer than 63 characters
-    pub fn with_unit(mut self, unit: Unit) -> Self {
-        self.unit = Some(unit);
-        self
-    }
-
-    /// Set the callback to be called for this instrument.
-    pub fn with_callback<F>(mut self, callback: F) -> Self
-    where
-        F: Fn(&dyn AsyncInstrument<M>) + Send + Sync + 'static,
-    {
-        self.callbacks.push(Box::new(callback));
-        self
-    }
-
-    /// Validate the instrument configuration and creates a new instrument.
-    pub fn try_init(self) -> Result<I> {
-        self.validate_instrument_config()
-            .map_err(MetricsError::InvalidInstrumentConfiguration)?;
-        I::try_from(self)
-    }
-
-    /// Creates a new instrument.
-    ///
-    /// This method reports configuration errors but still returns the instrument.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the instrument cannot be created. Use
-    /// [`try_init`](InstrumentBuilder::try_init) if you want to handle errors.
-    pub fn init(self) -> I {
-        if let Err(err) = self.validate_instrument_config() {
-            global::handle_error(MetricsError::InvalidInstrumentConfiguration(err));
-        }
-
-        I::try_from(self).unwrap()
-    }
-
-    fn validate_instrument_config(&self) -> std::result::Result<(), &'static str> {
-        // validate instrument name
-        if self.name.is_empty() {
-            return Err(INSTRUMENT_NAME_EMPTY);
-        }
-        if self.name.len() > 63 {
-            return Err(INSTRUMENT_NAME_LENGTH);
-        }
-        if self.name.starts_with(|c: char| !c.is_ascii_alphabetic()) {
-            return Err(INSTRUMENT_NAME_FIRST_ALPHABETIC);
-        }
-        if self
-            .name
-            .contains(|c: char| !c.is_ascii_alphanumeric() && c != '_' && c != '.' && c != '-')
-        {
-            return Err(INSTRUMENT_NAME_INVALID_CHAR);
-        }
-
-        // validate instrument unit
-        if let Some(unit) = &self.unit {
-            if unit.as_str().len() > 63 {
-                return Err(INSTRUMENT_UNIT_LENGTH);
-            }
-            if unit.as_str().contains(|c: char| !c.is_ascii()) {
-                return Err(INSTRUMENT_UNIT_INVALID_CHAR);
-            }
-        }
-        Ok(())
-    }
-}
-
-impl<I, M> fmt::Debug for AsyncInstrumentBuilder<'_, I, M>
-where
-    I: AsyncInstrument<M>,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("InstrumentBuilder")
-            .field("name", &self.name)
-            .field("description", &self.description)
-            .field("unit", &self.unit)
-            .field("kind", &std::any::type_name::<I>())
-            .field("callbacks_len", &self.callbacks.len())
-            .finish()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::metrics::instruments::{
-        INSTRUMENT_NAME_FIRST_ALPHABETIC, INSTRUMENT_NAME_INVALID_CHAR, INSTRUMENT_NAME_LENGTH,
-        INSTRUMENT_UNIT_INVALID_CHAR, INSTRUMENT_UNIT_LENGTH,
-    };
-    use crate::metrics::noop::NoopMeterCore;
-    use crate::metrics::{Counter, InstrumentBuilder, Unit};
-    use std::sync::Arc;
-
-    #[test]
-    fn test_instrument_config_validation() {
-        let meter = crate::metrics::Meter::new(Arc::new(NoopMeterCore::new()));
-        // (name, expected error)
-        let instrument_name_test_cases = vec![
-            ("validateName", ""),
-            ("_startWithNoneAlphabet", INSTRUMENT_NAME_FIRST_ALPHABETIC),
-            ("utf8char锈", INSTRUMENT_NAME_INVALID_CHAR),
-            (
-                "a12345678901234567890123456789012345678901234567890123456789012",
-                "",
-            ),
-            (
-                "a123456789012345678901234567890123456789012345678901234567890123",
-                INSTRUMENT_NAME_LENGTH,
-            ),
-            ("invalid name", INSTRUMENT_NAME_INVALID_CHAR),
-        ];
-        for (name, expected_error) in instrument_name_test_cases {
-            let builder: InstrumentBuilder<'_, Counter<u64>> =
-                InstrumentBuilder::new(&meter, name.into());
-            if expected_error.is_empty() {
-                assert!(builder.validate_instrument_config().is_ok());
-            } else {
-                assert_eq!(
-                    builder.validate_instrument_config().unwrap_err(),
-                    expected_error
-                );
-            }
-        }
-
-        // (unit, expected error)
-        let instrument_unit_test_cases = vec![
-            (
-                "0123456789012345678901234567890123456789012345678901234567890123",
-                INSTRUMENT_UNIT_LENGTH,
-            ),
-            ("utf8char锈", INSTRUMENT_UNIT_INVALID_CHAR),
-            ("kb", ""),
-        ];
-
-        for (unit, expected_error) in instrument_unit_test_cases {
-            let builder: InstrumentBuilder<'_, Counter<u64>> =
-                InstrumentBuilder::new(&meter, "test".into()).with_unit(Unit::new(unit));
-            if expected_error.is_empty() {
-                assert!(builder.validate_instrument_config().is_ok());
-            } else {
-                assert_eq!(
-                    builder.validate_instrument_config().unwrap_err(),
-                    expected_error
-                );
-            }
-        }
-    }
-}

opentelemetry-api/src/metrics/instruments/up_down_counter.rs

@@ -1,154 +0,0 @@
-use crate::{
-    metrics::{InstrumentBuilder, MetricsError},
-    KeyValue,
-};
-use core::fmt;
-use std::sync::Arc;
-use std::{any::Any, convert::TryFrom};
-
-use super::{AsyncInstrument, AsyncInstrumentBuilder};
-
-/// An SDK implemented instrument that records increasing or decreasing values.
-pub trait SyncUpDownCounter<T> {
-    /// Records an increment or decrement to the counter.
-    fn add(&self, value: T, attributes: &[KeyValue]);
-}
-
-/// An instrument that records increasing or decreasing values.
-#[derive(Clone)]
-pub struct UpDownCounter<T>(Arc<dyn SyncUpDownCounter<T> + Send + Sync>);
-
-impl<T> fmt::Debug for UpDownCounter<T>
-where
-    T: fmt::Debug,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_fmt(format_args!(
-            "UpDownCounter<{}>",
-            std::any::type_name::<T>()
-        ))
-    }
-}
-
-impl<T> UpDownCounter<T> {
-    /// Create a new up down counter.
-    pub fn new(inner: Arc<dyn SyncUpDownCounter<T> + Send + Sync>) -> Self {
-        UpDownCounter(inner)
-    }
-
-    /// Records an increment or decrement to the counter.
-    pub fn add(&self, value: T, attributes: &[KeyValue]) {
-        self.0.add(value, attributes)
-    }
-}
-
-impl TryFrom<InstrumentBuilder<'_, UpDownCounter<i64>>> for UpDownCounter<i64> {
-    type Error = MetricsError;
-
-    fn try_from(builder: InstrumentBuilder<'_, UpDownCounter<i64>>) -> Result<Self, Self::Error> {
-        builder.meter.instrument_provider.i64_up_down_counter(
-            builder.name,
-            builder.description,
-            builder.unit,
-        )
-    }
-}
-
-impl TryFrom<InstrumentBuilder<'_, UpDownCounter<f64>>> for UpDownCounter<f64> {
-    type Error = MetricsError;
-
-    fn try_from(builder: InstrumentBuilder<'_, UpDownCounter<f64>>) -> Result<Self, Self::Error> {
-        builder.meter.instrument_provider.f64_up_down_counter(
-            builder.name,
-            builder.description,
-            builder.unit,
-        )
-    }
-}
-
-/// An async instrument that records increasing or decreasing values.
-#[derive(Clone)]
-pub struct ObservableUpDownCounter<T>(Arc<dyn AsyncInstrument<T>>);
-
-impl<T> fmt::Debug for ObservableUpDownCounter<T>
-where
-    T: fmt::Debug,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_fmt(format_args!(
-            "ObservableUpDownCounter<{}>",
-            std::any::type_name::<T>()
-        ))
-    }
-}
-
-impl<T> ObservableUpDownCounter<T> {
-    /// Create a new observable up down counter.
-    pub fn new(inner: Arc<dyn AsyncInstrument<T>>) -> Self {
-        ObservableUpDownCounter(inner)
-    }
-
-    /// Records the increment or decrement to the counter.
-    ///
-    /// It is only valid to call this within a callback. If called outside of the
-    /// registered callback it should have no effect on the instrument, and an
-    /// error will be reported via the error handler.
-    pub fn observe(&self, value: T, attributes: &[KeyValue]) {
-        self.0.observe(value, attributes)
-    }
-
-    /// Used for SDKs to downcast instruments in callbacks.
-    pub fn as_any(&self) -> Arc<dyn Any> {
-        self.0.as_any()
-    }
-}
-
-impl<T> AsyncInstrument<T> for ObservableUpDownCounter<T> {
-    fn observe(&self, measurement: T, attributes: &[KeyValue]) {
-        self.0.observe(measurement, attributes)
-    }
-
-    fn as_any(&self) -> Arc<dyn std::any::Any> {
-        self.0.as_any()
-    }
-}
-
-impl TryFrom<AsyncInstrumentBuilder<'_, ObservableUpDownCounter<i64>, i64>>
-    for ObservableUpDownCounter<i64>
-{
-    type Error = MetricsError;
-
-    fn try_from(
-        builder: AsyncInstrumentBuilder<'_, ObservableUpDownCounter<i64>, i64>,
-    ) -> Result<Self, Self::Error> {
-        builder
-            .meter
-            .instrument_provider
-            .i64_observable_up_down_counter(
-                builder.name,
-                builder.description,
-                builder.unit,
-                builder.callbacks,
-            )
-    }
-}
-
-impl TryFrom<AsyncInstrumentBuilder<'_, ObservableUpDownCounter<f64>, f64>>
-    for ObservableUpDownCounter<f64>
-{
-    type Error = MetricsError;
-
-    fn try_from(
-        builder: AsyncInstrumentBuilder<'_, ObservableUpDownCounter<f64>, f64>,
-    ) -> Result<Self, Self::Error> {
-        builder
-            .meter
-            .instrument_provider
-            .f64_observable_up_down_counter(
-                builder.name,
-                builder.description,
-                builder.unit,
-                builder.callbacks,
-            )
-    }
-}

opentelemetry-api/src/metrics/meter.rs

@@ -1,219 +0,0 @@
-use core::fmt;
-use std::any::Any;
-use std::borrow::Cow;
-use std::sync::Arc;
-
-use crate::metrics::{
-    AsyncInstrumentBuilder, Counter, Histogram, InstrumentBuilder, InstrumentProvider,
-    ObservableCounter, ObservableGauge, ObservableUpDownCounter, Result, UpDownCounter,
-};
-use crate::KeyValue;
-
-use super::AsyncInstrument;
-
-/// Provides access to named [Meter] instances, for instrumenting an application
-/// or crate.
-pub trait MeterProvider {
-    /// Returns a new [Meter] with the provided name and default configuration.
-    ///
-    /// A [Meter] should be scoped at most to a single application or crate. The
-    /// name needs to be unique so it does not collide with other names used by
-    /// an application, nor other applications.
-    ///
-    /// If the name is empty, then an implementation defined default name will
-    /// be used instead.
-    fn meter(&self, name: impl Into<Cow<'static, str>>) -> Meter {
-        self.versioned_meter(
-            name,
-            None::<Cow<'static, str>>,
-            None::<Cow<'static, str>>,
-            None,
-        )
-    }
-
-    /// Creates an implementation of the [`Meter`] interface.
-    ///
-    /// The instrumentation name must be the name of the library providing instrumentation. This
-    /// name may be the same as the instrumented code only if that code provides built-in
-    /// instrumentation. If the instrumentation name is empty, then a implementation defined
-    /// default name will be used instead.
-    fn versioned_meter(
-        &self,
-        name: impl Into<Cow<'static, str>>,
-        version: Option<impl Into<Cow<'static, str>>>,
-        schema_url: Option<impl Into<Cow<'static, str>>>,
-        attributes: Option<Vec<KeyValue>>,
-    ) -> Meter;
-}
-
-/// Provides access to instrument instances for recording metrics.
-#[derive(Clone)]
-pub struct Meter {
-    pub(crate) instrument_provider: Arc<dyn InstrumentProvider + Send + Sync>,
-}
-
-impl Meter {
-    /// Create a new named meter from an instrumentation provider
-    #[doc(hidden)]
-    pub fn new(instrument_provider: Arc<dyn InstrumentProvider + Send + Sync>) -> Self {
-        Meter {
-            instrument_provider,
-        }
-    }
-
-    /// creates an instrument builder for recording increasing values.
-    pub fn u64_counter(
-        &self,
-        name: impl Into<Cow<'static, str>>,
-    ) -> InstrumentBuilder<'_, Counter<u64>> {
-        InstrumentBuilder::new(self, name.into())
-    }
-
-    /// creates an instrument builder for recording increasing values.
-    pub fn f64_counter(
-        &self,
-        name: impl Into<Cow<'static, str>>,
-    ) -> InstrumentBuilder<'_, Counter<f64>> {
-        InstrumentBuilder::new(self, name.into())
-    }
-
-    /// creates an instrument builder for recording increasing values via callback.
-    pub fn u64_observable_counter(
-        &self,
-        name: impl Into<Cow<'static, str>>,
-    ) -> AsyncInstrumentBuilder<'_, ObservableCounter<u64>, u64> {
-        AsyncInstrumentBuilder::new(self, name.into())
-    }
-
-    /// creates an instrument builder for recording increasing values via callback.
-    pub fn f64_observable_counter(
-        &self,
-        name: impl Into<Cow<'static, str>>,
-    ) -> AsyncInstrumentBuilder<'_, ObservableCounter<f64>, f64> {
-        AsyncInstrumentBuilder::new(self, name.into())
-    }
-
-    /// creates an instrument builder for recording changes of a value.
-    pub fn i64_up_down_counter(
-        &self,
-        name: impl Into<Cow<'static, str>>,
-    ) -> InstrumentBuilder<'_, UpDownCounter<i64>> {
-        InstrumentBuilder::new(self, name.into())
-    }
-
-    /// creates an instrument builder for recording changes of a value.
-    pub fn f64_up_down_counter(
-        &self,
-        name: impl Into<Cow<'static, str>>,
-    ) -> InstrumentBuilder<'_, UpDownCounter<f64>> {
-        InstrumentBuilder::new(self, name.into())
-    }
-
-    /// creates an instrument builder for recording changes of a value via callback.
-    pub fn i64_observable_up_down_counter(
-        &self,
-        name: impl Into<Cow<'static, str>>,
-    ) -> AsyncInstrumentBuilder<'_, ObservableUpDownCounter<i64>, i64> {
-        AsyncInstrumentBuilder::new(self, name.into())
-    }
-
-    /// creates an instrument builder for recording changes of a value via callback.
-    pub fn f64_observable_up_down_counter(
-        &self,
-        name: impl Into<Cow<'static, str>>,
-    ) -> AsyncInstrumentBuilder<'_, ObservableUpDownCounter<f64>, f64> {
-        AsyncInstrumentBuilder::new(self, name.into())
-    }
-
-    /// creates an instrument builder for recording the current value via callback.
-    pub fn u64_observable_gauge(
-        &self,
-        name: impl Into<Cow<'static, str>>,
-    ) -> AsyncInstrumentBuilder<'_, ObservableGauge<u64>, u64> {
-        AsyncInstrumentBuilder::new(self, name.into())
-    }
-
-    /// creates an instrument builder for recording the current value via callback.
-    pub fn i64_observable_gauge(
-        &self,
-        name: impl Into<Cow<'static, str>>,
-    ) -> AsyncInstrumentBuilder<'_, ObservableGauge<i64>, i64> {
-        AsyncInstrumentBuilder::new(self, name.into())
-    }
-
-    /// creates an instrument builder for recording the current value via callback.
-    pub fn f64_observable_gauge(
-        &self,
-        name: impl Into<Cow<'static, str>>,
-    ) -> AsyncInstrumentBuilder<'_, ObservableGauge<f64>, f64> {
-        AsyncInstrumentBuilder::new(self, name.into())
-    }
-
-    /// creates an instrument builder for recording a distribution of values.
-    pub fn f64_histogram(
-        &self,
-        name: impl Into<Cow<'static, str>>,
-    ) -> InstrumentBuilder<'_, Histogram<f64>> {
-        InstrumentBuilder::new(self, name.into())
-    }
-
-    /// creates an instrument builder for recording a distribution of values.
-    pub fn u64_histogram(
-        &self,
-        name: impl Into<Cow<'static, str>>,
-    ) -> InstrumentBuilder<'_, Histogram<u64>> {
-        InstrumentBuilder::new(self, name.into())
-    }
-
-    /// creates an instrument builder for recording a distribution of values.
-    pub fn i64_histogram(
-        &self,
-        name: impl Into<Cow<'static, str>>,
-    ) -> InstrumentBuilder<'_, Histogram<i64>> {
-        InstrumentBuilder::new(self, name.into())
-    }
-
-    /// Registers a callback to be called during the collection of a measurement
-    /// cycle.
-    ///
-    /// The instruments passed as arguments to be registered are the only
-    /// instruments that may observe values.
-    ///
-    /// If no instruments are passed, the callback will not be registered.
-    pub fn register_callback<F>(
-        &self,
-        instruments: &[Arc<dyn Any>],
-        callback: F,
-    ) -> Result<Box<dyn CallbackRegistration>>
-    where
-        F: Fn(&dyn Observer) + Send + Sync + 'static,
-    {
-        self.instrument_provider
-            .register_callback(instruments, Box::new(callback))
-    }
-}
-
-/// A token representing the unique registration of a callback for a set of
-/// instruments with a [Meter].
-pub trait CallbackRegistration: Send + Sync {
-    /// Removes the callback registration from its associated [Meter].
-    fn unregister(&mut self) -> Result<()>;
-}
-
-/// Records measurements for multiple instruments in a callback.
-pub trait Observer {
-    /// Records the f64 value with attributes for the observable.
-    fn observe_f64(&self, inst: &dyn AsyncInstrument<f64>, measurement: f64, attrs: &[KeyValue]);
-
-    /// Records the u64 value with attributes for the observable.
-    fn observe_u64(&self, inst: &dyn AsyncInstrument<u64>, measurement: u64, attrs: &[KeyValue]);
-
-    /// Records the i64 value with attributes for the observable.
-    fn observe_i64(&self, inst: &dyn AsyncInstrument<i64>, measurement: i64, attrs: &[KeyValue]);
-}
-
-impl fmt::Debug for Meter {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("Meter")
-    }
-}

opentelemetry-api/src/metrics/mod.rs

@@ -1,261 +0,0 @@
-//! # OpenTelemetry Metrics API
-
-use std::any::Any;
-use std::result;
-use std::sync::PoisonError;
-use std::{borrow::Cow, sync::Arc};
-use thiserror::Error;
-
-mod instruments;
-mod meter;
-pub mod noop;
-
-use crate::ExportError;
-pub use instruments::{
-    counter::{Counter, ObservableCounter, SyncCounter},
-    gauge::ObservableGauge,
-    histogram::{Histogram, SyncHistogram},
-    up_down_counter::{ObservableUpDownCounter, SyncUpDownCounter, UpDownCounter},
-    AsyncInstrument, AsyncInstrumentBuilder, Callback, InstrumentBuilder,
-};
-pub use meter::{CallbackRegistration, Meter, MeterProvider, Observer};
-
-/// A specialized `Result` type for metric operations.
-pub type Result<T> = result::Result<T, MetricsError>;
-
-/// Errors returned by the metrics API.
-#[derive(Error, Debug)]
-#[non_exhaustive]
-pub enum MetricsError {
-    /// Other errors not covered by specific cases.
-    #[error("Metrics error: {0}")]
-    Other(String),
-    /// Invalid configuration
-    #[error("Config error {0}")]
-    Config(String),
-    /// Fail to export metrics
-    #[error("Metrics exporter {} failed with {0}", .0.exporter_name())]
-    ExportErr(Box<dyn ExportError>),
-    /// Invalid instrument configuration such invalid instrument name, invalid instrument description, invalid instrument unit, etc.
-    /// See [spec](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#general-characteristics)
-    /// for full list of requirements.
-    #[error("Invalid instrument configuration: {0}")]
-    InvalidInstrumentConfiguration(&'static str),
-}
-
-impl<T: ExportError> From<T> for MetricsError {
-    fn from(err: T) -> Self {
-        MetricsError::ExportErr(Box::new(err))
-    }
-}
-
-impl<T> From<PoisonError<T>> for MetricsError {
-    fn from(err: PoisonError<T>) -> Self {
-        MetricsError::Other(err.to_string())
-    }
-}
-
-/// Units denote underlying data units tracked by `Meter`s.
-#[derive(Clone, Default, Debug, PartialEq, Eq, Hash)]
-pub struct Unit(Cow<'static, str>);
-
-impl Unit {
-    /// Create a new `Unit` from an `Into<String>`
-    pub fn new<S>(value: S) -> Self
-    where
-        S: Into<Cow<'static, str>>,
-    {
-        Unit(value.into())
-    }
-
-    /// View unit as &str
-    pub fn as_str(&self) -> &str {
-        self.0.as_ref()
-    }
-}
-
-impl AsRef<str> for Unit {
-    #[inline]
-    fn as_ref(&self) -> &str {
-        self.0.as_ref()
-    }
-}
-
-/// SDK implemented trait for creating instruments
-pub trait InstrumentProvider {
-    /// creates an instrument for recording increasing values.
-    fn u64_counter(
-        &self,
-        _name: Cow<'static, str>,
-        _description: Option<Cow<'static, str>>,
-        _unit: Option<Unit>,
-    ) -> Result<Counter<u64>> {
-        Ok(Counter::new(Arc::new(noop::NoopSyncInstrument::new())))
-    }
-
-    /// creates an instrument for recording increasing values.
-    fn f64_counter(
-        &self,
-        _name: Cow<'static, str>,
-        _description: Option<Cow<'static, str>>,
-        _unit: Option<Unit>,
-    ) -> Result<Counter<f64>> {
-        Ok(Counter::new(Arc::new(noop::NoopSyncInstrument::new())))
-    }
-
-    /// creates an instrument for recording increasing values via callback.
-    fn u64_observable_counter(
-        &self,
-        _name: Cow<'static, str>,
-        _description: Option<Cow<'static, str>>,
-        _unit: Option<Unit>,
-        _callback: Vec<Callback<u64>>,
-    ) -> Result<ObservableCounter<u64>> {
-        Ok(ObservableCounter::new(Arc::new(
-            noop::NoopAsyncInstrument::new(),
-        )))
-    }
-
-    /// creates an instrument for recording increasing values via callback.
-    fn f64_observable_counter(
-        &self,
-        _name: Cow<'static, str>,
-        _description: Option<Cow<'static, str>>,
-        _unit: Option<Unit>,
-        _callback: Vec<Callback<f64>>,
-    ) -> Result<ObservableCounter<f64>> {
-        Ok(ObservableCounter::new(Arc::new(
-            noop::NoopAsyncInstrument::new(),
-        )))
-    }
-
-    /// creates an instrument for recording changes of a value.
-    fn i64_up_down_counter(
-        &self,
-        _name: Cow<'static, str>,
-        _description: Option<Cow<'static, str>>,
-        _unit: Option<Unit>,
-    ) -> Result<UpDownCounter<i64>> {
-        Ok(UpDownCounter::new(
-            Arc::new(noop::NoopSyncInstrument::new()),
-        ))
-    }
-
-    /// creates an instrument for recording changes of a value.
-    fn f64_up_down_counter(
-        &self,
-        _name: Cow<'static, str>,
-        _description: Option<Cow<'static, str>>,
-        _unit: Option<Unit>,
-    ) -> Result<UpDownCounter<f64>> {
-        Ok(UpDownCounter::new(
-            Arc::new(noop::NoopSyncInstrument::new()),
-        ))
-    }
-
-    /// creates an instrument for recording changes of a value.
-    fn i64_observable_up_down_counter(
-        &self,
-        _name: Cow<'static, str>,
-        _description: Option<Cow<'static, str>>,
-        _unit: Option<Unit>,
-        _callback: Vec<Callback<i64>>,
-    ) -> Result<ObservableUpDownCounter<i64>> {
-        Ok(ObservableUpDownCounter::new(Arc::new(
-            noop::NoopAsyncInstrument::new(),
-        )))
-    }
-
-    /// creates an instrument for recording changes of a value via callback.
-    fn f64_observable_up_down_counter(
-        &self,
-        _name: Cow<'static, str>,
-        _description: Option<Cow<'static, str>>,
-        _unit: Option<Unit>,
-        _callback: Vec<Callback<f64>>,
-    ) -> Result<ObservableUpDownCounter<f64>> {
-        Ok(ObservableUpDownCounter::new(Arc::new(
-            noop::NoopAsyncInstrument::new(),
-        )))
-    }
-
-    /// creates an instrument for recording the current value via callback.
-    fn u64_observable_gauge(
-        &self,
-        _name: Cow<'static, str>,
-        _description: Option<Cow<'static, str>>,
-        _unit: Option<Unit>,
-        _callback: Vec<Callback<u64>>,
-    ) -> Result<ObservableGauge<u64>> {
-        Ok(ObservableGauge::new(Arc::new(
-            noop::NoopAsyncInstrument::new(),
-        )))
-    }
-
-    /// creates an instrument for recording the current value via callback.
-    fn i64_observable_gauge(
-        &self,
-        _name: Cow<'static, str>,
-        _description: Option<Cow<'static, str>>,
-        _unit: Option<Unit>,
-        _callback: Vec<Callback<i64>>,
-    ) -> Result<ObservableGauge<i64>> {
-        Ok(ObservableGauge::new(Arc::new(
-            noop::NoopAsyncInstrument::new(),
-        )))
-    }
-
-    /// creates an instrument for recording the current value via callback.
-    fn f64_observable_gauge(
-        &self,
-        _name: Cow<'static, str>,
-        _description: Option<Cow<'static, str>>,
-        _unit: Option<Unit>,
-        _callback: Vec<Callback<f64>>,
-    ) -> Result<ObservableGauge<f64>> {
-        Ok(ObservableGauge::new(Arc::new(
-            noop::NoopAsyncInstrument::new(),
-        )))
-    }
-
-    /// creates an instrument for recording a distribution of values.
-    fn f64_histogram(
-        &self,
-        _name: Cow<'static, str>,
-        _description: Option<Cow<'static, str>>,
-        _unit: Option<Unit>,
-    ) -> Result<Histogram<f64>> {
-        Ok(Histogram::new(Arc::new(noop::NoopSyncInstrument::new())))
-    }
-
-    /// creates an instrument for recording a distribution of values.
-    fn u64_histogram(
-        &self,
-        _name: Cow<'static, str>,
-        _description: Option<Cow<'static, str>>,
-        _unit: Option<Unit>,
-    ) -> Result<Histogram<u64>> {
-        Ok(Histogram::new(Arc::new(noop::NoopSyncInstrument::new())))
-    }
-
-    /// creates an instrument for recording a distribution of values.
-    fn i64_histogram(
-        &self,
-        _name: Cow<'static, str>,
-        _description: Option<Cow<'static, str>>,
-        _unit: Option<Unit>,
-    ) -> Result<Histogram<i64>> {
-        Ok(Histogram::new(Arc::new(noop::NoopSyncInstrument::new())))
-    }
-
-    /// Captures the function that will be called during data collection.
-    ///
-    /// It is only valid to call `observe` within the scope of the passed function.
-    fn register_callback(
-        &self,
-        instruments: &[Arc<dyn Any>],
-        callbacks: Box<MultiInstrumentCallback>,
-    ) -> Result<Box<dyn CallbackRegistration>>;
-}
-
-type MultiInstrumentCallback = dyn Fn(&dyn Observer) + Send + Sync;

opentelemetry-api/src/metrics/noop.rs

@@ -1,134 +0,0 @@
-//! # No-op OpenTelemetry Metrics Implementation
-//!
-//! This implementation is returned as the global Meter if no `Meter`
-//! has been set. It is also useful for testing purposes as it is intended
-//! to have minimal resource utilization and runtime impact.
-use crate::{
-    metrics::{
-        AsyncInstrument, CallbackRegistration, InstrumentProvider, Meter, MeterProvider, Observer,
-        Result, SyncCounter, SyncHistogram, SyncUpDownCounter,
-    },
-    KeyValue,
-};
-use std::{any::Any, borrow::Cow, sync::Arc};
-
-/// A no-op instance of a `MetricProvider`
-#[derive(Debug, Default)]
-pub struct NoopMeterProvider {
-    _private: (),
-}
-
-impl NoopMeterProvider {
-    /// Create a new no-op meter provider.
-    pub fn new() -> Self {
-        NoopMeterProvider { _private: () }
-    }
-}
-
-impl MeterProvider for NoopMeterProvider {
-    fn versioned_meter(
-        &self,
-        _name: impl Into<Cow<'static, str>>,
-        _version: Option<impl Into<Cow<'static, str>>>,
-        _schema_url: Option<impl Into<Cow<'static, str>>>,
-        _attributes: Option<Vec<KeyValue>>,
-    ) -> Meter {
-        Meter::new(Arc::new(NoopMeterCore::new()))
-    }
-}
-
-/// A no-op instance of a `Meter`
-#[derive(Debug, Default)]
-pub struct NoopMeterCore {
-    _private: (),
-}
-
-impl NoopMeterCore {
-    /// Create a new no-op meter core.
-    pub fn new() -> Self {
-        NoopMeterCore { _private: () }
-    }
-}
-
-impl InstrumentProvider for NoopMeterCore {
-    fn register_callback(
-        &self,
-        _instruments: &[Arc<dyn Any>],
-        _callback: Box<dyn Fn(&dyn Observer) + Send + Sync>,
-    ) -> Result<Box<dyn CallbackRegistration>> {
-        Ok(Box::new(NoopRegistration::new()))
-    }
-}
-
-/// A no-op instance of a callback [CallbackRegistration].
-#[derive(Debug, Default)]
-pub struct NoopRegistration {
-    _private: (),
-}
-
-impl NoopRegistration {
-    /// Create a new no-op registration.
-    pub fn new() -> Self {
-        NoopRegistration { _private: () }
-    }
-}
-
-impl CallbackRegistration for NoopRegistration {
-    fn unregister(&mut self) -> Result<()> {
-        Ok(())
-    }
-}
-
-/// A no-op sync instrument
-#[derive(Debug, Default)]
-pub struct NoopSyncInstrument {
-    _private: (),
-}
-
-impl NoopSyncInstrument {
-    /// Create a new no-op sync instrument
-    pub fn new() -> Self {
-        NoopSyncInstrument { _private: () }
-    }
-}
-
-impl<T> SyncCounter<T> for NoopSyncInstrument {
-    fn add(&self, _value: T, _attributes: &[KeyValue]) {
-        // Ignored
-    }
-}
-
-impl<T> SyncUpDownCounter<T> for NoopSyncInstrument {
-    fn add(&self, _value: T, _attributes: &[KeyValue]) {
-        // Ignored
-    }
-}
-
-impl<T> SyncHistogram<T> for NoopSyncInstrument {
-    fn record(&self, _value: T, _attributes: &[KeyValue]) {
-        // Ignored
-    }
-}
-
-/// A no-op async instrument.
-#[derive(Debug, Default)]
-pub struct NoopAsyncInstrument {
-    _private: (),
-}
-
-impl NoopAsyncInstrument {
-    /// Create a new no-op async instrument
-    pub fn new() -> Self {
-        NoopAsyncInstrument { _private: () }
-    }
-}
-
-impl<T> AsyncInstrument<T> for NoopAsyncInstrument {
-    fn observe(&self, _value: T, _attributes: &[KeyValue]) {
-        // Ignored
-    }
-
-    fn as_any(&self) -> Arc<dyn Any> {
-        Arc::new(())
-    }
-}

opentelemetry-api/src/order_map.rs

@@ -1,670 +0,0 @@
-use crate::{Key, KeyValue, Value};
-use indexmap::map::{
-    Drain, Entry, IntoIter, IntoKeys, IntoValues, Iter, IterMut, Keys, Values, ValuesMut,
-};
-use indexmap::{Equivalent, IndexMap};
-use std::collections::hash_map::RandomState;
-use std::hash::{BuildHasher, Hash};
-use std::iter::FromIterator;
-use std::ops::{Index, IndexMut, RangeBounds};
-
-/// A hash table implementation that preserves insertion order across all operations.
-///
-/// Entries will be returned according to their insertion order when iterating over the collection.
-#[derive(Clone, Debug)]
-pub struct OrderMap<K, V, S = RandomState>(IndexMap<K, V, S>);
-
-impl<K, V> OrderMap<K, V> {
-    /// Create a new map. (Does not allocate)
-    #[inline]
-    pub fn new() -> Self {
-        Self(IndexMap::new())
-    }
-
-    /// Create a new map with capacity for `n` key-value pairs. (Does not
-    /// allocate if `n` is zero.)
-    ///
-    /// Computes in **O(n)** time.
-    #[inline]
-    pub fn with_capacity(n: usize) -> Self {
-        Self(IndexMap::with_capacity(n))
-    }
-}
-
-impl<K, V, S> OrderMap<K, V, S> {
-    /// Create a new map with capacity for `n` key-value pairs. (Does not
-    /// allocate if `n` is zero.)
-    ///
-    /// Computes in **O(n)** time.
-    #[inline]
-    pub fn with_capacity_and_hasher(n: usize, hash_builder: S) -> Self {
-        Self(IndexMap::with_capacity_and_hasher(n, hash_builder))
-    }
-
-    /// Create a new map with `hash_builder`.
-    ///
-    /// This function is `const`, so it
-    /// can be called in `static` contexts.
-    pub const fn with_hasher(hash_builder: S) -> Self {
-        Self(IndexMap::with_hasher(hash_builder))
-    }
-
-    /// Computes in **O(1)** time.
-    pub fn capacity(&self) -> usize {
-        self.0.capacity()
-    }
-
-    /// Return a reference to the map's `BuildHasher`.
-    pub fn hasher(&self) -> &S {
-        self.0.hasher()
-    }
-
-    /// Return the number of key-value pairs in the map.
-    ///
-    /// Computes in **O(1)** time.
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    /// Returns true if the map contains no elements.
-    ///
-    /// Computes in **O(1)** time.
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-
-    /// Return an iterator over the key-value pairs of the map, in their order
-    pub fn iter(&self) -> Iter<'_, K, V> {
-        self.0.iter()
-    }
-
-    /// Return an iterator over the key-value pairs of the map, in their order
-    pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
-        self.0.iter_mut()
-    }
-
-    /// Return an iterator over the keys of the map, in their order
-    pub fn keys(&self) -> Keys<'_, K, V> {
-        self.0.keys()
-    }
-
-    /// Return an owning iterator over the keys of the map, in their order
-    pub fn into_keys(self) -> IntoKeys<K, V> {
-        self.0.into_keys()
-    }
-
-    /// Return an iterator over the values of the map, in their order
-    pub fn values(&self) -> Values<'_, K, V> {
-        self.0.values()
-    }
-
-    /// Return an iterator over mutable references to the values of the map,
-    /// in their order
-    pub fn values_mut(&mut self) -> ValuesMut<'_, K, V> {
-        self.0.values_mut()
-    }
-
-    /// Return an owning iterator over the values of the map, in their order
-    pub fn into_values(self) -> IntoValues<K, V> {
-        self.0.into_values()
-    }
-
-    /// Remove all key-value pairs in the map, while preserving its capacity.
-    ///
-    /// Computes in **O(n)** time.
-    pub fn clear(&mut self) {
-        self.0.clear();
-    }
-
-    /// Shortens the map, keeping the first `len` elements and dropping the rest.
-    ///
-    /// If `len` is greater than the map's current length, this has no effect.
-    pub fn truncate(&mut self, len: usize) {
-        self.0.truncate(len);
-    }
-
-    /// Clears the `IndexMap` in the given index range, returning those
-    /// key-value pairs as a drain iterator.
-    ///
-    /// The range may be any type that implements `RangeBounds<usize>`,
-    /// including all of the `std::ops::Range*` types, or even a tuple pair of
-    /// `Bound` start and end values. To drain the map entirely, use `RangeFull`
-    /// like `map.drain(..)`.
-    ///
-    /// This shifts down all entries following the drained range to fill the
-    /// gap, and keeps the allocated memory for reuse.
-    ///
-    /// ***Panics*** if the starting point is greater than the end point or if
-    /// the end point is greater than the length of the map.
-    pub fn drain<R>(&mut self, range: R) -> Drain<'_, K, V>
-    where
-        R: RangeBounds<usize>,
-    {
-        self.0.drain(range)
-    }
-
-    /// Splits the collection into two at the given index.
-    ///
-    /// Returns a newly allocated map containing the elements in the range
-    /// `[at, len)`. After the call, the original map will be left containing
-    /// the elements `[0, at)` with its previous capacity unchanged.
-    ///
-    /// ***Panics*** if `at > len`.
-    pub fn split_off(&mut self, at: usize) -> Self
-    where
-        S: Clone,
-    {
-        Self(self.0.split_off(at))
-    }
-}
-
-impl<K, V, S> OrderMap<K, V, S>
-where
-    K: Hash + Eq,
-    S: BuildHasher,
-{
-    /// Reserve capacity for `additional` more key-value pairs.
-    ///
-    /// Computes in **O(n)** time.
-    pub fn reserve(&mut self, additional: usize) {
-        self.0.reserve(additional)
-    }
-
-    /// Shrink the capacity of the map as much as possible.
-    ///
-    /// Computes in **O(n)** time.
-    pub fn shrink_to_fit(&mut self) {
-        self.0.shrink_to_fit()
-    }
-
-    /// Insert a key-value pair in the map.
-    ///
-    /// If an equivalent key already exists in the map: the key remains and
-    /// retains in its place in the order, its corresponding value is updated
-    /// with `value` and the older value is returned inside `Some(_)`.
-    ///
-    /// If no equivalent key existed in the map: the new key-value pair is
-    /// inserted, last in order, and `None` is returned.
-    ///
-    /// Computes in **O(1)** time (amortized average).
-    ///
-    /// See also [`entry`](#method.entry) if you you want to insert *or* modify
-    /// or if you need to get the index of the corresponding key-value pair.
-    pub fn insert(&mut self, key: K, value: V) -> Option<V> {
-        self.0.insert(key, value)
-    }
-
-    /// Insert a key-value pair in the map, and get their index.
-    ///
-    /// If an equivalent key already exists in the map: the key remains and
-    /// retains in its place in the order, its corresponding value is updated
-    /// with `value` and the older value is returned inside `(index, Some(_))`.
-    ///
-    /// If no equivalent key existed in the map: the new key-value pair is
-    /// inserted, last in order, and `(index, None)` is returned.
-    ///
-    /// Computes in **O(1)** time (amortized average).
-    ///
-    /// See also [`entry`](#method.entry) if you you want to insert *or* modify
-    /// or if you need to get the index of the corresponding key-value pair.
-    pub fn insert_full(&mut self, key: K, value: V) -> (usize, Option<V>) {
-        self.0.insert_full(key, value)
-    }
-
-    /// Get the given key’s corresponding entry in the map for insertion and/or
-    /// in-place manipulation.
-    ///
-    /// Computes in **O(1)** time (amortized average).
-    pub fn entry(&mut self, key: K) -> Entry<'_, K, V> {
-        self.0.entry(key)
-    }
-
-    /// Return `true` if an equivalent to `key` exists in the map.
-    ///
-    /// Computes in **O(1)** time (average).
-    pub fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool
-    where
-        Q: Hash + Equivalent<K>,
-    {
-        self.0.contains_key(key)
-    }
-
-    /// Return a reference to the value stored for `key`, if it is present,
-    /// else `None`.
-    ///
-    /// Computes in **O(1)** time (average).
-    pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&V>
-    where
-        Q: Hash + Equivalent<K>,
-    {
-        self.0.get(key)
-    }
-
-    /// Return references to the key-value pair stored for `key`,
-    /// if it is present, else `None`.
-    ///
-    /// Computes in **O(1)** time (average).
-    pub fn get_key_value<Q: ?Sized>(&self, key: &Q) -> Option<(&K, &V)>
-    where
-        Q: Hash + Equivalent<K>,
-    {
-        self.0.get_key_value(key)
-    }
-
-    /// Return item index, key and value
-    pub fn get_full<Q: ?Sized>(&self, key: &Q) -> Option<(usize, &K, &V)>
-    where
-        Q: Hash + Equivalent<K>,
-    {
-        self.0.get_full(key)
-    }
-
-    /// Return item index, if it exists in the map
-    ///
-    /// Computes in **O(1)** time (average).
-    pub fn get_index_of<Q: ?Sized>(&self, key: &Q) -> Option<usize>
-    where
-        Q: Hash + Equivalent<K>,
-    {
-        self.0.get_index_of(key)
-    }
-
-    /// Return a mutable reference to the element pointed at by `key`, if it exists.
-    pub fn get_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<&mut V>
-    where
-        Q: Hash + Equivalent<K>,
-    {
-        self.0.get_mut(key)
-    }
-
-    /// Return a mutable reference to the element pointed at by `key`, if it exists.
-    /// It also returns the element's index and its key.
-    pub fn get_full_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<(usize, &K, &mut V)>
-    where
-        Q: Hash + Equivalent<K>,
-    {
-        self.0.get_full_mut(key)
-    }
-
-    /// Remove the key-value pair equivalent to `key` and return
-    /// its value.
-    ///
-    /// Like `Vec::remove`, the pair is removed by shifting all of the
-    /// elements that follow it, preserving their relative order.
-    /// **This perturbs the index of all of those elements!**
-    ///
-    /// Return `None` if `key` is not in map.
-    ///
-    /// Computes in **O(n)** time (average).
-    pub fn shift_remove<Q: ?Sized>(&mut self, key: &Q) -> Option<V>
-    where
-        Q: Hash + Equivalent<K>,
-    {
-        self.0.shift_remove(key)
-    }
-
-    /// Remove and return the key-value pair equivalent to `key`.
-    ///
-    /// Like `Vec::remove`, the pair is removed by shifting all of the
-    /// elements that follow it, preserving their relative order.
-    /// **This perturbs the index of all of those elements!**
-    ///
-    /// Return `None` if `key` is not in map.
-    ///
-    /// Computes in **O(n)** time (average).
-    pub fn shift_remove_entry<Q: ?Sized>(&mut self, key: &Q) -> Option<(K, V)>
-    where
-        Q: Hash + Equivalent<K>,
-    {
-        self.0.shift_remove_entry(key)
-    }
-
-    /// Remove the key-value pair equivalent to `key` and return it and
-    /// the index it had.
-    ///
-    /// Like `Vec::remove`, the pair is removed by shifting all of the
-    /// elements that follow it, preserving their relative order.
-    /// **This perturbs the index of all of those elements!**
-    ///
-    /// Return `None` if `key` is not in map.
-    ///
-    /// Computes in **O(n)** time (average).
-    pub fn shift_remove_full<Q: ?Sized>(&mut self, key: &Q) -> Option<(usize, K, V)>
-    where
-        Q: Hash + Equivalent<K>,
-    {
-        self.0.shift_remove_full(key)
-    }
-
-    /// Remove the last key-value pair
-    ///
-    /// This preserves the order of the remaining elements.
-    ///
-    /// Computes in **O(1)** time (average).
-    pub fn pop(&mut self) -> Option<(K, V)> {
-        self.0.pop()
-    }
-
-    /// Scan through each key-value pair in the map and keep those where the
-    /// closure `keep` returns `true`.
-    ///
-    /// The elements are visited in order, and remaining elements keep their
-    /// order.
-    ///
-    /// Computes in **O(n)** time (average).
-    pub fn retain<F>(&mut self, keep: F)
-    where
-        F: FnMut(&K, &mut V) -> bool,
-    {
-        self.0.retain(keep);
-    }
-}
-
-impl<K, V, S> OrderMap<K, V, S> {
-    /// Get a key-value pair by index
-    ///
-    /// Valid indices are *0 <= index < self.len()*
-    ///
-    /// Computes in **O(1)** time.
-    pub fn get_index(&self, index: usize) -> Option<(&K, &V)> {
-        self.0.get_index(index)
-    }
-
-    /// Get a key-value pair by index
-    ///
-    /// Valid indices are *0 <= index < self.len()*
-    ///
-    /// Computes in **O(1)** time.
-    pub fn get_index_mut(&mut self, index: usize) -> Option<(&mut K, &mut V)> {
-        self.0.get_index_mut(index)
-    }
-
-    /// Get the first key-value pair
-    ///
-    /// Computes in **O(1)** time.
-    pub fn first(&self) -> Option<(&K, &V)> {
-        self.0.first()
-    }
-
-    /// Get the first key-value pair, with mutable access to the value
-    ///
-    /// Computes in **O(1)** time.
-    pub fn first_mut(&mut self) -> Option<(&K, &mut V)> {
-        self.0.first_mut()
-    }
-
-    /// Get the last key-value pair
-    ///
-    /// Computes in **O(1)** time.
-    pub fn last(&self) -> Option<(&K, &V)> {
-        self.0.last()
-    }
-
-    /// Get the last key-value pair, with mutable access to the value
-    ///
-    /// Computes in **O(1)** time.
-    pub fn last_mut(&mut self) -> Option<(&K, &mut V)> {
-        self.0.last_mut()
-    }
-
-    /// Remove the key-value pair by index
-    ///
-    /// Valid indices are *0 <= index < self.len()*
-    ///
-    /// Like `Vec::remove`, the pair is removed by shifting all of the
-    /// elements that follow it, preserving their relative order.
-    /// **This perturbs the index of all of those elements!**
-    ///
-    /// Computes in **O(n)** time (average).
-    pub fn shift_remove_index(&mut self, index: usize) -> Option<(K, V)> {
-        self.0.shift_remove_index(index)
-    }
-}
-
-impl<'a, K, V, S> IntoIterator for &'a OrderMap<K, V, S> {
-    type Item = (&'a K, &'a V);
-    type IntoIter = Iter<'a, K, V>;
-    fn into_iter(self) -> Self::IntoIter {
-        self.0.iter()
-    }
-}
-
-impl<'a, K, V, S> IntoIterator for &'a mut OrderMap<K, V, S> {
-    type Item = (&'a K, &'a mut V);
-    type IntoIter = IterMut<'a, K, V>;
-    fn into_iter(self) -> Self::IntoIter {
-        self.0.iter_mut()
-    }
-}
-
-impl<K, V, S> IntoIterator for OrderMap<K, V, S> {
-    type Item = (K, V);
-    type IntoIter = IntoIter<K, V>;
-    fn into_iter(self) -> Self::IntoIter {
-        self.0.into_iter()
-    }
-}
-
-/// Access `OrderMap` values corresponding to a key.
-///
-/// Panics if the value is missing.
-impl<K, V, Q: ?Sized, S> Index<&Q> for OrderMap<K, V, S>
-where
-    Q: Hash + Equivalent<K>,
-    K: Hash + Eq,
-    S: BuildHasher,
-{
-    type Output = V;
-
-    /// Returns a reference to the value corresponding to the supplied `key`.
-    ///
-    /// ***Panics*** if `key` is not present in the map.
-    fn index(&self, key: &Q) -> &V {
-        self.0.index(key)
-    }
-}
-
-/// Access `Ordermap` values corresponding to a key.
-///
-/// Mutable indexing allows changing / updating values of key-value
-/// pairs that are already present.
-///
-/// You can **not** insert new pairs with index syntax, use `.insert()`.
-impl<K, V, Q: ?Sized, S> IndexMut<&Q> for OrderMap<K, V, S>
-where
-    Q: Hash + Equivalent<K>,
-    K: Hash + Eq,
-    S: BuildHasher,
-{
-    /// Returns a mutable reference to the value corresponding to the supplied `key`.
-    ///
-    /// ***Panics*** if `key` is not present in the map.
-    fn index_mut(&mut self, key: &Q) -> &mut V {
-        self.0.index_mut(key)
-    }
-}
-
-/// Access `IndexMap` values at indexed positions.
-///
-/// It panics if the index is out of bounds.
-impl<K, V, S> Index<usize> for OrderMap<K, V, S> {
-    type Output = V;
-
-    /// Returns a reference to the value at the supplied `index`.
-    ///
-    /// ***Panics*** if `index` is out of bounds.
-    fn index(&self, index: usize) -> &V {
-        self.0.index(index)
-    }
-}
-
-/// Access `IndexMap` values at indexed positions.
-///
-/// Mutable indexing allows changing / updating indexed values
-/// that are already present.
-///
-/// You can **not** insert new values with index syntax, use `.insert()`.
-///
-/// # Examples
-///
-/// ```
-/// use indexmap::IndexMap;
-///
-/// let mut map = IndexMap::new();
-/// for word in "Lorem ipsum dolor sit amet".split_whitespace() {
-///     map.insert(word.to_lowercase(), word.to_string());
-/// }
-/// let lorem = &mut map[0];
-/// assert_eq!(lorem, "Lorem");
-/// lorem.retain(char::is_lowercase);
-/// assert_eq!(map["lorem"], "orem");
-/// ```
-///
-/// ```should_panic
-/// use indexmap::IndexMap;
-///
-/// let mut map = IndexMap::new();
-/// map.insert("foo", 1);
-/// map[10] = 1; // panics!
-/// ```
-impl<K, V, S> IndexMut<usize> for OrderMap<K, V, S> {
-    /// Returns a mutable reference to the value at the supplied `index`.
-    ///
-    /// ***Panics*** if `index` is out of bounds.
-    fn index_mut(&mut self, index: usize) -> &mut V {
-        self.0.index_mut(index)
-    }
-}
-
-impl<K, V, S> FromIterator<(K, V)> for OrderMap<K, V, S>
-where
-    K: Hash + Eq,
-    S: BuildHasher + Default,
-{
-    /// Create an `OrderMap` from the sequence of key-value pairs in the
-    /// iterable.
-    ///
-    /// `from_iter` uses the same logic as `extend`. See
-    /// [`extend`](#method.extend) for more details.
-    fn from_iter<I: IntoIterator<Item = (K, V)>>(iterable: I) -> Self {
-        Self(IndexMap::from_iter(iterable))
-    }
-}
-
-// todo: uncomment when the MSRV bumps
-// impl<K, V, const N: usize> From<[(K, V); N]> for OrderMap<K, V, RandomState>
-// where
-//     K: Hash + Eq,
-// {
-//     fn from(arr: [(K, V); N]) -> Self {
-//         Self(IndexMap::from(arr))
-//     }
-// }
-
-impl<K, V, S> Extend<(K, V)> for OrderMap<K, V, S>
-where
-    K: Hash + Eq,
-    S: BuildHasher,
-{
-    /// Extend the map with all key-value pairs in the iterable.
-    ///
-    /// This is equivalent to calling [`insert`](#method.insert) for each of
-    /// them in order, which means that for keys that already existed
-    /// in the map, their value is updated but it keeps the existing order.
-    ///
-    /// New keys are inserted in the order they appear in the sequence. If
-    /// equivalents of a key occur more than once, the last corresponding value
-    /// prevails.
-    fn extend<I: IntoIterator<Item = (K, V)>>(&mut self, iterable: I) {
-        self.0.extend(iterable)
-    }
-}
-
-impl<'a, K, V, S> Extend<(&'a K, &'a V)> for OrderMap<K, V, S>
-where
-    K: 'a + Hash + Eq + Copy,
-    V: 'a + Copy,
-    S: BuildHasher,
-{
-    /// Extend the map with all key-value pairs in the iterable.
-    ///
-    /// See the first extend method for more details.
-    fn extend<I: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iterable: I) {
-        self.0.extend(iterable)
-    }
-}
-
-impl<K, V, S> Default for OrderMap<K, V, S>
-where
-    S: Default,
-{
-    /// Return an empty `OrderMap`
-    fn default() -> Self {
-        Self(IndexMap::default())
-    }
-}
-
-impl<K, V1, S1, V2, S2> PartialEq<OrderMap<K, V2, S2>> for OrderMap<K, V1, S1>
-where
-    K: Hash + Eq,
-    V1: PartialEq<V2>,
-    S1: BuildHasher,
-    S2: BuildHasher,
-{
-    fn eq(&self, other: &OrderMap<K, V2, S2>) -> bool {
-        self.0.eq(&other.0)
-    }
-}
-
-impl<K, V, S> Eq for OrderMap<K, V, S>
-where
-    K: Eq + Hash,
-    V: Eq,
-    S: BuildHasher,
-{
-}
-
-impl<S> FromIterator<KeyValue> for OrderMap<Key, Value, S>
-where
-    S: BuildHasher + Default,
-{
-    /// Create an `OrderMap` from the sequence of key-value pairs in the
-    /// iterable.
-    ///
-    /// `from_iter` uses the same logic as `extend`. See
-    /// [`extend`](#method.extend) for more details.
-    fn from_iter<I: IntoIterator<Item = KeyValue>>(iterable: I) -> Self {
-        Self(IndexMap::from_iter(
-            iterable.into_iter().map(|kv| (kv.key, kv.value)),
-        ))
-    }
-}
-
-// todo: uncomment below when bumping MSRV
-// impl<const N: usize> From<[KeyValue; N]> for OrderMap<Key, Value, RandomState> {
-//     fn from(arr: [KeyValue; N]) -> Self {
-//         let arr = arr.map(|kv| (kv.key, kv.value));
-//         Self(IndexMap::from(arr))
-//     }
-// }
-
-impl<S> Extend<KeyValue> for OrderMap<Key, Value, S>
-where
-    S: BuildHasher,
-{
-    /// Extend the map with all key-value pairs in the iterable.
-    ///
-    /// This is equivalent to calling [`insert`](#method.insert) for each of
-    /// them in order, which means that for keys that already existed
-    /// in the map, their value is updated but it keeps the existing order.
-    ///
-    /// New keys are inserted in the order they appear in the sequence. If
-    /// equivalents of a key occur more than once, the last corresponding value
-    /// prevails.
-    fn extend<I: IntoIterator<Item = KeyValue>>(&mut self, iterable: I) {
-        self.0
-            .extend(iterable.into_iter().map(|kv| (kv.key, kv.value)))
-    }
-}

opentelemetry-api/src/propagation/mod.rs

@@ -1,232 +0,0 @@
-//! # OpenTelemetry Propagator interface
-//!
-//! Propagators API consists of two main formats:
-//!
-//! - `BinaryFormat` is used to serialize and deserialize a value
-//! into a binary representation.
-//! - `TextMapFormat` is used to inject and extract a value as
-//! text into injectors and extractors that travel in-band across process boundaries.
-//!
-//! Deserializing must set `is_remote` to true on the returned
-//! `SpanContext`.
-//!
-//! ## Binary Format
-//!
-//! `BinaryFormat` is a formatter to serialize and deserialize a value
-//! into a binary format.
-//!
-//! `BinaryFormat` MUST expose the APIs that serializes values into bytes,
-//! and deserializes values from bytes.
-//!
-//! ### ToBytes
-//!
-//! Serializes the given value into the on-the-wire representation.
-//!
-//! Required arguments:
-//!
-//! - the value to serialize, can be `SpanContext` or `DistributedContext`.
-//!
-//! Returns the on-the-wire byte representation of the value.
-//!
-//! ### FromBytes
-//!
-//! Creates a value from the given on-the-wire encoded representation.
-//!
-//! If the value could not be parsed, the underlying implementation
-//! SHOULD decide to return ether an empty value, an invalid value, or
-//! a valid value.
-//!
-//! Required arguments:
-//!
-//! - on-the-wire byte representation of the value.
-//!
-//! Returns a value deserialized from bytes.
-//!
-//! ## TextMap Format
-//!
-//! `TextMapFormat` is a formatter that injects and extracts a value
-//! as text into injectors and extractors that travel in-band across process boundaries.
-//!
-//! Encoding is expected to conform to the HTTP Header Field semantics.
-//! Values are often encoded as RPC/HTTP request headers.
-//!
-//! The carrier of propagated data on both the client (injector) and
-//! server (extractor) side is usually a http request. Propagation is
-//! usually implemented via library-specific request interceptors, where
-//! the client-side injects values and the server-side extracts them.
-//!
-//! `TextMapFormat` MUST expose the APIs that injects values into injectors,
-//! and extracts values from extractors.
-//!
-//! ### Fields
-//!
-//! The propagation fields defined. If your injector is reused, you should
-//! delete the fields here before calling `inject`.
-//!
-//! For example, if the injector is a single-use or immutable request object,
-//! you don't need to clear fields as they couldn't have been set before.
-//! If it is a mutable, retryable object, successive calls should clear
-//! these fields first.
-//!
-//! The use cases of this are:
-//!
-//! - allow pre-allocation of fields, especially in systems like gRPC
-//! Metadata
-//! - allow a single-pass over an iterator
-//!
-//! Returns list of fields that will be used by this formatter.
-//!
-//! ### Inject
-//!
-//! Injects the value downstream. For example, as http headers.
-//!
-//! Required arguments:
-//!
-//! - the `SpanContext` to be injected.
-//! - the injector that holds propagation fields. For example, an outgoing
-//! message or http request.
-//! - the `Setter` invoked for each propagation key to add or remove.
-//!
-//! #### Setter argument
-//!
-//! Setter is an argument in `Inject` that puts value into given field.
-//!
-//! `Setter` allows a `TextMapFormat` to set propagated fields into a
-//! injector.
-//!
-//! `Setter` MUST be stateless and allowed to be saved as a constant to
-//! avoid runtime allocations. One of the ways to implement it is `Setter`
-//! class with `Put` method as described below.
-//!
-//! ##### Put
-//!
-//! Replaces a propagated field with the given value.
-//!
-//! Required arguments:
-//!
-//! - the injector holds propagation fields. For example, an outgoing message
-//! or http request.
-//! - the key of the field.
-//! - the value of the field.
-//!
-//! The implementation SHOULD preserve casing (e.g. it should not transform
-//! `Content-Type` to `content-type`) if the used protocol is case insensitive,
-//! otherwise it MUST preserve casing.
-//!
-//! ### Extract
-//!
-//! Extracts the value from upstream. For example, as http headers.
-//!
-//! If the value could not be parsed, the underlying implementation will
-//! decide to return an object representing either an empty value, an invalid
-//! value, or a valid value.
-//!
-//! Required arguments:
-//!
-//! - the extractor holds propagation fields. For example, an outgoing message
-//! or http request.
-//! - the instance of `Getter` invoked for each propagation key to get.
-//!
-//! Returns the non-null extracted value.
-//!
-//! #### Getter argument
-//!
-//! Getter is an argument in `Extract` that get value from given field
-//!
-//! `Getter` allows a `TextMapFormat` to read propagated fields from a
-//! extractor.
-//!
-//! `Getter` MUST be stateless and allowed to be saved as a constant to avoid
-//! runtime allocations. One of the ways to implement it is `Getter` class
-//! with `Get` method as described below.
-//!
-//! ##### Get
-//!
-//! The Get function MUST return the first value of the given propagation
-//! key or return `None` if the key doesn't exist.
-//!
-//! Required arguments:
-//!
-//! - the extractor of propagation fields, such as an HTTP request.
-//! - the key of the field.
-//!
-//! The `get` function is responsible for handling case sensitivity. If
-//! the getter is intended to work with an HTTP request object, the getter
-//! MUST be case insensitive. To improve compatibility with other text-based
-//! protocols, text format implementations MUST ensure to always use the
-//! canonical casing for their attributes. NOTE: Canonical casing for HTTP
-//! headers is usually title case (e.g. `Content-Type` instead of `content-type`).
-//!
-//! ##### Keys
-//!
-//! The Keys function returns a vector of the propagation keys.
-//!
-use std::collections::HashMap;
-
-pub mod text_map_propagator;
-
-pub use text_map_propagator::TextMapPropagator;
-
-/// Injector provides an interface for adding fields from an underlying struct like `HashMap`
-pub trait Injector {
-    /// Add a key and value to the underlying data.
-    fn set(&mut self, key: &str, value: String);
-}
-
-/// Extractor provides an interface for removing fields from an underlying struct like `HashMap`
-pub trait Extractor {
-    /// Get a value from a key from the underlying data.
-    fn get(&self, key: &str) -> Option<&str>;
-
-    /// Collect all the keys from the underlying data.
-    fn keys(&self) -> Vec<&str>;
-}
-
-impl<S: std::hash::BuildHasher> Injector for HashMap<String, String, S> {
-    /// Set a key and value in the HashMap.
-    fn set(&mut self, key: &str, value: String) {
-        self.insert(key.to_lowercase(), value);
-    }
-}
-
-impl<S: std::hash::BuildHasher> Extractor for HashMap<String, String, S> {
-    /// Get a value for a key from the HashMap.
-    fn get(&self, key: &str) -> Option<&str> {
-        self.get(&key.to_lowercase()).map(|v| v.as_str())
-    }
-
-    /// Collect all the keys from the HashMap.
-    fn keys(&self) -> Vec<&str> {
-        self.keys().map(|k| k.as_str()).collect::<Vec<_>>()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::collections::HashMap;
-
-    #[test]
-    fn hash_map_get() {
-        let mut carrier = HashMap::new();
-        carrier.set("headerName", "value".to_string());
-
-        assert_eq!(
-            Extractor::get(&carrier, "HEADERNAME"),
-            Some("value"),
-            "case insensitive extraction"
-        );
-    }
-
-    #[test]
-    fn hash_map_keys() {
-        let mut carrier = HashMap::new();
-        carrier.set("headerName1", "value1".to_string());
-        carrier.set("headerName2", "value2".to_string());
-
-        let got = Extractor::keys(&carrier);
-        assert_eq!(got.len(), 2);
-        assert!(got.contains(&"headername1"));
-        assert!(got.contains(&"headername2"));
-    }
-}

opentelemetry-api/src/testing/mod.rs

@@ -1 +0,0 @@
-pub mod trace;

opentelemetry-api/src/trace/tracer_provider.rs

@@ -1,106 +0,0 @@
-use crate::{trace::Tracer, InstrumentationLibrary, KeyValue};
-use std::{borrow::Cow, sync::Arc};
-
-/// Types that can create instances of [`Tracer`].
-///
-/// See the [`global`] module for examples of storing and retrieving tracer
-/// provider instances.
-///
-/// [`global`]: crate::global
-pub trait TracerProvider {
-    /// The [`Tracer`] type that this provider will return.
-    type Tracer: Tracer;
-
-    /// Returns a new tracer with the given name.
-    ///
-    /// The `name` should be the application name or the name of the library
-    /// providing instrumentation. If the name is empty, then an
-    /// implementation-defined default name may be used instead.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use opentelemetry_api::{global, trace::TracerProvider};
-    /// use opentelemetry_api::KeyValue;
-    ///
-    /// let provider = global::tracer_provider();
-    ///
-    /// // tracer used in applications/binaries
-    /// let tracer = provider.tracer("my_app");
-    ///
-    /// // tracer used in libraries/crates that optionally includes version and schema url
-    /// let tracer = provider.versioned_tracer(
-    ///     "my_library",
-    ///     Some(env!("CARGO_PKG_VERSION")),
-    ///     Some("https://opentelemetry.io/schema/1.0.0"),
-    ///     Some(vec![KeyValue::new("key", "value")]),
-    /// );
-    /// ```
-    fn tracer(&self, name: impl Into<Cow<'static, str>>) -> Self::Tracer {
-        self.versioned_tracer(
-            name,
-            None::<Cow<'static, str>>,
-            None::<Cow<'static, str>>,
-            None,
-        )
-    }
-
-    /// Returns a new versioned tracer with a given name.
-    ///
-    /// The `name` should be the application name or the name of the library
-    /// providing instrumentation. If the name is empty, then an
-    /// implementation-defined default name may be used instead.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use opentelemetry_api::{global, trace::TracerProvider};
-    ///
-    /// let provider = global::tracer_provider();
-    ///
-    /// // tracer used in applications/binaries
-    /// let tracer = provider.tracer("my_app");
-    ///
-    /// // tracer used in libraries/crates that optionally includes version and schema url
-    /// let tracer = provider.versioned_tracer(
-    ///     "my_library",
-    ///     Some(env!("CARGO_PKG_VERSION")),
-    ///     Some("https://opentelemetry.io/schema/1.0.0"),
-    ///     None,
-    /// );
-    /// ```
-    fn versioned_tracer(
-        &self,
-        name: impl Into<Cow<'static, str>>,
-        version: Option<impl Into<Cow<'static, str>>>,
-        schema_url: Option<impl Into<Cow<'static, str>>>,
-        attributes: Option<Vec<KeyValue>>,
-    ) -> Self::Tracer {
-        self.library_tracer(Arc::new(InstrumentationLibrary::new(
-            name, version, schema_url, attributes,
-        )))
-    }
-
-    /// Returns a new versioned tracer with the given instrumentation library.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use opentelemetry_api::{global, InstrumentationLibrary, trace::TracerProvider};
-    ///
-    /// let provider = global::tracer_provider();
-    ///
-    /// // tracer used in applications/binaries
-    /// let tracer = provider.tracer("my_app");
-    ///
-    /// // tracer used in libraries/crates that optionally includes version and schema url
-    /// let library = std::sync::Arc::new(InstrumentationLibrary::new(
-    ///     env!("CARGO_PKG_NAME"),
-    ///     Some(env!("CARGO_PKG_VERSION")),
-    ///     Some("https://opentelemetry.io/schema/1.0.0"),
-    ///     None,
-    /// ));
-    /// let tracer = provider.library_tracer(library);
-    /// ```
-    fn library_tracer(&self, library: Arc<InstrumentationLibrary>) -> Self::Tracer;
-}

opentelemetry-appender-log/CHANGELOG.md

@@ -1,5 +1,75 @@
 # Changelog
 
+## vNext
+
+## 0.30.0
+
+Released 2025-May-23
+
+- Updated `opentelemetry` and `opentelemetry-semantic-conventions` dependencies to version 0.30.0.
+
+## 0.29.0
+
+Released 2025-Mar-21
+
+- Similar to the `opentelemetry-appender-tracing` fix [2658](https://github.com/open-telemetry/opentelemetry-rust/issues/2658)
+  InstrumentationScope(Logger) used by the appender now uses an empty ("") named Logger.
+  Previously, a Logger with name and version of the crate was used.
+  Receivers (processors, exporters) are expected to use `LogRecord.target()` as scope name.
+  This is already done in OTLP Exporters, so this change should be transparent to most users.
+- Update `opentelemetry` dependency version to 0.29.
+- Update `opentelemetry-semantic-conventions` dependency version to 0.29.
+
+## 0.28.0
+
+Released 2025-Feb-10
+
+- Update `opentelemetry` dependency version to 0.28.
+- Update `opentelemetry-semantic-conventions` dependency version to 0.28.
+- Bump msrv to 1.75.0.
+
+## 0.27.0
+
+Released 2024-Nov-11
+
+- Update `opentelemetry` dependency version to 0.27
+
+- Bump MSRV to 1.70 [#2179](https://github.com/open-telemetry/opentelemetry-rust/pull/2179)
+- [2193](https://github.com/open-telemetry/opentelemetry-rust/pull/2193) `opentelemetry-appender-log`: Output experimental code attributes 
+- **Breaking** [2291](https://github.com/open-telemetry/opentelemetry-rust/pull/2291) Rename `logs_level_enabled flag` to `spec_unstable_logs_enabled`. Please enable this updated flag if the feature is needed. This flag will be removed once the feature is stabilized in the specifications.
+
+## v0.26.0
+Released 2024-Sep-30
+- Update `opentelemetry` dependency version to 0.26
+
+## v0.25.0
+
+- Update `opentelemetry` dependency version to 0.25
+- Starting with this version, this crate will align with `opentelemetry` crate
+  on major,minor versions.
+
+## v0.5.0
+
+- [1869](https://github.com/open-telemetry/opentelemetry-rust/pull/1869) Utilize the `LogRecord::set_target()` method to pass the log target to the SDK.
+- Update `opentelemetry` dependency version to 0.24
+
+## v0.4.0
+
+- Add log key-values as attributes [#1628](https://github.com/open-telemetry/opentelemetry-rust/pull/1628)
+- Update `opentelemetry` dependency version to 0.23
+
+## v0.3.0
+
+## v0.2.0
+
+### Changed
+
+- Bump MSRV to 1.65 [#1318](https://github.com/open-telemetry/opentelemetry-rust/pull/1318)
+
+### Fixed
+
+- Add log appender versions to loggers (#1182).
+
 ## v0.1.0
 
 Initial crate release

opentelemetry-appender-log/CODEOWNERS

@@ -1,5 +0,0 @@
-# Code owners file.
-# This file controls who is tagged for review for any given pull request.
-
-# For anything not explicitly taken by someone else:
-*  @open-telemetry/rust-approvers

opentelemetry-appender-log/Cargo.toml

@@ -1,19 +1,43 @@
 [package]
 name = "opentelemetry-appender-log"
-version = "0.1.0"
+version = "0.30.0"
 description = "An OpenTelemetry appender for the log crate"
 homepage = "https://github.com/open-telemetry/opentelemetry-rust/tree/main/opentelemetry-appender-log"
 repository = "https://github.com/open-telemetry/opentelemetry-rust/tree/main/opentelemetry-appender-log"
 readme = "README.md"
 keywords = ["opentelemetry", "log", "logs"]
 license = "Apache-2.0"
-rust-version = "1.60"
+rust-version = "1.75.0"
 edition = "2021"
+autobenches = false
+
+[lib]
+bench = false
 
 [dependencies]
-opentelemetry_api = { version = "0.20", path = "../opentelemetry-api", features = ["logs"]}
-log = {version = "0.4.17", features = ["kv_unstable", "std"]}
+opentelemetry = { version = "0.30", path = "../opentelemetry", features = [
+  "logs",
+] }
+log = { workspace = true, features = ["kv", "std"] }
+serde = { workspace = true, optional = true, features = ["std"] }
+opentelemetry-semantic-conventions = { version = "0.30", path = "../opentelemetry-semantic-conventions", optional = true, features = [
+  "semconv_experimental",
+] }
 
 [features]
-logs_level_enabled = ["opentelemetry_api/logs_level_enabled"]
-default = ["logs_level_enabled"]
+spec_unstable_logs_enabled = ["opentelemetry/spec_unstable_logs_enabled"]
+with-serde = ["log/kv_serde", "serde"]
+experimental_metadata_attributes = ["dep:opentelemetry-semantic-conventions"]
+
+[dev-dependencies]
+opentelemetry_sdk = { path = "../opentelemetry-sdk", features = [
+  "testing",
+  "spec_unstable_logs_enabled",
+] }
+opentelemetry-stdout = { workspace = true, features = ["logs"] }
+log = { workspace = true, features = ["kv_serde"] }
+tokio = { workspace = true }
+serde = { workspace = true, features = ["std", "derive"] }
+
+[lints]
+workspace = true

opentelemetry-appender-log/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2023 The OpenTelemetry Authors
+   Copyright [yyyy] [name of copyright owner]
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

opentelemetry-appender-log/README.md

@@ -1,23 +1,32 @@
+# OpenTelemetry Log Appender for `log` crate
+
 ![OpenTelemetry — An observability framework for cloud-native software.][splash]
 
 [splash]: https://raw.githubusercontent.com/open-telemetry/opentelemetry-rust/main/assets/logo-text.png
 
-# OpenTelemetry Log Appender
-
-A [Log Appender](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/glossary.md#log-appender--bridge) that bridges logs from the [log crate](https://docs.rs/log/latest/log/) to OpenTelemetry.
+This crate contains a [Log Appender](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/glossary.md#log-appender--bridge) that bridges logs from the [log crate](https://docs.rs/log/latest/log/) to OpenTelemetry.
 
 [![Crates.io: opentelemetry-appender-log](https://img.shields.io/crates/v/opentelemetry-appender-log.svg)](https://crates.io/crates/opentelemetry-appender-log)
 [![Documentation](https://docs.rs/opentelemetry-appender-log/badge.svg)](https://docs.rs/opentelemetry-appender-log)
-[![LICENSE](https://img.shields.io/crates/l/opentelemetry-appender-log)](./LICENSE)
+[![LICENSE](https://img.shields.io/crates/l/opentelemetry-appender-log)](https://github.com/open-telemetry/opentelemetry-rust/blob/main/opentelemetry-appender-log/LICENSE)
 [![GitHub Actions CI](https://github.com/open-telemetry/opentelemetry-rust/workflows/CI/badge.svg)](https://github.com/open-telemetry/opentelemetry-rust/actions?query=workflow%3ACI+branch%3Amain)
 [![Slack](https://img.shields.io/badge/slack-@cncf/otel/rust-brightgreen.svg?logo=slack)](https://cloud-native.slack.com/archives/C03GDP0H023)
 
-## Overview
+## OpenTelemetry Overview
 
-[`OpenTelemetry`] is a collection of tools, APIs, and SDKs used to instrument,
-generate, collect, and export telemetry data (metrics, logs, and traces) for
-analysis in order to understand your software's performance and behavior. This
-crate provides additional propagators and exporters for sending telemetry data
-to vendors or using experimental propagators like `base64`.
+OpenTelemetry is an Observability framework and toolkit designed to create and
+manage telemetry data such as traces, metrics, and logs. OpenTelemetry is
+vendor- and tool-agnostic, meaning that it can be used with a broad variety of
+Observability backends, including open source tools like [Jaeger] and
+[Prometheus], as well as commercial offerings.
 
-[`OpenTelemetry`]: https://crates.io/crates/opentelemetry
+OpenTelemetry is *not* an observability backend like Jaeger, Prometheus, or other
+commercial vendors. OpenTelemetry is focused on the generation, collection,
+management, and export of telemetry. A major goal of OpenTelemetry is that you
+can easily instrument your applications or systems, no matter their language,
+infrastructure, or runtime environment. Crucially, the storage and visualization
+of telemetry is intentionally left to other tools.
+
+## Release Notes
+
+You can find the release notes (changelog) [here](https://github.com/open-telemetry/opentelemetry-rust/blob/main/opentelemetry-appender-log/CHANGELOG.md).

opentelemetry-appender-log/examples/logs-basic.rs

@@ -0,0 +1,35 @@
+//! run with `$ cargo run --example logs-basic`
+
+/// This example shows how to use in_memory_exporter for logs. This uses opentelemetry-appender-log crate, which is a
+/// [logging appender](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/glossary.md#log-appender--bridge) that bridges logs from the [log crate](https://docs.rs/log/latest/log/) to OpenTelemetry.
+/// The example setups a LoggerProvider with a in-memory exporter, so emitted logs are stored in memory.
+///
+use log::{error, info, warn, Level};
+use opentelemetry_appender_log::OpenTelemetryLogBridge;
+use opentelemetry_sdk::logs::{BatchLogProcessor, SdkLoggerProvider};
+use opentelemetry_stdout::LogExporter;
+
+#[tokio::main]
+async fn main() {
+    //Create an exporter that writes to stdout
+    let exporter = LogExporter::default();
+    //Create a LoggerProvider and register the exporter
+    let logger_provider = SdkLoggerProvider::builder()
+        .with_log_processor(BatchLogProcessor::builder(exporter).build())
+        .build();
+
+    // Setup Log Appender for the log crate.
+    let otel_log_appender = OpenTelemetryLogBridge::new(&logger_provider);
+    log::set_boxed_logger(Box::new(otel_log_appender)).unwrap();
+    log::set_max_level(Level::Info.to_level_filter());
+
+    // Emit logs using macros from the log crate.
+    let fruit = "apple";
+    let price = 2.99;
+
+    error!(fruit, price; "hello from {fruit}. My price is {price}");
+    warn!("warn!");
+    info!("test log!");
+
+    let _ = logger_provider.shutdown();
+}

opentelemetry-appender-tracing/CHANGELOG.md

@@ -1,5 +1,154 @@
 # Changelog
 
+## vNext
+
+## 0.30.1
+
+Released 2025-June-05
+
+- Bump `tracing-opentelemetry` to 0.31
+
+## 0.30.0
+
+Released 2025-May-23
+
+- Updated `opentelemetry` dependency to version 0.30.0.
+
+
+## 0.29.1
+
+Released 2025-Mar-24
+
+- Bump `tracing-opentelemetry` to 0.30
+
+
+## 0.29.0
+
+Released 2025-Mar-21
+
+Fixes [1682](https://github.com/open-telemetry/opentelemetry-rust/issues/1682).
+"spec_unstable_logs_enabled" feature now do not suppress logs for other layers.
+
+The special treatment of the "message" field has been extended when recording
+string values. With this change, when a log is emitted with a field named
+"message" (and string value), its value is directly assigned to the LogRecord’s
+body rather than being stored as an attribute named "message". This offers a
+slight performance improvement over previous.
+
+For example, the below will now produce LogRecord with the message value
+populated as LogRecord's body:
+
+```rust
+error!(name: "my-event-name", target: "my-system", event_id = 20, user_name = "otel", user_email = "otel@opentelemetry.io", message = "This is an example message");
+```
+
+Previously, Body was only populated when the below style was used.
+
+```rust
+error!(name: "my-event-name", target: "my-system", event_id = 20, user_name = "otel", user_email = "otel@opentelemetry.io", "This is an example message");
+```
+
+This style, while slightly slower, should still be used when the value is not a
+simple string, but require format arguments as in the below example.
+
+```rust
+error!(name: "my-event-name", target: "my-system", event_id = 20, user_name = "otel", user_email = "otel@opentelemetry.io", "This is an example message with format arguments {} and {}", "foo", "bar");
+```
+
+Fixes [2658](https://github.com/open-telemetry/opentelemetry-rust/issues/2658)
+InstrumentationScope(Logger) used by the appender now uses an empty ("") named
+Logger. Previously, a Logger with name and version of the crate was used.
+Receivers (processors, exporters) are expected to use `LogRecord.target()` as
+scope name. This is already done in OTLP Exporters, so this change should be
+transparent to most users.
+
+- Passes event name  to the `event_enabled` method on the `Logger`. This allows
+  implementations (SDK, processor, exporters) to leverage this additional
+  information to determine if an event is enabled.
+
+- `u64`, `i128`, `u128` and `usize` values are stored as `opentelemetry::logs::AnyValue::Int`
+when conversion is feasible. Otherwise stored as
+`opentelemetry::logs::AnyValue::String`. This avoids unnecessary string
+allocation when values can be represented in their original types.
+- Byte arrays are stored as `opentelemetry::logs::AnyValue::Bytes` instead
+of string.
+- `Error` fields are reported using attribute named "exception.message". For
+  example, the below will now report an attribute named "exception.message",
+  instead of previously reporting the user provided attribute "error".
+  `error!(....error = &OTelSdkError::AlreadyShutdown as &dyn std::error::Error...)`
+- perf - small perf improvement by avoiding string allocation of `target`
+- Update `opentelemetry` dependency version to 0.29.
+
+## 0.28.1
+
+Released 2025-Feb-12
+
+- New *experimental* feature to use trace_id & span_id from spans created through the [tracing](https://crates.io/crates/tracing) crate (experimental_use_tracing_span_context) [#2438](https://github.com/open-telemetry/opentelemetry-rust/pull/2438)
+
+## 0.28.0
+
+Released 2025-Feb-10
+
+- Update `opentelemetry` dependency version to 0.28.
+- Bump msrv to 1.75.0.
+
+## 0.27.0
+
+Released 2024-Nov-11
+
+- Update `opentelemetry` dependency version to 0.27
+
+- Bump MSRV to 1.70 [#2179](https://github.com/open-telemetry/opentelemetry-rust/pull/2179)
+- **Breaking** [2291](https://github.com/open-telemetry/opentelemetry-rust/pull/2291) Rename `logs_level_enabled flag` to `spec_unstable_logs_enabled`. Please enable this updated flag if the feature is needed. This flag will be removed once the feature is stabilized in the specifications.
+
+## v0.26.0
+
+Released 2024-Sep-30
+
+- Update `opentelemetry` dependency version to 0.26
+- [2101](https://github.com/open-telemetry/opentelemetry-rust/pull/2101) The `log` events emitted via the `tracing` pipeline using the `log-tracing` crate no longer include the target metadata as attributes. Exporters or backends that rely on this attribute should now access the target directly from the `LogRecord::target` field.
+
+## v0.25.0
+
+- Update `opentelemetry` dependency version to 0.25
+- Starting with this version, this crate will align with `opentelemetry` crate
+  on major,minor versions.
+- Reduce heap allocation by using `&'static str` for `SeverityText`.
+
+## v0.5.0
+
+- [1869](https://github.com/open-telemetry/opentelemetry-rust/pull/1869) Utilize the `LogRecord::set_target()` method to pass the tracing target to the SDK.
+  Exporters might use the target to override the instrumentation scope, which previously contained "opentelemetry-appender-tracing".
+
+- **Breaking** [1928](https://github.com/open-telemetry/opentelemetry-rust/pull/1928) Insert tracing event name into LogRecord::event_name instead of attributes.
+  - If using a custom exporter, then they must serialize this field directly from LogRecord::event_name instead of iterating over the attributes. OTLP Exporter is modified to handle this.
+- Update `opentelemetry` dependency version to 0.24
+
+## v0.4.0
+
+- Removed unwanted dependency on opentelemetry-sdk.
+- Update `opentelemetry` dependency version to 0.23
+
+## v0.3.0
+
+### Added
+
+- New experimental metadata attributes feature (experimental\_metadata\_attributes) [#1380](https://github.com/open-telemetry/opentelemetry-rust/pull/1380)
+  - Experimental new attributes for tracing metadata
+  - Fixes the following for events emitted using log crate
+    - Normalized metadata fields
+    - Remove redundant metadata
+
+## v0.2.0
+
+### Changed
+
+- Bump MSRV to 1.65 [#1318](https://github.com/open-telemetry/opentelemetry-rust/pull/1318)
+
+### Added
+
+- Add log appender versions to loggers (#1182)
+
 ## v0.1.0
 
 Initial crate release

opentelemetry-appender-tracing/CODEOWNERS

@@ -1,5 +0,0 @@
-# Code owners file.
-# This file controls who is tagged for review for any given pull request.
-
-# For anything not explicitly taken by someone else:
-*  @open-telemetry/rust-approvers

opentelemetry-appender-tracing/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "opentelemetry-appender-tracing"
-version = "0.1.0"
+version = "0.30.1"
 edition = "2021"
 description = "An OpenTelemetry log appender for the tracing crate"
 homepage = "https://github.com/open-telemetry/opentelemetry-rust/tree/main/opentelemetry-appender-tracing"
@@ -8,19 +8,49 @@ repository = "https://github.com/open-telemetry/opentelemetry-rust/tree/main/ope
 readme = "README.md"
 keywords = ["opentelemetry", "log", "logs", "tracing"]
 license = "Apache-2.0"
-rust-version = "1.60"
+rust-version = "1.75.0"
+autobenches = false
 
 [dependencies]
-opentelemetry_api = { version = "0.20", path = "../opentelemetry-api", features = ["logs"] }
-opentelemetry_sdk = { version = "0.20", path = "../opentelemetry-sdk", features = ["logs"] }
-tracing = {version = "0.1.37", default-features = false, features = ["std"]}
-tracing-core = "0.1.31"
-tracing-subscriber = { version = "0.3.0", default-features = false, features = ["registry", "std"] }
-once_cell = "1.13.0"
+log = { workspace = true, optional = true }
+opentelemetry = { version = "0.30", path = "../opentelemetry", features = ["logs"] }
+tracing = { workspace = true, features = ["std"]}
+tracing-core = { workspace = true }
+tracing-log = { workspace = true, optional = true }
+tracing-subscriber = { workspace = true, features = ["registry", "std"] }
+tracing-opentelemetry = { workspace = true, optional = true }
 
 [dev-dependencies]
-opentelemetry-stdout = { path = "../opentelemetry-stdout", features = ["logs"] }
+log = { workspace = true }
+opentelemetry-stdout = { workspace = true, features = ["logs"] }
+opentelemetry_sdk = { path = "../opentelemetry-sdk", features = ["logs", "testing"]  }
+tracing = { workspace = true, features = ["std"]}
+tracing-subscriber = { workspace = true, features = ["env-filter","registry", "std", "fmt"] }
+tracing-log = { workspace = true }
+criterion = { workspace = true }
+tokio = { workspace = true, features = ["full"]}
+
+[target.'cfg(not(target_os = "windows"))'.dev-dependencies]
+pprof = { version = "0.14", features = ["flamegraph", "criterion"] }
 
 [features]
-logs_level_enabled = ["opentelemetry_api/logs_level_enabled", "opentelemetry_sdk/logs_level_enabled"]
-default = ["logs_level_enabled"]
+default = []
+experimental_metadata_attributes = ["dep:tracing-log"]
+spec_unstable_logs_enabled = ["opentelemetry/spec_unstable_logs_enabled"]
+experimental_use_tracing_span_context = ["tracing-opentelemetry"]
+
+
+[[bench]]
+name = "logs"
+harness = false
+required-features = ["spec_unstable_logs_enabled"]
+
+[[bench]]
+name = "log-attributes"
+harness = false
+
+[lib]
+bench = false
+
+[lints]
+workspace = true

opentelemetry-appender-tracing/README.md

@@ -1,30 +1,53 @@
+# OpenTelemetry Log Appender for `tracing` crate
+
 ![OpenTelemetry — An observability framework for cloud-native software.][splash]
 
 [splash]: https://raw.githubusercontent.com/open-telemetry/opentelemetry-rust/main/assets/logo-text.png
 
-# OpenTelemetry Log Appender for Tracing
-
-A [Log
+This crate contains a [Log
 Appender](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/glossary.md#log-appender--bridge)
 that bridges logs from the [tracing crate](https://tracing.rs/tracing/#events)
-to OpenTelemetry logs. Note that this is different from the existing
+to OpenTelemetry. Note that this is different from the existing
 [tracing-opentelemetry](https://github.com/tokio-rs/tracing-opentelemetry)
 project, which supports bridging traces and logs from tracing into OpenTelemetry
-traces. This is an experimental component, and could be merged with the
-tracing-opentelemetry crate itself.
+traces.
 
 [![Crates.io: opentelemetry-appender-tracing](https://img.shields.io/crates/v/opentelemetry-appender-tracing.svg)](https://crates.io/crates/opentelemetry-appender-tracing)
 [![Documentation](https://docs.rs/opentelemetry-appender-tracing/badge.svg)](https://docs.rs/opentelemetry-appender-tracing)
-[![LICENSE](https://img.shields.io/crates/l/opentelemetry-appender-tracing)](./LICENSE)
+[![LICENSE](https://img.shields.io/crates/l/opentelemetry-appender-tracing)](https://github.com/open-telemetry/opentelemetry-rust/blob/main/opentelemetry-appender-tracing/LICENSE)
 [![GitHub Actions CI](https://github.com/open-telemetry/opentelemetry-rust/workflows/CI/badge.svg)](https://github.com/open-telemetry/opentelemetry-rust/actions?query=workflow%3ACI+branch%3Amain)
 [![Slack](https://img.shields.io/badge/slack-@cncf/otel/rust-brightgreen.svg?logo=slack)](https://cloud-native.slack.com/archives/C03GDP0H023)
 
-## Overview
+## OpenTelemetry Overview
 
-[`OpenTelemetry`] is a collection of tools, APIs, and SDKs used to instrument,
-generate, collect, and export telemetry data (metrics, logs, and traces) for
-analysis in order to understand your software's performance and behavior. This
-crate provides additional propagators and exporters for sending telemetry data
-to vendors or using experimental propagators like `base64`.
+OpenTelemetry is an Observability framework and toolkit designed to create and
+manage telemetry data such as traces, metrics, and logs. OpenTelemetry is
+vendor- and tool-agnostic, meaning that it can be used with a broad variety of
+Observability backends, including open source tools like [Jaeger] and
+[Prometheus], as well as commercial offerings.
 
-[`OpenTelemetry`]: https://crates.io/crates/opentelemetry
+OpenTelemetry is *not* an observability backend like Jaeger, Prometheus, or other
+commercial vendors. OpenTelemetry is focused on the generation, collection,
+management, and export of telemetry. A major goal of OpenTelemetry is that you
+can easily instrument your applications or systems, no matter their language,
+infrastructure, or runtime environment. Crucially, the storage and visualization
+of telemetry is intentionally left to other tools.
+
+*[Supported Rust Versions](#supported-rust-versions)*
+
+## Release Notes
+
+You can find the release notes (changelog) [here](https://github.com/open-telemetry/opentelemetry-rust/blob/main/opentelemetry-appender-tracing/CHANGELOG.md).
+
+## Supported Rust Versions
+
+OpenTelemetry is built against the latest stable release. The minimum supported
+version is 1.75.0. The current OpenTelemetry version is not guaranteed to build
+on Rust versions earlier than the minimum supported version.
+
+The current stable Rust compiler and the three most recent minor versions
+before it will always be supported. For example, if the current stable compiler
+version is 1.49, the minimum supported version will not be increased past 1.46,
+three minor versions prior. Increasing the minimum supported compiler version
+is not considered a semver breaking change as long as doing so complies with
+this policy.

opentelemetry-appender-tracing/benches/log-attributes.rs

@@ -0,0 +1,273 @@
+/*
+// Run this benchmark with:
+ // cargo bench --bench log-attributes
+ // Adding results in comments for a quick reference.
+ // Apple M4 Pro
+ //     Total Number of Cores:	14 (10 performance and 4 efficiency)
+
+| Test                 | Average time | Increment |
+|----------------------|--------------|-----------|
+| otel_0_attributes    | 72 ns        | -         |
+| otel_1_attributes    | 117 ns       | +45 ns    |
+| otel_2_attributes    | 155 ns       | +38 ns    |
+| otel_3_attributes    | 196 ns       | +41 ns    |
+| otel_4_attributes    | 240 ns       | +44 ns    |
+| otel_5_attributes    | 278 ns       | +38 ns    |
+| otel_6_attributes    | 346 ns       | +68 ns    | // Array is full. 6th attribute causes vec! to be allocated
+| otel_7_attributes    | 390 ns       | +44 ns    |
+| otel_8_attributes    | 431 ns       | +41 ns    |
+| otel_9_attributes    | 480 ns       | +49 ns    |
+| otel_10_attributes   | 519 ns       | +39 ns    |
+| otel_11_attributes   | 625 ns       | +106 ns   | // vec! initial capacity is 5. 11th attribute causes vec! to be reallocated
+| otel_12_attributes   | 676 ns       | +51 ns    |
+*/
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use opentelemetry::InstrumentationScope;
+use opentelemetry_appender_tracing::layer as tracing_layer;
+use opentelemetry_sdk::error::OTelSdkResult;
+use opentelemetry_sdk::logs::{LogProcessor, SdkLogRecord, SdkLoggerProvider};
+use opentelemetry_sdk::Resource;
+#[cfg(not(target_os = "windows"))]
+use pprof::criterion::{Output, PProfProfiler};
+use tracing::error;
+use tracing_subscriber::prelude::*;
+use tracing_subscriber::Registry;
+
+#[derive(Debug)]
+struct NoopProcessor;
+
+impl LogProcessor for NoopProcessor {
+    fn emit(&self, _: &mut SdkLogRecord, _: &InstrumentationScope) {}
+
+    fn force_flush(&self) -> OTelSdkResult {
+        Ok(())
+    }
+}
+
+/// Creates a single benchmark for a specific number of attributes
+fn create_benchmark(c: &mut Criterion, num_attributes: usize) {
+    let provider = SdkLoggerProvider::builder()
+        .with_resource(
+            Resource::builder_empty()
+                .with_service_name("benchmark")
+                .build(),
+        )
+        .with_log_processor(NoopProcessor)
+        .build();
+
+    let ot_layer = tracing_layer::OpenTelemetryTracingBridge::new(&provider);
+    let subscriber = Registry::default().with(ot_layer);
+
+    tracing::subscriber::with_default(subscriber, || {
+        c.bench_function(&format!("otel_{num_attributes}_attributes"), |b| {
+            b.iter(|| {
+                // Dynamically generate the error! macro call based on the number of attributes
+                match num_attributes {
+                    0 => {
+                        error!(
+                            name : "CheckoutFailed",
+                            message = "Unable to process checkout."
+                        );
+                    }
+                    1 => {
+                        error!(
+                            name : "CheckoutFailed",
+                            field1 = "field1",
+                            message = "Unable to process checkout."
+                        );
+                    }
+                    2 => {
+                        error!(
+                            name : "CheckoutFailed",
+                            field1 = "field1",
+                            field2 = "field2",
+                            message = "Unable to process checkout."
+                        );
+                    }
+                    3 => {
+                        error!(
+                            name : "CheckoutFailed",
+                            field1 = "field1",
+                            field2 = "field2",
+                            field3 = "field3",
+                            message = "Unable to process checkout."
+                        );
+                    }
+                    4 => {
+                        error!(
+                            name : "CheckoutFailed",
+                            field1 = "field1",
+                            field2 = "field2",
+                            field3 = "field3",
+                            field4 = "field4",
+                            message = "Unable to process checkout."
+                        );
+                    }
+                    5 => {
+                        error!(
+                            name : "CheckoutFailed",
+                            field1 = "field1",
+                            field2 = "field2",
+                            field3 = "field3",
+                            field4 = "field4",
+                            field5 = "field5",
+                            message = "Unable to process checkout."
+                        );
+                    }
+                    6 => {
+                        error!(
+                            name : "CheckoutFailed",
+                            field1 = "field1",
+                            field2 = "field2",
+                            field3 = "field3",
+                            field4 = "field4",
+                            field5 = "field5",
+                            field6 = "field6",
+                            message = "Unable to process checkout."
+                        );
+                    }
+                    7 => {
+                        error!(
+                            name : "CheckoutFailed",
+                            field1 = "field1",
+                            field2 = "field2",
+                            field3 = "field3",
+                            field4 = "field4",
+                            field5 = "field5",
+                            field6 = "field6",
+                            field7 = "field7",
+                            message = "Unable to process checkout."
+                        );
+                    }
+                    8 => {
+                        error!(
+                            name : "CheckoutFailed",
+                            field1 = "field1",
+                            field2 = "field2",
+                            field3 = "field3",
+                            field4 = "field4",
+                            field5 = "field5",
+                            field6 = "field6",
+                            field7 = "field7",
+                            field8 = "field8",
+                            message = "Unable to process checkout."
+                        );
+                    }
+                    9 => {
+                        error!(
+                            name : "CheckoutFailed",
+                            field1 = "field1",
+                            field2 = "field2",
+                            field3 = "field3",
+                            field4 = "field4",
+                            field5 = "field5",
+                            field6 = "field6",
+                            field7 = "field7",
+                            field8 = "field8",
+                            field9 = "field9",
+                            message = "Unable to process checkout."
+                        );
+                    }
+                    10 => {
+                        error!(
+                            name : "CheckoutFailed",
+                            field1 = "field1",
+                            field2 = "field2",
+                            field3 = "field3",
+                            field4 = "field4",
+                            field5 = "field5",
+                            field6 = "field6",
+                            field7 = "field7",
+                            field8 = "field8",
+                            field9 = "field9",
+                            field10 = "field10",
+                            message = "Unable to process checkout."
+                        );
+                    }
+                    11 => {
+                        error!(
+                            name : "CheckoutFailed",
+                            field1 = "field1",
+                            field2 = "field2",
+                            field3 = "field3",
+                            field4 = "field4",
+                            field5 = "field5",
+                            field6 = "field6",
+                            field7 = "field7",
+                            field8 = "field8",
+                            field9 = "field9",
+                            field10 = "field10",
+                            field11 = "field11",
+                            message = "Unable to process checkout."
+                        );
+                    }
+                    12 => {
+                        error!(
+                            name : "CheckoutFailed",
+                            field1 = "field1",
+                            field2 = "field2",
+                            field3 = "field3",
+                            field4 = "field4",
+                            field5 = "field5",
+                            field6 = "field6",
+                            field7 = "field7",
+                            field8 = "field8",
+                            field9 = "field9",
+                            field10 = "field10",
+                            field11 = "field11",
+                            field12 = "field12",
+                            message = "Unable to process checkout."
+                        );
+                    }
+                    _ => {
+                        // Fall back to 10 attributes for any higher number
+                        error!(
+                            name : "CheckoutFailed",
+                            field1 = "field1",
+                            field2 = "field2",
+                            field3 = "field3",
+                            field4 = "field4",
+                            field5 = "field5",
+                            field6 = "field6",
+                            field7 = "field7",
+                            field8 = "field8",
+                            field9 = "field9",
+                            field10 = "field10",
+                            message = "Unable to process checkout."
+                        );
+                    }
+                }
+            });
+        });
+    });
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    create_benchmark(c, 2);
+    // Run benchmarks for 0 to 12 attributes
+    // for num_attributes in 0..=12 {
+    //     create_benchmark(c, 2);
+    // }
+}
+
+#[cfg(not(target_os = "windows"))]
+criterion_group! {
+    name = benches;
+    config = Criterion::default()
+        .warm_up_time(std::time::Duration::from_secs(1))
+        .measurement_time(std::time::Duration::from_secs(2))
+        .with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)));
+    targets = criterion_benchmark
+}
+
+#[cfg(target_os = "windows")]
+criterion_group! {
+    name = benches;
+    config = Criterion::default()
+        .warm_up_time(std::time::Duration::from_secs(1))
+        .measurement_time(std::time::Duration::from_secs(2));
+    targets = criterion_benchmark
+}
+
+criterion_main!(benches);

opentelemetry-appender-tracing/benches/logs.rs

@@ -0,0 +1,181 @@
+/*
+    The benchmark results:
+    criterion = "0.5.1"
+    OS: Ubuntu 22.04.3 LTS (5.15.146.1-microsoft-standard-WSL2)
+    Hardware: AMD EPYC 7763 64-Core Processor - 2.44 GHz, 16vCPUs,
+    RAM: 64.0 GB
+    | Test                        | Average time|
+    |-----------------------------|-------------|
+    | log_no_subscriber           | 313 ps      |
+    | noop_layer_disabled         | 12 ns       |
+    | noop_layer_enabled          | 25 ns       |
+    | ot_layer_disabled           | 19 ns       |
+    | ot_layer_enabled            | 155 ns      |
+
+    Hardware: Apple M4 Pro
+    Total Number of Cores:	14 (10 performance and 4 efficiency)
+    | Test                        | Average time|
+    |-----------------------------|-------------|
+    | log_no_subscriber           | 285 ps      |
+    | noop_layer_disabled         | 8 ns       |
+    | noop_layer_enabled          | 14 ns       |
+    | ot_layer_disabled           | 12 ns       |
+    | ot_layer_enabled            | 130 ns      |
+*/
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use opentelemetry::InstrumentationScope;
+use opentelemetry_appender_tracing::layer as tracing_layer;
+use opentelemetry_sdk::error::OTelSdkResult;
+use opentelemetry_sdk::logs::{LogProcessor, SdkLogRecord, SdkLoggerProvider};
+use opentelemetry_sdk::Resource;
+#[cfg(not(target_os = "windows"))]
+use pprof::criterion::{Output, PProfProfiler};
+use tracing::error;
+use tracing_subscriber::prelude::*;
+use tracing_subscriber::Layer;
+use tracing_subscriber::Registry;
+
+#[derive(Debug)]
+struct NoopProcessor {
+    enabled: bool,
+}
+
+impl NoopProcessor {
+    fn new(enabled: bool) -> Self {
+        Self { enabled }
+    }
+}
+
+impl LogProcessor for NoopProcessor {
+    fn emit(&self, _: &mut SdkLogRecord, _: &InstrumentationScope) {}
+
+    fn force_flush(&self) -> OTelSdkResult {
+        Ok(())
+    }
+
+    fn event_enabled(
+        &self,
+        _level: opentelemetry::logs::Severity,
+        _target: &str,
+        _name: Option<&str>,
+    ) -> bool {
+        self.enabled
+    }
+}
+
+struct NoOpLogLayer {
+    enabled: bool,
+}
+
+impl<S> Layer<S> for NoOpLogLayer
+where
+    S: tracing::Subscriber,
+{
+    fn on_event(
+        &self,
+        event: &tracing::Event<'_>,
+        _ctx: tracing_subscriber::layer::Context<'_, S>,
+    ) {
+        let mut visitor = NoopEventVisitor;
+        event.record(&mut visitor);
+    }
+
+    fn event_enabled(
+        &self,
+        _event: &tracing::Event<'_>,
+        _ctx: tracing_subscriber::layer::Context<'_, S>,
+    ) -> bool {
+        self.enabled
+    }
+}
+
+struct NoopEventVisitor;
+
+impl tracing::field::Visit for NoopEventVisitor {
+    fn record_debug(&mut self, _field: &tracing::field::Field, _value: &dyn std::fmt::Debug) {}
+}
+
+fn benchmark_no_subscriber(c: &mut Criterion) {
+    c.bench_function("log_no_subscriber", |b| {
+        b.iter(|| {
+            error!(
+                name : "CheckoutFailed",
+                book_id = "12345",
+                book_title = "Rust Programming Adventures",
+                message = "Unable to process checkout."
+            );
+        });
+    });
+}
+
+fn benchmark_with_ot_layer(c: &mut Criterion, enabled: bool, bench_name: &str) {
+    let processor = NoopProcessor::new(enabled);
+    let provider = SdkLoggerProvider::builder()
+        .with_resource(
+            Resource::builder_empty()
+                .with_service_name("benchmark")
+                .build(),
+        )
+        .with_log_processor(processor)
+        .build();
+    let ot_layer = tracing_layer::OpenTelemetryTracingBridge::new(&provider);
+    let subscriber = Registry::default().with(ot_layer);
+
+    tracing::subscriber::with_default(subscriber, || {
+        c.bench_function(bench_name, |b| {
+            b.iter(|| {
+                error!(
+                    name : "CheckoutFailed",
+                    book_id = "12345",
+                    book_title = "Rust Programming Adventures",
+                    message = "Unable to process checkout."
+                );
+            });
+        });
+    });
+}
+
+fn benchmark_with_noop_layer(c: &mut Criterion, enabled: bool, bench_name: &str) {
+    let subscriber = Registry::default().with(NoOpLogLayer { enabled });
+
+    tracing::subscriber::with_default(subscriber, || {
+        c.bench_function(bench_name, |b| {
+            b.iter(|| {
+                error!(
+                    name : "CheckoutFailed",
+                    book_id = "12345",
+                    book_title = "Rust Programming Adventures",
+                    message = "Unable to process checkout."
+                );
+            });
+        });
+    });
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    benchmark_no_subscriber(c);
+    benchmark_with_ot_layer(c, true, "ot_layer_enabled");
+    benchmark_with_ot_layer(c, false, "ot_layer_disabled");
+    benchmark_with_noop_layer(c, true, "noop_layer_enabled");
+    benchmark_with_noop_layer(c, false, "noop_layer_disabled");
+}
+
+#[cfg(not(target_os = "windows"))]
+criterion_group! {
+    name = benches;
+    config = Criterion::default()
+        .warm_up_time(std::time::Duration::from_secs(1))
+        .measurement_time(std::time::Duration::from_secs(2))
+        .with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)));
+    targets = criterion_benchmark
+}
+#[cfg(target_os = "windows")]
+criterion_group! {
+    name = benches;
+    config = Criterion::default()
+        .warm_up_time(std::time::Duration::from_secs(1))
+        .measurement_time(std::time::Duration::from_secs(2));
+    targets = criterion_benchmark
+}
+criterion_main!(benches);

opentelemetry-appender-tracing/examples/basic.rs

@@ -1,28 +1,55 @@
 //! run with `$ cargo run --example basic
 
-use opentelemetry_api::KeyValue;
 use opentelemetry_appender_tracing::layer;
-use opentelemetry_sdk::{
-    logs::{Config, LoggerProvider},
-    Resource,
-};
+use opentelemetry_sdk::{logs::SdkLoggerProvider, Resource};
 use tracing::error;
-use tracing_subscriber::prelude::*;
+use tracing_subscriber::{prelude::*, EnvFilter};
 
 fn main() {
     let exporter = opentelemetry_stdout::LogExporter::default();
-    let provider: LoggerProvider = LoggerProvider::builder()
-        .with_config(
-            Config::default().with_resource(Resource::new(vec![KeyValue::new(
-                "service.name",
-                "log-appender-tracing-example",
-            )])),
+    let provider: SdkLoggerProvider = SdkLoggerProvider::builder()
+        .with_resource(
+            Resource::builder()
+                .with_service_name("log-appender-tracing-example")
+                .build(),
         )
         .with_simple_exporter(exporter)
         .build();
-    let layer = layer::OpenTelemetryTracingBridge::new(&provider);
-    tracing_subscriber::registry().with(layer).init();
 
-    error!(target: "my-system", event_id = 20, event_name = "my-event_name", user_name = "otel", user_email = "otel@opentelemetry.io");
-    drop(provider);
+    // To prevent a telemetry-induced-telemetry loop, OpenTelemetry's own internal
+    // logging is properly suppressed. However, logs emitted by external components
+    // (such as reqwest, tonic, etc.) are not suppressed as they do not propagate
+    // OpenTelemetry context. Until this issue is addressed
+    // (https://github.com/open-telemetry/opentelemetry-rust/issues/2877),
+    // filtering like this is the best way to suppress such logs.
+    //
+    // The filter levels are set as follows:
+    // - Allow `info` level and above by default.
+    // - Completely restrict logs from `hyper`, `tonic`, `h2`, and `reqwest`.
+    //
+    // Note: This filtering will also drop logs from these components even when
+    // they are used outside of the OTLP Exporter.
+    let filter_otel = EnvFilter::new("info")
+        .add_directive("hyper=off".parse().unwrap())
+        .add_directive("opentelemetry=off".parse().unwrap())
+        .add_directive("tonic=off".parse().unwrap())
+        .add_directive("h2=off".parse().unwrap())
+        .add_directive("reqwest=off".parse().unwrap());
+    let otel_layer = layer::OpenTelemetryTracingBridge::new(&provider).with_filter(filter_otel);
+
+    // Create a new tracing::Fmt layer to print the logs to stdout. It has a
+    // default filter of `info` level and above, and `debug` and above for logs
+    // from OpenTelemetry crates. The filter levels can be customized as needed.
+    let filter_fmt = EnvFilter::new("info").add_directive("opentelemetry=debug".parse().unwrap());
+    let fmt_layer = tracing_subscriber::fmt::layer()
+        .with_thread_names(true)
+        .with_filter(filter_fmt);
+
+    tracing_subscriber::registry()
+        .with(otel_layer)
+        .with(fmt_layer)
+        .init();
+
+    error!(name: "my-event-name", target: "my-system", event_id = 20, user_name = "otel", user_email = "otel@opentelemetry.io", message = "This is an example message");
+    let _ = provider.shutdown();
 }

opentelemetry-appender-tracing/src/lib.rs

@@ -1 +1,155 @@
+//! # OpenTelemetry-Appender-Tracing
+//!
+//! This crate provides a bridge between the [`tracing`](https://docs.rs/tracing/latest/tracing/) crate and OpenTelemetry logs.
+//! It converts `tracing` events into OpenTelemetry `LogRecords`, allowing applications using `tracing` to seamlessly integrate
+//! with OpenTelemetry logging backends.
+//!
+//! ## Background
+//!
+//! Unlike traces and metrics, OpenTelemetry does not provide a dedicated logging API for end-users. Instead, it recommends using
+//! existing logging libraries and bridging them to OpenTelemetry logs. This crate serves as such a bridge for `tracing` users.
+//!
+//! ## Features
+//!
+//! - Converts `tracing` events into OpenTelemetry [`LogRecords`](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/logs/data-model.md#log-and-event-record-definition)
+//! - Integrates as a [`Layer`](https://docs.rs/tracing-subscriber/latest/tracing_subscriber/layer/trait.Layer.html)
+//!   from [`tracing-subscriber`](https://docs.rs/tracing-subscriber/latest/tracing_subscriber/), allowing
+//!   to be used alongside other `tracing` layers, such as `fmt`
+//! - Automatically attaches OpenTelemetry trace context (`TraceId`, `SpanId`, `TraceFlags`) to logs
+//! - Automatically associates OpenTelemetry Resource to logs
+//! - Supports exporting logs to OpenTelemetry-compatible backends (OTLP, stdout, etc.)
+//!
+//! ## Getting Started
+//!
+//! ### 1. Install Dependencies
+//!
+//! Add the following dependencies to your `Cargo.toml`:
+//!
+//! ```toml
+//! [dependencies]
+//! tracing = ">=0.1.40"
+//! tracing-core = { version = ">=0.1.33" }
+//! tracing-subscriber = { version = "0.3", features = ["registry", "std", "fmt"] }
+//! opentelemetry = { version = "0.28", features = ["logs"] }
+//! opentelemetry-sdk = { version = "0.28", features = ["logs"] }
+//! opentelemetry-appender-tracing = { version = "0.28.1" }
+//! ```
+//!
+//! ### 2. Set Up the OpenTelemetry Logger Provider
+//!
+//! Before integrating with `tracing`, create an OpenTelemetry [`SdkLoggerProvider`](https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/logs/struct.SdkLoggerProvider.html):
+//!
+//! ```rust
+//! use opentelemetry_sdk::logs::SdkLoggerProvider;
+//! use opentelemetry_stdout::LogExporter;
+//!
+//! let exporter = LogExporter::default();
+//! let provider = SdkLoggerProvider::builder()
+//!     .with_simple_exporter(exporter)
+//!     .build();
+//! ```
+//!
+//! In this example, `SdkLoggerProvider` is configured to use the `opentelemetry_stdout` crate to export logs to stdout. You can replace it with any other OpenTelemetry-compatible exporter.
+//! Any additional OpenTelemetry configuration (e.g., setting up a resource, additional processors etc.) can be done at this stage.
+//!
+//! ### 3. Create the OpenTelemetry-Tracing Bridge
+//!
+//! Create `OpenTelemetryTracingBridge` layer using the `SdkLoggerProvider` created in the previous step.
+//!
+//! ```rust
+//! # use opentelemetry_sdk::logs::SdkLoggerProvider;
+//! # use opentelemetry_stdout::LogExporter;
+//! # use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
+//! # let exporter = LogExporter::default();
+//! # let provider = SdkLoggerProvider::builder()
+//! #    .with_simple_exporter(exporter)
+//! #    .build();
+//! let otel_layer = OpenTelemetryTracingBridge::new(&provider);
+//! ```
+//!
+//! ### 4. Register the `tracing` Subscriber
+//!
+//! Since this crate provides a `Layer` for `tracing`, you can register it with the `tracing` subscriber as shown below.
+//!
+//! ```rust
+//! # use opentelemetry_sdk::logs::SdkLoggerProvider;
+//! # use opentelemetry_stdout::LogExporter;
+//! # let exporter = LogExporter::default();
+//! # let provider = SdkLoggerProvider::builder().with_simple_exporter(exporter).build();
+//! # use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
+//! # let otel_layer = OpenTelemetryTracingBridge::new(&provider);
+//! use tracing_subscriber::prelude::*;
+//!
+//! tracing_subscriber::registry()
+//!     .with(otel_layer)
+//!     .with(tracing_subscriber::fmt::layer()) // In this example, `fmt` layer is also added.
+//!     .init();
+//! ```
+//!
+//! ### 5. Log Events Using `tracing`
+//!
+//! ```rust
+//! use tracing::error;
+//! error!(name: "my-event-name1", target: "my-system", event_id = 10, user_name = "otel", user_email = "otel@opentelemetry.io", message = "This is an example message");
+//! ```
+//!
+//!
+//! ## Mapping details
+//!
+//! Since OpenTelemetry and `tracing` have their own data models, this bridge performs the following mappings:
+//!
+//! | `tracing`             | OpenTelemetry           | Notes                                                                                   |
+//! |-----------------------|-------------------------|-----------------------------------------------------------------------------------------|
+//! | name of the event     | `EventName`             | OpenTelemetry defines logs with name as Events, so every `tracing` Event is actually an OTel Event |
+//! | target                | `target`                | Groups logs from the same module/crate. At recording time, `target` is stored in a top-level field. But exporters treat this information as OpenTelemetry `InstrumentationScope` |
+//! | level of the event    | `Severity`, `SeverityText` |                                                                                         |
+//! | Fields                | `Attributes`            | Converted into OpenTelemetry log attributes. Field with "message" as key is specially treated and stored as `LogRecord::Body` |
+//! | Message               | `Body`                  | The body/message of the log. This is done only if body was not already populated from "message" field above |
+//!
+//! ### Data Type Mapping
+//!
+//! The data types supported by `tracing` and OpenTelemetry are different and the following conversions are applied:
+//!
+//! | `tracing` Type | OpenTelemetry `AnyValue` Type |
+//! |----------------|-------------------------------|
+//! | `i64`          | `Int`                         |
+//! | `f32`, `f64`   | `Double`                      |
+//! | `u64`,`u128` ,`i128`         | `Int` (if convertible to `i64` without loss) else `String` |
+//! | `&str`         | `String`                      |
+//! | `bool`         | `Bool`                        |
+//! | `&[u8]`        | `Bytes`                       |
+//! | `&dyn Debug`   | `String` (via `Debug` formatting) |
+//! | `&dyn Error`   | `String` (via `Debug` formatting). This is stored into an attribute with key "exception.message", following [OTel conventions](https://opentelemetry.io/docs/specs/semconv/attributes-registry/exception/) |
+//!
+//! In future, additional types may be supported.
+//!
+//! > **Note:** This crate does not support `tracing` Spans. One may use [`tracing-opentelemetry`](https://docs.rs/tracing-opentelemetry/latest/tracing_opentelemetry/) to
+//! > convert `tracing` spans into OpenTelemetry spans. This is a third-party crate
+//! > that is not maintained by the OpenTelemetry project.
+//! > `tracing-opentelemetry`:
+//! > - Converts `tracing` spans into OpenTelemetry spans  
+//! > - Converts `tracing` events into OpenTelemetry `SpanEvents` rather than logs
+//! >   Depending on the outcome of the
+//! >   [discussion](https://github.com/open-telemetry/opentelemetry-rust/issues/1571),
+//! >   the OpenTelemetry project may provide direct support to map `tracing`
+//! >   spans to OpenTelemetry in the future.
+//!
+//! ## Feature Flags
+//! `spec_unstable_logs_enabled`: TODO
+//!
+//! `experimental_metadata_attributes`: TODO
+//!
+//! `experimental_use_tracing_span_context`: TODO
+//!
+//! ## Limitations
+//! 1. There is no support for `Valuable` crate. [2819](https://github.com/open-telemetry/opentelemetry-rust/issues/2819)
+//!
+//! ## Stability Guarantees
+//! // TODO
+//!
+//! ## Further Reading
+//!
+//! - OpenTelemetry Rust: [opentelemetry-rust](https://github.com/open-telemetry/opentelemetry-rust)
+//! - Tracing: [tracing](https://docs.rs/tracing/)
+//! - OpenTelemetry Logs: [OpenTelemetry Logging Specification](https://opentelemetry.io/docs/specs/otel/logs/)
 pub mod layer;