chore(deps): update github/codeql-action action to v3.29.11 (#890)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

.circleci/config.yml

@@ -1,78 +0,0 @@
-version: 2.1
-
-orbs:
-  rebar3: tsloughter/rebar3@0.8.1
-  codecov: codecov/codecov@1.0.5
-
-jobs:
-  codecov:
-    parameters:
-      executor:
-        description: The executor to use for this job.
-        type: executor
-        default: erlang
-    executor: <<parameters.executor>>
-    steps:
-      - attach_workspace:
-          at: ~/project/
-      - codecov/upload:
-          file: _build/test/covertool/opentelemetry.covertool.xml
-
-  run_benchmarks:
-    docker:
-    - image: circleci/elixir:1.9
-    steps:
-    - checkout
-
-    - run: |
-        mix local.hex --force
-        mix local.rebar --force
-
-        rebar3 as bench compile
-
-        ERL_LIBS=_build/bench/lib/ mix run --no-mix-exs samples/run.exs
-
-erlang22: &erlang22
-  executor:
-    name: rebar3/erlang
-    tag: "22"
-
-erlang21: &erlang21
-  executor:
-    name: rebar3/erlang
-    tag: "21"
-
-workflows:
-  otp21:
-    jobs:
-      - rebar3/compile:
-          <<: *erlang21
-
-  otp22:
-    jobs:
-      - rebar3/compile:
-          <<: *erlang22
-      - rebar3/xref:
-          <<: *erlang22
-          requires:
-            - rebar3/compile
-      - rebar3/dialyzer:
-          <<: *erlang22
-          requires:
-            - rebar3/compile
-      - rebar3/ct:
-          <<: *erlang22
-          requires:
-            - rebar3/compile
-      - rebar3/cover:
-          <<: *erlang22
-          requires:
-            - rebar3/ct
-      - codecov:
-          <<: *erlang22
-          requires:
-            - rebar3/cover
-
-  benchmarks:
-    jobs:
-      - run_benchmarks

.formatter.exs

@@ -0,0 +1,3 @@
+[
+  inputs: ["{mix,.formatter}.exs", "{samples,test}/**/*.{ex,exs}"]
+]

.github/labeler.yml

@@ -0,0 +1,20 @@
+language-elixir:
+  - apps/**/*.ex
+  - apps/**/*.exs
+
+language-erlang:
+  - apps/**/*.erl
+  - apps/**/*.hrl
+  - apps/**/rebar.config
+
+scope-api:
+  - apps/opentelemetry_api/**
+
+scope-sdk:
+  - apps/opentelemetry/**
+
+scope-semconv:
+  - apps/opentelemetry_semantic_conventions/**
+
+scope-ci:
+  - .github/workflows/**

.github/repository-settings.md

@@ -0,0 +1,6 @@
+# Repository Settings Changes
+
+Tracks changes to this repository's settings by admins/maintainers per [community guidelines](https://github.com/open-telemetry/community/blob/main/docs/how-to-configure-new-repository.md#collaborators-and-teams).
+
+## Changelog
+

.github/workflows/elixir.yml

@@ -0,0 +1,188 @@
+name: Elixir
+
+on:
+  pull_request:
+    branches:
+      - "main"
+    types: [opened, reopened, synchronize, labeled]
+
+  push:
+    branches:
+      - "main"
+
+permissions:
+  contents: read
+
+jobs:
+  format:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v5
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: "27.2"
+          elixir-version: "1.18.1"
+          version-type: "strict"
+      - uses: actions/cache@v4
+        name: Cache
+        with:
+          path: |
+            apps/opentelemetry_api/deps
+          key: v3-${{ hashFiles('apps/opentelemetry_api/mix.lock') }}
+      - run: mix format --check-formatted
+      - run: mix deps.get
+        working-directory: apps/opentelemetry_api/
+      - run: mix format --check-formatted
+        working-directory: apps/opentelemetry_api/
+  sdk_tests:
+    runs-on: ${{ matrix.os }}
+    name: Test SDK on Elixir ${{ matrix.elixir_version }} (OTP ${{ matrix.otp_version }}) and ${{ matrix.os }}
+    strategy:
+      matrix:
+        otp_version: ["27.2", "25.3.2.16"]
+        elixir_version: ["1.18.1", "1.14.5"]
+        rebar3_version: ["3.24.0"]
+        os: [ubuntu-24.04]
+        exclude:
+          - elixir_version: "1.14.5"
+          - otp_version: "27.2"
+    env:
+      OTP_VERSION: ${{ matrix.otp_version }}
+      ELIXIR_VERSION: ${{ matrix.elixir_version }}
+    steps:
+      - uses: actions/checkout@v5
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: ${{ matrix.otp_version }}
+          elixir-version: ${{ matrix.elixir_version }}
+          rebar3-version: ${{ matrix.rebar3_version }}
+          version-type: "strict"
+      - name: Compile
+        run: rebar3 as test compile
+      - name: ExUnit
+        run: mix test --no-start test/otel_tests.exs test/otel_metric_tests.exs
+
+  api_tests:
+    runs-on: ${{ matrix.os }}
+    name: Test API on Elixir ${{ matrix.elixir_version }} (OTP ${{ matrix.otp_version }}) and ${{ matrix.os }}
+    strategy:
+      matrix:
+        otp_version: ["27.2", "25.3.2.16"]
+        elixir_version: ["1.18.1", "1.14.5"]
+        rebar3_version: ["3.24.0"]
+        os: [ubuntu-24.04]
+        exclude:
+          - elixir_version: "1.14.5"
+          - otp_version: "27.2"
+    env:
+      OTP_VERSION: ${{ matrix.otp_version }}
+      ELIXIR_VERSION: ${{ matrix.elixir_version }}
+    defaults:
+      run:
+        working-directory: apps/opentelemetry_api/
+    steps:
+      - uses: actions/checkout@v5
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: ${{ matrix.otp_version }}
+          elixir-version: ${{ matrix.elixir_version }}
+          rebar3-version: ${{ matrix.rebar3_version }}
+          version-type: "strict"
+      - uses: actions/cache@v4
+        name: Cache
+        with:
+          path: |
+            apps/opentelemetry_api/deps
+            apps/opentelemetry_api/_build
+          key: ${{ runner.os }}-build-${{ matrix.otp_version }}-${{ matrix.elixir_version }}-v4-${{ hashFiles(format('{0}{1}', github.workspace, '/apps/opentelemetry_api/mix.lock')) }}
+          restore-keys: |
+            ${{ runner.os }}-build-${{ matrix.otp_version }}-${{ matrix.elixir_version }}-
+      - run: mix deps.get
+        name: Deps
+      - run: mix test --cover
+        name: ExUnit
+      - uses: codecov/codecov-action@v5
+        if: ${{ always() }}
+        with:
+          file: apps/opentelemetry_api/coverage.xml
+          env_vars: OTP_VERSION,ELIXIR_VERSION
+          flags: api,elixir
+
+  dialyze:
+    runs-on: ${{ matrix.os }}
+    name: Dialyze on Elixir ${{ matrix.elixir_version }} (OTP ${{ matrix.otp_version }}) and ${{ matrix.os }}
+    strategy:
+      matrix:
+        otp_version: ["27.2"]
+        elixir_version: ["1.18.1"]
+        rebar3_version: ["3.24.0"]
+        os: [ubuntu-24.04]
+    env:
+      OTP_VERSION: ${{ matrix.otp_version }}
+      ELIXIR_VERSION: ${{ matrix.elixir_version }}
+    defaults:
+      run:
+        working-directory: apps/opentelemetry_api/
+    steps:
+      - uses: actions/checkout@v5
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: ${{ matrix.otp_version }}
+          elixir-version: ${{ matrix.elixir_version }}
+          version-type: "strict"
+      - uses: actions/cache@v4
+        name: Cache
+        with:
+          path: |
+            apps/opentelemetry_api/deps
+            apps/opentelemetry_api/_build
+          key: ${{ runner.os }}-dialyzer-${{ matrix.otp_version }}-${{ matrix.elixir_version }}-v4-${{ hashFiles('apps/opentelemetry_api/mix.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-build-${{ matrix.otp_version }}-${{ matrix.elixir_version }}-
+      - run: mix deps.get
+        name: Deps
+      - run: mix dialyzer
+        name: Dialyzer
+
+  semconv_tests:
+    runs-on: ${{ matrix.os }}
+    if: (contains(github.event.pull_request.labels.*.name, 'language-elixir') && contains(github.event.pull_request.labels.*.name, 'scope-semconv'))
+    name: Test SemConv on Elixir ${{ matrix.elixir_version }} (OTP ${{ matrix.otp_version }}) and ${{ matrix.os }}
+    strategy:
+      matrix:
+        otp_version: ["27.2", "25.3.2.16"]
+        elixir_version: ["1.18.1", "1.14.5"]
+        rebar3_version: ["3.24.0"]
+        os: [ubuntu-24.04]
+        exclude:
+          - elixir_version: "1.14.5"
+          - otp_version: "27.2"
+    defaults:
+      run:
+        working-directory: apps/opentelemetry_semantic_conventions
+    env:
+      OTP_VERSION: ${{ matrix.otp_version }}
+      ELIXIR_VERSION: ${{ matrix.elixir_version }}
+    steps:
+      - uses: actions/checkout@v5
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: ${{ matrix.otp_version }}
+          elixir-version: ${{ matrix.elixir_version }}
+          rebar3-version: ${{ matrix.rebar3_version }}
+          version-type: "strict"
+      - name: Cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/deps
+            ~/_build
+          key: ${{ runner.os }}-test-${{ matrix.otp_version }}-${{ matrix.elixir_version }}-${{ hashFiles('**/mix.lock') }}
+
+      - name: Get and compile deps
+        if: steps.deps-cache.outputs.cache-hit != 'true'
+        run: |
+          mix deps.get
+          mix deps.compile
+      - name: ExUnit
+        run: mix test

.github/workflows/erlang.yml

@@ -0,0 +1,173 @@
+---
+name: Erlang
+
+on:
+  pull_request:
+    branches:
+      - "main"
+    types: [opened, reopened, synchronize, labeled]
+
+  push:
+    branches:
+      - "main"
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    permissions:
+      checks: write
+    name: Test on OTP ${{ matrix.otp_version }} and ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        otp_version: ["27.2", "26.2.5.6", "25.3.2.16"]
+        rebar3_version: ["3.24.0"]
+        os: [ubuntu-24.04]
+    env:
+      OTP_VERSION: ${{ matrix.otp_version }}
+    steps:
+      - uses: actions/checkout@v5
+      - name: Run Collector
+        run: docker compose up -d
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: ${{ matrix.otp_version }}
+          rebar3-version: ${{ matrix.rebar3_version }}
+          version-type: "strict"
+      - uses: actions/cache@v4
+        name: Cache
+        with:
+          path: |
+            _build
+          key: ${{ runner.os }}-build-${{ matrix.otp_version }}-${{ hashFiles(format('rebar.lock')) }}-5
+          restore-keys: |
+            ${{ runner.os }}-build-${{ matrix.otp_version }}-5-
+      - name: Compile
+        run: rebar3 compile
+      - name: EUnit tests
+        run: rebar3 eunit --cover
+      - name: Common Test tests
+        run: rebar3 ct --cover
+
+      - name: Publish Test Report
+        uses: mikepenz/action-junit-report@v5
+        if: success() || failure() # always run even if the previous step fails
+        with:
+          report_paths: "**/_build/test/logs/*/junit_report.xml"
+
+      - name: XRef
+        run: rebar3 xref
+      - name: Covertool
+        if: ${{ always() }}
+        run: rebar3 covertool generate
+      - uses: codecov/codecov-action@v5
+        if: ${{ always() }}
+        with:
+          file: _build/test/covertool/opentelemetry.covertool.xml
+          env_vars: OTP_VERSION
+          flags: sdk,erlang
+      - uses: codecov/codecov-action@v5
+        if: ${{ always() }}
+        with:
+          file: _build/test/covertool/opentelemetry_api.covertool.xml
+          env_vars: OTP_VERSION
+          flags: api,erlang
+      - uses: codecov/codecov-action@v5
+        if: ${{ always() }}
+        with:
+          file: _build/test/covertool/opentelemetry_exporter.covertool.xml
+          env_vars: OTP_VERSION
+          flags: exporter,erlang
+      - uses: codecov/codecov-action@v5
+        if: ${{ always() }}
+        with:
+          file: _build/test/covertool/opentelemetry_zipkin.covertool.xml
+          env_vars: OTP_VERSION
+          flags: zipkin,erlang
+  dialyzer:
+    name: Dialyze on OTP ${{ matrix.otp_version }} and ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        otp_version: ["27.2"]
+        rebar3_version: ["3.24.0"]
+        os: [ubuntu-24.04]
+    steps:
+      - uses: actions/checkout@v5
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: ${{ matrix.otp_version }}
+          rebar3-version: ${{ matrix.rebar3_version }}
+          version-type: "strict"
+      - uses: actions/cache@v4
+        name: Cache
+        with:
+          path: |
+            _build
+          key: ${{ runner.os }}-build-${{ matrix.otp_version }}-${{ hashFiles('rebar.lock') }}-5
+          restore-keys: |
+            ${{ runner.os }}-dialyzer-${{ matrix.otp_version }}-5-
+      - name: Compile
+        run: rebar3 compile
+      - name: Dialyzer
+        run: rebar3 as dialyzer dialyzer
+
+  eqWAlizer:
+    name: EqWAlizer on OTP ${{ matrix.otp_version }} and ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        otp_version: ["27.2"]
+        rebar3_version: ["3.24.0"]
+        os: [ubuntu-24.04]
+    steps:
+      - uses: actions/checkout@v5
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: ${{ matrix.otp_version }}
+          rebar3-version: ${{ matrix.rebar3_version }}
+          version-type: "strict"
+      - uses: actions/cache@v4
+        name: Cache
+        with:
+          path: |
+            _build
+          key: ${{ runner.os }}-build-${{ matrix.otp_version }}-${{ hashFiles('rebar.lock') }}-5
+          restore-keys: |
+            ${{ runner.os }}-eqWAlizer-${{ matrix.otp_version }}-5-
+      - name: Download elp
+        run: |
+          wget https://github.com/WhatsApp/erlang-language-platform/releases/download/2024-12-09/elp-linux-x86_64-unknown-linux-gnu-otp-27.1.tar.gz
+          tar xvf elp-linux-x86_64-unknown-linux-gnu-otp-27.1.tar.gz
+      - name: Compile
+        run: rebar3 compile
+      - name: eqWAlizer
+        run: ./elp eqwalize-all
+
+  semconv_tests:
+    runs-on: ${{ matrix.os }}
+    if: (contains(github.event.pull_request.labels.*.name, 'language-erlang') && contains(github.event.pull_request.labels.*.name, 'scope-semconv'))
+    name: Test SemConv on (OTP ${{ matrix.otp_version }}) and ${{ matrix.os }}
+    strategy:
+      matrix:
+        otp_version: ["27.2", "25.3.2.16"]
+        rebar3_version: ["3.24.0"]
+        os: [ubuntu-24.04]
+    defaults:
+      run:
+        working-directory: apps/opentelemetry_semantic_conventions
+    env:
+      OTP_VERSION: ${{ matrix.otp_version }}
+    steps:
+      - uses: actions/checkout@v5
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: ${{ matrix.otp_version }}
+          rebar3-version: ${{ matrix.rebar3_version }}
+          version-type: "strict"
+      - name: Compile
+        run: rebar3 compile
+      - name: Common Test tests
+        run: rebar3 ct --cover

.github/workflows/fossa.yml

@@ -0,0 +1,27 @@
+name: FOSSA scanning
+
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+
+jobs:
+  fossa:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: "27.2"
+          rebar3-version: "3.24.0"
+          elixir-version: "1.18.1"
+          version-type: "strict"
+
+      - uses: fossas/fossa-action@3ebcea1862c6ffbd5cf1b4d0bd6b3fe7bd6f2cac # v1.7.0
+        with:
+          api-key: ${{secrets.FOSSA_API_KEY}}
+          team: OpenTelemetry

.github/workflows/labeler.yml

@@ -0,0 +1,15 @@
+name: "Pull Request Labeler"
+on: [pull_request_target]
+
+permissions:
+  contents: read
+
+jobs:
+  triage:
+    permissions:
+      pull-requests: write # required for labeling PRs
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/labeler@v4
+        with:
+          repo-token: "${{ secrets.GITHUB_TOKEN }}"

.github/workflows/main.yml

@@ -1,39 +0,0 @@
-name: Common Test
-
-on:
-  pull_request:
-    branches:
-      - 'master'
-  push:
-    branches:
-      - 'master'
-
-jobs:
-  build:
-    name: Test on OTP ${{ matrix.otp_version }} and ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-
-    strategy:
-      matrix:
-        otp_version: ['23.0.2', '22.3.4.2', '21.3.8.16']
-        os: [ubuntu-latest]
-
-    steps:
-    - uses: actions/checkout@v2
-    - uses: gleam-lang/setup-erlang@v1.0.0
-      with:
-        otp-version: ${{ matrix.otp_version }}
-
-    - name: Compile
-      run: rebar3 compile
-    - name: EUnit tests
-      run: rebar3 eunit
-    - name: Dialyzer
-      run: rebar3 dialyzer
-    - name: XRef
-      run: rebar3 xref
-    - name: Covertool
-      run: rebar3 covertool generate
-    - uses: codecov/codecov-action@v1
-      with:
-        file: _build/test/covertool/opentelemetry.covertool.xml

.github/workflows/ossf-scorecard.yml

@@ -0,0 +1,47 @@
+name: OSSF Scorecard
+
+on:
+  push:
+    branches:
+      - main
+  schedule:
+    - cron: "33 11 * * 1" # once a week
+  workflow_dispatch:
+
+permissions: read-all
+
+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:
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        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@3c3833e0f8c1c83d449a7478aa59c036a9165498 # v3.29.11
+        with:
+          sarif_file: results.sarif

.github/workflows/w3c_interop.yml

@@ -0,0 +1,54 @@
+name: W3C Interop
+
+on:
+  pull_request:
+    branches:
+      - 'main'
+  push:
+    branches:
+      - 'main'
+
+permissions:
+  contents: read
+
+jobs:
+  interop_tests:
+    name: Run W3C Trace Context Interop Tests
+    runs-on: ubuntu-24.04
+    steps:
+    - uses: actions/checkout@v5
+    - uses: erlef/setup-beam@v1
+      with:
+        otp-version: '26.1.2'
+        version-type: strict
+        rebar3-version: '3.22.1'
+    - uses: actions/cache@v4
+      name: Cache
+      with:
+        path: |
+          _build
+        key: ${{ runner.os }}-build-${{ matrix.otp_version }}-${{ hashFiles(format('rebar.lock')) }}-1
+        restore-keys: |
+          ${{ runner.os }}-build-${{ matrix.otp_version }}-1-
+
+    - name: Compile
+      run: rebar3 as interop compile
+
+    - uses: actions/checkout@v5
+      with:
+        repository: 'w3c/trace-context'
+        path: 'trace-context'
+    - name: Setup python
+      uses: actions/setup-python@v5
+      with:
+        python-version: 3.13
+        architecture: x64
+    - run: pip install aiohttp
+    - run: |
+        rebar3 as interop compile
+
+        erl -noinput -pa ./_build/interop/extras/interop/ $(rebar3 as interop path) -s w3c_trace_context_interop &
+        sleep 1
+        cd trace-context/test
+        STRICT_LEVEL=2 python3 test.py http://127.0.0.1:5000/test
+      shell: bash

.gitignore

@@ -17,3 +17,6 @@ _build
 *.iml
 rebar3.crashdump
 *~
+doc
+!_index.md
+guides

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "apps/opentelemetry_exporter/opentelemetry-proto"]
+	path = apps/opentelemetry_exporter/opentelemetry-proto
+	url = https://github.com/open-telemetry/opentelemetry-proto.git

CHANGELOG.md

@@ -0,0 +1,656 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## API 1.4.1 - 2025-07-31
+
+### Fixes
+
+- Various type spec fixes
+
+## SDK 1.5.1 - 2025-07-31
+
+### Fixes
+
+- [fix the batch export timeout to default to 30 seconds](https://github.com/open-telemetry/opentelemetry-erlang/pull/836)
+
+## OTLP Exporter 1.8.1 - 2025-07-31
+
+### Fixes
+
+- [fix: key for otlp traces protocol app configuration](https://github.com/open-telemetry/opentelemetry-erlang/pull/789)
+
+## Experimental API 0.5.2 - 2024-11-22
+
+### Added
+
+- [Hard code semconv values](https://github.com/open-telemetry/opentelemetry-erlang/pull/780)
+
+## Experimental SDK 0.6.0 - 2024-11-22
+
+### Added
+
+- [move metrics and logs to separate exporter modules from
+  traces](https://github.com/open-telemetry/opentelemetry-erlang/pull/720)
+- [make the console metric exporter handle all
+  values](https://github.com/open-telemetry/opentelemetry-erlang/pull/709)
+
+### Fixes
+
+- [metric exporter: nothing to do for an empty list of
+  metrics](https://github.com/open-telemetry/opentelemetry-erlang/pull/782)
+- [Hard code semconv
+  values](https://github.com/open-telemetry/opentelemetry-erlang/pull/780)
+- [removed old unused otel_metric_exporter
+  module](https://github.com/open-telemetry/opentelemetry-erlang/pull/715)
+  
+## Exporter 1.8.0 - 2024-10-05
+
+### Fixes
+
+- [BREAKING: Fixes support for attribute values that are lists when the elements
+  are strings. Lists of strings in attribute values are no longer flattened but
+  remain lists. Meaning to use an Erlang charlist string or iolist as a value in
+  an attribute you must convert with `unicode:characters_to_binary` before
+  adding to the
+  attributes](https://github.com/open-telemetry/opentelemetry-erlang/pull/737)
+
+## API 1.4.0 - 2024-10-05
+
+### Changes
+
+- [Hard code semconv 0.2 values](https://github.com/open-telemetry/opentelemetry-erlang/pull/780)
+
+## SDK 1.5.0 - 2024-10-05
+
+### Changes
+
+- [Fix invalid warning log causing FORMATTER
+  CRASH](https://github.com/open-telemetry/opentelemetry-erlang/pull/774)
+- [Hard code semconv 0.2 values](https://github.com/open-telemetry/opentelemetry-erlang/pull/780)
+
+## API 1.3.1 - 2024-09-03
+
+### Fixes
+
+- [Fix dialyzer warning when starting a span by adding
+  `otel_span:start_config`](https://github.com/open-telemetry/opentelemetry-erlang/pull/717)
+
+## Experimental API 0.5.1 - 2024-03-18
+
+### Added
+
+- [instrument kind temporality function for use by the
+  SDK](https://github.com/open-telemetry/opentelemetry-erlang/pull/713)
+
+## Experimental SDK 0.5.1 - 2024-03-18
+
+### Fixes
+
+- [use correct default temporality for streams based on the instrument
+  kind](https://github.com/open-telemetry/opentelemetry-erlang/pull/713)
+
+## API 1.3.0 - 2024-03-15
+
+### Changes
+
+- [Add `otel_tracestate` module for creating and updating
+  tracestate](https://github.com/open-telemetry/opentelemetry-erlang/pull/607)
+- [Attributes module `otel_attributes` moved to
+  API](https://github.com/open-telemetry/opentelemetry-erlang/pull/618)
+- [Moved attribute processing functions to `otel_attributes` from
+  `otel_span`](https://github.com/open-telemetry/opentelemetry-erlang/pull/620)
+
+## SDK 1.4.0 - 2024-03-15
+
+### Changes
+
+- [Attributes module `otel_attributes` moved to
+  API](https://github.com/open-telemetry/opentelemetry-erlang/pull/618)
+- [create unique processor name in
+  otel_tracer_server](https://github.com/open-telemetry/opentelemetry-erlang/pull/646)
+
+### Fixes
+
+- [Fix leak of atoms/persistent terms by creating unique processor name in `otel_tracer_server`](https://github.com/open-telemetry/opentelemetry-erlang/pull/646)
+- [fix(otel_batch_processor): don't divide `max_queue_size` by
+  word-size](https://github.com/open-telemetry/opentelemetry-erlang/pull/635)
+- [fix(otel_processor): wait for runner process
+  termination](https://github.com/open-telemetry/opentelemetry-erlang/pull/641)
+
+## Exporter 1.7.0 - 2024-03-15
+
+## Added
+
+- [Add User-Agent header to exporter
+  requests](https://github.com/open-telemetry/opentelemetry-erlang/pull/605)
+
+## Experimental API 0.5.0 - 2024-03-15
+
+### Changes
+
+- [Allow to create observable instruments without passing callback
+  arguments](https://github.com/open-telemetry/opentelemetry-erlang/pull/604)
+- [Allow to give `advisory_params` to instrument creation functions](https://github.com/open-telemetry/opentelemetry-erlang/pull/628)
+- [Attributes are optional in Counter.add(), UpDownCounter.add() and Histo.record()](https://github.com/open-telemetry/opentelemetry-erlang/pull/632)
+- [Support explicit_bucket_boundaries advisory
+  parameters](https://github.com/open-telemetry/opentelemetry-erlang/pull/628)
+
+## Experimental SDK 0.5.0 - 2024-03-15
+
+### Added
+
+- [Add `instrument_unit` to view criteria](https://github.com/open-telemetry/opentelemetry-erlang/pull/604)
+- [Validate instrument name](https://github.com/open-telemetry/opentelemetry-erlang/pull/604)
+- [Handle `explicit_bucket_boundaries` advisory parameter](https://github.com/open-telemetry/opentelemetry-erlang/pull/628)
+- [Rename `boundaries` to `explicit_bucket_boundaries` in histogram explicit aggregation options](https://github.com/open-telemetry/opentelemetry-erlang/pull/628)
+- [Allow creating wildcard views](https://github.com/open-telemetry/opentelemetry-erlang/pull/624)
+- [Exemplars support](https://github.com/open-telemetry/opentelemetry-erlang/pull/692)
+- [Metric
+  producers](https://github.com/open-telemetry/opentelemetry-erlang/pull/701)
+- [Exemplar reservoir support](https://github.com/open-telemetry/opentelemetry-erlang/pull/692)
+  
+### Changes
+
+- [Align histogram default boundaries with specification](https://github.com/open-telemetry/opentelemetry-erlang/pull/614)
+- [Metrics: fix observable callbacks to return a list of
+  results](https://github.com/open-telemetry/opentelemetry-erlang/pull/561)
+- [Add a fresh context to each observable callback and test observe
+  exemplars](https://github.com/open-telemetry/opentelemetry-erlang/pull/697)
+  
+### Fixes
+
+ - [Correctly record histogram values greater than last boundary](https://github.com/open-telemetry/opentelemetry-erlang/pull/614)
+ - [Readers should use a default cumulative temporality if not specified](https://github.com/open-telemetry/opentelemetry-erlang/pull/613)
+ - [Check for positive data values in counters and histograms](https://github.com/open-telemetry/opentelemetry-erlang/pull/632)
+- [Fix Delta metric export to only include those recorded in collection cycle](https://github.com/open-telemetry/opentelemetry-erlang/pull/677)
+- [Cumulative sums
+  fix](https://github.com/open-telemetry/opentelemetry-erlang/pull/592)
+- [Fix transmitted time units for
+  logs](https://github.com/open-telemetry/opentelemetry-erlang/pull/640)
+- [don't export unit fields in metrics when the unit is
+  undefined](https://github.com/open-telemetry/opentelemetry-erlang/pull/669)
+
+## SDK 1.3.1 - 2023-08-15
+
+### Added
+
+- [Add support for OTEL_SDK_DISABLED environment variable and sdk_disabled
+  application environment
+  variable](https://github.com/open-telemetry/opentelemetry-erlang/pull/574)
+
+### Changes
+
+- [Resource is now an argument to TracerProvider start, but still set
+  automatically by SDK startup of the global
+  Provider](https://github.com/open-telemetry/opentelemetry-erlang/pull/568)
+- [Global Tracer no longer set to no-op on SDK
+  shutdown](https://github.com/open-telemetry/opentelemetry-erlang/pull/568)
+- [Remove use of `deprecated` module attribute to support
+  OTP-22](https://github.com/open-telemetry/opentelemetry-erlang/pull/603)
+
+### Fixes
+
+- [Fixed parsing of key/value list configuration where value has = in
+  it](https://github.com/open-telemetry/opentelemetry-erlang/pull/596)
+
+## API 1.2.2 - 2023-08-15
+
+### Changes
+
+- [Remove use of `deprecated` module attribute to support
+  OTP-22](https://github.com/open-telemetry/opentelemetry-erlang/pull/603)
+
+## Exporter 1.6.0 - 2023-06-21
+
+### Changes
+
+- [Update OTLP protos to
+  0.20.0](https://github.com/open-telemetry/opentelemetry-erlang/pull/598)
+
+## Exporter 1.5.0 - 2023-05-19
+
+### Fixes
+
+- [only start inets httpc profile if it doesn't
+  exist](https://github.com/open-telemetry/opentelemetry-erlang/pull/591)
+
+## Exporter 1.4.1 - 2023-04-26
+
+### Fixes
+
+- [Relax version constraints on API and
+  SDK](https://github.com/open-telemetry/opentelemetry-erlang/pull/578)
+
+## SDK 1.3.0 - 2023-03-21
+
+### Fixes
+
+- [Fix swapping exporter
+  tables](https://github.com/open-telemetry/opentelemetry-erlang/pull/559)
+
+## Exporter 1.4.0 - 2023-02-21
+
+### Fixes
+
+- [bump tls_certificate_check to fix crash on OTP-25](https://github.com/open-telemetry/opentelemetry-erlang/pull/547)
+
+## API v1.2.1 - 2023-02-21
+
+### Fixes
+
+- [Have set_status check is_recording in all cases](https://github.com/open-telemetry/opentelemetry-erlang/pull/540)
+- [Using opentelemetry_semantic_conventions for record_exception](https://github.com/open-telemetry/opentelemetry-erlang/pull/537)
+
+## Experimental SDK 0.3.0 - 2023-02-21
+
+### Fixes
+
+- [metrics: fix updating delta timestamps in aggregations](https://github.com/open-telemetry/opentelemetry-erlang/pull/546)
+- [Move is_monotonic check to the SDK](https://github.com/open-telemetry/opentelemetry-erlang/pull/544)
+
+## Experimental API 0.3.0 - 2023-02-21
+
+### Fixes
+
+- [Move is_monotonic check to the SDK](https://github.com/open-telemetry/opentelemetry-erlang/pull/544)
+
+## Exporter 1.2.2 - 2022-10-21
+
+### Fixes
+
+- [Allow multiple instances of OTLP grpc
+  connections](https://github.com/open-telemetry/opentelemetry-erlang/pull/481)
+
+## Experimental API 0.1.0 - 2022-10-19
+
+### Added
+
+- Erlang Metrics API
+
+### Removed
+
+- [Old experimental metrics
+  api](https://github.com/open-telemetry/opentelemetry-erlang/pull/479)
+  
+## Experimental SDK 0.1.0 - 2022-10-19
+
+### Added
+
+- Metrics SDK
+- Logging handler and exporter
+- [Delta support for explicit
+  histogram](https://github.com/open-telemetry/opentelemetry-erlang/pull/475)
+- [Logging
+  Handler](https://github.com/open-telemetry/opentelemetry-erlang/pull/468)
+- [OTLP Metrics
+  exporting](https://github.com/open-telemetry/opentelemetry-erlang/pull/456)
+  
+### Fixed
+
+- [Fix OTLP Protocol allowed
+  values](https://github.com/open-telemetry/opentelemetry-erlang/pull/420)  
+  
+## API 1.1.1 - 2022-10-19
+
+### Fixed
+
+- Gradualizer cleanup of type specs
+
+## SDK 1.1.2 - 2022-10-19
+
+#### Added
+
+- [Replaced telemetry_library record with library info as resource
+  attributes](https://github.com/open-telemetry/opentelemetry-erlang/pull/457)
+  
+## Exporter 1.2.1 - 2022-09-08
+
+### Fixes
+
+- Gradualizer cleanup
+  
+## Exporter 1.2.0 - 2022-09-08
+
+### Fixes
+
+- [Fix InstrumentationScope encoding in OTLP
+  protobufs](https://github.com/open-telemetry/opentelemetry-erlang/pull/451)
+  
+### Added
+  
+- [Exporter now respects top-level `ssl_options` application environment value
+  and handles endpoint parse errors](https://github.com/open-telemetry/opentelemetry-erlang/pull/442)
+
+## SDK 1.1.1 - 2022-09-02
+
+### Added
+
+- [Flush Trace Provider on application
+  shutdown](https://github.com/open-telemetry/opentelemetry-erlang/pull/470)
+
+### Fixes
+
+- Fix dependency on API to require `~> 1.1`
+
+## Exporter 1.1.1 - 2022-09-02
+
+### Fixes
+
+- Fix dependency on API and SDK to require `~> 1.1`
+
+## Zipkin Exporter 1.1.0 - 2022-09-02
+
+### Fixes
+
+- Support `opentelemetry_sdk ~> 1.1` exporter API
+
+## API 1.1.0 - 2022-8-31
+
+#### Added
+
+- [Span context now set in logger metadata when context is updated in process
+  dictionary](https://github.com/open-telemetry/opentelemetry-erlang/pull/394)
+- [Instrumentation Scope replaces Instrumentation
+  Library](https://github.com/open-telemetry/opentelemetry-erlang/pull/405) --
+  If you were using the record directly, please use the function
+  `opentelemetry:instrumentation_scope/3` or
+  `opentelemetry:instrumentation_library/3` to create an `instrumentation_scope`
+  record. 
+
+## SDK 1.1.0 - 2022-8-31
+
+#### Added
+
+- [Instrumentation Scope replaces Instrumentation
+  Library](https://github.com/open-telemetry/opentelemetry-erlang/pull/405) --
+  If you were using the record directly, please use the function
+  `opentelemetry:instrumentation_scope/3` or
+  `opentelemetry:instrumentation_library/3` to create an `instrumentation_scope`
+  record.
+
+### Fixed
+
+- [Allow custom text propagator to be configured via application
+  env](https://github.com/open-telemetry/opentelemetry-erlang/pull/408)
+- [No longer grow export table in batch processor if no export table is
+  configured](https://github.com/open-telemetry/opentelemetry-erlang/pull/413)
+
+## Exporter 1.1.0 - 2022-8-31
+
+#### Added
+
+- [Instrumentation Scope replaces Instrumentation
+  Library](https://github.com/open-telemetry/opentelemetry-erlang/pull/405) --
+  If you were using the record directly, please use the function
+  `opentelemetry:instrumentation_scope/3` or
+  `opentelemetry:instrumentation_library/3` to create an `instrumentation_scope`
+  record.
+
+## Experimental API/SDK
+
+#### Added
+
+- [Initial work to support the stable spec for the Metrics API and
+  SDK](https://github.com/open-telemetry/opentelemetry-erlang/pull/412)
+
+## SDK 1.0.5 - 2022-05-20
+
+### Fixed
+
+- [span processor config: don't override user settings with
+  defaults](https://github.com/open-telemetry/opentelemetry-erlang/pull/397)
+
+## SDK 1.0.4 - 2022-05-13
+
+### Fixed
+
+- [Setting the exporter with `traces_exporter` application environment variable
+  now properly overrides the configuration passed to the
+  processor](https://github.com/open-telemetry/opentelemetry-erlang/pull/393)
+
+## Exporter 1.0.4 - 2022-05-06
+
+- [fix bug where port 80 is used even for https](https://github.com/open-telemetry/opentelemetry-erlang/pull/389)
+
+## 1.0.3 - 2022-04-27
+
+### [API 1.0.3]
+
+- Doc fixes and improvements to `tracer.ex` and `otel_propagator_text_map.erl`
+
+### [SDK 1.0.3]
+
+- [Improve performance of Span set_status](https://github.com/open-telemetry/opentelemetry-erlang/pull/384)
+
+### [Exporter 1.0.3]
+
+- [Fix use of `otlp_endpoint` configuration from Elixir](https://github.com/open-telemetry/opentelemetry-erlang/pull/376)
+- [Remove the SDK application `opentelemetry` from the Exporter's runtime dependencies](https://github.com/open-telemetry/opentelemetry-erlang/pull/387)
+
+## 1.0.2 - 2022-02-22
+
+### [API 1.0.2]
+
+#### Added
+
+- [Docs for Erlang and Elixir macros added](https://github.com/open-telemetry/opentelemetry-erlang/pull/362)
+
+### [SDK 1.0.2]
+
+#### Added
+
+- [Simpler configuration of span processors](https://github.com/open-telemetry/opentelemetry-erlang/pull/357)
+
+#### Fixed
+
+- Span Status: Ignore status changes that don't follow the [define precedence in
+  the spec](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#set-status)
+
+### [Zipkin Exporter 1.0.0]
+
+#### Fixed
+
+- [Attribute values that are lists are converted to strings in Zipkin tags](https://github.com/open-telemetry/opentelemetry-erlang/pull/363)
+- [Status converted to Zipkin tags](https://github.com/open-telemetry/opentelemetry-erlang/pull/363)
+
+## 1.0.1 - 2022-02-03
+
+### [API]
+
+#### Fixed
+
+- [W3C Tracestate: Keep last value for duplicate key](https://github.com/open-telemetry/opentelemetry-erlang/pull/346)
+- [add report_cb to format log messages in composite propagator to have more
+  detailed logs](https://github.com/open-telemetry/opentelemetry-erlang/pull/355)
+- [Fix use of wrong timestamp format on events](https://github.com/open-telemetry/opentelemetry-erlang/pull/354)
+
+#### Fixed
+
+### [SDK]
+
+- [Fix use of wrong timestamp format on events](https://github.com/open-telemetry/opentelemetry-erlang/pull/354)
+
+### [Exporter]
+
+#### Fixed
+
+- [use the default port of the scheme (http/https) instead of default OTLP
+  port](https://github.com/open-telemetry/opentelemetry-erlang/pull/354)
+
+## 1.0.0 - 2022-01-03
+
+### [SDK]
+
+#### Fixed
+
+- [SDK will continue to try initializing exporter if it fails to resolve startup
+  ordering issues](https://github.com/open-telemetry/opentelemetry-erlang/pull/338)
+- [elixir span docs: fix reference to attributes
+  type](https://github.com/open-telemetry/opentelemetry-erlang/pull/336)
+  
+### [API]
+
+#### Fixed
+
+- [events: accept map for attributes on an event](https://github.com/open-telemetry/opentelemetry-erlang/pull/335)
+
+### [Exporter]
+
+#### Added
+
+- New `opentelemetry_exporter` application environment options:
+  - `otlp_protocol`: The transport protocol, supported values: `grpc` and `http_protobuf`. Defaults to `http_protobuf`.
+  - `otlp_traces_protocol`: The transport protocol to use for exporting traces, supported values: `grpc` and `http_protobuf`. Defaults to `http_protobuf`.
+  - `otlp_compression`: Compression type to use, supported values: `gzip`. Defaults to no compression.
+  - `otlp_traces_compression`: Compression type to use for exporting traces, supported values: `gzip`. Defaults to no compression.
+
+- New environment variable options:
+  - `OTEL_EXPORTER_OTLP_PROTOCOL`: The transport protocol to use, supported values: `grpc` and `http_protobuf`. Defaults to `http_protobuf`
+  - `OTEL_EXPORTER_OTLP_TRACES_PROTOCOL`: The transport protocol to use for exporting traces, supported values: `grpc` and `http_protobuf`. Defaults to `http_protobuf`.
+  - `OTEL_EXPORTER_OTLP_COMPRESSION`: Compression to use, supported value: gzip. Defaults to no compression.
+  - `OTEL_EXPORTER_OTLP_TRACES_COMPRESSION`: Compression to use when exporting traces, supported value: gzip. Defaults to no compression.
+
+## [API 1.0.0-rc.4.1] - 2021-12-28
+
+##### Fixed
+
+- `add_event` function and macros fixed to accept both a map of attributes or a
+  list.
+  
+## [API 1.0.0-rc.4] - 2021-12-25
+
+### Added
+
+- Looking up a Tracer for a module is now done by first looking up the
+  OTP Application name and then the Tracer using that name. This means all
+  Tracers share the same "namespace" again which saves space by not duplicating
+  the Tracer record for every module.
+- Configurable limits for the number of Attributes, Events and Links allowed in
+  a Span, an Event or a Link -- defaults to 128. The length of each Attribute's
+  value can also be limited but has a default of infinity.
+  
+  Environment variables added to configure the limits:
+  
+  - `OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT`: Limit on number of Attributes on a Span.
+  - `OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT`: Limit length of Attribute values.
+  - `OTEL_SPAN_EVENT_COUNT_LIMIT`: Limit number of Events on a Span.
+  - `OTEL_SPAN_LINK_COUNT_LIMIT`: Limit number of Links on a Span.
+  - `OTEL_EVENT_ATTRIBUTE_COUNT_LIMIT`: Limit on number of Attributes on an Event.
+  - `OTEL_LINK_ATTRIBUTE_COUNT_LIMIT`: Limit on number of Attributes on a Link.
+- Support for a Schema URL in a Resource and in the Instrumentation Library
+  information of a Tracer. For more information about Schema URLs see the
+  specification for [Resources](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/resource/sdk.md)
+  and [getting a Tracer](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md).
+- `OTEL_CREATE_APPLICATION_TRACERS` is a new environment variable,
+  `create_application_tracers` is the application environment key, for disabling
+  the automatic creation of Tracers for every Application at boot. The old keys,
+  `OTEL_REGISTER_LOADED_APPLICATIONS` and `register_loaded_applications`, will
+  continue to work as well.
+
+### Fixed
+
+- Attribute values now validate against what is allowable per the specification
+  rather than allowing anything the protobuf could encode. This may be breaking
+  to some users who were relying on the incorrect behavior, such as allowing
+  dictionaries or non-homogeneous lists/tuples. The one exception we have
+  kept is continuing to allow atoms in place of binaries for performance.
+- Attribute values of type list/tuple must be homogeneous.
+- Span start opts are now validated. Previously, opts underwent no validations.
+- Event and link attributes are now validated. Previously only span attributes
+  were validated.
+- Events accept atoms for the name again.
+
+### Removed
+
+- The `sampler` option to `start_span` and `with_span` was removed.
+- `register_tracer` has been removed and now `get_tracer` will cache the Tracer
+  after creation if needed.
+
+## [API 1.0.0-rc.3.2] - 2021-10-13
+
+##### Fixed
+
+- `otel_propagator_trace_context:extract/1` no longer crashes on `undefined`
+  header values
+  
+## [API 1.0.0-rc.3.1] - 2021-10-12
+
+##### Fixed
+
+- Properly published the package with Erlang and Elixir source. Package for
+  1.0.0-rc.3 was retired on Hex.pm
+
+## [API 1.0.0-rc.3] - 2021-10-12
+
+### Removed
+
+- Removed `opentelemetry:register_application_tracer`. Each application has a
+  Tracer registered for it automatically on boot. This can be disabled by
+  setting `opentelemetry` environment variable `register_loaded_applications` to
+  `false`.
+- Named Tracers registered with `opentelemetry:register_tracer` are now stored
+  separately from the mapping of Named Tracers created for each
+  application. Meaning if you have a module `mod_a` in application `app_a` with
+  application vsn `0.1.0` and also manually register a Tracer named `mod_a` with
+  version `1.1.1` then use of macros like `?with_span` will use the `app_a`
+  version `0.1.0` Named Tracer and manual use of a Named Tracer like:
+  
+  ```
+  Tracer = opentelemetry:get_tracer(mod_a),
+  otel_tracer:with_span(Tracer, span_name, #{}, fun() -> ... end),
+  ```
+  
+  will use Named Tracer `mod_a` with version `1.1.1`. In previous versions after
+  registering a Tracer named `mod_a` it would override the `mod_a` pointing to
+  the `app_a` Tracer.
+  
+  Additionally, manual registration of a Named Tracer with the name `app_a` will
+  not override the application registered Tracer of `app_a`.
+
+#### Context
+
+##### Added
+
+- B3 single header format support added
+
+##### Changed
+
+- Propagators must now be implementations of a propagator type's behaviour. At
+  this time only the `otel_propagator_text_map` behaviour exists. Callbacks for
+  inject and extract take an optional "set" and "get" function for working with
+  a carrier.
+- Configuration of propagators is now a list of atoms representing either the
+  name of a builtin propagator (at this time those are, `trace_context`, `b3`,
+  `b3multi` and `baggage`) or the name of a module implementing the
+  propagator's behaviour.
+  - Default configuration: `{text_map_propagators, [trace_context, baggage]}`
+- Injectors and extractors can be configured separately instead of using the
+  same list of propagators for both by configuring `text_map_injectors` and
+  `text_map_extractors`.
+  - For example you may want your service to support receiving `b3multi` headers
+    but have no need for it including `b3multi` headers when it is propagating to
+    other services:
+
+    ```
+    {text_map_injectors, [trace_context, baggage]},
+    {text_map_extractors, [b3multi, trace_context, baggage]}
+    ```
+    
+##### Fixed
+
+- `b3` propagator renamed `b3multi` to properly convey it is the version of the
+  B3 spec that creates multiple headers
+
+## [SDK - 1.0.0-rc.3] - 2021-10-12
+
+### Fixed
+
+- Memory leak fix: Non-recording Spans are no longer inserted into the ETS table tracking active span.
+- Ratio based root span sampling fixed, before it didn't take into account the
+  generated trace id.

CODEOWNERS

@@ -5,7 +5,7 @@
 #####################################################
 #
 # Learn about membership in OpenTelemetry community:
-#  https://github.com/open-telemetry/community/blob/master/community-membership.md
+#  https://github.com/open-telemetry/community/blob/main/community-membership.md
 # 
 #
 # Learn about CODEOWNERS file format: 

CONTRIBUTING.md

@@ -0,0 +1,114 @@
+# Development Setup Guide for Erlang Repository
+
+## Introduction
+Welcome to the Erlang Repository! 🎉
+
+This guide aims to assist contributors in setting up their local development environment. Feel free to suggest improvements or raise questions in your contributions.
+
+## Pre-requisites
+
+To work with this repository, you'll need the following tools and dependencies:
+
+- **Erlang/OTP Version** :
+  
+- We support the latest major release plus the prior two releases, aligning with Ericsson’s version support policy for Erlang itself.  
+- For a definitive list of supported versions, refer to the [erlang.yml](.github/workflows/erlang.yml) file in this repository.  
+
+If using the Elixir API:  
+
+* Elixir 1.14+
+
+* For a definitive list of supported versions, refer to the [elixir.yml](.github/workflows/elixir.yml) file in this repository.
+
+* Refer to the official [Erlang Installation Guide](https://www.erlang.org/downloads) for setting up Erlang.
+
+## Local Run/Build
+
+### Setting Up and Running the Project Locally
+
+To run the project locally, follow these steps:
+
+Start required services:
+
+```
+docker compose up -d
+```
+
+Set up Erlang/OTP and Rebar3 and Verify setup (Ensure you have the correct versions as specified in the prerequisites):
+
+Run the compilation step to check for errors:
+```
+rebar3 compile
+```
+
+## Testing
+
+To execute tests, use the following commands:
+
+### Unit Tests (EUnit):
+
+```
+rebar3 eunit
+```
+
+### Integration and Functional Tests (Common Test):
+
+```
+rebar3 ct
+```
+
+### Test results and logs can be viewed in a browser by opening:
+
+```
+build/test/logs/index.html
+
+```
+### Elixir Tests
+
+Elixir tests are run in two places:
+
+1. Inside apps/opentelemetry_api/:
+
+```
+mix test
+```
+
+2. At the top level:
+
+```
+mix test --no-start test/otel_tests.exs test/otel_metric_tests.exs
+```
+
+## Contribution Rules
+Please review the [OpenTelemetry Specification](https://opentelemetry.io/docs/specs/otel/) for details on coding standards, commit message formatting, and the contribution process.
+
+## Troubleshooting Guide
+
+### Debugging Common Failures
+
+* Test Failures: Check the test logs in _build/test/logs/.
+
+* Compilation Issues: Ensure correct OTP and Rebar3 versions are installed.
+
+* Dialyzer Warnings: Ensure rebar3 compile completes successfully.
+
+## Developer Setup and Language Servers
+
+For improved development experience, consider using the following Language Server Protocols (LSPs):
+
+* Erlang LSP: [Erlang Language Platform](https://whatsapp.github.io/erlang-language-platform/)
+
+* Installing it removes the need for an additional type-checking step:
+
+```
+elp eqwalize-all
+```
+
+* Install from: [Erlang Language Platform Releases](https://github.com/WhatsApp/erlang-language-platform/releases/)
+
+* Elixir LSP: [Elixir LS](https://github.com/elixir-lsp/elixir-ls)
+
+## Further Help
+
+* If you encounter any issues or have questions, feel free to open an issue or reach out to the maintainers.
+* Join our [slack](https://cloud-native.slack.com/archives/C01N75YMZCN) channel also for further help and discussions

README.md

@@ -1,44 +1,118 @@
-OpenTelemetry
-=====
+## OpenTelemetry Erlang/Elixir
 
-[![EEF Observability WG project](https://img.shields.io/badge/EEF-Observability-black)](https://github.com/erlef/eef-observability-wg)
-[![Hex.pm](https://img.shields.io/hexpm/v/opentelemetry)](https://hex.pm/packages/opentelemetry)
-![Build Status](https://github.com/open-telemetry/opentelemetry-erlang/workflows/Common%20Test/badge.svg)
+---
 
-OpenTelemetry stats collection and distributed tracing framework for Erlang.
+<p align="center">
+  <a href="https://hex.pm/packages/opentelemetry_api">
+    <img
+        src="https://img.shields.io/hexpm/v/opentelemetry_api?label=API&amp;style=for-the-badge"
+        alt="Hex.pm" />
+  </a>
+  <a href="https://hex.pm/packages/opentelemetry">
+    <img
+        src="https://img.shields.io/hexpm/v/opentelemetry?label=SDK&amp;style=for-the-badge"
+        alt="Hex.pm" />
+  </a>
+  <a href="https://hex.pm/packages/opentelemetry_exporter">
+    <img
+  src="https://img.shields.io/hexpm/v/opentelemetry_exporter?label=OTLP%20Exporter&amp;style=for-the-badge"
+  alt="Hex.pm" />
+  </a>
+  <a href="https://github.com/erlef/eef-observability-wg">
+    <img
+        src="https://img.shields.io/badge/EEF-Observability-black?style=for-the-badge"
+        alt="EEF Observability WG project" />
+  </a>
+</p>
 
-Requires OTP 21.3 or above.
+<p align="center">
+  <a href="https://github.com/open-telemetry/opentelemetry-erlang/actions">
+    <img src="https://img.shields.io/github/actions/workflow/status/open-telemetry/opentelemetry-erlang/erlang.yml?style=for-the-badge&branch=main" alt="GitHub Workflow Status" />
+  </a>
+  <img src="https://img.shields.io/codecov/c/github/open-telemetry/opentelemetry-erlang?style=for-the-badge" alt="Codecov" />
+</p>
+
+---
+
+[OpenTelemetry](https://opentelemetry.io/) distributed tracing framework for
+Erlang and Elixir.
+
+These applications implement version 1.8.0 of the [OpenTelemetry
+Specification](https://github.com/open-telemetry/opentelemetry-specification),
+see the [spec compliance
+matrix](https://github.com/open-telemetry/opentelemetry-specification/blob/main/spec-compliance-matrix.md)
+for a list of features supported.
+
+## Requirements
+
+- Erlang/OTP 23+ (With best effort for OTP 22 support)
+
+If using the Elixir API:
+
+- Elixir 1.13+
+
+## Contacting Us
+
+We hold weekly meetings. See details at [community page](https://github.com/open-telemetry/community#special-interest-groups).
+
+We use [GitHub
+Discussions](https://github.com/open-telemetry/opentelemetry-erlang/discussions)
+for support or general questions. Feel free to drop us a line.
+
+We are also present in the #otel-erlang-elixir channel in the [CNCF
+slack](https://slack.cncf.io/). Please join us for more informal discussions.
+
+You can also find us in the #opentelemetry channel on [Elixir
+Slack](https://elixir-slackin.herokuapp.com/).
+
+## Getting Started
+
+You can find a getting started guide on [opentelemetry.io](https://opentelemetry.io/docs/instrumentation/erlang/getting-started/).
+
+To start capturing distributed traces from your application it first needs to be
+instrumented. The easiest way to do this is by using an instrumentation library.
+There are a number of [officially supported instrumentation
+libraries](https://github.com/open-telemetry/opentelemetry-erlang-contrib) for
+popular Erlang and Elixir libraries and frameworks.
 
 ## Design
 
-The [OpenTelemetry specification](https://github.com/open-telemetry/opentelemetry-specification) defines a language library as having 2 components, the API and the SDK. The API must not only define the interfaces of any implementation in that language but also be able to function as a noop implementation of the tracer. The SDK is the default implementation of the API that must be optional.
+The [OpenTelemetry
+specification](https://github.com/open-telemetry/opentelemetry-specification)
+defines a language library as having two components, the API and the SDK. The API
+must not only define the interfaces of any implementation in that language but
+also be able to function as a noop implementation of the tracer. The SDK is the
+default implementation of the API that must be optional.
 
-If you are instrumenting a project your application should only depend on the [OpenTelemetry API](https://github.com/open-telemetry/opentelemetry-erlang-api/) application. 
+When instrumenting a project, your application should only depend on the
+[OpenTelemetry API](https://hex.pm/packages/opentelemetry_api) application,
+found in directory `apps/opentelemetry_api` of this repo. The API is published as
+the Hex package [opentelemetry_api](https://hex.pm/packages/opentelemetry_api).
 
-This repository is the Erlang's SDK implementation and should be included in the final release and configured to setup the sampler, span processors and span exporters.
+The SDK implementation, found under `apps/opentelemetry` and Hex package
+[opentelemetry](https://hex.pm/packages/opentelemetry), should be included in an
+OTP Release along with an exporter.
 
-## Using
+Example of Release configuration in `rebar.config`:
 
-In an Erlang project add `opentelemetry` as the first element of the release's applications:
+```erlang
+{relx, [{release, {my_instrumented_release, "0.1.0"},
+         [opentelemetry_exporter,
+	      {opentelemetry, temporary},
+          my_instrumented_app]},
 
-``` erlang
-{relx, [{release, {<name>, <version>}, 
-         [{opentelemetry, temporary},
-          <your applications>]},
-        ...]}.
+       ...]}.
 ```
 
-In the above example `opentelemetry` is set to `temporary` so that if the `opentelemetry` application crashes, or is shutdown, it does not terminate the other applications in the project. This is optional, the `opentelemetry` application purposely sticks to `permanent` for the processes started by the root supervisor to leave it up to the end user whether they want the crash or shutdown or `opentelemetry` to be ignored or cause the shutdown of the rest of the applications in the release.
+Example configuration for [mix's Release
+task](https://hexdocs.pm/mix/Mix.Tasks.Release.html):
 
-Doing the same for an Elixir project would be:
-
-``` elixir
+```elixir
 def project do
   [
-    ...
     releases: [
-      <name>: [
-        applications: [opentelemetry: :temporary]
+      my_instrumented_release: [
+        applications: [opentelemetry_exporter: :permanent, opentelemetry: :temporary]
       ],
 
       ...
@@ -47,45 +121,109 @@ def project do
 end
 ```
 
-## Benchmarks
+Note that you also need to add `opentelemetry_exporter` before your other `opentelemetry` dependencies in `mix.exs`,
+so that it starts before `opentelemetry` does.
 
-Running benchmarks is done with [benchee](https://github.com/bencheeorg/benchee). Benchmark functions are in modules under `samples/`. To run them open a rebar3 shell in the `bench` profile:
+In the above example `opentelemetry_exporter` is listed first, ensuring that all of its
+dependencies are booted before `opentelemetry` attempts to start the
+exporter. `opentelemetry` is set to `temporary` so that if the `opentelemetry`
+application crashes, or is shutdown, it does not terminate the other
+applications in the project -- `opentelemetry_exporter` does not need to be
+`temporary` because it does not have a startup and supervision tree. This is
+optional; the `opentelemetry` application purposely sticks to `permanent` for
+the processes started by the root supervisor to leave it up to the end user
+whether they want the crash or shutdown or `opentelemetry` to be ignored or
+cause the shutdown of the rest of the applications in the release.
 
-``` shell
-$ rebar3 as bench compile
+## Git Dependencies
 
-> ot_benchmarks:run().
+While it is recommended to use the Hex packages for the
+[API](https://hex.pm/packages/opentelemetry_api),
+[SDK](https://hex.pm/packages/opentelemetry) and [OTLP
+exporter](https://hex.pm/packages/opentelemetry_exporter), there are times
+depending on the git repo is necessary. Because the OpenTelemetry OTP
+Applications are kept in a single repository, under the directory `apps`, either
+[rebar3's](https://rebar3.org) `git_subdir` (rebar 3.14 or above is required) or
+[mix's](https://elixir-lang.org/getting-started/mix-otp/introduction-to-mix.html)
+`sparse` feature must be used when using these as Git dependencies in a project. The
+blocks below show how the git repo for the API and/or SDK
+Applications can be used in rebar3 and mix.
+
+```erlang
+{opentelemetry_api, {git_subdir, "http://github.com/open-telemetry/opentelemetry-erlang", {branch, "main"}, "apps/opentelemetry_api"}},
+{opentelemetry, {git_subdir, "http://github.com/open-telemetry/opentelemetry-erlang", {branch, "main"}, "apps/opentelemetry"}},
+{opentelemetry_exporter, {git_subdir, "http://github.com/open-telemetry/opentelemetry-erlang", {branch, "main"}, "apps/opentelemetry_exporter"}}
 ```
 
-If an Elixir script is wanted for the benchmarks they could be run like:
+```elixir
+{:opentelemetry_api, github: "open-telemetry/opentelemetry-erlang", sparse:
+"apps/opentelemetry_api", override: true},
+{:opentelemetry, github: "open-telemetry/opentelemetry-erlang", sparse:
+"apps/opentelemetry", override: true},
+{:opentelemetry_exporter, github: "open-telemetry/opentelemetry-erlang", sparse: "apps/opentelemetry_exporter", override: true}
+```
 
-``` shell
-$ ERL_LIBS=_build/bench/lib/ mix run --no-mix-exs samples/run.exs
+The `override: true` is required because the SDK Application, `opentelemetry`, has
+the API in its `deps` list of its `rebar.config` as a Hex dependency and this will
+clash when `mix` tries to resolve the dependencies and fail without the
+override. `override: true` is also used on the SDK because the
+`opentelemetry_exporter` application depends on it and the API as Hex deps so if
+it is included the override is necessary.
+
+## Benchmarks
+
+Running benchmarks is done with [benchee](https://github.com/bencheeorg/benchee). Benchmark functions are stored in modules, under `samples/`. To run them, open a rebar3 shell in the `bench` profile:
+
+```shell
+$ rebar3 as bench shell
+
+> otel_benchmarks:run().
+```
+
+If an Elixir script is wanted for the benchmarks they could be run (after
+running `rebar3 as bench compile`) as follows:
+
+```shell
+$ ERL_AFLAGS="-pa ./_build/bench/extras/samples/" ERL_LIBS=_build/bench/lib/ mix run --no-mix-exs samples/run.exs
 ```
 
 ## W3C Trace Context Interop Tests
 
 Start the interop web server in a shell:
 
-``` shell
+```shell
 $ rebar3 as interop shell
 
-> w3c_trace_context_interop:run().
+> w3c_trace_context_interop:start().
 ```
 
 Then, clone the [W3C Trace Context repo](https://github.com/w3c/trace-context) and run the tests:
 
-``` shell
+```shell
 $ cd test
 $ python3 test.py http://127.0.0.1:5000/test
 ```
 
 ## Contributing
 
-Approvers:
-- [Fred Hebert](https://github.com/ferd), Postmates Inc.
+### Maintainers
 
-Maintainers:
-- [Łukasz Jan Niemier](https://github.com/hauleth),
-- [Ilya Khaprov](https://github.com/deadtrickster), KOBIL Systems
-- [Tristan Sloughter](https://github.com/tsloughter), Postmates Inc.
+- [Bryan Naegele](https://github.com/bryannaegele), [Simplebet](https://simplebet.io/)
+- [Iliia Khaprov](https://github.com/deadtrickster), [VMWare](https://www.vmware.com/)
+- [Łukasz Jan Niemier](https://github.com/hauleth)
+- [Tristan Sloughter](https://github.com/tsloughter), [Splunk](https://www.splunk.com/en_us/observability/apm-application-performance-monitoring.html)
+
+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
+
+- [Fred Hebert](https://github.com/ferd), [Honeycomb](https://www.honeycomb.io/)
+- [Greg Mefford](https://github.com/GregMefford), [STORD](https://www.stord.com/)
+
+For more information about the approver role, see the [community repository](https://github.com/open-telemetry/community/blob/main/guides/contributor/membership.md#approver).
+
+_Find more about the maintainer role in [community repository](https://github.com/open-telemetry/community/blob/master/community-membership.md#maintainer)._
+
+### Thanks to all the people who have contributed
+
+[![contributors](https://contributors-img.web.app/image?repo=open-telemetry/opentelemetry-erlang)](https://github.com/open-telemetry/opentelemetry-erlang/graphs/contributors)

VERSIONING.md

@@ -0,0 +1,133 @@
+# Versioning and Releasing
+
+[OTP] Applications and the [OpenTelemetry Spec] itself use [semver v2].
+
+In this document, references to OTP concepts are distinguished by capitalizing the word
+(for example Application and Release) while the generic term (like release) is
+lowercase.
+
+[OTP]: http://erlang.org/doc/system_architecture_intro/sys_arch_intro.html
+[OpenTelemetry Spec]: https://github.com/open-telemetry/opentelemetry-specification
+[semver v2]: https://semver.org/spec/v2.0.0.html 
+
+## Module Prefix
+
+The module prefix for all modules in any of these core Applications is
+`otel`. This means modules can move between Applications without their name
+changing. Because of Erlang's flat namespace, there is no code for a user to change
+when an API graduates from experimental to stable, if the user was
+using the latest version of the experimental API.
+
+This also allows flexibility for modules that might be in the SDK but are found
+to be better placed in the API, or vice versa. This has happened a few times in
+the pre-1.0 world as functionality was floating from SDK to API at times.
+
+## OTP Applications
+
+### Experimental API (`opentelemetry_api_experimental`)
+
+The experimental package is where any API that is not stable when 1.0 is
+released [MUST] live. At this time (prior to 1.0) that means Metrics and Logging.
+
+This package will always be 0.x because it is never stable and modules will be
+removed when they are moved to the stable API package. Breaking changes,
+as well as non-trivial additions, to the experimental API will only result in a
+minor version bump.
+[MUST]: https://tools.ietf.org/html/rfc2119#section-1
+
+### API (`opentelemetry_api`)
+
+The API package must provide semver-defined backwards-compatibility
+once a major version (e.g. 1.0.0) is released. When a particular part of the API
+becomes stable, its modules are moved from `opentelemetry_api_experimental` to
+`opentelemetry_api` and a new minor release of both is published.
+
+At the release of version 1.0, the following signal APIs will be included
+in `opentelemetry_api`:
+
+* Tracing
+* Baggage
+* Context
+
+### Experimental SDK (`opentelemetry_sdk_experimental`)
+
+The experimental SDK contains the implementations for the APIs in the
+experimental API of the same minor version. For example, there may be
+multiple patch-level releases (`v0.3.2`, `v0.3.3`) of the experimental
+SDK for each minor version of the experimental API (`v0.3.0`).
+Any setup for signals contained in the experimental SDK must be done on startup
+of the experimental SDK. For example, setting the default Meter would be done
+in `start/2` of `opentelemetry_sdk_experimental`.
+
+### SDK (`opentelemetry`)
+
+Functionality is implemented in this Application and the API is dynamically
+configured to use a particular SDK -- at this time there is only 1 SDK
+implementation, the default implementation.
+
+A goal is that the latest SDK can always be used with any version of the API, so
+that a user can always pull the latest implementation into their final Release
+to run with any API versions that were used in instrumented Applications within the
+Release.
+
+### OTLP Exporter (`opentelemetry_exporter`)
+
+Exporter implementations are tied to the SDK's public API.
+
+## Releases
+
+### Experimental API
+
+As noted in the previous section, `opentelemetry_api_experimental` is versioned
+separately from the rest and will always remain 0.x.
+
+### API
+
+Additions to the API are released with minor version bumps.
+
+### Experimental SDK
+
+As noted in the previous section, `opentelemetry_sdk_experimental` is versioned
+separately from the rest, but in lockstep with `opentelemetry_api_experimental`,
+and will always remain 0.x.
+
+### SDK
+
+Additions to the SDK are released with minor version bumps.
+
+## Deprecation
+
+Code is only marked as deprecated when the replacement is stable.
+
+Unlikely example: There is a Tracing v2 spec defined. The module will be named
+`otel_trace2` and the functions in `otel_trace` marked as deprecated.
+
+Deprecated functions must be marked with `-deprecated` in the module so that
+`xref` provides a warning about usage to the user.
+
+## Removal
+
+A major version bump is required to remove a signal or module.
+
+In the unlikely example mentioned in the Deprecation section, this step would mean removal of the
+original module (`otel_trace`) and a major version bump release.
+
+## Examples
+
+Purely for illustration purposes, not intended to represent actual releases:
+
+- v1.0.0 release:
+   - `opentelemetry_api` 1.0.0
+     - Contains APIs for tracing, baggage, propagators
+   - `opentelemetry_api_experimental` 0.2.0
+     - Contains APIs for metrics
+   - `opentelemetry_sdk` 1.0.0
+   - `opentelemetry_sdk_experimental` 0.2.0
+- v1.15.0 release (with metrics)
+   - `opentelemetry_api` 1.15.0
+     - Contains APIs for tracing, baggage, propagators, metrics
+   - `opentelemetry_api_experimental` 0.42.0
+     - No longer contains APIs for metrics
+   - `opentelemetry_sdk` 1.15.0
+   - `opentelemetry_sdk_experimental` 0.42.0
+   

apps/opentelemetry/LICENSE

@@ -0,0 +1,201 @@
+                                 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 [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.
+   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.

apps/opentelemetry/README.md

@@ -0,0 +1,245 @@
+# Erlang/Elixir OpenTelemetry SDK
+
+[![Hex.pm](https://img.shields.io/hexpm/v/opentelemetry?label=SDK&style=for-the-badge)](https://hex.pm/packages/opentelemetry)
+[![EEF Observability WG
+project](https://img.shields.io/badge/EEF-Observability-black?style=for-the-badge)](https://github.com/erlef/eef-observability-wg)
+[![GitHub Workflow Status](https://img.shields.io/github/workflow/status/open-telemetry/opentelemetry-erlang/Erlang?style=for-the-badge)](https://github.com/open-telemetry/opentelemetry-erlang/actions)
+
+The [SDK](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/sdk.md) is an implementation of the [OpenTelemetry
+API](https://hex.pm/packages/opentelemetry_api) and should be included in your
+final deployable artifact (usually an OTP Release).
+
+## Configuration
+
+The SDK starts up its supervision tree on boot, so initial configuration must be
+done through the Application or [OS environment
+variables](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/sdk-configuration.md).
+The following example configurations show configuring the SDK to use the batch
+span processor which then exports through the [OpenTelemetry
+Protocol](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/protocol/otlp.md)
+over HTTP to `http://localhost:4318`, encoding the Spans with protobufs.
+
+```erlang
+[
+ {opentelemetry,
+  [{span_processor, batch},
+   {traces_exporter, otlp}]},
+
+ {opentelemetry_exporter, 
+  [{otlp_protocol, http_protobuf},
+   {otlp_endpoint, "http://localhost:4318"}]}]}
+].
+```
+
+```elixir
+config :opentelemetry, 
+  span_processor: :batch,
+  traces_exporter: :otlp
+
+config :opentelemetry_exporter,
+  otlp_protocol: :http_protobuf,
+  otlp_endpoint: "http://localhost:4318"
+```
+
+If your exporting pipeline is not ready, you may disable trace exporting to prevent memory overflows.
+This can be done by setting `traces_exporter`'s value to the atom `none`.
+
+```erlang
+[
+ {opentelemetry,
+  [{traces_exporter, none}]}
+].
+```
+
+```elixir
+config :opentelemetry, traces_exporter: :none
+```
+
+The following sections detail the available SDK options and how to configure
+them through either the OS or Application environment.
+
+### Automatically Created Tracers
+
+Spans are created by Tracers and each Tracer is associated with a [name and
+version](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#get-a-tracer).
+The name and version can be anything, but the macros provided by the API will always use
+a Tracer with name/version of the OTP Application the macro is used in. To
+facilitate this a Tracer is created for each available Application when the SDK
+boots. It relies on mapping modules to Applications, so if there is a huge
+number of modules in a Release the time to create all these Tracers can become
+more than you want to wait on boot.
+
+| OS                              | Application                | Default | Type    |
+|:--------------------------------|:---------------------------|:--------|:--------|
+| OTEL_CREATE_APPLICATION_TRACERS | create_application_tracers | true    | boolean |
+
+Disabling the creation of Tracers at start-up means when the macros are used to
+start Spans the name and version of the Tracer creating those Spans will be
+undefined, but everything will continue to work as before.
+
+### Samplers
+
+Sampling is a mechanism to control the number of traces collected and sent to the backend. A [Sampler](https://opentelemetry.io/docs/reference/specification/trace/sdk/#sampler) is responsible for making a decision on whether to sample a trace or not.
+
+This decision happens when starting a span. For this reason, only the initial attributes passed to `with_span` or `start_span` are available to the Sampler. Attributes added within `with_span` or between `start_span` and `end_span` calls don't affect the outcome as the decision to sample or not has already been made.
+
+There are several [built-in samplers](https://opentelemetry.io/docs/reference/specification/trace/sdk/#built-in-samplers) available, and it's possible to create custom samplers.
+
+| OS                             | Application              | Default   | Type    |
+|:-------------------------------|:-------------------------|:----------|:--------|
+| OTEL_TRACES_SAMPLER             | sampler                 | parentbased_always_on | always_on, always_off, traceidratio, parentbased_always_on, parentbased_always_off, parentbased_traceidratio |
+| OTEL_TRACES_SAMPLER_ARG         | sampler                 |          | String. Each Sampler type defines its own expected input, if any.|
+
+
+#### Custom Sampler
+
+To create a custom sampler, implement a module with behaviour `otel_sampler`, and then install your custom sampler when configuring the `opentelemetry` application
+
+```elixir
+defmodule MySampler do
+  require OpenTelemetry.Tracer, as: Tracer
+  @behaviour :otel_sampler
+
+  @impl :otel_sampler
+  def setup(_sampler_opts) do
+    []
+  end
+
+  @impl :otel_sampler
+  def description(_sampler_config) do
+    "MySampler"
+  end
+
+  @impl :otel_sampler
+  def should_sample(
+        ctx,
+        _trace_id,
+        _links,
+        _span_name,
+        _span_kind,
+        _attributes,
+        _sampler_config
+  ) do
+    sample_decision = ... # custom logic to determine whether to sample or not
+
+    tracestate = Tracer.current_span_ctx(ctx) |> OpenTelemetry.Span.tracestate()
+
+    case sample_decision do
+      true -> {:record_and_sample, [], tracestate}
+      false -> {:drop, [], tracestate}
+    end
+  end
+end
+```
+
+```elixir
+config :opentelemetry,
+  sampler: {:parent_based, %{root: {MySampler, %{my_config_arg: 1}}}},
+  span_processor: :batch,
+  traces_exporter: :otlp
+```
+
+### Propagators
+
+Propagators define how to inject and extract context in requests to or from
+external services. A propagator that works on key/value pairs of text, like HTTP
+headers, can be any module that implements the `otel_propagator_text_map`
+behaviour. There are 4 built-in propagators that are part of the API:
+
+- [tracecontext](https://w3c.github.io/trace-context/): Encodes the Trace
+  context as headers `traceparent` and `tracestate`.
+- [baggage](https://w3c.github.io/baggage/): Encodes
+  [baggage](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/baggage/api.md)
+  elements as a comma delimited list under header key `baggage`.
+- [b3multi](https://github.com/openzipkin/b3-propagation#multiple-headers): The
+  propagation format from [Zipkin](https://zipkin.io/) that breaks the context across multiple
+  headers, `X-B3-TraceId`, `X-B3-SpanId` and `X-B3-Sampled`.
+- [b3](https://github.com/openzipkin/b3-propagation#single-header):  The
+  propagation format from Zipkin that encodes to a single header `b3`.
+
+| OS               | Application          | Default                | Type                                                             |
+|:-----------------|:---------------------|:-----------------------|:-----------------------------------------------------------------|
+| OTEL_PROPAGATORS | text_map_propagators | [tracecontext,baggage] | List of propagators (`tracecontext`, `baggage`, `b3multi`, `b3`) |
+
+
+### Batch Span Processor
+
+[Span
+processors](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/sdk.md#span-processor)
+are invoked when a Span is started and when it ends. The default processor is
+the batch processor (`otel_batch_processor`) -- also available is the simple
+processor (`otel_simple_processor`) which blocks on every finished Span until it
+is exported.
+
+The batch processor waits `bsp_scheduled_delay_ms` milliseconds or until the buffer of
+finished Spans reaches `bsp_max_queue_size` and then exports the spans together.
+The export is canceled if it takes longer than `bsp_exporting_timeout_ms`.
+
+| OS                             | Application              | Default | Type    |
+|:-------------------------------|:-------------------------|:--------|:--------|
+| OTEL_BSP_SCHEDULE_DELAY_MILLIS | bsp_scheduled_delay_ms   | 5000    | integer |
+| OTEL_BSP_EXPORT_TIMEOUT_MILLIS | bsp_exporting_timeout_ms | 30000   | integer |
+| OTEL_BSP_MAX_QUEUE_SIZE        | bsp_max_queue_size       | 2048    | integer |
+
+### Resource Detectors
+
+[Resources](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/overview.md#resources)
+capture information about the environment the program is running in. For
+example, a process producing telemetry that is running in a container on
+Kubernetes has a Pod name, it is in a namespace and possibly is part of a
+Deployment which also has a name. All three of these attributes can be included
+in the Resource.
+
+| OS                             | Application               | Default                                        | Type            |
+|:-------------------------------|:--------------------------|:-----------------------------------------------|:----------------|
+| OTEL_RESOURCE_DETECTORS        | resource_detectors        | [otel_resource_env_var, otel_resource_app_env] | list of modules |
+| OTEL_RESOURCE_DETECTOR_TIMEOUT | resource_detector_timeout | 5000                                           | integer         |
+    
+The default detectors read resource attributes from the OS environment variable
+`OTEL_RESOURCE_ATTRIBUTES` and Application environment variable `resource`.
+
+### Span Limits
+
+The number of Attributes, Events and Links on a Span are limited, as well as the
+length of an Attribute's value. When the limit is reached any additional
+Attributes, Events or Links are dropped and Attribute values larger than the
+length limit are truncated.
+
+| OS                                     | Application                  | Default  | Type                    |
+|:---------------------------------------|:-----------------------------|:---------|:------------------------|
+| OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT        | attribute_count_limit        | 128      | integer                 |
+| OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT | attribute_value_length_limit | infinity | integer \| infinity     |
+| OTEL_SPAN_EVENT_COUNT_LIMIT            | event_count_limit            | 128      | integer                 |
+| OTEL_SPAN_LINK_COUNT_LIMIT             | link_count_limit             | 128      | integer                 |
+| OTEL_EVENT_ATTRIBUTE_COUNT_LIMIT       | attribute_per_event_limit    | 128      | integer                 |
+| OTEL_LINK_ATTRIBUTE_COUNT_LIMIT        | attribute_per_link_limit     | 128      | integer                 |
+
+Read more in the specification about [Span
+limits](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/sdk.md#span-limits)
+and [Attribute
+limits](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/common/common.md#attribute-limits).
+
+### Span Sweeper
+
+Because of Erlang's "Let It Crash" philosophy it is possible that at some point
+a Span will never have `end_span` called. To handle these cases the SDK includes
+a process that will periodically check the active Span table for Spans that are
+older than the `span_ttl` and will drop or end the Span depending on the
+configured `strategy`. The `failed_attribute_and_end_span` strategy will add the
+attribute `finished_by_sweeper` with value `true` to the Span before calling
+`end_span`.
+
+The sweeper's configuration is a map under environment key `sweeper`.
+
+| OS                             | Application  | Default | Type                                                        |
+|:-------------------------------|:-------------|:---------|:-----------------------------------------------------------|
+| OTEL_SPAN_SWEEPER_INTERVAL     | interval     | 600000   | integer \| infinity                                        |
+| OTEL_SPAN_SWEEPER_STRATEGY     | strategy     | drop     | drop \| end_span \| failed_attribute_and_end_span \| fun/1 |
+| OTEL_SPAN_SWEEPER_SPAN_TTL     | span_ttl     | 1800000  | integer \| infinity                                        |
+| OTEL_SPAN_SWEEPER_STORAGE_SIZE | storage_size | infinity | integer \| infinity                                        |
+
+## Contributing
+
+Read OpenTelemetry project [contributing
+guide](https://github.com/open-telemetry/community/blob/main/CONTRIBUTING.md)
+for general information about the project.

apps/opentelemetry/docs.config

@@ -0,0 +1,25 @@
+{source_url, <<"https://github.com/open-telemetry/opentelemetry-erlang">>}.
+{extras, [<<"apps/opentelemetry/README.md">>, <<"apps/opentelemetry/LICENSE">>, <<"VERSIONING.md">>]}.
+{main, <<"readme">>}.
+{proglang, erlang}.
+{groups_for_modules, [
+    {'Span', [otel_span_ets,
+              otel_span_limits,
+              otel_span_sweeper]},
+    {'Span Processing', [otel_span_processor,
+                         otel_simple_processor,
+                         otel_batch_processor]},
+    {'Exporter', [otel_exporter,
+                  otel_exporter_pid,
+                  otel_exporter_stdout,
+                  otel_exporter_tab]},
+    {'Resource', [otel_resource,
+                  otel_resource_detector,
+                  otel_resource_app_env,
+                  otel_resource_env_var]},
+    {'Sampling', [otel_sampler,
+                  otel_sampler_always_on,
+                  otel_sampler_always_off,
+                  otel_sampler_parent_based,
+                  otel_sampler_trace_id_ratio_based]}
+]}.

apps/opentelemetry/include/otel_sampler.hrl

@@ -16,6 +16,6 @@
 %% @end
 %%%-------------------------------------------------------------------------
 
--define(NOT_RECORD, not_record).
--define(RECORD, record).
--define(RECORD_AND_SAMPLED, record_and_sampled).
+-define(DROP, drop).
+-define(RECORD_ONLY, record_only).
+-define(RECORD_AND_SAMPLE, record_and_sample).

apps/opentelemetry/include/otel_span.hrl

@@ -0,0 +1,85 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @doc
+%% @end
+%%%-------------------------------------------------------------------------
+
+-record(span, {
+          %% 128 bit int trace id
+          trace_id                :: opentelemetry:trace_id() | undefined | '_',
+
+          %% 64 bit int span id
+          span_id                 :: opentelemetry:span_id() | undefined | '$1',
+
+          tracestate = []         :: opentelemetry:tracestate() | '_',
+
+          %% 64 bit int parent span
+          parent_span_id          :: opentelemetry:span_id() | undefined | '_',
+
+          %% name of the span
+          name                    :: unicode:unicode_binary() | atom() | '_',
+
+          %% Distinguishes between spans generated in a particular context. For example,
+          %% two spans with the same name may be distinguished using `client` (caller)
+          %% and `server` (callee) to identify queueing latency associated with the span.status
+          kind                    :: opentelemetry:span_kind() | undefined | '_',
+
+          start_time              :: opentelemetry:timestamp() | '$2',
+          end_time                :: opentelemetry:timestamp() | undefined | '_',
+
+          %% A set of attributes on the span.
+          attributes              :: otel_attributes:t() | undefined | '_',
+
+          %% List of time-stamped events in the Span.
+          events                  :: otel_events:t() | '_',
+
+          %% links to spans in other traces
+          links                   :: otel_links:t() | '_',
+
+          %% An optional final status for this span.
+          status                  :: opentelemetry:status() | undefined | '_',
+
+          %% 8-bit integer, lowest bit is if it is sampled
+          trace_flags = 1         :: integer() | undefined | '_',
+
+          %% this field is not propagated and is only here as an implementation optimization
+          %% If true updates like adding events are done on the span. The same as if the
+          %% trace flags lowest bit is 1 but simply not propagated.
+          is_recording            :: boolean() | undefined | '_',
+
+          instrumentation_scope :: opentelemetry:instrumentation_scope() | undefined | '_'
+         }).
+
+-record(span_limits, {
+          attribute_count_limit = 128             :: integer(), %% Maximum allowed attribute count per span;
+          attribute_value_length_limit = infinity :: integer() | infinity,  %% Maximum allowed attribute value length
+          event_count_limit = 128                 :: integer(), %% Maximum allowed span event count
+          link_count_limit = 128                  :: integer(), %% Maximum allowed span link count
+          attribute_per_event_limit = 128         :: integer(), %% Maximum allowed attribute per span event count
+          attribute_per_link_limit = 128          :: integer() %% Maximum allowed attribute per span link count
+       }).
+
+-record(link, {
+          trace_id   :: opentelemetry:trace_id(),
+          span_id    :: opentelemetry:span_id(),
+          attributes :: otel_attributes:t(),
+          tracestate :: opentelemetry:tracestate()
+         }).
+
+-record(event, {
+          system_time_native :: integer(),
+          name               :: unicode:unicode_binary() | atom(),
+          attributes         :: otel_attributes:t()
+         }).

apps/opentelemetry/rebar.config

@@ -0,0 +1,11 @@
+{erl_opts, [debug_info]}.
+{deps, [{opentelemetry_api, "~> 1.4.0"}]}.
+
+{profiles,
+ [{docs, [{edoc_opts,
+           [
+            {doclet, edoc_doclet_chunks},
+            {layout, edoc_layout_chunks},
+            {preprocess, true},
+            {dir, "_build/default/lib/opentelemetry/doc"},
+            {subpackages, true}]}]}]}.

apps/opentelemetry/src/opentelemetry.app.src

@@ -0,0 +1,21 @@
+{application, opentelemetry,
+ [{description, "Implementation of stable OpenTelemetry signals"},
+  {vsn, "1.5.1"},
+  {registered, [
+                %% global tracer provider supervisor for use by the API
+                otel_tracer_provider_sup
+               ]},
+  {mod, {opentelemetry_app, []}},
+  {applications,
+   [kernel,
+    stdlib,
+    opentelemetry_api
+   ]},
+  {exclude_paths, ["rebar.lock"]},
+  {env, []},
+  {modules, []},
+
+  {doc, "doc"},
+  {licenses, ["Apache-2.0"]},
+  {links, [{"GitHub", "https://github.com/open-telemetry/opentelemetry-erlang"}]}
+ ]}.

apps/opentelemetry/src/opentelemetry_app.erl

@@ -0,0 +1,70 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @private
+%%%-------------------------------------------------------------------------
+-module(opentelemetry_app).
+
+-behaviour(application).
+
+-export([start/2,
+         stop/1]).
+
+-include_lib("opentelemetry_api/include/opentelemetry.hrl").
+
+start(_StartType, _StartArgs) ->
+    Config = otel_configuration:merge_with_os(
+               application:get_all_env(opentelemetry)),
+
+    %% set the global propagators for HTTP based on the application env
+    %% these get set even if the SDK is disabled
+    setup_text_map_propagators(Config),
+
+    SupResult = opentelemetry_sup:start_link(Config),
+
+    case Config of
+        #{sdk_disabled := true} ->
+            %% skip the rest if the SDK is disabled
+            SupResult;
+        _ ->
+            %% set global span limits record based on configuration
+            otel_span_limits:set(Config),
+
+            Resource = otel_resource_detector:get_resource(),
+            _ = otel_tracer_provider_sup:start(?GLOBAL_TRACER_PROVIDER_NAME, Resource, Config),
+
+            %% must be done after the supervisor starts so that otel_tracer_server is running
+            %% TODO: make this work with release upgrades. Currently if an application's version
+            %% changes the version in the tracer will not be updated.
+            create_loaded_application_tracers(Config),
+
+            SupResult
+    end.
+
+stop(_State) ->
+    ok.
+
+%% internal functions
+
+setup_text_map_propagators(#{text_map_propagators := List}) ->
+    CompositePropagator = otel_propagator_text_map_composite:create(List),
+    opentelemetry:set_text_map_propagator(CompositePropagator).
+
+create_loaded_application_tracers(#{create_application_tracers := true}) ->
+    %% TODO: filter out OTP apps that will not have any instrumentation
+    LoadedApplications = application:loaded_applications(),
+    opentelemetry:create_application_tracers(LoadedApplications),
+    ok;
+create_loaded_application_tracers(_) ->
+    ok.

apps/opentelemetry/src/opentelemetry_sup.erl

@@ -0,0 +1,64 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @private
+%%%-------------------------------------------------------------------------
+-module(opentelemetry_sup).
+
+-behaviour(supervisor).
+
+-export([start_link/1]).
+
+-export([init/1]).
+
+-define(SERVER, ?MODULE).
+
+-include_lib("opentelemetry_api/include/opentelemetry.hrl").
+
+start_link(Opts) ->
+    supervisor:start_link({local, ?SERVER}, ?MODULE, [Opts]).
+
+init([#{sdk_disabled := true}]) ->
+    {ok, {#{}, []}};
+init([Opts]) ->
+    SupFlags = #{strategy => one_for_one,
+                 intensity => 1,
+                 period => 5},
+
+    Detectors =  #{id => otel_resource_detector,
+                   start => {otel_resource_detector, start_link, [Opts]},
+                   restart => permanent,
+                   shutdown => 5000,
+                   type => worker,
+                   modules => [otel_resource_detector]},
+
+    TracerProviderSup = #{id => otel_tracer_provider_sup,
+                          start => {otel_tracer_provider_sup, start_link, []},
+                          restart => permanent,
+                          shutdown => 5000,
+                          type => supervisor,
+                          modules => [otel_tracer_provider_sup]},
+
+    SpanSup = #{id => otel_span_sup,
+                start => {otel_span_sup, start_link, [Opts]},
+                type => supervisor,
+                restart => permanent,
+                shutdown => infinity,
+                modules => [otel_span_sup]},
+
+    %% `SpanSup' should be the last to shutdown so the ETS table lives until the end
+    %% the `TracerServer' process
+    ChildSpecs = [SpanSup, Detectors, TracerProviderSup],
+
+    {ok, {SupFlags, ChildSpecs}}.

apps/opentelemetry/src/otel_batch_processor.erl

@@ -0,0 +1,465 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @doc The Batch Span Processor implements the {@link otel_span_processor}
+%% behaviour.
+%% 
+%% It stores finished Spans in a ETS table buffer and exports
+%% them on an interval or when the table reaches a maximum size.
+%%
+%% You can configure these timeouts:
+%%
+%% <ul>
+%% <li>`exporting_timeout_ms': how long to let the exports run before killing.</li>
+%% <li>`check_table_size_ms': timeout to check the size of the export table.</li>
+%% <li>`scheduled_delay_ms': how often to trigger running the exporters.</li>
+%% </ul>
+%%
+%% The size limit of the current table where finished spans are stored can
+%% be configured with the `max_queue_size' option.
+%% @end
+%%%-----------------------------------------------------------------------
+-module(otel_batch_processor).
+
+-behaviour(gen_statem).
+-behaviour(otel_span_processor).
+
+-export([start_link/1,
+         on_start/3,
+         on_end/2,
+         force_flush/1,
+         report_cb/1,
+
+         %% deprecated
+         set_exporter/1,
+         set_exporter/2,
+         set_exporter/3]).
+
+-export([init/1,
+         callback_mode/0,
+         idle/3,
+         exporting/3,
+         terminate/3]).
+
+%% uncomment when OTP-23 becomes the minimum required version
+%% -deprecated({set_exporter, 1, "set through the otel_tracer_provider instead"}).
+%% -deprecated({set_exporter, 2, "set through the otel_tracer_provider instead"}).
+%% -deprecated({set_exporter, 3, "set through the otel_tracer_provider instead"}).
+
+-include_lib("opentelemetry_api/include/opentelemetry.hrl").
+-include_lib("kernel/include/logger.hrl").
+-include("otel_span.hrl").
+
+-record(data, {exporter             :: {module(), term()} | undefined,
+               exporter_config      :: {module(), term()} | undefined | none,
+               resource             :: otel_resource:t() | undefined,
+               handed_off_table     :: atom() | undefined,
+               runner_pid           :: pid() | undefined,
+               max_queue_size       :: integer() | infinity,
+               exporting_timeout_ms :: integer(),
+               check_table_size_ms  :: integer() | infinity,
+               scheduled_delay_ms   :: integer(),
+               table_1              :: atom(),
+               table_2              :: atom(),
+               reg_name             :: atom()}).
+
+-define(CURRENT_TABLES_KEY(Name), {?MODULE, current_table, Name}).
+
+%% create unique table names to support multiple batch processors at once
+-define(TABLE_NAME(TN), lists:concat([TN, "_", erlang:pid_to_list(self())])).
+-define(TABLE_1, ?REG_NAME(?TABLE_NAME(otel_export_table1))).
+-define(TABLE_2, ?REG_NAME(?TABLE_NAME(otel_export_table2))).
+-define(CURRENT_TABLE(RegName), persistent_term:get(?CURRENT_TABLES_KEY(RegName))).
+
+-define(DEFAULT_MAX_QUEUE_SIZE, 2048).
+-define(DEFAULT_SCHEDULED_DELAY_MS, timer:seconds(5)).
+-define(DEFAULT_EXPORTER_TIMEOUT_MS, timer:seconds(30)).
+-define(DEFAULT_CHECK_TABLE_SIZE_MS, timer:seconds(1)).
+
+-define(ENABLED_KEY(RegName), {?MODULE, enabled_key, RegName}).
+
+-ifdef(TEST).
+-export([current_tab_to_list/1]).
+current_tab_to_list(RegName) ->
+    ets:tab2list(?CURRENT_TABLE(RegName)).
+-endif.
+
+%% require a unique name to distinguish multiple batch processors while
+%% still having a single name, instead of a possibly changing pid, to
+%% communicate with the processor
+%% @doc Starts a Batch Span Processor.
+%% @end
+-spec start_link(#{name := atom() | list()}) -> {ok, pid(), map()}.
+start_link(Config=#{name := Name}) ->
+    RegisterName = ?REG_NAME(Name),
+    Config1 = Config#{reg_name => RegisterName},
+    {ok, Pid} = gen_statem:start_link({local, RegisterName}, ?MODULE, [Config1], []),
+    {ok, Pid, Config1}.
+
+%% @deprecated Please use {@link otel_tracer_provider}
+set_exporter(Exporter) ->
+    set_exporter(global, Exporter, []).
+
+%% @deprecated Please use {@link otel_tracer_provider}
+-spec set_exporter(module(), term()) -> ok.
+set_exporter(Exporter, Options) ->
+    gen_statem:call(?REG_NAME(global), {set_exporter, {Exporter, Options}}).
+
+%% @deprecated Please use {@link otel_tracer_provider}
+-spec set_exporter(atom(), module(), term()) -> ok.
+set_exporter(Name, Exporter, Options) ->
+    gen_statem:call(?REG_NAME(Name), {set_exporter, {Exporter, Options}}).
+
+%% @private
+-spec on_start(otel_ctx:t(), opentelemetry:span(), otel_span_processor:processor_config())
+              -> opentelemetry:span().
+on_start(_Ctx, Span, _) ->
+    Span.
+
+%% @private
+-spec on_end(opentelemetry:span(), otel_span_processor:processor_config())
+            -> true | dropped | {error, invalid_span} | {error, no_export_buffer}.
+on_end(#span{trace_flags=TraceFlags}, _) when not(?IS_SAMPLED(TraceFlags)) ->
+    dropped;
+on_end(Span=#span{}, #{reg_name := RegName}) ->
+    do_insert(RegName, Span);
+on_end(_Span, _) ->
+    {error, invalid_span}.
+
+%% @private
+-spec force_flush(#{reg_name := gen_statem:server_ref()}) -> ok.
+force_flush(#{reg_name := RegName}) ->
+    gen_statem:cast(RegName, force_flush).
+
+%% @private
+init([Args=#{reg_name := RegName}]) ->
+    process_flag(trap_exit, true),
+
+    SizeLimit = maps:get(max_queue_size, Args, ?DEFAULT_MAX_QUEUE_SIZE),
+    ExportingTimeout = maps:get(exporting_timeout_ms, Args, ?DEFAULT_EXPORTER_TIMEOUT_MS),
+    ScheduledDelay = maps:get(scheduled_delay_ms, Args, ?DEFAULT_SCHEDULED_DELAY_MS),
+    CheckTableSize = maps:get(check_table_size_ms, Args, ?DEFAULT_CHECK_TABLE_SIZE_MS),
+
+    %% TODO: this should be passed in from the tracer server
+    Resource = case maps:find(resource, Args) of
+                   {ok, R} ->
+                       R;
+                   error ->
+                       otel_resource_detector:get_resource()
+               end,
+    %% Resource = otel_tracer_provider:resource(),
+
+    Table1 = ?TABLE_1,
+    Table2 = ?TABLE_2,
+
+    _Tid1 = new_export_table(Table1),
+    _Tid2 = new_export_table(Table2),
+    persistent_term:put(?CURRENT_TABLES_KEY(RegName), Table1),
+
+    %% only enable export table if there is going to be an exporter
+    case maps:get(exporter, Args, none) of
+        ExporterConfig when ExporterConfig =:= none ; ExporterConfig =:= undefined ->
+            disable(RegName);
+        ExporterConfig ->
+            enable(RegName)
+    end,
+
+    {ok, idle, #data{exporter=undefined,
+                     exporter_config=ExporterConfig,
+                     resource = Resource,
+                     handed_off_table=undefined,
+                     max_queue_size=SizeLimit,
+                     exporting_timeout_ms=ExportingTimeout,
+                     check_table_size_ms=CheckTableSize,
+                     scheduled_delay_ms=ScheduledDelay,
+                     table_1=Table1,
+                     table_2=Table2,
+                     reg_name=RegName}}.
+
+%% @private
+callback_mode() ->
+    [state_functions, state_enter].
+
+%% @private
+idle(enter, _OldState, Data=#data{exporter=undefined,
+                                  exporter_config=ExporterConfig,
+                                  scheduled_delay_ms=SendInterval,
+                                  check_table_size_ms=CheckInterval,
+                                  reg_name=RegName}) ->
+    Exporter = init_exporter(RegName, ExporterConfig),
+    {keep_state, Data#data{exporter=Exporter},
+     [{{timeout, export_spans}, SendInterval, export_spans},
+      {{timeout, check_table_size}, CheckInterval, check_table_size}]};
+idle(enter, _OldState, #data{scheduled_delay_ms=SendInterval,
+                             check_table_size_ms=CheckInterval}) ->
+    {keep_state_and_data,
+     [{{timeout, export_spans}, SendInterval, export_spans},
+      {{timeout, check_table_size}, CheckInterval, check_table_size}]};
+idle(_, export_spans, Data=#data{exporter=undefined,
+                                 exporter_config=ExporterConfig,
+                                 reg_name=RegName}) ->
+    Exporter = init_exporter(RegName, ExporterConfig),
+    {next_state, exporting, Data#data{exporter=Exporter}};
+idle(_, export_spans, Data) ->
+    {next_state, exporting, Data};
+idle(EventType, Event, Data) ->
+    handle_event_(idle, EventType, Event, Data).
+
+%% receiving an `export_spans' timeout while exporting means the `ExportingTimeout'
+%% is shorter than the `SendInterval'. Postponing the event will ensure we export
+%% after
+%% @private
+exporting({timeout, export_spans}, export_spans, _) ->
+    {keep_state_and_data, [postpone]};
+exporting(enter, _OldState, #data{exporter=undefined,
+                                  reg_name=RegName}) ->
+    %% exporter still undefined, go back to idle
+    %% first empty the table and disable the processor so no more spans are added
+    %% we wait until the attempt to export to disable so we don't lose spans
+    %% on startup but disable once it is clear an exporter isn't being set
+    clear_table_and_disable(RegName),
+
+    %% use state timeout to transition to `idle' since we can't set a
+    %% new state in an `enter' handler
+    {keep_state_and_data, [{state_timeout, 0, no_exporter}]};
+exporting(enter, _OldState, Data=#data{exporting_timeout_ms=ExportingTimeout,
+                                       scheduled_delay_ms=SendInterval}) ->
+    case export_spans(Data) of
+        ok ->
+            %% in an `enter' handler we can't return a `next_state' or `next_event'
+            %% so we rely on a timeout to trigger the transition to `idle'
+            {keep_state, Data#data{runner_pid=undefined}, [{state_timeout, 0, empty_table}]};
+        {OldTableName, RunnerPid} ->
+            {keep_state, Data#data{runner_pid=RunnerPid,
+                                   handed_off_table=OldTableName},
+             [{state_timeout, ExportingTimeout, exporting_timeout},
+              {{timeout, export_spans}, SendInterval, export_spans}]}
+    end;
+
+%% TODO: we need to just check if `exporter=undefined' right?
+%% two hacks since we can't transition to a new state or send an action from `enter'
+exporting(state_timeout, no_exporter, Data) ->
+    {next_state, idle, Data};
+exporting(state_timeout, empty_table, Data) ->
+    {next_state, idle, Data};
+
+exporting(state_timeout, exporting_timeout, Data=#data{handed_off_table=ExportingTable}) ->
+    %% kill current exporting process because it is taking too long
+    %% which deletes the exporting table, so create a new one and
+    %% repeat the state to force another span exporting immediately
+    Data1 = kill_runner(Data),
+    new_export_table(ExportingTable),
+    {next_state, idle, Data1};
+%% important to verify runner_pid and FromPid are the same in case it was sent
+%% after kill_runner was called but before it had done the unlink
+exporting(info, {'EXIT', FromPid, _}, Data=#data{runner_pid=FromPid}) ->
+    complete_exporting(Data);
+%% important to verify runner_pid and FromPid are the same in case it was sent
+%% after kill_runner was called but before it had done the unlink
+exporting(info, {completed, FromPid}, Data=#data{runner_pid=FromPid}) ->
+    complete_exporting(Data);
+exporting(EventType, Event, Data) ->
+    handle_event_(exporting, EventType, Event, Data).
+
+%% transition to exporting on a force_flush unless we are already exporting
+%% if exporting then postpone the event so the force flush happens after
+%% this current exporting is complete
+handle_event_(exporting, _, force_flush, _Data) ->
+    {keep_state_and_data, [postpone]};
+handle_event_(_State, _, force_flush, Data) ->
+    {next_state, exporting, Data};
+
+handle_event_(_State, {timeout, check_table_size}, check_table_size, #data{max_queue_size=infinity}) ->
+    keep_state_and_data;
+handle_event_(_State, {timeout, check_table_size}, check_table_size, #data{max_queue_size=MaxQueueSize,
+                                                                           check_table_size_ms=CheckInterval,
+                                                                           reg_name=RegName}) ->
+    case ets:info(?CURRENT_TABLE(RegName), size) of
+        M when M >= MaxQueueSize ->
+            disable(RegName);
+        _ ->
+            enable(RegName)
+    end,
+    {keep_state_and_data, [{{timeout, check_table_size}, CheckInterval, check_table_size}]};
+handle_event_(_, {call, From}, {set_exporter, ExporterConfig}, Data=#data{exporter=OldExporter,
+                                                                          reg_name=RegName}) ->
+    otel_exporter:shutdown(OldExporter),
+
+    %% enable immediately or else spans will be dropped for a period even after this call returns
+    enable(RegName),
+
+    {keep_state, Data#data{exporter=undefined,
+                           exporter_config=ExporterConfig}, [{reply, From, ok},
+                                                             {next_event, internal, init_exporter}]};
+handle_event_(_, internal, init_exporter, Data=#data{exporter=undefined,
+                                                     exporter_config=ExporterConfig,
+                                                     reg_name=RegName}) ->
+    Exporter = init_exporter(RegName, ExporterConfig),
+    {keep_state, Data#data{exporter=Exporter}};
+handle_event_(_, _, _, _) ->
+    keep_state_and_data.
+
+%% @private
+terminate(_Reason, _State, #data{exporter=Exporter,
+                                 resource=Resource,
+                                 reg_name=RegName}) ->
+    CurrentTable = ?CURRENT_TABLE(RegName),
+
+    %% `export' is used to perform a blocking export
+    _ = export(Exporter, Resource, CurrentTable),
+
+    ok.
+
+%%
+
+init_exporter(RegName, ExporterConfig) ->
+    case otel_exporter:init(ExporterConfig) of
+        Exporter when Exporter =/= undefined andalso Exporter =/= none ->
+            enable(RegName),
+            Exporter;
+        _ ->
+            %% exporter is undefined/none
+            %% disable the insertion of new spans and delete the current table
+            clear_table_and_disable(RegName),
+            undefined
+    end.
+
+clear_table_and_disable(RegName) ->
+    disable(RegName),
+    ets:delete(?CURRENT_TABLE(RegName)),
+    new_export_table(?CURRENT_TABLE(RegName)).
+
+enable(RegName)->
+    persistent_term:put(?ENABLED_KEY(RegName), true).
+
+disable(RegName) ->
+    persistent_term:put(?ENABLED_KEY(RegName), false).
+
+is_enabled(RegName) ->
+    persistent_term:get(?ENABLED_KEY(RegName), true).
+
+do_insert(RegName, Span) ->
+    try
+        case is_enabled(RegName) of
+            true ->
+                ets:insert(?CURRENT_TABLE(RegName), Span);
+            _ ->
+                dropped
+        end
+    catch
+        error:badarg ->
+            {error, no_batch_span_processor};
+        _:_ ->
+            {error, other}
+    end.
+
+complete_exporting(Data=#data{handed_off_table=ExportingTable})
+  when ExportingTable =/= undefined ->
+    new_export_table(ExportingTable),
+    {next_state, idle, Data#data{runner_pid=undefined,
+                                 handed_off_table=undefined}};
+complete_exporting(Data) ->
+    {next_state, idle, Data#data{runner_pid=undefined,
+                                 handed_off_table=undefined}}.
+
+kill_runner(Data=#data{runner_pid=RunnerPid}) when RunnerPid =/= undefined ->
+    Mon = erlang:monitor(process, RunnerPid),
+    erlang:unlink(RunnerPid),
+    erlang:exit(RunnerPid, kill),
+    %% Wait for the runner process termination to be sure that
+    %% the export table is destroyed and can be safely recreated
+    receive
+        {'DOWN', Mon, process, RunnerPid, _} ->
+            Data#data{runner_pid=undefined, handed_off_table=undefined}
+    end.
+
+new_export_table(Name) ->
+     ets:new(Name, [public,
+                    named_table,
+                    {write_concurrency, true},
+                    duplicate_bag,
+                    %% OpenTelemetry exporter protos group by the
+                    %% instrumentation_scope. So using instrumentation_scope
+                    %% as the key means we can easily lookup all spans for
+                    %% for each instrumentation_scope and export together.
+                    {keypos, #span.instrumentation_scope}]).
+
+export_spans(#data{exporter=Exporter,
+                   resource=Resource,
+                   table_1=Table1,
+                   table_2=Table2,
+                   reg_name=RegName}) ->
+    CurrentTable = ?CURRENT_TABLE(RegName),
+    case ets:info(CurrentTable, size) of
+        0 ->
+            %% nothing to do if the table is empty
+            ok;
+        _ ->
+            NewCurrentTable = case CurrentTable of
+                                  Table1 ->
+                                      Table2;
+                                  Table2 ->
+                                      Table1
+                              end,
+
+            %% an atom is a single word so this does not trigger a global GC
+            persistent_term:put(?CURRENT_TABLES_KEY(RegName), NewCurrentTable),
+            %% set the table to accept inserts
+            enable(RegName),
+
+            Self = self(),
+            RunnerPid = erlang:spawn_link(fun() -> send_spans(Self, Resource, Exporter) end),
+            ets:give_away(CurrentTable, RunnerPid, export),
+            {CurrentTable, RunnerPid}
+    end.
+
+send_spans(FromPid, Resource, Exporter) ->
+    receive
+        {'ETS-TRANSFER', Table, FromPid, export} ->
+            export(Exporter, Resource, Table),
+            ets:delete(Table),
+            completed(FromPid)
+    end.
+
+completed(FromPid) ->
+    FromPid ! {completed, self()}.
+
+export(undefined, _, _) ->
+    true;
+export(Exporter, Resource, SpansTid) ->
+    %% don't let a exporter exception crash us
+    %% and return true if exporter failed
+    try
+        otel_exporter_traces:export(Exporter, SpansTid, Resource) =:= failed_not_retryable
+    catch
+        Kind:Reason:StackTrace ->
+            ?LOG_INFO(#{source => exporter,
+                        during => export,
+                        kind => Kind,
+                        reason => Reason,
+                        exporter => Exporter,
+                        stacktrace => StackTrace}, #{report_cb => fun ?MODULE:report_cb/1}),
+            true
+    end.
+
+%% logger format functions
+%% @private
+report_cb(#{source := exporter,
+            during := export,
+            kind := Kind,
+            reason := Reason,
+            exporter := {ExporterModule, _},
+            stacktrace := StackTrace}) ->
+    {"span exporter threw exception: exporter=~p ~ts",
+     [ExporterModule, otel_utils:format_exception(Kind, Reason, StackTrace)]}.

apps/opentelemetry/src/otel_configuration.erl

@@ -0,0 +1,544 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2021, 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.
+%%
+%% Merges environment variable configuration values with application
+%% configuration. The OS environment variables take precedence over the
+%% application environment.
+%% @private
+%%%-------------------------------------------------------------------------
+-module(otel_configuration).
+
+-export([merge_with_os/1,
+         merge_list_with_environment/3,
+         report_cb/1]).
+
+-define(BATCH_PROCESSOR_DEFAULTS, #{scheduled_delay_ms => 5000,
+                                    exporting_timeout_ms => 30000,
+                                    max_queue_size => 2048,
+                                    exporter => {opentelemetry_exporter, #{}}}).
+-define(SIMPLE_PROCESSOR_DEFAULTS, #{exporting_timeout_ms => 30000,
+                                     exporter => {opentelemetry_exporter, #{}}}).
+
+%% required configuration
+%% using a map instead of a record because there can be more values
+-type t() :: #{sdk_disabled := boolean(),
+               log_level := atom(),
+               register_loaded_applications := boolean() | undefined,
+               create_application_tracers := boolean() | undefined,
+               id_generator := module(),
+               deny_list := [atom()],
+
+               resource_detectors := [module()],
+               resource_detector_timeout := integer(),
+               bsp_scheduled_delay_ms := integer() | undefined,
+               bsp_exporting_timeout_ms := integer() | undefined,
+               bsp_max_queue_size := integer() | undefined,
+               ssp_exporting_timeout_ms := integer() | undefined,
+               text_map_propagators := [atom()],
+               traces_exporter := {atom(), term()} | none | undefined,
+               metrics_exporter := {atom(), term()} | none | undefined,
+               views := list(), %% TODO: type should be `[otel_meter_server:view_config]'
+                                %% when Metrics are moved out of the experimental app
+               readers := [#{id := atom(), module => module(), config => map()}],
+               exemplars_enabled := boolean(),
+               exemplar_filter := always_on | always_off | trace_based,
+               metric_producers := [{module(), term()}],
+
+               processors := list(),
+               sampler := {atom(), term()},
+               sweeper := #{interval => integer() | infinity,
+                            strategy => atom() | fun(),
+                            span_ttl => integer() | infinity,
+                            storage_size => integer() | infinity},
+               attribute_count_limit := integer(),
+               attribute_value_length_limit := integer() | infinity,
+               event_count_limit := integer(),
+               link_count_limit := integer(),
+               attribute_per_event_limit := integer(),
+               attribute_per_link_limit := integer()}.
+
+-export_type([t/0]).
+
+-include_lib("kernel/include/logger.hrl").
+-include_lib("opentelemetry_api/include/gradualizer.hrl").
+
+-spec new() -> t().
+new() ->
+    ?assert_type(#{sdk_disabled => false,
+                   log_level => info,
+                   register_loaded_applications => undefined,
+                   create_application_tracers => undefined,
+                   id_generator => otel_id_generator,
+                   deny_list => [],
+                   resource_detectors => [otel_resource_env_var,
+                                          otel_resource_app_env],
+                   resource_detector_timeout => 5000,
+                   bsp_scheduled_delay_ms => undefined,
+                   bsp_exporting_timeout_ms => undefined,
+                   bsp_max_queue_size => undefined,
+                   ssp_exporting_timeout_ms => undefined,
+                   text_map_propagators => [trace_context, baggage],
+                   traces_exporter => {opentelemetry_exporter, #{}},
+                   metrics_exporter => {opentelemetry_exporter, #{}},
+                   views => [],
+                   readers => [],
+                   exemplars_enabled => false,
+                   exemplar_filter => trace_based,
+                   metric_producers => [],
+                   processors => [{otel_batch_processor, ?BATCH_PROCESSOR_DEFAULTS}],
+                   sampler => {parent_based, #{root => always_on}},
+                   sweeper => #{interval => timer:minutes(10),
+                                strategy => drop,
+                                span_ttl => timer:minutes(30),
+                                storage_size => infinity},
+                   attribute_count_limit => 128,
+                   attribute_value_length_limit => infinity,
+                   event_count_limit => 128,
+                   link_count_limit => 128,
+                   attribute_per_event_limit => 128,
+                   attribute_per_link_limit => 128}, t()).
+
+-spec merge_with_os(list()) -> t().
+merge_with_os(AppEnv) ->
+    ConfigMap = new(),
+
+    lists:foldl(fun(F, Acc) ->
+                        F(AppEnv, Acc)
+                end, ConfigMap, [fun span_limits/2,
+                                 fun general/2,
+                                 fun sampler/2,
+                                 fun processors/2,
+                                 fun sweeper/2]).
+
+-spec span_limits(list(), t()) -> t().
+span_limits(AppEnv, ConfigMap) ->
+    merge_list_with_environment(config_mappings(span_limits), AppEnv, ConfigMap).
+
+-spec general(list(), t()) -> t().
+general(AppEnv, ConfigMap) ->
+    Config = merge_list_with_environment(config_mappings(general_sdk), AppEnv, ConfigMap),
+
+    %% merge the old `register_loaded_applications' with the new config key
+    %% `create_application_tracers' that has replaced it
+    Config1 = maps:update_with(create_application_tracers,
+                               fun(undefined) ->
+                                       %% `create_application_tracers' isn't set so update
+                                       %% with the `register_loaded_applications' value
+                                       %% or `true' if it too isn't set
+                                       case maps:get(register_loaded_applications, Config) of
+                                           undefined ->
+                                               true;
+                                           Bool ->
+                                               Bool
+                                       end;
+                                  (Bool) ->
+                                       Bool
+                               end, Config),
+
+    ?assert_type(Config1, t()).
+
+-spec sweeper(list(), t()) -> t().
+sweeper(AppEnv, ConfigMap=#{sweeper := DefaultSweeperConfig}) ->
+    AppEnvSweeper = proplists:get_value(sweeper, AppEnv, #{}),
+
+    %% convert sweeper config to a list to utilize the merge_list_with_environment function
+    SweeperConfig = merge_list_with_environment(config_mappings(sweeper),
+                                                maps:to_list(AppEnvSweeper),
+                                                DefaultSweeperConfig),
+    ConfigMap#{sweeper => SweeperConfig}.
+
+-spec processors(list(), t()) -> t().
+processors(AppEnv, ConfigMap) ->
+    SpanProcessors = case transform(span_processor, proplists:get_value(span_processor, AppEnv)) of
+                         undefined ->
+                             Processors = proplists:get_value(processors, AppEnv, maps:get(processors, ConfigMap)),
+                             transform(span_processors, Processors);
+                         SpanProcessor ->
+                             case proplists:get_value(processors, AppEnv) of
+                                 undefined ->
+                                     ok;
+                                 _ ->
+                                     ?LOG_INFO("both processors and span_processor set in configuration but "
+                                               "only one should be used. span_processor will be ignored.")
+                             end,
+
+                             [SpanProcessor]
+                     end,
+
+    ProcessorsConfig = lists:map(fun({Name, Opts}) ->
+                                         Opts1 = merge_processor_config(Name, Opts, ConfigMap, AppEnv),
+                                         {Name, Opts1}
+                                 end, SpanProcessors),
+
+    ConfigMap#{processors := ProcessorsConfig}.
+
+%% use the top level app env and os env configuration to set/override processor config values
+merge_processor_config(otel_batch_processor, Opts, ConfigMap, AppEnv) ->
+    BatchEnvMapping = [{bsp_scheduled_delay_ms, scheduled_delay_ms},
+                       {bsp_exporting_timeout_ms, exporting_timeout_ms},
+                       {bsp_max_queue_size, max_queue_size},
+                       {traces_exporter, exporter}],
+    maps:merge(?BATCH_PROCESSOR_DEFAULTS,
+               merge_processor_config_(BatchEnvMapping, Opts, ConfigMap, AppEnv));
+merge_processor_config(otel_simple_processor, Opts, ConfigMap, AppEnv) ->
+    SimpleEnvMapping = [{ssp_exporting_timeout_ms, exporting_timeout_ms},
+                        {traces_exporter, exporter}],
+    maps:merge(?SIMPLE_PROCESSOR_DEFAULTS,
+               merge_processor_config_(SimpleEnvMapping, Opts, ConfigMap, AppEnv));
+merge_processor_config(_, Opts, _, _) ->
+    Opts.
+
+merge_processor_config_(EnvMapping, Opts, ConfigMap, AppEnv) ->
+    Mappings = config_mappings(general_sdk),
+
+    lists:foldl(fun({K, V}, Acc) ->
+                        case maps:get(K, ConfigMap, undefined) of
+                            undefined ->
+                                Acc;
+                            Value ->
+                                %% use default only if the config isn't found in Opts
+                                %% but if the value in ConfigMap isn't the default use it
+                                IsDefault = is_default(K, AppEnv, Mappings),
+                                case (IsDefault andalso not maps:is_key(V, Opts)) orelse not IsDefault of
+                                    true ->
+                                        Acc#{V => Value};
+                                    false ->
+                                        Acc
+                                end
+                        end
+                end, Opts, EnvMapping).
+
+%% return true if the user (through application or os environment) configured
+%% a certain setting
+is_default(Key, AppEnv, Mappings) ->
+    {OSVarName, Key, _TransformType} = lists:keyfind(Key, 2, Mappings),
+    not lists:keymember(Key, 1, AppEnv) andalso os:getenv(OSVarName) =:= false.
+
+%% sampler configuration is unique since it has the _ARG that is a sort of
+%% sub-configuration of the sampler config, and isn't a list.
+-spec sampler(list(), t()) -> t().
+sampler(AppEnv, ConfigMap) ->
+    OSVar = "OTEL_TRACES_SAMPLER",
+    Key = sampler,
+    Transform = sampler,
+    case os:getenv("OTEL_TRACES_SAMPLER") of
+        false ->
+            case proplists:get_value(Key, AppEnv) of
+                undefined ->
+                    ConfigMap;
+                Sampler ->
+                    update_config_map(OSVar, Key, Transform, Sampler, ConfigMap)
+            end;
+        OSEnvSampler->
+            SamplerTuple = {OSEnvSampler, os:getenv("OTEL_TRACES_SAMPLER_ARG")},
+            update_config_map(OSVar, Key, Transform, SamplerTuple, ConfigMap)
+    end.
+
+%% requires `ConfigMap' contains every key and its default
+%% will replace the defaults with the value from either the OS environment or application
+%% environment, with the OS environment taking precedence.
+-spec merge_list_with_environment([{OSVar, Key, Transform}], AppEnv, ConfigMap) -> ConfigMap
+              when OSVar :: string(),
+                   Key :: atom(),
+                   Transform :: atom(),
+                   AppEnv :: [{atom(), term()}],
+                   ConfigMap :: map().
+merge_list_with_environment(ConfigMappings, AppEnv, ConfigMap) ->
+    lists:foldl(fun({OSVar, Key, Transform}, Acc) ->
+                        case os:getenv(OSVar) of
+                            false ->
+                                %% not in the OS environment so check application environment
+                                case lists:keyfind(Key, 1, AppEnv) of
+                                    false ->
+                                        %% not in the application env so leave default
+                                        Acc;
+                                    {_, Value} ->
+                                        %% transform even the value from the
+                                        %% application environment to ensure it
+                                        %% is of the right type/format
+                                        update_config_map(OSVar, Key, Transform, Value, Acc)
+                                end;
+                            OSVal ->
+                                update_config_map(OSVar, Key, Transform, OSVal, Acc)
+                        end
+                end, ConfigMap, ConfigMappings).
+
+update_config_map(OSVar, Key, Transform, Value, ConfigMap) ->
+    try transform(Transform, Value) of
+        TransformedValue ->
+            ConfigMap#{Key := TransformedValue}
+    catch
+        Kind:Reason:StackTrace ->
+            ?LOG_INFO(#{source => transform,
+                        kind => Kind,
+                        reason => Reason,
+                        os_var => OSVar,
+                        key => Key,
+                        transform => Transform,
+                        value => Value,
+                        stacktrace => StackTrace},
+                      #{report_cb => fun ?MODULE:report_cb/1}),
+            ConfigMap
+    end.
+
+report_cb(#{source := transform,
+            kind := Kind,
+            reason := Reason,
+            os_var := OSVar,
+            key := Key,
+            transform := Transform,
+            value := Value,
+            stacktrace := StackTrace}) ->
+    {"Transforming configuration value failed: os_var=~ts key=~ts transform=~ts value=~ts exception=~ts",
+     [OSVar, Key, Transform, Value, otel_utils:format_exception(Kind, Reason, StackTrace)]}.
+
+config_mappings(general_sdk) ->
+    [{"OTEL_SDK_DISABLED", sdk_disabled, boolean},
+     {"OTEL_LOG_LEVEL", log_level, existing_atom},
+
+     %% `register_loaded_applications' is kept for backwards compatibility
+     {"OTEL_REGISTER_LOADED_APPLICATIONS", register_loaded_applications, boolean},
+     {"OTEL_CREATE_APPLICATION_TRACERS", create_application_tracers, boolean},
+
+     {"OTEL_ID_GENERATOR", id_generator, existing_atom},
+     {"OTEL_DENY_LIST", deny_list, existing_atom_list},
+     {"OTEL_PROPAGATORS", text_map_propagators, propagators},
+     {"OTEL_TRACES_EXPORTER", traces_exporter, exporter},
+     {"OTEL_METRICS_EXPORTER", metrics_exporter, exporter},
+     {"OTEL_METRIC_VIEWS", views, views},
+     {"OTEL_METRIC_READERS", readers, readers},
+     {"OTEL_ERLANG_X_EXEMPLARS_ENABLED", exemplars_enabled, boolean},
+     {"OTEL_METRICS_EXEMPLAR_FILTER", exemplar_filter, exemplar_filter},
+     {"OTEL_ERLANG_X_METRIC_PRODUCERS", metric_producers, metric_producers},
+     {"OTEL_RESOURCE_DETECTORS", resource_detectors, existing_atom_list},
+     {"OTEL_RESOURCE_DETECTOR_TIMEOUT", resource_detector_timeout, integer},
+
+     {"OTEL_BSP_SCHEDULE_DELAY_MILLIS", bsp_scheduled_delay_ms, integer},
+     {"OTEL_BSP_EXPORT_TIMEOUT_MILLIS", bsp_exporting_timeout_ms, integer},
+     {"OTEL_BSP_MAX_QUEUE_SIZE", bsp_max_queue_size, integer},
+     %% the following is not supported yet
+     %% {"OTEL_BSP_MAX_EXPORT_BATCH_SIZE", bsp_max_export_batch_size, integer}
+
+     {"OTEL_SSP_EXPORT_TIMEOUT_MILLIS", ssp_exporting_timeout_ms, integer}
+    ];
+config_mappings(span_limits) ->
+    [{"OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT", attribute_count_limit, integer},
+     {"OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT", attribute_value_length_limit, integer_infinity},
+     {"OTEL_SPAN_EVENT_COUNT_LIMIT", event_count_limit, integer},
+     {"OTEL_SPAN_LINK_COUNT_LIMIT", link_count_limit, integer},
+     {"OTEL_EVENT_ATTRIBUTE_COUNT_LIMIT", attribute_per_event_limit, integer},
+     {"OTEL_LINK_ATTRIBUTE_COUNT_LIMIT", attribute_per_link_limit, integer}%% ,
+     %% {"OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT", attribute_value_length_limit, integer},
+     %% {"OTEL_ATTRIBUTE_COUNT_LIMIT", attribute_per_link_limit, integer}
+    ];
+config_mappings(sweeper) ->
+    [{"OTEL_SPAN_SWEEPER_INTERVAL", interval, integer_infinity},
+     {"OTEL_SPAN_SWEEPER_STRATEGY", strategy, atom_or_fun},
+     {"OTEL_SPAN_SWEEPER_SPAN_TTL", span_ttl, integer_infinity},
+     {"OTEL_SPAN_SWEEPER_STORAGE_SIZE", storage_size, integer_infinity}
+    ].
+
+transform(_, undefined) ->
+    undefined;
+transform(existing_atom_list, [A | _]=List) when is_atom(A) ->
+    List;
+transform(existing_atom_list, String) when is_list(String) ->
+    List = string:split(String, ",", all),
+    lists:filtermap(fun(A) ->
+                            try transform(existing_atom, string:trim(A)) of
+                                Value ->
+                                    {true, Value}
+                            catch
+                                _:_ ->
+                                    false
+                            end
+                    end, List);
+transform(exporter, Exporter) when Exporter =:= "otlp" ; Exporter =:= otlp ->
+    {opentelemetry_exporter, #{}};
+transform(exporter, Exporter) when Exporter =:= "jaeger" ; Exporter =:= jaeger ->
+    ?LOG_WARNING("configuring jaeger exporter through OTEL_TRACES_EXPORTER is not yet supported ", []),
+    none;
+transform(exporter, Exporter)  when Exporter =:= "zipkin" ; Exporter =:= zipkin ->
+    ?LOG_WARNING("configuring zipkin exporter through OTEL_TRACES_EXPORTER is not yet supported ", []),
+    none;
+transform(exporter, Exporter) when Exporter =:= "none" ; Exporter =:= none ->
+    none;
+transform(exporter, Value={Term, _}) when is_atom(Term) ->
+    Value;
+transform(exporter, UnknownExporter) when is_list(UnknownExporter) ->
+    ?LOG_WARNING("unknown exporter ~p. falling back to default otlp", [UnknownExporter]),
+    {opentelemetry_exporter, #{}};
+
+transform(otlp_protocol, Proto) when Proto =:= "grpc"; Proto =:= grpc ->
+  grpc;
+transform(otlp_protocol, Proto) when Proto =:= "http/protobuf"; Proto =:= "http_protobuf"; Proto =:= http_protobuf ->
+  http_protobuf;
+transform(otlp_protocol, Proto) when Proto =:= "http/json"; Proto =:= "http_json"; Proto =:= http_json ->
+  ?LOG_WARNING("The http/json transport protocol is not supported by the OTLP exporter, spans will not be exported.", []),
+  undefined;
+transform(otlp_protocol, Proto) ->
+  ?LOG_WARNING("unknown ~ts transport protocol, spans will not be exported.", [Proto]),
+  undefined;
+
+transform(integer_infinity, infinity) ->
+    infinity;
+transform(integer_infinity, Value) ->
+    transform(integer, Value);
+transform(integer, Value) when is_integer(Value) ->
+    Value;
+transform(integer, Value) when is_list(Value) ->
+    list_to_integer(Value);
+transform(existing_atom, Value) when is_atom(Value) ->
+    Value;
+transform(existing_atom, Value) when is_list(Value) ->
+    list_to_existing_atom(Value);
+transform(atom_or_fun, Value) when is_list(Value) ->
+    list_to_existing_atom(Value);
+transform(atom_or_fun, Value) when is_atom(Value) ->
+    Value;
+transform(atom_or_fun, Value) when is_function(Value) ->
+    Value;
+transform(boolean, Value) when is_boolean(Value) ->
+    Value;
+transform(boolean, "true") ->
+    true;
+transform(boolean, "false") ->
+    false;
+transform(url, Value=#{}) ->
+    Value;
+transform(url, Value) ->
+    uri_string:parse(Value);
+%% convert sampler string to usable configuration term
+transform(sampler, {"parentbased_always_on", _}) ->
+    {parent_based, #{root => always_on}};
+transform(sampler, {"parentbased_always_off", _}) ->
+    {parent_based, #{root => always_off}};
+transform(sampler, {"always_on", _}) ->
+    always_on;
+transform(sampler, {"always_off", _}) ->
+    always_off;
+transform(sampler, {"traceidratio", false}) ->
+    {trace_id_ratio_based, 1.0};
+transform(sampler, {"traceidratio", Probability}) ->
+    {trace_id_ratio_based, probability_string_to_float(Probability)};
+transform(sampler, {"parentbased_traceidratio", false}) ->
+    {parent_based, #{root => {trace_id_ratio_based, 1.0}}};
+transform(sampler, {"parentbased_traceidratio", Probability}) ->
+    {parent_based, #{root => {trace_id_ratio_based, probability_string_to_float(Probability)}}};
+transform(sampler, Value) ->
+    Value;
+transform(key_value_list, Value) when is_list(Value) ->
+    case io_lib:printable_unicode_list(Value) of
+        true ->
+            Pairs = string:split(Value, ",", all),
+            lists:filtermap(fun(Pair) ->
+                                    case string:split(Pair, "=", leading) of
+                                        [K, V] ->
+                                            V1 = re:replace(string:trim(V), "^\"|\"$", "", [global, {return, list}]),
+                                            {true, {string:trim(K), V1}};
+                                        _ ->
+                                            false
+                                    end
+                            end, Pairs);
+        false ->
+            Value
+    end;
+transform(propagators, [P | _]=Propagators) when is_atom(P) ->
+    lists:filtermap(fun(Propagator) ->
+                            case transform(propagator, Propagator) of
+                                undefined ->
+                                    false;
+                                Value ->
+                                    {true, Value}
+                            end
+                    end, Propagators);
+transform(propagators, PropagatorsString) when is_list(PropagatorsString) ->
+    Propagators = string:split(PropagatorsString, ",", all),
+    lists:filtermap(fun(Propagator) when is_list(Propagator) ->
+                          case transform(propagator, string:trim(Propagator)) of
+                              undefined ->
+                                  false;
+                              Value ->
+                                  {true, Value}
+                          end
+                  end, Propagators);
+
+transform(propagator, Value) when Value =:= "tracecontext" ;
+                                  Value =:= tracecontext ;
+                                  Value =:= trace_context ->
+    trace_context;
+transform(propagator, Value) when Value =:= "baggage" ;
+                                  Value =:= baggage ->
+    baggage;
+transform(propagator, Value) when Value =:= "b3multi" ;
+                                  Value =:= b3multi ->
+    b3multi;
+transform(propagator, Value) when Value =:= "b3" ;
+                                  Value =:= b3 ->
+    b3;
+%% TODO: support jager propagator format
+%% transform(propagator, "jaeger") ->
+%%     jaeger;
+transform(propagator, Propagator) when is_atom(Propagator) ->
+    Propagator;
+transform(propagator, Propagator) ->
+    ?LOG_WARNING("Ignoring unknown propagator ~ts in OS environment variable $OTEL_PROPAGATORS",
+                 [Propagator]),
+    undefined;
+transform(span_processors, Processors) when is_list(Processors) ->
+    [transform(span_processor, Processor) || Processor <- Processors];
+transform(span_processors, Unknown) ->
+    ?LOG_WARNING("processors value must be a list, but ~ts given. No span processors will be used", [Unknown]),
+    [];
+transform(span_processor, batch) ->
+    {otel_batch_processor, ?BATCH_PROCESSOR_DEFAULTS};
+transform(span_processor, simple) ->
+    {otel_simple_processor, ?SIMPLE_PROCESSOR_DEFAULTS};
+transform(span_processor, SpanProcessor) ->
+    SpanProcessor;
+transform(readers, Readers) ->
+    Readers;
+transform(exemplar_filter, ExemplarFilter) when ExemplarFilter =:= "always_on" ;
+                                                ExemplarFilter =:= always_on ->
+    always_on;
+transform(exemplar_filter, ExemplarFilter) when ExemplarFilter =:= "always_off" ;
+                                                ExemplarFilter =:= always_off ->
+    always_off;
+transform(exemplar_filter, _) ->
+    trace_based;
+transform(metric_producers, MetricProducers) when is_list(MetricProducers) ->
+    lists:filtermap(fun({ProducerModule, ProducerConfig}) when is_atom(ProducerModule) ->
+                            {true, {ProducerModule, ProducerConfig}};
+                       (ProducerModule) when is_atom(ProducerModule) ->
+                            {true, {ProducerModule, []}};
+                       (_) ->
+                            false
+                    end, MetricProducers);
+transform(views, Views) ->
+    Views.
+
+
+probability_string_to_float(Probability) ->
+    try list_to_float(Probability) of
+        Float ->
+            Float
+    catch
+        error:badarg when Probability =:= "1" ->
+            1.0;
+         error:badarg when Probability =:= "0" ->
+            0.0;
+        error:badarg ->
+            ?LOG_WARNING("Unable to convert $OTEL_TRACE_SAMPLER_ARG string value ~ts to float, using 1.0"),
+            1.0
+    end.

apps/opentelemetry/src/otel_events.erl

@@ -0,0 +1,101 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2021, 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.
+%%
+%% @doc
+%% @end
+%%%-------------------------------------------------------------------------
+-module(otel_events).
+
+-export([new/3,
+         add/2,
+         list/1,
+         dropped/1]).
+
+-include("otel_span.hrl").
+
+-record(events, {
+                 count_limit :: integer(),
+                 attribute_per_event_limit :: integer(),
+                 attribute_value_length_limit :: integer() | infinity,
+                 dropped :: integer(),
+                 list :: [#event{}]
+                }).
+
+-type t() :: #events{}.
+
+-export_type([t/0]).
+
+new(EventCountLimit, AttributePerEventLimit, AttributeValueLengthLimit) ->
+    #events{count_limit=EventCountLimit,
+            attribute_per_event_limit=AttributePerEventLimit,
+            attribute_value_length_limit=AttributeValueLengthLimit,
+            dropped=0,
+            list=[]}.
+
+add(NewEvents, Events) ->
+    add_events(NewEvents, Events).
+
+list(#events{list=List}) ->
+    List.
+
+dropped(#events{dropped=Dropped}) ->
+    Dropped.
+
+%%
+
+add_events(NewEvents, Events=#events{count_limit=CountLimit,
+                                     list=List}) ->
+    Limit = CountLimit - length(List),
+    add_events_(NewEvents, Limit, Events).
+
+add_events_([], _, Events) ->
+    Events;
+add_events_(NewEvents, Limit, Events=#events{dropped=Dropped}) when Limit =< 0->
+    %% we've hit the limit on the number of events so drop the rest
+    Events#events{dropped=Dropped + length(NewEvents)};
+add_events_([NewEvent | Rest], Limit, Events=#events{attribute_per_event_limit=AttributePerEventLimit,
+                                                     attribute_value_length_limit=AttributeValueLengthLimit,
+                                                     dropped=Dropped,
+                                                     list=List}) ->
+    case new_event(NewEvent, AttributePerEventLimit, AttributeValueLengthLimit) of
+        drop ->
+            add_events_(Rest, Limit, Events#events{dropped=Dropped + 1});
+        Event ->
+            add_events_(Rest, Limit - 1, Events#events{list=[Event | List]})
+    end.
+
+new_event(#{system_time_native := Timestamp,
+            name := Name,
+            attributes := Attributes}, AttributePerEventLimit, AttributeValueLengthLimit) ->
+    #event{system_time_native=Timestamp,
+           name=Name,
+           attributes=otel_attributes:new(Attributes, AttributePerEventLimit, AttributeValueLengthLimit)};
+new_event(#{name := Name,
+            attributes := Attributes}, AttributePerEventLimit, AttributeValueLengthLimit) ->
+    #event{system_time_native=opentelemetry:timestamp(),
+           name=Name,
+           attributes=otel_attributes:new(Attributes, AttributePerEventLimit, AttributeValueLengthLimit)};
+new_event({Time, Name, Attributes}, AttributePerEventLimit, AttributeValueLengthLimit)
+  when is_binary(Name) ; is_atom(Name) ->
+    #event{system_time_native=Time,
+           name=Name,
+           attributes=otel_attributes:new(Attributes, AttributePerEventLimit, AttributeValueLengthLimit)};
+new_event({Name, Attributes}, AttributePerEventLimit, AttributeValueLengthLimit)
+  when is_binary(Name) ; is_atom(Name) ->
+    #event{system_time_native=opentelemetry:timestamp(),
+           name=Name,
+           attributes=otel_attributes:new(Attributes, AttributePerEventLimit, AttributeValueLengthLimit)};
+new_event(_, _, _) ->
+    drop.
+

apps/opentelemetry/src/otel_exporter.erl

@@ -0,0 +1,174 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @doc
+%% @end
+%%%-----------------------------------------------------------------------
+-module(otel_exporter).
+
+-export([init/1,
+         export_traces/4,
+         export_metrics/4,
+         export_logs/4,
+         export_traces/3,
+         export_metrics/3,
+         export_logs/3,
+         shutdown/1,
+         report_cb/1]).
+
+%% Kept only for backwards compatibility. Look at `otel_exporter_traces', `otel_exporter_metrics'
+%% and `otel_exporter_logs' instead.
+-callback init(term()) -> {ok, term()} | ignore.
+
+%% Kept only for backwards compatibility. Look at `otel_exporter_traces', `otel_exporter_metrics'
+%% and `otel_exporter_logs' instead.
+-callback export(traces | logs | metrics, ets:tab(), otel_resource:t(), term()) -> ok |
+                                                                                   success |
+                                                                                   failed_not_retryable |
+                                                                                   failed_retryable.
+
+%% Kept only for backwards compatibility. Look at `otel_exporter_traces', `otel_exporter_metrics'
+%% and `otel_exporter_logs' instead.failed_retryable.
+-callback shutdown(term()) -> ok.
+
+-include_lib("kernel/include/logger.hrl").
+
+init({ExporterModule, Config}) when is_atom(ExporterModule) ->
+    try ExporterModule:init(Config) of
+        {ok, ExporterState} when ExporterModule =:= opentelemetry_exporter ->
+            %% since we log when the initialization failed so the user knows it later succeeded
+            ?LOG_INFO("OTLP exporter successfully initialized"),
+            {ExporterModule, ExporterState};
+        {ok, ExporterState} ->
+            ?LOG_INFO("Exporter ~tp successfully initialized", [ExporterModule]),
+            {ExporterModule, ExporterState};
+        ignore ->
+            undefined
+    catch
+        Kind:Reason:StackTrace ->
+            %% logging in debug level since config argument in stacktrace could have secrets
+            ?LOG_DEBUG(#{source => exporter,
+                         during => init,
+                         kind => Kind,
+                         reason => Reason,
+                         exporter => ExporterModule,
+                         stacktrace => StackTrace}, #{report_cb => fun ?MODULE:report_cb/1}),
+
+            %% print a more useful message about the failure if we can discern
+            %% one from the failure reason and exporter used
+            case {Kind, Reason} of
+                {error, badarg} when ExporterModule =:= opentelemetry_exporter ->
+                    case maps:get(protocol, Config, undefined) of
+                        grpc ->
+                            %% grpc protocol uses grpcbox which is not included by default
+                            %% this will check if it is available so we can warn the user if
+                            %% the dependency needs to be added
+                            try grpcbox:module_info() of
+                                _ ->
+                                    undefined
+                            catch
+                                _:_ ->
+                                    ?LOG_WARNING("OTLP exporter failed to initialize when using the GRPC "
+                                                 "protocol and `grpcbox` module is not available in the "
+                                                 "code path. Verify that you have the `grpcbox` dependency "
+                                                 "included and rerun.", []),
+                                    undefined
+                            end;
+                        _ ->
+                            %% same as the debug log above
+                            %% without the stacktrace and at a higher level
+                            ?LOG_WARNING(#{source => exporter,
+                                           during => init,
+                                           kind => Kind,
+                                           reason => Reason,
+                                           exporter => ExporterModule}, #{report_cb => fun ?MODULE:report_cb/1}),
+                            undefined
+                    end;
+                {error, undef} when ExporterModule =:= opentelemetry_exporter ->
+                    ?LOG_WARNING("OTLP exporter module `opentelemetry_exporter` not found. "
+                                 "Verify you have included the `opentelemetry_exporter` dependency."),
+                    undefined;
+                {error, undef} ->
+                    ?LOG_WARNING("Exporter module ~tp not found. Verify you have included "
+                                 "the dependency that contains the exporter module.", [ExporterModule]),
+                    undefined;
+                _ ->
+                    %% same as the debug log above
+                    %% without the stacktrace and at a higher level
+                    ?LOG_WARNING(#{source => exporter,
+                                   during => init,
+                                   kind => Kind,
+                                   reason => Reason,
+                                   exporter => ExporterModule}, #{report_cb => fun ?MODULE:report_cb/1}),
+                    undefined
+            end
+    end;
+init(Exporter) when Exporter =:= none ; Exporter =:= undefined ->
+    undefined;
+init(ExporterModule) when is_atom(ExporterModule) ->
+    init({ExporterModule, []}).
+
+export_traces({ExporterModule, Config}, SpansTid, Resource) ->
+    ExporterModule:export(traces, SpansTid, Resource, Config).
+
+export_metrics({ExporterModule, Config}, MetricsTid, Resource) ->
+    ExporterModule:export(metrics, MetricsTid, Resource, Config).
+
+export_logs({ExporterModule, Config}, Batch, Resource) ->
+    ExporterModule:export(logs, Batch, Resource, Config).
+
+%% below export_* functions are for backwards compatibility
+
+export_traces(ExporterModule, SpansTid, Resource, Config) ->
+    ExporterModule:export(traces, SpansTid, Resource, Config).
+
+export_metrics(ExporterModule, MetricsTid, Resource, Config) ->
+    ExporterModule:export(metrics, MetricsTid, Resource, Config).
+
+export_logs(ExporterModule, Batch, Resource, Config) ->
+    ExporterModule:export(logs, Batch, Resource, Config).
+
+shutdown(undefined) ->
+    ok;
+shutdown({ExporterModule, Config}) ->
+    ExporterModule:shutdown(Config).
+
+report_cb(#{source := exporter,
+            during := init,
+            kind := Kind,
+            reason := Reason,
+            exporter := opentelemetry_exporter,
+            stacktrace := StackTrace}) ->
+    {"OTLP exporter failed to initialize: ~ts",
+     [otel_utils:format_exception(Kind, Reason, StackTrace)]};
+report_cb(#{source := exporter,
+            during := init,
+            kind := Kind,
+            reason := Reason,
+            exporter := ExporterModule,
+            stacktrace := StackTrace}) ->
+    {"Exporter ~tp failed to initialize: ~ts",
+     [ExporterModule, otel_utils:format_exception(Kind, Reason, StackTrace)]};
+report_cb(#{source := exporter,
+            during := init,
+            kind := Kind,
+            reason := Reason,
+            exporter := opentelemetry_exporter}) ->
+    {"OTLP exporter failed to initialize with exception ~tp:~tp", [Kind, Reason]};
+report_cb(#{source := exporter,
+            during := init,
+            kind := Kind,
+            reason := Reason,
+            exporter := ExporterModule}) ->
+    {"Exporter ~p failed to initialize with exception ~tp:~tp", [ExporterModule, Kind, Reason]}.

apps/opentelemetry/src/otel_exporter_pid.erl

@@ -12,12 +12,12 @@
 %% See the License for the specific language governing permissions and
 %% limitations under the License.
 %%
-%% @doc A test reporter for sending trace spans to an Erlang PID as message.
+%% @doc A test exporter for sending trace spans to an Erlang PID as message.
 %% @end
 %%%-----------------------------------------------------------------------
--module(ot_exporter_pid).
+-module(otel_exporter_pid).
 
--behaviour(ot_exporter).
+-behaviour(otel_exporter_traces).
 
 -export([init/1,
          export/3,

apps/opentelemetry/src/otel_exporter_stdout.erl

@@ -12,12 +12,12 @@
 %% See the License for the specific language governing permissions and
 %% limitations under the License.
 %%
-%% @doc Reporter that prints spans to stdout.
+%% @doc Exporter that prints spans to stdout.
 %% @end
 %%%-----------------------------------------------------------------------
--module(ot_exporter_stdout).
+-module(otel_exporter_stdout).
 
--behaviour(ot_exporter).
+-behaviour(otel_exporter_traces).
 
 -export([init/1,
          export/3,

apps/opentelemetry/src/otel_exporter_tab.erl

@@ -15,9 +15,9 @@
 %% @doc A test reporter that keeps finished spans in an ETS table.
 %% @end
 %%%-----------------------------------------------------------------------
--module(ot_exporter_tab).
+-module(otel_exporter_tab).
 
--behaviour(ot_exporter).
+-behaviour(otel_exporter_traces).
 
 -export([init/1,
          export/3,

apps/opentelemetry/src/otel_exporter_traces.erl

@@ -15,7 +15,11 @@
 %% @doc
 %% @end
 %%%-----------------------------------------------------------------------
--module(ot_exporter).
+-module(otel_exporter_traces).
+
+-export([init/1,
+         export/3,
+         shutdown/1]).
 
 %% Do any initialization of the exporter here and return configuration
 %% that will be passed along with a list of spans to the `export' function.
@@ -25,8 +29,17 @@
 %% spans that have been collected so far and the configuration returned in `init'.
 %% Do whatever needs to be done to export each span here, the caller will block
 %% until it returns.
--callback export(ets:tab(), ot_resource:t(), term()) -> ok |
-                                                        success |
-                                                        failed_not_retryable |
-                                                        failed_retryable.
+-callback export(ets:tab(), otel_resource:t(), term()) -> ok |
+                                                          success |
+                                                          failed_not_retryable |
+                                                          failed_retryable.
 -callback shutdown(term()) -> ok.
+
+init(Opts) ->
+    otel_exporter:init(Opts).
+
+export({ExporterModule, Config}, SpansTid, Resource) ->
+    ExporterModule:export(SpansTid, Resource, Config).
+
+shutdown(Exporter) ->
+    otel_exporter:shutdown(Exporter).

apps/opentelemetry/src/otel_id_generator.erl

@@ -0,0 +1,56 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2021, 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.
+%%
+%% @doc This module provides the behaviour to implement for custom trace
+%% and span id generation and the default implementation of the
+%% generators which produces random 128 bit and 64 bit integers for the
+%% trace id and span id.
+%% @end
+%%%-----------------------------------------------------------------------
+-module(otel_id_generator).
+
+-export([generate_trace_id/0,
+         generate_trace_id/1,
+         generate_span_id/0,
+         generate_span_id/1]).
+
+-callback generate_trace_id() -> opentelemetry:trace_id().
+
+-callback generate_span_id() -> opentelemetry:span_id().
+
+-type t() :: module().
+
+-export_type([t/0]).
+
+-include_lib("opentelemetry_api/include/gradualizer.hrl").
+
+%% @doc Calls a module implementing the `otel_id_generator' behaviour to generate a trace id
+-spec generate_trace_id(t()) -> opentelemetry:trace_id().
+generate_trace_id(Module) ->
+    Module:generate_trace_id().
+
+%% @doc Calls a module implementing the `otel_id_generator' behaviour to generate a span id
+-spec generate_span_id(t()) -> opentelemetry:span_id().
+generate_span_id(Module) ->
+    Module:generate_span_id().
+
+%% @doc Generates a 128 bit random integer to use as a trace id.
+-spec generate_trace_id() -> opentelemetry:trace_id().
+generate_trace_id() ->
+    rand:uniform(?assert_type(2 bsl 127 - 1, pos_integer())). %% 2 shifted left by 127 == 2 ^ 128
+
+%% @doc Generates a 64 bit random integer to use as a span id.
+-spec generate_span_id() -> opentelemetry:span_id().
+generate_span_id() ->
+    rand:uniform(?assert_type(2 bsl 63 - 1, pos_integer())). %% 2 shifted left by 63 == 2 ^ 64

apps/opentelemetry/src/otel_links.erl

@@ -0,0 +1,104 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2021, 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.
+%%
+%% @doc
+%% @end
+%%%-------------------------------------------------------------------------
+-module(otel_links).
+
+-export([new/4,
+         list/1,
+         dropped/1]).
+
+-include_lib("opentelemetry_api/include/opentelemetry.hrl").
+-include("otel_span.hrl").
+
+-record(links, {
+                count_limit :: integer(),
+                attribute_per_link_limit :: integer(),
+                attribute_value_length_limit :: integer() | infinity,
+                dropped :: integer(),
+                list :: [#link{}]
+               }).
+
+-type t() :: #links{}.
+
+-export_type([t/0]).
+
+new(List, LinkCountLimit, AttributePerLinkLimit, AttributeValueLengthLimit) ->
+    {Links, Dropped} = create_links(List, LinkCountLimit, AttributePerLinkLimit, AttributeValueLengthLimit),
+    #links{count_limit=LinkCountLimit,
+           attribute_per_link_limit=AttributePerLinkLimit,
+           attribute_value_length_limit=AttributeValueLengthLimit,
+           dropped=Dropped,
+           list=Links}.
+
+list(#links{list=List}) ->
+    List.
+
+dropped(#links{dropped=Dropped}) ->
+    Dropped.
+%%
+
+create_links(List, LinkCountLimit, AttributePerLinkLimit, AttributeValueLengthLimit) ->
+    create_links(List, LinkCountLimit, AttributePerLinkLimit, AttributeValueLengthLimit, 0, []).
+
+create_links([], _, _, _AttributeValueLengthLimit, Dropped, Links) ->
+    {Links, Dropped};
+create_links(List, 0, _, _, Dropped, Links) ->
+    {Links, Dropped + length(List)};
+create_links([L | Rest], Limit, AttributePerLinkLimit, AttributeValueLengthLimit, Dropped, List) ->
+    case new_link(L, AttributePerLinkLimit, AttributeValueLengthLimit) of
+        drop ->
+            create_links(Rest, Limit, AttributePerLinkLimit, AttributeValueLengthLimit, Dropped + 1, List);
+        Link ->
+            create_links(Rest, Limit - 1, AttributePerLinkLimit, AttributeValueLengthLimit, Dropped, [Link | List])
+    end.
+
+%%
+
+new_link({TraceId, SpanId, Attributes, TraceState}, AttributePerLinkLimit, AttributeValueLengthLimit)
+  when is_integer(TraceId),
+       is_integer(SpanId),
+       (is_list(Attributes) orelse is_map(Attributes)) ->
+    #link{trace_id=TraceId,
+          span_id=SpanId,
+          tracestate=TraceState,
+          attributes=otel_attributes:new(Attributes, AttributePerLinkLimit, AttributeValueLengthLimit)};
+new_link(Link=#link{}, _AttributePerLinkLimit, _AttributeValueLengthLimit) ->
+    Link;
+new_link(#{trace_id := TraceId,
+           span_id := SpanId,
+           tracestate := TraceState,
+           attributes := Attributes}, AttributePerLinkLimit, AttributeValueLengthLimit) ->
+    #link{trace_id=TraceId,
+          span_id=SpanId,
+          tracestate=TraceState,
+          attributes=otel_attributes:new(Attributes, AttributePerLinkLimit, AttributeValueLengthLimit)};
+new_link({#span_ctx{trace_id=TraceId,
+                    span_id=SpanId,
+                    tracestate=TraceState}, Attributes}, AttributePerLinkLimit, AttributeValueLengthLimit) ->
+    #link{trace_id=TraceId,
+          span_id=SpanId,
+          tracestate=TraceState,
+          attributes=otel_attributes:new(Attributes, AttributePerLinkLimit, AttributeValueLengthLimit)};
+new_link(#span_ctx{trace_id=TraceId,
+                   span_id=SpanId,
+                   tracestate=TraceState}, AttributePerLinkLimit, AttributeValueLengthLimit) ->
+    #link{trace_id=TraceId,
+          span_id=SpanId,
+          tracestate=TraceState,
+          attributes=otel_attributes:new([], AttributePerLinkLimit, AttributeValueLengthLimit)};
+new_link(_, _, _) ->
+    drop.

apps/opentelemetry/src/otel_resource.erl

@@ -0,0 +1,201 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @doc A Resource is attributes representing the entity producing
+%% telemetry. For example, by default the language (Erlang), name of this
+%% library (`opentelemetry'), and version of this library are included in
+%% the Resource.
+%%
+%% This module provides the functional interface for working with the
+%% resource record.
+%%
+%% The `opentelemetry' library supports <i>resource detectors</i> to
+%% detect attributes to include in the Resource. See {@link otel_resource_detector}
+%% for the behaviour to detect resources, and the {@link otel_resource_app_env}
+%% and {@link otel_resource_env_var} modules for built-in implementations.
+%%
+%% See the <a href="https://opentelemetry.io/docs/concepts/resources/">
+%% OpenTelemetry Resource documentation</a> for more information on Resources.
+%% @end
+%%%-----------------------------------------------------------------------
+-module(otel_resource).
+
+-export([create/1,
+         create/2,
+         merge/2,
+         schema_url/1,
+         attributes/1,
+         is_key/2]).
+
+-type key() :: unicode:latin1_binary() | atom().
+%% values allowed in attributes of a resource are limited
+
+-type value() :: unicode:latin1_binary() | integer() | float() | boolean().
+%% A resource value.
+
+-type schema_url() :: uri_string:uri_string().
+%% A schema URL for the resource.
+
+-define(MAX_LENGTH, 255).
+
+-record(resource, {schema_url :: schema_url() | undefined,
+                   attributes :: otel_attributes:t()}).
+
+-type t() :: #resource{} | undefined.
+%% The type that represents a resource.
+
+-export_type([t/0]).
+
+%% @equiv create(Attributes, undefined)
+-spec create(#{key() => value()} | [{key(), value()}]) -> t().
+create(Attributes) ->
+    create(Attributes, undefined).
+
+%% @doc Creates a new resources from the given map or list of `Attributes' and
+%% with the given `SchemaUrl'.
+%%
+%%
+%% This function verifies each key and value, and drops any that don't pass verification.
+-spec create(#{key() => value()} | [{key(), value()}], schema_url() | undefined) -> t().
+create(Map, SchemaUrl) when is_map(Map) ->
+    create(maps:to_list(Map), SchemaUrl);
+create(List, SchemaUrl) when is_list(List) ->
+    List1 = lists:filtermap(fun({K, V}) ->
+                                    %% TODO: log an info or debug message when dropping?
+                                    case try_check_key(K, true) of
+                                        {true, Key} ->
+                                            case check_value(V) of
+                                                {true, Value} ->
+                                                    {true, {Key, Value}};
+                                                _ ->
+                                                    false
+                                            end;
+                                        _ ->
+                                            false
+                                    end
+                            end, lists:ukeysort(1, List)),
+    #resource{schema_url=SchemaUrl,
+              attributes=otel_attributes:new(List1, 128, 255)}.
+
+%% @doc Returns the schema URL of the resource.
+-spec schema_url(t()) -> schema_url() | undefined.
+schema_url(#resource{schema_url=Schema}) ->
+    Schema;
+schema_url(_) ->
+    undefined.
+
+%% @doc Returns the attributes of the given `Resource'.
+%%
+%% This function returns `undefined' only in case `Resource' is an invalid argument
+%% (not a resource record).
+-spec attributes(t()) -> otel_attributes:t() | undefined.
+attributes(#resource{attributes=Attributes}) ->
+    Attributes;
+attributes(_) ->
+    undefined.
+
+%% @doc Returns `true' if `Key' is valid and part of the given resource.
+-spec is_key(key(), t()) -> boolean().
+is_key(K, #resource{attributes=Attributes}) ->
+    case try_check_key(K, false) of
+        {true, Key} ->
+            maps:is_key(Key, otel_attributes:map(Attributes));
+        _ ->
+            false
+    end;
+is_key(_, _) ->
+    false.
+
+%% @doc Merges the two given resources.
+%%
+%% In case of collision, the first argument (`Resource') takes precedence.
+-spec merge(t(), t()) -> t().
+merge(#resource{schema_url=NewSchemaUrl,
+                attributes=NewAttributes}, CurrentResource=#resource{schema_url=CurrentSchemaUrl,
+                                                             attributes=CurrentAttributes}) ->
+    SchameUrl = merge_schema_url(NewSchemaUrl, CurrentSchemaUrl),
+    NewMap = otel_attributes:map(NewAttributes),
+    CurrentResource#resource{schema_url=SchameUrl,
+                     attributes=otel_attributes:set(NewMap, CurrentAttributes)}.
+
+%%
+
+%% when merging resources the schemas are checked to verify they match.
+%% if they do match then the schema is set to `undefined' and the attributes are kept.
+merge_schema_url(SchemaUrl, undefined) ->
+    SchemaUrl;
+merge_schema_url(undefined, SchemaUrl) ->
+    SchemaUrl;
+merge_schema_url(NewSchemaUrl, CurrentSchemaUrl) ->
+    merge_schema_url_(uri_string:normalize(NewSchemaUrl), uri_string:normalize(CurrentSchemaUrl)).
+
+merge_schema_url_(SchemaUrl, SchemaUrl) ->
+    SchemaUrl;
+merge_schema_url_(_, _) ->
+    undefined.
+
+%% a resource key must be a non-empty latin1 string or atom, stored as atom
+try_check_key(K, UnconditionalBinaryToAtom) ->
+    try check_key(K, UnconditionalBinaryToAtom)
+    catch error:badarg -> false
+    end.
+
+check_key(<<>>, _) ->
+    false;
+check_key(K, UnconditionalBinaryToAtom) when is_binary(K) ->
+    case check_string_value(K) of
+        {true, Key} when UnconditionalBinaryToAtom ->
+            {true, binary_to_atom(Key, latin1)};
+        {true, Key} ->
+            {true, binary_to_existing_atom(Key, latin1)};
+        false ->
+            false
+    end;
+check_key(K, UnconditionalBinaryToAtom) when is_list(K) ->
+    check_key(list_to_binary(K), UnconditionalBinaryToAtom);
+check_key(K, _) when is_atom(K) ->
+    % Atoms have an length upper limit of 255 utf8 codepoints, so the
+    % latin1 representation, if it exists, shares that limit
+    _ = atom_to_binary(K, latin1),
+    {true, K};
+check_key(_, _) ->
+    false.
+
+%% a resource value can be a latin1 string, integer, float or boolean
+check_value(V) when is_integer(V) ;
+                    is_float(V) ;
+                    is_boolean(V) ->
+    {true, V};
+check_value(V) when is_binary(V) ->
+    check_string_value(V);
+check_value(V) when is_list(V) ->
+    try unicode:characters_to_binary(V) of
+        B ->
+            check_string_value(B)
+    catch
+        error:badarg ->
+            %% must be an array attribute value
+            {true, V}
+    end;
+check_value(_) ->
+    false.
+
+check_string_value(V) ->
+    %% all resource strings, key or value, must be latin1 with length less than 255
+    case string:length(V) =< ?MAX_LENGTH of
+        true ->
+            {true, V};
+        false ->
+            false
+    end.

apps/opentelemetry/src/otel_resource_app_env.erl

@@ -0,0 +1,88 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2020, 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.
+%%
+%% @doc Resource detector ({@link otel_resource_detector}) which adds attributes
+%% to the `Resource' based on the value of `resource'
+%% in the `opentelemetry' application's environment.
+%%
+%% For example, if the `opentelemetry' application environment has the following
+%% configuration under the `resource' key:
+%%
+%% ```
+%% [{service, #{name => "myservice",
+%%              namespace => "mynamespace"}}]
+%% '''
+%%
+%% then it results in the `Resource' attributes `service.name' and `service.namespace'
+%% set to `myservice' and `mynamespace"}}]' respectively.
+%%
+%% This detector is on by default (see the default configuration for `resource_detectors' in the
+%% `opentelemetry' application environment).
+%% @end
+%%%-----------------------------------------------------------------------
+-module(otel_resource_app_env).
+
+-behaviour(otel_resource_detector).
+
+-export([get_resource/1,
+         parse/1]).
+
+%% @private
+get_resource(_Config) ->
+    Attributes = parse(application:get_env(opentelemetry, resource, #{})),
+    otel_resource:create(Attributes).
+
+%%
+
+%% @private
+parse(Attributes) when is_map(Attributes) ->
+    parse(maps:to_list(Attributes));
+parse(Attributes) when is_list(Attributes) ->
+    lists:flatmap(fun({Key, Values}) when is_list(Key) ; is_binary(Key) ; is_atom(Key) ->
+                          parse_values(to_string(Key), Values);
+                     (_) ->
+                          %% ignore anything else
+                          []
+                  end, Attributes);
+parse(_) ->
+    %% must be a map or list. ignore and return empty if it isn't
+    [].
+
+parse_values(Key, Values) when is_map(Values) ->
+    parse_values(Key, maps:to_list(Values));
+parse_values(Key, Values) when is_list(Values) ->
+    case io_lib:printable_unicode_list(Values) of
+        true ->
+            [{unicode:characters_to_binary(Key), unicode:characters_to_binary(Values)}];
+        false ->
+            lists:flatmap(fun({SubKey, Value=[{_,_}|_]}) ->
+                                  %% list of tuples means we have more subkeys
+                                  parse_values([Key, ".", to_string(SubKey)], Value);
+                             ({SubKey, Value}) when is_map(Value) ->
+                                  %% map value means we have more subkeys
+                                  parse_values([Key, ".", to_string(SubKey)], Value);
+                             ({SubKey, Value})->
+                                  [{otel_utils:assert_to_binary([Key, ".", to_string(SubKey)]), Value}]
+                          end, Values)
+    end;
+parse_values(Key, Value) ->
+    [{unicode:characters_to_binary(Key), Value}].
+
+-spec to_string(atom() | binary() | list()) -> binary().
+to_string(K) when is_atom(K) ->
+    atom_to_binary(K, utf8);
+to_string(K) when is_list(K) ->
+    otel_utils:assert_to_binary(K);
+to_string(K) when is_binary(K) ->
+    K.

apps/opentelemetry/src/otel_resource_detector.erl

@@ -0,0 +1,317 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2020, 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.
+%%
+%% @doc Resource detectors are responsible for reading in attributes about
+%% the runtime environment of a node (such as an environment variable or
+%% some metadata endpoint provided by a cloud host) and returning a
+%% {@link otel_resource:t()} made from those attributes.
+%%
+%% This module is meant for users who intend to write their own resource
+%% detectors.
+%%
+%% This behaviour is a state machine (started by the `opentelemetry' application)
+%%  which spawns a process for each detector, collects the
+%% results of running each, and merges them in the order they are defined. Once the
+%% state machine process is ready, it will reply to {@link get_resource/1}
+%% calls with the final {@link otel_resource:t()}.
+%% @end
+%%%-------------------------------------------------------------------------
+-module(otel_resource_detector).
+
+-behaviour(gen_statem).
+
+-export([start_link/1,
+         get_resource/0,
+         get_resource/1]).
+
+-export([init/1,
+         callback_mode/0,
+         handle_event/4]).
+
+-callback get_resource(term()) -> otel_resource:t().
+%% Function that takes the configuration of a resource detector 
+%% and returns a resource.
+
+-type detector() :: module() | {module(), term()}.
+
+-include_lib("kernel/include/logger.hrl").
+
+-record(data, {resource         :: otel_resource:t(),
+               detectors        :: [detector()],
+               detector_timeout :: integer()}).
+
+%% @private
+-spec start_link(Config) -> {ok, pid()} | ignore | {error, term()} when
+              Config :: #{resource_detectors := [module()],
+                          resource_detector_timeout := integer()}.
+start_link(Config) ->
+    gen_statem:start_link({local, ?MODULE}, ?MODULE, [Config], []).
+
+%% @equiv get_resource(6000)
+-spec get_resource() -> otel_resource:t().
+get_resource() ->
+    get_resource(6000).
+
+%% @doc Gets the resource formed by detecting attributes through resource
+%% detectors.
+%%
+%% If the call doesn't complete within the given `Timeout' then an empty
+%% resource is returned.
+-spec get_resource(timeout()) -> otel_resource:t().
+get_resource(Timeout) ->
+    try gen_statem:call(?MODULE, get_resource, Timeout)
+    catch
+        _:_ ->
+            %% TODO: should we return an error instead?
+            %% returning an empty resource ensures we continue on and
+            %% don't crash anything depending on the returned resource
+            %% but could mean we have an empty resource while the
+            %% gen_server later has a full resourced
+            otel_resource:create([])
+    end.
+
+%% @private
+init([#{resource_detectors := Detectors,
+        resource_detector_timeout := DetectorTimeout}]) ->
+    process_flag(trap_exit, true),
+
+    {ok, collecting, #data{resource=otel_resource:create([]),
+                           detectors=Detectors,
+                           detector_timeout=DetectorTimeout},
+     [{next_event, internal, spawn_detectors}]}.
+
+%% @private
+callback_mode() ->
+    [handle_event_function, state_enter].
+
+%% @private
+handle_event(enter, _, ready, Data=#data{resource=Resource}) ->
+    NewResource = default_resource_attributes(Resource),
+    {keep_state, Data#data{resource=NewResource}};
+handle_event(enter, _, _, _) ->
+    keep_state_and_data;
+handle_event(internal, spawn_detectors, collecting, Data=#data{detectors=Detectors}) ->
+    %% merging must be done in a specific order so Refs are kept in a list
+    ToCollectRefs = spawn_detectors(Detectors),
+    {next_state, next_state(ToCollectRefs), Data, [state_timeout(Data)]};
+handle_event(info, {'EXIT', Pid, _}, {collecting, [{_, Pid, Detector} | Rest]}, Data) ->
+    ?LOG_WARNING("detector ~p crashed while executing", [Detector]),
+    {next_state, next_state(Rest), Data, [state_timeout(Data)]};
+
+handle_event(info, {resource, Ref, Resource}, {collecting, [{Ref, _, _} | Rest]},
+             Data=#data{resource=CurrentResource}) ->
+    NewResource = otel_resource:merge(Resource, CurrentResource),
+    {next_state, next_state(Rest), Data#data{resource=NewResource}, state_timeout(Data)};
+handle_event(state_timeout, resource_detector_timeout, {collecting, [{_, Pid, Detector} | Rest]}, Data) ->
+    ?LOG_WARNING("detector ~p timed out while executing", [Detector]),
+    %% may still have an EXIT in the mailbox but with `unlink' we might not
+    erlang:unlink(Pid),
+    erlang:exit(Pid, kill),
+    {next_state, next_state(Rest), Data, state_timeout(Data)};
+handle_event(info, _, _, _Data) ->
+    %% merging resources must be done in order, so postpone the message
+    %% if it isn't the head of the list
+    {keep_state_and_data, [postpone]};
+
+handle_event({call, From}, get_resource, ready, #data{resource=Resource}) ->
+    {keep_state_and_data, [{reply, From, Resource}]};
+handle_event({call, _From}, get_resource, _, _Data) ->
+    %% can't get the resource until all detectors have completed
+    %% at which point this statem will be in the `ready' state
+    {keep_state_and_data, [postpone]};
+handle_event(_, _, ready, _) ->
+    %% if in `ready' state get rid of all the postpones messages in
+    %% the mailbox that were postponed. Could be EXIT's or late resource
+    %% messages
+    keep_state_and_data.
+
+%%
+
+%% go to the `ready' state if the list of detectors to collect for is empty
+next_state([]) ->
+    ready;
+next_state(List) ->
+    {collecting, List}.
+
+state_timeout(#data{detector_timeout=DetectorTimeout}) ->
+    {state_timeout, DetectorTimeout, resource_detector_timeout}.
+
+spawn_detectors(Detectors) ->
+    lists:map(fun(Detector) ->
+                      Ref = erlang:make_ref(),
+                      Pid = spawn_detector(Detector, Ref),
+                      {Ref, Pid, Detector}
+              end, Detectors).
+
+spawn_detector(Detector={Module, Config}, Ref) ->
+    Self = self(),
+    erlang:spawn_link(fun() ->
+                              try Module:get_resource(Config) of
+                                  Resource ->
+                                      Self ! {resource, Ref, Resource}
+                              catch
+                                  C:T:S ->
+                                      ?LOG_WARNING("caught exception while detector ~p was "
+                                                   "executing: class=~p exception=~p stacktrace=~p",
+                                                   [Detector, C, T, S]),
+                                      %% TODO: log about detector's exception
+                                      Self ! {resource, Ref, otel_resource:create([])}
+                              end
+                      end);
+spawn_detector(Module, Ref) ->
+    spawn_detector({Module, []}, Ref).
+
+default_resource_attributes(Resource) ->
+    ProgName = prog_name(),
+    ProcessResource = otel_resource:create([{'process.executable.name', ProgName} | process_attributes()]),
+    Resource1 = otel_resource:merge(ProcessResource, Resource),
+    Resource2 = add_service_name(Resource1, ProgName),
+    Resource3 = add_service_instance(Resource2),
+    add_telemetry_info(Resource3).
+
+process_attributes() ->
+    OtpVsn = otp_vsn(),
+    ErtsVsn = erts_vsn(),
+    [{'process.runtime.name', unicode:characters_to_binary(emulator())},
+     {'process.runtime.version', unicode:characters_to_binary(ErtsVsn)},
+     {'process.runtime.description', unicode:characters_to_binary(runtime_description(OtpVsn, ErtsVsn))}].
+
+runtime_description(OtpVsn, ErtsVsn) ->
+    io_lib:format("Erlang/OTP ~s erts-~s", [OtpVsn, ErtsVsn]).
+
+erts_vsn() ->
+    erlang:system_info(version).
+
+otp_vsn() ->
+    erlang:system_info(otp_release).
+
+emulator() ->
+    erlang:system_info(machine).
+
+prog_name() ->
+    %% RELEASE_PROG is set by mix and rebar3 release scripts
+    %% PROGNAME is an OS variable set by `erl' and rebar3 release scripts
+    unicode:characters_to_binary(os_or_default("RELEASE_PROG", os_or_default("PROGNAME", <<"erl">>))).
+
+os_or_default(EnvVar, Default) ->
+    case os:getenv(EnvVar) of
+        false ->
+            Default;
+        Value ->
+            Value
+    end.
+
+-dialyzer({nowarn_function, find_release/0}).
+find_release() ->
+    try release_handler:which_releases(permanent) of
+        [{RelName, RelVsn, _Apps, permanent} | _] ->
+            {RelName, RelVsn}
+    catch
+        %% can happen if `release_handler' isn't available
+        %% or its process isn't started
+        _:_ ->
+            {release_name(), os:getenv("RELEASE_VSN")}
+    end.
+
+release_name() ->
+    case os:getenv("RELEASE_NAME") of
+        false ->
+            %% older relx generated releases only set and export this variable
+            os:getenv("REL_NAME");
+        RelName ->
+            RelName
+    end.
+
+%% if OTEL_SERVICE_NAME isn't set then check for service.name in attributes
+%% if that isn't found then try finding the release name
+%% if no release name we use the default service name
+add_service_name(Resource, ProgName) ->
+    case os:getenv("OTEL_SERVICE_NAME") of
+        false ->
+            case otel_resource:is_key('service.name', Resource) of
+                false ->
+                    ServiceResource = service_release_name(ProgName),
+                    otel_resource:merge(ServiceResource, Resource);
+                true ->
+                    Resource
+            end;
+        ServiceName ->
+            %% service.name resource first to override any other service.name
+            %% attribute that could be set in the resource
+            case unicode:characters_to_binary(ServiceName) of
+                {_, _, _} ->
+                    ?LOG_WARNING("error converting service name ~s to utf8. falling back on the release name for service.name resource attributes", [ServiceName]),
+                    ServiceResource = service_release_name(ProgName),
+                    otel_resource:merge(ServiceResource, Resource);
+                BinaryString ->
+                    ServiceNameResource = otel_resource:create([{'service.name', BinaryString}]),
+                    otel_resource:merge(ServiceNameResource, Resource)
+            end
+    end.
+
+%% if OTEL_SERVICE_INSTANCE isn't set then check for service.name in attributes
+%% if that isn't found then try getting node.
+%% if node is nonode@nohost set a random instance id
+add_service_instance(Resource) ->
+    case os:getenv("OTEL_SERVICE_INSTANCE") of
+        false ->
+            case otel_resource:is_key('service.instance.id', Resource) of
+                false ->
+                    case erlang:node() of
+                        nonode@nohost ->
+                            ServiceInstanceId = otel_id_generator:generate_trace_id(),
+                            ServiceInstanceResource = otel_resource:create([{'service.instance.id', ServiceInstanceId}]),
+                            otel_resource:merge(ServiceInstanceResource, Resource);
+                        ServiceInstance ->
+                            ServiceInstance1 = erlang:atom_to_binary(ServiceInstance, utf8),
+                            case binary:match(ServiceInstance1, <<"@localhost">>) of
+                                nomatch ->
+                                    ServiceInstanceResource = otel_resource:create([{'service.instance.id', ServiceInstance1}]),
+                                    otel_resource:merge(ServiceInstanceResource, Resource);
+                                _Match ->
+                                    ServiceInstanceId = otel_id_generator:generate_trace_id(),
+                                    ServiceInstanceResource = otel_resource:create([{'service.instance.id', ServiceInstanceId}]),
+                                    otel_resource:merge(ServiceInstanceResource, Resource)
+                            end
+                    end;
+                true ->
+                    Resource
+            end;
+        ServiceInstance ->
+            ServiceInstanceResource = otel_resource:create([{'service.instance.id',
+                                                             otel_utils:assert_to_binary(ServiceInstance)}]),
+            otel_resource:merge(ServiceInstanceResource, Resource)
+    end.
+
+service_release_name(ProgName) ->
+    case find_release() of
+        {RelName, RelVsn} when RelName =/= false ->
+            otel_resource:create([{'service.name', RelName} |
+                                  case RelVsn of
+                                      false -> [];
+                                      _ -> [{'service.version', RelVsn}]
+                                  end]);
+        _ ->
+            otel_resource:create([{'service.name', <<"unknown_service:", ProgName/binary>>}])
+    end.
+
+add_telemetry_info(Resource) ->
+    {ok, LibraryVsn} = application:get_key(opentelemetry, vsn),
+    LibraryName = <<"opentelemetry">>,
+    LibraryLanguage = <<"erlang">>,
+    ResourceAttributes = [{'telemetry.sdk.name', LibraryName},
+                          {'telemetry.sdk.language', LibraryLanguage},
+                          {'telemetry.sdk.version', LibraryVsn}],
+    TelemetryInfoResource = otel_resource:create(ResourceAttributes),
+    otel_resource:merge(TelemetryInfoResource, Resource).

apps/opentelemetry/src/otel_resource_env_var.erl

@@ -12,24 +12,35 @@
 %% See the License for the specific language governing permissions and
 %% limitations under the License.
 %%
-%% @doc
+%% @doc Resource detector ({@link otel_resource_detector}) which adds attributes
+%% to the `Resource' based on environment variables.
 %%
+%% This resource detector reads the `OTEL_RESOURCE_ATTRIBUTES' environment
+%% variable and parses it as a comma-separated list of key-value pairs. For
+% example, `key1=val1,key2=val2'.
+%%
+%% This detector is on by default (see the default configuration for `resource_detectors' in the
+%% `opentelemetry' application environment).
 %% @end
 %%%-----------------------------------------------------------------------
--module(ot_resource_env_var).
+-module(otel_resource_env_var).
 
--export([get_resource/0,
+-behaviour(otel_resource_detector).
+
+-export([get_resource/1,
          parse/1]).
 
--define(OS_ENV, "OTEL_RESOURCE_LABELS").
+-define(OS_ENV, "OTEL_RESOURCE_ATTRIBUTES").
 -define(LABEL_LIST_SPLITTER, ",").
 -define(LABEL_KEY_VALUE_SPLITTER, "=").
 
-get_resource() ->
-    ot_resource:create(parse(os:getenv(?OS_ENV))).
+%% @private
+get_resource(_Config) ->
+    otel_resource:create(parse(os:getenv(?OS_ENV))).
 
 %%
 
+%% @private
 -spec parse(false | string()) -> list().
 parse(false) ->
     [];

apps/opentelemetry/src/otel_sampler.erl

@@ -0,0 +1,140 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @doc Behaviour for defining samplers.
+%%
+%% A sampler should provide a function run on each started span that returns whether to
+%% record and propagate, only record, or not record the span.
+%%
+%% For more information on the concept of <i>Sampling</i>, see
+%% <a href="https://opentelemetry.io/docs/concepts/sampling/">Sampling in the OpenTelemetry
+%% documentation</a> or the
+%% <a href="https://opentelemetry.io/docs/specs/otel/trace/sdk/#sampling">Sampling spec</a>.
+%% For examples of configuring samplers or implementing your own sampler,
+%% see <a href="https://opentelemetry.io/docs/languages/erlang/sampling/">the OpenTelemetry
+%% Erlang documentation</a>.
+%%
+%% <h3>Configuration</h3>
+%%
+%% To configure sampling for the `opentelemetry' application, see
+%% <a href="https://hexdocs.pm/opentelemetry/readme.html#samplers">the documentation</a>.
+%% @end
+%%%-------------------------------------------------------------------------
+-module(otel_sampler).
+
+-export([description/1, new/1, should_sample/7]).
+
+-export_type([description/0,
+              sampler_spec/0,
+              sampler_config/0,
+              sampler_opts/0,
+              sampling_decision/0,
+              sampling_result/0,
+              t/0]).
+
+-callback setup(sampler_opts()) -> sampler_config().
+%% Called when a sampler is created to set up the sampler.
+%% Should return the sampler configuration that is then passed to other callbacks.
+
+-callback description(sampler_config()) -> description().
+%% Should return the description of the sampler.
+
+-callback should_sample(
+    otel_ctx:t(),
+    opentelemetry:trace_id(),
+    otel_links:t(),
+    opentelemetry:span_name(),
+    opentelemetry:span_kind(),
+    opentelemetry:attributes_map(),
+    sampler_config()
+) -> sampling_result().
+%% Main callback that determines whether a span should be sampled.\
+
+-include("otel_sampler.hrl").
+
+-type description() :: unicode:unicode_binary().
+%% The description of the sampler.
+
+-type sampler_config() :: term().
+%% Any term used to configured a given sampler.
+
+-type sampler_opts() :: term().
+%% Any options passed to a sampler.
+
+-type builtin_sampler() ::
+    always_on
+    | always_off
+    | {trace_id_ratio_based, float()}
+    | {parent_based, #{
+        remote_parent_sampled => sampler_spec(),
+        remote_parent_not_sampled => sampler_spec(),
+        local_parent_sampled => sampler_spec(),
+        local_parent_not_sampled => sampler_spec(),
+        root => sampler_spec()
+    }}.
+%% A built-in sampler.
+
+-type sampler_spec() :: builtin_sampler() | {module(), sampler_opts()}.
+%% Specification to create a sampler.
+
+-type sampling_decision() :: ?DROP | ?RECORD_ONLY | ?RECORD_AND_SAMPLE.
+%% The decision that a sampler can make on a given span.
+
+-type sampling_result() :: {
+                            sampling_decision(),
+                            opentelemetry:attributes_map(),
+                            opentelemetry:tracestate() | otel_tracestate:members()
+                           }.
+%% The result of a sampling decision.
+
+-opaque t() :: {module(), description(), sampler_opts()}.
+%% A sampler.
+
+%% @doc Returns a sampler based on the given specification.
+-spec new(SamplerSpec :: sampler_spec()) -> t().
+new(always_on) ->
+    new({otel_sampler_always_on, #{}});
+new(always_off) ->
+    new({otel_sampler_always_off, #{}});
+new({trace_id_ratio_based, Opts}) ->
+    new({otel_sampler_trace_id_ratio_based, Opts});
+new({parent_based, Opts}) ->
+    new({otel_sampler_parent_based, Opts});
+new({Sampler, Opts}) ->
+    Config = Sampler:setup(Opts),
+    {Sampler, Sampler:description(Config), Config}.
+
+%% @private
+-spec should_sample(
+    t(),
+    otel_ctx:t(),
+    opentelemetry:trace_id(),
+    otel_links:t(),
+    opentelemetry:span_name(),
+    opentelemetry:span_kind(),
+    opentelemetry:attributes_map()
+) -> sampling_result().
+should_sample({Sampler, _, Config}, Ctx, TraceId, Links, SpanName, Kind, Attributes) ->
+    case Sampler:should_sample(Ctx, TraceId, Links, SpanName, Kind, Attributes, Config) of
+        %% to support backwards compatibility with when `tracestate' was just a list, not
+        %% a record, we accept a list and create a new `tracestate'
+        {Decision, Attributes, Tracestate} when is_list(Tracestate) ->
+            {Decision, Attributes, otel_tracestate:new(Tracestate)};
+        Result ->
+            Result
+    end.
+
+%% @doc Returns the description of the given sampler.
+-spec description(t()) -> description().
+description(_Sampler = {_, Description, _}) -> Description.

apps/opentelemetry/src/otel_sampler_always_off.erl

@@ -12,38 +12,29 @@
 %% See the License for the specific language governing permissions and
 %% limitations under the License.
 %%
-%% @doc
+%% @doc An {@link otel_sampler} that drops all spans.
 %%
+%% This is one of the
+%% <a href="https://opentelemetry.io/docs/specs/otel/trace/sdk/#built-in-samplers">built-in
+%% samplers</a> provided by the OpenTelemetry SDK.
 %% @end
 %%%-------------------------------------------------------------------------
--module(ot_metric_exporter).
+-module(otel_sampler_always_off).
 
--behaviour(gen_server).
+-behavior(otel_sampler).
 
--export([start_link/1,
-         export/1]).
-
--export([init/1,
-         handle_call/3,
-         handle_cast/2]).
+-export([description/1, setup/1, should_sample/7]).
 
 -include_lib("opentelemetry_api/include/opentelemetry.hrl").
+-include("otel_sampler.hrl").
 
--record(state, {exporter :: {module(), term()}}).
+%% @private
+setup(_Opts) -> [].
 
-start_link(Opts) ->
-    gen_server:start_link({local, ?MODULE}, ?MODULE, Opts, []).
+%% @private
+description(_) -> <<"AlwaysOffSampler">>.
 
-export(Records) ->
-    {Module, Args} = gen_server:call(?MODULE, exporter),
-    erlang:apply(Module, export, [Records | Args]).
-
-init(Opts) ->
-    Exporter = proplists:get_value(metric_exporter, Opts, {ot_metric_exporter_stdout, []}),
-    {ok, #state{exporter=Exporter}}.
-
-handle_call(exporter, _From, State=#state{exporter=Exporter}) ->
-    {reply, Exporter, State}.
-
-handle_cast(_Msg, State) ->
-    {noreply, State}.
+%% @private
+should_sample(Ctx, _TraceId, _Links, _SpanName, _SpanKind, _Attributes, _Opts) ->
+    SpanCtx = otel_tracer:current_span_ctx(Ctx),
+    {?DROP, [], otel_span:tracestate(SpanCtx)}.

apps/opentelemetry/src/otel_sampler_always_on.erl

@@ -0,0 +1,40 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @doc An {@link otel_sampler} that records and samples all spans.
+%%
+%% This is one of the
+%% <a href="https://opentelemetry.io/docs/specs/otel/trace/sdk/#built-in-samplers">built-in
+%% samplers</a> provided by the OpenTelemetry SDK.
+%% @end
+%%%-------------------------------------------------------------------------
+-module(otel_sampler_always_on).
+
+-behavior(otel_sampler).
+
+-export([description/1, setup/1, should_sample/7]).
+
+-include_lib("opentelemetry_api/include/opentelemetry.hrl").
+-include("otel_sampler.hrl").
+
+%% @private
+setup(_Opts) -> [].
+
+%% @private
+description(_) -> <<"AlwaysOnSampler">>.
+
+%% @private
+should_sample(Ctx, _TraceId, _Links, _SpanName, _SpanKind, _Attributes, _Opts) ->
+    SpanCtx = otel_tracer:current_span_ctx(Ctx),
+    {?RECORD_AND_SAMPLE, [], otel_span:tracestate(SpanCtx)}.

apps/opentelemetry/src/otel_sampler_parent_based.erl

@@ -0,0 +1,115 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @doc An {@link otel_sampler} that makes the decision based on the parent.
+%%
+%% This sampler decides with the following possibilities:
+%% <ol>
+%%   <li>a remote parent that is sampled (by default `always_on');</li>
+%%   <li>a remote parent that is not sampled (by default `always_off');</li>
+%%   <li>a local parent that is sampled (by default `always_on');</li>
+%%   <li>a local parent that is not sampled (by default `always_off');</li>
+%%   <li>no parent (by default `always_on').</li>
+%% </ol>
+%%
+%% For each of these cases a different sampler can be configured.
+%% For options, see {@link opts()}.
+%%
+%% This is one of the
+%% <a href="https://opentelemetry.io/docs/specs/otel/trace/sdk/#built-in-samplers">built-in
+%% samplers</a> provided by the OpenTelemetry SDK.
+%% @end
+%%%-------------------------------------------------------------------------
+-module(otel_sampler_parent_based).
+
+-behavior(otel_sampler).
+
+-export([description/1, setup/1, should_sample/7]).
+
+-export_type([opts/0]).
+
+-include_lib("kernel/include/logger.hrl").
+-include_lib("opentelemetry_api/include/opentelemetry.hrl").
+
+-type opts() :: #{
+    remote_parent_sampled => otel_sampler:sampler_spec(),
+    remote_parent_not_sampled => otel_sampler:sampler_spec(),
+    local_parent_sampled => otel_sampler:sampler_spec(),
+    local_parent_not_sampled => otel_sampler:sampler_spec(),
+    root => otel_sampler:sampler_spec()
+}.
+%% Options to configure this sampler.
+
+%% @private
+setup(Opts = #{root := RootSpec}) ->
+    RemoteParentSampledSampler = sampler_for_spec(remote_parent_sampled, Opts, always_on),
+    RemoteParentNotSampledSampler = sampler_for_spec(remote_parent_not_sampled, Opts, always_off),
+    LocalParentSampledSampler = sampler_for_spec(local_parent_sampled, Opts, always_on),
+    LocalParentNotSampledSampler = sampler_for_spec(local_parent_not_sampled, Opts, always_off),
+    RootSampler = otel_sampler:new(RootSpec),
+    #{
+        root => RootSampler,
+        remote_parent_sampled => RemoteParentSampledSampler,
+        remote_parent_not_sampled => RemoteParentNotSampledSampler,
+        local_parent_sampled => LocalParentSampledSampler,
+        local_parent_not_sampled => LocalParentNotSampledSampler
+    };
+setup(Opts) ->
+    ?LOG_INFO("No sampler spec found for parent_based 'root' option. The 'always_on' sampler will be used for root spans."),
+    setup(Opts#{root => always_on}).
+
+sampler_for_spec(Key, Opts, DefaultModule) ->
+    Spec = maps:get(Key, Opts, DefaultModule),
+    otel_sampler:new(Spec).
+
+%% @private
+description(#{
+    root := RootSampler,
+    remote_parent_sampled := RemoteParentSampler,
+    remote_parent_not_sampled := RemoteParentNotSampler,
+    local_parent_sampled := LocalParentSampler,
+    local_parent_not_sampled := LocalParentNotSampler
+}) ->
+    <<"ParentBased{root:", (otel_sampler:description(RootSampler))/binary, ",remoteParentSampled:",
+        (otel_sampler:description(RemoteParentSampler))/binary, ",remoteParentNotSampled:",
+        (otel_sampler:description(RemoteParentNotSampler))/binary, ",localParentSampled:",
+        (otel_sampler:description(LocalParentSampler))/binary, ",localParentNotSampled:",
+        (otel_sampler:description(LocalParentNotSampler))/binary, "}">>.
+
+%% @private
+should_sample(Ctx, TraceId, Links, SpanName, SpanKind, Attributes, Config) ->
+    ParentSpanCtx = otel_tracer:current_span_ctx(Ctx),
+    SamplerKey = parent_based_sampler(ParentSpanCtx),
+    {Sampler, _Description, SamplerOpts} = maps:get(SamplerKey, Config),
+    Sampler:should_sample(Ctx, TraceId, Links, SpanName, SpanKind, Attributes, SamplerOpts).
+
+%% remote parent sampled
+parent_based_sampler(#span_ctx{trace_flags = TraceFlags, is_remote = true}) when
+    ?IS_SAMPLED(TraceFlags)
+->
+    remote_parent_sampled;
+%% remote parent not sampled
+parent_based_sampler(#span_ctx{is_remote = true}) ->
+    remote_parent_not_sampled;
+%% local parent sampled
+parent_based_sampler(#span_ctx{trace_flags = TraceFlags}) when
+    ?IS_SAMPLED(TraceFlags)
+->
+    local_parent_sampled;
+%% local parent not sampled
+parent_based_sampler(#span_ctx{}) ->
+    local_parent_not_sampled;
+%% root
+parent_based_sampler(_SpanCtx) ->
+    root.

apps/opentelemetry/src/otel_sampler_trace_id_ratio_based.erl

@@ -0,0 +1,80 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @doc An {@link otel_sampler} that samples a configured percentage of spans.
+%%
+%% This sampler samples a configured percentage of spans, where the sampling
+%% decision is <i>deterministic</i> with respect to the span trace ID. That means
+%% the sampler always makes the same decision for the same trace ID.
+%%
+%% This is one of the
+%% <a href="https://opentelemetry.io/docs/specs/otel/trace/sdk/#built-in-samplers">built-in
+%% samplers</a> provided by the OpenTelemetry SDK.
+%% @end
+%%%-------------------------------------------------------------------------
+-module(otel_sampler_trace_id_ratio_based).
+
+-behavior(otel_sampler).
+
+-export([description/1, setup/1, should_sample/7]).
+
+-export_type([config/0, probability/0]).
+
+-include_lib("opentelemetry_api/include/opentelemetry.hrl").
+-include("otel_sampler.hrl").
+
+-type probability() :: float().
+%% A probability on whether to sample a span, between `0.0' and `1.0'.
+
+-type config() :: #{probability := probability(), id_upper_bound := integer()}.
+%% The configuration for this sampler.
+
+%% 2^63 - 1
+-define(MAX_VALUE, 9223372036854775807).
+
+%% @private
+-spec setup(probability()) -> config().
+setup(Probability) ->
+    IdUpperBound =
+        case Probability of
+            P when P == 0.0 ->
+                0;
+            P when P =:= 1.0 ->
+                ?MAX_VALUE;
+            P when P >= 0.0 andalso P =< 1.0 ->
+                P * ?MAX_VALUE
+        end,
+    #{probability => Probability, id_upper_bound => IdUpperBound}.
+
+%% @private
+description(#{probability := Probability}) ->
+    unicode:characters_to_binary(io_lib:format("TraceIdRatioBased{~.6f}", [Probability])).
+
+%% @private
+should_sample(Ctx, TraceId, _Links, _SpanName, _SpanKind, _Attributes, #{
+    id_upper_bound := IdUpperBound
+}) ->
+    SpanCtx = otel_tracer:current_span_ctx(Ctx),
+    {decide(TraceId, IdUpperBound), [], otel_span:tracestate(SpanCtx)}.
+
+decide(undefined, _IdUpperBound) ->
+    ?DROP;
+decide(0, _IdUpperBound) ->
+    ?DROP;
+decide(TraceId, IdUpperBound) ->
+    Lower64Bits = TraceId band ?MAX_VALUE,
+    case erlang:abs(Lower64Bits) < IdUpperBound of
+        true -> ?RECORD_AND_SAMPLE;
+        false -> ?DROP
+    end.

apps/opentelemetry/src/otel_simple_processor.erl

@@ -0,0 +1,269 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2021, 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.
+%%
+%% @doc This Span Processor synchronously exports each ended Span.
+%%
+%% Use this processor if ending a Span should block until it has been
+%% exported. This is useful for cases like a serverless environment where
+%% the application will possibly be suspended after handling a request.
+%%
+%% @end
+%%%-----------------------------------------------------------------------
+-module(otel_simple_processor).
+
+-behaviour(gen_statem).
+-behaviour(otel_span_processor).
+
+-export([start_link/1,
+         on_start/3,
+         on_end/2,
+         force_flush/1,
+         report_cb/1,
+
+         %% deprecated
+         set_exporter/1,
+         set_exporter/2,
+         set_exporter/3]).
+
+-export([init/1,
+         callback_mode/0,
+         idle/3,
+         exporting/3,
+         terminate/3]).
+
+%% uncomment when OTP-23 becomes the minimum required version
+%% -deprecated({set_exporter, 1, "set through the otel_tracer_provider instead"}).
+%% -deprecated({set_exporter, 2, "set through the otel_tracer_provider instead"}).
+%% -deprecated({set_exporter, 3, "set through the otel_tracer_provider instead"}).
+
+-eqwalizer({nowarn_function, on_end/2}).
+
+-include_lib("opentelemetry_api/include/opentelemetry.hrl").
+-include_lib("kernel/include/logger.hrl").
+-include("otel_span.hrl").
+
+-record(data, {exporter             :: {module(), term()} | undefined,
+               exporter_config      :: {module(), term()} | undefined | none,
+               current_from         :: gen_statem:from() | undefined,
+               resource             :: otel_resource:t(),
+               handed_off_table     :: atom() | undefined,
+               runner_pid           :: pid() | undefined,
+               exporting_timeout_ms :: integer()}).
+
+-define(DEFAULT_EXPORTER_TIMEOUT_MS, timer:minutes(5)).
+-define(NAME_TO_ATOM(Name, Unique), list_to_atom(lists:concat([Name, "_", Unique]))).
+
+%% require a unique name to distinguish multiple simple processors while
+%% still having a single name, instead of a possibly changing pid, to
+%% communicate with the processor
+%% @doc Starts a Simple Span Processor.
+%% @end
+-spec start_link(#{name := atom() | list()}) -> {ok, pid(), map()}.
+start_link(Config=#{name := Name}) ->
+    RegisterName = ?NAME_TO_ATOM(?MODULE, Name),
+    Config1 = Config#{reg_name => RegisterName},
+    {ok, Pid} = gen_statem:start_link({local, RegisterName}, ?MODULE, [Config1], []),
+    {ok, Pid, Config1}.
+
+%% @deprecated Please use {@link otel_tracer_provider}
+set_exporter(Exporter) ->
+    set_exporter(global, Exporter, []).
+
+%% @deprecated Please use {@link otel_tracer_provider}
+-spec set_exporter(module(), term()) -> ok.
+set_exporter(Exporter, Options) ->
+    gen_statem:call(?REG_NAME(global), {set_exporter, {Exporter, Options}}).
+
+%% @deprecated Please use {@link otel_tracer_provider}
+-spec set_exporter(atom(), module(), term()) -> ok.
+set_exporter(Name, Exporter, Options) ->
+    gen_statem:call(?REG_NAME(Name), {set_exporter, {Exporter, Options}}).
+
+%% @private
+-spec on_start(otel_ctx:t(), opentelemetry:span(), otel_span_processor:processor_config())
+              -> opentelemetry:span().
+on_start(_Ctx, Span, _) ->
+    Span.
+
+%% @private
+-spec on_end(opentelemetry:span(), otel_span_processor:processor_config())
+            -> true | dropped | {error, invalid_span} | {error, no_export_buffer}.
+on_end(#span{trace_flags=TraceFlags}, _) when not(?IS_SAMPLED(TraceFlags)) ->
+    dropped;
+on_end(Span=#span{}, #{reg_name := RegName}) ->
+    gen_statem:call(RegName, {export, Span});
+on_end(_Span, _) ->
+    {error, invalid_span}.
+
+%% @private
+-spec force_flush(#{reg_name := gen_statem:server_ref()}) -> ok.
+force_flush(#{reg_name := RegName}) ->
+    gen_statem:cast(RegName, force_flush).
+
+%% @private
+init([Args]) ->
+    process_flag(trap_exit, true),
+
+    ExportingTimeout = maps:get(exporting_timeout_ms, Args, ?DEFAULT_EXPORTER_TIMEOUT_MS),
+
+    %% TODO: this should be passed in from the tracer server
+    Resource = case maps:find(resource, Args) of
+                   {ok, R} ->
+                       R;
+                   error ->
+                       otel_resource_detector:get_resource()
+               end,
+    %% Resource = otel_tracer_provider:resource(),
+
+    {ok, idle, #data{exporter=undefined,
+                     exporter_config=maps:get(exporter, Args, none),
+                     resource = Resource,
+                     handed_off_table=undefined,
+                     exporting_timeout_ms=ExportingTimeout},
+     [{next_event, internal, init_exporter}]}.
+
+%% @private
+callback_mode() ->
+    state_functions.
+
+%% @private
+idle({call, From}, {export, _Span}, #data{exporter=undefined}) ->
+    {keep_state_and_data, [{reply, From, dropped}]};
+idle({call, From}, {export, Span}, Data) ->
+    {next_state, exporting, Data, [{next_event, internal, {export, From, Span}}]};
+idle(EventType, Event, Data) ->
+    handle_event_(idle, EventType, Event, Data).
+
+%% @private
+exporting({call, _From}, {export, _}, _) ->
+    {keep_state_and_data, [postpone]};
+exporting(internal, {export, From, Span}, Data=#data{exporting_timeout_ms=ExportingTimeout}) ->
+    {OldTableName, RunnerPid} = export_span(Span, Data),
+    {keep_state, Data#data{runner_pid=RunnerPid,
+                           current_from=From,
+                           handed_off_table=OldTableName},
+     [{state_timeout, ExportingTimeout, exporting_timeout}]};
+exporting(state_timeout, exporting_timeout, Data=#data{current_from=From,
+                                                       handed_off_table=_ExportingTable}) ->
+    %% kill current exporting process because it is taking too long
+    %% which deletes the exporting table, so create a new one and
+    %% repeat the state to force another span exporting immediately
+    Data1 = kill_runner(Data),
+    {next_state, idle, Data1, [{reply, From, {error, timeout}}]};
+%% important to verify runner_pid and FromPid are the same in case it was sent
+%% after kill_runner was called but before it had done the unlink
+exporting(info, {'EXIT', FromPid, _}, Data=#data{runner_pid=FromPid}) ->
+    complete_exporting(Data);
+%% important to verify runner_pid and FromPid are the same in case it was sent
+%% after kill_runner was called but before it had done the unlink
+exporting(info, {completed, FromPid}, Data=#data{runner_pid=FromPid}) ->
+    complete_exporting(Data);
+exporting(EventType, Event, Data) ->
+    handle_event_(exporting, EventType, Event, Data).
+
+handle_event_(_, internal, init_exporter, Data=#data{exporter=undefined,
+                                                     exporter_config=ExporterConfig}) ->
+    Exporter = otel_exporter:init(ExporterConfig),
+    {keep_state, Data#data{exporter=Exporter}};
+handle_event_(_, {call, From}, {set_exporter, Exporter}, Data=#data{exporter=OldExporter}) ->
+    otel_exporter:shutdown(OldExporter),
+    {keep_state, Data#data{exporter=otel_exporter:init(Exporter)}, [{reply, From, ok}]};
+handle_event_(_, _, _, _) ->
+    keep_state_and_data.
+
+%% @private
+terminate(_, _, _Data) ->
+    ok.
+
+%%
+
+complete_exporting(Data=#data{current_from=From,
+                              handed_off_table=ExportingTable})
+  when ExportingTable =/= undefined ->
+    {next_state, idle, Data#data{current_from=undefined,
+                                 runner_pid=undefined,
+                                 handed_off_table=undefined},
+     [{reply, From, ok}]}.
+
+kill_runner(Data=#data{runner_pid=RunnerPid}) when RunnerPid =/= undefined ->
+    Mon = erlang:monitor(process, RunnerPid),
+    erlang:unlink(RunnerPid),
+    erlang:exit(RunnerPid, kill),
+    %% Wait for the runner process termination to be sure that
+    %% the export table is destroyed and can be safely recreated
+    receive
+        {'DOWN', Mon, process, RunnerPid, _} ->
+            Data#data{runner_pid=undefined, handed_off_table=undefined}
+    end.
+
+new_export_table(Name) ->
+     ets:new(Name, [public,
+                    {write_concurrency, true},
+                    duplicate_bag,
+                    %% OpenTelemetry exporter protos group by the
+                    %% instrumentation_scope. So using instrumentation_scope
+                    %% as the key means we can easily lookup all spans for
+                    %% for each instrumentation_scope and export together.
+                    {keypos, #span.instrumentation_scope}]).
+
+export_span(Span, #data{exporter=Exporter,
+                        resource=Resource}) ->
+    Table = new_export_table(otel_simple_processor_table),
+    _ = ets:insert(Table, Span),
+    Self = self(),
+    RunnerPid = erlang:spawn_link(fun() -> send_spans(Self, Resource, Exporter) end),
+    ets:give_away(Table, RunnerPid, export),
+    {Table, RunnerPid}.
+
+%% Additional benefit of using a separate process is calls to `register` won't
+%% timeout if the actual exporting takes longer than the call timeout
+send_spans(FromPid, Resource, Exporter) ->
+    receive
+        {'ETS-TRANSFER', Table, FromPid, export} ->
+            export(Exporter, Resource, Table),
+            ets:delete(Table),
+            completed(FromPid)
+    end.
+
+completed(FromPid) ->
+    FromPid ! {completed, self()}.
+
+export(undefined, _, _) ->
+    true;
+export(Exporter, Resource, SpansTid) ->
+    %% don't let a exporter exception crash us
+    %% and return true if exporter failed
+    try
+        otel_exporter_traces:export(Exporter, SpansTid, Resource) =:= failed_not_retryable
+    catch
+        Kind:Reason:StackTrace ->
+            ?LOG_INFO(#{source => exporter,
+                        during => export,
+                        kind => Kind,
+                        reason => Reason,
+                        exporter => Exporter,
+                        stacktrace => StackTrace}, #{report_cb => fun ?MODULE:report_cb/1}),
+            true
+    end.
+
+%% logger format functions
+%% @private
+report_cb(#{source := exporter,
+            during := export,
+            kind := Kind,
+            reason := Reason,
+            exporter := {ExporterModule, _},
+            stacktrace := StackTrace}) ->
+    {"exporter threw exception: exporter=~p ~ts",
+     [ExporterModule, otel_utils:format_exception(Kind, Reason, StackTrace)]}.

apps/opentelemetry/src/otel_span_ets.erl

@@ -0,0 +1,209 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @doc
+%% ETS backed interface for working with spans.
+%% @end
+%%%-------------------------------------------------------------------------
+-module(otel_span_ets).
+
+-behaviour(gen_server).
+
+-export([start_link/1,
+         init/1,
+         handle_call/3,
+         handle_cast/2]).
+
+-export([start_span/7,
+         end_span/1,
+         end_span/2,
+         get_ctx/1,
+         set_attribute/3,
+         set_attributes/2,
+         add_event/3,
+         add_events/2,
+         set_status/2,
+         update_name/2]).
+
+%% since `span_ctx' and `span' are in the API the `span_sdk' has to be term()
+-eqwalizer({nowarn_function, get_ctx/1}).
+
+-include_lib("opentelemetry_api/include/opentelemetry.hrl").
+-include("otel_span.hrl").
+-include("otel_span_ets.hrl").
+-include_lib("stdlib/include/ms_transform.hrl").
+
+-include_lib("opentelemetry_api/include/gradualizer.hrl").
+
+-record(state, {}).
+
+start_link(Opts) ->
+    gen_server:start_link(?MODULE, Opts, []).
+
+%% @doc Start a span and insert into the active span ets table.
+-spec start_span(otel_ctx:t(), opentelemetry:span_name(), otel_sampler:t(), otel_id_generator:t(),
+                 otel_span:start_config(), fun(), otel_tracer_server:instrumentation_scope() | undefined)
+                -> opentelemetry:span_ctx().
+start_span(Ctx, Name, Sampler, IdGeneratorModule, Opts, Processors, InstrumentationScope) ->
+    case otel_span_utils:start_span(Ctx, Name, Sampler, IdGeneratorModule, Opts) of
+        {SpanCtx=#span_ctx{is_recording=true}, Span=#span{}} ->
+            Span1 = Span#span{instrumentation_scope=InstrumentationScope},
+            Span2 = Processors(Ctx, Span1),
+            case storage_insert(Span2) of
+                true ->
+                    SpanCtx;
+                _ ->
+                    %% adding the span to storage failed, this means there
+                    %% is no span backing the spanctx and we must return
+                    %% a noop span instead
+                    otel_tracer_noop:noop_span_ctx()
+            end;
+        {SpanCtx, #span{}} ->
+            %% span isn't recorded so don't run processors or insert into ets table
+            SpanCtx
+    end.
+
+end_span(SpanCtx=#span_ctx{span_sdk={_, OnEndProcessors}}) ->
+    end_span(SpanCtx, undefined, OnEndProcessors).
+
+end_span(SpanCtx=#span_ctx{span_sdk={_, OnEndProcessors}}, Timestamp) ->
+    end_span(SpanCtx, Timestamp, OnEndProcessors).
+
+%% @doc End a span based on its context and send to exporter.
+-spec end_span(opentelemetry:span_ctx(), integer() | undefined, fun()) -> boolean() | {error, term()}.
+end_span(#span_ctx{span_id=SpanId,
+                   is_recording=true,
+                   tracestate=Tracestate}, Timestamp, Processors) ->
+    case ets:take(?SPAN_TAB, SpanId) of
+        [Span] ->
+            Span1 = otel_span_utils:end_span((?assert_type(Span, #span{}))#span{tracestate=Tracestate,
+                                                                                is_recording=false}, Timestamp),
+            Processors(Span1);
+        _ ->
+            false
+    end;
+end_span(_, _, _) ->
+    true.
+
+-spec get_ctx(opentelemetry:span()) -> opentelemetry:span_ctx().
+get_ctx(#span{trace_id=TraceId,
+              span_id=SpanId,
+              tracestate=TraceState,
+              is_recording=IsRecording}) ->
+    #span_ctx{trace_id=TraceId,
+              span_id=SpanId,
+              tracestate=TraceState,
+              is_recording=IsRecording}.
+
+-spec set_attribute(opentelemetry:span_ctx() | undefined,
+                    opentelemetry:attribute_key(),
+                    opentelemetry:attribute_value()) -> boolean().
+set_attribute(#span_ctx{span_id=SpanId}, Key, Value) ->
+    try ets:lookup_element(?SPAN_TAB, SpanId, #span.attributes) of
+        Attributes ->
+            ets:update_element(?SPAN_TAB, SpanId, {#span.attributes, otel_attributes:set(Key, Value, Attributes)})
+    catch error:badarg ->
+            false
+    end;
+set_attribute(_, _, _) ->
+    false.
+
+%% Note: Spans are referenced through the current active span context in a process
+%% and thus modified only by a single process, so concurrent updates of the same field
+%% are not a real concern. This allows `add_events' and `set_attributes' to lookup and
+%% update only the specific element of the `span' without worrying about it having been
+%% changed by another process between the lookup and update.
+-spec set_attributes(opentelemetry:span_ctx() | undefined, opentelemetry:attributes_map()) -> boolean().
+set_attributes(#span_ctx{span_id=SpanId}, NewAttributes) ->
+    try ets:lookup_element(?SPAN_TAB, SpanId, #span.attributes) of
+        Attributes ->
+            ets:update_element(?SPAN_TAB, SpanId, {#span.attributes,
+                                                   otel_attributes:set(NewAttributes, Attributes)})
+    catch error:badarg ->
+            false
+    end.
+
+-spec add_event(opentelemetry:span_ctx() | undefined, unicode:unicode_binary(), opentelemetry:attributes_map()) -> boolean().
+add_event(SpanCtx, Name, Attributes) ->
+    Events = opentelemetry:events([{Name, Attributes}]),
+    add_events(SpanCtx, Events).
+
+-spec add_events(opentelemetry:span_ctx() | undefined, [opentelemetry:event()]) -> boolean().
+add_events(#span_ctx{span_id=SpanId}, NewEvents) ->
+    try ets:lookup_element(?SPAN_TAB, SpanId, #span.events) of
+        Events ->
+            ets:update_element(?SPAN_TAB, SpanId, {#span.events, otel_events:add(NewEvents, Events)})
+    catch error:badarg ->
+            false
+    end.
+
+-spec set_status(opentelemetry:span_ctx() | undefined, opentelemetry:status()) -> boolean().
+set_status(#span_ctx{span_id=SpanId}, Status=#status{code=NewCode}) ->
+    try ets:lookup_element(?SPAN_TAB, SpanId, #span.status) of
+         #status{code=?OTEL_STATUS_ERROR} when NewCode =:= ?OTEL_STATUS_OK ->
+            %% can only set status to OK if it has been set to ERROR before
+            ets:update_element(?SPAN_TAB, SpanId, {#span.status, Status});
+        #status{code=?OTEL_STATUS_UNSET} ->
+            %% if UNSET then the status can be updated to OK or ERROR
+            ets:update_element(?SPAN_TAB, SpanId, {#span.status, Status});
+        undefined ->
+            %% if undefined then the status can be updated to anything
+            ets:update_element(?SPAN_TAB, SpanId, {#span.status, Status});
+        _ ->
+            %% nothing to do since status code is either
+            %% OK or ERROR but NewCode is not OK
+            false
+    catch error:badarg ->
+            false
+    end;
+set_status(_, _) ->
+    false.
+
+-spec update_name(opentelemetry:span_ctx() | undefined, opentelemetry:span_name()) -> boolean().
+update_name(#span_ctx{span_id=SpanId}, Name) ->
+    ets:update_element(?SPAN_TAB, SpanId, {#span.name, Name});
+update_name(_, _) ->
+    false.
+
+%%
+
+storage_insert(undefined) ->
+    true;
+storage_insert(Span) ->
+    try
+        ets:insert(?SPAN_TAB, Span)
+    catch
+        error:badarg ->
+            false
+    end.
+
+init(_Opts) ->
+    %% ets table is required for other parts to not crash so we create
+    %% it in init and not in a handle_continue or whatever else
+    case ets:info(?SPAN_TAB, name) of
+        undefined ->
+            ets:new(?SPAN_TAB, [named_table, public,
+                                {write_concurrency, true},
+                                {keypos, #span.span_id}]);
+        _ ->
+            ok
+    end,
+
+    {ok, #state{}}.
+
+handle_call(_Msg, _From, State) ->
+    {noreply, State}.
+
+handle_cast(_Msg, State) ->
+    {noreply, State}.

apps/opentelemetry/src/otel_span_ets.hrl

@@ -1 +1,2 @@
 -define(SPAN_TAB, otel_span_table).
+

apps/opentelemetry/src/otel_span_limits.erl

@@ -0,0 +1,82 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2021, 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.
+%%
+%% @doc Module for setting the global limits for the number of attributes,
+%% events and links on a Span.
+%% @end
+%%%-------------------------------------------------------------------------
+-module(otel_span_limits).
+
+-export([get/0,
+         set/1,
+         attribute_count_limit/0,
+         attribute_value_length_limit/0,
+         event_count_limit/0,
+         link_count_limit/0,
+         attribute_per_event_limit/0,
+         attribute_per_link_limit/0]).
+
+-include("otel_span.hrl").
+
+-define(SPAN_LIMITS_KEY, {?MODULE, span_limits}).
+
+-spec get() -> #span_limits{}.
+get() ->
+    persistent_term:get(?SPAN_LIMITS_KEY).
+
+-spec set(otel_configuration:t()) -> ok.
+set(#{attribute_count_limit := AttributeCountLimit,
+      attribute_value_length_limit := AttributeValueLengthLimit,
+      event_count_limit := EventCountLimit,
+      link_count_limit := LinkCountLimit,
+      attribute_per_event_limit := AttributePerEventLimit,
+      attribute_per_link_limit := AttributePerLinkLimit}) ->
+    SpanLimits = #span_limits{attribute_count_limit=AttributeCountLimit,
+                              attribute_value_length_limit=AttributeValueLengthLimit,
+                              event_count_limit=EventCountLimit,
+                              link_count_limit=LinkCountLimit,
+                              attribute_per_event_limit=AttributePerEventLimit,
+                              attribute_per_link_limit=AttributePerLinkLimit},
+    persistent_term:put(?SPAN_LIMITS_KEY, SpanLimits).
+
+attribute_count_limit() ->
+    get_limit(attribute_count_limit, ?MODULE:get()).
+
+attribute_value_length_limit() ->
+    get_limit(attribute_value_length_limit, ?MODULE:get()).
+
+event_count_limit() ->
+    get_limit(event_count_limit, ?MODULE:get()).
+
+link_count_limit() ->
+    get_limit(link_count_limit, ?MODULE:get()).
+
+attribute_per_event_limit() ->
+    get_limit(attribute_per_event_limit, ?MODULE:get()).
+
+attribute_per_link_limit() ->
+    get_limit(attribute_per_link_limit, ?MODULE:get()).
+
+get_limit(attribute_count_limit, #span_limits{attribute_count_limit=AttributeCountLimit}) ->
+    AttributeCountLimit;
+get_limit(attribute_value_length_limit, #span_limits{attribute_value_length_limit=AttributeValueLengthLimit}) ->
+    AttributeValueLengthLimit;
+get_limit(event_count_limit, #span_limits{event_count_limit=EventCountLimit}) ->
+    EventCountLimit;
+get_limit(link_count_limit, #span_limits{link_count_limit=LinkCountLimit}) ->
+    LinkCountLimit;
+get_limit(attribute_per_event_limit, #span_limits{attribute_per_event_limit=AttributePerEventLimit}) ->
+    AttributePerEventLimit;
+get_limit(attribute_per_link_limit, #span_limits{attribute_per_link_limit=AttributePerLinkLimit}) ->
+    AttributePerLinkLimit.

apps/opentelemetry/src/otel_span_processor.erl

@@ -0,0 +1,55 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @doc Behaviour each Span Processor must implement.
+%% @end
+%%%-------------------------------------------------------------------------
+-module(otel_span_processor).
+
+-export([start_link/2]).
+
+-type processor_config() :: term().
+
+-export_type([processor_config/0]).
+
+-callback processor_init(pid(), processor_config()) -> processor_config().
+
+-callback on_start(otel_ctx:t(), opentelemetry:span(), processor_config()) -> opentelemetry:span().
+
+-callback on_end(opentelemetry:span(), processor_config()) -> true |
+                                                              dropped |
+                                                              {error, invalid_span} |
+                                                              {error, no_export_buffer}.
+
+-callback force_flush(processor_config()) -> ok |
+                                             {error, term()}.
+
+-optional_callbacks([processor_init/2]).
+
+%% @doc Starts a span processor.
+%% 
+%% `Module' must implement the `otel_span_processor' behaviour. This function
+%% calls `Module:start_link/1' with `Config' as the argument.
+%% @end
+-spec start_link(module(), Config) -> {ok, pid(), Config} | {error, term()} when
+      Config :: processor_config().
+start_link(Module, Config) ->
+    case Module:start_link(Config) of
+        {ok, Pid} ->
+            {ok, Pid, Config};
+        {ok, Pid, Config1} ->
+            {ok, Pid, Config1};
+        {error, _}=Error ->
+            Error
+    end.

apps/opentelemetry/src/otel_span_processor_sup.erl

@@ -0,0 +1,39 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2022, 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.
+%%
+%% @private
+%% @end
+%%%-------------------------------------------------------------------------
+-module(otel_span_processor_sup).
+
+-behaviour(supervisor).
+
+-export([start_link/1]).
+
+-export([init/1]).
+
+-define(SERVER, ?MODULE).
+
+start_link(RegName) ->
+    supervisor:start_link({local, RegName}, ?MODULE, []).
+
+init([]) ->
+    SupFlags = #{strategy => simple_one_for_one,
+                 intensity => 1,
+                 period => 5},
+    ChildSpecs = [#{id => otel_span_processor,
+                    start => {otel_span_processor, start_link, []},
+                    shutdown => 5000}],
+
+    {ok, {SupFlags, ChildSpecs}}.

apps/opentelemetry/src/otel_span_sup.erl

@@ -12,10 +12,9 @@
 %% See the License for the specific language governing permissions and
 %% limitations under the License.
 %%
-%% @doc
-%% @end
+%% @private
 %%%-------------------------------------------------------------------------
--module(ot_span_sup).
+-module(otel_span_sup).
 
 -behaviour(supervisor).
 
@@ -26,31 +25,31 @@
 
 -define(SERVER, ?MODULE).
 
-start_link(Opts) ->
-    supervisor:start_link({local, ?SERVER}, ?MODULE, [Opts]).
+start_link(Config) ->
+    supervisor:start_link({local, ?SERVER}, ?MODULE, [Config]).
 
 start_child(ChildSpec) ->
     supervisor:start_child(?SERVER, ChildSpec).
 
-init([Opts]) ->
+init([Config]) ->
     SupFlags = #{strategy => one_for_one,
                  intensity => 1,
                  period => 5},
 
-    SweeperOpts = proplists:get_value(sweeper, Opts, #{}),
-    Sweeper = #{id => ot_span_sweeper,
-                start => {ot_span_sweeper, start_link, [SweeperOpts]},
+    SweeperConfig = maps:get(sweeper, Config),
+    Sweeper = #{id => otel_span_sweeper,
+                start => {otel_span_sweeper, start_link, [SweeperConfig]},
                 restart => permanent,
                 shutdown => 5000,
                 type => worker,
-                modules => [ot_span_sweeper]},
+                modules => [otel_span_sweeper]},
 
-    SpanHandler = #{id => ot_span_ets,
-                    start => {ot_span_ets, start_link, [[]]},
+    SpanHandler = #{id => otel_span_ets,
+                    start => {otel_span_ets, start_link, [[]]},
                     restart => permanent,
                     shutdown => 5000,
                     type => worker,
-                    modules => [ot_span_ets]},
+                    modules => [otel_span_ets]},
 
     ChildSpecs = [SpanHandler, Sweeper],
     {ok, {SupFlags, ChildSpecs}}.

apps/opentelemetry/src/otel_span_sweeper.erl

@@ -17,7 +17,7 @@
 %% period of time.
 %% @end
 %%%-------------------------------------------------------------------------
--module(ot_span_sweeper).
+-module(otel_span_sweeper).
 
 -behaviour(gen_statem).
 
@@ -32,27 +32,28 @@
 -export([storage_size/0]).
 
 -include_lib("opentelemetry_api/include/opentelemetry.hrl").
--include("ot_span_ets.hrl").
--include("ot_tracer.hrl").
--include("ot_span.hrl").
+-include("otel_span_ets.hrl").
+-include("otel_tracer.hrl").
+-include("otel_span.hrl").
 -include_lib("kernel/include/logger.hrl").
 
+-include_lib("opentelemetry_api/include/gradualizer.hrl").
+
 -record(data, {interval :: integer() | infinity,
                strategy :: drop | end_span | failed_attribute_and_end_span | fun((opentelemetry:span()) -> ok),
                ttl :: integer() | infinity,
                storage_size :: integer() | infinity}).
 
 storage_size() ->
-    {ets:info(?SPAN_TAB, size), ets:info(?SPAN_TAB, memory) * erlang:system_info({wordsize, external})}.
+    {ets:info(?SPAN_TAB, size), ?assert_type(ets:info(?SPAN_TAB, memory), integer()) * erlang:system_info({wordsize, external})}.
 
-start_link(Opts) ->
-    gen_statem:start_link({local, ?MODULE}, ?MODULE, [Opts], []).
+start_link(Config) ->
+    gen_statem:start_link({local, ?MODULE}, ?MODULE, [Config], []).
 
-init([SweeperConfig]) ->
-    Interval = maps:get(interval, SweeperConfig, timer:minutes(10)),
-    Strategy = maps:get(strategy, SweeperConfig, drop),
-    TTL = maps:get(span_ttl, SweeperConfig, timer:minutes(30)),
-    StorageSize = maps:get(storage_size, SweeperConfig, infinity),
+init([#{interval := Interval,
+        strategy := Strategy,
+        span_ttl := TTL,
+        storage_size := StorageSize}]) ->
     {ok, ready, #data{interval=Interval,
                       strategy=Strategy,
                       ttl=maybe_convert_time_unit(TTL),
@@ -136,7 +137,7 @@ sweep_spans(failed_attribute_and_end_span, TTL) ->
                  %% must have finished without needing to be swept
                  ok;
              [Span=#span{attributes=Attributes}] ->
-                 Span1 = Span#span{attributes=Attributes ++ [{<<"finished_by_sweeper">>, true}]},
+                 Span1 = Span#span{attributes=otel_attributes:set(<<"finished_by_sweeper">>, true, Attributes)},
                  end_span(Span1)
          end
      end || SpanId <- ExpiredSpanIds],
@@ -162,6 +163,6 @@ expired_match_spec(Time, Return) ->
 
 end_span(Span=#span{tracestate=Tracestate}) ->
     %% hack to not lose tracestate when ending without span ctx
-    Span1 = ot_span_utils:end_span(Span#span{tracestate=Tracestate}),
+    Span1 = otel_span_utils:end_span(Span#span{tracestate=Tracestate}),
     {_, #tracer{on_end_processors=Processors}} = opentelemetry:get_tracer(),
     Processors(Span1).

apps/opentelemetry/src/otel_span_utils.erl

@@ -0,0 +1,128 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @private
+%%%-------------------------------------------------------------------------
+-module(otel_span_utils).
+
+-export([start_span/5,
+         end_span/1,
+         end_span/2]).
+
+-include_lib("opentelemetry_api/include/opentelemetry.hrl").
+-include("otel_sampler.hrl").
+-include("otel_span.hrl").
+
+-spec start_span(otel_ctx:t(), opentelemetry:span_name(), otel_sampler:t(), otel_id_generator:t(),
+                 otel_span:start_config()) -> {opentelemetry:span_ctx(), opentelemetry:span() | undefined}.
+start_span(Ctx, Name, Sampler, IdGenerator, Opts) ->
+    SpanAttributeCountLimit = otel_span_limits:attribute_count_limit(),
+    SpanAttributeValueLengthLimit= otel_span_limits:attribute_value_length_limit(),
+    EventCountLimit = otel_span_limits:event_count_limit(),
+    LinkCountLimit = otel_span_limits:link_count_limit(),
+    AttributePerEventLimit = otel_span_limits:attribute_per_event_limit(),
+    AttributePerLinkLimit = otel_span_limits:attribute_per_link_limit(),
+
+
+    Attributes = otel_attributes:new(maps:get(attributes, Opts),
+                                     SpanAttributeCountLimit,
+                                     SpanAttributeValueLengthLimit),
+    Links = otel_links:new(maps:get(links, Opts),
+                           LinkCountLimit,
+                           AttributePerLinkLimit,
+                           SpanAttributeValueLengthLimit),
+    Events = otel_events:new(EventCountLimit, AttributePerEventLimit, SpanAttributeValueLengthLimit),
+
+    Kind = maps:get(kind, Opts),
+    StartTime = maps:get(start_time, Opts),
+
+    new_span(Ctx, Name, Sampler, IdGenerator, StartTime, Kind, Attributes, Events, Links).
+
+new_span(Ctx, Name, Sampler, IdGeneratorModule, StartTime, Kind, Attributes, Events, Links) ->
+    {NewSpanCtx, ParentSpanId} = new_span_ctx(Ctx, IdGeneratorModule),
+
+    TraceId = NewSpanCtx#span_ctx.trace_id,
+    SpanId = NewSpanCtx#span_ctx.span_id,
+
+    {TraceFlags, IsRecording, SamplerAttributes, TraceState} =
+        sample(Ctx, Sampler, TraceId, Links, Name, Kind, otel_attributes:map(Attributes)),
+
+    Span = #span{trace_id=TraceId,
+                 span_id=SpanId,
+                 tracestate=TraceState,
+                 start_time=StartTime,
+                 parent_span_id=ParentSpanId,
+                 kind=Kind,
+                 name=Name,
+                 attributes=otel_attributes:set(SamplerAttributes, Attributes),
+                 events=Events,
+                 links=Links,
+                 trace_flags=TraceFlags,
+                 is_recording=IsRecording},
+
+    {NewSpanCtx#span_ctx{trace_flags=TraceFlags,
+                         tracestate=TraceState,
+                         is_valid=true,
+                         is_recording=IsRecording}, Span}.
+
+-spec new_span_ctx(otel_ctx:t(), otel_id_generator:t()) ->
+          {opentelemetry:span_ctx(), opentelemetry:span_id() | undefined}.
+new_span_ctx(Ctx, IdGeneratorModule) ->
+    case otel_tracer:current_span_ctx(Ctx) of
+        undefined ->
+            {root_span_ctx(IdGeneratorModule), undefined};
+        #span_ctx{is_valid=false} ->
+            {root_span_ctx(IdGeneratorModule), undefined};
+        ParentSpanCtx=#span_ctx{span_id=ParentSpanId} ->
+            %% keep the rest of the parent span ctx, simply need to update the span_id
+            {ParentSpanCtx#span_ctx{span_id=IdGeneratorModule:generate_span_id()}, ParentSpanId}
+    end.
+
+root_span_ctx(IdGeneratorModule) ->
+    #span_ctx{trace_id=IdGeneratorModule:generate_trace_id(),
+              span_id=IdGeneratorModule:generate_span_id(),
+              is_valid=true,
+              trace_flags=0}.
+
+%%--------------------------------------------------------------------
+%% @doc
+%% Set the end time for a span if it hasn't been set before.
+%% @end
+%%--------------------------------------------------------------------
+-spec end_span(opentelemetry:span()) -> opentelemetry:span().
+end_span(Span=#span{end_time=undefined,
+                    trace_flags=TraceFlags}) when ?IS_SAMPLED(TraceFlags) ->
+    end_span(Span, undefined);
+end_span(Span) ->
+    Span.
+
+-spec end_span(#span{}, integer() | undefined) -> opentelemetry:span().
+end_span(Span, Timestamp) when is_integer(Timestamp) ->
+    Span#span{end_time=Timestamp};
+end_span(Span, _) ->
+    Span#span{end_time=opentelemetry:timestamp()}.
+%%
+
+sample(Ctx, Sampler, TraceId, Links, SpanName, Kind, Attributes) ->
+    {Decision, NewAttributes, TraceState} = otel_sampler:should_sample(
+        Sampler, Ctx, TraceId, Links, SpanName, Kind, Attributes
+    ),
+    case Decision of
+        ?DROP ->
+            {0, false, NewAttributes, TraceState};
+        ?RECORD_ONLY ->
+            {0, true, NewAttributes, TraceState};
+        ?RECORD_AND_SAMPLE ->
+            {1, true, NewAttributes, TraceState}
+    end.

apps/opentelemetry/src/otel_tracer.hrl

@@ -0,0 +1,15 @@
+%% This record is for the data of a named tracer.
+%% The `tracer' contains the modules to use for span creation,
+%% the sampler to use at creation time and the processors to
+%% run `OnStart' and `OnEnd'.
+%% See OpenTelemetry Tracer spec: https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/sdk.md#tracer-creation
+-record(tracer,
+        {
+         module                  :: module(),
+         on_start_processors     :: fun((otel_ctx:t(), opentelemetry:span()) -> opentelemetry:span()),
+         on_end_processors       :: fun((opentelemetry:span()) -> boolean() | {error, term()}),
+         sampler                 :: otel_sampler:t(),
+         id_generator            :: otel_id_generator:t(),
+         instrumentation_scope   :: otel_tracer_server:instrumentation_scope() | undefined
+        }).
+-type tracer() :: #tracer{}.

apps/opentelemetry/src/otel_tracer_default.erl

@@ -0,0 +1,54 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @doc
+%% @end
+%%%-------------------------------------------------------------------------
+-module(otel_tracer_default).
+
+-behaviour(otel_tracer).
+
+-export([start_span/4,
+         with_span/5]).
+
+-include_lib("opentelemetry_api/include/opentelemetry.hrl").
+-include("otel_tracer.hrl").
+-include("otel_span_ets.hrl").
+
+%% @doc Starts an inactive Span and returns its SpanCtx.
+-spec start_span(otel_ctx:t(), opentelemetry:tracer(), opentelemetry:span_name(),
+                 otel_span:start_config()) -> opentelemetry:span_ctx().
+start_span(Ctx, {_, #tracer{on_start_processors=Processors,
+                            on_end_processors=OnEndProcessors,
+                            sampler=Sampler,
+                            id_generator=IdGeneratorModule,
+                            instrumentation_scope=InstrumentationScope}}, Name, Opts) ->
+    SpanCtx = otel_span_ets:start_span(Ctx, Name, Sampler, IdGeneratorModule, Opts, Processors, InstrumentationScope),
+    SpanCtx#span_ctx{span_sdk={otel_span_ets, OnEndProcessors}}.
+
+-spec with_span(otel_ctx:t(), opentelemetry:tracer(), opentelemetry:span_name(),
+                otel_span:start_config(), otel_tracer:traced_fun(T)) -> T.
+with_span(Ctx, Tracer, SpanName, Opts, Fun) ->
+    SpanCtx = start_span(Ctx, Tracer, SpanName, Opts),
+    Ctx1 = otel_tracer:set_current_span(Ctx, SpanCtx),
+    Token = otel_ctx:attach(Ctx1),
+    try
+        Fun(SpanCtx)
+    after
+        %% passing SpanCtx directly ensures that this `end_span' ends the span started
+        %% in this function. If spans in `Fun()' were started and not finished properly
+        %% they will be abandoned and it be up to the `otel_span_sweeper' to eventually remove them.
+        _ = otel_span_ets:end_span(SpanCtx),
+        otel_ctx:detach(Token)
+    end.

apps/opentelemetry/src/otel_tracer_provider_sup.erl

@@ -0,0 +1,56 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2022, 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.
+%%
+%% @private
+%%%-------------------------------------------------------------------------
+-module(otel_tracer_provider_sup).
+
+-behaviour(supervisor).
+
+-export([start_link/0,
+         start/2,
+         start/3]).
+
+-export([init/1]).
+
+-define(SERVER, ?MODULE).
+
+start_link() ->
+    supervisor:start_link({local, ?SERVER}, ?MODULE, []).
+
+%% here to support deprecated function `opentelemetry:start_tracer_provider/2'
+start(Name, Config) ->
+    start(Name, otel_resource:create([]), Config).
+
+start(Name, Resource, Config) ->
+    try
+        supervisor:start_child(?MODULE, [Name, Resource, Config])
+    catch
+        exit:{noproc, _} ->
+            %% no tracer provider sup is started, the sdk is probably disabled
+            {error, no_tracer_provider_supervisor}
+    end.
+
+init([]) ->
+    SupFlags = #{strategy => simple_one_for_one,
+                 intensity => 1,
+                 period => 5},
+
+    TracerServerSup = #{id => otel_tracer_server_sup,
+                        start => {otel_tracer_server_sup, start_link, []},
+                        restart => permanent,
+                        type => supervisor,
+                        modules => [otel_tracer_server_sup]},
+
+    {ok, {SupFlags, [TracerServerSup]}}.

apps/opentelemetry/src/otel_tracer_server.erl

@@ -0,0 +1,205 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @doc This module is the SDK's implementation of the TracerProvider. The
+%% calls to the server are done from the API module `otel_tracer_provider'.
+%% This `gen_server' is started as part of the SDK's supervision tree and
+%% registers itself as the default TracerProvider by using the name
+%% `otel_tracer_provider' as its name.
+%% @end
+%%%-------------------------------------------------------------------------
+-module(otel_tracer_server).
+
+-behaviour(gen_server).
+
+-export([start_link/5]).
+
+-export([init/1,
+         handle_call/3,
+         handle_cast/2,
+         code_change/1]).
+
+-include_lib("kernel/include/logger.hrl").
+-include_lib("opentelemetry_api/include/opentelemetry.hrl").
+-include("otel_tracer.hrl").
+-include("otel_span.hrl").
+
+-type instrumentation_scope() :: #instrumentation_scope{}.
+-export_type([instrumentation_scope/0]).
+
+-record(state,
+        {
+         %% the tracer configuration shared between all named
+         %% tracers created by this provider
+         shared_tracer :: tracer() | undefined,
+         id_generator :: module(),
+         processors :: [module()],
+         sampler :: otel_sampler:t(),
+         resource :: otel_resource:t(),
+
+         span_processor_sup :: atom(),
+
+         %% list of tracer names to return noop tracers for
+         deny_list :: [atom() | {atom(), string()}]
+        }).
+
+-spec start_link(atom(), atom(), atom(), otel_resource:t(), otel_configuration:t()) -> {ok, pid()} | ignore | {error, term()}.
+start_link(Name, RegName, SpanProcessorSupRegName, Resource, Config) ->
+    gen_server:start_link({local, RegName}, ?MODULE, [Name, SpanProcessorSupRegName, Resource, Config], []).
+
+init([Name, SpanProcessorSup, Resource, #{id_generator := IdGeneratorModule,
+                                          sampler := SamplerSpec,
+                                          processors := Processors,
+                                          deny_list := DenyList}]) ->
+    Sampler = otel_sampler:new(SamplerSpec),
+
+    Processors1 = init_processors(SpanProcessorSup, Processors),
+
+    Tracer = #tracer{module=otel_tracer_default,
+                     sampler=Sampler,
+                     on_start_processors=on_start(Processors1),
+                     on_end_processors=on_end(Processors1),
+                     id_generator=IdGeneratorModule},
+
+    %% TODO: don't do this if its already set?
+    opentelemetry:set_default_tracer(Name, {otel_tracer_default, Tracer}),
+
+    {ok, #state{id_generator=IdGeneratorModule,
+                resource=Resource,
+                sampler=Sampler,
+                deny_list=DenyList,
+                shared_tracer=Tracer,
+                span_processor_sup=SpanProcessorSup,
+                processors=Processors1}}.
+
+handle_call(resource, _From, State=#state{resource=Resource}) ->
+    {reply, Resource, State};
+handle_call({get_tracer, _Name, _Vsn, _SchemaUrl}, _From, State=#state{shared_tracer=undefined}) ->
+    {reply, {otel_tracer_noop, []}, State};
+handle_call({get_tracer, Name, Vsn, SchemaUrl}, _From, State=#state{shared_tracer=Tracer,
+                                                                    deny_list=DenyList})
+  when Tracer =/= undefined ->
+    %% TODO: support semver constraints in denylist
+    case proplists:is_defined(Name, DenyList) of
+        true ->
+            {reply, {otel_tracer_noop, []}, State};
+        false ->
+            InstrumentationScope = opentelemetry:instrumentation_scope(Name, Vsn, SchemaUrl),
+            TracerTuple = {Tracer#tracer.module,
+                           Tracer#tracer{instrumentation_scope=InstrumentationScope}},
+            {reply, TracerTuple, State}
+    end;
+handle_call({get_tracer, InstrumentationScope}, _From, State=#state{shared_tracer=Tracer,
+                                                                    deny_list=_DenyList})
+  when Tracer =/= undefined ->
+    {reply, {Tracer#tracer.module,
+             Tracer#tracer{instrumentation_scope=InstrumentationScope}}, State};
+handle_call(force_flush, _From, State=#state{processors=Processors}) ->
+    Reply = lists:foldl(fun(Processor, Result) ->
+                                case force_flush_(Processor) of
+                                    ok ->
+                                        Result;
+                                    {error, Reason} ->
+                                        update_force_flush_error(Reason, Result)
+                                end
+                        end, ok, Processors),
+    {reply, Reply, State}.
+
+handle_cast(_, State) ->
+    {noreply, State}.
+
+code_change(State) ->
+    {ok, State}.
+%%
+
+-spec update_force_flush_error(term(), ok | {error, list()}) -> {error, list()}.
+update_force_flush_error(Reason, ok) ->
+    {error, [Reason]};
+update_force_flush_error(Reason, {error, List}) ->
+    {error, [Reason | List]}.
+
+%% TODO: remove after a period of deprecation for processor `set_exporter' functions
+%% This is a hack that makes it so there is a known name for the processor if there
+%% is only one, like was once guaranteed. This allows functions like `set_exporter'
+%% to work. But if there is more than one processor defined or it isn't one of the
+%% builtin processors we will not do this hack of adding a name to the config.
+init_processors(SpanProcessorSup, [{P, Config}]) when P =:= otel_batch_processor ;
+                                                      P =:= otel_simple_processor ->
+    case init_processor(SpanProcessorSup, P, maps:merge(#{name => global}, Config)) of
+        {true, {_, _}=Processor} ->
+            [Processor];
+        _ ->
+            []
+    end;
+init_processors(SpanProcessorSup, Processors) ->
+    init_processors_(SpanProcessorSup, Processors).
+
+init_processors_(_SpanProcessorSup, []) ->
+    [];
+init_processors_(SpanProcessorSup, [{P, Config} | Rest]) ->
+    case init_processor(SpanProcessorSup, P, Config) of
+        {true, {_, _}=Processor} ->
+            [Processor | init_processors_(SpanProcessorSup, Rest)];
+        _ ->
+            init_processors_(SpanProcessorSup, Rest)
+    end.
+
+init_processor(SpanProcessorSup, ProcessorModule, Config) ->
+    %% start_link is an optional callback for processors
+    case lists:member({start_link, 1}, ProcessorModule:module_info(exports)) of
+        true ->
+            try supervisor:start_child(SpanProcessorSup,
+                                       [ProcessorModule,
+                                        %% use a unique reference to distinguish multiple processors of the same type while
+                                        %% still having a single name, instead of a possibly changing pid, to
+                                        %% communicate with the processor
+                                        maps:merge(#{name => erlang:ref_to_list(erlang:make_ref())},
+                                                   Config)])
+            of
+                {ok, _Pid, Config1} ->
+                    {true, {ProcessorModule, Config1}};
+                {error, Reason} ->
+                    ?LOG_INFO("Dropping span processor ~p because `processor_init/1` failed ~p", [ProcessorModule, Reason]),
+                    false
+            catch
+                C:T:S ->
+                    ?LOG_DEBUG("Dropping span processor ~p because `processor_init/1` threw an exception ~p:~p:~p", [ProcessorModule, C, T, S]),
+                    ?LOG_INFO("Dropping span processor ~p because `processor_init/1` threw an exception ~p:~p", [ProcessorModule, C, T]),
+                    false
+            end;
+        false ->
+            {true, {ProcessorModule, Config}}
+    end.
+
+on_start(Processors) ->
+    fun(Ctx, Span) ->
+            lists:foldl(fun({P, Config}, Acc) ->
+                                P:on_start(Ctx, Acc, Config)
+                        end, Span, Processors)
+    end.
+
+on_end(Processors) ->
+    fun(Span) ->
+            lists:foldl(fun({P, Config}, Bool) ->
+                                Bool andalso P:on_end(Span, Config) =:= true
+                        end, true, Processors)
+    end.
+
+force_flush_({Processor, Config}) ->
+    try
+        Processor:force_flush(Config)
+    catch
+        C:T ->
+            {error, {Processor, {C, T}}}
+    end.

apps/opentelemetry/src/otel_tracer_server_sup.erl

@@ -0,0 +1,61 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2022, 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.
+%%
+%% @private
+%%%-------------------------------------------------------------------------
+-module(otel_tracer_server_sup).
+
+-behaviour(supervisor).
+
+-export([start_link/3]).
+
+-export([init/1]).
+
+-include_lib("opentelemetry_api/include/opentelemetry.hrl").
+
+start_link(Name, Resource, Opts) ->
+    supervisor:start_link(?MODULE, [Name, Resource, Opts]).
+
+init([Name, Resource, Opts]) ->
+    SupFlags = #{strategy => one_for_one,
+                 intensity => 1,
+                 period => 5},
+
+    %% the name of the span tracer provider is used to distinguish span processor
+    %% supervisors and the tracer provider itself.
+    %% in the case of the global provider the name is `global'
+    SpanProcessorSupRegName = list_to_atom(lists:concat([otel_span_processor_sup, "_", Name])),
+    TracerServeRegName = list_to_atom(lists:concat([otel_tracer_provider, "_", Name])),
+
+    SpanProcessorSup = #{id => otel_span_processor_sup,
+                         start => {otel_span_processor_sup, start_link, [SpanProcessorSupRegName]},
+                         restart => permanent,
+                         shutdown => 5000,
+                         type => supervisor,
+                         modules => [otel_span_processor_sup, otel_span_processor]},
+
+    TracerServer = #{id => otel_tracer_server,
+                     start => {otel_tracer_server, start_link, [Name,
+                                                                TracerServeRegName,
+                                                                SpanProcessorSupRegName,
+                                                                Resource,
+                                                                Opts]},
+                     restart => permanent,
+                     shutdown => 5000,
+                     type => worker,
+                     modules => [otel_tracer_provider, otel_tracer_server]},
+
+    ChildSpecs = [SpanProcessorSup, TracerServer],
+
+    {ok, {SupFlags, ChildSpecs}}.

apps/opentelemetry/test/attributes_sampler.erl

@@ -0,0 +1,53 @@
+%% sampler returns `DROP' if a span attribute matches the configured attribute map
+%% otherwise `RECORD_AND_SAMPLE'
+-module(attributes_sampler).
+
+-behavior(otel_sampler).
+
+-export([description/1,
+         setup/1,
+         should_sample/7]).
+
+-include("otel_sampler.hrl").
+
+setup(Attributes) when is_map(Attributes) ->
+    Attributes;
+setup(_) ->
+    #{}.
+
+description(_) ->
+    <<"AttributesSampler">>.
+
+-spec should_sample(Ctx, TraceId, Links, SpanName, SpanKind, Attributes, Config) -> Result
+              when Ctx :: otel_ctx:t(),
+                   TraceId :: opentelemetry:trace_id(),
+                   Links :: otel_links:t(),
+                   SpanName :: opentelemetry:span_name(),
+                   SpanKind :: nopentelemetry:span_kind(),
+                   Attributes :: opentelemetry:attributes_map(),
+                   Config :: otel_sampler:sampler_config(),
+                   Result :: otel_sampler:sampling_result().
+should_sample(_Ctx, _TraceId, _Links, _SpanName, _SpanKind, Attributes, ConfigAttributes) ->
+    case has_match(Attributes, ConfigAttributes) of
+        true ->
+            {?DROP, [], []};
+        _ ->
+            {?RECORD_AND_SAMPLE, [], []}
+    end.
+
+has_match(A, B) ->
+    {Min, Max} = if
+                     map_size(A) < map_size(B) ->
+                         {A, B};
+                     true ->
+                         {B, A}
+                 end,
+    I = maps:iterator(Min),
+    has_match_(maps:next(I), Max).
+
+has_match_(none, _) ->
+    false;
+has_match_({K, V, _I}, B) when map_get(K, B) =:= V ->
+    true;
+has_match_({_K, _V, I}, B) ->
+    has_match_(maps:next(I), B).

apps/opentelemetry/test/otel_batch_processor_SUITE.erl

@@ -0,0 +1,107 @@
+-module(otel_batch_processor_SUITE).
+
+-compile(export_all).
+
+-include_lib("stdlib/include/assert.hrl").
+-include_lib("common_test/include/ct.hrl").
+
+-include("otel_span.hrl").
+-include_lib("opentelemetry_api/include/opentelemetry.hrl").
+
+all() ->
+    [exporting_timeout_test,
+     check_table_size_test,
+     exporting_runner_timeout_test].
+
+%% verifies that after the runner has to be killed for taking too long
+%% that everything is still functional and the exporter does not crash
+exporting_timeout_test(_Config) ->
+    process_flag(trap_exit, true),
+
+    {ok, Pid, _} = otel_batch_processor:start_link(#{name => test_processor,
+                                                     resource => otel_resource:create([]),
+                                                     exporter => ?MODULE,
+                                                     exporting_timeout_ms => 1,
+                                                     scheduled_delay_ms => 1}),
+
+    receive
+        {'EXIT', Pid, _} ->
+            %% test is to ensure we don't hit this
+            ct:fail(batch_processor_crash)
+    after
+        100 ->
+            ok
+    end.
+
+check_table_size_test(_Config) ->
+    MaxQueueSize = 10,
+    CheckTableSizeMs = 1,
+    {ok, _Pid, #{reg_name := RegName}} = otel_batch_processor:start_link(
+                                           #{name => test_processor_check_size_test,
+                                             resource => otel_resource:create([]),
+                                             exporter => ?MODULE,
+                                             exporting_timeout_ms => timer:minutes(10),
+                                             %% long enough, so that it never happens during the test
+                                             scheduled_delay_ms => timer:minutes(10),
+                                             check_table_size_ms => CheckTableSizeMs,
+                                             max_queue_size => MaxQueueSize}
+                                          ),
+    %% max_queue_size limit is not reached
+    true = otel_batch_processor:on_end(generate_span(), #{reg_name => RegName}),
+    lists:foreach(fun(_) ->
+                          otel_batch_processor:on_end(generate_span(), #{reg_name => RegName})
+                  end,
+                  lists:seq(1, MaxQueueSize)),
+    %% Wait for more than CheckTablesizeMS to be sure  check timeout occurred
+    timer:sleep(CheckTableSizeMs * 5),
+    dropped = otel_batch_processor:on_end(generate_span(), #{reg_name => RegName}),
+
+    otel_batch_processor:force_flush(#{reg_name => RegName}),
+    %% force_flush is async, have to wait for some long enough time again,
+    timer:sleep(CheckTableSizeMs * 10),
+    true = otel_batch_processor:on_end(generate_span(), #{reg_name => RegName}).
+
+exporting_runner_timeout_test(_Config) ->
+    process_flag(trap_exit, true),
+
+    {ok, Pid, #{reg_name := RegName}} = otel_batch_processor:start_link(
+                                          #{name => test_processor1,
+                                            resource => otel_resource:create([]),
+                                            exporter => ?MODULE,
+                                            exporting_timeout_ms => 1,
+                                            scheduled_delay_ms => 1}),
+
+    %% Insert a few spans to make sure runner process will be spawned and killed
+    %% because it hangs for 10 minutes (see export/4 below)
+    true = otel_batch_processor:on_end(generate_span(), #{reg_name => RegName}),
+    true = otel_batch_processor:on_end(generate_span(), #{reg_name => RegName}),
+
+    receive
+        {'EXIT', Pid, _} ->
+            %% test is to ensure we don't hit this
+            ct:fail(batch_processor_crash)
+    after
+        200 ->
+            ok
+    end.
+
+%% exporter behaviour
+
+init(_) ->
+    {ok, []}.
+
+export(_, _, _, _) ->
+    timer:sleep(timer:minutes(10)).
+
+shutdown(_) ->
+    ok.
+
+%% helpers
+
+generate_span() ->
+    #span{trace_id = otel_id_generator:generate_trace_id(),
+          span_id = otel_id_generator:generate_span_id(),
+          name = "test_span",
+          trace_flags = 1,
+          is_recording = true,
+          instrumentation_scope = #instrumentation_scope{name = "test"}}.

apps/opentelemetry/test/otel_configuration_SUITE.erl

@@ -0,0 +1,420 @@
+-module(otel_configuration_SUITE).
+
+-compile(export_all).
+
+-include_lib("stdlib/include/assert.hrl").
+-include_lib("common_test/include/ct.hrl").
+
+-include("otel_span.hrl").
+
+-define(assertIsSubset(X, Y),
+        lists:foreach(fun({K, V}) ->
+                              V1 = proplists:get_value(K, Y, undefined),
+                              %% include the key in the assert so it is there
+                              %% in the error message if it fails
+                              ?assertEqual({K, V}, {K, V1})
+                      end, X)).
+
+all() ->
+    [empty_os_environment, sampler, sampler_parent_based, sampler_parent_based_zero,
+     sampler_trace_id, sampler_trace_id_default, sampler_parent_based_one,
+     log_level, propagators, propagators_b3, propagators_b3multi, otlp_exporter,
+     jaeger_exporter, zipkin_exporter, none_exporter, app_env_exporter,
+     otlp_metrics_exporter, none_metrics_exporter, span_limits, bad_span_limits,
+     bad_app_config, deny_list, resource_detectors, span_processors].
+
+init_per_testcase(empty_os_environment, Config) ->
+    Vars = [],
+    [{os_vars, Vars} | Config];
+init_per_testcase(log_level, Config) ->
+    Vars = [{"OTEL_LOG_LEVEL", "error"}],
+
+    setup_env(Vars),
+
+    [{os_vars, Vars} | Config];
+init_per_testcase(propagators, Config) ->
+    Vars = [{"OTEL_PROPAGATORS", "baggage,afakeone"}],
+
+    setup_env(Vars),
+
+    [{os_vars, Vars} | Config];
+init_per_testcase(propagators_b3, Config) ->
+    Vars = [{"OTEL_PROPAGATORS", "b3"}],
+
+    setup_env(Vars),
+
+    [{os_vars, Vars} | Config];
+init_per_testcase(propagators_b3multi, Config) ->
+    Vars = [{"OTEL_PROPAGATORS", "b3multi"}],
+
+    setup_env(Vars),
+
+    [{os_vars, Vars} | Config];
+init_per_testcase(sampler, Config) ->
+    Vars = [{"OTEL_TRACES_SAMPLER", "parentbased_always_off"}],
+
+    setup_env(Vars),
+
+    [{os_vars, Vars} | Config];
+init_per_testcase(sampler_trace_id, Config) ->
+    Vars = [{"OTEL_TRACES_SAMPLER", "traceidratio"},
+            {"OTEL_TRACES_SAMPLER_ARG", "0.5"}],
+
+    setup_env(Vars),
+
+    [{os_vars, Vars} | Config];
+init_per_testcase(sampler_trace_id_default, Config) ->
+    Vars = [{"OTEL_TRACES_SAMPLER", "traceidratio"}],
+
+    setup_env(Vars),
+
+    [{os_vars, Vars} | Config];
+init_per_testcase(sampler_parent_based, Config) ->
+    Vars = [{"OTEL_TRACES_SAMPLER", "parentbased_traceidratio"},
+            {"OTEL_TRACES_SAMPLER_ARG", "0.5"}],
+
+    setup_env(Vars),
+
+    [{os_vars, Vars} | Config];
+init_per_testcase(sampler_parent_based_one, Config) ->
+    Vars = [{"OTEL_TRACES_SAMPLER", "parentbased_traceidratio"},
+            {"OTEL_TRACES_SAMPLER_ARG", "1"}],
+
+    setup_env(Vars),
+
+    [{os_vars, Vars} | Config];
+init_per_testcase(sampler_parent_based_zero, Config) ->
+    Vars = [{"OTEL_TRACES_SAMPLER", "parentbased_traceidratio"},
+            {"OTEL_TRACES_SAMPLER_ARG", "0"}],
+
+    setup_env(Vars),
+
+    [{os_vars, Vars} | Config];
+init_per_testcase(otlp_exporter, Config) ->
+    Vars = [{"OTEL_TRACES_EXPORTER", "otlp"}],
+
+    setup_env(Vars),
+
+    [{os_vars, Vars} | Config];
+init_per_testcase(zipkin_exporter, Config) ->
+    Vars = [{"OTEL_TRACES_EXPORTER", "zipkin"}],
+
+    setup_env(Vars),
+
+    [{os_vars, Vars} | Config];
+init_per_testcase(jaeger_exporter, Config) ->
+    Vars = [{"OTEL_TRACES_EXPORTER", "jaeger"}],
+
+    setup_env(Vars),
+
+    [{os_vars, Vars} | Config];
+init_per_testcase(none_exporter, Config) ->
+    Vars = [{"OTEL_TRACES_EXPORTER", "none"}],
+
+    setup_env(Vars),
+
+    [{os_vars, Vars} | Config];
+
+init_per_testcase(otlp_metrics_exporter, Config) ->
+    Vars = [{"OTEL_METRICS_EXPORTER", "otlp"}],
+
+    setup_env(Vars),
+
+    [{os_vars, Vars} | Config];
+init_per_testcase(none_metrics_exporter, Config) ->
+    Vars = [{"OTEL_METRICS_EXPORTER", "none"}],
+
+    setup_env(Vars),
+
+    [{os_vars, Vars} | Config];
+init_per_testcase(deny_list, Config) ->
+    Vars = [{"OTEL_DENY_LIST", "opentelemetry_exporter,opentelemetry,nonexisting_atom"}],
+
+    setup_env(Vars),
+
+    [{os_vars, Vars} | Config];
+init_per_testcase(resource_detectors, Config) ->
+    Vars = [{"OTEL_RESOURCE_DETECTORS", "opentelemetry_exporter,opentelemetry,nonexisting_atom"}],
+
+    setup_env(Vars),
+
+    [{os_vars, Vars} | Config];
+init_per_testcase(span_limits, Config) ->
+    Vars = [{"OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT", "111"},
+            {"OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT", "009"},
+            {"OTEL_SPAN_EVENT_COUNT_LIMIT", "200"},
+            {"OTEL_SPAN_LINK_COUNT_LIMIT", "1101"},
+            {"OTEL_EVENT_ATTRIBUTE_COUNT_LIMIT", "400"},
+            {"OTEL_LINK_ATTRIBUTE_COUNT_LIMIT", "500"}],
+
+    setup_env(Vars),
+
+    ExpectedOpts = #{attribute_count_limit => 111,
+                     attribute_value_length_limit => 9,
+                     event_count_limit => 200,
+                     link_count_limit => 1101,
+                     attribute_per_event_limit => 400,
+                     attribute_per_link_limit => 500},
+    ExpectedRecord = #span_limits{attribute_count_limit=111,
+                                  attribute_value_length_limit=9,
+                                  event_count_limit=200,
+                                  link_count_limit=1101,
+                                  attribute_per_event_limit=400,
+                                  attribute_per_link_limit=500},
+
+    [{expected_opts, ExpectedOpts}, {expected_record, ExpectedRecord}, {os_vars, Vars} | Config];
+init_per_testcase(bad_span_limits, Config) ->
+    Vars = [{"OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT", "aaa"},
+            {"OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT", "bbb"},
+            {"OTEL_SPAN_EVENT_COUNT_LIMIT", "1d4"},
+            {"OTEL_SPAN_LINK_COUNT_LIMIT", "eee"},
+            {"OTEL_EVENT_ATTRIBUTE_COUNT_LIMIT", "$L%"},
+            {"OTEL_LINK_ATTRIBUTE_COUNT_LIMIT", "gibberish"}],
+
+    setup_env(Vars),
+
+    ExpectedOpts = #{},
+    ExpectedRecord = #span_limits{attribute_count_limit=128,
+                                  attribute_value_length_limit=infinity,
+                                  event_count_limit=128,
+                                  link_count_limit=128,
+                                  attribute_per_event_limit=128,
+                                  attribute_per_link_limit=128},
+
+    [{expected_opts, ExpectedOpts}, {expected_record, ExpectedRecord}, {os_vars, Vars} | Config];
+init_per_testcase(bad_app_config, Config) ->
+    [{os_vars, []} | Config];
+init_per_testcase(app_env_exporter, Config) ->
+
+    [{os_vars, []} | Config];
+init_per_testcase(span_processors, Config) ->
+    [{os_vars, []} | Config].
+
+end_per_testcase(_, Config) ->
+    Vars = ?config(os_vars, Config),
+
+    [os:unsetenv(Name) || {Name, _} <- Vars],
+
+    ok.
+
+empty_os_environment(_Config) ->
+    ?assertMatch(#{log_level := info,
+                   text_map_propagators := [trace_context, baggage],
+                   sampler := {parent_based, #{root := always_on}}},
+                 otel_configuration:merge_with_os([])),
+
+    ?assertMatch(#{log_level := error},
+                 otel_configuration:merge_with_os([{log_level, error}])),
+
+    ok.
+
+sampler(_Config) ->
+    ?assertMatch({parent_based, #{root := always_off}},
+                 maps:get(sampler, otel_configuration:merge_with_os([]))),
+
+    ok.
+
+sampler_parent_based(_Config) ->
+    ?assertMatch({parent_based, #{root := {trace_id_ratio_based, 0.5}}},
+                 maps:get(sampler, otel_configuration:merge_with_os([]))),
+
+    ok.
+
+sampler_trace_id(_Config) ->
+    ?assertMatch({trace_id_ratio_based, 0.5},
+                 maps:get(sampler, otel_configuration:merge_with_os([]))),
+
+    ok.
+
+sampler_trace_id_default(_Config) ->
+    ?assertMatch({trace_id_ratio_based, 1.0},
+                 maps:get(sampler, otel_configuration:merge_with_os([]))),
+
+    ok.
+
+sampler_parent_based_one(_Config) ->
+    ?assertMatch({parent_based, #{root := {trace_id_ratio_based, 1.0}}},
+                 maps:get(sampler, otel_configuration:merge_with_os([]))),
+
+    ok.
+
+sampler_parent_based_zero(_Config) ->
+    ?assertMatch({parent_based, #{root := {trace_id_ratio_based, +0.0}}},
+                 maps:get(sampler, otel_configuration:merge_with_os([]))),
+
+    ok.
+
+log_level(_Config) ->
+    ?assertMatch(#{log_level := error}, otel_configuration:merge_with_os([])),
+    ?assertMatch(#{log_level := error}, otel_configuration:merge_with_os([{log_level, info}])),
+
+    ok.
+
+propagators(_Config) ->
+    ?assertMatch(#{log_level := error,
+                   text_map_propagators := [baggage]},
+                 otel_configuration:merge_with_os([{log_level, error}])),
+
+    ok.
+
+propagators_b3(_Config) ->
+    ?assertMatch(#{log_level := error,
+                   text_map_propagators := [b3]},
+                 otel_configuration:merge_with_os([{log_level, error}])),
+
+    ok.
+
+propagators_b3multi(_Config) ->
+    ?assertMatch(#{log_level := error,
+                   text_map_propagators := [b3multi]},
+                 otel_configuration:merge_with_os([{log_level, error}])),
+
+    ok.
+
+otlp_exporter(_Config) ->
+    ?assertMatch({opentelemetry_exporter, #{}},
+                 maps:get(traces_exporter, otel_configuration:merge_with_os([]))),
+
+    ok.
+
+jaeger_exporter(_Config) ->
+    ?assertMatch(none,
+                 maps:get(traces_exporter, otel_configuration:merge_with_os([]))),
+    ok.
+
+zipkin_exporter(_Config) ->
+    ?assertMatch(none,
+                 maps:get(traces_exporter, otel_configuration:merge_with_os([]))),
+    ok.
+
+none_exporter(_Config) ->
+    ?assertMatch(none,
+                 maps:get(traces_exporter, otel_configuration:merge_with_os([]))),
+
+    ?assertMatch(#{processors := [{otel_simple_processor, #{exporter := none}}]},
+                 otel_configuration:merge_with_os([{span_processor, simple}])),
+
+    ?assertMatch(#{processors := [{otel_batch_processor, #{exporter := none}}]},
+                 otel_configuration:merge_with_os([{span_processor, batch}])),
+
+    ok.
+
+app_env_exporter(_Config) ->
+    ?assertMatch({someother_exporter, #{}},
+                 maps:get(traces_exporter,
+                          otel_configuration:merge_with_os([{traces_exporter, {someother_exporter, #{}}}]))),
+
+    ?assertMatch({opentelemetry_exporter, #{}},
+                 maps:get(traces_exporter,
+                          otel_configuration:merge_with_os([{traces_exporter, otlp}]))),
+
+    ?assertMatch(none,
+                 maps:get(traces_exporter,
+                          otel_configuration:merge_with_os([{traces_exporter, jaeger}]))),
+
+    ?assertMatch(none,
+                 maps:get(traces_exporter,
+                          otel_configuration:merge_with_os([{traces_exporter, zipkin}]))),
+
+    ok.
+
+otlp_metrics_exporter(_Config) ->
+    ?assertMatch({opentelemetry_exporter, #{}},
+                 maps:get(metrics_exporter, otel_configuration:merge_with_os([]))),
+
+    ok.
+
+none_metrics_exporter(_Config) ->
+    ?assertMatch(none,
+                 maps:get(metrics_exporter, otel_configuration:merge_with_os([]))),
+
+    ok.
+
+deny_list(_Config) ->
+    %% nonexisting_atom in the OTEL_DENY_LIST os var is dropped bc it isn't an existing atom
+    ?assertMatch(#{deny_list := [opentelemetry_exporter,opentelemetry]},
+                 otel_configuration:merge_with_os([])),
+
+    ok.
+
+resource_detectors(_Config) ->
+    %% nonexisting_atom in the OTEL_RESOURCE_DETECTORS os var is dropped bc it isn't an existing atom
+    ?assertMatch(#{resource_detectors := [opentelemetry_exporter,opentelemetry]},
+                 otel_configuration:merge_with_os([])),
+
+    ok.
+
+span_limits(Config) ->
+    compare_span_limits(Config).
+
+bad_span_limits(Config) ->
+    compare_span_limits(Config).
+
+bad_app_config(_Config) ->
+    ?assertMatch(#{attribute_value_length_limit := infinity},
+                 otel_configuration:merge_with_os([{attribute_value_length_limit, "aaa"}])),
+
+    ok.
+
+compare_span_limits(Config) ->
+    ExpectedRecord = ?config(expected_record, Config),
+    ExpectedOpts = maps:to_list(?config(expected_opts, Config)),
+    Opts = maps:to_list(otel_configuration:merge_with_os([])),
+
+    ?assertIsSubset(ExpectedOpts, Opts),
+
+    otel_span_limits:set(maps:from_list(Opts)),
+
+    SpanLimits = otel_span_limits:get(),
+
+    %% verifies the defaults because the base record has the defaults set as well
+    ?assertEqual(ExpectedRecord, SpanLimits),
+
+    ok.
+
+span_processors(_Config) ->
+    ?assertMatch(#{processors := [{otel_simple_processor, #{}}]},
+                 otel_configuration:merge_with_os([{span_processor, simple}])),
+
+    ?assertMatch(#{processors := [{otel_batch_processor, #{exporter := {opentelemetry_exporter,#{}},
+                                                           exporting_timeout_ms := 2,
+                                                           max_queue_size := 1,
+                                                           scheduled_delay_ms := 15000}}]},
+                 otel_configuration:merge_with_os([{span_processor, batch},
+                                                   {bsp_scheduled_delay_ms, 15000},
+                                                   {bsp_exporting_timeout_ms, 2},
+                                                   {bsp_max_queue_size, 1}])),
+
+    ?assertMatch(#{processors := [{otel_batch_processor, #{exporter := none}}]},
+                 otel_configuration:merge_with_os([{span_processor, batch},
+                                                   {traces_exporter, none}])),
+
+    ?assertMatch(#{processors := [{otel_batch_processor, #{exporter := {opentelemetry_exporter,#{}},
+                                                           exporting_timeout_ms := 30000,
+                                                           max_queue_size := 2048,
+                                                           scheduled_delay_ms := 5000}}]},
+                 otel_configuration:merge_with_os([{span_processor, batch}])),
+
+    ?assertMatch(#{processors := [{otel_batch_processor, #{exporter := {opentelemetry_exporter,
+                                                                        #{endpoints := ["https://example.com"]}},
+                                                           exporting_timeout_ms := 2,
+                                                           max_queue_size := 1,
+                                                           scheduled_delay_ms := 15000}}]},
+                 otel_configuration:merge_with_os([{processors, [{otel_batch_processor, #{exporter => {opentelemetry_exporter,#{endpoints => ["https://example.com"]}},
+                                                                                          scheduled_delay_ms => 15000,
+                                                                                          max_queue_size => 4,
+                                                                                          exporting_timeout_ms => 3}}]},
+                                                   {bsp_exporting_timeout_ms, 2},
+                                                   {bsp_max_queue_size, 1}])),
+
+    ?assertMatch(#{processors := [{otel_simple_processor, #{exporter := {opentelemetry_exporter,#{}},
+                                                            exporting_timeout_ms := 2}}]},
+                 otel_configuration:merge_with_os([{span_processor, simple},
+                                                   {ssp_exporting_timeout_ms, 2}])),
+
+    ok.
+
+%%
+
+setup_env(Vars) ->
+    [os:putenv(Name, Value) || {Name, Value} <- Vars].

apps/opentelemetry/test/otel_propagation_SUITE.erl

@@ -0,0 +1,201 @@
+-module(otel_propagation_SUITE).
+
+-compile(export_all).
+
+-include_lib("stdlib/include/assert.hrl").
+-include_lib("common_test/include/ct.hrl").
+
+-include_lib("opentelemetry_api/include/opentelemetry.hrl").
+-include_lib("opentelemetry_api/include/otel_tracer.hrl").
+-include("otel_tracer.hrl").
+-include("otel_span.hrl").
+-include("otel_test_utils.hrl").
+-include("otel_sampler.hrl").
+-include("otel_span_ets.hrl").
+
+all() ->
+    [override_propagators,
+     {group, w3c},
+     {group, b3multi},
+     {group, b3}].
+
+groups() ->
+    [{w3c, [], [propagation]},
+     {b3multi, [], [propagation]},
+     {b3, [], [propagation]}].
+
+init_per_suite(Config) ->
+    application:load(opentelemetry),
+    application:set_env(opentelemetry, processors, [{otel_batch_processor, #{scheduled_delay_ms => 1,
+                                                                             exporter => none}}]),
+    {ok, _} = application:ensure_all_started(opentelemetry),
+    Config.
+
+end_per_suite(_Config) ->
+    application:unload(opentelemetry),
+    ok.
+
+init_per_group(Propagator, Config) when Propagator =:= w3c ;
+                                        Propagator =:= b3multi ;
+                                        Propagator =:= b3 ->
+    %% start in group as well since we must stop it after each group run
+    {ok, _} = application:ensure_all_started(opentelemetry),
+
+    case Propagator of
+        w3c ->
+            CompositePropagator = otel_propagator_text_map_composite:create([baggage, trace_context]),
+            opentelemetry:set_text_map_propagator(CompositePropagator);
+        b3multi ->
+            CompositePropagator = otel_propagator_text_map_composite:create([baggage, b3multi]),
+            opentelemetry:set_text_map_propagator(CompositePropagator);
+        b3 ->
+            CompositePropagator = otel_propagator_text_map_composite:create([baggage, b3]),
+            opentelemetry:set_text_map_propagator(CompositePropagator)
+    end,
+
+    [{propagator, Propagator} | Config].
+
+end_per_group(_, _Config) ->
+    _ = application:stop(opentelemetry).
+
+propagation(Config) ->
+    Propagator = ?config(propagator, Config),
+    SpanCtx=#span_ctx{trace_id=TraceId,
+                      span_id=SpanId} = ?start_span(<<"span-1">>),
+    ?set_current_span(SpanCtx),
+
+    ?assertMatch(#span_ctx{trace_flags=1}, ?current_span_ctx),
+    ?assertMatch(#span_ctx{is_recording=true}, ?current_span_ctx),
+
+
+    otel_baggage:set("key-1", <<"value=1">>, []),
+    %% TODO: should the whole baggage entry be dropped if metadata is bad?
+    %% drop bad metadata (the `1').
+    otel_baggage:set(<<"key-2">>, <<"value-2">>, [<<"metadata">>, 1, {<<"md-k-1">>, <<"md-v-1">>}]),
+    %% drop baggage with bad value
+    otel_baggage:set(<<"key-3">>, value3),
+
+    Headers = otel_propagator_text_map:inject([{<<"existing-header">>, <<"I exist">>}]),
+
+    EncodedTraceId = io_lib:format("~32.16.0b", [TraceId]),
+    EncodedSpanId = io_lib:format("~16.16.0b", [SpanId]),
+
+    ?assertListsEqual([{<<"baggage">>, <<"key-2=value-2;metadata;md-k-1=md-v-1,key-1=value%3D1">>},
+                       {<<"existing-header">>, <<"I exist">>} |
+                       trace_context(Propagator, EncodedTraceId, EncodedSpanId)], Headers),
+
+    otel_span:end_span(SpanCtx),
+
+    ?assertEqual(#{<<"key-1">> => {<<"value=1">>, []},
+                   <<"key-2">> => {<<"value-2">>, [<<"metadata">>, {<<"md-k-1">>, <<"md-v-1">>}]}},
+                 otel_baggage:get_all()),
+
+    %% ?end_span doesn't remove the span from the context
+    ?assertEqual(SpanCtx, ?current_span_ctx),
+    ?set_current_span(undefined),
+    ?assertEqual(undefined, ?current_span_ctx),
+
+    %% clear our baggage from the context to test extraction
+    otel_baggage:clear(),
+    ?assertEqual(#{}, otel_baggage:get_all()),
+
+    %% make header keys uppercase to validate the extractor is case insensitive
+    BinaryHeaders = [{string:uppercase(Key), iolist_to_binary(Value)} || {Key, Value} <- Headers],
+    otel_propagator_text_map:extract(BinaryHeaders),
+
+    ?assertEqual(#{<<"key-1">> => {<<"value=1">>, []},
+                   <<"key-2">> => {<<"value-2">>, [<<"metadata">>, {<<"md-k-1">>, <<"md-v-1">>}]}},
+                 otel_baggage:get_all()),
+
+    %% extracted remote spans are set to the active span
+    %% but with `is_recording' false
+    ?assertMatch(#span_ctx{is_recording=false}, ?current_span_ctx),
+
+    #span_ctx{trace_id=TraceId2,
+              span_id=_SpanId2} = ?start_span(<<"span-2">>),
+
+    %% new span should be a child of the extracted span
+    ?assertEqual(TraceId, TraceId2),
+
+    ok.
+
+override_propagators(_Config) ->
+    SpanCtx=#span_ctx{} = ?start_span(<<"span-1">>),
+    ?set_current_span(SpanCtx),
+
+    ?assertMatch(#span_ctx{trace_flags=1}, ?current_span_ctx),
+    ?assertMatch(#span_ctx{is_recording=true}, ?current_span_ctx),
+
+
+    otel_baggage:set("key-1", <<"value=1">>, []),
+    %% TODO: should the whole baggage entry be dropped if metadata is bad?
+    %% drop bad metadata (the `1').
+    otel_baggage:set(<<"key-2">>, <<"value-2">>, [<<"metadata">>, 1, {<<"md-k-1">>, <<"md-v-1">>}]),
+    %% drop baggage with bad value
+    otel_baggage:set(<<"key-3">>, value3),
+
+    Headers = otel_propagator_text_map:inject({otel_propagator_baggage, []}, [{<<"existing-header">>, <<"I exist">>}]),
+
+    %% the manually set propagators does not include trace_context or b3multi
+    %% so header must only have the existing-header and the baggage
+    ?assertListsEqual([{<<"baggage">>, <<"key-2=value-2;metadata;md-k-1=md-v-1,key-1=value%3D1">>},
+                       {<<"existing-header">>, <<"I exist">>}], Headers),
+
+    otel_span:end_span(SpanCtx),
+
+    ?assertEqual(#{<<"key-1">> => {<<"value=1">>, []},
+                   <<"key-2">> => {<<"value-2">>, [<<"metadata">>, {<<"md-k-1">>, <<"md-v-1">>}]}},
+                 otel_baggage:get_all()),
+
+    %% ?end_span doesn't remove the span from the context
+    ?assertEqual(SpanCtx, ?current_span_ctx),
+    ?set_current_span(undefined),
+    ?assertEqual(undefined, ?current_span_ctx),
+
+    %% clear our baggage from the context to test extraction
+    otel_baggage:clear(),
+    ?assertEqual(#{}, otel_baggage:get_all()),
+
+    %% make header keys uppercase to validate the extractor is case insensitive
+    BinaryHeaders = [{string:uppercase(Key), iolist_to_binary(Value)} || {Key, Value} <- Headers],
+    otel_propagator_text_map:extract({otel_propagator_baggage, []}, BinaryHeaders),
+
+    ?assertEqual(#{<<"key-1">> => {<<"value=1">>, []},
+                   <<"key-2">> => {<<"value-2">>, [<<"metadata">>, {<<"md-k-1">>, <<"md-v-1">>}]}},
+                 otel_baggage:get_all()),
+
+    %% no trace extractor used so current span ctx remains undefined
+    ?assertEqual(undefined, ?current_span_ctx),
+
+    ok.
+
+%%
+
+assert_all_exported(Tid, SpanCtxs) ->
+    [assert_exported(Tid, SpanCtx) || SpanCtx <- SpanCtxs].
+
+assert_exported(Tid, #span_ctx{trace_id=TraceId,
+                               span_id=SpanId}) ->
+    ?UNTIL_NOT_EQUAL([], ets:match_object(Tid, #span{trace_id=TraceId,
+                                                     span_id=SpanId,
+                                                     _='_'})).
+
+assert_not_exported(Tid, #span_ctx{trace_id=TraceId,
+                                   span_id=SpanId}) ->
+    %% sleep so exporter has run before we check
+    %% since we can't do like when checking it exists with UNTIL
+    timer:sleep(100),
+    ?assertMatch([], ets:match(Tid, #span{trace_id=TraceId,
+                                          span_id=SpanId,
+                                          _='_'})).
+
+trace_context(w3c, EncodedTraceId, EncodedSpanId) ->
+    [{<<"traceparent">>,
+     iolist_to_binary([<<"00">>, "-", EncodedTraceId,"-", EncodedSpanId, "-", <<"01">>])}];
+trace_context(b3multi, EncodedTraceId, EncodedSpanId) ->
+    [{<<"X-B3-Sampled">>, <<"1">>},
+     {<<"X-B3-SpanId">>, iolist_to_binary(EncodedSpanId)},
+     {<<"X-B3-TraceId">>, iolist_to_binary(EncodedTraceId)}];
+trace_context(b3, EncodedTraceId, EncodedSpanId) ->
+    [{<<"b3">>,
+      iolist_to_binary([EncodedTraceId, "-", EncodedSpanId, "-", <<"1">>])}].

apps/opentelemetry/test/otel_resource_SUITE.erl

@@ -0,0 +1,386 @@
+-module(otel_resource_SUITE).
+
+-compile(export_all).
+
+-include_lib("stdlib/include/assert.hrl").
+-include_lib("common_test/include/ct.hrl").
+
+-include_lib("opentelemetry_api/include/opentelemetry.hrl").
+-include("otel_span.hrl").
+-include("otel_test_utils.hrl").
+-include("otel_tracer.hrl").
+
+%% TODO: negative testing. What a valid value is is still in flux so nothing bothering
+%% to write tests to limit what can be a value only have them become valid values.
+all() ->
+    [startup, startup_env_service_name, os_env_resource, app_env_resource, combining,
+     combining_conflicting_schemas, crash_detector, timeout_detector, release_service_name,
+     unknown_service_name, release_service_name_no_version, service_instance_id_env,
+     service_instance_id_env_attributes, {group, net_kernel_node_name}, service_instance_id_node_id2,
+     validate_keys, do_not_create_unneeded_atoms].
+
+groups() ->
+    [{net_kernel_node_name, [], [service_instance_id_node_id1,
+                                 service_instance_id_node_name]}].
+
+init_per_suite(Config) ->
+    Config.
+
+end_per_suite(_Config) ->
+    ok.
+
+init_per_group(net_kernel_node_name, Config) ->
+    case os:getenv("CI") of
+        "true" ->
+            {skip, github_ci};
+        _ ->
+            Config
+    end;
+init_per_group(_, Config) ->
+    Config.
+
+end_per_group(_, _Config) ->
+    ok.
+
+init_per_testcase(service_instance_id_node_name, Config) ->
+    start_net_kernel_and_detector([test@instance, shortnames]),
+    Config;
+init_per_testcase(service_instance_id_node_id1, Config) ->
+    start_net_kernel_and_detector([test@localhost, shortnames]),
+    Config;
+init_per_testcase(_, Config) ->
+    Config.
+
+end_per_testcase(TestCase, _Config) when TestCase =:= service_instance_id_node_name ;
+                                         TestCase =:= service_instance_id_node_id1 ->
+    net_kernel:stop(),
+    ok;
+end_per_testcase(_, _) ->
+    ok.
+
+startup(_Config) ->
+    try
+        os:putenv("OTEL_RESOURCE_ATTRIBUTES", "service.name=cttest,service.version=1.1.1"),
+
+        {ok, _} = application:ensure_all_started(opentelemetry),
+        Resource = otel_tracer_provider:resource(),
+        _ = application:stop(opentelemetry),
+
+        ?assertMatch(#{'service.name' := <<"cttest">>,
+                       'service.version' := <<"1.1.1">>}, otel_attributes:map(otel_resource:attributes(Resource))),
+        ok
+    after
+        os:unsetenv("OTEL_RESOURCE_ATTRIBUTES"),
+        application:stop(opentelemetry),
+        application:unload(opentelemetry)
+    end.
+
+startup_env_service_name(_Config) ->
+    try
+        os:putenv("OTEL_SERVICE_NAME", "env-service-name"),
+        os:putenv("OTEL_RESOURCE_ATTRIBUTES", "service.name=cttest,service.version=1.1.1"),
+
+        {ok, _} = application:ensure_all_started(opentelemetry),
+        Resource = otel_tracer_provider:resource(),
+        _ = application:stop(opentelemetry),
+
+        ?assertMatch(#{'service.name' := <<"env-service-name">>,
+                       'service.version' := <<"1.1.1">>}, otel_attributes:map(otel_resource:attributes(Resource))),
+        ok
+    after
+        os:unsetenv("OTEL_SERVICE_NAME"),
+        os:unsetenv("OTEL_RESOURCE_ATTRIBUTES"),
+        application:stop(opentelemetry),
+        application:unload(opentelemetry)
+    end.
+
+
+crash_detector(_Config) ->
+    try
+        application:load(opentelemetry),
+        application:set_env(opentelemetry, resource, #{<<"c">> => <<"d">>,
+                                                       "sk" => "sv"}),
+        os:putenv("OTEL_RESOURCE_ATTRIBUTES", "service.name=cttest,service.version=2.1.1"),
+
+        otel_resource_detector:start_link(#{resource_detectors => [otel_resource_env_var,
+                                                                   {otel_resource_detector_test, error},
+                                                                   otel_resource_app_env],
+                                            resource_detector_timeout => 100}),
+
+        Resource = otel_resource_detector:get_resource(),
+
+        ?assertMatch(#{'service.name' := <<"cttest">>,
+                       'service.version' := <<"2.1.1">>,
+                       c := <<"d">>,
+                       sk := <<"sv">>}, otel_attributes:map(otel_resource:attributes(Resource))),
+
+        ok
+    after
+        os:unsetenv("OTEL_RESOURCE_ATTRIBUTES"),
+        application:unload(opentelemetry)
+    end.
+
+timeout_detector(_Config) ->
+    try
+        application:load(opentelemetry),
+        application:set_env(opentelemetry, resource, #{<<"e">> => <<"f">>}),
+        os:putenv("OTEL_RESOURCE_ATTRIBUTES", "service.name=cttest,service.version=3.1.1"),
+
+        otel_resource_detector:start_link(#{resource_detectors => [otel_resource_env_var,
+                                                                   {otel_resource_detector_test, sleep},
+                                                                   otel_resource_app_env],
+                                            resource_detector_timeout => 100}),
+
+        Resource = otel_resource_detector:get_resource(),
+
+        ?assertMatch(#{'service.name' := <<"cttest">>,
+                       'service.version' := <<"3.1.1">>,
+                       e := <<"f">>}, otel_attributes:map(otel_resource:attributes(Resource))),
+
+        ?assertEqual(otel_resource:create([]), otel_resource_detector:get_resource(0)),
+
+        ok
+    after
+        os:unsetenv("OTEL_RESOURCE_ATTRIBUTES"),
+        application:unload(opentelemetry)
+    end.
+
+os_env_resource(_Config) ->
+    Resource = otel_resource_env_var:parse("service.name=cttest,service.version=1.1.1"),
+    Expected = [{"service.name", "cttest"}, {"service.version", "1.1.1"}],
+    ?assertEqual(Expected, Resource),
+    ok.
+
+app_env_resource(_Config) ->
+    Attributes = #{a => [{b,[{c,d}]}], service => #{name => <<"hello">>}},
+    Expected = [{<<"a.b.c">>, d}, {<<"service.name">>, <<"hello">>}],
+
+    %% sort because this is created from a map and need to make sure
+    %% the order is always the same when we do the assertion
+    ?assertEqual(Expected, lists:sort(otel_resource_app_env:parse(Attributes))),
+    ok.
+
+combining(_Config) ->
+    Resource1 = otel_resource:create(otel_resource_app_env:parse([{service, [{name, <<"other-name">>},
+                                                                             {version, "1.1.1"}]}]),
+                                     <<"https://opentelemetry.io/schemas/1.8.0">>),
+    Resource2 = otel_resource:create(otel_resource_env_var:parse("service.name=cttest,service.version=1.1.1"),
+                                     <<"https://opentelemetry.io/schemas/1.8.0">>),
+
+    Merged = otel_resource:merge(Resource1, Resource2),
+
+    Expected = otel_attributes:new([{'service.name', <<"other-name">>},
+                                    {'service.version', <<"1.1.1">>}], 128, 255),
+    ?assertEqual(Expected, otel_resource:attributes(Merged)),
+    ?assertEqual(<<"https://opentelemetry.io/schemas/1.8.0">>, otel_resource:schema_url(Merged)),
+    ok.
+
+combining_conflicting_schemas(_Config) ->
+    Resource1 = otel_resource:create(otel_resource_app_env:parse([{service, [{name, <<"other-name">>},
+                                                                             {version, "1.1.1"}]}]), <<"https://opentelemetry.io/schemas/1.8.0">>),
+    Resource2 = otel_resource:create(otel_resource_env_var:parse("service.name=cttest,service.version=1.1.1"),
+                                     <<"https://opentelemetry.io/schemas/1.7.0">>),
+
+    Merged = otel_resource:merge(Resource1, Resource2),
+
+    Expected = otel_attributes:new([{'service.name', <<"other-name">>},
+                                    {'service.version', <<"1.1.1">>}], 128, 255),
+    ?assertEqual(Expected, otel_resource:attributes(Merged)),
+    ?assertEqual(undefined, otel_resource:schema_url(Merged)),
+    ok.
+
+unknown_service_name(_Config) ->
+    try
+        os:unsetenv("OTEL_RESOURCE_ATTRIBUTES"),
+
+        application:unload(opentelemetry),
+        application:load(opentelemetry),
+        application:set_env(opentelemetry, resource, #{<<"e">> => <<"f">>}),
+
+        otel_resource_detector:start_link(#{resource_detectors => [otel_resource_env_var,
+                                                                   otel_resource_app_env],
+                                            resource_detector_timeout => 100}),
+
+        Resource = otel_resource_detector:get_resource(),
+        ?assertMatch(#{'service.name' := <<"unknown_service:erl">>,
+                       'process.runtime.name' := <<"BEAM">>,
+                       'process.executable.name' := <<"erl">>,
+                       e := <<"f">>}, otel_attributes:map(otel_resource:attributes(Resource))),
+
+        ok
+    after
+        os:unsetenv("OTEL_RESOURCE_ATTRIBUTES")
+    end.
+
+release_service_name(_Config) ->
+    try
+        os:putenv("RELEASE_NAME", "rel-cttest"),
+        os:putenv("RELEASE_VSN", "0.1.0"),
+        application:unload(opentelemetry),
+        application:load(opentelemetry),
+        application:set_env(opentelemetry, resource, #{<<"e">> => <<"f">>}),
+
+        otel_resource_detector:start_link(#{resource_detectors => [otel_resource_env_var,
+                                                                   otel_resource_app_env],
+                                            resource_detector_timeout => 100}),
+
+        Resource = otel_resource_detector:get_resource(),
+        ?assertMatch(#{'service.name' := <<"rel-cttest">>,
+                       'service.version' := <<"0.1.0">>,
+                       e := <<"f">>}, otel_attributes:map(otel_resource:attributes(Resource))),
+
+        ok
+    after
+        os:unsetenv("RELEASE_VSN"),
+        os:unsetenv("RELEASE_NAME")
+    end.
+
+service_instance_id_env(_Config) ->
+    try
+        os:putenv("OTEL_SERVICE_INSTANCE", "test@instance"),
+        application:unload(opentelemetry),
+        application:load(opentelemetry),
+        application:set_env(opentelemetry, resource, #{<<"e">> => <<"f">>}),
+
+        otel_resource_detector:start_link(#{resource_detectors => [otel_resource_env_var,
+                                                                   otel_resource_app_env],
+                                            resource_detector_timeout => 100}),
+
+        Resource = otel_resource_detector:get_resource(),
+        ?assertMatch(#{'service.instance.id' := <<"test@instance">>,
+                       e := <<"f">>}, otel_attributes:map(otel_resource:attributes(Resource))),
+
+        ok
+    after
+        os:unsetenv("OTEL_SERVICE_INSTANCE")
+    end.
+
+service_instance_id_env_attributes(_Config) ->
+    try
+        os:putenv("OTEL_RESOURCE_ATTRIBUTES", "service.instance.id=test@instance"),
+        application:unload(opentelemetry),
+        application:load(opentelemetry),
+        application:set_env(opentelemetry, resource, #{<<"e">> => <<"f">>}),
+
+        otel_resource_detector:start_link(#{resource_detectors => [otel_resource_env_var,
+                                                                   otel_resource_app_env],
+                                            resource_detector_timeout => 100}),
+
+        Resource = otel_resource_detector:get_resource(),
+        ?assertMatch(#{'service.instance.id' := <<"test@instance">>,
+                       e := <<"f">>}, otel_attributes:map(otel_resource:attributes(Resource))),
+
+        ok
+    after
+        os:unsetenv("OTEL_RESOURCE_ATTRIBUTES")
+    end.
+
+service_instance_id_node_name(_Config) ->
+    Resource = otel_resource_detector:get_resource(),
+    ?assertMatch(#{'service.instance.id' := <<"test@instance">>,
+                   e := <<"f">>}, otel_attributes:map(otel_resource:attributes(Resource))),
+
+    ok.
+
+service_instance_id_node_id1(_Config) ->
+    Resource = otel_resource_detector:get_resource(),
+    ResourceMap = otel_attributes:map(otel_resource:attributes(Resource)),
+    ?assertNotMatch(#{'service.instance.id' := <<"test@localhost">>}, ResourceMap),
+    ?assert(maps:is_key('service.instance.id', ResourceMap)),
+
+    ok.
+
+service_instance_id_node_id2(_Config) ->
+    application:unload(opentelemetry),
+    application:load(opentelemetry),
+    application:set_env(opentelemetry, resource, #{<<"e">> => <<"f">>}),
+
+    otel_resource_detector:start_link(#{resource_detectors => [otel_resource_env_var,
+                                                                otel_resource_app_env],
+                                        resource_detector_timeout => 100}),
+
+    Resource = otel_resource_detector:get_resource(),
+    ResourceMap = otel_attributes:map(otel_resource:attributes(Resource)),
+    ?assertNotMatch(#{'service.instance.id' := <<"nonode@nohost">>}, ResourceMap),
+    ?assert(maps:is_key('service.instance.id', ResourceMap)),
+    ok.
+
+release_service_name_no_version(_Config) ->
+    try
+        os:putenv("RELEASE_NAME", "rel-cttest"),
+        application:unload(opentelemetry),
+        application:load(opentelemetry),
+        application:set_env(opentelemetry, resource, #{<<"e">> => <<"f">>}),
+
+        otel_resource_detector:start_link(#{resource_detectors => [otel_resource_env_var,
+                                                                   otel_resource_app_env],
+                                            resource_detector_timeout => 100}),
+
+        Resource = otel_resource_detector:get_resource(),
+        ?assertMatch(#{'service.name' := <<"rel-cttest">>,
+                       e := <<"f">>}, otel_attributes:map(otel_resource:attributes(Resource))),
+        ?assertNot(maps:is_key('service.version', otel_attributes:map(otel_resource:attributes(Resource)))),
+
+        ok
+    after
+        os:unsetenv("RELEASE_NAME")
+    end.
+
+validate_keys(_Config) ->
+    application:unload(opentelemetry),
+    application:load(opentelemetry),
+    application:set_env(opentelemetry, resource, #{
+                                                   <<"e">> => <<"f">>,
+                                                   service => #{
+                                                                <<"name">> => <<"name">>,
+                                                                alias => <<"alias">>
+                                                               },
+                                                   g => <<"h">>,
+                                                   '' => <<"i">>,
+                                                   'ə' => <<"j">>
+                                                  }),
+
+    otel_resource_detector:start_link(#{resource_detectors => [otel_resource_app_env],
+                                        resource_detector_timeout => 100}),
+
+    Resource = otel_resource_detector:get_resource(),
+    ?assert(otel_resource:is_key(e, Resource)),
+    ?assert(otel_resource:is_key('service.name', Resource)),
+    ?assert(otel_resource:is_key(<<"service.alias">>, Resource)),
+    ?assert(otel_resource:is_key("service.alias", Resource)),
+    ?assert(otel_resource:is_key('service.alias', Resource)),
+    ?assert(otel_resource:is_key(g, Resource)),
+    ?assertNot(otel_resource:is_key('ə', Resource)),
+    ?assertNot(otel_resource:is_key('', Resource)),
+
+    ok.
+
+do_not_create_unneeded_atoms(_Config) ->
+    NonAtomBinary = fun NonAtomBinaryF(0) ->
+                            error(max_iterations);
+                        NonAtomBinaryF(N) ->
+                            Candidate = << <<($a + rand:uniform(6) - 1)>> || _ <- lists:seq(1,8) >>,
+                            try binary_to_existing_atom(Candidate, latin1) of
+                                _ -> NonAtomBinaryF(N - 1)
+                            catch error:badarg -> Candidate
+                            end
+                    end(100),
+    otel_resource_detector:start_link(#{resource_detectors => [otel_resource_app_env],
+                                        resource_detector_timeout => 100}),
+    Resource = otel_resource_detector:get_resource(),
+    ?assertNot(otel_resource:is_key(NonAtomBinary, Resource)),
+    ?assertError(badarg, binary_to_existing_atom(NonAtomBinary, latin1)),
+    ok.
+
+%%
+
+start_net_kernel_and_detector(NetKernelArgs) ->
+    ?assertMatch({ok, _}, net_kernel:start(NetKernelArgs)),
+    application:unload(opentelemetry),
+    application:load(opentelemetry),
+    application:set_env(opentelemetry, resource, #{<<"e">> => <<"f">>}),
+
+    otel_resource_detector:start_link(#{resource_detectors => [otel_resource_env_var,
+                                                               otel_resource_app_env],
+                                        resource_detector_timeout => 100}),
+    ok.

apps/opentelemetry/test/otel_resource_detector_test.erl

@@ -0,0 +1,9 @@
+-module(otel_resource_detector_test).
+
+-export([get_resource/1]).
+
+get_resource(sleep) ->
+    timer:sleep(5000),
+    otel_resource:create([{<<"some-test-resource">>, <<"some-test-value">>}]);
+get_resource(error) ->
+    erlang:error(some_failure).

apps/opentelemetry/test/otel_samplers_SUITE.erl

@@ -0,0 +1,345 @@
+-module(otel_samplers_SUITE).
+
+-compile(export_all).
+
+-include_lib("stdlib/include/assert.hrl").
+-include_lib("common_test/include/ct.hrl").
+
+-include_lib("opentelemetry_api/include/opentelemetry.hrl").
+-include("otel_sampler.hrl").
+
+all() ->
+    [trace_id_ratio_based, parent_based, get_description, custom_sampler_module,
+     custom_attributes_sampler].
+
+init_per_suite(Config) ->
+    application:load(opentelemetry),
+    %% set application environment variables
+    {ok, _} = application:ensure_all_started(opentelemetry),
+    Config.
+
+end_per_suite(_Config) ->
+    ok = application:stop(opentelemetry).
+
+init_per_testcase(_, Config) ->
+    Config.
+
+end_per_testcase(_, _Config) ->
+    ok.
+
+get_description(_Config) ->
+    Probability = 0.5,
+    Sampler = otel_sampler:new({trace_id_ratio_based, Probability}),
+
+    ?assertEqual(<<"TraceIdRatioBased{0.500000}">>, otel_sampler:description(Sampler)),
+
+    ParentBasedSampler = otel_sampler:new(
+        {parent_based, #{
+            root => {trace_id_ratio_based, Probability}
+        }}
+    ),
+    ?assertEqual(
+        <<"ParentBased{root:TraceIdRatioBased{0.500000},remoteParentSampled:AlwaysOnSampler,remoteParentNotSampled:AlwaysOffSampler,localParentSampled:AlwaysOnSampler,localParentNotSampled:AlwaysOffSampler}">>,
+        otel_sampler:description(ParentBasedSampler)
+    ),
+
+    ok.
+
+trace_id_ratio_based(_Config) ->
+    SpanName = <<"span-prob-sampled">>,
+    Probability = 0.5,
+    DoSample = 120647249294066572380176333851662846319,
+    DoNotSample = 53020601517903903921384168845238205400,
+    EmptyTracestate = otel_tracestate:new(),
+
+    Ctx = otel_ctx:new(),
+
+    %% sampler that runs on all spans
+    {Sampler, _, Opts} = otel_sampler:new({trace_id_ratio_based, Probability}),
+
+    %% checks the trace id is under the upper bound
+    ?assertMatch(
+        {?RECORD_AND_SAMPLE, [], EmptyTracestate},
+        Sampler:should_sample(
+            otel_tracer:set_current_span(Ctx, undefined),
+            DoSample,
+            [],
+            SpanName,
+            undefined,
+            [],
+            Opts
+        )
+    ),
+
+    %% checks the trace id is is over the upper bound
+    ?assertMatch(
+        {?DROP, [], EmptyTracestate},
+        Sampler:should_sample(
+            otel_tracer:set_current_span(Ctx, undefined),
+            DoNotSample,
+            [],
+            SpanName,
+            undefined,
+            [],
+            Opts
+        )
+    ),
+
+    %% ignores the parent span context trace flags
+    ?assertEqual(
+        {?DROP, [], otel_tracestate:new()},
+        Sampler:should_sample(
+            otel_tracer:set_current_span(Ctx, #span_ctx{
+                trace_flags = 1,
+                is_remote = true
+            }),
+            DoNotSample,
+            [],
+            SpanName,
+            undefined,
+            [],
+            Opts
+        )
+    ),
+
+    %% ignores the parent span context trace flags
+    ?assertEqual(
+        {?RECORD_AND_SAMPLE, [], otel_tracestate:new()},
+        Sampler:should_sample(
+            otel_tracer:set_current_span(Ctx, #span_ctx{
+                trace_flags = 0,
+                is_remote = false
+            }),
+            DoSample,
+            [],
+            SpanName,
+            undefined,
+            [],
+            Opts
+        )
+    ),
+
+    %% trace id is under the upper bound
+    ?assertEqual(
+        {?RECORD_AND_SAMPLE, [], otel_tracestate:new()},
+        Sampler:should_sample(
+            otel_tracer:set_current_span(Ctx, #span_ctx{
+                trace_flags = 0,
+                is_remote = true
+            }),
+            DoSample,
+            [],
+            SpanName,
+            undefined,
+            [],
+            Opts
+        )
+    ),
+
+    ok.
+
+parent_based(_Config) ->
+    SpanName = <<"span-prob-sampled">>,
+    Probability = 0.5,
+    DoSample = 120647249294066572380176333851662846319,
+    DoNotSample = 53020601517903903921384168845238205400,
+    EmptyTracestate = otel_tracestate:new(),
+
+    Ctx = otel_ctx:new(),
+
+    {Sampler, _, Opts} = otel_sampler:new(
+        {parent_based, #{root => {trace_id_ratio_based, Probability}}}
+    ),
+
+    %% with no parent it will run the probability sampler
+    ?assertEqual(
+        {?RECORD_AND_SAMPLE, [], EmptyTracestate},
+        Sampler:should_sample(
+            otel_tracer:set_current_span(Ctx, undefined),
+            DoSample,
+            [],
+            SpanName,
+            undefined,
+            [],
+            Opts
+        )
+    ),
+    ?assertEqual(
+        {?DROP, [], EmptyTracestate},
+        Sampler:should_sample(
+            otel_tracer:set_current_span(Ctx, undefined),
+            DoNotSample,
+            [],
+            SpanName,
+            undefined,
+            [],
+            Opts
+        )
+    ),
+
+    %% with parent it will use the parents value
+    ?assertEqual(
+        {?RECORD_AND_SAMPLE, [], EmptyTracestate},
+        Sampler:should_sample(
+            otel_tracer:set_current_span(Ctx, #span_ctx{
+                trace_flags = 1,
+                is_remote = true
+            }),
+            DoNotSample,
+            [],
+            SpanName,
+            undefined,
+            [],
+            Opts
+        )
+    ),
+    ?assertEqual(
+        {?DROP, [], EmptyTracestate},
+        Sampler:should_sample(
+            otel_tracer:set_current_span(Ctx, #span_ctx{
+                trace_flags = 0,
+                is_remote = true
+            }),
+            DoNotSample,
+            [],
+            SpanName,
+            undefined,
+            [],
+            Opts
+        )
+    ),
+
+    %% with no root sampler in setup opts the default sampler always_on is used
+    {DefaultParentOrElse, _, Opts1} = otel_sampler:new({parent_based, #{}}),
+
+    ?assertMatch(
+        {?RECORD_AND_SAMPLE, [], EmptyTracestate},
+        DefaultParentOrElse:should_sample(
+            otel_tracer:set_current_span(Ctx, undefined),
+            DoSample,
+            [],
+            SpanName,
+            undefined,
+            [],
+            Opts1
+        )
+    ),
+    ?assertMatch(
+        {?RECORD_AND_SAMPLE, [], EmptyTracestate},
+        DefaultParentOrElse:should_sample(
+            otel_tracer:set_current_span(Ctx, undefined),
+            DoNotSample,
+            [],
+            SpanName,
+            undefined,
+            [],
+            Opts1
+        )
+    ),
+
+    ?assertEqual(
+        {?RECORD_AND_SAMPLE, [], otel_tracestate:new()},
+        DefaultParentOrElse:should_sample(
+            otel_tracer:set_current_span(Ctx, #span_ctx{trace_flags = 1}),
+            DoNotSample,
+            [],
+            SpanName,
+            undefined,
+            [],
+            Opts1
+        )
+    ),
+    ?assertEqual(
+        {?DROP, [], otel_tracestate:new()},
+        DefaultParentOrElse:should_sample(
+            otel_tracer:set_current_span(Ctx, #span_ctx{
+                trace_flags = 0,
+                is_remote = true
+            }),
+            DoNotSample,
+            [],
+            SpanName,
+            undefined,
+            [],
+            Opts1
+        )
+    ),
+
+    ok.
+
+custom_sampler_module(_Config) ->
+    SpanName = <<"span-name">>,
+    {Sampler, _, Opts} = otel_sampler:new({static_sampler, #{SpanName => ?DROP}}),
+    ?assertMatch(
+        {?DROP, [], []},
+        Sampler:should_sample(
+            otel_ctx:new(),
+            otel_id_generator:generate_trace_id(),
+            [],
+            SpanName,
+            undefined,
+            [],
+            Opts
+        )
+    ),
+    ok.
+
+custom_attributes_sampler(_Config) ->
+    SpanName = <<"span-name">>,
+    {Sampler, _, Opts} = otel_sampler:new({attributes_sampler, #{'http.target' => <<"/healthcheck">>}}),
+    ?assertMatch(
+        {?DROP, [], []},
+        Sampler:should_sample(
+            otel_ctx:new(),
+            otel_id_generator:generate_trace_id(),
+            [],
+            SpanName,
+            undefined,
+            #{'http.target' => <<"/healthcheck">>,
+              a => b},
+            Opts
+        )
+    ),
+
+    ?assertMatch(
+       {?RECORD_AND_SAMPLE, [], []},
+       Sampler:should_sample(
+         otel_ctx:new(),
+         otel_id_generator:generate_trace_id(),
+         [],
+         SpanName,
+         undefined,
+         #{a => 1},
+         Opts
+        )
+      ),
+
+    ?assertMatch(
+       {?RECORD_AND_SAMPLE, [], []},
+       Sampler:should_sample(
+            otel_ctx:new(),
+            otel_id_generator:generate_trace_id(),
+            [],
+            SpanName,
+            undefined,
+            #{},
+            Opts
+        )
+    ),
+    ok.
+
+should_sample(_Config) ->
+    Sampler = otel_sampler:new(always_on),
+    ?assertMatch(
+        {?RECORD_AND_SAMPLE, [], []},
+        otel_samplers:should_sample(
+            Sampler,
+            otel_ctx:new(),
+            otel_id_generator:generate_trace_id(),
+            [],
+            <<"span-name">>,
+            undefined,
+            []
+        )
+    ),
+    ok.

apps/opentelemetry/test/otel_sweeper_SUITE.erl

@@ -2,19 +2,19 @@
 %%% @doc
 %%% @end
 %%% ---------------------------------------------------------------------------
--module(ot_sweeper_SUITE).
+-module(otel_sweeper_SUITE).
 
 -compile(export_all).
 
 -include_lib("eunit/include/eunit.hrl").
 -include_lib("common_test/include/ct.hrl").
 
--include("ot_test_utils.hrl").
--include("ot_span.hrl").
+-include("otel_test_utils.hrl").
+-include("otel_span.hrl").
 -include_lib("opentelemetry_api/include/opentelemetry.hrl").
--include_lib("opentelemetry_api/include/tracer.hrl").
+-include_lib("opentelemetry_api/include/otel_tracer.hrl").
 
--include("../src/ot_span_ets.hrl").
+-include("../src/otel_span_ets.hrl").
 
 all() ->
     [storage_size,
@@ -28,6 +28,7 @@ init_per_suite(Config) ->
 
 end_per_suite(_Config) ->
     application:unload(opentelemetry),
+    application:stop(opentelemetry),
     ok.
 
 init_per_testcase(storage_size, Config) ->
@@ -35,22 +36,21 @@ init_per_testcase(storage_size, Config) ->
                                                   strategy => end_span,
                                                   span_ttl => 500,
                                                   storage_size => 100}),
-    application:set_env(opentelemetry, tracer, ot_tracer_default),
-    application:set_env(opentelemetry, processors, [{ot_batch_processor, #{scheduled_delay_ms => 1}}]),
+    application:set_env(opentelemetry, tracer, otel_tracer_default),
+    application:set_env(opentelemetry, processors, [{otel_batch_processor, #{scheduled_delay_ms => 1,
+                                                                            exporter => {otel_exporter_pid, self()}}}]),
     {ok, _} = application:ensure_all_started(opentelemetry),
 
-    ot_batch_processor:set_exporter(ot_exporter_pid, self()),
     Config;
 init_per_testcase(Type, Config) ->
     application:set_env(opentelemetry, sweeper, #{interval => 250,
                                                   strategy => Type,
                                                   span_ttl => 500}),
-    application:set_env(opentelemetry, tracer, ot_tracer_default),
-    application:set_env(opentelemetry, processors, [{ot_batch_processor, #{scheduled_delay_ms => 1}}]),
+    application:set_env(opentelemetry, tracer, otel_tracer_default),
+    application:set_env(opentelemetry, processors, [{otel_batch_processor, #{scheduled_delay_ms => 1,
+                                                                             exporter => {otel_exporter_pid, self()}}}]),
     {ok, _} = application:ensure_all_started(opentelemetry),
 
-    ot_batch_processor:set_exporter(ot_exporter_pid, self()),
-
     Config.
 
 end_per_testcase(_, _Config) ->
@@ -60,9 +60,13 @@ end_per_testcase(_, _Config) ->
 storage_size(_Config) ->
     SpanName1 = <<"span-1">>,
     SpanCtx = ?start_span(SpanName1),
+    ?set_current_span(SpanCtx),
 
     ChildSpanName1 = <<"child-span-1">>,
     ChildSpanCtx = ?start_span(ChildSpanName1),
+    ?set_current_span(ChildSpanCtx),
+
+    ?assertEqual(SpanCtx#span_ctx.trace_id, ChildSpanCtx#span_ctx.trace_id),
 
     [ChildSpanData] = ets:lookup(?SPAN_TAB, ChildSpanCtx#span_ctx.span_id),
     ?assertEqual(ChildSpanName1, ChildSpanData#span.name),
@@ -77,7 +81,7 @@ storage_size(_Config) ->
     %% should be no exported spans
     ?assertEqual(no_span, receive
                               {span, #span{name=N}} when N =:= SpanName1 ->
-                                  got_span
+                                  gotel_span
                           after
                               0 ->
                                   no_span
@@ -86,20 +90,22 @@ storage_size(_Config) ->
 drop(_Config) ->
     SpanName1 = <<"span-1">>,
     SpanCtx = ?start_span(SpanName1),
+    otel_tracer:set_current_span(SpanCtx),
 
     ChildSpanName1 = <<"child-span-1">>,
     ChildSpanCtx = ?start_span(ChildSpanName1),
+    otel_tracer:set_current_span(ChildSpanCtx),
 
     [ChildSpanData] = ets:lookup(?SPAN_TAB, ChildSpanCtx#span_ctx.span_id),
     ?assertEqual(ChildSpanName1, ChildSpanData#span.name),
     ?assertEqual(SpanCtx#span_ctx.span_id, ChildSpanData#span.parent_span_id),
 
-    ?end_span(),
+    otel_span:end_span(ChildSpanCtx),
 
     %% wait until the sweeper sweeps away the parent span
     ?UNTIL(ets:tab2list(?SPAN_TAB) =:= []),
 
-    ?end_span(),
+    otel_span:end_span(SpanCtx),
 
     receive
         {span, S=#span{name=Name}} when Name =:= ChildSpanName1 ->
@@ -116,7 +122,7 @@ drop(_Config) ->
     %% should be no exported span for span-1
     ?assertEqual(no_span, receive
                               {span, #span{name=N}} when N =:= SpanName1 ->
-                                  got_span
+                                  gotel_span
                           after
                               0 ->
                                   no_span
@@ -124,11 +130,14 @@ drop(_Config) ->
 
 end_span(_Config) ->
     SpanName1 = <<"span-1">>,
-    _SpanCtx = ?start_span(SpanName1),
+    SpanCtx = ?start_span(SpanName1),
+    otel_tracer:set_current_span(SpanCtx),
 
     ChildSpanName1 = <<"child-span-1">>,
-    _ChildSpanCtx = ?start_span(ChildSpanName1),
-    ?end_span(),
+    ChildSpanCtx = ?start_span(ChildSpanName1),
+    otel_tracer:set_current_span(ChildSpanCtx),
+
+    otel_span:end_span(SpanCtx),
 
     %% wait until the sweeper sweeps away the parent span
     ?UNTIL(ets:tab2list(?SPAN_TAB) =:= []),
@@ -147,15 +156,17 @@ end_span(_Config) ->
 failed_attribute_and_end_span(_Config) ->
     SpanName1 = <<"span-1">>,
     SpanCtx = ?start_span(SpanName1),
+    otel_tracer:set_current_span(SpanCtx),
 
     ChildSpanName1 = <<"child-span-1">>,
     ChildSpanCtx = ?start_span(ChildSpanName1),
+    otel_tracer:set_current_span(ChildSpanCtx),
 
     [ChildSpanData] = ets:lookup(?SPAN_TAB, ChildSpanCtx#span_ctx.span_id),
     ?assertEqual(ChildSpanName1, ChildSpanData#span.name),
     ?assertEqual(SpanCtx#span_ctx.span_id, ChildSpanData#span.parent_span_id),
 
-    ?end_span(),
+    otel_span:end_span(ChildSpanData),
 
     %% wait until the sweeper sweeps away the parent span
     ?UNTIL(ets:tab2list(?SPAN_TAB) =:= []),
@@ -164,7 +175,7 @@ failed_attribute_and_end_span(_Config) ->
         {span, S=#span{name=Name,
                        attributes=Attributes}} when Name =:= SpanName1 ->
             %% should have attribute finished_by_sweeper
-            ?assertMatch([{<<"finished_by_sweeper">>, true}], Attributes),
+            ?assertMatch(#{<<"finished_by_sweeper">> := true}, otel_attributes:map(Attributes)),
 
             %% Verify the end time and duration are set when the span was finished
             ?assertMatch(ST when is_integer(ST), S#span.start_time),

apps/opentelemetry/test/otel_test_utils.hrl

@@ -1,6 +1,6 @@
 %% Try for 1 seconds
 -define(UNTIL(X), (fun Until(I) when I =:= 10 ->
-                           ct:fail(timeout);
+                           ct:fail("timeout: UNTIL(~s)", [??X]);
                        Until(I) ->
                            case X of
                                true ->
@@ -13,7 +13,7 @@
 
 %% try for 1 second and also return the result of Y
 -define(UNTIL_NOT_EQUAL(X, Y), (fun Until(I) when I =:= 10 ->
-                                        ct:fail(timeout);
+                                        ct:fail("timeout: UNTIL_NOT_EQUAL(~s, ~s)", [??X, ??Y]);
                                     Until(I) ->
                                         R = Y,
                                         case X =/= R of
@@ -25,7 +25,10 @@
                                         end
                                 end)(0)).
 
--define(assertListsMatch(List1, List2), ?assertEqual(lists:sort(List1), lists:sort(List2))).
+-define(assertListsEqual(List1, List2), ?assertEqual(lists:sort(List1), lists:sort(List2))).
+
+-define(assertIsSubset(List1, List2), ?assertMatch([], sets:to_list(sets:subtract(sets:from_list(List1),
+                                                                                  sets:from_list(List2))))).
 
 %% a macro for asserting the important parts of a span ctx are equal
 %% parts we keep in the record like is_recording is not propagated and

apps/opentelemetry/test/static_sampler.erl

@@ -0,0 +1,14 @@
+-module(static_sampler).
+
+-behavior(otel_sampler).
+
+-export([description/1, setup/1, should_sample/7]).
+
+-include("otel_sampler.hrl").
+
+%% sampler returns the value from the Opts map based on the SpanName or `DROP'
+setup(Opts) -> Opts.
+
+description(_) -> <<"StaticSampler">>.
+
+should_sample(_, _, _, SpanName, _, _, Config) -> {maps:get(SpanName, Config, ?DROP), [], []}.

apps/opentelemetry_api/.formatter.exs

@@ -0,0 +1,3 @@
+[
+  inputs: ["{mix,.dialyzer_ignore,.formatter}.exs", "{lib,test}/**/*.{ex,exs}"]
+]

apps/opentelemetry_api/.gitignore

@@ -0,0 +1,33 @@
+edoc
+.rebar3
+_*
+.eunit
+*.o
+*.beam
+*.plt
+*.swp
+*.swo
+.erlang.cookie
+ebin
+log
+erl_crash.dump
+.rebar
+logs
+_build
+.idea
+*.iml
+rebar3.crashdump
+*~
+
+/_build
+/cover
+/deps
+/doc
+/.fetch
+erl_crash.dump
+*.ez
+*.beam
+/config/*.secret.exs
+.elixir_ls/
+
+/coverage.xml

apps/opentelemetry_api/LICENSE

@@ -0,0 +1,201 @@
+                                 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 [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.
+   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.

apps/opentelemetry_api/README.md

@@ -0,0 +1,269 @@
+# Erlang/Elixir OpenTelemetry API
+
+[![EEF Observability WG project](https://img.shields.io/badge/EEF-Observability-black)](https://github.com/erlef/eef-observability-wg)
+[![Hex.pm](https://img.shields.io/hexpm/v/opentelemetry)](https://hex.pm/packages/opentelemetry_api)
+
+This is the API portion of [OpenTelemetry](https://opentelemetry.io/) for Erlang
+and Elixir Applications, implementing the API portion of [the specification](https://github.com/open-telemetry/opentelemetry-specification).
+
+This is a library, it does not start any processes, and should be the only
+OpenTelemetry dependency of Erlang/Elixir Applications.
+
+## Use
+
+There are both Erlang and Elixir macros that make use of the current module's
+name to lookup a [Named
+Tracer](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/glossary.md#tracer-name--meter-name)
+-- a Named Tracer is created for each Application loaded in the system at start
+time -- for you and can be used for Trace and Span operations:
+
+``` erlang
+-include_lib("opentelemetry_api/include/otel_tracer.hrl").
+
+some_fun() ->
+    ?with_span(<<"some_fun/0">>, #{}, 
+        fun(_SpanCtx) -> 
+            ...
+            ?set_attribute(<<"key">>, <<"value">>),
+            ...
+        end),
+```
+
+``` elixir
+require OpenTelemetry.Tracer
+      
+def some_fun() do
+    OpenTelemetry.Tracer.with_span "some-span" do
+      ...
+      OpenTelemetry.Tracer.set_attribute("key", "value")
+      ...
+    end
+end
+```
+
+### Tracing API
+
+The macros and functions available for Elixir in `OpenTelemetry.Tracer` and the
+Erlang macros in `otel_tracer.hrl` are the best way to work with Spans. They
+will automatically use the Tracer named for the Application the module using the
+macro is in. For example, the Spans created in
+[opentelemetry_oban](https://hex.pm/packages/opentelemetry_oban) use the
+`with_span` macro resulting in the Span being created with the
+`opentelemetry_oban` named Tracer and associated with the [Instrumentation
+Library](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/glossary.md#instrumentation-library)
+of the same name and version of the Tracer -- the version also matches the
+`opentelemetry_oban` Application version.
+
+#### Context
+
+[Context](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/context/context.md) is used to pass values associated with the current [execution
+unit](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/glossary.md#execution-unit).
+At this time the only values kept in the Context by this OpenTelemetry library
+are the [Span
+Context](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#spancontext)
+for the currently active Span and the
+[Baggage](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/baggage/api.md)
+
+When a Context variable is not an explicit argument in the API macros or
+functions the Context from the [process
+dictionary](https://www.erlang.org/doc/reference_manual/processes.html#process-dictionary)
+is used. If no Context is found in the current process's pdict then one is
+created.
+
+#### Starting and Ending Spans
+
+A Span represents a single operation in a Trace. It has a start and end time,
+can have a single parent and one or more children. The easiest way to create
+Spans is to wrap the operation you want a Span to represent in the `with_span`
+macro. The macro handles getting a
+[Tracer](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#tracer)
+associated with the OTP Application the module is in, starting the Span, setting
+it as the currently active Span in the Context stored in the process dictionary
+and ending the Span when the `Fun` or body of the Elixir macro finish, even if
+an exception is thrown -- however, the exception is not caught, so it does not
+change how user code should deal with raised exceptions. After the Span is
+ended the Context in the process dictionary is reset to its value before the
+newly started Span was set as the active Span. This handling of the active Span
+in the process dictionary ensures proper lineage of Spans is kept when starting
+and ending child Spans.
+
+``` erlang
+?with_span(SpanName, StartOpts, Fun)
+```
+
+``` elixir
+OpenTelemetry.Tracer.with_span name, start_opts do
+    ...
+end
+```
+
+`StartOpts`/`start_opts` is a map of [Span creation options](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#span-creation):
+
+- `kind`: 
+[SpanKind](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#spankind)
+defines the relationship between the Span, its parents, and its children in a
+Trace. Possible values: `internal`, `server`, `client`, `producer` and
+`consumer`. Defaults to `internal` if not specified.
+- `attributes`: See
+  [Attributes](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/common/common.md#attributes)
+  for details about Attributes. Default is an empty list of attributes.
+- `links`:  List of [Links](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/overview.md#links-between-spans) to causally related Spans from the same or a different Trace.
+- `start_time`: The start time of the Span operation. Defaults to the current
+  time. The option should only be set if the start of the operation described by
+  the Span has already passed.
+
+current_span_ctx(ctx)
+
+set_current_span(span_ctx)
+
+When using `start_span` instead of `with_span` there must be a corresponding
+call to the [end Span
+API](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#end)
+to signal that the operation described by the Span has ended. `end_span`
+optionally takes a timestamp to use as the end time of the Span.
+
+``` erlang
+?end_span()
+?end_span(Timestamp)
+```
+
+``` elixir
+OpenTelemetry.Tracer.end_span(timestamp \\ :undefined)
+```
+
+#### Sampling
+
+Sampling is performed at span creation time by the Sampler configured on the Tracer, see [Samplers](https://hexdocs.pm/opentelemetry/readme.html).
+
+To pass attributes for use by the sampler, use the attributes field of `StartOpts`/`start_opts` 
+
+example:
+
+``` elixir
+OpenTelemetry.Tracer.start_span(span_name, %{attributes: %{my_attribute: "my value"}})
+```
+
+
+#### Setting Attributes
+
+[Setting
+Attributes](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#set-attributes)
+can be done with a single key and value passed to `set_attribute` or through a
+map of
+[Attributes](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/common/common.md#attributes)
+all at once. Setting an attribute with a key that already exists in the Span's
+map of attributes will result in that key's value being overwritten.
+
+``` erlang
+?set_attribute(Key, Value)
+?set_attributes(Attributes)
+```
+
+``` elixir
+OpenTelemetry.Tracer.set_attribute(key, value)
+OpenTelemetry.Tracer.set_attributes(attributes)
+```
+
+Be aware that there are [configurable limits](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/common/common.md#attribute-limits) on the number and size of
+Attributes per Span.
+
+#### Adding Events
+
+[Adding
+Events](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#add-events)
+can be done by passing the name of the event and the
+[Attributes](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/common/common.md#attributes)
+to associate with it or as a list of Events. Each Event in the list of Events is
+a map containing the timestamp, name, and Attributes which can be created with
+the function `event/2` and `event/3` in the `opentelemetry` and `OpenTelemetry`
+modules.
+
+``` erlang
+?add_event(Name, Attributes)
+?add_events(Events)
+```
+
+``` elixir
+OpenTelemetry.Tracer.add_event(event, attributes)
+OpenTelemetry.Tracer.add_events(events)
+```
+
+#### Setting the Status
+
+[Set
+Status](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#set-status)
+will override the default Span Status of `Unset`. A Status is a code (`ok`,
+`error` or `unset`) and, only if the code is `error`, an optional message string
+that describes the error.
+
+``` erlang
+?set_status(Code, Message)
+```
+
+``` elixir
+OpenTelemetry.Tracer.set_status(code, message)
+```
+
+#### Update Span Name
+
+[Updating the Span
+name](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#updatename)
+can be done after starting the Span but must be done before the Span is end'ed.
+
+``` erlang
+?update_name(Name)
+```
+
+``` elixir
+OpenTelemetry.Tracer.update_name(name)
+```
+
+### Including the OpenTelemetry SDK
+
+When only the API is available at runtime a no-op Tracer is used and no Traces
+are exported. The [OpenTelemetry SDK](https://hex.pm/packages/opentelemetry)
+provides the functionality of Tracers, Span Processors and Exporters and should
+be included as part of a
+[Release](https://erlang.org/doc/design_principles/release_structure.html) and
+not as a dependency of any individual Application.
+
+### Exporters
+
+Included in the same [Github
+repo](https://github.com/open-telemetry/opentelemetry-erlang) as the API and SDK are an exporter for the [OpenTelemetry Protocol
+(OTLP)](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/protocol/otlp.md)
+and [Zipkin](https://zipkin.io/):
+
+- [OpenTelemetry Protocol](https://hex.pm/packages/opentelemetry_exporter)
+- [Zipkin](https://hex.pm/packages/opentelemetry_zipkin)
+
+### Log Correlation
+
+When a Span is made active in a process, for example when the `with_span` macro
+is used, it is added to the [logger
+metadata](https://www.erlang.org/doc/apps/kernel/logger_chapter.html). The
+metadata is under the key `otel_span_ctx`. Example usage:
+
+``` erlang
+{kernel,
+  [{logger_level, debug},
+    {logger,
+     [{handler, default, logger_std_h,
+       #{formatter => {logger_formatter,
+                        #{template => [time, " ", file, ":", line, " ", level, ": ",
+                                       {otel_trace_id, ["trace_id=",otel_trace_id," "], []},
+                                       {otel_span_id, ["span_id=",otel_span_id," "], []},
+                                       msg,"\n"]}}}}]}]}
+```
+
+### Integrations
+
+Instrumentations of many popular Erlang and Elixir projects can be found in the
+[contrib repo](https://github.com/open-telemetry/opentelemetry-erlang-contrib)
+and on [hex.pm](https://hex.pm) under the [OpenTelemetry organization](https://hex.pm/orgs/opentelemetry).
+
+## Contributing
+
+Read OpenTelemetry project [contributing
+guide](https://github.com/open-telemetry/community/blob/main/CONTRIBUTING.md)
+for general information about the project.

apps/opentelemetry_api/dialyzer.ignore-warnings

@@ -0,0 +1 @@
+src/otel_tracer_provider.erl:39:5: Unknown function otel_tracer_provider_sup:start/2

apps/opentelemetry_api/include/gradualizer.hrl

@@ -0,0 +1,39 @@
+%% Syntax elements for type annotations
+%%
+%% The macro ?annotate_type/2 can be used to annotate an expression with a
+%% type.  This is useful to add type annotation after fetching a value from an
+%% ets table, received a message on a known form or read from a dict, proplist,
+%% process dictionary, etc.
+%%
+%% The specified type must be compatible with the type detected by Gradualizer.
+%% Otherwise a type error is reported.
+%%
+%%     N = ?annotate_type( Message, non_neg_integer() )
+%%
+%% The macro ?assert_type/2 can be used to refine (downcast) a type propagated
+%% by Gradualizer.  For example, the programmer may know that the length of a
+%% list is within a certain range, rather than any non_neg_integer():
+%%
+%%     Arity = ?assert_type( length(Args), arity() )
+%%
+%% The functions '::'/2 and ':::'/2 can also be used directly if the type is
+%% quoted:
+%%
+%%     N = '::'(Message, "non_neg_integer()")
+%%
+%% Gradualizer detects occurrences of the functions '::'/2 and ':::'/2 and
+%% adjusts type checking accordingly.  The macros are supplied only for
+%% convenience.
+%%
+-compile({inline, ['::'/2, ':::'/2]}).
+-compile({nowarn_unused_function, ['::'/2, ':::'/2]}).
+-ignore_xref(['::'/2, ':::'/2]).
+
+'::'(Expr, _Type) -> Expr.
+':::'(Expr, _Type) -> Expr.
+
+%% Type annotation
+-define(annotate_type(Expr, Type), '::'(Expr, ??Type)).
+
+%% Refinement (downcast) AKA type assertion
+-define(assert_type(Expr, Type), ':::'(Expr, ??Type)).

apps/opentelemetry_api/include/opentelemetry.hrl

@@ -0,0 +1,80 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%%------------------------------------------------------------------------
+
+%% convert 2 strings (one meant to be like a namespace and the other a unique name)
+%% to an atom for use registering a process
+-define(REG_NAME(Name), list_to_atom(lists:concat([?MODULE, "_", Name]))).
+-define(GLOBAL_TRACER_PROVIDER_NAME, global).
+-define(GLOBAL_TRACER_PROVIDER_REG_NAME, otel_tracer_provider_global).
+
+%% These records are based on protos found in the opentelemetry-proto repo:
+%% src/opentelemetry/proto/trace/v1/trace.proto
+%% They are not exact translations because further processing is done after
+%% the span has finished and can be vendor specific. For example, there is
+%% no count of the number of dropped attributes in the span record. And
+%% an attribute's value can be a function to only evaluate the value if it
+%% is actually used (at the time of exporting).
+
+%% for use in guards: sampling bit is the first bit in 8-bit trace options
+-define(IS_SAMPLED(TraceFlags), (TraceFlags band 1) =/= 0).
+
+-define(SPAN_KIND_INTERNAL, internal).
+-define(SPAN_KIND_SERVER, server).
+-define(SPAN_KIND_CLIENT, client).
+-define(SPAN_KIND_PRODUCER, producer).
+-define(SPAN_KIND_CONSUMER, consumer).
+
+-define(OTEL_STATUS_UNSET, unset).
+-define(OTEL_STATUS_OK, ok).
+-define(OTEL_STATUS_ERROR, error).
+
+%% Holds information about the instrumentation scope specified when
+%% getting a Tracer from the TracerProvider.
+-record(instrumentation_scope, {name       :: unicode:unicode_binary() | undefined,
+                                version    :: unicode:unicode_binary() | undefined,
+                                schema_url :: uri_string:uri_string() | undefined}).
+
+-record(span_ctx, {
+          %% 128 bit int trace id
+          trace_id          :: opentelemetry:trace_id(),
+          %% 64 bit int span id
+          span_id           :: opentelemetry:span_id(),
+          %% 8-bit integer, lowest bit is if it is sampled
+          trace_flags = 0   :: integer(),
+          %% Tracestate represents tracing-system specific context in a list of key-value pairs.
+          %% Tracestate allows different vendors propagate additional information and
+          %% inter-operate with their legacy Id formats.
+          tracestate = otel_tracestate:new() :: otel_tracestate:t(),
+          %% IsValid is a boolean flag which returns true if the SpanContext has a non-zero
+          %% TraceID and a non-zero SpanID.
+          is_valid          :: boolean() | undefined,
+          %% true if the span context came from a remote process
+          %% defaults to false and the propagator must set to true when extracting
+          is_remote = false :: boolean(),
+          %% this field is not propagated and is only here as an implementation optimization
+          %% If true updates like adding events are done on the span. The same as if the
+          %% trace flags lowest bit is 1 but simply not propagated.
+          is_recording      :: boolean() | undefined,
+
+          %% the sdk must put a module to call in the SDK for span operations
+          %% and include an optional term of configuration it needs
+          span_sdk          :: {module(), term()} | undefined
+         }).
+
+-record(status, {
+          code = ?OTEL_STATUS_UNSET :: opentelemetry:status_code(),
+          %% developer-facing error message
+          message = <<"">>          :: unicode:unicode_binary()
+         }).

apps/opentelemetry_api/include/otel_ctx.hrl

@@ -0,0 +1,4 @@
+-define(current_ctx, otel_ctx:get_current()).
+
+-define(with_ctx(Ctx, Fun),
+        otel_ctx:with_ctx(Ctx, Fun)).

apps/opentelemetry_api/include/otel_tracer.hrl

@@ -0,0 +1,58 @@
+%% macros for tracing
+%% tracers for applications are automatically created on boot
+
+-define(current_tracer, opentelemetry:get_application_tracer(?MODULE)).
+-define(current_span_ctx, otel_tracer:current_span_ctx()).
+
+-define(start_span(SpanName),
+        otel_tracer:start_span(?current_tracer, SpanName, #{})).
+
+-define(start_span(SpanName, StartOpts),
+        otel_tracer:start_span(?current_tracer, SpanName, StartOpts)).
+
+-define(with_span(SpanName, Fun),
+        otel_tracer:with_span(?current_tracer, SpanName, #{}, Fun)).
+
+-define(with_span(SpanName, StartOpts, Fun),
+        otel_tracer:with_span(?current_tracer, SpanName, StartOpts, Fun)).
+
+-define(set_current_span(SpanCtx),
+        otel_tracer:set_current_span(SpanCtx)).
+
+%% updates the current context with the updated span context that
+%% has `is_recording' set to `false'
+-define(end_span(),
+        ?end_span(undefined)).
+
+-define(end_span(Timestamp),
+        otel_tracer:set_current_span(otel_span:end_span(?current_span_ctx, Timestamp))).
+
+-define(is_recording(),
+        otel_span:is_recording(?current_span_ctx)).
+
+-define(set_attribute(Key, Value),
+        otel_span:set_attribute(?current_span_ctx, Key, Value)).
+
+-define(set_attributes(Attributes),
+        otel_span:set_attributes(?current_span_ctx, Attributes)).
+
+-define(record_exception(Class, Term, Stacktrace, Attributes),
+        otel_span:record_exception(?current_span_ctx, Class, Term, Stacktrace, Attributes)).
+
+-define(record_exception(Class, Term, Message, Stacktrace, Attributes),
+        otel_span:record_exception(?current_span_ctx, Class, Term, Message, Stacktrace, Attributes)).
+
+-define(add_event(Name, Attributes),
+        otel_span:add_event(?current_span_ctx, Name, Attributes)).
+
+-define(add_events(Events),
+        otel_span:add_events(?current_span_ctx, Events)).
+
+-define(set_status(Code, Message),
+        otel_span:set_status(?current_span_ctx, Code, Message)).
+
+-define(set_status(StatusOrCode),
+        otel_span:set_status(?current_span_ctx, StatusOrCode)).
+
+-define(update_name(Name),
+        otel_span:update_name(?current_span_ctx, Name)).

apps/opentelemetry_api/lib/open_telemetry.ex

@@ -0,0 +1,215 @@
+defmodule OpenTelemetry do
+  @moduledoc """
+  An [OpenTelemetry](https://opentelemetry.io) Trace consists of 1 or more Spans that either have a
+  parent/child relationship or are linked together through a Link. Each Span has a TraceId (`t:trace_id/0`),
+  SpanId (`t:span_id/0`), and a start and end time in nanoseconds.
+
+  This module provides declaration of the types used throughout the library, as well as functions for
+  building the additional pieces of a span that are optional. Each item can be attached to individual
+  Span using the functions in `OpenTelemetry.Span` module.
+
+  ## Example
+
+      require OpenTelemetry.Tracer, as: Tracer
+
+      Tracer.with_span "some-span" do
+        event = OpenTelemetry.event("ecto.query", query: query, total_time: total_time)
+        Tracer.add_events([event])
+      end
+  """
+
+  @typedoc """
+  A SpanContext represents the portion of a Span needed to do operations on a
+  Span. Within a process it acts as a key for looking up and modifying the
+  actual Span. It is also what is serialized and propagated across process
+  boundaries.
+  """
+  @type span_ctx() :: :opentelemetry.span_ctx()
+
+  @typedoc """
+  Span represents a single operation within a trace. Spans can be
+  nested to form a trace tree. Spans may also be linked to other spans
+  from the same or different trace and form graphs. Often, a trace
+  contains a root span that describes the end-to-end latency, and one
+  or more subspans for its sub-operations. A trace can also contain
+  multiple root spans, or none at all. Spans do not need to be
+  contiguous - there may be gaps or overlaps between spans in a trace.
+  """
+  @type span() :: :opentelemetry.span()
+  @type span_kind() :: :opentelemetry.span_kind()
+  @type span_name() :: :opentelemetry.span_name()
+
+  @typedoc """
+  TraceId is a unique identifier for a trace. All spans from the same trace share
+  the same `trace_id`. The ID is a 16-byte array. An ID with all zeroes
+  is considered invalid.
+  """
+  @type trace_id() :: non_neg_integer()
+
+  @typedoc """
+  SpanId is a unique identifier for a span within a trace, assigned when the span
+  is created. The ID is an 8-byte array. An ID with all zeroes is considered
+  invalid.
+  """
+  @type span_id() :: non_neg_integer()
+
+  @typedoc """
+  Hex-encoded TraceId as a 32-character lowercase binary string.
+  """
+  @type hex_trace_id() :: :opentelemetry.hex_trace_id()
+
+  @typedoc """
+  Hex-encoded SpanId as a 16-character lowercase binary string.
+  """
+  @type hex_span_id() :: :opentelemetry.hex_span_id()
+
+  @type attribute_key() :: :opentelemetry.attribute_key()
+  @type attribute_value() :: :opentelemetry.attribute_value()
+
+  @typedoc """
+  Attributes are a collection of key/value pairs. The value can be a string,
+  an integer, a double or the boolean values `true` or `false`. Note, global attributes
+  like server name can be set using the resource API.
+
+  Examples of attributes:
+
+      [{"/http/user_agent" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36"}
+       {"/http/server_latency", 300}
+       {"abc.com/myattribute", True}
+       {"abc.com/score", 10.239}]
+  """
+  @type attributes_map() :: :opentelemetry.attributes_map()
+
+  @typedoc """
+  Tracestate represents tracing-system specific context in a list of key-value pairs.
+  Tracestate allows different vendors propagate additional information and
+  inter-operate with their legacy Id formats.
+
+  It is a tracestate in the [w3c-trace-context format](https://www.w3.org/TR/trace-context/#tracestate-header).
+  See also [https://github.com/w3c/distributed-tracing](https://github.com/w3c/distributed-tracing)
+  for more details about this field.
+  """
+  @type tracestate() :: :opentelemetry.tracestate()
+
+  @typedoc """
+  A Link is a pointer from the current span to another span in the same trace or in a
+  different trace. For example, this can be used in batching operations,
+  where a single batch handler processes multiple requests from different
+  traces or when the handler receives a request from a different project.
+  """
+  @type link() :: :opentelemetry.link()
+
+  @typedoc """
+  An Event is a time-stamped annotation of the span, consisting of user-supplied
+  text description and key-value pairs.
+  """
+  @type event() :: :opentelemetry.event()
+  @type event_name() :: :opentelemetry.event_name()
+
+  @typedoc """
+  An optional final status for this span. Semantically when Status
+  wasn't set it means span ended without errors and assume `:unset`.
+
+  Application developers may set the status as `:ok` when the operation
+  has been validated to have completed successfully, or `:error` when
+  the operation contains an error.
+  """
+  @type status() :: :opentelemetry.status()
+
+  @type status_code() :: :opentelemetry.status_code()
+
+  defdelegate get_tracer(name), to: :opentelemetry
+  defdelegate get_tracer(name, vsn, schema_url), to: :opentelemetry
+  defdelegate set_default_tracer(t), to: :opentelemetry
+
+  # Helpers to build OpenTelemetry structured types
+
+  @doc """
+  A monotonically increasing time provided by the Erlang runtime system in the native time unit.
+  This value is the most accurate and precise timestamp available from the Erlang runtime and
+  should be used for finding durations or any timestamp that can be converted to a system
+  time before being sent to another system.
+
+  Use `convert_timestamp/2` or `timestamp_to_nano/1` to convert a native monotonic time to a
+  system time of either nanoseconds or another unit.
+
+  Using these functions allows timestamps to be accurate, used for duration and be exportable
+  as POSIX time when needed.
+  """
+  @spec timestamp() :: integer()
+  defdelegate timestamp(), to: :opentelemetry
+
+  @doc """
+  Convert a native monotonic timestamp to nanosecond POSIX time. Meaning the time since Epoch.
+  Epoch is defined to be 00:00:00 UTC, 1970-01-01.
+  """
+  @spec timestamp_to_nano(integer()) :: integer()
+  defdelegate timestamp_to_nano(timestamp), to: :opentelemetry
+
+  @doc """
+  Convert a native monotonic timestamp to POSIX time of any `t::erlang.time_unit/0`.
+  Meaning the time since Epoch. Epoch is defined to be 00:00:00 UTC, 1970-01-01.
+  """
+  @spec convert_timestamp(integer(), :erlang.time_unit()) :: integer()
+  defdelegate convert_timestamp(timestamp, unit), to: :opentelemetry
+
+  # span item functions
+
+  @doc """
+  Creates a `t:link/0`.
+  """
+  @spec link(trace_id(), span_id(), attributes_map(), tracestate()) :: link()
+  defdelegate link(trace_id, span_id, attributes, tracestate), to: :opentelemetry
+
+  @doc """
+  Creates a `t:link/0` from a `t:span_ctx/0`.
+  """
+  @spec link(span_ctx() | :undefined) :: link()
+  defdelegate link(span_ctx), to: :opentelemetry
+
+  @doc """
+  Creates a `t:link/0` from a `t:span_ctx/0` and list of `t:attributes_map/0`.
+  """
+  @spec link(span_ctx() | :undefined, attributes_map()) :: link()
+  defdelegate link(span_ctx, attributes), to: :opentelemetry
+
+  @doc """
+  Creates a list of `t:link/0` from a list of 4-tuples.
+  """
+  @spec links([
+          {integer(), integer(), attributes_map(), tracestate()}
+          | span_ctx()
+          | {span_ctx(), attributes_map()}
+        ]) :: [link()]
+  defdelegate links(link_list), to: :opentelemetry
+
+  @doc """
+  Creates a `t:event/0`.
+  """
+  @spec event(event_name(), attributes_map()) :: event()
+  defdelegate event(name, attributes), to: :opentelemetry
+
+  @doc """
+  Creates a `t:event/0`.
+  """
+  @spec event(integer(), event_name(), attributes_map()) :: event()
+  defdelegate event(timestamp, name, attributes), to: :opentelemetry
+
+  @doc """
+  Creates a list of `t:event/0` items.
+  """
+  @spec events(list()) :: [event()]
+  defdelegate events(event_list), to: :opentelemetry
+
+  @doc """
+  Creates a Status with an empty description.
+  """
+  @spec status(:opentelemetry.status_code()) :: status()
+  defdelegate status(code), to: :opentelemetry
+
+  @doc """
+  Creates a Status.
+  """
+  @spec status(:opentelemetry.status_code(), String.t()) :: status()
+  defdelegate status(code, message), to: :opentelemetry
+end

apps/opentelemetry_api/lib/open_telemetry/baggage.ex

@@ -0,0 +1,16 @@
+defmodule OpenTelemetry.Baggage do
+  @moduledoc """
+  Baggage is used to annotate telemetry, adding context and information to
+  metrics, traces, and logs. It is represented by a set of name/value pairs
+  describing user-defined properties.
+  """
+
+  defdelegate set(keyvalues), to: :otel_baggage
+  defdelegate set(ctx_or_key, keyvalues), to: :otel_baggage
+  defdelegate set(ctx, key, value), to: :otel_baggage
+  defdelegate set(ctx, key, values, metadata), to: :otel_baggage
+  defdelegate get_all(), to: :otel_baggage
+  defdelegate get_all(ctx), to: :otel_baggage
+  defdelegate clear(), to: :otel_baggage
+  defdelegate clear(ctx), to: :otel_baggage
+end

apps/opentelemetry_api/lib/open_telemetry/ctx.ex

@@ -0,0 +1,20 @@
+defmodule OpenTelemetry.Ctx do
+  @moduledoc """
+  Ctx is responsible for propagating values within a process that are associated
+  with a particular Trace or set of Baggage. `OpenTelemetry.Tracer` and
+  `OpenTelemetry.Baggage` handle updating the Context.
+  """
+
+  @type t() :: :otel_ctx.t()
+
+  defdelegate new(), to: :otel_ctx
+  defdelegate attach(ctx), to: :otel_ctx
+  defdelegate detach(token), to: :otel_ctx
+  defdelegate set_value(key, value), to: :otel_ctx
+  defdelegate set_value(ctx, key, value), to: :otel_ctx
+  defdelegate get_value(key, default), to: :otel_ctx
+  defdelegate get_value(ctx, key, default), to: :otel_ctx
+  defdelegate clear(), to: :otel_ctx
+  defdelegate remove(key), to: :otel_ctx
+  defdelegate get_current(), to: :otel_ctx
+end

apps/opentelemetry_api/lib/open_telemetry/span.ex

@@ -0,0 +1,212 @@
+defmodule OpenTelemetry.Span do
+  @moduledoc """
+  This module contains macros for Span operations that update the active current Span in the current process.
+  An example of creating an Event and adding it to the current Span:
+
+      require OpenTelemetry.Tracer, as: Tracer
+      require OpenTelemetry.Span, as: Span
+
+      span_ctx = Tracer.start_span("some-span")
+      ...
+      Span.add_event(span_ctx, "ecto.query", query: query, total_time: total_time)
+      ...
+      Span.end_span(span_ctx)
+
+  A Span represents a single operation within a trace. Spans can be nested to form a trace tree.
+  Each trace contains a root span, which typically describes the end-to-end latency and, optionally,
+  one or more sub-spans for its sub-operations.
+
+  Spans encapsulate:
+
+  - The span name
+  - An immutable SpanContext (`t:OpenTelemetry.span_ctx/0`) that uniquely identifies the Span
+  - A parent Span in the form of a Span (`t:OpenTelemetry.span/0`), SpanContext (`t:OpenTelemetry.span_ctx/0`), or `undefined`
+  - A start timestamp
+  - An end timestamp
+  - An ordered mapping of Attributes (`t:OpenTelemetry.attributes_map/0`)
+  - A list of Links to other Spans (`t:OpenTelemetry.link/0`)
+  - A list of timestamped Events (`t:OpenTelemetry.event/0`)
+  - A Status (`t:OpenTelemetry.status/0`)
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#span)
+  """
+
+  @type start_opts() :: :otel_span.start_opts()
+  @type start_config() :: :otel_span.start_config()
+
+  @doc """
+  Get the SpanId of a Span.
+  """
+  @spec span_id(OpenTelemetry.span_ctx()) :: OpenTelemetry.span_id()
+  defdelegate span_id(span), to: :otel_span
+
+  @doc """
+  Get the hex-encoded trace context.
+  """
+  @spec hex_span_ctx(OpenTelemetry.span_ctx() | nil) ::
+          %{
+            otel_trace_id: OpenTelemetry.hex_trace_id(),
+            otel_span_id: OpenTelemetry.hex_span_id(),
+            otel_trace_flags: binary()
+          }
+          | %{}
+  defdelegate hex_span_ctx(span_ctx), to: :otel_span
+
+  @doc """
+  Get the lowercase hex encoded span ID.
+  """
+  @spec hex_span_id(OpenTelemetry.span_ctx()) :: OpenTelemetry.hex_span_id()
+  defdelegate hex_span_id(span), to: :otel_span
+
+  @doc """
+  Get the TraceId of a Span.
+  """
+  @spec trace_id(OpenTelemetry.span_ctx()) :: OpenTelemetry.trace_id()
+  defdelegate trace_id(span), to: :otel_span
+
+  @doc """
+  Get the lowercase hex encoded trace ID.
+  """
+  @spec hex_trace_id(OpenTelemetry.span_ctx()) :: OpenTelemetry.hex_trace_id()
+  defdelegate hex_trace_id(span), to: :otel_span
+
+  @doc """
+  Get the Tracestate of a Span.
+  """
+  @spec tracestate(OpenTelemetry.span_ctx()) :: OpenTelemetry.tracestate()
+  defdelegate tracestate(span), to: :otel_span
+
+  @doc """
+  End the Span. Sets the end timestamp for the currently active Span. This has no effect on any
+  child Spans that may exist of this Span.
+
+  The Span Context is returned with `is_recording` set to `false`.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#end)
+  """
+  defdelegate end_span(span_ctx), to: :otel_span
+
+  @doc """
+  End the Span. Sets the end timestamp for the currently active Span using the passed in timestamp if valid, current timestamp otherwise. This has no effect on any
+  child Spans that may exist of this Span.
+
+  The Span Context is returned with `is_recording` set to `false`.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#end)
+  """
+  defdelegate end_span(span_ctx, timestamp), to: :otel_span
+
+  @doc """
+  Returns whether this Span is recording information like events, attributes, status, etc.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#isrecording)
+  """
+  defdelegate is_recording(span_ctx), to: :otel_span
+
+  @doc """
+  Returns true if the SpanContext has a non-zero TraceId and SpanId.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#isvalid)
+  """
+  defdelegate is_valid(span_ctx), to: :otel_span
+
+  @doc """
+  Set an attribute with key and value on the currently active Span.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#set-attributes)
+  """
+  @spec set_attribute(
+          OpenTelemetry.span_ctx(),
+          OpenTelemetry.attribute_key(),
+          OpenTelemetry.attribute_value()
+        ) :: boolean()
+  defdelegate set_attribute(span_ctx, key, value), to: :otel_span
+
+  @doc """
+  Add a list of attributes to the currently active Span.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#set-attributes)
+  """
+  @spec set_attributes(OpenTelemetry.span_ctx(), OpenTelemetry.attributes_map()) :: boolean()
+  defdelegate set_attributes(span_ctx, attributes), to: :otel_span
+
+  @doc """
+  Add an event to the currently active Span.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#add-events)
+  """
+  @spec add_event(
+          OpenTelemetry.span_ctx(),
+          OpenTelemetry.event_name(),
+          OpenTelemetry.attributes_map()
+        ) :: boolean()
+  defdelegate add_event(span_ctx, event, attributes), to: :otel_span
+
+  @doc """
+  Add a list of events to the currently active Span.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#add-events)
+  """
+  @spec add_events(OpenTelemetry.span_ctx(), [OpenTelemetry.event()]) :: boolean()
+  defdelegate add_events(span_ctx, events), to: :otel_span
+
+  defguardp is_exception?(term)
+            when is_map(term) and :erlang.is_map_key(:__struct__, term) and
+                   is_atom(:erlang.map_get(:__struct__, term)) and
+                   :erlang.is_map_key(:__exception__, term) and
+                   :erlang.map_get(:__exception__, term) == true
+
+  @doc """
+  Record an exception as an event, following the semantics convetions for exceptions.
+
+  If trace is not provided, the stacktrace is retrieved from `Process.info/2`
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#record-exception)
+  """
+  @spec record_exception(OpenTelemetry.span_ctx(), Exception.t()) :: boolean()
+  def record_exception(span_ctx, exception, trace \\ nil, attributes \\ [])
+
+  def record_exception(span_ctx, exception, trace, attributes) when is_exception?(exception) do
+    exception_type = to_string(exception.__struct__)
+
+    exception_attributes = [
+      {:"exception.type", exception_type},
+      {:"exception.message", Exception.message(exception)},
+      {:"exception.stacktrace", Exception.format_stacktrace(trace)}
+    ]
+
+    add_event(span_ctx, :exception, exception_attributes ++ attributes)
+  end
+
+  def record_exception(_, _, _, _), do: false
+
+  @doc """
+  Sets the Status of the currently active Span.
+
+  If used, this will override the default Span Status, which is `:unset`.
+  Valid statuses are `:ok`, or `:error`. Calling this will also set the
+  `status_code` attribute to `1`(`:ok`), or `2`(`:error`).
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#set-status)
+  """
+  @spec set_status(OpenTelemetry.span_ctx(), OpenTelemetry.status()) :: boolean()
+  defdelegate set_status(span_ctx, status), to: :otel_span
+
+  @doc """
+  Updates the Span name.
+
+  It is highly discouraged to update the name of a Span after its creation. Span name is
+  often used to group, filter and identify the logical groups of spans. And often, filtering
+  logic will be implemented before the Span creation for performance reasons. Thus the name
+  update may interfere with this logic.
+
+  The function name is called update_name to differentiate this function from the regular
+  property setter. It emphasizes that this operation signifies a major change for a Span
+  and may lead to re-calculation of sampling or filtering decisions made previously
+  depending on the implementation.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#updatename)
+  """
+  @spec update_name(OpenTelemetry.span_ctx(), OpenTelemetry.span_name()) :: boolean()
+  defdelegate update_name(span_ctx, name), to: :otel_span
+end

apps/opentelemetry_api/lib/open_telemetry/tracer.ex

@@ -0,0 +1,260 @@
+defmodule OpenTelemetry.Tracer do
+  @moduledoc """
+  This module contains macros for Tracer operations around the lifecycle of the Spans within a Trace.
+
+  The Tracer is able to start a new Span as a child of the active Span of the current process, set
+  a different Span to be the current Span by passing the Span's context, end a Span or run a code
+  block within the context of a newly started span that is ended when the code block completes.
+
+  The macros `start_span` and `with_span` use the Tracer associated with the Application the module
+  is included in. These Tracers are created at boot time for each loaded Application.
+
+      require OpenTelemetry.Tracer, as: Tracer
+
+      Tracer.with_span "span-1" do
+        ... do something ...
+      end
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#tracer)
+  """
+
+  @doc """
+  Starts a new span and does not make it the current active span of the current process.
+
+  The current active Span is used as the parent of the created Span.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#span-creation)
+  """
+  defmacro start_span(name, opts \\ quote(do: %{})) do
+    quote bind_quoted: [name: name, start_opts: opts] do
+      :otel_tracer.start_span(
+        :opentelemetry.get_application_tracer(__MODULE__),
+        name,
+        Map.new(start_opts)
+      )
+    end
+  end
+
+  @doc """
+  Starts a new span and does not make it the current active span of the current process.
+
+  The current active Span is used as the parent of the created Span.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#span-creation)
+  """
+  defmacro start_span(ctx, name, opts) do
+    quote bind_quoted: [ctx: ctx, name: name, start_opts: opts] do
+      :otel_tracer.start_span(
+        ctx,
+        :opentelemetry.get_application_tracer(__MODULE__),
+        name,
+        Map.new(start_opts)
+      )
+    end
+  end
+
+  @doc """
+  Takes a `t:OpenTelemetry.span_ctx/0` and the Tracer sets it to the currently active Span.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#get-context)
+  """
+  def set_current_span(span_ctx) do
+    :otel_tracer.set_current_span(span_ctx)
+  end
+
+  @doc """
+  Takes a `t:OpenTelemetry.Ctx.t/0` and the `t:OpenTelemetry.span_ctx/0` and the Tracer sets
+  it to the current span in the pass Context.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#get-context)
+  """
+  def set_current_span(ctx, span_ctx) do
+    :otel_tracer.set_current_span(ctx, span_ctx)
+  end
+
+  @doc """
+  Creates a new span which is set to the currently active Span in the Context of the block.
+  The Span is ended automatically when the `block` completes and the Context is what it was
+  before the block.
+
+  See `start_span/2` and `end_span/0`.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#span-creation)
+  """
+  defmacro with_span(name, start_opts \\ quote(do: %{}), do: block) do
+    quote do
+      :otel_tracer.with_span(
+        :opentelemetry.get_application_tracer(__MODULE__),
+        unquote(name),
+        Map.new(unquote(start_opts)),
+        fn _ -> unquote(block) end
+      )
+    end
+  end
+
+  @doc """
+  Creates a new span which is set to the currently active Span in the Context of the block.
+  The Span is ended automatically when the `block` completes and the Context is what it was
+  before the block.
+
+  See `start_span/2` and `end_span/0`.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#span-creation)
+  """
+  defmacro with_span(ctx, name, start_opts, do: block) do
+    quote do
+      :otel_tracer.with_span(
+        unquote(ctx),
+        :opentelemetry.get_application_tracer(__MODULE__),
+        unquote(name),
+        Map.new(unquote(start_opts)),
+        fn _ -> unquote(block) end
+      )
+    end
+  end
+
+  @doc """
+  Returns the currently active `t:OpenTelemetry.span_ctx/0`.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#get-context)
+  """
+  def current_span_ctx() do
+    :otel_tracer.current_span_ctx()
+  end
+
+  @doc """
+  Returns the `t:OpenTelemetry.span_ctx/0` active in Context `ctx`.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#get-context)
+  """
+  def current_span_ctx(ctx) do
+    :otel_tracer.current_span_ctx(ctx)
+  end
+
+  @doc """
+  End the currently active Span and sets its end timestamp.
+  This has no effect on any child Spans that may exist of this Span.
+
+  To end a specific span, see `OpenTelemetry.Span.end_span/1`.
+
+  The Span in the current Context has its `is_recording` set to `false`.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#end)
+  """
+  @spec end_span(:opentelemetry.timestamp() | :undefined) ::
+          :opentelemetry.span_ctx() | :undefined
+  def end_span(timestamp \\ :undefined) do
+    non_recording_span = :otel_span.end_span(:otel_tracer.current_span_ctx(), timestamp)
+    _ = :otel_tracer.set_current_span(non_recording_span)
+    non_recording_span
+  end
+
+  @doc """
+  Set an attribute with key and value on the currently active Span.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#set-attributes)
+  """
+  @spec set_attribute(OpenTelemetry.attribute_key(), OpenTelemetry.attribute_value()) :: boolean()
+  def set_attribute(key, value) do
+    :otel_span.set_attribute(
+      :otel_tracer.current_span_ctx(),
+      key,
+      value
+    )
+  end
+
+  @doc """
+  Add a list of attributes to the currently active Span.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#set-attributes)
+  """
+  @spec set_attributes(OpenTelemetry.attributes_map()) :: boolean()
+  def set_attributes(attributes) do
+    :otel_span.set_attributes(:otel_tracer.current_span_ctx(), attributes)
+  end
+
+  @doc """
+  Add an event to the currently active Span.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#add-events)
+  """
+  @spec add_event(OpenTelemetry.event_name(), OpenTelemetry.attributes_map()) :: boolean()
+  def add_event(event, attributes) do
+    :otel_span.add_event(
+      :otel_tracer.current_span_ctx(),
+      event,
+      attributes
+    )
+  end
+
+  @doc """
+  Add a list of events to the currently active Span.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#add-events)
+  """
+  @spec add_events([OpenTelemetry.event()]) :: boolean()
+  def add_events(events) do
+    :otel_span.add_events(:otel_tracer.current_span_ctx(), events)
+  end
+
+  @doc """
+  Record an exception as an event, following the semantics convetions for exceptions.
+
+  If trace is not provided, the stacktrace is retrieved from `Process.info/2`
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#record-exception)
+  """
+  @spec record_exception(Exception.t()) :: boolean()
+  def record_exception(exception, trace \\ nil, attributes \\ []) do
+    OpenTelemetry.Span.record_exception(
+      :otel_tracer.current_span_ctx(),
+      exception,
+      trace,
+      attributes
+    )
+  end
+
+  @doc """
+  Creates and sets the Status of the currently active Span.
+
+  If used, this will override the default Span Status, which is `:unset`.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#set-status)
+  """
+  @spec set_status(OpenTelemetry.status_code(), String.t()) :: boolean()
+  def set_status(code, message) do
+    :otel_span.set_status(:otel_tracer.current_span_ctx(), code, message)
+  end
+
+  @doc """
+  Sets the Status of the currently active Span.
+
+  If used, this will override the default Span Status, which is `:unset`.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#set-status)
+  """
+  @spec set_status(OpenTelemetry.status()) :: boolean()
+  def set_status(status) do
+    :otel_span.set_status(:otel_tracer.current_span_ctx(), status)
+  end
+
+  @doc """
+  Updates the Span name.
+
+  It is highly discouraged to update the name of a Span after its creation. Span name is
+  often used to group, filter and identify the logical groups of spans. And often, filtering
+  logic will be implemented before the Span creation for performance reasons. Thus the name
+  update may interfere with this logic.
+
+  The function name is called update_name to differentiate this function from the regular
+  property setter. It emphasizes that this operation signifies a major change for a Span
+  and may lead to re-calculation of sampling or filtering decisions made previously
+  depending on the implementation.
+
+  See [specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.8.0/specification/trace/api.md#updatename)
+  """
+  @spec update_name(String.t()) :: boolean()
+  def update_name(name) do
+    :otel_span.update_name(:otel_tracer.current_span_ctx(), name)
+  end
+end

apps/opentelemetry_api/mix.exs

@@ -0,0 +1,87 @@
+defmodule OpenTelemetry.MixProject do
+  use Mix.Project
+
+  def project do
+    {app, desc} = load_app()
+
+    [
+      app: app,
+      version: to_string(Keyword.fetch!(desc, :vsn)),
+      description: to_string(Keyword.fetch!(desc, :description)),
+      elixir: "~> 1.8",
+      start_permanent: Mix.env() == :prod,
+      deps: [
+        {:eqwalizer_support,
+         git: "https://github.com/whatsapp/eqwalizer.git",
+         branch: "main",
+         sparse: "eqwalizer_support",
+         only: [:dev],
+         runtime: false},
+        {:dialyxir, "~> 1.0", only: [:dev], runtime: false},
+        {:covertool, ">= 0.0.0", only: :test},
+        {:ex_doc, "~> 0.37", only: :dev, runtime: false}
+      ],
+      name: "OpenTelemetry API",
+      test_coverage: [tool: :covertool],
+      package: package(),
+      dialyzer: [
+        ignore_warnings: "dialyzer.ignore-warnings",
+        remove_defaults: [:unknown],
+        plt_add_apps: [:eqwalizer_support],
+        list_unused_filters: true
+      ],
+      source_url: "https://github.com/open-telemetry/opentelemetry-erlang",
+      homepage_url: "https://github.com/open-telemetry/opentelemetry-erlang",
+      docs: [
+        main: "readme",
+        source_url_pattern:
+          "https://github.com/open-telemetry/opentelemetry-erlang/blob/main/apps/opentelemetry_api/%{path}#L%{line}",
+        extras: ["README.md", "LICENSE"],
+        groups_for_modules: [
+          Context: [:otel_ctx, OpenTelemetry.Ctx],
+          Baggage: [:otel_baggage, OpenTelemetry.Baggage],
+          Tracer: [
+            :otel_tracer,
+            :otel_tracer_noop,
+            :otel_tracer_provider,
+            :otel_tracestate,
+            OpenTelemetry.Tracer,
+            OpenTelemetry.Span
+          ],
+          Propagators: [
+            :otel_propagator,
+            :otel_propagator_baggage,
+            :otel_propagator_b3,
+            :otel_propagator_b3multi,
+            :otel_propagator_b3single,
+            :otel_propagator_text_map,
+            :otel_propagator_text_map_composite,
+            :otel_propagator_text_map_noop,
+            :otel_propagator_trace_context
+          ]
+        ]
+      ]
+    ]
+  end
+
+  def application, do: []
+
+  defp package() do
+    [
+      description: "OpenTelemetry API",
+      build_tools: ["rebar3", "mix"],
+      files: ~w(lib mix.exs README.md LICENSE rebar.config include src),
+      licenses: ["Apache-2.0"],
+      links: %{
+        "GitHub" => "https://github.com/open-telemetry/opentelemetry-erlang",
+        "OpenTelemetry.io" => "https://opentelemetry.io"
+      }
+    ]
+  end
+
+  defp load_app do
+    {:ok, [{:application, name, desc}]} = :file.consult(~c"src/opentelemetry_api.app.src")
+
+    {name, desc}
+  end
+end

apps/opentelemetry_api/mix.lock

@@ -0,0 +1,12 @@
+%{
+  "covertool": {:hex, :covertool, "2.0.6", "4a291b4e3449025b0595d8f44c8d7635d4f48f033be2ce88d22a329f36f94a91", [:rebar3], [], "hexpm", "5db3fcd82180d8ea4ad857d4d1ab21a8d31b5aee0d60d2f6c0f9e25a411d1e21"},
+  "dialyxir": {:hex, :dialyxir, "1.4.2", "764a6e8e7a354f0ba95d58418178d486065ead1f69ad89782817c296d0d746a5", [:mix], [{:erlex, ">= 0.2.6", [hex: :erlex, repo: "hexpm", optional: false]}], "hexpm", "516603d8067b2fd585319e4b13d3674ad4f314a5902ba8130cd97dc902ce6bbd"},
+  "earmark_parser": {:hex, :earmark_parser, "1.4.43", "34b2f401fe473080e39ff2b90feb8ddfeef7639f8ee0bbf71bb41911831d77c5", [:mix], [], "hexpm", "970a3cd19503f5e8e527a190662be2cee5d98eed1ff72ed9b3d1a3d466692de8"},
+  "eqwalizer_support": {:git, "https://github.com/whatsapp/eqwalizer.git", "1a787cb604f6083ebe8763e358ea362e4677e500", [branch: "main", sparse: "eqwalizer_support"]},
+  "erlex": {:hex, :erlex, "0.2.7", "810e8725f96ab74d17aac676e748627a07bc87eb950d2b83acd29dc047a30595", [:mix], [], "hexpm", "3ed95f79d1a844c3f6bf0cea61e0d5612a42ce56da9c03f01df538685365efb0"},
+  "ex_doc": {:hex, :ex_doc, "0.37.1", "65ca30d242082b95aa852b3b73c9d9914279fff56db5dc7b3859be5504417980", [:mix], [{:earmark_parser, "~> 1.4.42", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_c, ">= 0.1.0", [hex: :makeup_c, repo: "hexpm", optional: true]}, {:makeup_elixir, "~> 0.14 or ~> 1.0", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1 or ~> 1.0", [hex: :makeup_erlang, repo: "hexpm", optional: false]}, {:makeup_html, ">= 0.1.0", [hex: :makeup_html, repo: "hexpm", optional: true]}], "hexpm", "6774f75477733ea88ce861476db031f9399c110640752ca2b400dbbb50491224"},
+  "makeup": {:hex, :makeup, "1.2.1", "e90ac1c65589ef354378def3ba19d401e739ee7ee06fb47f94c687016e3713d1", [:mix], [{:nimble_parsec, "~> 1.4", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "d36484867b0bae0fea568d10131197a4c2e47056a6fbe84922bf6ba71c8d17ce"},
+  "makeup_elixir": {:hex, :makeup_elixir, "1.0.1", "e928a4f984e795e41e3abd27bfc09f51db16ab8ba1aebdba2b3a575437efafc2", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}, {:nimble_parsec, "~> 1.2.3 or ~> 1.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "7284900d412a3e5cfd97fdaed4f5ed389b8f2b4cb49efc0eb3bd10e2febf9507"},
+  "makeup_erlang": {:hex, :makeup_erlang, "1.0.2", "03e1804074b3aa64d5fad7aa64601ed0fb395337b982d9bcf04029d68d51b6a7", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "af33ff7ef368d5893e4a267933e7744e46ce3cf1f61e2dccf53a111ed3aa3727"},
+  "nimble_parsec": {:hex, :nimble_parsec, "1.4.2", "8efba0122db06df95bfaa78f791344a89352ba04baedd3849593bfce4d0dc1c6", [:mix], [], "hexpm", "4b21398942dda052b403bbe1da991ccd03a053668d147d53fb8c4e0efe09c973"},
+}

apps/opentelemetry_api/rebar.config

@@ -0,0 +1,11 @@
+{erl_opts, [debug_info]}.
+{deps, []}.
+
+{profiles,
+ [{docs, [{edoc_opts,
+           [
+            {doclet, edoc_doclet_chunks},
+            {layout, edoc_layout_chunks},
+            {preprocess, true},
+            {dir, "_build/dev/lib/opentelemetry_api/doc"},
+            {subpackages, true}]}]}]}.

apps/opentelemetry_api/src/opentelemetry.erl

@@ -0,0 +1,573 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @doc The types defined here, and referencing records in opentelemetry.hrl
+%% are used to store trace information while being collected on the
+%% Erlang node.
+%%
+%% Thus, while the types are based on protos found in the opentelemetry-proto
+%% repo: src/opentelemetry/proto/trace/v1/trace.proto,
+%% they are not exact translations because further processing is done after
+%% the span has finished and can be vendor specific. For example, there is
+%% no count of the number of dropped attributes in the span record. And
+%% an attribute's value can be a function to only evaluate the value if it
+%% is actually used (at the time of exporting). And the stacktrace is a
+%% regular Erlang stack trace.
+%% @end
+%%%-------------------------------------------------------------------------
+-module(opentelemetry).
+
+-export([start_tracer_provider/2,
+         set_default_tracer/1,
+         set_default_tracer/2,
+         create_application_tracers/1,
+         get_tracer/0,
+         get_tracer/1,
+         get_tracer/3,
+         set_tracer/2,
+         get_application/1,
+         get_application_tracer/1,
+         get_application_scope/1,
+         set_text_map_propagator/1,
+         set_text_map_extractor/1,
+         get_text_map_extractor/0,
+         set_text_map_injector/1,
+         get_text_map_injector/0,
+         instrumentation_scope/3,
+         instrumentation_library/3,
+         timestamp/0,
+         timestamp_to_nano/1,
+         convert_timestamp/2,
+         link/1,
+         link/2,
+         link/4,
+         links/1,
+         event/2,
+         event/3,
+         events/1,
+         status/1,
+         status/2,
+         verify_and_set_term/3,
+         vsn_to_binary/1]).
+
+-include("opentelemetry.hrl").
+-include_lib("kernel/include/logger.hrl").
+
+-export_type([tracer/0,
+              instrumentation_scope/0,
+              trace_id/0,
+              span_id/0,
+              hex_trace_id/0,
+              hex_span_id/0,
+              trace_flags/0,
+              timestamp/0,
+              span_name/0,
+              span_ctx/0,
+              span/0,
+              span_kind/0,
+              link/0,
+              attribute_key/0,
+              attribute_value/0,
+              attribute/0,
+              attributes_map/0,
+              event/0,
+              event_name/0,
+              tracestate/0,
+              status/0,
+              status_code/0,
+              resource/0,
+              text_map/0]).
+
+-type tracer()             :: {module(), term()}.
+
+-type instrumentation_scope() :: #instrumentation_scope{}.
+
+-type trace_id()           :: non_neg_integer().
+-type span_id()            :: non_neg_integer().
+
+-type hex_trace_id()       :: binary().
+-type hex_span_id()        :: binary().
+
+-type trace_flags()        :: non_neg_integer().
+
+-type timestamp()          :: integer().
+
+-type span_ctx()           :: #span_ctx{}.
+-type span()               :: term().
+-type span_name()          :: unicode:unicode_binary() | atom().
+
+-type attribute_key()      :: unicode:unicode_binary() | atom().
+-type attribute_value()    :: unicode:unicode_binary()   |
+                              atom()                     |
+                              number()                   |
+                              boolean()                  |
+                              [unicode:unicode_binary() | atom() | float() | integer() | boolean()] |
+                              tuple().
+-type attribute()          :: {attribute_key(), attribute_value()}.
+-type attributes_map()     :: #{attribute_key() => attribute_value()} |
+                              [attribute()].
+
+-type span_kind()          :: ?SPAN_KIND_INTERNAL    |
+                              ?SPAN_KIND_SERVER      |
+                              ?SPAN_KIND_CLIENT      |
+                              ?SPAN_KIND_PRODUCER    |
+                              ?SPAN_KIND_CONSUMER.
+-type event()              :: #{system_time_native => integer(),
+                                name              := event_name(),
+                                attributes        := attributes_map()}.
+-type event_name()         :: unicode:unicode_binary() | atom().
+-type link()               :: #{trace_id   := trace_id(),
+                                span_id    := span_id(),
+                                attributes := attributes_map(),
+                                tracestate := otel_tracestate:t()}.
+-type status()             :: #status{}.
+-type status_code()        :: ?OTEL_STATUS_UNSET | ?OTEL_STATUS_OK | ?OTEL_STATUS_ERROR.
+
+%% The key must begin with a lowercase letter, and can only contain
+%% lowercase letters 'a'-'z', digits '0'-'9', underscores '_', dashes
+%% '-', asterisks '*', and forward slashes '/'.
+%% The value is opaque string up to 256 characters printable ASCII
+%% RFC0020 characters (i.e., the range 0x20 to 0x7E) except ',' and '='.
+%% Note that this also excludes tabs, newlines, carriage returns, etc.
+-type tracestate()         :: otel_tracestate:t().
+
+-type resource()           :: #{unicode:unicode_binary() => unicode:unicode_binary()}.
+
+-type text_map()       :: [{unicode:unicode_binary(), unicode:unicode_binary()}].
+
+-define(TRACER_KEY(TracerProvider, Name), {?MODULE, TracerProvider, tracer, Name}).
+-define(DEFAULT_TRACER_KEY(TracerProvider), ?TRACER_KEY(TracerProvider, '$__default_tracer')).
+-define(MODULE_TO_APPLICATION_KEY, {?MODULE, otel_module_to_application_key}).
+-define(TEXT_MAP_EXTRACTOR_KEY, {?MODULE, text_map_extractor}).
+-define(TEXT_MAP_INJECTOR_KEY, {?MODULE, text_map_injector}).
+
+%% uncomment when OTP-23 becomes the minimum required version
+%% -deprecated({start_tracer_provider, 2, "start the TracerProvider through the SDK"}).
+
+-include("gradualizer.hrl").
+
+%% @deprecated Start the TracerProvider through the SDK"
+-spec start_tracer_provider(atom(), map()) -> {ok, pid() | undefined} | {error, term()}.
+start_tracer_provider(Name, Config) ->
+    otel_tracer_provider:start(Name, Config).
+
+-spec set_default_tracer(tracer()) -> boolean().
+set_default_tracer(Tracer) ->
+    set_default_tracer(?GLOBAL_TRACER_PROVIDER_NAME, Tracer).
+
+-spec set_default_tracer(atom(), tracer()) -> boolean().
+set_default_tracer(TracerProvider, Tracer) ->
+    verify_and_set_term(Tracer, ?DEFAULT_TRACER_KEY(TracerProvider), otel_tracer).
+
+-spec set_tracer(atom(), tracer()) -> boolean().
+set_tracer(Name, Tracer) ->
+    set_tracer(Name, <<>>, undefined, Tracer).
+
+-spec set_tracer(Name, Vsn, SchemaUrl, Tracer) -> boolean() when
+      Name :: atom(),
+      Vsn :: unicode:chardata() | undefined,
+      SchemaUrl :: uri_string:uri_string() | undefined,
+      Tracer:: opentelemetry:tracer().
+set_tracer(Name, Vsn, SchemaUrl, Tracer) ->
+    set_tracer(?GLOBAL_TRACER_PROVIDER_NAME, Name, Vsn, SchemaUrl, Tracer).
+
+-spec set_tracer(TracerProvider, Name, Vsn, SchemaUrl, Tracer) -> boolean() when
+      TracerProvider :: atom(),
+      Name :: atom(),
+      Vsn :: unicode:chardata() | undefined,
+      SchemaUrl :: uri_string:uri_string() | undefined,
+      Tracer:: opentelemetry:tracer().
+set_tracer(TracerProvider, Name, Vsn, SchemaUrl, Tracer) ->
+    verify_and_set_term(Tracer, ?TRACER_KEY(TracerProvider, {Name, Vsn, SchemaUrl}), otel_tracer).
+
+-spec create_application_tracers([{Application, Description, Vsn}]) -> ok when
+      Application :: atom(),
+      Description :: string(),
+      Vsn :: string().
+create_application_tracers(Applications) ->
+    TracerMap = lists:foldl(fun({Name, _Description, Version}, Acc) ->
+                                    Vsn = vsn_to_binary(Version),
+                                    SchemaUrl = application:get_env(Name, otel_schema_url, undefined),
+                                    _ = get_tracer(Name, Version, SchemaUrl),
+                                    maps:merge(Acc, module_to_application(Name, Vsn, SchemaUrl))
+                            end, #{}, Applications),
+    persistent_term:put(?MODULE_TO_APPLICATION_KEY, TracerMap).
+
+%% creates a map of modules to application name, version and schema_url tuple
+module_to_application(Name, Version, SchemaUrl) ->
+    {ok, Modules} = application:get_key(Name, modules),
+    lists:foldl(fun(M, Acc) ->
+                        Acc#{M => {Name, Version, SchemaUrl}}
+                end, #{}, Modules).
+
+%% @doc Returns the default global tracer.
+%%
+%% Without the `opentelemetry' application loaded (as a dependency) and
+%% started (or another SDK), this function returns the default value
+%% `{otel_tracer_noop, []}'.
+-spec get_tracer() -> tracer().
+get_tracer() ->
+    get_tracer_(?GLOBAL_TRACER_PROVIDER_NAME).
+
+-spec get_tracer_(atom()) -> tracer().
+get_tracer_(TracerProvider) ->
+    persistent_term:get(?DEFAULT_TRACER_KEY(TracerProvider), {otel_tracer_noop, []}).
+
+%% @doc Returns the tracer for the given name.
+%%
+%% Passing `{Name, Vsn, SchemaUrl}' is the same as calling
+%% `get_tracer(Name, Vsn, SchemaUrl)'.
+%% @see get_tracer/3
+-spec get_tracer(Name) -> Tracer when
+      Name :: atom() | {atom(), Vsn, SchemaUrl},
+      Vsn :: unicode:chardata() | undefined,
+      SchemaUrl :: uri_string:uri_string() | undefined,
+      Tracer :: opentelemetry:tracer().
+get_tracer('$__default_tracer') ->
+    get_tracer();
+get_tracer({Name, Vsn, SchemaUrl}) ->
+    get_tracer(Name, Vsn, SchemaUrl);
+get_tracer(Name) ->
+    get_tracer(Name, undefined, undefined).
+
+%% @equiv get_tracer({Name, Vsn, SchemaUrl})
+-spec get_tracer(Name, Vsn, SchemaUrl) -> Tracer when
+      Name :: atom(),
+      Vsn :: unicode:chardata() | undefined,
+      SchemaUrl :: uri_string:uri_string() | undefined,
+      Tracer :: opentelemetry:tracer().
+get_tracer(Name, Vsn, SchemaUrl) ->
+    get_tracer(?GLOBAL_TRACER_PROVIDER_NAME, Name, Vsn, SchemaUrl).
+
+-spec get_tracer(TracerProvider, Name, Vsn, SchemaUrl) -> Tracer when
+      TracerProvider :: atom() | pid(),
+      Name :: atom(),
+      Vsn :: unicode:chardata() | undefined,
+      SchemaUrl :: uri_string:uri_string() | undefined,
+      Tracer :: opentelemetry:tracer().
+get_tracer(TracerProvider, Name, Vsn, SchemaUrl) ->
+    %% check cache and then use provider to get the tracer if it isn't cached yet
+    case persistent_term:get(?TRACER_KEY(TracerProvider, {Name, Vsn, SchemaUrl}), undefined) of
+        undefined ->
+            VsnBin = vsn_to_binary(Vsn),
+            Tracer = otel_tracer_provider:get_tracer(TracerProvider, Name, VsnBin, SchemaUrl),
+
+            %% cache the tracer
+            _ = set_tracer(Name, Vsn, SchemaUrl, Tracer),
+
+            Tracer;
+        Tracer ->
+            Tracer
+    end.
+
+-spec get_application_tracer(module()) -> tracer().
+get_application_tracer(ModuleName) ->
+    get_tracer(get_application(ModuleName)).
+
+-spec get_application_scope(module()) -> instrumentation_scope() | undefined.
+get_application_scope(ModuleName) ->
+    case get_application(ModuleName) of
+        {Name, Vsn, SchemaUrl} ->
+            instrumentation_scope(Name, Vsn, SchemaUrl);
+        _ ->
+            instrumentation_scope(<<>>, <<>>, <<>>)
+    end.
+
+%% looks up the name, version and schema_url used to create a Trace for the OTP
+%% Application a module is in. This name is used to look up a Tracer to use so
+%% if none is found for the ModuleName the key used for the default tracer.
+-spec get_application(module()) -> ApplicationTuple when
+      ApplicationTuple :: {Name, Vsn, SchemaUrl} | atom(),
+      Name :: atom(),
+      Vsn :: unicode:unicode_binary() | undefined,
+      SchemaUrl :: uri_string:uri_string() | undefined.
+get_application(ModuleName) ->
+    Map = persistent_term:get(?MODULE_TO_APPLICATION_KEY, #{}),
+    maps:get(ModuleName, Map, '$__default_tracer').
+
+%% setting the propagator is the same as setting the same injector and extractor
+set_text_map_propagator(Propagator) ->
+    set_text_map_injector(Propagator),
+    set_text_map_extractor(Propagator).
+
+set_text_map_extractor(Propagator) ->
+    persistent_term:put(?TEXT_MAP_EXTRACTOR_KEY, Propagator).
+
+set_text_map_injector(Propagator) ->
+    persistent_term:put(?TEXT_MAP_INJECTOR_KEY, Propagator).
+
+get_text_map_extractor() ->
+    persistent_term:get(?TEXT_MAP_EXTRACTOR_KEY, otel_propagator_text_map_noop).
+
+get_text_map_injector() ->
+    persistent_term:get(?TEXT_MAP_INJECTOR_KEY, otel_propagator_text_map_noop).
+
+%% @doc A monotonically increasing time provided by the Erlang runtime system in the native time unit.
+%% This value is the most accurate and precise timestamp available from the Erlang runtime and
+%% should be used for finding durations or any timestamp that can be converted to a system
+%% time before being sent to another system.
+
+%% Use {@link convert_timestamp/2} or {@link timestamp_to_nano/1} to convert a native monotonic time to a
+%% system time of either nanoseconds or another {@link erlang:time_unit()}.
+
+%% Using these functions allows timestamps to be accurate, used for duration and be exportable
+%% as POSIX time when needed.
+%% @end
+-spec timestamp() -> integer().
+timestamp() ->
+    erlang:monotonic_time().
+
+%% @doc Convert a native monotonic timestamp to nanosecond POSIX time. Meaning the time since Epoch.
+%% Epoch is defined to be 00:00:00 UTC, 1970-01-01.
+%% @end
+-spec timestamp_to_nano(timestamp()) -> pos_integer().
+timestamp_to_nano(Timestamp) ->
+    ?assert_type(convert_timestamp(Timestamp, nanosecond), pos_integer()).
+
+%% @doc Convert a native monotonic timestamp to POSIX time of any {@link erlang:time_unit()}.
+%% Meaning the time since Epoch. Epoch is defined to be 00:00:00 UTC, 1970-01-01.
+%% @end
+-spec convert_timestamp(timestamp(), erlang:time_unit()) -> integer().
+convert_timestamp(Timestamp, Unit) ->
+    Offset = erlang:time_offset(),
+    erlang:convert_time_unit(Timestamp + Offset, native, Unit).
+
+%% @doc Creates a list of Span links from the given `List'.
+%%
+%% This is equivalent to calling {@link link/2} or {@link link/4} multiple times.
+-spec links([TraceIdAndSpanId | span_ctx() | {span_ctx(), Attributes}]) -> [link()] when
+      TraceIdAndSpanId :: {trace_id(), span_id(), Attributes, TraceState},
+      Attributes :: attributes_map(),
+      TraceState :: otel_tracestate:t() | [{string(), string()}].
+links(List) when is_list(List) ->
+    lists:filtermap(fun({TraceId, SpanId, Attributes, TraceState}) when is_integer(TraceId) ,
+                                                                        is_integer(SpanId) ->
+                            link_or_false(TraceId, SpanId, otel_attributes:process_attributes(Attributes), TraceState);
+                       ({#span_ctx{trace_id=TraceId,
+                                   span_id=SpanId,
+                                   tracestate=TraceState}, Attributes}) when is_integer(TraceId) ,
+                                                                             is_integer(SpanId) ->
+                            link_or_false(TraceId, SpanId, otel_attributes:process_attributes(Attributes), TraceState);
+                       (#span_ctx{trace_id=TraceId,
+                                  span_id=SpanId,
+                                  tracestate=TraceState}) when is_integer(TraceId) ,
+                                                               is_integer(SpanId) ->
+                            link_or_false(TraceId, SpanId, [], TraceState);
+                       (_) ->
+                            false
+              end, List);
+links(_) ->
+    [].
+
+
+%% @equiv link(SpanCtx, [])
+-spec link(span_ctx() | undefined) -> link() | undefined.
+link(SpanCtx) ->
+    link(SpanCtx, []).
+
+%% @doc Creates a Span link to the Span represented by the given `SpanCtx'.
+%%
+%% The returned link can be used in the `links' field of a Span.
+-spec link(span_ctx() | undefined, attributes_map()) -> link() | undefined.
+link(_SpanCtx = #span_ctx{trace_id=TraceId,
+                          span_id=SpanId,
+                          tracestate=TraceState}, Attributes) ->
+    ?MODULE:link(TraceId, SpanId, otel_attributes:process_attributes(Attributes), TraceState);
+link(_, _) ->
+    undefined.
+
+%% @doc Creates a Span link to the Span represented by the given `TraceId' and `SpanId'.
+%%
+%% The returned link can be used in the `links' field of a Span.
+-spec link(TraceId, SpanId, Attributes, TraceState) -> link() | undefined when
+      TraceId :: trace_id(),
+      SpanId :: span_id(),
+      Attributes :: attributes_map(),
+      TraceState :: otel_tracestate:t().
+link(TraceId, SpanId, Attributes, TraceState) when is_integer(TraceId),
+                                                   is_integer(SpanId),
+                                                   (is_list(Attributes) orelse is_map(Attributes)) ->
+    #{trace_id => TraceId,
+      span_id => SpanId,
+      attributes => otel_attributes:process_attributes(Attributes),
+      tracestate => TraceState};
+link(_, _, _, _) ->
+    undefined.
+
+%% @equiv event(opentelemetry:timestamp(), Name, Attributes)
+-spec event(Name, Attributes) -> event() | undefined when
+      Name :: event_name(),
+      Attributes :: attributes_map().
+event(Name, Attributes) ->
+    event(opentelemetry:timestamp(), Name, Attributes).
+
+%% @doc Creates a Span event with the given `Name' and `Attributes'.
+%%
+%% The Span event is marked to have happened at `Timestamp'. The returned
+%% event can be used to add an event to a Span through {@link otel_span:add_events/2},
+%% for example.
+-spec event(Timestamp, Name, Attributes) -> event() | undefined when
+      Timestamp :: integer(),
+      Name :: event_name(),
+      Attributes :: attributes_map().
+event(Timestamp, Name, Attributes) when is_integer(Timestamp),
+                                        (is_list(Attributes) orelse is_map(Attributes)) ->
+
+    case otel_span:is_valid_name(Name) of
+        true ->
+            #{system_time_native => Timestamp,
+              name => Name,
+              attributes => otel_attributes:process_attributes(Attributes)};
+        false ->
+            undefined
+    end;
+event(_, _, _) ->
+    undefined.
+
+%% @doc Creates a list of Span events from the given `List'.
+%%
+%% This is a convenience function to create a list of Span events from a list
+%% of `{Time, Name, Attributes}' or `{Name, Attributes}' tuples. It's equivalent
+%% to calling {@link event/2} or {@link event/3} multiple times. This function
+%% also automatically filters out any invalid tuple.
+-spec events([Event]) -> [event()] when
+      Event :: {Timestamp :: integer(), event_name(), attributes_map()} |
+               {event_name(), attributes_map()}.
+events(Events) ->
+    Now = opentelemetry:timestamp(),
+    lists:filtermap(fun({Time, Name, Attributes}) ->
+                            case event(Time, Name, Attributes) of
+                                undefined ->
+                                    false;
+                                Event ->
+                                    {true, Event}
+                            end;
+                       ({Name, Attributes}) ->
+                            case event(Now, Name, Attributes) of
+                                undefined ->
+                                    false;
+                                Event ->
+                                    {true, Event}
+                            end;
+                       (_) ->
+                            false
+                    end, Events).
+
+%% @doc Create a Span status from the given `Code'.
+%%
+%% The returned status can be used to set the status of a Span through
+%% {@link otel_span:set_status/2}, for example.
+-spec status(Code) -> status() | undefined when
+      Code :: status_code().
+status(Code) ->
+    status(Code, <<>>).
+
+%% @doc Create a Span status from the given `Code' and with the given `Message'.
+%%
+%% The returned status can be used to set the status of a Span through
+%% {@link otel_span:set_status/2}, for example.
+-spec status(Code, Message) -> status() | undefined when
+      Code :: status_code(),
+      Message :: unicode:unicode_binary().
+status(?OTEL_STATUS_ERROR, Message) when is_binary(Message) ->
+    #status{code=?OTEL_STATUS_ERROR, message=Message};
+status(?OTEL_STATUS_OK, _Message) ->
+    #status{code=?OTEL_STATUS_OK};
+status(?OTEL_STATUS_UNSET, _Message) ->
+    #status{code=?OTEL_STATUS_UNSET};
+status(_, _) ->
+    undefined.
+
+%% internal functions
+
+%% @private
+-spec verify_and_set_term(module() | {module(), term()}, term(), atom()) -> boolean().
+verify_and_set_term(Module, TermKey, Behaviour) ->
+    case verify_module_exists(Module) of
+        true ->
+            persistent_term:put(TermKey, Module),
+            true;
+        false ->
+            ?LOG_WARNING("Module ~p does not exist. "
+                         "A noop ~p will be used.",
+                         [Module, Behaviour]),
+            false
+    end.
+
+%% @private
+-spec verify_module_exists(module() | {module(), term()}) -> boolean().
+verify_module_exists({Module, _}) ->
+    verify_module_exists(Module);
+verify_module_exists(Module) ->
+    try Module:module_info() of
+        _ ->
+          true
+    catch
+        error:undef ->
+            false
+    end.
+
+%% for use in a filtermap
+%% return {true, Link} if a link is returned or return false
+%% a list is supported for tracestate for backwards compatibility
+%% @private
+link_or_false(TraceId, SpanId, Attributes, TraceState) when is_list(TraceState) ->
+    link_or_false(TraceId, SpanId, Attributes, otel_tracestate:new(TraceState));
+link_or_false(TraceId, SpanId, Attributes, TraceState) ->
+    case link(TraceId, SpanId, Attributes, TraceState) of
+        Link=#{}->
+            {true, Link};
+        _ ->
+            false
+    end.
+
+instrumentation_scope(Name, Vsn, SchemaUrl) ->
+    case name_to_binary(Name) of
+        undefined ->
+            undefined;
+        BinaryName ->
+            #instrumentation_scope{name=BinaryName,
+                                   version=vsn_to_binary(Vsn),
+                                   schema_url=schema_url_to_binary(SchemaUrl)}
+    end.
+
+%% this function remains solely to keep backwards compatibility
+%% but `instrumentation_scope' should be used instead
+instrumentation_library(Name, Vsn, SchemaUrl) ->
+    instrumentation_scope(Name, Vsn, SchemaUrl).
+
+%% schema_url is option, so set to undefined if its not a string
+schema_url_to_binary(SchemaUrl) when is_binary(SchemaUrl) ; is_list(SchemaUrl) ->
+    unicode:characters_to_binary(SchemaUrl);
+schema_url_to_binary(_) ->
+    undefined.
+
+%% Vsn can't be an atom or anything but a list or binary
+%% so return empty binary string if it isn't a list or binary.
+%% @private
+vsn_to_binary(Vsn) when is_binary(Vsn) ; is_list(Vsn) ->
+    unicode:characters_to_binary(Vsn);
+vsn_to_binary(_) ->
+    <<>>.
+
+%% Instrumentation name can be atom, list or binary. But atom `undefined'
+%% must stay as `undefined' atom.
+name_to_binary(undefined)->
+    undefined;
+name_to_binary(T) when is_atom(T) ->
+    atom_to_binary(T, utf8);
+name_to_binary(T) when is_list(T) ->
+    list_to_binary(T);
+name_to_binary(T) when is_binary(T) ->
+    T.

apps/opentelemetry_api/src/opentelemetry_api.app.src

@@ -0,0 +1,15 @@
+{application, opentelemetry_api,
+ [{description, "OpenTelemetry API"},
+  {vsn, "1.4.1"},
+  {registered, []},
+  {applications,
+   [kernel,
+    stdlib
+   ]},
+  {exclude_paths, ["rebar.lock"]},
+  {env,[]},
+  {modules, []},
+
+  {licenses, ["Apache-2.0"]},
+  {links, [{"GitHub", "https://github.com/open-telemetry/opentelemetry-erlang"}]}
+ ]}.

apps/opentelemetry_api/src/otel_attributes.erl

@@ -0,0 +1,219 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2021, 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.
+%%
+%% @doc Functions to work with Attributes.
+%%
+%% An Attribute is a key-value pair with string or atom keys.
+%% See <a href="https://opentelemetry.io/docs/specs/otel/common/#attribute">the specification</a>.
+%% @end
+%%%-------------------------------------------------------------------------
+-module(otel_attributes).
+
+-export([new/3,
+         set/2,
+         set/3,
+         dropped/1,
+         map/1,
+         is_valid_attribute/2,
+         process_attributes/1]).
+
+-define(is_allowed_key(Key), (is_atom(Key) orelse (is_binary(Key) andalso Key =/= <<"">>))).
+-define(is_allowed_value(Value), (is_atom(Value) orelse
+                                  is_boolean(Value) orelse
+                                  is_number(Value) orelse
+                                  is_binary(Value) orelse
+                                  is_list(Value))).
+-record(attributes, {
+                     count_limit :: integer(),
+                     value_length_limit :: integer() | infinity,
+                     dropped :: integer(),
+                     map :: map()
+                    }).
+
+-type t() :: #attributes{}.
+
+-export_type([t/0]).
+
+%% @doc Creates a new `Attributes' from `Pairs' with the given count and value length limits.
+%%
+%% `Pairs' can be a list of key-value pairs or a map. If `Pairs' is not a list or map, the
+%% function returns an empty `Attributes'.
+-spec new(
+    [opentelemetry:attribute()] | opentelemetry:attributes_map(),
+    integer(),
+    integer() | infinity
+) -> t().
+new(Pairs, CountLimit, ValueLengthLimit) when is_list(Pairs) ->
+    new(maps:from_list(Pairs), CountLimit, ValueLengthLimit);
+new(Map, CountLimit, ValueLengthLimit) when is_map(Map) ->
+    update_attributes(Map, #attributes{count_limit=CountLimit,
+                                        value_length_limit=ValueLengthLimit,
+                                        dropped=0,
+                                        map=#{}});
+new(_, CountLimit, ValueLengthLimit) ->
+    #attributes{count_limit=CountLimit,
+                value_length_limit=ValueLengthLimit,
+                dropped=0,
+                map=#{}}.
+
+%% @doc Sets the given key-value pairs in the given `Attributes'. Overrides 
+%% the existing value for a given key if it already exists in `Attributes'.
+%%
+%% `NewListOrMap' can be a list of key-value pairs or a map. If `NewListOrMap' is not a list
+%% or map, the function returns `Attributes' as is. Returns the updated `Attributes'.
+-spec set([opentelemetry:attribute()] | opentelemetry:attributes_map(), t()) -> t().
+set(NewListOrMap, Attributes) when is_list(NewListOrMap) ->
+    set(maps:from_list(NewListOrMap), Attributes);
+set(NewMap, Attributes) when is_map(NewMap) ->
+    update_attributes(NewMap, Attributes);
+set(_, Attributes) ->
+    Attributes.
+
+%% @doc Sets the given key-value pair in the given `Attributes'.
+%%
+%% Overrides the existing value under `Key' if `Key' already exists.
+%% Returns the updated `Attributes'.
+-spec set(opentelemetry:attribute_key(), opentelemetry:attribute_value(), t()) -> t().
+set(Key, Value, Attributes) ->
+    update_attribute(Key, Value, Attributes).
+
+%% @doc Returns the count of dropped attributes in the given `Attributes'.
+dropped(#attributes{dropped=Dropped}) ->
+    Dropped.
+
+%% @doc Returns the Attributes in the form of a map.
+%%
+%% For example:
+%% ```
+%% otel_attributes:new([], 10, 10),
+%% otel_attributes:set(<<"key">>, <<"value">>, Attributes),
+%% otel_attributes:map(Attributes).
+%% %=> #{<<"key">> => <<"value">>}
+%% '''
+-spec map(t()) -> map().
+map(#attributes{map=Map}) ->
+    Map.
+
+%%
+
+update_attributes(List, Attributes) ->
+    maps:fold(fun update_attribute/3, Attributes, List).
+
+%% add key/value if the size is still under the limit or the key is already in the map
+update_attribute(Key, Value, Attributes=#attributes{count_limit=CountLimit,
+                                                    value_length_limit=ValueLengthLimit,
+                                                    map=Map})
+  when is_binary(Value) , (map_size(Map) < CountLimit orelse is_map_key(Key, Map)) ->
+    Attributes#attributes{map=Map#{Key => maybe_truncate_binary(Value, ValueLengthLimit)}};
+%% value is a list of binaries, so potentially truncate
+update_attribute(Key, [Value1 | _Rest] = Value, Attributes=#attributes{count_limit=CountLimit,
+                                                    value_length_limit=ValueLengthLimit,
+                                                    map=Map})
+  when is_binary(Value1) , (map_size(Map) < CountLimit orelse is_map_key(Key, Map)) ->
+    Attributes#attributes{map=Map#{Key => [maybe_truncate_binary(V, ValueLengthLimit) || V <- Value]}};
+%% already in the map and not a binary so update
+update_attribute(Key, Value, Attributes=#attributes{map=Map}) when is_map_key(Key, Map) ->
+    Attributes#attributes{map=Map#{Key := Value}};
+%% we've already started dropping, so just increment
+update_attribute(_Key, _Value, Attributes=#attributes{dropped=Dropped})
+  when Dropped > 0 ->
+    Attributes#attributes{dropped=Dropped + 1};
+%% met or exceeded the limit
+update_attribute(_Key, _Value, Attributes=#attributes{count_limit=CountLimit,
+                                                      dropped=Dropped,
+                                                      map=Map})
+  when map_size(Map) >= CountLimit ->
+    Attributes#attributes{dropped=Dropped + 1};
+%% new attribute
+update_attribute(Key, Value, Attributes=#attributes{map=Map}) ->
+    Attributes#attributes{map=Map#{Key => Value}}.
+
+maybe_truncate_binary(Value, infinity) ->
+  Value;
+maybe_truncate_binary(Value, ValueLengthLimit) ->
+    case string:length(Value) > ValueLengthLimit of
+        true ->
+            string:slice(Value, 0, ValueLengthLimit);
+        false ->
+            Value
+    end.
+
+%% @doc Checks whether the given key-value pair makes for a valid attribute.
+%%
+%% For example:
+%% ```
+%% otel_attributes:is_valid_attribute(<<"key">>, <<"value">>).
+%% %=> true
+%%
+%% otel_attributes:is_valid_attribute(atom_key, <<"value">>).
+%% %=> true
+%%
+%% otel_attributes:is_valid_attribute(123, <<"value">>).
+%% %=> false
+%% '''
+-spec is_valid_attribute(opentelemetry:attribute_key(), opentelemetry:attribute_value()) -> boolean().
+is_valid_attribute(Key, Value) when is_tuple(Value) , ?is_allowed_key(Key) ->
+    is_valid_attribute(Key, tuple_to_list(Value));
+%% lists as attribute values must be primitive types and homogeneous
+is_valid_attribute(Key, [Value1 | _Rest] = Values) when is_binary(Value1) , ?is_allowed_key(Key) ->
+    lists:all(fun is_binary/1, Values);
+is_valid_attribute(Key, [Value1 | _Rest] = Values) when is_boolean(Value1) , ?is_allowed_key(Key) ->
+    lists:all(fun is_boolean/1, Values);
+is_valid_attribute(Key, [Value1 | _Rest] = Values) when is_atom(Value1) , ?is_allowed_key(Key) ->
+    lists:all(fun is_valid_atom_value/1, Values);
+is_valid_attribute(Key, [Value1 | _Rest] = Values) when is_integer(Value1) , ?is_allowed_key(Key) ->
+    lists:all(fun is_integer/1, Values);
+is_valid_attribute(Key, [Value1 | _Rest] = Values) when is_float(Value1) , ?is_allowed_key(Key) ->
+    lists:all(fun is_float/1, Values);
+is_valid_attribute(_Key, Value) when is_list(Value) ->
+    false;
+is_valid_attribute(Key, []) when ?is_allowed_key(Key) ->
+    true;
+is_valid_attribute(Key, Value) when ?is_allowed_key(Key) , ?is_allowed_value(Value) ->
+    true;
+is_valid_attribute(_, _) ->
+    false.
+
+is_valid_atom_value(undefined) ->
+    false;
+is_valid_atom_value(nil) ->
+    false;
+is_valid_atom_value(Value) ->
+    is_atom(Value) andalso (is_boolean(Value) == false).
+
+%% @private
+-spec process_attributes(eqwalizer:dynamic()) -> opentelemetry:attributes_map().
+process_attributes(Attributes) when is_map(Attributes) ->
+    maps:fold(fun process_attribute/3, #{}, Attributes);
+process_attributes([]) -> #{};
+process_attributes(Attributes) when is_list(Attributes) ->
+    process_attributes(maps:from_list(Attributes));
+process_attributes(_) ->
+    #{}.
+
+process_attribute(Key, Value, Map) when is_tuple(Value) ->
+    List = tuple_to_list(Value),
+    case is_valid_attribute(Key, List) of
+        true ->
+            maps:put(Key, Value, Map);
+        false ->
+            Map
+    end;
+process_attribute(Key, Value, Map) ->
+    case is_valid_attribute(Key, Value) of
+        true ->
+            maps:put(Key, Value, Map);
+        false ->
+            Map
+    end.

apps/opentelemetry_api/src/otel_baggage.erl

@@ -0,0 +1,240 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @doc Baggage is used to annotate telemetry, adding context and
+%% information to metrics, traces, and logs. It is represented by a set
+%% of name/value pairs describing user-defined properties.
+%%
+%% The baggage can be stored either in the <i>current context</i> (with {@link set/1} or
+%% {@link set/3}, for example) or in an explicit Context (see {@link otel_ctx}).
+%% @end
+%%%-------------------------------------------------------------------------
+-module(otel_baggage).
+
+-export([set/1,
+         set/2,
+         set/3,
+         set/4,
+         set_to/2,
+         set_to/3,
+         set_to/4,
+         get_all/0,
+         get_all/1,
+         clear/0,
+         clear/1]).
+
+%% Keys and values are UTF-8 binaries
+
+-type key() :: unicode:unicode_binary().
+%% The type for the baggage key, which is a UTF-8 binary.
+
+-type value() :: unicode:unicode_binary().
+%% The type for the baggage value, which is a UTF-8 binary.
+
+-type input_key() :: key() | unicode:charlist().
+%% An input key, that is, a key that is then converted to a UTF-8 binary.
+
+-type input_value() :: value() | unicode:charlist() | atom().
+%% An input value, that is, a value that is then converted to a UTF-8 binary.
+
+-type metadata() :: [unicode:unicode_binary() | {unicode:unicode_binary(), unicode:unicode_binary()}].
+%% The type for the baggage metadata, which is a list of UTF-8 binaries or a list of
+%% tuples of UTF-8 binaries (as key-value pairs).
+
+-type t() :: #{key() => {value(), metadata()}}.
+%% The type for the baggage.
+
+-export_type([t/0,
+              key/0,
+              value/0]).
+
+-define(BAGGAGE_KEY, '$__otel_baggage_ctx_key').
+
+-include("gradualizer.hrl").
+
+%% @doc Sets the given key-value pairs in the current baggage.
+%%
+%% If you need to set <i>metadata</i> for the key-value pair, use {@link set/3} instead.
+-spec set(#{key() => value()} | [{key(), value()}]) -> ok.
+set(KeyValues) when is_list(KeyValues) ->
+    set(maps:from_list(KeyValues));
+set(KeyValues) when is_map(KeyValues) ->
+    Baggage = otel_ctx:get_value(?BAGGAGE_KEY, #{}),
+    otel_ctx:set_value(?BAGGAGE_KEY, maps:merge(Baggage, verify_baggage(KeyValues)));
+set(_) ->
+    ok.
+
+%% @doc Sets the given key-value pair in the current baggage, or sets the
+%% given key-value pairs in the baggage for the given context.
+%%
+%% Returns `ok' when using the `set(Key, Value)' form, or the updated context when
+%% using the `set(Ctx, KeyValues)' form.
+%% @end
+%% Ctx will never be a list or binary so we can tell if a context is passed by checking that
+-spec set(otel_ctx:t() | input_key(), #{input_key() => input_value()} | [{input_key(), input_value()}] | input_value()) -> otel_ctx:t() | ok.
+set(Key, Value) when (is_list(Key) orelse is_binary(Key)) andalso is_binary(Value) ->
+    ?assert_type(set(Key, Value, []), ok | undefined | #{any() => any()});
+%% drop bad value
+set(Key, Value) when (is_list(Key) orelse is_binary(Key)) andalso not is_binary(Value) ->
+    ok;
+set(Ctx, KeyValues) when is_list(KeyValues) ->
+    %% eqwalizer:ignore I know what I'm doing
+    ?assert_type(set(Ctx, maps:from_list(KeyValues)), ok | undefined | #{any() => any()});
+set(Ctx, KeyValues) when is_map(KeyValues) andalso (is_map(Ctx) orelse Ctx =:= undefined)->
+    Baggage = otel_ctx:get_value(Ctx, ?BAGGAGE_KEY, #{}),
+    otel_ctx:set_value(Ctx, ?BAGGAGE_KEY, maps:merge(Baggage, verify_baggage(KeyValues))).
+
+%% @doc Sets the given key-value pairs in the baggage for the given context.
+%%
+%% Returns the updated context.
+-spec set_to(otel_ctx:t(), #{input_key() => input_value()} | [{input_key(), input_value()}]) -> otel_ctx:t().
+set_to(Ctx, KeyValues) when is_list(KeyValues) ->
+    set_to(Ctx, maps:from_list(KeyValues));
+set_to(Ctx, KeyValues) when is_map(KeyValues) ->
+    Baggage = otel_ctx:get_value(Ctx, ?BAGGAGE_KEY, #{}),
+    otel_ctx:set_value(Ctx, ?BAGGAGE_KEY, maps:merge(Baggage, verify_baggage(KeyValues))).
+
+%% @doc Sets the given key-value pair in the current baggage (with the
+%% associated metadata), or sets the given key-value pair in the baggage for the
+%% given context.
+%%
+%% Returns `ok' when using the `set(Key, Value, Metadata)' form, or the updated
+%% context when using the `set(Ctx, Key, Value)' form.
+-spec set(otel_ctx:t() | input_key(), input_key() | input_value(), input_value() | metadata()) -> otel_ctx:t() | ok.
+set(Key, Value, Metadata) when (is_list(Key) orelse is_binary(Key)) andalso is_binary(Value) ->
+    Baggage = otel_ctx:get_value(?BAGGAGE_KEY, #{}),
+    otel_ctx:set_value(?BAGGAGE_KEY, maps:merge(Baggage, verify_baggage(#{Key => {Value, Metadata}})));
+%% drop bad value
+set(Key, Value, _Metadata) when (is_list(Key) orelse is_binary(Key)) andalso not is_binary(Value) ->
+    ok;
+set(Ctx, Key, Value) ->
+    set_to(?assert_type(Ctx, otel_ctx:t()),
+           ?assert_type(Key, input_key()),
+           ?assert_type(Value, input_value()),
+           []).
+
+%% @doc Sets the given key-value pair in the baggage for the given context.
+%%
+%% Returns the updated context.
+-spec set_to(otel_ctx:t(), input_key(), input_value()) -> otel_ctx:t().
+set_to(Ctx, Key, Value) ->
+    set_to(Ctx, Key, Value, []).
+
+%% @doc Sets the given key-value pair in the baggage for the given context, with the
+%% associated metadata.
+%%
+%% Returns the updated context.
+-spec set(otel_ctx:t(), input_key(), input_value(), metadata()) -> otel_ctx:t().
+set(Ctx, Key, Value, Metadata) when is_binary(Value) ->
+    Baggage = otel_ctx:get_value(Ctx, ?BAGGAGE_KEY, #{}),
+    otel_ctx:set_value(Ctx, ?BAGGAGE_KEY, maps:merge(Baggage, verify_baggage(#{Key => {Value, Metadata}})));
+%% drop bad value
+set(Ctx, _, _, _) ->
+    Ctx.
+
+%% @doc Sets the given key-value pair in the baggage for the given context, with the
+%% associated metadata.
+%%
+%% Returns the updated context.
+-spec set_to(otel_ctx:t(), input_key(), input_value(), metadata()) -> otel_ctx:t().
+set_to(Ctx, Key, Value, Metadata) when is_binary(Value) ->
+    Baggage = otel_ctx:get_value(Ctx, ?BAGGAGE_KEY, #{}),
+    otel_ctx:set_value(Ctx, ?BAGGAGE_KEY, maps:merge(Baggage, verify_baggage(#{Key => {Value, Metadata}})));
+%% drop bad value
+set_to(Ctx, _, _, _) ->
+    Ctx.
+
+%% @doc Returns the baggage from the process dictionary.
+-spec get_all() -> t().
+get_all() ->
+    otel_ctx:get_value(?BAGGAGE_KEY, #{}).
+
+%% @doc Returns the baggage for the given context.
+-spec get_all(otel_ctx:t()) -> t().
+get_all(Ctx) ->
+    otel_ctx:get_value(Ctx, ?BAGGAGE_KEY, #{}).
+
+%% @doc Clears the baggage, removing all the current key-value pairs.
+-spec clear() -> ok.
+clear() ->
+    otel_ctx:set_value(?BAGGAGE_KEY, #{}).
+
+%% @doc Clears the baggage for the given context, removing all the current key-value pairs.
+-spec clear(otel_ctx:t()) -> otel_ctx:t().
+clear(Ctx) ->
+    otel_ctx:set_value(Ctx, ?BAGGAGE_KEY, #{}).
+
+%%
+
+%% checks the keys, values and metadata are valid and drops them if they are not
+%% all strings are converted to binaries
+verify_baggage(KeyValues) ->
+    maps:fold(fun(K, V, Acc) ->
+                      %% TODO: filter out keys with invalid characters here
+                      case to_binary(K) of
+                          error ->
+                              Acc;
+                          BinKey ->
+                              case update_metadata(V) of
+                                  {true, ValueMetadata} ->
+                                      Acc#{BinKey => ValueMetadata};
+                                  _ ->
+                                      Acc
+                              end
+                      end
+              end, #{}, KeyValues).
+
+to_binary(String) when is_list(String)->
+    %% wrap in a `try' in case the list is not a printable list
+    %% this can go away if we start checking the key with a regex
+    %% to ensure it only contains certain characters
+    try unicode:characters_to_binary(String) catch _:_ -> error end;
+to_binary(String) when is_atom(String) ->
+    atom_to_binary(String, utf8);
+to_binary(String) when is_binary(String) ->
+    String;
+to_binary(_) ->
+    error.
+
+update_metadata({Value, Metadata}) when is_list(Value) ->
+    case to_binary(Value) of
+        error ->
+            false;
+        BinValue ->
+            update_metadata(BinValue, Metadata)
+    end;
+update_metadata(Value) when is_list(Value) ->
+    case to_binary(Value) of
+        error ->
+            false;
+        BinValue ->
+            update_metadata(BinValue, [])
+    end;
+update_metadata({Value, Metadata}) ->
+    update_metadata(Value, Metadata);
+update_metadata(Value) ->
+    update_metadata(Value, []).
+
+update_metadata(Value, Metadata) when (is_binary(Value) orelse is_list(Value)) andalso is_list(Metadata) ->
+    {true, {Value, lists:filtermap(fun verify_metadata/1, Metadata)}};
+update_metadata(_, _) ->
+    false.
+
+
+verify_metadata({MK, MV}) when is_binary(MK) , is_binary(MV) ->
+    true;
+verify_metadata(M) when is_binary(M) ->
+    true;
+verify_metadata(_) ->
+    false.

apps/opentelemetry_api/src/otel_ctx.erl

@@ -0,0 +1,209 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @doc Ctx is responsible for propagating values within a process that
+%% are associated with a particular Trace or set of Baggage.
+%% `OpenTelemetry.Tracer' and `OpenTelemetry.Baggage' handle updating
+%% the Context.
+%%
+%% Functions in this module include variants that explicitly take a `Ctx'
+%% argument and variants that implicitly use the <i>current context</i>, which is
+%% the context stored in the process dictionary.
+%% @end
+%%%-------------------------------------------------------------------------
+-module(otel_ctx).
+
+-export([new/0,
+         set_value/2,
+         set_value/3,
+         get_value/1,
+         get_value/2,
+         get_value/3,
+         remove/1,
+         remove/2,
+         clear/0,
+         clear/1,
+
+         attach/1,
+         detach/1,
+         with_ctx/2,
+         get_current/0,
+
+         text_map_extractor/2,
+         text_map_injector/2,
+         text_map_extractor_fun/3,
+         text_map_injector_fun/3]).
+
+-type t() :: map() | undefined.
+%% A context map.
+
+-type key() :: term().
+%% A context key.
+
+-type value() :: term().
+%% A context value.
+
+%% at this time the "token" is actually the context map itself
+-opaque token() :: t().
+%% An opaque token that represents a context.
+
+-export_type([t/0,
+              token/0,
+              key/0,
+              value/0
+            ]).
+
+-define(CURRENT_CTX, '$__current_otel_ctx').
+
+%% @doc Creates a new context.
+-spec new() -> t().
+new() ->
+    #{}.
+
+%% @doc Sets a value in the current context under the given key.
+-spec set_value(term(), term()) -> ok.
+set_value(Key, Value) ->
+    erlang:put(?CURRENT_CTX, set_value(erlang:get(?CURRENT_CTX), Key, Value)),
+    ok.
+
+%% @doc Sets a value in the given context under the given key.
+%%
+%% Returns the updated context.
+-spec set_value(t(), term(), term()) -> t().
+set_value(Ctx, Key, Value) when is_map(Ctx) ->
+    Ctx#{Key => Value};
+set_value(_, Key, Value) ->
+    #{Key => Value}.
+
+%% @doc Gets a value from the current context under the given key.
+-spec get_value(term()) -> eqwalizer:dynamic().
+get_value(Key) ->
+    get_value(erlang:get(?CURRENT_CTX), Key, undefined).
+
+%% @doc Gets a value from the current context under the given key, or returns the default value
+%% if the key is not present in the current context.
+-spec get_value(term(), term()) -> eqwalizer:dynamic().
+get_value(Key, Default) ->
+    get_value(erlang:get(?CURRENT_CTX), Key, Default).
+
+%% @doc Gets a value from the given context under the given key, or returns the default value
+%% if the key is not present in the given context or if `Ctx' is `undefined'.
+-spec get_value(t(), term(), term()) -> eqwalizer:dynamic().
+get_value(undefined, _Key, Default) ->
+    Default;
+get_value(Ctx, Key, Default) when is_map(Ctx) ->
+    maps:get(Key, Ctx, Default);
+get_value(_, _, Default) ->
+    Default.
+
+%% @doc Removes all key-value pairs from the current context.
+-spec clear() -> ok.
+clear() ->
+    erlang:erase(?CURRENT_CTX),
+    ok.
+
+%% @doc Removes all key-value pairs from the given context.
+%%
+%% Returns an empty context.
+-spec clear(t()) -> t().
+clear(_Ctx) ->
+    new().
+
+%% @doc Removes the value under the given key from the current context.
+-spec remove(term()) -> ok.
+remove(Key) ->
+    case erlang:get(?CURRENT_CTX) of
+        Map when is_map(Map) ->
+            erlang:put(?CURRENT_CTX, maps:remove(Key, Map)),
+            ok;
+        _ ->
+            ok
+    end.
+
+%% @doc Removes the value under the given key from the given context.
+%%
+%% Returns the updated context.
+-spec remove(t(), term()) -> t().
+remove(Ctx, Key) when is_map(Ctx) ->
+    maps:remove(Key, Ctx);
+remove(_, _) ->
+    new().
+
+%% @doc Returns the current context.
+-spec get_current() -> map().
+get_current() ->
+    case erlang:get(?CURRENT_CTX) of
+        Map when is_map(Map) ->
+            Map;
+        _ ->
+            #{}
+    end.
+
+%% @doc Attaches the given context to the current process.
+%%
+%% Essentially, this sets `Ctx' as the <i>current context</i>
+%% .
+-spec attach(t()) -> token().
+attach(Ctx) ->
+    update_logger_process_metadata(Ctx),
+    erlang:put(?CURRENT_CTX, Ctx).
+
+%% @doc Detaches the given context from the current process.
+-spec detach(token()) -> t() | undefined.
+detach(Token) ->
+    %% at this time `Token' is a context
+    update_logger_process_metadata(Token),
+    erlang:put(?CURRENT_CTX, Token).
+
+%% @doc Attaches a context and runs a function, detaching the context at the end.
+%%
+%% Returns the detached context.
+-spec with_ctx(t(), fun(() -> term())) -> {term(), t()}.
+with_ctx(Ctx, Fun) ->
+    Token = otel_ctx:attach(Ctx),
+    try
+        Result = Fun(),
+        {Result, otel_ctx:detach(Token)}
+    catch
+        C:T:S ->
+            otel_ctx:detach(Token),
+            erlang:raise(C, T, S)
+    end.
+
+
+%% Extractor and Injector setup functions
+
+%% @private
+text_map_extractor(Key, FromText) ->
+    {fun ?MODULE:text_map_extractor_fun/3, {Key, FromText}}.
+
+%% @private
+text_map_extractor_fun(TextMap, Key, FromText) ->
+    New = FromText(TextMap, ?MODULE:get_value(Key, #{})),
+    ?MODULE:set_value(Key, New).
+
+%% @private
+text_map_injector(Key, ToText) ->
+    {fun ?MODULE:text_map_injector_fun/3, {Key, ToText}}.
+
+%% @private
+text_map_injector_fun(TextMap, Key, ToText) ->
+    TextMap ++ ToText(?MODULE:get_value(Key, undefined)).
+
+%%
+
+update_logger_process_metadata(undefined) ->
+    ok;
+update_logger_process_metadata(Ctx) ->
+    otel_tracer:update_logger_process_metadata(Ctx).

apps/opentelemetry_api/src/otel_propagator.erl

@@ -0,0 +1,91 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2020, 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.
+%%
+%% @doc A Propagator injects or extracts data from a Context so information
+%% like baggage and trace context can be transported along with cross service
+%% requests, like an HTTP request.
+%%
+%% Propagators are defined based on the type of encoding they inject and
+%% extract. At this time there is only a TextMapPropagator,
+%% {@link otel_propagator_text_map}, which works on ASCII keys and values.
+%%
+%% This behaviour is only for defining the callbacks used by each propagator
+%% per type and is only used by developers adding a new type of propagator
+%% (like for binary protocols), not implementations of propagators themselves
+%% (like B3 or W3C TraceContext).
+%%
+%% Users configure and call propagators based on their type. See the docs
+%% for {@link otel_propagator_text_map} for more details.
+%% @end
+%%%-------------------------------------------------------------------------
+-module(otel_propagator).
+
+-export([builtins_to_modules/1,
+         builtin_to_module/1]).
+
+-callback inject(t(), carrier()) -> carrier().
+%% Sets a value into a carrier.
+
+-callback inject_from(otel_ctx:t(), t(), carrier()) -> carrier().
+%% Sets a value from a context into a carrier.
+
+-callback extract(t(), carrier()) -> otel_ctx:t() | otel_ctx:token().
+%% Extracts a value from a carrier.
+
+-callback extract_to(otel_ctx:t(), t(), carrier()) -> otel_ctx:t().
+%% Extracts a value from a carrier into a context.
+
+-type t() :: builtin() | module() | {module(), term()}.
+%% A propagator, which can be a built-in propagator, a module, or a module
+%% and associated term.
+
+%% trace_context and tracecontext are the same. tracecontext is the term
+%% in Otel specs and trace_context is the more idiomatic Erlang spelling
+%% In the future, also: jaeger
+-type builtin() :: trace_context | tracecontext | b3 | b3multi | baggage.
+%% A built-in propagator.
+
+-type carrier() :: term().
+%% A carrier, which can be any type.
+
+-export_type([t/0,
+              builtin/0,
+              carrier/0]).
+
+%% convert the short name of a propagator to its module name if it is a builtin
+%% if the name doesn't match a builtin it is assumed to be a module
+%% @private
+-spec builtins_to_modules([t()]) -> [module() | {module(), term()}].
+builtins_to_modules(Propagators) ->
+    [builtin_to_module(P) || P <- Propagators].
+
+%% @private
+-spec builtin_to_module(builtin() | module() | {module(), term()}) -> module() | {module(), term()}.
+builtin_to_module(tracecontext) ->
+    otel_propagator_trace_context;
+builtin_to_module(trace_context) ->
+    otel_propagator_trace_context;
+builtin_to_module(b3) ->
+    {otel_propagator_b3, b3single};
+builtin_to_module(b3multi) ->
+    {otel_propagator_b3, b3multi};
+builtin_to_module(baggage) ->
+    otel_propagator_baggage;
+%% TODO: add jaeger as builtin propagator
+%% builtin_to_module(jaeger) ->
+%%     otel_propagator_jaeger;
+builtin_to_module(Module) when is_atom(Module) ->
+    Module;
+builtin_to_module(Propagator) ->
+    Propagator.

apps/opentelemetry_api/src/otel_propagator_b3.erl

@@ -0,0 +1,114 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @doc An implementation of {@link otel_propagator_text_map} that injects and
+%% extracts trace context using the B3 specification from Zipkin.
+%%
+%% Since `trace_context' and `baggage' are the two default propagators, the
+%% global TextMap Propagators must be configured if B3 is to be used for
+%% propagation:
+%%
+%% ```
+%% {text_map_propagators, [b3, baggage]},
+%% '''
+%%
+%% To use B3 multi-header format use:
+%%
+%% ```
+%% {text_map_propagators, [b3multi, baggage]},
+%% '''
+%%
+%% ```
+%% CompositePropagator = otel_propagator_text_map_composite:create([b3, baggage]),
+%% opentelemetry:set_text_map_propagator(CompositePropagator).
+%% '''
+%%
+%% It is also possible to set a separate list of injectors or extractors.
+%% For example, if the service should extract B3 encoded context but you
+%% only want to inject context encoded with the W3C TraceContext format
+%% (maybe you have some services only supporting B3 that are making requests
+%% to your server but you have no reason to continue propagating in both
+%% formats when communicating to other services further down the stack).
+%% In that case you would instead set configuration like:
+%%
+%%
+%% ```
+%% {text_map_extractors, [b3, trace_context, baggage]},
+%% {text_map_injectors, [trace_context, baggage]},
+%% '''
+%%
+%% Or using calls to {@link opentelemetry} at runtime:
+%%
+%% ```
+%% B3CompositePropagator = otel_propagator_text_map_composite:create([b3, trace_context, baggage]),
+%% CompositePropagator = otel_propagator_text_map_composite:create([trace_context, baggage]),
+%% opentelemetry:set_text_map_extractor(B3CompositePropagator),
+%% opentelemetry:set_text_map_injector(CompositePropagator).
+%% '''
+%% @end
+%%%-----------------------------------------------------------------------
+-module(otel_propagator_b3).
+
+-behaviour(otel_propagator_text_map).
+
+-export([fields/1,
+         inject/4,
+         extract/5]).
+
+-include("opentelemetry.hrl").
+
+-define(B3_CONTEXT_KEY, <<"b3">>).
+
+%% Returns all the keys the propagator sets with `inject'
+%% @private
+fields(b3single) ->
+    otel_propagator_b3single:fields(b3single);
+fields(b3multi) ->
+    otel_propagator_b3multi:fields(b3multi);
+fields(_) ->
+    [].
+
+%% @private
+-spec inject(Context, Carrier, CarrierSetFun, Options) -> Carrier
+              when Context :: otel_ctx:t(),
+                   Carrier :: otel_propagator:carrier(),
+                   CarrierSetFun :: otel_propagator_text_map:carrier_set(),
+                   Options :: b3multi | b3single.
+inject(Ctx, Carrier, CarrierSet, Options=b3single) ->
+    otel_propagator_b3single:inject(Ctx, Carrier, CarrierSet, Options);
+inject(Ctx, Carrier, CarrierSet, Options=b3multi) ->
+    otel_propagator_b3multi:inject(Ctx, Carrier, CarrierSet, Options);
+inject(_Ctx, Carrier, _CarrierSet, _Options) ->
+    Carrier.
+
+% Extract trace context from the supplied carrier. The b3 single header takes
+% precedence over the multi-header format.
+%
+% If extraction fails, the original context will be returned.
+%% @private
+-spec extract(Context, Carrier, CarrierKeysFun, CarrierGetFun, Options) -> Context
+              when Context :: otel_ctx:t(),
+                   Carrier :: otel_propagator:carrier(),
+                   CarrierKeysFun :: otel_propagator_text_map:carrier_keys(),
+                   CarrierGetFun :: otel_propagator_text_map:carrier_get(),
+                   Options :: otel_propagator_text_map:propagator_options().
+extract(Ctx, Carrier, CarrierKeysFun, CarrierGet, Options) ->
+    case otel_propagator_b3single:extract(Ctx, Carrier, CarrierKeysFun, CarrierGet, Options) of
+        Result when Result =/= undefined -> Result;
+        _ ->
+            case otel_propagator_b3multi:extract(Ctx, Carrier, CarrierKeysFun, CarrierGet, Options) of
+                Result when Result =/= undefined -> Result;
+                _ -> Ctx
+            end
+    end.

apps/opentelemetry_api/src/otel_propagator_b3multi.erl

@@ -0,0 +1,138 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @doc An implementation of {@link otel_propagator_text_map} that injects and
+%% extracts trace context using the B3 multi header format specification from
+%% Zipkin.
+%%
+%% @see otel_propagator_b3
+%% @end
+%%%-----------------------------------------------------------------------
+-module(otel_propagator_b3multi).
+
+-behaviour(otel_propagator_text_map).
+
+-export([fields/1,
+         inject/4,
+         extract/5]).
+
+-include("opentelemetry.hrl").
+
+-define(B3_TRACE_ID, <<"X-B3-TraceId">>).
+-define(B3_SPAN_ID, <<"X-B3-SpanId">>).
+-define(B3_SAMPLED, <<"X-B3-Sampled">>).
+
+%% @private
+fields(_) ->
+    [?B3_TRACE_ID, ?B3_SPAN_ID, ?B3_SAMPLED].
+
+%% @private
+-spec inject(Context, Carrier, CarrierSetFun, Options) -> Carrier
+              when Context :: otel_ctx:t(),
+                   Carrier :: otel_propagator:carrier(),
+                   CarrierSetFun :: otel_propagator_text_map:carrier_set(),
+                   Options :: otel_propagator_text_map:propagator_options().
+inject(Ctx, Carrier, CarrierSet, _Options) ->
+    case otel_tracer:current_span_ctx(Ctx) of
+        #span_ctx{trace_id=TraceId,
+                  span_id=SpanId,
+                  trace_flags=TraceOptions} when TraceId =/= 0, SpanId =/= 0 ->
+            Options = case TraceOptions band 1 of 1 -> <<"1">>; _ -> <<"0">> end,
+            EncodedTraceId = io_lib:format("~32.16.0b", [TraceId]),
+            EncodedSpanId = io_lib:format("~16.16.0b", [SpanId]),
+            case {unicode:characters_to_binary(EncodedTraceId),
+                  unicode:characters_to_binary(EncodedSpanId)} of
+                {BinTraceId, BinSpanId} when is_binary(BinTraceId) , is_binary(BinSpanId) ->
+                    CarrierSet(?B3_TRACE_ID, BinTraceId,
+                               CarrierSet(?B3_SPAN_ID, BinSpanId,
+                                          CarrierSet(?B3_SAMPLED, Options, Carrier)));
+                _ ->
+                    Carrier
+            end;
+        _ ->
+            Carrier
+    end.
+
+% Extract trace context from the supplied carrier. The b3 single header takes
+% precedence over the multi-header format.
+%
+% If extraction fails, the original context will be returned.
+%% @private
+-spec extract(Context, Carrier, CarrierKeysFun, CarrierGetFun, Options) -> Context
+              when Context :: otel_ctx:t(),
+                   Carrier :: otel_propagator:carrier(),
+                   CarrierKeysFun :: otel_propagator_text_map:carrier_keys(),
+                   CarrierGetFun :: otel_propagator_text_map:carrier_get(),
+                   Options :: otel_propagator_text_map:propagator_options().
+extract(Ctx, Carrier, _CarrierKeysFun, CarrierGet, _Options) ->
+    try
+        TraceId = parse_trace_id(CarrierGet(?B3_TRACE_ID, Carrier)),
+        SpanId = parse_span_id(CarrierGet(?B3_SPAN_ID, Carrier)),
+        Sampled = parse_is_sampled(CarrierGet(?B3_SAMPLED, Carrier)),
+
+        SpanCtx = otel_tracer:from_remote_span(TraceId, SpanId, Sampled),
+        otel_tracer:set_current_span(Ctx, SpanCtx)
+    catch
+        throw:invalid ->
+            undefined;
+
+        %% thrown if _to_integer fails or an invalid string encoding is sent
+        error:badarg ->
+            undefined
+    end.
+
+% Trace ID is a 32 or 16 lower-hex character binary.
+parse_trace_id(TraceId) when is_binary(TraceId) ->
+     case string:length(TraceId) =:= 32 orelse string:length(TraceId) =:= 16 of
+         true -> string_to_integer(TraceId, 16);
+         _ -> throw(invalid)
+     end;
+parse_trace_id(_) ->
+    throw(invalid).
+
+% Span ID is a 16 lower-hex character binary.
+parse_span_id(SpanId) when is_binary(SpanId) ->
+     case string:length(SpanId) =:= 16 of
+         true -> string_to_integer(SpanId, 16);
+         _ -> throw(invalid)
+     end;
+parse_span_id(_) ->
+    throw(invalid).
+
+% Sampling State is encoded as a single hex character for all states except
+% Defer. Defer is absence of the sampling field.
+%
+% Possible states:
+%   1 - accept
+%   0 - deny
+%   d - debug (not supported at the moment, we instead used accept)
+%
+% Before the specification was written, some tracers propagated X-B3-Sampled as
+% true or false.
+parse_is_sampled(Sampled) when is_binary(Sampled) ->
+    case Sampled of
+        S when S =:= <<"1">> orelse S =:= <<"d">> orelse S =:= <<"true">> -> 1;
+        S when S =:= <<"0">> orelse S =:= <<"false">> -> 0;
+        _ -> throw(invalid)
+    end;
+parse_is_sampled(undefined) ->
+    % Sampled flag is optional. If it's missing then the sampling decision is
+    % deferred. We don't currently support it and just set the flag to 0
+    % instead (similarly how some other OTEL implementations are doing).
+    0;
+parse_is_sampled(_) ->
+    throw(invalid).
+
+string_to_integer(S, Base) when is_binary(S) ->
+    binary_to_integer(S, Base).

apps/opentelemetry_api/src/otel_propagator_b3single.erl

@@ -0,0 +1,144 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2019, 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.
+%%
+%% @doc An implementation of {@link otel_propagator_text_map} that injects and
+%% extracts trace context using the B3 single header format specification from
+%% Zipkin.
+%%
+%% @see otel_propagator_b3
+%% @end
+%%%-----------------------------------------------------------------------
+-module(otel_propagator_b3single).
+
+-behaviour(otel_propagator_text_map).
+
+-export([fields/1,
+         inject/4,
+         extract/5]).
+
+-include("opentelemetry.hrl").
+
+-define(B3_CONTEXT_KEY, <<"b3">>).
+
+%% @private
+fields(_) ->
+    [?B3_CONTEXT_KEY].
+
+%% @private
+-spec inject(Context, Carrier, CarrierSetFun, Options) -> Carrier
+              when Context :: otel_ctx:t(),
+                   Carrier :: otel_propagator:carrier(),
+                   CarrierSetFun :: otel_propagator_text_map:carrier_set(),
+                   Options :: otel_propagator_text_map:propagator_options().
+inject(Ctx, Carrier, CarrierSet, _Options) ->
+    case otel_tracer:current_span_ctx(Ctx) of
+        #span_ctx{trace_id=TraceId,
+                  span_id=SpanId,
+                  trace_flags=TraceOptions} when TraceId =/= 0, SpanId =/= 0 ->
+            Options = case TraceOptions band 1 of 1 -> <<"1">>; _ -> <<"0">> end,
+            EncodedTraceId = io_lib:format("~32.16.0b", [TraceId]),
+            EncodedSpanId = io_lib:format("~16.16.0b", [SpanId]),
+            B3Context = otel_utils:assert_to_binary([EncodedTraceId, "-",
+                                                     EncodedSpanId, "-", Options]),
+            CarrierSet(?B3_CONTEXT_KEY, B3Context, Carrier);
+        _ ->
+            Carrier
+    end.
+
+%% @private
+-spec extract(Context, Carrier, CarrierKeysFun, CarrierGetFun, Options) -> Context
+              when Context :: otel_ctx:t(),
+                   Carrier :: otel_propagator:carrier(),
+                   CarrierKeysFun :: otel_propagator_text_map:carrier_keys(),
+                   CarrierGetFun :: otel_propagator_text_map:carrier_get(),
+                   Options :: otel_propagator_text_map:propagator_options().
+extract(Ctx, Carrier, _CarrierKeysFun, CarrierGet, _Options) ->
+    try
+        [TraceId, SpanId, Sampled] = parse_b3_context(Carrier, CarrierGet),
+        SpanCtx = otel_tracer:from_remote_span(TraceId, SpanId, Sampled),
+        otel_tracer:set_current_span(Ctx, SpanCtx)
+    catch
+        throw:invalid ->
+            undefined;
+
+        %% thrown if _to_integer fails or an invalid string encoding is sent
+        error:badarg ->
+            undefined
+    end.
+
+% B3 maps propagation fields into a hyphen delimited string:
+%   {TraceId}-{SpanId}-{SamplingState}-{ParentSpanId}, where the last two fields are optional.
+%
+% When only propagating a sampling decision, the header is still named b3, but
+% only contains the sampling state:
+%   {SamplingState}
+parse_b3_context(Carrier, CarrierGet) ->
+    case CarrierGet(?B3_CONTEXT_KEY, Carrier) of
+        B3Context when is_binary(B3Context) ->
+            decode_b3_context(string:split(B3Context, "-", all));
+        _ ->
+            throw(invalid)
+    end.
+
+decode_b3_context([TraceId, SpanId]) ->
+    % Sampled flag is optional. If it's missing then the sampling decision is
+    % deferred. We don't currently support it and just set the flag to 0
+    % instead (similarly how some other OTEL implementations are doing).
+    [parse_trace_id(TraceId), parse_span_id(SpanId), 0];
+decode_b3_context([TraceId, SpanId, Sampled]) ->
+    [parse_trace_id(TraceId), parse_span_id(SpanId), parse_is_sampled(Sampled)];
+decode_b3_context([TraceId, SpanId, Sampled, _ParentSpanId]) ->
+    [parse_trace_id(TraceId), parse_span_id(SpanId), parse_is_sampled(Sampled)];
+decode_b3_context(_) ->
+    throw(invalid).
+
+% Trace ID is a 32 or 16 lower-hex character binary.
+parse_trace_id(TraceId) when is_binary(TraceId) ->
+     case string:length(TraceId) =:= 32 orelse string:length(TraceId) =:= 16 of
+         true -> string_to_integer(TraceId, 16);
+         _ -> throw(invalid)
+     end;
+parse_trace_id(_) ->
+    throw(invalid).
+
+% Span ID is a 16 lower-hex character binary.
+parse_span_id(SpanId) when is_binary(SpanId) ->
+     case string:length(SpanId) =:= 16 of
+         true -> string_to_integer(SpanId, 16);
+         _ -> throw(invalid)
+     end;
+parse_span_id(_) ->
+    throw(invalid).
+
+% Sampling State is encoded as a single hex character for all states except
+% Defer. Defer is absence of the sampling field.
+%
+% Possible states:
+%   1 - accept
+%   0 - deny
+%   d - debug (not supported at the moment, we instead used accept)
+%
+% Before the specification was written, some tracers propagated X-B3-Sampled as
+% true or false.
+parse_is_sampled(Sampled) when is_binary(Sampled) ->
+    case Sampled of
+        S when S =:= <<"1">> orelse S =:= <<"d">> orelse S =:= <<"true">> -> 1;
+        S when S =:= <<"0">> orelse S =:= <<"false">> -> 0;
+        _ -> throw(invalid)
+    end;
+parse_is_sampled(_) ->
+    throw(invalid).
+
+string_to_integer(S, Base) when is_binary(S) ->
+    binary_to_integer(S, Base).

apps/opentelemetry_api/src/otel_propagator_baggage.erl

@@ -0,0 +1,241 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2021, 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.
+%%
+%% @doc An implementation of {@link otel_propagator_text_map} that injects and
+%% extracts baggage using the
+%% <a href="https://w3c.github.io/baggage/">W3C Baggage format</a>.
+%%
+%% This propagator along with {@link otel_propagator_trace_context} are used
+%% by default. The global TextMap Propagators can be configured in the
+%% application environment:
+%%
+%% ```
+%% {text_map_propagators, [trace_context, baggage]},
+%% '''
+%%
+%% Or by calling {@link opentelemetry:set_text_map_propagator/1}.
+%% @end
+%%%-----------------------------------------------------------------------
+-module(otel_propagator_baggage).
+
+-behaviour(otel_propagator_text_map).
+
+-export([fields/1,
+         inject/4,
+         extract/5]).
+
+-include("opentelemetry.hrl").
+
+-define(DEC2HEX(X),
+        if ((X) >= 0) andalso ((X) =< 9) -> (X) + $0;
+           ((X) >= 10) andalso ((X) =< 15) -> (X) + $A - 10
+        end).
+
+-define(HEX2DEC(X),
+        if ((X) >= $0) andalso ((X) =< $9) -> (X) - $0;
+           ((X) >= $A) andalso ((X) =< $F) -> (X) - $A + 10;
+           ((X) >= $a) andalso ((X) =< $f) -> (X) - $a + 10
+        end).
+
+-define(BAGGAGE_HEADER, <<"baggage">>).
+
+%% @private
+fields(_) ->
+    [?BAGGAGE_HEADER].
+
+%% @private
+-spec inject(Context, Carrier, CarrierSetFun, Options) -> Carrier
+              when Context :: otel_ctx:t(),
+                   Carrier :: otel_propagator:carrier(),
+                   CarrierSetFun :: otel_propagator_text_map:carrier_set(),
+                   Options :: otel_propagator_text_map:propagator_options().
+inject(Ctx, Carrier, CarrierSet, _Options) ->
+    Baggage = otel_baggage:get_all(Ctx),
+    case maps:fold(fun(Key, Value, Acc) ->
+                           [$,, [encode_key(Key), "=", encode_value(Value)] | Acc]
+                   end, [], Baggage) of
+        [$, | List] ->
+            CarrierSet(?BAGGAGE_HEADER, otel_utils:assert_to_binary(List), Carrier);
+        _ ->
+            Carrier
+    end.
+
+%% @private
+-spec extract(Context, Carrier, CarrierKeysFun, CarrierGetFun, Options) -> Context
+              when Context :: otel_ctx:t(),
+                   Carrier :: otel_propagator:carrier(),
+                   CarrierKeysFun :: otel_propagator_text_map:carrier_keys(),
+                   CarrierGetFun :: otel_propagator_text_map:carrier_get(),
+                   Options :: otel_propagator_text_map:propagator_options().
+extract(Ctx, Carrier, _CarrierKeysFun, CarrierGet, _Options) ->
+    case CarrierGet(?BAGGAGE_HEADER, Carrier) of
+        undefined ->
+            Ctx;
+        String ->
+            Pairs = string:lexemes(String, [$,]),
+            DecodedBaggage =
+                lists:foldl(fun(Pair, Acc) ->
+                                    [Key, Value] = string:split(Pair, "="),
+                                    Acc#{decode_key(Key) => decode_value(Value)}
+
+                            end, #{}, Pairs),
+            otel_baggage:set_to(Ctx, DecodedBaggage)
+    end.
+
+%%
+
+encode_key(Key) ->
+    form_urlencode(Key, [{encoding, utf8}]).
+
+encode_value({Value, Metadata}) ->
+    EncodedMetadata = encode_metadata(Metadata),
+    EncodedValue = form_urlencode(Value, [{encoding, utf8}]),
+    otel_utils:assert_to_binary(lists:join(<<";">>, [EncodedValue | EncodedMetadata])).
+
+encode_metadata(Metadata) when is_list(Metadata) ->
+    lists:filtermap(fun({MK, MV}) when is_binary(MK) , is_binary(MV)  ->
+                            {true, [MK, <<"=">>, MV]};
+                       (M) when is_binary(M) ->
+                            {true, M};
+                       (_) ->
+                            false
+                    end, Metadata);
+encode_metadata(_) ->
+    [].
+
+decode_key(Key) ->
+    percent_decode(string:trim(otel_utils:assert_to_binary(Key))).
+
+decode_value(ValueAndMetadata) ->
+    [Value | MetadataList] = string:lexemes(ValueAndMetadata, [$;]),
+    {string_decode(Value), lists:filtermap(fun metadata_decode/1, MetadataList)}.
+
+metadata_decode(Metadata) ->
+    case string:split(Metadata, "=") of
+        [MetadataKey] ->
+            {true, string_decode(MetadataKey)};
+        [MetadataKey, MetadataValue] ->
+            {true, {string_decode(MetadataKey), string_decode(MetadataValue)}};
+        _ ->
+            false
+    end.
+
+string_decode(S) ->
+    percent_decode(string:trim(otel_utils:assert_to_binary(S))).
+
+%% TODO: call `uri_string:percent_decode' and remove this when OTP-23 is
+%% the oldest version we maintain support for
+-spec percent_decode(URI) -> Result when
+      URI :: unicode:chardata(),
+      Result :: unicode:chardata() | uri_string:error().
+percent_decode(URI) when is_list(URI) orelse
+                         is_binary(URI) ->
+    raw_decode(URI).
+
+%% TODO: call `uri_string:percent_encode' when it is added to OTP and
+%% available in the oldest version we support
+form_urlencode(Cs, [{encoding, Encoding}])
+  when is_list(Cs), Encoding =:= utf8; Encoding =:= unicode ->
+    B = convert_to_binary(Cs, utf8, Encoding),
+    html5_byte_encode(B);
+form_urlencode(Cs, [{encoding, Encoding}])
+  when is_binary(Cs), Encoding =:= utf8; Encoding =:= unicode ->
+    html5_byte_encode(Cs);
+form_urlencode(Cs, [{encoding, Encoding}]) when is_list(Cs); is_binary(Cs) ->
+    throw({error,invalid_encoding, Encoding});
+form_urlencode(Cs, _) ->
+    throw({error,invalid_input, Cs}).
+
+html5_byte_encode(B) ->
+    html5_byte_encode(B, <<>>).
+%%
+html5_byte_encode(<<>>, Acc) ->
+    Acc;
+html5_byte_encode(<<$ ,T/binary>>, Acc) ->
+    html5_byte_encode(T, <<Acc/binary,$+>>);
+html5_byte_encode(<<H,T/binary>>, Acc) ->
+    case is_url_char(H) of
+        true ->
+            html5_byte_encode(T, <<Acc/binary,H>>);
+        false ->
+            <<A:4,B:4>> = <<H>>,
+            html5_byte_encode(T, <<Acc/binary,$%,(?DEC2HEX(A)),(?DEC2HEX(B))>>)
+    end;
+html5_byte_encode(H, _Acc) ->
+    throw({error,invalid_input, H}).
+
+
+%% Return true if input char can appear in form-urlencoded string
+%% Allowed chararacters:
+%%   0x2A, 0x2D, 0x2E, 0x30 to 0x39, 0x41 to 0x5A,
+%%   0x5F, 0x61 to 0x7A
+is_url_char(C)
+  when C =:= 16#2A; C =:= 16#2D;
+       C =:= 16#2E; C =:= 16#5F;
+       16#30 =< C, C =< 16#39;
+       16#41 =< C, C =< 16#5A;
+       16#61 =< C, C =< 16#7A -> true;
+is_url_char(_) -> false.
+
+%% Convert to binary
+convert_to_binary(Binary, InEncoding, OutEncoding) ->
+    case unicode:characters_to_binary(Binary, InEncoding, OutEncoding) of
+        {error, _List, RestData} ->
+            throw({error, invalid_input, RestData});
+        {incomplete, _List, RestData} ->
+            throw({error, invalid_input, RestData});
+        Result ->
+            Result
+    end.
+
+-spec raw_decode(list()|binary()) -> list() | binary() | uri_string:error().
+raw_decode(Cs) ->
+    raw_decode(Cs, <<>>).
+%%
+raw_decode(L, Acc) when is_list(L) ->
+    try
+        B0 = otel_utils:assert_to_binary(L),
+        B1 = raw_decode(B0, Acc),
+        unicode:characters_to_list(B1)
+    catch
+        throw:{error, Atom, RestData} ->
+            {error, Atom, RestData}
+    end;
+raw_decode(<<$%,C0,C1,Cs/binary>>, Acc) ->
+    case is_hex_digit(C0) andalso is_hex_digit(C1) of
+        true ->
+            B = ?HEX2DEC(C0)*16+?HEX2DEC(C1),
+            raw_decode(Cs, <<Acc/binary, B>>);
+        false ->
+            throw({error,invalid_percent_encoding,<<$%,C0,C1>>})
+    end;
+raw_decode(<<C,Cs/binary>>, Acc) ->
+    raw_decode(Cs, <<Acc/binary, C>>);
+raw_decode(<<>>, Acc) ->
+    check_utf8(Acc).
+
+%% Returns Cs if it is utf8 encoded.
+check_utf8(Cs) ->
+    case unicode:characters_to_list(Cs) of
+        {incomplete,_,_} ->
+            throw({error,invalid_utf8,Cs});
+        {error,_,_} ->
+            throw({error,invalid_utf8,Cs});
+        _ -> Cs
+    end.
+
+-spec is_hex_digit(non_neg_integer()) -> boolean().
+is_hex_digit(C)
+  when $0 =< C, C =< $9;$a =< C, C =< $f;$A =< C, C =< $F -> true;
+is_hex_digit(_) -> false.

apps/opentelemetry_api/src/otel_propagator_text_map.erl

@@ -0,0 +1,244 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2020, 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.
+%%
+%% @doc A TextMap Propagator is a Propagator that performs injection and
+%% extraction with ASCII keys and values.
+%%
+%% An example of
+%% configuring the TextMap Propagator to inject and extract Baggage and
+%% TraceContext:
+%%
+%% ```
+%% {text_map_propagators, [trace_context, baggage]},
+%% '''
+%%
+%% The propagators are then used at the points that cross-service
+%% communication is performed. By default, {@link inject/2} and {@link extract/2} work on a
+%% generic list of 2-tuple's with binary string keys and values. You can pass (as an argument)
+%% a user-defined function for setting a key/value in the carrier and for getting
+%% the value of a key. For example, injecting and extracting to and from
+%% <a href="https://github.com/benoitc/hackney">Hackney</a> headers could be
+%% done with Hackney-specific functions:
+%%
+%% ```
+%% set_header(Key, Value, Headers) ->
+%%   hackney_headers:store(Key, Value, Headers).
+%%
+%% some_fun_calling_hackney() ->
+%%   Headers = otel_propagator_text_map:inject(opentelemetry:get_text_map_injector(), hackney_headers:new(), fun set_header/2),
+%%   %% ...
+%% '''
+%%
+%% An example of extraction in an <a href="https://github.com/elli-lib/elli">Elli</a> request
+%% handler:
+%%
+%% ```
+%% get_header(Req, Key) ->
+%%   elli_request:get_header(Key, Req, Default).
+%%
+%% handle(Req, _Args) ->
+%%   otel_propagator_text_map:extract(Req, fun get_header/2),
+%%   %% ...
+%%   {ok, [], <<"hello world">>}.
+%% '''
+%% @end
+%%%-------------------------------------------------------------------------
+-module(otel_propagator_text_map).
+
+-behaviour(otel_propagator).
+
+-export([fields/1,
+         inject/1,
+         inject/2,
+         inject/3,
+         inject_from/2,
+         inject_from/3,
+         inject_from/4,
+         extract/1,
+         extract/2,
+         extract/4,
+         extract_to/2,
+         extract_to/3,
+         extract_to/5]).
+
+-export([default_carrier_get/2,
+         default_carrier_set/3,
+         default_carrier_keys/1]).
+
+-include_lib("kernel/include/logger.hrl").
+
+%% Sets a value into a carrier
+-callback inject(otel_ctx:t(), otel_propagator:carrier(), carrier_set(), propagator_options()) -> otel_propagator:carrier().
+
+%% Extracts values from a carrier and sets them in the context
+-callback extract(otel_ctx:t(), otel_propagator:carrier(), carrier_keys(), carrier_get(), propagator_options()) -> term().
+
+%% Returns all the keys the propagator sets with `inject'
+-callback fields(propagator_options()) -> [field_key()].
+
+%% a textmap propagator can have any term associated with it
+-type propagator_options() :: term().
+
+-type field_key() :: unicode:latin1_binary().
+-type field_value() :: unicode:latin1_binary().
+
+%% return all matching keys from the carrier
+%% for example: with the jaeger propagation format this would be
+%% all keys found with prefix "uberctx-"
+-type carrier_keys() :: fun((otel_propagator:carrier()) -> [unicode:latin1_binary()]).
+-type carrier_get() :: fun((unicode:latin1_binary(), otel_propagator:carrier()) -> unicode:latin1_binary() | undefined).
+-type carrier_set() :: fun((unicode:latin1_binary(), unicode:latin1_binary(), otel_propagator:carrier()) -> otel_propagator:carrier()).
+
+-type default_text_map_carrier() :: [{unicode:latin1_binary(), unicode:latin1_binary()}].
+
+%% 2-tuple form is a textmap propagator with options
+%% an empty list is passed for options if the propagator is a module with no options
+-type t() :: module() | {module(), propagator_options()}.
+
+-export_type([t/0,
+              carrier_set/0,
+              carrier_get/0,
+              carrier_keys/0,
+              propagator_options/0]).
+
+%% @private
+-spec fields(otel_propagator:t()) -> [field_key()].
+fields(Propagator) when is_atom(Propagator) ->
+    Propagator:fields([]);
+fields({Module, Options}) ->
+    Module:fields(Options).
+
+%% @doc Injects `Carrier' into the current context using the current TextMap Propagator.
+%%
+%% @see inject/2
+-spec inject(otel_propagator:carrier()) -> otel_propagator:carrier().
+inject(Carrier) ->
+    Propagator = opentelemetry:get_text_map_injector(),
+    inject(Propagator, Carrier, fun default_carrier_set/3).
+
+%% @doc Injects `Carrier' into the current context using the provided `Propagator'.
+%%
+%% By default, the `Carrier' is set using the a default carrier set function.
+%% @see inject/3
+-spec inject(otel_propagator:t(), otel_propagator:carrier()) -> otel_propagator:carrier().
+inject(Propagator, Carrier) ->
+    inject(Propagator, Carrier, fun default_carrier_set/3).
+
+%% @doc Injects `Carrier' (through `CarrierSetFun') into the current
+%% context using the provided `Propagator'.
+-spec inject(otel_propagator:t(), otel_propagator:carrier(), fun()) -> otel_propagator:carrier().
+inject(Propagator, Carrier, CarrierSetFun) ->
+    Context = otel_ctx:get_current(),
+    inject_from(Context, Propagator, Carrier, CarrierSetFun).
+
+%% @equiv inject_from(Context, opentelemetry:get_text_map_injector(), Carrier)
+-spec inject_from(otel_ctx:t(), otel_propagator:carrier()) -> otel_propagator:carrier().
+inject_from(Context, Carrier) ->
+    Propagator = opentelemetry:get_text_map_injector(),
+    inject_from(Context, Propagator, Carrier, fun default_carrier_set/3).
+
+%% @equiv inject_from(Context, Propagator, Carrier, fun default_carrier_set/3)
+-spec inject_from(otel_ctx:t(), otel_propagator:t(), otel_propagator:carrier()) -> otel_propagator:carrier().
+inject_from(Context, Propagator, Carrier) ->
+    inject_from(Context, Propagator, Carrier, fun default_carrier_set/3).
+
+%% @doc Injects `Carrier' (through `CarrierSetFun') into the given
+%% `Context' using the provided propagator `Propagator'.
+-spec inject_from(otel_ctx:t(), otel_propagator:t(), otel_propagator:carrier(), fun()) -> otel_propagator:carrier().
+inject_from(Context, Propagator, Carrier, CarrierSetFun) when is_atom(Propagator) ->
+     Propagator:inject(Context, Carrier, CarrierSetFun, []);
+inject_from(Context, {Propagator, Options}, Carrier, CarrierSetFun) ->
+     Propagator:inject(Context, Carrier, CarrierSetFun, Options).
+
+%% @doc Extracts the current context from the provided `Carrier' using the current
+%% TextMap Propagator.
+-spec extract(otel_propagator:carrier()) -> otel_ctx:token().
+extract(Carrier) ->
+    Propagator = opentelemetry:get_text_map_extractor(),
+    extract(Propagator, Carrier, fun default_carrier_keys/1, fun default_carrier_get/2).
+
+%% @doc Extracts the current context from the provided `Carrier' using the
+%% given `Propagator'.
+-spec extract(otel_propagator:t(), otel_propagator:carrier()) -> otel_ctx:token().
+extract(Propagator, Carrier) ->
+    extract(Propagator, Carrier, fun default_carrier_keys/1, fun default_carrier_get/2).
+
+%% @doc Extracts the current context from the provided `Carrier' using the
+%% given `Propagator' and functions to get all the keys and get the keys from the carrier.
+-spec extract(otel_propagator:t(), otel_propagator:carrier(), fun(), fun()) -> otel_ctx:token().
+extract(Propagator, Carrier, CarrierKeysFun, CarrierGetFun) ->
+    Context = otel_ctx:get_current(),
+    Context1 = extract_to(Context, Propagator, Carrier, CarrierKeysFun, CarrierGetFun),
+    otel_ctx:attach(Context1).
+
+%% @equiv extract_to(Context, opentelemetry:get_text_map_extractor(), Carrier)
+-spec extract_to(otel_ctx:t(), otel_propagator:carrier()) -> otel_ctx:t().
+extract_to(Context, Carrier) ->
+    Propagator = opentelemetry:get_text_map_extractor(),
+    extract_to(Context, Propagator, Carrier, fun default_carrier_keys/1, fun default_carrier_get/2).
+
+%% @equiv extract_to(Context, Propagator, Carrier, fun default_carrier_keys/1, fun default_carrier_get/2)
+-spec extract_to(otel_ctx:t(), otel_propagator:t(), otel_propagator:carrier()) -> otel_ctx:t().
+extract_to(Context, Propagator, Carrier) ->
+    extract_to(Context, Propagator, Carrier, fun default_carrier_keys/1, fun default_carrier_get/2).
+
+%% @doc Extracts the current context from the provided `Carrier' using the
+%% given `Propagator' and functions to get all the keys and get the keys from the carrier.
+-spec extract_to(otel_ctx:t(), otel_propagator:t(), otel_propagator:carrier(), fun(), fun()) -> otel_ctx:t().
+extract_to(Context, Propagator, Carrier, CarrierKeysFun, CarrierGetFun) when is_atom(Propagator) ->
+    Propagator:extract(Context, Carrier, CarrierKeysFun, CarrierGetFun, []);
+extract_to(Context, {Propagator, Options}, Carrier, CarrierKeysFun, CarrierGetFun) ->
+    Propagator:extract(Context, Carrier, CarrierKeysFun, CarrierGetFun, Options).
+
+%% case-insensitive finding of a key string in a list of ASCII strings
+%% if there are multiple entries in the list for the same key the values
+%% will be combined and separated by commas. This is the method defined
+%% in RFC7230 for HTTP headers.
+%% @private
+-spec default_carrier_get(field_key(), default_text_map_carrier()) -> field_value() | undefined.
+default_carrier_get(Key, List) ->
+    default_carrier_get(Key, List, []).
+
+default_carrier_get(_, [], []) ->
+    undefined;
+default_carrier_get(_, [], Result) ->
+    unicode:characters_to_binary(lists:join($,, lists:reverse(Result)), latin1);
+default_carrier_get(Key, [{H, V} | Rest], Result) ->
+    case string:equal(Key, H, true, none) of
+        true ->
+            default_carrier_get(Key, Rest, [V | Result]);
+        false ->
+            default_carrier_get(Key, Rest, Result)
+    end.
+
+%% case-insensitive ASCII string based lists:keyreplace
+%% @private
+-spec default_carrier_set(field_key(), field_value(), default_text_map_carrier())
+                         -> default_text_map_carrier().
+default_carrier_set(Key, Value, []) ->
+    [{Key, Value}];
+default_carrier_set(Key, Value, [{H, _}=Elem | Rest]) ->
+    case string:equal(Key, H, true, none) of
+        true ->
+            [{Key, Value} | Rest];
+        false ->
+            [Elem | default_carrier_set(Key, Value, Rest)]
+    end.
+
+%% @private
+-spec default_carrier_keys(default_text_map_carrier()) -> [field_key()].
+default_carrier_keys([]) ->
+    [];
+default_carrier_keys([{K, _} | Rest]) ->
+    [K | default_carrier_keys(Rest)].

apps/opentelemetry_api/src/otel_propagator_text_map_composite.erl

@@ -0,0 +1,105 @@
+%%%------------------------------------------------------------------------
+%% Copyright 2020, 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.
+%%
+%% @doc A Composite TextMap Propagator is a Propagator that performs run
+%% multiple TextMap Propagators in a specified order.
+%%
+%% An example of creating a Composite TextMap Propagator to inject and
+%% extract Baggage and TraceContext:
+%%
+%% ```
+%% Propagator = otel_propagator_text_map_composite:create([trace_context, baggage]),
+%% otel_propagator_text_map:extract(Propagator, Carrier)
+%% '''
+%% @end
+%%%-------------------------------------------------------------------------
+-module(otel_propagator_text_map_composite).
+
+-behaviour(otel_propagator_text_map).
+
+-export([create/1,
+         fields/1,
+         inject/4,
+         extract/5,
+         report_cb/1]).
+
+-include_lib("kernel/include/logger.hrl").
+
+
+%% @doc Create a new Composite TextMap Propagator.
+%%
+%% The `Propagators' list is a list of atoms that represent the <i>suffix</i>
+%% of the module name of the TextMap Propagator to be used.
+-spec create([otel_propagator:builtin()]) -> otel_propagator:t().
+create(Propagators) ->
+    {?MODULE, otel_propagator:builtins_to_modules(Propagators)}.
+
+%% @private
+fields(Propagators) ->
+    lists:flatmap(fun(Propagator) ->
+                          otel_propagator_text_map:fields(Propagator)
+                  end, Propagators).
+
+%% @private
+-spec inject(Context, Carrier, CarrierSetFun, Injectors) -> Carrier
+              when Context :: otel_ctx:t(),
+                   Carrier :: otel_propagator:carrier(),
+                   CarrierSetFun :: otel_propagator_text_map:carrier_set(),
+                   Injectors :: [otel_propagator_text_map:t()].
+inject(Context, Carrier, CarrierSetFun, Injectors) ->
+    run_injectors(Context, Injectors, Carrier, CarrierSetFun).
+
+%% @private
+-spec extract(Context, Carrier, CarrierKeysFun, CarrierGetFun, Extractors) -> Context
+              when Context :: otel_ctx:t(),
+                   Carrier :: otel_propagator:carrier(),
+                   CarrierKeysFun :: otel_propagator_text_map:carrier_keys(),
+                   CarrierGetFun :: otel_propagator_text_map:carrier_get(),
+                   Extractors :: [otel_propagator_text_map:t()].
+extract(Context, Carrier, CarrierKeysFun, CarrierGetFun, Extractors) ->
+    run_extractors(Context, Extractors, Carrier, CarrierKeysFun, CarrierGetFun).
+
+run_extractors(Context, Extractors, Carrier, CarrierKeysFun, CarrierGetFun) when is_list(Extractors) ->
+    lists:foldl(fun(Propagator, ContextAcc) ->
+                        try otel_propagator_text_map:extract_to(ContextAcc, Propagator, Carrier, CarrierKeysFun, CarrierGetFun)
+                        catch
+                            C:E:S ->
+                                ?LOG_INFO(#{extractor => Propagator, carrier => Carrier,
+                                            class => C, exception => E, stacktrace => S},
+                                          #{report_cb => fun ?MODULE:report_cb/1}),
+                                ContextAcc
+                        end
+                end, Context, otel_propagator:builtins_to_modules(Extractors)).
+
+run_injectors(Context, Injectors, Carrier, Setter) when is_list(Injectors) ->
+    lists:foldl(fun(Propagator, CarrierAcc) ->
+                        try otel_propagator_text_map:inject_from(Context, Propagator, CarrierAcc, Setter)
+                        catch
+                            C:E:S ->
+                                ?LOG_INFO(#{injector => Propagator, carrier => CarrierAcc,
+                                            class => C, exception => E, stacktrace => S},
+                                          #{report_cb => fun ?MODULE:report_cb/1}),
+                                CarrierAcc
+                        end
+                end, Carrier, otel_propagator:builtins_to_modules(Injectors)).
+
+%% @private
+report_cb(#{extractor := Propagator, carrier := _Carrier,
+            class := Class, exception := Exception, stacktrace := StackTrace}) ->
+    {"text map propagator failed to extract from carrier: propagator=~ts exception=~ts",
+     [Propagator, otel_utils:format_exception(Class, Exception, StackTrace)]};
+report_cb(#{injector := Propagator, carrier := _Carrier,
+            class := Class, exception := Exception, stacktrace := StackTrace}) ->
+    {"text map propagator failed to inject to carrier: propagator=~ts exception=~ts",
+     [Propagator, otel_utils:format_exception(Class, Exception, StackTrace)]}.