diff --git a/.cspell.yml b/.cspell.yml index 093e65ff96e3..57d3c4fbc4f2 100644 --- a/.cspell.yml +++ b/.cspell.yml @@ -5,6 +5,7 @@ version: '0.2' language: en-US import: - '@cspell/dict-es-es/cspell-ext.json' + - '@cspell/dict-fr-fr/cspell-ext.json' - '@cspell/dict-pt-br/cspell-ext.json' caseSensitive: true ignorePaths: @@ -31,6 +32,8 @@ dictionaryDefinitions: path: .cspell/en-words.txt - name: es-palabras path: .cspell/es-palabras.txt + - name: fr-mots + path: .cspell/fr-mots.txt - name: pt-palavras path: .cspell/pt-palavras.txt dictionaries: @@ -40,6 +43,7 @@ dictionaries: # Local word lists - en-words - es-palabras + - fr-mots - pt-palavras # Programming languages and software terms - cpp @@ -49,3 +53,5 @@ dictionaries: - softwareTerms # Other - companies +words: # Valid words across all locales + - htmltest diff --git a/.cspell/en-words.txt b/.cspell/en-words.txt index 7f3a83d42974..d22571563ed6 100644 --- a/.cspell/en-words.txt +++ b/.cspell/en-words.txt @@ -34,6 +34,7 @@ discoverability dotnet Dyla dynatrace +ebpf emailservice EMEA erlang diff --git a/.cspell/es-palabras.txt b/.cspell/es-palabras.txt index 73807ec34e1b..a6f26c4b633b 100644 --- a/.cspell/es-palabras.txt +++ b/.cspell/es-palabras.txt @@ -7,3 +7,10 @@ microservicios extensibilidad correlacionarse deserializa +proprietarias +aspiracional +deserializar +Muestreadores +muestreadores +monitoreo +multilenguaje diff --git a/.cspell/fr-mots.txt b/.cspell/fr-mots.txt new file mode 100644 index 000000000000..7970e82b0e43 --- /dev/null +++ b/.cspell/fr-mots.txt @@ -0,0 +1,213 @@ +analyse +analyser +avec +collecter +collectez +comportement +contenant +créez +dans +découvrez +définie +démo +dessous +données +d'utiliser +efficace +entièrement +être +générer +gratuit +indépendant +instrumenter +intégrations +langages +librairies +logiciels +métriques +nombreux +nombreuses +observabilité +outils +permet +permettant +projet +projets +peut +qualité +savoir +s'intègre +supporte +supporté +tant +télémétrie +transmettez +universelle +utilisé +visuel +votre +vous +l'état +système +incluent +rendre +signifie +émettre +metriques +produites +doivent +transmises +Pourquoi +l'essor +commerciales +besoin +répond +suivant +principes +clés +propriétaire +générez +dépendance +fournisseur +n'avez +d'apprendre +seul +combinés +offrent +équipes +organisations +flexibilité +dont +informatique +Extensibilité +conçu +extensible +Quelques +façon +étendu +Ajouter +receveur +Collecteur +afin +prendre +venant +personnalisée +bibliothèques +personnalisées +Créer +collecteur +adaptée +utilisation +spécifique +nouvel +exportateur +personnalisé +prend +propagateur +contexte +plupart +utilisateurs +n'aient +d'étendre +presque +tous +niveaux +Histoire +trouve +antérieurs +créés +résoudre +même +problème +norme +décrivant +manière +transmettre +Aucun +n'étant +indépendante +fusionné +leurs +offrant +utilisez +actuellement +pouvez +découvrir +migrer +ensuite +commencer +Lancez +directement +composants +standardisé +définissant +sémantiques +décrire +langage +implémentent +spécifications +écosystème +instrumentent +automatique +génèrent +requérir +reçoit +modifie +autre +Opérateur +ressources +Faas +variété +intègrent +fournir +défaut +pris +fournisseurs +fournissent +contribuent +n’aient +d’étendre +conçus +créer +gérer +telles +outil +compris +ainsi +commerciaux +d'autres +génération +collecte +gestion +objectifs +principaux +pouvoir +aisément +systèmes +quelque +soit +leur +environnement +d'exécution +stockage +visualisation +sont +intentionnellement +laissés +d'autres +comprendre +sortantes +logiciel +d’aujourd’hui +souhaitez +jetez +oeil +valeurs +principaux +suivants +spécification +communautaires +brève +êtes +standardisée +autres diff --git a/.github/component-label-map.yml b/.github/component-label-map.yml index 5d46cf7e0ced..9caa5a08906b 100644 --- a/.github/component-label-map.yml +++ b/.github/component-label-map.yml @@ -22,6 +22,10 @@ lang:es: - changed-files: - any-glob-to-any-file: - content/es/** +lang:fr: + - changed-files: + - any-glob-to-any-file: + - content/fr/** sig:cpp: - changed-files: - any-glob-to-any-file: diff --git a/.github/component-owners.yml b/.github/component-owners.yml index 65d9e881b1b0..2cba8f7d7a1b 100644 --- a/.github/component-owners.yml +++ b/.github/component-owners.yml @@ -80,3 +80,6 @@ components: content/es: - open-telemetry/docs-maintainers - open-telemetry/docs-es-approvers + content/fr: + - open-telemetry/docs-maintainers + - open-telemetry/docs-fr-approvers diff --git a/.gitmodules b/.gitmodules index b3e0735ae018..b444d2d24a00 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,7 +1,7 @@ [submodule "themes/docsy"] path = themes/docsy url = https://github.com/google/docsy.git - docsy-pin = v0.10.0-26-g79511949 + docsy-pin = v0.11.0-2-g68aa7b3 docsy-note = "2024-04-01 Switching to google/docsy.git from cncf/docsy.git since we don't have any CNCF customizations." docsy-reminder = "Ensure that any tag referenced by `docsy-pin` is present in the remote repo (url), otherwise add (push) the tags to the repo." [submodule "content-modules/opentelemetry-specification"] @@ -23,7 +23,7 @@ [submodule "content-modules/opamp-spec"] path = content-modules/opamp-spec url = https://github.com/open-telemetry/opamp-spec - opamp-pin = v0.9.0-2-g950df29 + opamp-pin = v0.10.0 [submodule "content-modules/opentelemetry-go"] path = content-modules/opentelemetry-go url = https://github.com/open-telemetry/opentelemetry-go @@ -31,4 +31,4 @@ [submodule "content-modules/opentelemetry-java-examples"] path = content-modules/opentelemetry-java-examples url = https://github.com/open-telemetry/opentelemetry-java-examples.git - javaexamples-pin = 8fe9a11 + javaexamples-pin = 0f736ec diff --git a/.htmltest.yml b/.htmltest.yml index 9ad637f30f5d..2278e2d4e6ac 100644 --- a/.htmltest.yml +++ b/.htmltest.yml @@ -7,9 +7,15 @@ IgnoreInternalEmptyHash: true # TODO: remove after resolution of https://github. CheckMailto: false TestFilesConcurrently: true IgnoreDirs: + # DO NOT EDIT! IgnoreDirs list is auto-generated from markdown file front matter. + # 2024-11-03 The following entry is for `en` pages only. Other locales do + # not currently require it. - ^blog/(\d+/)?page/\d+ - # TODO drop after https://github.com/open-telemetry/opentelemetry.io/issues/5267 is fixed: - - zh/docs/contributing/pr-checks + # TODO drop next line after https://github.com/open-telemetry/opentelemetry.io/issues/5423 is fixed for ja pages: + - ^ja/docs/concepts/instrumentation/libraries/ + # TODO drop next line after https://github.com/open-telemetry/opentelemetry.io/issues/5423 is fixed for pt pages: + - ^pt/docs/concepts/instrumentation/libraries/ + # DO NOT EDIT! IgnoreDirs list is auto-generated from markdown file front matter. IgnoreInternalURLs: # list of paths IgnoreURLs: # list of regexs of paths or URLs to be ignored - ^/api$ diff --git a/README.md b/README.md index 9a2c86de3d00..3f4e8247d349 100644 --- a/README.md +++ b/README.md @@ -4,6 +4,8 @@ This is the source repository for the [OpenTelemetry][] website, project documentation, and blog. The site is [built][contributing.md] using [Hugo][] and is hosted on [Netlify][]. +Public analytics for the website is [available here][]. + ## Get involved To learn how to contribute fixes and new content to this project, read the @@ -52,7 +54,7 @@ Here is a list of community roles with current and previous members: - Approvers: [@open-telemetry/docs-approvers][] - [Michael Hausenblas](https://github.com/mhausenblas), Amazon - - [Tiffany Hrabusa](https://github.com/tiffany76) + - [Tiffany Hrabusa](https://github.com/tiffany76), Grafana Labs - Maintainers: [@open-telemetry/docs-maintainers][] @@ -101,3 +103,5 @@ contributed][contributors]! [slack]: https://slack.cncf.io/ [hugo]: https://gohugo.io [netlify]: https://netlify.com +[available here]: + https://lookerstudio.google.com/reporting/34c2a65a-39e8-44aa-afa0-094975fee55d/page/4VDGB diff --git a/content-modules/opamp-spec b/content-modules/opamp-spec index 950df2967e22..fb2ff487c70a 160000 --- a/content-modules/opamp-spec +++ b/content-modules/opamp-spec @@ -1 +1 @@ -Subproject commit 950df2967e22526aa553aac1d874ac90b973d140 +Subproject commit fb2ff487c70ac1895652ab5c4a965dfc2ae20d03 diff --git a/content-modules/opentelemetry-java-examples b/content-modules/opentelemetry-java-examples index 8fe9a11a33af..0f736eca6a4b 160000 --- a/content-modules/opentelemetry-java-examples +++ b/content-modules/opentelemetry-java-examples @@ -1 +1 @@ -Subproject commit 8fe9a11a33affcc4942f2df6668cd6ce787cde3f +Subproject commit 0f736eca6a4b6865fb62b00033a53369e69440f7 diff --git a/content/en/announcements/2024-community-awards.md b/content/en/announcements/2024-community-awards.md new file mode 100644 index 000000000000..eaf465e9499b --- /dev/null +++ b/content/en/announcements/2024-community-awards.md @@ -0,0 +1,9 @@ +--- +title: OpenTelemetry Community Awards +date: 2024-10-29 +expiryDate: 2024-11-08 +--- + + +[**2024 OpenTelemetry Community Awards**](/blog/2024/community-awards/) +nominations are open! diff --git a/content/en/blog/2023/spring-native/index.md b/content/en/blog/2023/spring-native/index.md index acb1127a0601..5c4aaab586fe 100644 --- a/content/en/blog/2023/spring-native/index.md +++ b/content/en/blog/2023/spring-native/index.md @@ -37,11 +37,11 @@ Boot 3) out of the box: ``` To get even more visibility, the Starter can be combined with -[instrumentation libraries](/docs/languages/java/libraries/). For this purpose, -the OpenTelemetry Java contributors have improved the JDBC (database) libraries -and logging instrumentation libraries. For example, for the Logback logging -library, they have added GraalVM configuration to make the library work in -native mode[^1]. +[instrumentation libraries](/docs/languages/java/instrumentation/). For this +purpose, the OpenTelemetry Java contributors have improved the JDBC (database) +libraries and logging instrumentation libraries. For example, for the Logback +logging library, they have added GraalVM configuration to make the library work +in native mode[^1]. Furthermore, they have worked to reduce the configuration to set up the logging and database instrumentation with the Starter. For example, if your application diff --git a/content/en/blog/2024/community-awards.md b/content/en/blog/2024/community-awards.md new file mode 100644 index 000000000000..e1fc9b54de94 --- /dev/null +++ b/content/en/blog/2024/community-awards.md @@ -0,0 +1,28 @@ +--- +title: 2024 OpenTelemetry Community Awards +linkTitle: OpenTelemetry Community Awards +date: 2024-10-29 +author: OpenTelemetry Governance Committee +--- + +OpenTelemetry is a community-driven project, fueled by a group of awesome humans +who are actively revolutionizing the field of observability with their +contributions. Whether it's through code, documentation, project management, +outreach, adoption, or simply helping others answer technical questions on our +[CNCF Slack](https://slack.cncf.io/), we want to recognize these contributions +and the people behind them -- because we're all human, and we all like that warm +fuzzy feeling of appreciation. + +We are thrilled to announce the first-ever **OpenTelemetry Community Awards**! +This is your chance to nominate individuals who have made a notable impact to +OpenTelemetry over the past year. _Everyone_ can nominate _anyone_ in the +community, be they a contributor, end-user, or community member. + +Submit nominations using +[this Google Form](https://forms.gle/ioqFNmDhKNYYAtRs7). + +Although we require sign-in to ensure only one form submission per person, +nominations are completely anonymous. You can nominate up to five people per +submission, and nominations will be open **until midnight UTC on November 8th, +2024**. Winners will be announced at KubeCon + CloudNativeCon North +America 2024. diff --git a/content/en/blog/2024/gc-candidates.md b/content/en/blog/2024/gc-candidates.md new file mode 100644 index 000000000000..0a2a9fc5c02b --- /dev/null +++ b/content/en/blog/2024/gc-candidates.md @@ -0,0 +1,36 @@ +--- +title: + Announcing the 2024 OpenTelemetry Governance Committee Election Candidates +linkTitle: 2024 GC Candidates +date: 2024-10-15 +author: OpenTelemetry Governance Committee +cSpell:ignore: Baeyens Danielson Marylia +--- + +The OpenTelemetry election committee is excited to announce the final list of +candidates for the upcoming 2024 OpenTelemetry Governance Committee Election! + +If you are an +[eligible voter](https://github.com/open-telemetry/community/blob/main/elections/2024/governance-committee-election.md#voter-eligibility), +you’ll have the opportunity to continue shaping the future of OpenTelemetry by +casting your vote between 21 October 2024 00:00 UTC and 23 October 2024 23:59 +UTC. You'll be selecting your preferred candidates to fill the four available +seats in this year's election. + +You can find the candidates' pictures, profile link, and descriptions on the +[candidates page](https://github.com/open-telemetry/community/blob/main/elections/2024/governance-committee-candidates.md). +Here are their names: + +- Adriana Villela +- Alolita Sharma +- Daniel Dyla +- Jamie Danielson +- Marylia Gutierrez +- Morgan McLean +- Pablo Baeyens Fernández +- Trask Stalnaker + +You can check your eligibility by reviewing +[this GitHub issue](https://github.com/open-telemetry/community/issues/2329). If +you are not listed there but believe you have the right to vote, kindly +[fill out this registration form](https://forms.gle/LBvyRpNwZvqcJxUbA). diff --git a/content/en/blog/2024/gc-election-results.md b/content/en/blog/2024/gc-election-results.md new file mode 100644 index 000000000000..fc102c1543e2 --- /dev/null +++ b/content/en/blog/2024/gc-election-results.md @@ -0,0 +1,32 @@ +--- +title: Announcing the 2024 Governance Committee Election Results +linkTitle: 2024 GC Election Results +date: 2024-10-24 +author: OpenTelemetry Governance Committee +cSpell:ignore: Baeyens +--- + +We are delighted to announce the results of the +[2024 OpenTelemetry Governance Committee Election](https://github.com/open-telemetry/community/blob/main/elections/2024/governance-committee-election.md)! + +The OpenTelemetry project continues to bring together an exceptionally vibrant +community, who are shaping the future of observability with their contributions. +This year, active contributors have shown their commitment again by +participating in our election process, and they've done it in great numbers. + +701 contributors were eligible to vote this year, and 299 of them cast their +ballot. This is a new record for the project! With a participation rate of 43%, +it represents a significant increase from the 2023 election, where 206 ballots +were cast with 616 eligible voters, proof of OpenTelemetry's healthy growth and +engagement. + +Four positions were up for election in this year's Governance Committee +selection process. Without further ado, please join us in congratulating +[Alolita Sharma](https://github.com/alolita), +[Morgan McLean](https://github.com/mtwo), +[Pablo Baeyens Fernández](https://github.com/mx-psi), and +[Trask Stalnaker](https://github.com/trask)! All will serve a two-year term. + +We'd like to thank everyone who participated -- candidates, voters, and the +election organizers -- for their efforts. You can find the +[full results of the election here](https://vote.heliosvoting.org/helios/elections/176e7ca8-647d-11ef-9b9a-2a30e2a223da/view). diff --git a/content/en/blog/2024/state-profiling.md b/content/en/blog/2024/state-profiling.md new file mode 100644 index 000000000000..70010be554bd --- /dev/null +++ b/content/en/blog/2024/state-profiling.md @@ -0,0 +1,117 @@ +--- +title: The State of Profiling +linkTitle: Profiling state +date: 2024-10-25 +cSpell:ignore: Baeyens Florian Geisendörfer Kalkanis Lehner Mathieu Rühsen +author: >- + [Damien Mathieu](https://github.com/dmathieu) (Elastic), [Pablo + Baeyens](https://github.com/mx-psi) (Datadog), [Felix + Geisendörfer](https://github.com/felixge) (Datadog), [Christos + Kalkanis](https://github.com/christos68k) (Elastic), [Morgan + McLean](https://github.com/mtwo) (Splunk), [Florian + Lehner](https://github.com/florianl) (Elastic), [Tim + Rühsen](https://github.com/rockdaboot) (Elastic) +issue: https://github.com/open-telemetry/opentelemetry.io/issues/5477 +sig: Profiling SIG +--- + +A little over six months ago, OpenTelemetry announced +[support for the profiling signal](/blog/2024/profiling/). While the signal is +still in development and isn’t yet recommended for production use, the Profiling +SIG has made substantial progress on many fronts. + +This post provides a summary of the progress the Profiling SIG has made over the +past six months. + +## OTLP improvements + +Profiles were added as a new signal type to OTLP in +[v1.3.0](https://github.com/open-telemetry/opentelemetry-proto/releases/tag/v1.3.0), +though this area is still marked as unstable as we continue to make changes to +it. + +While our original intent was to keep wire compatibility with +[pprof](https://github.com/google/pprof), that goal proved impractical, so the +Profiling SIG +[has decided](https://github.com/open-telemetry/opentelemetry-proto/issues/567#issuecomment-2286565449) +to refactor the protocol and not aim for strict compatibility with pprof. +Instead, we will aim for convertibility, similarly to what we already do for +other signals. This shift is still a work in progress, and is causing several +breaking changes to the profiling section of the protocol. Note that this has no +impact on the stable sections that make up the majority of the OTLP protocol, +like metrics, spans, logs, resources, etc. + +## eBPF agent improvements + +Back in June, the +[donation of the Elastic Continuous Profiling Agent](/blog/2024/elastic-contributes-continuous-profiling-agent/) +was finalized. Since then, the +[opentelemetry-ebpf-profiler](https://github.com/open-telemetry/opentelemetry-ebpf-profiler) +repository has been buzzing with improvements. + +Our next goal for the eBPF agent is for it to run as a Collector receiver. Once +this is complete, the Collector can be run on every node as an agent, which +collects profiles for that host and forwards them using OTLP. This architecture +will allow us to extract some specific parts of the agent that aren’t strictly +profiling, such as retrieving host metadata and system metrics, and move them to +processors, making the agent lighter and more modular. + +## Collector support + +Since +[v0.112.0](https://github.com/open-telemetry/opentelemetry-collector/releases/tag/v0.112.0), +the OpenTelemetry Collector is able to receive, process and export profiling +data, and has support for profile ingestion and export using OTLP. + +You can try it out by enabling the `service.profilesSupport` +[feature gate](https://github.com/open-telemetry/opentelemetry-collector/blob/main/featuregate/README.md#controlling-gates) +in your collector, followed by a configuration similar to the following, which +ingests and exports data using OTLP: + +```yaml +receivers: + otlp: + protocols: + grpc: +exporters: + otlp: + endpoint: 'localhost:4317' +service: + pipelines: + profiles: + receivers: [otlp] + exporters: [otlp] +``` + +While this feature can be used now on the Collector, we do not yet recommend +doing so in production: it is still under heavy development and is expected to +have breaking changes, such as the ones mentioned above with OTLP. + +However, this support in the Collector means that any receiver, processor or +exporter of the Collector can now start adding profiles support, which we highly +encourage to do, as a way to allow a smoother integration in the future, as well +as to find potential issues early. If you wish to report a bug or contribute on +this effort, you can +[view them on the contrib repository](https://github.com/open-telemetry/opentelemetry-collector-contrib/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22+label%3Adata%3Aprofiles). + +## Semantic Conventions and Specification + +To improve interoperability, the Profiling SIG worked also on +[OpenTelemetry Semantic Conventions for profiling](/docs/specs/semconv/attributes-registry/profile/). +There is also ongoing work to introduce a +[profiling OpenTelemetry specification](https://github.com/open-telemetry/opentelemetry-specification/pull/4197). +This work will continue and should enable wide adoption across different +platforms, tools and other OTel signals. + +## What’s next ? + +Support for profiles in OpenTelemetry is moving very quickly, and while we’re +still far from being able to provide a stable signal, we are happy to report +that folks can start hacking with it, and integrate it within their modules. + +If you’re interested in helping profiling move forward, or face issues when +integrating with it, the Profiling SIG is always happy to get or provide help. + +You can find us on +[#otel-profiles](https://cloud-native.slack.com/archives/C03J794L0BV) in the +CNCF slack. diff --git a/content/en/blog/_index.md b/content/en/blog/_index.md index 022dd0feceae..9fddb96c7694 100644 --- a/content/en/blog/_index.md +++ b/content/en/blog/_index.md @@ -1,7 +1,15 @@ --- title: Blog -menu: - main: { weight: 50 } -redirects: [{ from: '', to: '2024/ 301!' }] +menu: { main: { weight: 50 } } +redirects: + # Every January, update the year number in the paths below + - { from: '', to: '2024/ 301!' } + # Workaround to https://github.com/open-telemetry/opentelemetry.io/issues/4440: + - { from: 'index.xml', to: '2024/index.xml 301!' } outputs: [HTML, RSS] +htmltest: + IgnoreDirs: + # 2024-11-03 The following entry is for `en` pages only. Other locales do + # not currently require it. + - ^blog/(\d+/)?page/\d+ --- diff --git a/content/en/docs/collector/_index.md b/content/en/docs/collector/_index.md index 4aeecbd40f26..6885af6eaab7 100644 --- a/content/en/docs/collector/_index.md +++ b/content/en/docs/collector/_index.md @@ -3,7 +3,7 @@ title: Collector description: Vendor-agnostic way to receive, process and export telemetry data. aliases: [collector/about] cascade: - vers: 0.111.0 + vers: 0.112.0 weight: 270 --- diff --git a/content/en/docs/collector/building/connector.md b/content/en/docs/collector/building/connector/index.md similarity index 99% rename from content/en/docs/collector/building/connector.md rename to content/en/docs/collector/building/connector/index.md index e36741c2f030..410cfb733635 100644 --- a/content/en/docs/collector/building/connector.md +++ b/content/en/docs/collector/building/connector/index.md @@ -54,11 +54,11 @@ following links: ### The Old Architecture: -![Before picture of how processors emitted data directly to another pipelines exporter](../../img/otel-collector-before-connector.png) +![Before picture of how processors emitted data directly to another pipelines exporter](./otel-collector-before-connector.svg) ### New Architecture Using a Connector: -![How the pipeline should work using the connector component](../../img/otel-collector-after-connector.png) +![How the pipeline should work using the connector component](./otel-collector-after-connector.svg) ## Building Example Connector diff --git a/content/en/docs/collector/building/connector/otel-collector-after-connector.svg b/content/en/docs/collector/building/connector/otel-collector-after-connector.svg new file mode 100644 index 000000000000..a6bd7802b339 --- /dev/null +++ b/content/en/docs/collector/building/connector/otel-collector-after-connector.svg @@ -0,0 +1,235 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/content/en/docs/collector/building/connector/otel-collector-before-connector.svg b/content/en/docs/collector/building/connector/otel-collector-before-connector.svg new file mode 100644 index 000000000000..662198cd7766 --- /dev/null +++ b/content/en/docs/collector/building/connector/otel-collector-before-connector.svg @@ -0,0 +1,177 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/content/en/docs/collector/custom-collector.md b/content/en/docs/collector/custom-collector.md index d476c8e3b307..d88480e14f15 100644 --- a/content/en/docs/collector/custom-collector.md +++ b/content/en/docs/collector/custom-collector.md @@ -166,11 +166,11 @@ receivers: go.opentelemetry.io/collector/receiver/otlpreceiver {{% version-from-registry collector-receiver-otlp %}} providers: - - gomod: go.opentelemetry.io/collector/confmap/provider/envprovider v1.16.0 - - gomod: go.opentelemetry.io/collector/confmap/provider/fileprovider v1.16.0 - - gomod: go.opentelemetry.io/collector/confmap/provider/httpprovider v0.110.0 - - gomod: go.opentelemetry.io/collector/confmap/provider/httpsprovider v0.110.0 - - gomod: go.opentelemetry.io/collector/confmap/provider/yamlprovider v0.110.0 + - gomod: go.opentelemetry.io/collector/confmap/provider/envprovider v1.18.0 + - gomod: go.opentelemetry.io/collector/confmap/provider/fileprovider v1.18.0 + - gomod: go.opentelemetry.io/collector/confmap/provider/httpprovider v1.18.0 + - gomod: go.opentelemetry.io/collector/confmap/provider/httpsprovider v1.18.0 + - gomod: go.opentelemetry.io/collector/confmap/provider/yamlprovider v1.18.0 ``` {{% alert color="primary" title="Tip" %}} diff --git a/content/en/docs/collector/deployment/agent.md b/content/en/docs/collector/deployment/agent.md index 2a17343c3b7b..eff8d8df82ef 100644 --- a/content/en/docs/collector/deployment/agent.md +++ b/content/en/docs/collector/deployment/agent.md @@ -129,7 +129,7 @@ Cons: [instrumentation]: /docs/languages/ [otlp]: /docs/specs/otel/protocol/ [collector]: /docs/collector/ -[instrument-java-metrics]: /docs/languages/java/instrumentation/#metrics +[instrument-java-metrics]: /docs/languages/java/api-components/#meterprovider [otlp-exporter]: /docs/specs/otel/protocol/exporter/ [java-otlp-example]: https://github.com/open-telemetry/opentelemetry-java-docs/tree/main/otlp diff --git a/content/en/docs/collector/img/otel-collector-after-connector.png b/content/en/docs/collector/img/otel-collector-after-connector.png deleted file mode 100644 index e106c5fd9726..000000000000 Binary files a/content/en/docs/collector/img/otel-collector-after-connector.png and /dev/null differ diff --git a/content/en/docs/collector/img/otel-collector-before-connector.png b/content/en/docs/collector/img/otel-collector-before-connector.png deleted file mode 100644 index a8667d4b6edf..000000000000 Binary files a/content/en/docs/collector/img/otel-collector-before-connector.png and /dev/null differ diff --git a/content/en/docs/collector/img/otel-collector.svg b/content/en/docs/collector/img/otel-collector.svg index 022696c23bb7..1e1583cfb3b2 100644 --- a/content/en/docs/collector/img/otel-collector.svg +++ b/content/en/docs/collector/img/otel-collector.svg @@ -1,6 +1,6 @@ - - - + + + diff --git a/content/en/docs/collector/internal-telemetry.md b/content/en/docs/collector/internal-telemetry.md index 16e6082446fe..c850dd150f55 100644 --- a/content/en/docs/collector/internal-telemetry.md +++ b/content/en/docs/collector/internal-telemetry.md @@ -36,11 +36,11 @@ service: telemetry: metrics: readers: - pull: - exporter: - prometheus: - host: '0.0.0.0' - port: 8888 + - pull: + exporter: + prometheus: + host: '0.0.0.0' + port: 8888 ``` You can adjust the verbosity of the Collector metrics output by setting the @@ -65,46 +65,6 @@ service: level: detailed ``` -The Collector can also be configured to push its own metrics to an -[OTLP receiver](https://github.com/open-telemetry/opentelemetry-collector/tree/main/receiver/otlpreceiver) -and send them through configured pipelines. In the following example, the -Collector is configured to push metrics every 10s using OTLP gRPC to -`localhost:14317`: - -```yaml -receivers: - otlp/internal_metrics: - protocols: - grpc: - endpoint: localhost:14317 -exporters: - debug: -service: - pipelines: - metrics: - receivers: [otlp/internal_metrics] - exporters: [debug] - telemetry: - metrics: - readers: - - periodic: - interval: 10000 - exporter: - otlp: - protocol: grpc/protobuf - endpoint: localhost:14317 -``` - -{{% alert title="Caution" color="warning" %}} - -When self-monitoring, the Collector collects its own telemetry and sends it to -the desired backend for analysis. This can be a risky practice. If the Collector -is underperforming, its self-monitoring capability could be impacted. As a -result, the self-monitored telemetry might not reach the backend in time for -critical analysis. - -{{% /alert %}} - ### Configure internal logs Log output is found in `stderr`. You can configure logs in the config @@ -144,6 +104,94 @@ journalctl | grep otelcol | grep Error {{% /tab %}} {{< /tabpane >}} +### Configure internal traces + +The Collector does not expose traces by default, but it can be configured to. + +{{% alert title="Caution" color="warning" %}} + +Internal tracing is an experimental feature, and no guarantees are made as to +the stability of the emitted span names and attributes. + +{{% /alert %}} + +The following configuration can be used to emit internal traces from the +Collector to an OTLP/gRPC backend: + +```yaml +service: + telemetry: + traces: + processors: + - batch: + exporter: + otlp: + protocol: grpc/protobuf + endpoint: https://backend:4317 +``` + +See the [example configuration][kitchen-sink-config] for additional options. +Note that the `tracer_provider` section there corresponds to `traces` here. + +[kitchen-sink-config]: + https://github.com/open-telemetry/opentelemetry-configuration/blob/main/examples/kitchen-sink.yaml + +### Self-monitoring + +The Collector can be configured to push its own telemetry to an +[OTLP receiver](https://github.com/open-telemetry/opentelemetry-collector/tree/main/receiver/otlpreceiver) +and send the data through configured pipelines. In the following example, the +Collector is configured to push metrics and traces every 10s using OTLP gRPC to +`localhost:14317`: + +```yaml +receivers: + otlp/internal: + protocols: + grpc: + endpoint: localhost:14317 +exporters: + debug: +service: + pipelines: + metrics: + receivers: [otlp/internal] + exporters: [debug] + traces: + receivers: [otlp/internal] + exporters: [debug] + telemetry: + metrics: + readers: + - periodic: + interval: 10000 + exporter: + otlp: + protocol: grpc/protobuf + endpoint: localhost:14317 + traces: + processors: + batch: + exporter: + otlp: + protocol: grpc/protobuf + endpoint: localhost:14317 +``` + +{{% alert title="Caution" color="warning" %}} + +When self-monitoring, the Collector collects its own telemetry and sends it to +the desired backend for analysis. This can be a risky practice. If the Collector +is underperforming, its self-monitoring capability could be impacted. As a +result, the self-monitored telemetry might not reach the backend in time for +critical analysis. + +Moreover, sending internal telemetry through the Collector's own pipelines can +create a continuous loop of spans, metric points, or logs, putting undue strain +on the Collector's performance. This setup should not be used in production. + +{{% /alert %}} + ## Types of internal telemetry The OpenTelemetry Collector aims to be a model of observable service by clearly diff --git a/content/en/docs/concepts/instrumentation-scope/spans-with-instrumentation-scope.svg b/content/en/docs/concepts/instrumentation-scope/spans-with-instrumentation-scope.svg index ccbfc25c43dc..9e5ecfb13cae 100644 --- a/content/en/docs/concepts/instrumentation-scope/spans-with-instrumentation-scope.svg +++ b/content/en/docs/concepts/instrumentation-scope/spans-with-instrumentation-scope.svg @@ -1,3 +1,3 @@ - /api/placeOrderCheckoutService::placeOrderprepareOrderItemsCartService::getCartCache::findCache::findProductService::getProductCache::findCache::findDB::querycheckoutCache::findDB::query \ No newline at end of file + /api/placeOrderCheckoutService::placeOrderprepareOrderItemsCartService::getCartCache::findCache::findProductService::getProductCache::findCache::findDB::querycheckoutCache::findDB::query diff --git a/content/en/docs/concepts/instrumentation/libraries.md b/content/en/docs/concepts/instrumentation/libraries.md index 9d240f97b2ad..7ef1ddcf74ff 100644 --- a/content/en/docs/concepts/instrumentation/libraries.md +++ b/content/en/docs/concepts/instrumentation/libraries.md @@ -22,6 +22,8 @@ and document hooks. Other advantages provided by native instrumentation include: various consumption scenarios using a wide variety of well-documented OpenTelemetry extensibility points. +![ Native Instrumentation vs instrumentation libraries](/img/libraries-instrumentation.svg) + ## Semantic conventions [Semantic conventions](/docs/specs/semconv/general/trace/) are the main source @@ -265,7 +267,7 @@ After you create a span, pass new trace context to the application code (callback or handler), by making the span active; if possible, do this explicitly. The following Java example shows how to add trace context and activate a span. See the -[Context extraction in Java](/docs/languages/java/instrumentation/#context-propagation), +[Context extraction in Java](/docs/languages/java/api-components/#contextpropagators), for more examples. ```java @@ -289,9 +291,7 @@ try (Scope unused = span.makeCurrent()) { ``` In the case of a messaging system, you might receive more than one message at -once. Received messages become -[links](/docs/languages/java/instrumentation/#create-spans-with-links) on the -span you create. Refer to +once. Received messages become links on the span you create. Refer to [messaging conventions](/docs/specs/semconv/messaging/messaging-spans/) for details. @@ -343,7 +343,7 @@ There might be some exceptions where you don't need to propagate context: context propagation in addition to active spans. - Put spans (trace context) created by library in the context explicitly, document how to access it. - - Alow users to pass trace context in your context. + - Allow users to pass trace context in your context. - Within the library, propagate trace context explicitly. Active spans might change during callbacks. - Capture active context from users on the public API surface as soon as you diff --git a/content/en/docs/contributing/localization.md b/content/en/docs/contributing/localization.md index 4a88cc7f00ec..615669b7ef09 100644 --- a/content/en/docs/contributing/localization.md +++ b/content/en/docs/contributing/localization.md @@ -11,6 +11,34 @@ English is the default language, with US English as the default (implicit) local A growing number of other localizations are supported, as can be seen from the languages dropdown menu in the top nav. +## English language maintainer guidance + +### When link checking fails for non-English pages + +English is the default language of the OpenTelemetry website. After you add, +edit, or reorganized English language documentation, link checking may fail for +non-English pages. When this happens: + + + +- Do **not** fix the broken links. Each non-English page is associated with a + specific commit of the corresponding English page, as identified by the git + commit hash value of the `default_lang_commit` front matter key. +- Configure the link checker to ignore the non-English pages by adding the + following to the page's front matter, or to the closest common ancestor file, + when more than one page has link errors: + ```yaml + htmltest: + # TODO: remove the IgnoreDirs once broken links are fixed + IgnoreDirs: + - path-regex/to/non-en/directory/contain/files/to/ignore + - path-2-etc + ``` +- Run `npm run check:links` and include any updates to the `.htmltest.yml` + config file with your PR. + + + ## Translation guidance We recommend that you follow the guidance offered in this section when @@ -204,22 +232,59 @@ For more details about the script, run `npm run check:i18n -- -h`. ## New localizations -(Section To Be Completed soon with information about how to propose a new -localization.) - - +{{% /alert %}} [main]: https://github.com/open-telemetry/opentelemetry.io/commits/main/ [multilingual framework]: https://gohugo.io/content-management/multilingual/ +[PR #5386]: https://github.com/open-telemetry/opentelemetry.io/pull/5386/files diff --git a/content/en/docs/demo/feature-flags.md b/content/en/docs/demo/feature-flags.md index 4b9fd1c72999..71f9995131f5 100644 --- a/content/en/docs/demo/feature-flags.md +++ b/content/en/docs/demo/feature-flags.md @@ -18,7 +18,7 @@ change the `defaultVariant` value in the config file for a given flag to "on". | `adServiceFailure` | Ad Service | Generate an error for `GetAds` 1/10th of the time | | `adServiceManualGc` | Ad Service | Trigger full manual garbage collections in the ad service | | `adServiceHighCpu` | Ad Service | Trigger high cpu load in the ad service. If you want to demo cpu throttling, set cpu resource limits | -| `cartServiceFailure` | Cart Service | Generate an error for `EmptyCart` 1/10th of the time | +| `cartServiceFailure` | Cart Service | Generate an error whenever `EmptyCart` is called | | `productCatalogFailure` | Product Catalog | Generate an error for `GetProduct` requests with product ID: `OLJCESPC7Z` | | `recommendationServiceCacheFailure` | Recommendation | Create a memory leak due to an exponentially growing cache. 1.4x growth, 50% of requests trigger growth. | | `paymentServiceFailure` | Payment Service | Generate an error when calling the `charge` method. | diff --git a/content/en/docs/kubernetes/helm/operator.md b/content/en/docs/kubernetes/helm/operator.md index 39ec637131b1..aed4886dfffe 100644 --- a/content/en/docs/kubernetes/helm/operator.md +++ b/content/en/docs/kubernetes/helm/operator.md @@ -63,8 +63,8 @@ generate/configure the required TLS certificate. `.Values.admissionWebhooks.create` and `admissionWebhooks.certManager.enabled` while setting your custom cert secret name in `admissionWebhooks.secretName` - You can disable webhooks all together by disabling - `.Values.admissionWebhooks.create` and setting env var to - `ENABLE_WEBHOOKS: "false"` + `.Values.admissionWebhooks.create` and setting env var + `.Values.manager.env.ENABLE_WEBHOOKS` to `false` All the configuration options (with comments) available in the chart can be viewed in its diff --git a/content/en/docs/kubernetes/operator/automatic.md b/content/en/docs/kubernetes/operator/automatic.md index cd3be74751db..2435e060b81a 100644 --- a/content/en/docs/kubernetes/operator/automatic.md +++ b/content/en/docs/kubernetes/operator/automatic.md @@ -428,9 +428,16 @@ spec: instrumentation> ``` +See the +[Python agent configuration docs](/docs/zero-code/python/configuration/#disabling-specific-instrumentations) +for more details. + #### Learn more {#python-learn-more} -[See the Python agent Configuration docs for more details.](/docs/zero-code/python/configuration/#disabling-specific-instrumentations) +For Python-specific quirks, see +[Python OpenTelemetry Operator docs](/docs/zero-code/python/operator/#python-specific-topics) +and the +[Python agent configuration docs](/docs/zero-code/python/configuration/). ### Go diff --git a/content/en/docs/languages/java/_index.md b/content/en/docs/languages/java/_index.md index 8349448c580f..7a7091bbbbc3 100644 --- a/content/en/docs/languages/java/_index.md +++ b/content/en/docs/languages/java/_index.md @@ -6,82 +6,11 @@ description: >- aliases: [/java, /java/metrics, /java/tracing] cascade: vers: - instrumentation: 2.8.0 - otel: 1.42.1 + instrumentation: 2.9.0 + otel: 1.43.0 contrib: 1.38.0 - semconv: 1.27.0 + semconv: 1.28.0 weight: 18 --- {{% docs/languages/index-intro java /%}} - -### Repositories - -OpenTelemetry Java consists of the following repositories: - -- [opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java): - Components for manual instrumentation including API and SDK as well as - extensions, the OpenTracing shim. -- [opentelemetry-java-docs][]: Manual instrumentation examples. -- [opentelemetry-java-instrumentation](https://github.com/open-telemetry/opentelemetry-java-instrumentation): - Built on top of opentelemetry-java and provides a Java agent JAR that can be - attached to any Java 8+ application and dynamically injects bytecode to - capture telemetry from a number of popular libraries and frameworks. -- [opentelemetry-java-contrib](https://github.com/open-telemetry/opentelemetry-java-contrib): - Provides helpful libraries and standalone OpenTelemetry-based utilities that - don't fit the express scope of the OpenTelemetry Java or Java Instrumentation - projects. For example, JMX metric gathering. -- [semantic-conventions-java](https://github.com/open-telemetry/semantic-conventions-java): - Java implementation of - [OpenTelemetry Semantic Conventions](/docs/specs/semconv/). For example, - `ResourceAttributes.SERVICE_NAME`. -- [opentelemetry-proto-java](https://github.com/open-telemetry/opentelemetry-proto-java): - Java bindings for the [OpenTelemetry Protocol (OTLP)](/docs/specs/otlp/). - -### Components - -See [components] for a complete list of published components. - -### Releases - -Published [releases][] are available on [maven central][]. We strongly recommend -using our BOM to keep the versions of the various components in sync. - -#### Maven - -```xml - - - - - io.opentelemetry - opentelemetry-bom - {{% param vers.otel %}} - pom - import - - - - - - io.opentelemetry - opentelemetry-api - - - -``` - -#### Gradle - -```kotlin -dependencies { - implementation(platform("io.opentelemetry:opentelemetry-bom:{{% param vers.otel %}}")) - implementation("io.opentelemetry:opentelemetry-api") -} -``` - -[maven central]: https://mvnrepository.com/artifact/io.opentelemetry -[opentelemetry-java-docs]: - https://github.com/open-telemetry/opentelemetry-java-docs#java-opentelemetry-examples -[releases]: https://github.com/open-telemetry/opentelemetry-java/releases -[components]: https://github.com/open-telemetry/opentelemetry-java#releases diff --git a/content/en/docs/languages/java/api-components.md b/content/en/docs/languages/java/api-components.md new file mode 100644 index 000000000000..c5df547cdf7a --- /dev/null +++ b/content/en/docs/languages/java/api-components.md @@ -0,0 +1,1688 @@ +--- +title: Record Telemetry with API +weight: 11 +logBridgeWarning: > + While the `LoggerProvider` / `Logger` APIs are structurally similar to the + equivalent trace and metric APIs, they serve a different use case. As of now, + `LoggerProvider` / `Logger` and associated classes represent the [Log Bridge + API](/docs/specs/otel/logs/bridge-api/), which exists to write log appenders + to bridge logs recorded through other log APIs / frameworks into + OpenTelemetry. They are not intended for end user use as a replacement for + Log4j / SLF4J / Logback / etc. +cSpell:ignore: Dotel kotlint Logback updowncounter +--- + + + + +The API is a set of classes and interfaces for recording telemetry across key +observability signals. The [SDK](../sdk/) is the built-in reference +implementation of the API, [configured](../configuration/) to process and export +telemetry. This page is a conceptual overview of the API, including +descriptions, links to relevant Javadocs, artifact coordinates, and sample API +usage. + +The API consists of the following top-level components: + +- [Context](#context-api): A standalone API for propagating context throughout + an application and across application boundaries, including trace context and + baggage. +- [TracerProvider](#tracerprovider): The API entry point for traces. +- [MeterProvider](#meterprovider): The API entry point for metrics. +- [LoggerProvider](#loggerprovider): The API entry point for logs. +- [OpenTelemetry](#opentelemetry): A holder for top-level API components (i.e. + `TracerProvider`, `MeterProvider`, `LoggerProvider`, `ContextPropagators`) + which is convenient to pass to instrumentation. + +The API is designed to support multiple implementations. Two implementations are +provided by OpenTelemetry: + +- [SDK](../sdk/) reference implementation. This is the right choice for most + users. +- [Noop](#noop-implementation) implementation. A minimalist, zero-dependency + implementation for instrumentations to use by default when the user doesn't + install an instance. + +The API is designed to be taken as a direct dependency by libraries, frameworks, +and application owners. It comes with +[strong backwards compatibility guarantees](https://github.com/open-telemetry/opentelemetry-java/blob/main/VERSIONING.md#compatibility-requirements), +zero transitive dependencies, and +[supports Java 8+](https://github.com/open-telemetry/opentelemetry-java/blob/main/VERSIONING.md#language-version-compatibility). +Libraries and frameworks should depend only on the API and only call methods +from the API, and instruct applications / end users to add a dependency on the +SDK and install a configured instance. + +## API Components + +The following sections describe the OpenTelemetry API. Each component section +includes: + +- A brief description, including a link to the Javadoc type reference. +- Links to relevant resources to understand the API methods and arguments. +- A simple exploration of API usage. + +## Context API + +The `io.opentelemetry:opentelemetry-api-context:{{% param vers.otel %}}` +artifact contains standalone APIs (i.e. packaged separately from +[OpenTelemetry API](#opentelemetry-api)) for propagating context throughout an +application and across application boundaries. + +It consists of: + +- [Context](#context): An immutable bundle of key value pairs which is + implicitly or explicitly propagated through an application. +- [ContextStorage](#contextstorage): A mechanism for storing and retrieving the + current context, defaulting to thread local. +- [ContextPropagators](#context): A container of registered propagators for + propagating `Context` across application boundaries. + +The `io.opentelemetry:opentelemetry-extension-kotlint:{{% param vers.otel %}}` +is an extension with tools for propagating context into coroutines. + +### Context + +[Context](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-context/latest/io/opentelemetry/context/Context.html) +is an immutable bundle of key value pairs, with utilities for implicitly +propagating through an application and across threads. Implicit propagation +means that the context can be accessed without explicitly passing it as an +argument. Context is a recurring concept in the OpenTelemetry API: + +- The current active [Span](#span) is stored in context, and by default a span's + parent is assigned to whatever span is currently in context. +- The measurements recorded to [metric instruments](#meter) accept a context + argument, used to link measurements to spans via + [exemplars](/docs/specs/otel/metrics/data-model/#exemplars) and defaulting to + whatever span is currently in context. +- [LogRecords](#logrecordbuilder) accept a context argument, used to link log + record spans and defaulting to whatever span is currently in context. + +The following code snippet explores `Context` API usage: + + + +```java +package otel; + +import io.opentelemetry.context.Context; +import io.opentelemetry.context.ContextKey; +import io.opentelemetry.context.Scope; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; + +public class ContextUsage { + public static void contextUsage() throws Exception { + // Define an example context key + ContextKey exampleContextKey = ContextKey.named("example-context-key"); + + // Context doesn't contain the key until we add it + // Context.current() accesses the current context + // output => current context value: null + System.out.println("current context value: " + Context.current().get(exampleContextKey)); + + // Add entry to context + Context context = Context.current().with(exampleContextKey, "value"); + + // The local context var contains the added value + // output => context value: value + System.out.println("context value: " + context.get(exampleContextKey)); + // The current context still doesn't contain the value + // output => current context value: null + System.out.println("current context value: " + Context.current().get(exampleContextKey)); + + // Calling context.makeCurrent() sets Context.current() to the context until the scope is + // closed, upon which Context.current() is restored to the state prior to when + // context.makeCurrent() was called. The resulting Scope implements AutoCloseable and is + // normally used in a try-with-resources block. Failure to call Scope.close() is an error and + // may cause memory leaks or other issues. + try (Scope scope = context.makeCurrent()) { + // The current context now contains the added value + // output => context value: value + System.out.println("context value: " + context.get(exampleContextKey)); + } + + // The local context var still contains the added value + // output => context value: value + System.out.println("context value: " + context.get(exampleContextKey)); + // The current context no longer contains the value + // output => current context value: null + System.out.println("current context value: " + Context.current().get(exampleContextKey)); + + ExecutorService executorService = Executors.newSingleThreadExecutor(); + ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1); + + // Context instances can be explicitly passed around application code, but it's more convenient + // to use implicit context, calling Context.makeCurrent() and accessing via Context.current(). + // Context provides a number of utilities for implicit context propagation. These utilities wrap + // utility classes like Scheduler, ExecutorService, ScheduledExecutorService, Runnable, + // Callable, Consumer, Supplier, Function, etc and modify their behavior to call + // Context.makeCurrent() before running. + context.wrap(ContextUsage::callable).call(); + context.wrap(ContextUsage::runnable).run(); + context.wrap(executorService).submit(ContextUsage::runnable); + context.wrap(scheduledExecutorService).schedule(ContextUsage::runnable, 1, TimeUnit.SECONDS); + context.wrapConsumer(ContextUsage::consumer).accept(new Object()); + context.wrapConsumer(ContextUsage::biConsumer).accept(new Object(), new Object()); + context.wrapFunction(ContextUsage::function).apply(new Object()); + context.wrapSupplier(ContextUsage::supplier).get(); + } + + /** Example {@link java.util.concurrent.Callable}. */ + private static Object callable() { + return new Object(); + } + + /** Example {@link Runnable}. */ + private static void runnable() {} + + /** Example {@link java.util.function.Consumer}. */ + private static void consumer(Object object) {} + + /** Example {@link java.util.function.BiConsumer}. */ + private static void biConsumer(Object object1, Object object2) {} + + /** Example {@link java.util.function.Function}. */ + private static Object function(Object object) { + return object; + } + + /** Example {@link java.util.function.Supplier}. */ + private static Object supplier() { + return new Object(); + } +} +``` + + +### ContextStorage + +[ContextStorage](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-context/latest/io/opentelemetry/context/ContextStorage.html) +is a mechanism for storing and retrieving the current `Context`. + +The default `ContextStorage` implementation stores `Context` in thread local. + +### ContextPropagators + +[ContextPropagators](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-context/latest/io/opentelemetry/context/propagation/ContextPropagators.html) +is a container of registered propagators for propagating `Context` across +application boundaries. Context is injected into a carrier when leaving an +application (i.e. an outbound HTTP request), and extracted from a carrier when +entering an application (i.e. serving an HTTP request). + +See [SDK TextMapPropagators](../sdk/#textmappropagator) for propagator +implementations. + +The following code snippet explores `ContextPropagators` API for injection: + + + +```java +package otel; + +import io.opentelemetry.api.baggage.propagation.W3CBaggagePropagator; +import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator; +import io.opentelemetry.context.Context; +import io.opentelemetry.context.propagation.ContextPropagators; +import io.opentelemetry.context.propagation.TextMapPropagator; +import io.opentelemetry.context.propagation.TextMapSetter; +import java.net.URI; +import java.net.http.HttpClient; +import java.net.http.HttpRequest; +import java.net.http.HttpResponse; + +public class InjectContextUsage { + private static final TextMapSetter TEXT_MAP_SETTER = new HttpRequestSetter(); + + public static void injectContextUsage() throws Exception { + // Create a ContextPropagators instance which propagates w3c trace context and w3c baggage + ContextPropagators propagators = + ContextPropagators.create( + TextMapPropagator.composite( + W3CTraceContextPropagator.getInstance(), W3CBaggagePropagator.getInstance())); + + // Create an HttpRequest builder + HttpClient httpClient = HttpClient.newBuilder().build(); + HttpRequest.Builder requestBuilder = + HttpRequest.newBuilder().uri(new URI("http://127.0.0.1:8080/resource")).GET(); + + // Given a ContextPropagators instance, inject the current context into the HTTP request carrier + propagators.getTextMapPropagator().inject(Context.current(), requestBuilder, TEXT_MAP_SETTER); + + // Send the request with the injected context + httpClient.send(requestBuilder.build(), HttpResponse.BodyHandlers.discarding()); + } + + /** {@link TextMapSetter} with a {@link HttpRequest.Builder} carrier. */ + private static class HttpRequestSetter implements TextMapSetter { + @Override + public void set(HttpRequest.Builder carrier, String key, String value) { + if (carrier == null) { + return; + } + carrier.setHeader(key, value); + } + } +} +``` + + +The following code snippet explores `ContextPropagators` API for extraction: + + + +```java +package otel; + +import com.sun.net.httpserver.HttpExchange; +import com.sun.net.httpserver.HttpHandler; +import com.sun.net.httpserver.HttpServer; +import io.opentelemetry.api.baggage.propagation.W3CBaggagePropagator; +import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator; +import io.opentelemetry.context.Context; +import io.opentelemetry.context.Scope; +import io.opentelemetry.context.propagation.ContextPropagators; +import io.opentelemetry.context.propagation.TextMapGetter; +import io.opentelemetry.context.propagation.TextMapPropagator; +import io.opentelemetry.context.propagation.TextMapSetter; +import java.io.IOException; +import java.io.OutputStream; +import java.net.InetSocketAddress; +import java.nio.charset.StandardCharsets; +import java.util.List; + +public class ExtractContextUsage { + private static final TextMapGetter TEXT_MAP_GETTER = new HttpRequestGetter(); + + public static void extractContextUsage() throws Exception { + // Create a ContextPropagators instance which propagates w3c trace context and w3c baggage + ContextPropagators propagators = + ContextPropagators.create( + TextMapPropagator.composite( + W3CTraceContextPropagator.getInstance(), W3CBaggagePropagator.getInstance())); + + // Create a server, which uses the propagators to extract context from requests + HttpServer server = HttpServer.create(new InetSocketAddress(8080), 0); + server.createContext("/path", new Handler(propagators)); + server.setExecutor(null); + server.start(); + } + + private static class Handler implements HttpHandler { + private final ContextPropagators contextPropagators; + + private Handler(ContextPropagators contextPropagators) { + this.contextPropagators = contextPropagators; + } + + @Override + public void handle(HttpExchange exchange) throws IOException { + // Extract the context from the request and make the context current + Context extractedContext = + contextPropagators + .getTextMapPropagator() + .extract(Context.current(), exchange, TEXT_MAP_GETTER); + try (Scope scope = extractedContext.makeCurrent()) { + // Do work with the extracted context + } finally { + String response = "success"; + exchange.sendResponseHeaders(200, response.length()); + OutputStream os = exchange.getResponseBody(); + os.write(response.getBytes(StandardCharsets.UTF_8)); + os.close(); + } + } + } + + /** {@link TextMapSetter} with a {@link HttpExchange} carrier. */ + private static class HttpRequestGetter implements TextMapGetter { + @Override + public Iterable keys(HttpExchange carrier) { + return carrier.getRequestHeaders().keySet(); + } + + @Override + public String get(HttpExchange carrier, String key) { + if (carrier == null) { + return null; + } + List headers = carrier.getRequestHeaders().get(key); + if (headers == null || headers.isEmpty()) { + return null; + } + return headers.get(0); + } + } +} +``` + + +## OpenTelemetry API + +The `io.opentelemetry:opentelemetry-api:{{% param vers.otel %}}` artifact +contains the OpenTelemetry API, including traces, metrics, logs, noop +implementation, baggage, key `TextMapPropagator` implementations, and a +dependency on the [context API](#context-api). + +### Providers and Scopes + +Providers and scopes are recurring concepts in the OpenTelemetry API. A scope is +a logical unit within the application which telemetry is associated with. A +provider provides components for recording telemetry relative to a particular +scope: + +- [TracerProvider](#tracerprovider) provides scoped [Tracers](#tracer) for + recording spans. +- [MeterProvider](#meterprovider) provides scoped [Meters](#meter) for recording + metrics. +- [LoggerProvider](#loggerprovider) provides scoped [Loggers](#logger) for + recording logs. + +{{% alert %}} {{% param logBridgeWarning %}} {{% /alert %}} + +A scope is identified by the triplet (name, version, schemaUrl). Care must be +taken to ensure the scope identity is unique. A typical approach is to set the +scope name to the package name or fully qualified class name, and to set the +scope version to the library version. If emitting telemetry for multiple signals +(i.e. metrics and traces), the same scope should be used. See +[instrumentation scope](/docs/concepts/instrumentation-scope/) for details. + +The following code snippet explores provider and scope API usage: + + + +```java +package otel; + +import io.opentelemetry.api.OpenTelemetry; +import io.opentelemetry.api.logs.Logger; +import io.opentelemetry.api.logs.LoggerProvider; +import io.opentelemetry.api.metrics.Meter; +import io.opentelemetry.api.metrics.MeterProvider; +import io.opentelemetry.api.trace.Tracer; +import io.opentelemetry.api.trace.TracerProvider; + +public class ProvidersAndScopes { + + private static final String SCOPE_NAME = "fully.qualified.name"; + private static final String SCOPE_VERSION = "1.0.0"; + private static final String SCOPE_SCHEMA_URL = "https://example"; + + public static void providersUsage(OpenTelemetry openTelemetry) { + // Access providers from an OpenTelemetry instance + TracerProvider tracerProvider = openTelemetry.getTracerProvider(); + MeterProvider meterProvider = openTelemetry.getMeterProvider(); + // NOTE: LoggerProvider is a special case and should only be used to bridge logs from other + // logging APIs / frameworks into OpenTelemetry. + LoggerProvider loggerProvider = openTelemetry.getLogsBridge(); + + // Access tracer, meter, logger from providers to record telemetry for a particular scope + Tracer tracer = + tracerProvider + .tracerBuilder(SCOPE_NAME) + .setInstrumentationVersion(SCOPE_VERSION) + .setSchemaUrl(SCOPE_SCHEMA_URL) + .build(); + Meter meter = + meterProvider + .meterBuilder(SCOPE_NAME) + .setInstrumentationVersion(SCOPE_VERSION) + .setSchemaUrl(SCOPE_SCHEMA_URL) + .build(); + Logger logger = + loggerProvider + .loggerBuilder(SCOPE_NAME) + .setInstrumentationVersion(SCOPE_VERSION) + .setSchemaUrl(SCOPE_SCHEMA_URL) + .build(); + + // ...optionally, shorthand versions are available if scope version and schemaUrl aren't + // available + tracer = tracerProvider.get(SCOPE_NAME); + meter = meterProvider.get(SCOPE_NAME); + logger = loggerProvider.get(SCOPE_NAME); + } +} +``` + + +### Attributes + +[Attributes](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/common/Attributes.html) +is a bundle of key value pairs representing the +[standard attribute definition](/docs/specs/otel/common/#standard-attribute). +`Attributes` are a recurring concept in the OpenTelemetry API: + +- [Spans](#span), span events, and span links have attributes. +- The measurements recorded to [metric instruments](#meter) have attributes. +- [LogRecords](#logrecordbuilder) have attributes. + +See [semantic attributes](#semantic-attributes) for attribute constants +generated from the semantic conventions. + +See [attribute naming](/docs/specs/semconv/general/attribute-naming/) for +guidance on attribute naming. + +The following code snippet explores `Attributes` API usage: + + + +```java +package otel; + +import io.opentelemetry.api.common.AttributeKey; +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.common.AttributesBuilder; +import java.util.Map; + +public class AttributesUsage { + // Establish static constant for attribute keys and reuse to avoid allocations + private static final AttributeKey SHOP_ID = AttributeKey.stringKey("com.acme.shop.id"); + private static final AttributeKey SHOP_NAME = + AttributeKey.stringKey("com.acme.shop.name"); + private static final AttributeKey CUSTOMER_ID = + AttributeKey.longKey("com.acme.customer.id"); + private static final AttributeKey CUSTOMER_NAME = + AttributeKey.stringKey("com.acme.customer.name"); + + public static void attributesUsage() { + // Use a varargs initializer and pre-allocated attribute keys. This is the most efficient way to + // create attributes. + Attributes attributes = + Attributes.of( + SHOP_ID, + "abc123", + SHOP_NAME, + "opentelemetry-demo", + CUSTOMER_ID, + 123L, + CUSTOMER_NAME, + "Jack"); + + // ...or use a builder. + attributes = + Attributes.builder() + .put(SHOP_ID, "abc123") + .put(SHOP_NAME, "opentelemetry-demo") + .put(CUSTOMER_ID, 123) + .put(CUSTOMER_NAME, "Jack") + // Optionally initialize attribute keys on the fly + .put(AttributeKey.stringKey("com.acme.string-key"), "value") + .put(AttributeKey.booleanKey("com.acme.bool-key"), true) + .put(AttributeKey.longKey("com.acme.long-key"), 1L) + .put(AttributeKey.doubleKey("com.acme.double-key"), 1.1) + .put(AttributeKey.stringArrayKey("com.acme.string-array-key"), "value1", "value2") + .put(AttributeKey.booleanArrayKey("come.acme.bool-array-key"), true, false) + .put(AttributeKey.longArrayKey("come.acme.long-array-key"), 1L, 2L) + .put(AttributeKey.doubleArrayKey("come.acme.double-array-key"), 1.1, 2.2) + // Optionally omit initializing AttributeKey + .put("com.acme.string-key", "value") + .put("com.acme.bool-key", true) + .put("come.acme.long-key", 1L) + .put("come.acme.double-key", 1.1) + .put("come.acme.string-array-key", "value1", "value2") + .put("come.acme.bool-array-key", true, false) + .put("come.acme.long-array-key", 1L, 2L) + .put("come.acme.double-array-key", 1.1, 2.2) + .build(); + + // Attributes has a variety of methods for manipulating and reading data. + // Read an attribute key: + String shopIdValue = attributes.get(SHOP_ID); + // Inspect size: + int size = attributes.size(); + boolean isEmpty = attributes.isEmpty(); + // Convert to a map representation: + Map, Object> map = attributes.asMap(); + // Iterate through entries, printing each to the template: (): \n + attributes.forEach( + (attributeKey, value) -> + System.out.printf( + "%s (%s): %s%n", attributeKey.getKey(), attributeKey.getType(), value)); + // Convert to a builder, remove the com.acme.customer.id and any entry whose key starts with + // com.acme.shop, and build a new instance: + AttributesBuilder builder = attributes.toBuilder(); + builder.remove(CUSTOMER_ID); + builder.removeIf(attributeKey -> attributeKey.getKey().startsWith("com.acme.shop")); + Attributes trimmedAttributes = builder.build(); + } +} +``` + + +### OpenTelemetry + +[OpenTelemetry](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/OpenTelemetry.html) +is a holder for top-level API components which is convenient to pass to +instrumentation. + +`OpenTelemetry` consists of: + +- [TracerProvider](#tracerprovider): The API entry point for traces. +- [MeterProvider](#meterprovider): The API entry point for metrics. +- [LoggerProvider](#loggerprovider): The API entry point for logs. +- [ContextPropagators](#contextpropagators): The API entry point for context + propagation. + +The following code snippet explores `OpenTelemetry` API usage: + + + +```java +package otel; + +import io.opentelemetry.api.OpenTelemetry; +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.logs.LoggerProvider; +import io.opentelemetry.api.metrics.MeterProvider; +import io.opentelemetry.api.trace.TracerProvider; +import io.opentelemetry.context.propagation.ContextPropagators; + +public class OpenTelemetryUsage { + private static final Attributes WIDGET_RED_CIRCLE = Util.WIDGET_RED_CIRCLE; + + public static void openTelemetryUsage(OpenTelemetry openTelemetry) { + // Access TracerProvider, MeterProvider, LoggerProvider, ContextPropagators + TracerProvider tracerProvider = openTelemetry.getTracerProvider(); + MeterProvider meterProvider = openTelemetry.getMeterProvider(); + LoggerProvider loggerProvider = openTelemetry.getLogsBridge(); + ContextPropagators propagators = openTelemetry.getPropagators(); + } +} +``` + + +### GlobalOpenTelemetry + +[GlobalOpenTelemetry](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/GlobalOpenTelemetry.html) +holds a global singleton [OpenTelemetry](#opentelemetry) instance. + +Instrumentation should avoid using `GlobalOpenTelemetry`. Instead, accept +`OpenTelemetry` as an initialization argument and default to the +[Noop implementation](#noop-implementation) if not set. There is an exception to +this rule: the `OpenTelemetry` instance installed by the +[Java agent](/docs/zero-code/java/agent/) is available via +`GlobalOpenTelemetry`. Users with additional manual instrumentation are +encouraged to access it via `GlobalOpenTelemetry.get()`. + +`GlobalOpenTelemetry.get()` is guaranteed to always return the same result. If +`GlobalOpenTelemetry.get()` is called before `GlobalOpenTelemetry.set(..)`, +`GlobalOpenTelemetry` is set to the noop implementation and future calls to +`GlobalOpenTelemetry.set(..)` throw an exception. Therefore, it's critical to +call `GlobalOpenTelemetry.set(..)` as early in the application lifecycle as +possible, and before `GlobalOpenTelemetry.get()` is called by any +instrumentation. This guarantee surfaces initialization ordering issues: calling +`GlobalOpenTelemetry.set()` too late (i.e. after instrumentation has called +`GlobalOpenTelemetry.get()`) triggers an exception rather than silently failing. + +If [autoconfigure](../configuration/#zero-code-sdk-autoconfigure) is present, +`GlobalOpenTelemetry` can be automatically initialized by setting +`-Dotel.java.global-autoconfigure.enabled=true` (or via env var +`export OTEL_JAVA_GLOBAL_AUTOCONFIGURE_ENABLED=true`). When enabled, the first +call to `GlobalOpenTelemetry.get()` triggers autoconfiguration and calls +`GlobalOpenTelemetry.set(..)` with the resulting `OpenTelemetry` instance. + +The following code snippet explores `GlobalOpenTelemetry` API context +propagation: + + + +```java +package otel; + +import io.opentelemetry.api.GlobalOpenTelemetry; +import io.opentelemetry.api.OpenTelemetry; + +public class GlobalOpenTelemetryUsage { + + public static void openTelemetryUsage(OpenTelemetry openTelemetry) { + // Set the GlobalOpenTelemetry instance as early in the application lifecycle as possible + // Set must only be called once. Calling multiple times raises an exception. + GlobalOpenTelemetry.set(openTelemetry); + + // Get the GlobalOpenTelemetry instance. + openTelemetry = GlobalOpenTelemetry.get(); + } +} +``` + + +### TracerProvider + +[TracerProvider](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/trace/TracerProvider.html) +is the API entry point for traces and provides [Tracers](#tracer). See +[providers and scopes](#providers-and-scopes) for information on providers and +scopes. + +#### Tracer + +[Tracer](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/trace/Tracer.html) +is used to [record spans](#span) for an instrumentation scope. See +[providers and scopes](#providers-and-scopes) for information on providers and +scopes. + +#### Span + +[SpanBuilder](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/trace/SpanBuilder.html) +and +[Span](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/trace/Span.html) +are used to construct and record data to spans. + +`SpanBuilder` is used to add data to a span before starting it by calling +`Span startSpan()`. Data can be added / updated after starting by calling +various `Span` update methods. The data provided to `SpanBuilder` before +starting is provided as an input to [Samplers](../sdk/#sampler). + +The following code snippet explores `SpanBuilder` / `Span` API usage: + + + +```java +package otel; + +import static io.opentelemetry.context.Context.current; + +import io.opentelemetry.api.common.AttributeKey; +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.api.trace.SpanKind; +import io.opentelemetry.api.trace.StatusCode; +import io.opentelemetry.api.trace.Tracer; +import java.util.Arrays; + +public class SpanUsage { + private static final Attributes WIDGET_RED_CIRCLE = Util.WIDGET_RED_CIRCLE; + + public static void spanUsage(Tracer tracer) { + // Get a span builder by providing the span name + Span span = + tracer + .spanBuilder("span name") + // Set span kind + .setSpanKind(SpanKind.INTERNAL) + // Set attributes + .setAttribute(AttributeKey.stringKey("com.acme.string-key"), "value") + .setAttribute(AttributeKey.booleanKey("com.acme.bool-key"), true) + .setAttribute(AttributeKey.longKey("com.acme.long-key"), 1L) + .setAttribute(AttributeKey.doubleKey("com.acme.double-key"), 1.1) + .setAttribute( + AttributeKey.stringArrayKey("com.acme.string-array-key"), + Arrays.asList("value1", "value2")) + .setAttribute( + AttributeKey.booleanArrayKey("come.acme.bool-array-key"), + Arrays.asList(true, false)) + .setAttribute( + AttributeKey.longArrayKey("come.acme.long-array-key"), Arrays.asList(1L, 2L)) + .setAttribute( + AttributeKey.doubleArrayKey("come.acme.double-array-key"), Arrays.asList(1.1, 2.2)) + // Optionally omit initializing AttributeKey + .setAttribute("com.acme.string-key", "value") + .setAttribute("com.acme.bool-key", true) + .setAttribute("come.acme.long-key", 1L) + .setAttribute("come.acme.double-key", 1.1) + .setAllAttributes(WIDGET_RED_CIRCLE) + // Uncomment to optionally explicitly set the parent span context. If omitted, the + // span's parent will be set using Context.current(). + // .setParent(parentContext) + // Uncomment to optionally add links. + // .addLink(linkContext, linkAttributes) + // Start the span + .startSpan(); + + // Check if span is recording before computing additional data + if (span.isRecording()) { + // Update the span name with information not available when starting + span.updateName("new span name"); + + // Add additional attributes not available when starting + span.setAttribute("com.acme.string-key2", "value"); + + // Add additional span links not available when starting + span.addLink(exampleLinkContext()); + // optionally include attributes on the link + span.addLink(exampleLinkContext(), WIDGET_RED_CIRCLE); + + // Add span events + span.addEvent("my-event"); + // optionally include attributes on the event + span.addEvent("my-event", WIDGET_RED_CIRCLE); + + // Record exception, syntactic sugar for a span event with a specific shape + span.recordException(new RuntimeException("error")); + + // Set the span status + span.setStatus(StatusCode.OK, "status description"); + } + + // Finally, end the span + span.end(); + } + + /** Return a dummy link context. */ + private static SpanContext exampleLinkContext() { + return Span.fromContext(current()).getSpanContext(); + } +} +``` + + +Span parenting is an important aspect of tracing. Each span has an optional +parent. By collecting all the spans in a trace and following each span's parent, +we can construct a hierarchy. The span APIs are built on top of +[context](#context), which allows span context to be implicitly passed around an +application and across threads. When a span is created, its parent is set to the +whatever span is present in `Context.current()` unless there is no span or the +context is explicitly overridden. + +Most of the context API usage guidance applies to spans. Span context is +propagated across application boundaries with the +[W3CTraceContextPropagator](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/trace/propagation/W3CTraceContextPropagator.html) +and other [TextMapPropagators](../sdk/#textmappropagator). + +The following code snippet explores `Span` API context propagation: + + + +```java +package otel; + +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.api.trace.Tracer; +import io.opentelemetry.context.Context; +import io.opentelemetry.context.Scope; + +public class SpanAndContextUsage { + private final Tracer tracer; + + SpanAndContextUsage(Tracer tracer) { + this.tracer = tracer; + } + + public void nestedSpanUsage() { + // Start a span. Since we don't call makeCurrent(), we must explicitly call setParent on + // children. Wrap code in try / finally to ensure we end the span. + Span span = tracer.spanBuilder("span").startSpan(); + try { + // Start a child span, explicitly setting the parent. + Span childSpan = + tracer + .spanBuilder("span child") + // Explicitly set parent. + .setParent(span.storeInContext(Context.current())) + .startSpan(); + // Call makeCurrent(), adding childSpan to Context.current(). Spans created inside the scope + // will have their parent set to childSpan. + try (Scope childSpanScope = childSpan.makeCurrent()) { + // Call another method which creates a span. The span's parent will be childSpan since it is + // started in the childSpan scope. + doWork(); + } finally { + childSpan.end(); + } + } finally { + span.end(); + } + } + + private int doWork() { + Span doWorkSpan = tracer.spanBuilder("doWork").startSpan(); + try (Scope scope = doWorkSpan.makeCurrent()) { + int result = 0; + for (int i = 0; i < 10; i++) { + result += i; + } + return result; + } finally { + doWorkSpan.end(); + } + } +} +``` + + +### MeterProvider + +[MeterProvider](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/MeterProvider.html) +is the API entry point for metrics and provides [Meters](#meter). See +[providers and scopes](#providers-and-scopes) for information on providers and +scopes. + +#### Meter + +[Meter](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/Meter.html) +is used to obtain instruments for a particular +[instrumentation scope](#providers-and-scopes). See +[providers and scopes](#providers-and-scopes) for information on providers and +scopes. There are a variety of instruments, each with different semantics and +default behavior in the SDK. It's important to choose the right instrument for +each particular use case: + +| Instrument | Sync or Async | Description | Example | Default SDK Aggregation | +| ------------------------------------------- | ------------- | ---------------------------------------------------------------------------------- | ------------------------------------------------------- | ---------------------------------------------------------------------------------------------- | +| [Counter](#counter) | sync | Record monotonic (positive) values. | Record user logins | [sum (monotonic=true)](/docs/specs/otel/metrics/sdk/#sum-aggregation) | +| [Async Counter](#async-counter) | async | Observe monotonic sums. | Observe number of classes loaded in the JVM | [sum (monotonic=true)](/docs/specs/otel/metrics/sdk/#sum-aggregation) | +| [UpDownCounter](#updowncounter) | sync | Record non-monotonic (positive and negative) values. | Record when items are added to and removed from a queue | [sum (monotonic=false)](/docs/specs/otel/metrics/sdk/#sum-aggregation) | +| [Async UpDownCounter](#async-updowncounter) | async | Observe non-monotonic (positive and negative) sums. | Observe JVM memory pool usage | [sum (monotonic=false)](/docs/specs/otel/metrics/sdk/#sum-aggregation) | +| [Histogram](#histogram) | sync | Record monotonic (positive) values where the distribution is important. | Record duration of HTTP requests processed by server | [ExplicitBucketHistogram](/docs/specs/otel/metrics/sdk/#explicit-bucket-histogram-aggregation) | +| [Gauge](#gauge) | sync | Record the latest value where spatial re-aggregation does not make sense **[1]**. | Record temperature | [LastValue](/docs/specs/otel/metrics/sdk/#last-value-aggregation) | +| [Async Gauge](#async-gauge) | async | Observe the latest value where spatial re-aggregation does not make sense **[1]**. | Observe CPU utilization | [LastValue](/docs/specs/otel/metrics/sdk/#last-value-aggregation) | + +**[1]**: Spatial re-aggregation is the process of merging attribute streams by +dropping attributes which are not needed. For example, given series with +attributes `{"color": "red", "shape": "square"}`, +`{"color": "blue", "shape": "square"}`, you can perform spatial re-aggregation +by dropping the `color` attribute, and merging the series where the attributes +are equal after dropping `color`. Most aggregations have a useful spatial +aggregation merge function (i.e. sums are summed together), but gauges +aggregated by the `LastValue` aggregation are the exception. For example, +suppose the series mentioned previously are tracking the temperature of widgets. +How do you merge the series when you drop the `color` attribute? There is no +good answer besides flipping a coin and selecting a random value. + +The instrument APIs have share a variety of features: + +- Created using the builder pattern. +- Required instrument name. +- Optional unit and description. +- Record values which are `long` or `double`, which is configured via the + builder. + +See +[metric guidelines](http://localhost:1313/docs/specs/semconv/general/metrics/#general-guidelines) +for details on metric naming and units. + +See +[guidelines for instrumentation library authors](/docs/specs/otel/metrics/supplementary-guidelines/#guidelines-for-instrumentation-library-authors) +for additional guidance on instrument selection. + +#### Counter + +[LongCounter](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/LongCounter.html) +and +[DoubleCounter](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/DoubleCounter.html) +are used to record monotonic (positive) values. + +The following code snippet explores counter API usage: + + + +```java +package otel; + +import static otel.Util.WIDGET_COLOR; +import static otel.Util.WIDGET_SHAPE; +import static otel.Util.computeWidgetColor; +import static otel.Util.computeWidgetShape; +import static otel.Util.customContext; + +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.metrics.LongCounter; +import io.opentelemetry.api.metrics.Meter; + +public class CounterUsage { + private static final Attributes WIDGET_RED_CIRCLE = Util.WIDGET_RED_CIRCLE; + + public static void counterUsage(Meter meter) { + // Construct a counter to record measurements that are always positive (monotonically + // increasing). + LongCounter counter = + meter + .counterBuilder("fully.qualified.counter") + .setDescription("A count of produced widgets") + .setUnit("{widget}") + // optionally change the type to double + // .ofDoubles() + .build(); + + // Record a measurement with no attributes or context. + // Attributes defaults to Attributes.empty(), context to Context.current(). + counter.add(1L); + + // Record a measurement with attributes, using pre-allocated attributes whenever possible. + counter.add(1L, WIDGET_RED_CIRCLE); + // Sometimes, attributes must be computed using application context. + counter.add( + 1L, Attributes.of(WIDGET_SHAPE, computeWidgetShape(), WIDGET_COLOR, computeWidgetColor())); + + // Record a measurement with attributes, and context. + // Most users will opt to omit the context argument, preferring the default Context.current(). + counter.add(1L, WIDGET_RED_CIRCLE, customContext()); + } +} +``` + + +#### Async Counter + +[ObservableLongCounter](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/ObservableLongCounter.htmll) +and +[ObservableDoubleCounter](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/ObservableDoubleCounter.html) +are used to observe monotonic (positive) sums. + +The following code snippet explores async counter API usage: + + + +```java +package otel; + +import static otel.Util.WIDGET_COLOR; +import static otel.Util.WIDGET_SHAPE; +import static otel.Util.computeWidgetColor; +import static otel.Util.computeWidgetShape; + +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.metrics.Meter; +import io.opentelemetry.api.metrics.ObservableLongCounter; +import java.util.concurrent.atomic.AtomicLong; + +public class AsyncCounterUsage { + // Pre-allocate attributes whenever possible + private static final Attributes WIDGET_RED_CIRCLE = Util.WIDGET_RED_CIRCLE; + + public static void asyncCounterUsage(Meter meter) { + AtomicLong widgetCount = new AtomicLong(); + + // Construct an async counter to observe an existing counter in a callback + ObservableLongCounter asyncCounter = + meter + .counterBuilder("fully.qualified.counter") + .setDescription("A count of produced widgets") + .setUnit("{widget}") + // Uncomment to optionally change the type to double + // .ofDoubles() + .buildWithCallback( + // the callback is invoked when a MetricReader reads metrics + observableMeasurement -> { + long currentWidgetCount = widgetCount.get(); + + // Record a measurement with no attributes. + // Attributes defaults to Attributes.empty(). + observableMeasurement.record(currentWidgetCount); + + // Record a measurement with attributes, using pre-allocated attributes whenever + // possible. + observableMeasurement.record(currentWidgetCount, WIDGET_RED_CIRCLE); + // Sometimes, attributes must be computed using application context. + observableMeasurement.record( + currentWidgetCount, + Attributes.of( + WIDGET_SHAPE, computeWidgetShape(), WIDGET_COLOR, computeWidgetColor())); + }); + + // Optionally close the counter to unregister the callback when required + asyncCounter.close(); + } +} +``` + + +#### UpDownCounter + +[LongUpDownCounter](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/LongUpDownCounter.html) +and +[DoubleUpDownCounter](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/DoubleUpDownCounter.html) +are used to record non-monotonic (positive and negative) values. + +The following code snippet explores updowncounter API usage: + + + +```java +package otel; + +import static otel.Util.WIDGET_COLOR; +import static otel.Util.WIDGET_SHAPE; +import static otel.Util.computeWidgetColor; +import static otel.Util.computeWidgetShape; +import static otel.Util.customContext; + +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.metrics.LongUpDownCounter; +import io.opentelemetry.api.metrics.Meter; + +public class UpDownCounterUsage { + + private static final Attributes WIDGET_RED_CIRCLE = Util.WIDGET_RED_CIRCLE; + + public static void usage(Meter meter) { + // Construct an updowncounter to record measurements that go up and down. + LongUpDownCounter upDownCounter = + meter + .upDownCounterBuilder("fully.qualified.updowncounter") + .setDescription("Current length of widget processing queue") + .setUnit("{widget}") + // Uncomment to optionally change the type to double + // .ofDoubles() + .build(); + + // Record a measurement with no attributes or context. + // Attributes defaults to Attributes.empty(), context to Context.current(). + upDownCounter.add(1L); + + // Record a measurement with attributes, using pre-allocated attributes whenever possible. + upDownCounter.add(-1L, WIDGET_RED_CIRCLE); + // Sometimes, attributes must be computed using application context. + upDownCounter.add( + -1L, Attributes.of(WIDGET_SHAPE, computeWidgetShape(), WIDGET_COLOR, computeWidgetColor())); + + // Record a measurement with attributes, and context. + // Most users will opt to omit the context argument, preferring the default Context.current(). + upDownCounter.add(1L, WIDGET_RED_CIRCLE, customContext()); + } +} +``` + + +#### Async UpDownCounter + +[ObservableLongUpDownCounter](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/ObservableLongUpDownCounter.html) +and +[ObservableDoubleUpDownCounter](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/ObservableDoubleUpDownCounter.html) +are used to observe non-monotonic (positive and negative) sums. + +The following code snippet explores async updowncounter API usage: + + + +```java +package otel; + +import static otel.Util.WIDGET_COLOR; +import static otel.Util.WIDGET_SHAPE; +import static otel.Util.computeWidgetColor; +import static otel.Util.computeWidgetShape; + +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.metrics.Meter; +import io.opentelemetry.api.metrics.ObservableLongUpDownCounter; +import java.util.concurrent.atomic.AtomicLong; + +public class AsyncUpDownCounterUsage { + private static final Attributes WIDGET_RED_CIRCLE = Util.WIDGET_RED_CIRCLE; + + public static void asyncUpDownCounterUsage(Meter meter) { + AtomicLong queueLength = new AtomicLong(); + + // Construct an async updowncounter to observe an existing up down counter in a callback + ObservableLongUpDownCounter asyncUpDownCounter = + meter + .upDownCounterBuilder("fully.qualified.updowncounter") + .setDescription("Current length of widget processing queue") + .setUnit("{widget}") + // Uncomment to optionally change the type to double + // .ofDoubles() + .buildWithCallback( + // the callback is invoked when a MetricReader reads metrics + observableMeasurement -> { + long currentWidgetCount = queueLength.get(); + + // Record a measurement with no attributes. + // Attributes defaults to Attributes.empty(). + observableMeasurement.record(currentWidgetCount); + + // Record a measurement with attributes, using pre-allocated attributes whenever + // possible. + observableMeasurement.record(currentWidgetCount, WIDGET_RED_CIRCLE); + // Sometimes, attributes must be computed using application context. + observableMeasurement.record( + currentWidgetCount, + Attributes.of( + WIDGET_SHAPE, computeWidgetShape(), WIDGET_COLOR, computeWidgetColor())); + }); + + // Optionally close the counter to unregister the callback when required + asyncUpDownCounter.close(); + } +} +``` + + +#### Histogram + +[DoubleHistogram](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/DoubleHistogram.html) +and +[LongHistogram](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/LongHistogram.html) +are used to record monotonic (positive) values where the distribution is +important. + +The following code snippet explores histogram API usage: + + + +```java +package otel; + +import static otel.Util.WIDGET_COLOR; +import static otel.Util.WIDGET_SHAPE; +import static otel.Util.computeWidgetColor; +import static otel.Util.computeWidgetShape; +import static otel.Util.customContext; + +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.metrics.DoubleHistogram; +import io.opentelemetry.api.metrics.Meter; + +public class HistogramUsage { + private static final Attributes WIDGET_RED_CIRCLE = Util.WIDGET_RED_CIRCLE; + + public static void histogramUsage(Meter meter) { + // Construct a histogram to record measurements where the distribution is important. + DoubleHistogram histogram = + meter + .histogramBuilder("fully.qualified.histogram") + .setDescription("Length of time to process a widget") + .setUnit("s") + // Uncomment to optionally provide advice on useful default explicit bucket boundaries + // .setExplicitBucketBoundariesAdvice(Arrays.asList(1.0, 2.0, 3.0)) + // Uncomment to optionally change the type to long + // .ofLongs() + .build(); + + // Record a measurement with no attributes or context. + // Attributes defaults to Attributes.empty(), context to Context.current(). + histogram.record(1.1); + + // Record a measurement with attributes, using pre-allocated attributes whenever possible. + histogram.record(2.2, WIDGET_RED_CIRCLE); + // Sometimes, attributes must be computed using application context. + histogram.record( + 3.2, Attributes.of(WIDGET_SHAPE, computeWidgetShape(), WIDGET_COLOR, computeWidgetColor())); + + // Record a measurement with attributes, and context. + // Most users will opt to omit the context argument, preferring the default Context.current(). + histogram.record(4.4, WIDGET_RED_CIRCLE, customContext()); + } +} +``` + + +#### Gauge + +[DoubleGauge](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/DoubleGauge.html) +and +[LongGauge](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/LongGauge.html) +are used to record the latest value where spatial re-aggregation does not make +sense. + +The following code snippet explores gauge API usage: + + + +```java +package otel; + +import static otel.Util.WIDGET_COLOR; +import static otel.Util.WIDGET_SHAPE; +import static otel.Util.computeWidgetColor; +import static otel.Util.computeWidgetShape; +import static otel.Util.customContext; + +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.metrics.DoubleGauge; +import io.opentelemetry.api.metrics.Meter; + +public class GaugeUsage { + private static final Attributes WIDGET_RED_CIRCLE = Util.WIDGET_RED_CIRCLE; + + public static void gaugeUsage(Meter meter) { + // Construct a gauge to record measurements as they occur, which cannot be spatially + // re-aggregated. + DoubleGauge gauge = + meter + .gaugeBuilder("fully.qualified.gauge") + .setDescription("The current temperature of the widget processing line") + .setUnit("K") + // Uncomment to optionally change the type to long + // .ofLongs() + .build(); + + // Record a measurement with no attributes or context. + // Attributes defaults to Attributes.empty(), context to Context.current(). + gauge.set(273.0); + + // Record a measurement with attributes, using pre-allocated attributes whenever possible. + gauge.set(273.0, WIDGET_RED_CIRCLE); + // Sometimes, attributes must be computed using application context. + gauge.set( + 273.0, + Attributes.of(WIDGET_SHAPE, computeWidgetShape(), WIDGET_COLOR, computeWidgetColor())); + + // Record a measurement with attributes, and context. + // Most users will opt to omit the context argument, preferring the default Context.current(). + gauge.set(1L, WIDGET_RED_CIRCLE, customContext()); + } +} +``` + + +#### Async Gauge + +[ObservableDoubleGauge](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/ObservableDoubleGauge.html) +and +[ObservableLongGauge](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/ObservableLongGauge.html) +are used to observe the latest value where spatial re-aggregation does not make +sense. + +The following code snippet explores async gauge API usage: + + + +```java +package otel; + +import static otel.Util.WIDGET_COLOR; +import static otel.Util.WIDGET_SHAPE; +import static otel.Util.computeWidgetColor; +import static otel.Util.computeWidgetShape; + +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.metrics.Meter; +import io.opentelemetry.api.metrics.ObservableDoubleGauge; +import java.util.concurrent.atomic.AtomicReference; + +public class AsyncGaugeUsage { + private static final Attributes WIDGET_RED_CIRCLE = Util.WIDGET_RED_CIRCLE; + + public static void asyncGaugeUsage(Meter meter) { + AtomicReference processingLineTemp = new AtomicReference<>(273.0); + + // Construct an async counter to observe an existing counter in a callback + ObservableDoubleGauge asyncGauge = + meter + .gaugeBuilder("fully.qualified.gauge") + .setDescription("The current temperature of the widget processing line") + .setUnit("K") + // Uncomment to optionally change the type to long + // .ofLongs() + .buildWithCallback( + // the callback is invoked when a MetricReader reads metrics + observableMeasurement -> { + double currentWidgetCount = processingLineTemp.get(); + + // Record a measurement with no attributes. + // Attributes defaults to Attributes.empty(). + observableMeasurement.record(currentWidgetCount); + + // Record a measurement with attributes, using pre-allocated attributes whenever + // possible. + observableMeasurement.record(currentWidgetCount, WIDGET_RED_CIRCLE); + // Sometimes, attributes must be computed using application context. + observableMeasurement.record( + currentWidgetCount, + Attributes.of( + WIDGET_SHAPE, computeWidgetShape(), WIDGET_COLOR, computeWidgetColor())); + }); + + // Optionally close the gauge to unregister the callback when required + asyncGauge.close(); + } +} +``` + + +### LoggerProvider + +[LoggerProvider](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/logs/LoggerProvider.html) +is the API entry point for logs and provides [Loggers](#logger). See +[providers and scopes](#providers-and-scopes) for information on providers and +scopes. + +{{% alert %}} {{% param logBridgeWarning %}} {{% /alert %}} + +#### Logger + +[Logger](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/logs/Logger.html) +is used to [emit log records](#logrecordbuilder) for an +[instrumentation scope](#providers-and-scopes). See +[providers and scopes](#providers-and-scopes) for information on providers and +scopes. + +#### LogRecordBuilder + +[LogRecordBuilder](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/logs/LogRecordBuilder.html) +is used to construct and emit log records. + +The following code snippet explores `LogRecordBuilder` API usage: + + + +```java +package otel; + +import io.opentelemetry.api.common.AttributeKey; +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.common.Value; +import io.opentelemetry.api.logs.Logger; +import io.opentelemetry.api.logs.Severity; +import java.util.Arrays; +import java.util.Map; +import java.util.concurrent.TimeUnit; + +public class LogRecordUsage { + private static final Attributes WIDGET_RED_CIRCLE = Util.WIDGET_RED_CIRCLE; + + public static void logRecordUsage(Logger logger) { + logger + .logRecordBuilder() + // Set body. Note, setBody(..) is called multiple times for demonstration purposes but only + // the last call is used. + // Set the body to a string, syntactic sugar for setBody(Value.of("log message")) + .setBody("log message") + // Optionally set the body to a Value to record arbitrarily complex structured data + .setBody(Value.of("log message")) + .setBody(Value.of(1L)) + .setBody(Value.of(1.1)) + .setBody(Value.of(true)) + .setBody(Value.of(new byte[] {'a', 'b', 'c'})) + .setBody(Value.of(Value.of("entry1"), Value.of("entry2"))) + .setBody( + Value.of( + Map.of( + "stringKey", + Value.of("entry1"), + "mapKey", + Value.of(Map.of("stringKey", Value.of("entry2")))))) + // Set severity + .setSeverity(Severity.DEBUG) + .setSeverityText("debug") + // Set timestamp + .setTimestamp(System.currentTimeMillis(), TimeUnit.MILLISECONDS) + // Optionally set the timestamp when the log was observed + .setObservedTimestamp(System.currentTimeMillis(), TimeUnit.MILLISECONDS) + // Set attributes + .setAttribute(AttributeKey.stringKey("com.acme.string-key"), "value") + .setAttribute(AttributeKey.booleanKey("com.acme.bool-key"), true) + .setAttribute(AttributeKey.longKey("com.acme.long-key"), 1L) + .setAttribute(AttributeKey.doubleKey("com.acme.double-key"), 1.1) + .setAttribute( + AttributeKey.stringArrayKey("com.acme.string-array-key"), + Arrays.asList("value1", "value2")) + .setAttribute( + AttributeKey.booleanArrayKey("come.acme.bool-array-key"), Arrays.asList(true, false)) + .setAttribute(AttributeKey.longArrayKey("come.acme.long-array-key"), Arrays.asList(1L, 2L)) + .setAttribute( + AttributeKey.doubleArrayKey("come.acme.double-array-key"), Arrays.asList(1.1, 2.2)) + .setAllAttributes(WIDGET_RED_CIRCLE) + // Uncomment to optionally explicitly set the context used to correlate with spans. If + // omitted, Context.current() is used. + // .setContext(context) + // Emit the log record + .emit(); + } +} +``` + + +### Noop implementation + +The `OpenTelemetry#noop()` method provides access to a noop implementation of +[OpenTelemetry](#opentelemetry) and all API components it provides access to. As +the name suggests, the noop implementation does nothing and is designed to have +no impact on performance. Instrumentation may see impact on performance even +when the noop is used if it is computing / allocating attribute values and other +data required to record the telemetry. The noop is a useful default instance of +`OpenTelemetry` when a user has not configured and installed a concrete +implementation such as the [SDK](../sdk/). + +The following code snippet explores `OpenTelemetry#noop()` API usage: + + + +```java +package otel; + +import static otel.Util.WIDGET_COLOR; +import static otel.Util.WIDGET_RED_CIRCLE; +import static otel.Util.WIDGET_SHAPE; + +import io.opentelemetry.api.OpenTelemetry; +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.logs.Logger; +import io.opentelemetry.api.logs.Severity; +import io.opentelemetry.api.metrics.DoubleGauge; +import io.opentelemetry.api.metrics.DoubleHistogram; +import io.opentelemetry.api.metrics.LongCounter; +import io.opentelemetry.api.metrics.LongUpDownCounter; +import io.opentelemetry.api.metrics.Meter; +import io.opentelemetry.api.trace.StatusCode; +import io.opentelemetry.api.trace.Tracer; + +public class NoopUsage { + private static final String SCOPE_NAME = "fully.qualified.name"; + + public static void noopUsage() { + // Access the noop OpenTelemetry instance + OpenTelemetry noopOpenTelemetry = OpenTelemetry.noop(); + + // Noop tracing + Tracer noopTracer = OpenTelemetry.noop().getTracer(SCOPE_NAME); + noopTracer + .spanBuilder("span name") + .startSpan() + .setAttribute(WIDGET_SHAPE, "square") + .setStatus(StatusCode.OK) + .addEvent("event-name", Attributes.builder().put(WIDGET_COLOR, "red").build()) + .end(); + + // Noop metrics + Attributes attributes = WIDGET_RED_CIRCLE; + Meter noopMeter = OpenTelemetry.noop().getMeter(SCOPE_NAME); + DoubleHistogram histogram = noopMeter.histogramBuilder("fully.qualified.histogram").build(); + histogram.record(1.0, attributes); + // counter + LongCounter counter = noopMeter.counterBuilder("fully.qualified.counter").build(); + counter.add(1, attributes); + // async counter + noopMeter + .counterBuilder("fully.qualified.counter") + .buildWithCallback(observable -> observable.record(10, attributes)); + // updowncounter + LongUpDownCounter upDownCounter = + noopMeter.upDownCounterBuilder("fully.qualified.updowncounter").build(); + // async updowncounter + noopMeter + .upDownCounterBuilder("fully.qualified.updowncounter") + .buildWithCallback(observable -> observable.record(10, attributes)); + upDownCounter.add(-1, attributes); + // gauge + DoubleGauge gauge = noopMeter.gaugeBuilder("fully.qualified.gauge").build(); + gauge.set(1.1, attributes); + // async gauge + noopMeter + .gaugeBuilder("fully.qualified.gauge") + .buildWithCallback(observable -> observable.record(10, attributes)); + + // Noop logs + Logger noopLogger = OpenTelemetry.noop().getLogsBridge().get(SCOPE_NAME); + noopLogger + .logRecordBuilder() + .setBody("log message") + .setAttribute(WIDGET_SHAPE, "square") + .setSeverity(Severity.INFO) + .emit(); + } +} +``` + + +### Semantic attributes + +The [semantic conventions](/docs/specs/semconv/) describe how to collect +telemetry in a standardized way for common operations. This includes an +[attribute registry](/docs/specs/semconv/attributes-registry/), which enumerates +definitions for all attributes referenced in the conventions, organized by +domain. The +[semantic-conventions-java](https://github.com/open-telemetry/semantic-conventions-java) +project generates constants from the semantic conventions, which can be used to +help instrumentation conform: + +| Description | Artifact | +| -------------------------------------------------- | -------------------------------------------------------------------------------------------- | +| Generated code for stable semantic conventions | `io.opentelemetry.semconv:opentelemetry-semconv:{{% param vers.semconv %}}-alpha` | +| Generated code for incubating semantic conventions | `io.opentelemetry.semconv:opentelemetry-semconv-incubating:{{% param vers.semconv %}}-alpha` | + +{{% alert %}} While both `opentelemetry-semconv` and +`opentelemetry-semconv-incubating` include the `-alpha` suffix and are subject +to breaking changes, the intent is to stabilize `opentelemetry-semconv` and +leave the `-alpha` suffix on `opentelemetry-semconv-incubating` permanently. +Libraries can use `opentelemetry-semconv-incubating` for testing, but should not +include it as a dependency: since attributes may come and go from version to +version, including it as a dependency may expose end users to runtime errors +when transitive version conflicts occur. {{% /alert %}} + +The attribute constants generated from semantic conventions are instances of +`AttributeKey`, and can be used anywhere the OpenTelemetry API accepts +attributes. + +The following code snippet explores semantic convention attribute API usage: + + + +```java +package otel; + +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.semconv.HttpAttributes; +import io.opentelemetry.semconv.ServerAttributes; +import io.opentelemetry.semconv.incubating.HttpIncubatingAttributes; + +public class SemanticAttributesUsage { + public static void semanticAttributesUsage() { + // Semantic attributes are organized by top-level domain and whether they are stable or + // incubating. + // For example: + // - stable attributes starting with http.* are in the HttpAttributes class. + // - stable attributes starting with server.* are in the ServerAttributes class. + // - incubating attributes starting with http.* are in the HttpIncubatingAttributes class. + // Attribute keys which define an enumeration of values are accessible in an inner + // {AttributeKey}Values class. + // For example, the enumeration of http.request.method values is available in the + // HttpAttributes.HttpRequestMethodValues class. + Attributes attributes = + Attributes.builder() + .put(HttpAttributes.HTTP_REQUEST_METHOD, HttpAttributes.HttpRequestMethodValues.GET) + .put(HttpAttributes.HTTP_ROUTE, "/users/:id") + .put(ServerAttributes.SERVER_ADDRESS, "example") + .put(ServerAttributes.SERVER_PORT, 8080L) + .put(HttpIncubatingAttributes.HTTP_RESPONSE_BODY_SIZE, 1024) + .build(); + } +} +``` + + +### Baggage + +[Baggage](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/baggage/Baggage.html) +is a bundle of application defined key-value pairs associated with a distributed +request or workflow execution. Baggage keys and values are strings, and values +have optional string metadata. Telemetry can be enriched with data from baggage +by configuring the [SDK](../sdk/) to add entries as attributes to spans, +metrics, and log records. The baggage API is built on top of +[context](#context), which allows span context to be implicitly passed around an +application and across threads. Most of the context API usage guidance applies +to baggage. + +Baggage is propagated across application boundaries with the +[W3CBaggagePropagator](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/baggage/propagation/W3CBaggagePropagator.html) +(see [TextMapPropagator](../sdk/#textmappropagator) for details). + +The following code snippet explores `Baggage` API usage: + + + +```java +package otel; + +import static io.opentelemetry.context.Context.current; + +import io.opentelemetry.api.baggage.Baggage; +import io.opentelemetry.api.baggage.BaggageEntry; +import io.opentelemetry.api.baggage.BaggageEntryMetadata; +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.context.Scope; +import java.util.Map; +import java.util.stream.Collectors; + +public class BaggageUsage { + private static final Attributes WIDGET_RED_CIRCLE = Util.WIDGET_RED_CIRCLE; + + public static void baggageUsage() { + // Access current baggage with Baggage.current() + // output => context baggage: {} + Baggage currentBaggage = Baggage.current(); + System.out.println("current baggage: " + asString(currentBaggage)); + // ...or from a Context + currentBaggage = Baggage.fromContext(current()); + + // Baggage has a variety of methods for manipulating and reading data. + // Convert to builder and add entries: + Baggage newBaggage = + Baggage.current().toBuilder() + .put("shopId", "abc123") + .put("shopName", "opentelemetry-demo", BaggageEntryMetadata.create("metadata")) + .build(); + // ...or uncomment to start from empty + // newBaggage = Baggage.empty().toBuilder().put("shopId", "abc123").build(); + // output => new baggage: {shopId=abc123(), shopName=opentelemetry-demo(metadata)} + System.out.println("new baggage: " + asString(newBaggage)); + // Read an entry: + String shopIdValue = newBaggage.getEntryValue("shopId"); + // Inspect size: + int size = newBaggage.size(); + boolean isEmpty = newBaggage.isEmpty(); + // Convert to map representation: + Map map = newBaggage.asMap(); + // Iterate through entries: + newBaggage.forEach((s, baggageEntry) -> {}); + + // The current baggage still doesn't contain the new entries + // output => context baggage: {} + System.out.println("current baggage: " + asString(Baggage.current())); + + // Calling Baggage.makeCurrent() sets Baggage.current() to the baggage until the scope is + // closed, upon which Baggage.current() is restored to the state prior to when + // Baggage.makeCurrent() was called. + try (Scope scope = newBaggage.makeCurrent()) { + // The current baggage now contains the added value + // output => context baggage: {shopId=abc123(), shopName=opentelemetry-demo(metadata)} + System.out.println("current baggage: " + asString(Baggage.current())); + } + + // The current baggage no longer contains the new entries: + // output => context baggage: {} + System.out.println("current baggage: " + asString(Baggage.current())); + } + + private static String asString(Baggage baggage) { + return baggage.asMap().entrySet().stream() + .map( + entry -> + String.format( + "%s=%s(%s)", + entry.getKey(), + entry.getValue().getValue(), + entry.getValue().getMetadata().getValue())) + .collect(Collectors.joining(", ", "{", "}")); + } +} +``` + + +## Incubating API + +The `io.opentelemetry:opentelemetry-api-incubator:{{% param vers.otel %}}-alpha` +artifact contains experimental trace, metric, log, and context APIs which. +Incubating APIs may have breaking API changes in minor releases. Often, these +represent experimental specification features or API designs we want to vet with +user feedback before committing to. We encourage users to try these APIs and +open issues with any feedback (positive or negative). Libraries should not +depend on the incubating APIs, since users may be exposed to runtime errors when +transitive version conflicts occur. + +See +[incubator README](https://github.com/open-telemetry/opentelemetry-java/tree/main/api/incubator) +for available APIs and sample usage. diff --git a/content/en/docs/languages/java/api.md b/content/en/docs/languages/java/api.md index 5a77f07f940e..8c8e8f079851 100644 --- a/content/en/docs/languages/java/api.md +++ b/content/en/docs/languages/java/api.md @@ -1,6 +1,6 @@ --- -title: API reference -linkTitle: API +title: Javadoc API reference +linkTitle: Javadoc redirect: https://javadoc.io/doc/io.opentelemetry manualLinkTarget: _blank _build: { render: link } diff --git a/content/en/docs/languages/java/configuration.md b/content/en/docs/languages/java/configuration.md index f73a996a8786..5668297caa6d 100644 --- a/content/en/docs/languages/java/configuration.md +++ b/content/en/docs/languages/java/configuration.md @@ -1,7 +1,7 @@ --- title: Configure the SDK linkTitle: Configure the SDK -weight: 12 +weight: 13 aliases: [config] # prettier-ignore cSpell:ignore: authservice autoconfigured blrp Customizer Dotel ignore LOWMEMORY myservice ottrace PKCS retryable tracepropagators @@ -11,7 +11,7 @@ cSpell:ignore: authservice autoconfigured blrp Customizer Dotel ignore LOWMEMORY The [SDK](../sdk/) is the built-in reference implementation of the -[API](../instrumentation/), processing and exporting telemetry produced by +[API](../api-components/), processing and exporting telemetry produced by instrumentation API calls. Configuring the SDK to process and export appropriately is an essential step to integrating OpenTelemetry into an application. diff --git a/content/en/docs/languages/java/getting-started.md b/content/en/docs/languages/java/getting-started.md index bb4078b15cfd..69fd4a79dedd 100644 --- a/content/en/docs/languages/java/getting-started.md +++ b/content/en/docs/languages/java/getting-started.md @@ -1,5 +1,5 @@ --- -title: Getting Started +title: Getting Started by Example description: Get telemetry for your app in less than 5 minutes! weight: 10 --- diff --git a/content/en/docs/languages/java/instrumentation.md b/content/en/docs/languages/java/instrumentation.md index f106bfc12bcc..c08589bf13d6 100644 --- a/content/en/docs/languages/java/instrumentation.md +++ b/content/en/docs/languages/java/instrumentation.md @@ -1,1102 +1,203 @@ --- -title: Instrumentation +title: Instrumentation ecosystem aliases: - /docs/java/getting_started - /docs/java/manual_instrumentation - manual - manual_instrumentation -weight: 20 -description: Manual instrumentation for OpenTelemetry Java -# prettier-ignore -cSpell:ignore: Autowired customizer logback loggable multivalued rolldice springframework + - libraries +weight: 10 +description: Instrumentation ecosystem in OpenTelemetry Java +cSpell:ignore: Logback logback --- -{{% docs/languages/instrumentation-intro %}} +Instrumentation records telemetry using the [API](../api-components/). The +[SDK](../sdk/) is the built-in reference implementation of the API, and is +[configured](../configuration/) to process and export the telemetry produced by +instrumentation API calls. This page discusses the OpenTelemetry ecosystem in +OpenTelemetry Java, including resources for end users and cross-cutting +instrumentation topics: + +- [Instrumentation categories](#instrumentation-categories): There are a variety + of categories of instrumentation addressing different use cases and + installation patterns. +- [Context propagation](#context-propagation): Context propagation provides + correlation between traces, metrics, and logs, allowing the signals to + complement each other. +- [Semantic conventions](#semantic-conventions): The semantic conventions define + how to produce telemetry for standard operations. +- [Log instrumentation](#log-instrumentation): The semantic conventions define + how to produce telemetry for standard operations. + +{{% alert %}} While [instrumentation categories](#instrumentation-categories) +enumerates several options for instrumenting an application, we recommend users +start with the [Java agent](#zero-code-java-agent). The Java agent has a simple +installation process, and automatically detects and installs instrumentation +from a large library. {{% /alert %}} + +## Instrumentation categories + +There are several categories of instrumentation: + +- [Zero-code: Java agent](#zero-code-java-agent) is a form of zero-code + instrumentation **[1]** that dynamically manipulates application bytecode. +- [Zero-code: Spring Boot starter](#zero-code-spring-boot-starter) is a form of + zero-code instrumentation **[1]** that leverages spring autoconfigure to + install [library instrumentation](#library-instrumentation). +- [Library instrumentation](#library-instrumentation) wraps or uses extension + points to instrument a library, requiring users to install and/or adapt + library usage. +- [Native instrumentation](#native-instrumentation) is built directly into + libraries and frameworks. +- [Manual instrumentation](#manual-instrumentation) is written by application + authors, and typically specific to the application domain. +- [Shims](#shims) bridge data from one observability library to another, + typically _from_ some library into OpenTelemetry. + +**[1]**: Zero-code instrumentation is installed automatically based on detected +libraries / frameworks. + +The +[opentelemetry-java-instrumentation](https://github.com/open-telemetry/opentelemetry-java-instrumentation) +project contains the source code for Java agent, Spring Boot starter, and +Library instrumentation. + +### Zero-code: Java agent + +The Java agent is a form of zero-code +[automatic instrumentation](/docs/specs/otel/glossary/#automatic-instrumentation) +that dynamically manipulates application bytecode. + +For a list of libraries instrumented by the Java agent, see the +"Auto-instrumented versions" column on +[supported libraries](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/docs/supported-libraries.md). + +See [Java agent](/docs/zero-code/java/agent/) for more details. + +### Zero-code: Spring Boot starter + +The Spring Boot starter is a form of zero-code +[automatic instrumentation](/docs/specs/otel/glossary/#automatic-instrumentation) +that leverages spring autoconfigure to install +[library instrumentation](#library-instrumentation). + +See [Spring Boot starter](/docs/zero-code/java/spring-boot-starter/) for +details. + +### Library instrumentation + +[Library instrumentation](/docs/specs/otel/glossary/#instrumentation-library) +wraps or uses extension points to instrument a library, requiring users to +install and/or adapt library usage. + +For a list of instrumentation libraries, see the "Standalone Library +Instrumentation" column on +[supported libraries](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/docs/supported-libraries.md). + +### Native instrumentation + +[Native instrumentation](/docs/specs/otel/glossary/#natively-instrumented) is +built directly into libraries or frameworks. OpenTelemetry encourages library +authors to add native instrumentation using the [API](../api-components/). In +the long term, we hope the native instrumentation becomes the norm, and view the +instrumentation maintained by OpenTelemetry in +[opentelemetry-java-instrumentation](https://github.com/open-telemetry/opentelemetry-java-instrumentation) +as a temporary means of filling the gap. + +{{% docs/languages/native-libraries "java" %}} + +### Manual instrumentation + +[Manual instrumentation](/docs/specs/otel/glossary/#manual-instrumentation) is +written by application authors, and typically specific to the application +domain. + +### Shims + +A shim is instrumentation that bridges data from one observability library to +another, typically _from_ some library into OpenTelemetry. + +Shims maintained in the OpenTelemetry Java ecosystem: + +| Description | Documentation | Signal(s) | Artifact | +| ------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------- | +| Bridge [OpenTracing](https://opentracing.io/) into OpenTelemetry | [README](https://github.com/open-telemetry/opentelemetry-java/tree/main/opentracing-shim) | Traces | `io.opentelemetry:opentelemetry-opentracing-shim:{{% param vers.otel %}}` | +| Bridge [Opencensus](https://opencensus.io/) into OpenTelemetry | [README](https://github.com/open-telemetry/opentelemetry-java/tree/main/opencensus-shim) | Traces, Metrics | `io.opentelemetry:opentelemetry-opencensus-shim:{{% param vers.otel %}}-alpha` | +| Bridge [Micrometer](https://micrometer.io/) into OpenTelemetry | [README](https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation/micrometer/micrometer-1.5/library) | Metrics | `io.opentelemetry.instrumentation:opentelemetry-micrometer-1.5:{{% param vers.instrumentation %}}-alpha` | +| Bridge [JMX](https://docs.oracle.com/javase/7/docs/technotes/guides/management/agent.html) into OpenTelemetry | [README](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/instrumentation/jmx-metrics/javaagent/README.md) | Metrics | `io.opentelemetry.instrumentation:opentelemetry-jmx-metrics:{{% param vers.instrumentation %}}-alpha` | +| Bridge OpenTelemetry into [Prometheus Java client](https://github.com/prometheus/client_java) | [README](https://github.com/open-telemetry/opentelemetry-java-contrib/tree/main/prometheus-client-bridge) | Metrics | `io.opentelemetry.contrib:opentelemetry-prometheus-client-bridge:{{% param vers.contrib %}}-alpha` | +| Bridge OpenTelemetry into [Micrometer](https://micrometer.io/) | [README](https://github.com/open-telemetry/opentelemetry-java-contrib/tree/main/micrometer-meter-provider) | Metrics | `io.opentelemetry.contrib:opentelemetry-micrometer-meter-provider:{{% param vers.contrib %}}-alpha` | +| Bridge [Log4j](https://logging.apache.org/log4j/2.x/index.html) into OpenTelemetry | [README](https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation/log4j/log4j-appender-2.17/library) | Logs | `io.opentelemetry.instrumentation:opentelemetry-log4j-appender-2.17:{{% param vers.instrumentation %}}-alpha` | +| Bridge [Logback](https://logback.qos.ch/) into OpenTelemetry | [README](https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation/logback/logback-appender-1.0/library) | Logs | `io.opentelemetry.instrumentation:opentelemetry-logback-appender-1.0:{{% param vers.instrumentation %}}-alpha` | +| Bridge OpenTelemetry context into [Log4j](https://logging.apache.org/log4j/2.x/index.html) | [README](https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation/log4j/log4j-context-data/log4j-context-data-2.17/library-autoconfigure) | Context | `io.opentelemetry.instrumentation:opentelemetry-log4j-context-data-2.17-autoconfigure:{{% param vers.instrumentation %}}-alpha` | +| Bridge OpenTelemetry context into [Logback](https://logback.qos.ch/) | [README](https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation/logback/logback-mdc-1.0/library) | Context | `io.opentelemetry.instrumentation:opentelemetry-logback-mdc-1.0:{{% param vers.instrumentation %}}-alpha` | + +## Context propagation + +The OpenTelemetry APIs are designed to be complementary, with the whole greater +than the sum of the parts. Each signal has its own strengths, and collectively +stitch together a compelling observability story. + +Importantly, the data from the various signals are linked together through trace +context: + +- Spans are related to other spans through span parent and links, which each + record trace context of related spans. +- Metrics are related to spans through + [exemplars](/docs/specs/otel/metrics/data-model/#exemplars), which record + trace context of a particular measurement. +- Logs are related to spans by recording trace context on log records. + +For this correlation to work, trace context must be propagated throughout an +application (across function calls and threads), and across application +boundaries. The [context API](../api-components/#context-api) facilitates this. +Instrumentation needs to be written in a manner which is context aware: -{{% alert title="Note" color="info" %}} See [Manage Telemetry with SDK](../sdk/) -for a conceptual overview of OpenTelemetry Java SDK concepts. See -**[Configure the SDK](../configuration/)** for details on SDK configuration, -including -[zero-code SDK autoconfigure](../configuration/#zero-code-sdk-autoconfigure). -{{% /alert %}} +- Libraries that represent the entry point to an application (i.e. HTTP servers, + message consumers, etc.) should + [extract context](../api-components/#contextpropagators) from incoming + messages. +- Libraries that represent an exit point from an application (i.e. HTTP clients, + message producers, etc.) should + [inject context](../api-components/#contextpropagators) into outgoing + messages. +- Libraries should implicitly or explicitly pass + [Context](../api-components/#context) through the callstack and across any + threads. + +## Semantic conventions -{{% alert title="Note" color="info" %}} +The [semantic conventions](/docs/specs/semconv/) define how to produce telemetry +for standard operations. Among other things, the semantic conventions specify +span names, span kinds, metric instruments, metric units, metric types, and +attribute key, value, and requirement levels. -On this page you will learn how you can add traces, metrics and logs to your -code _manually_. But, you are not limited to only use one kind of -instrumentation: use [zero-code instrumentation](/docs/zero-code/java/agent/) to -get started and then enrich your code with manual instrumentation as needed. - -Note, that especially if you cannot modify the source code of your app, you can -skip manual instrumentation and only use automatic instrumentation. - -Also, for libraries your code depends on, you don't have to write -instrumentation code yourself, since they might come with OpenTelemetry built-in -_natively_ or you can make use of [instrumentation libraries](../libraries/). - -{{% /alert %}} - -## Example app preparation {#example-app} - -This page uses a modified version of the example app from -[Getting Started](../getting-started/) to help you learn about manual -instrumentation. - -You don't have to use the example app: if you want to instrument your own app or -library, follow the instructions here to adapt the process to your own code. - -### Prerequisites - -For running the example app, ensure that you have the following installed -locally: - -- Java JDK 17+, due to the use of Spring Boot 3. OpenTelemetry Java itself only - [requires Java 8+][java-vers]. -- [Gradle](https://gradle.org/). - -### Dependencies {#example-app-dependencies} - -To begin, set up an environment in a new directory called `java-simple`. Within -that directory, create a file called `build.gradle.kts` with the following -content: - -```kotlin -plugins { - id("java") - id("org.springframework.boot") version "3.0.6" - id("io.spring.dependency-management") version "1.1.0" -} - -sourceSets { - main { - java.setSrcDirs(setOf(".")) - } -} - -repositories { - mavenCentral() -} - -dependencies { - implementation("org.springframework.boot:spring-boot-starter-web") -} -``` - -### Create and launch an HTTP Server - -To highlight the difference between instrumenting a _library_ and a standalone -_app_, split out the dice rolling into a _library_ class, which then will be -imported as a dependency by the app. - -Create the _library file_ name `Dice.java` and add the following code to it: - -```java -package otel; - -import java.util.ArrayList; -import java.util.List; -import java.util.concurrent.ThreadLocalRandom; - -public class Dice { - - private int min; - private int max; - - public Dice(int min, int max) { - this.min = min; - this.max = max; - } - - public List rollTheDice(int rolls) { - List results = new ArrayList(); - for (int i = 0; i < rolls; i++) { - results.add(this.rollOnce()); - } - return results; - } - - private int rollOnce() { - return ThreadLocalRandom.current().nextInt(this.min, this.max + 1); - } -} -``` - -Create the app files `DiceApplication.java` and `RollController.java` and add -the following code to them: - -```java -// DiceApplication.java -package otel; - -import org.springframework.boot.SpringApplication; -import org.springframework.boot.Banner; -import org.springframework.boot.autoconfigure.SpringBootApplication; - -@SpringBootApplication -public class DiceApplication { - public static void main(String[] args) { - - SpringApplication app = new SpringApplication(DiceApplication.class); - app.setBannerMode(Banner.Mode.OFF); - app.run(args); - } -} -``` - -```java -// RollController.java -package otel; - -import java.util.List; -import java.util.Optional; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.springframework.http.HttpStatus; -import org.springframework.web.bind.annotation.GetMapping; -import org.springframework.web.bind.annotation.RequestParam; -import org.springframework.web.bind.annotation.RestController; -import org.springframework.web.server.ResponseStatusException; - -import otel.Dice; - -@RestController -public class RollController { - private static final Logger logger = LoggerFactory.getLogger(RollController.class); - - @GetMapping("/rolldice") - public List index(@RequestParam("player") Optional player, - @RequestParam("rolls") Optional rolls) { - - if (!rolls.isPresent()) { - throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Missing rolls parameter", null); - } - - List result = new Dice(1, 6).rollTheDice(rolls.get()); - - if (player.isPresent()) { - logger.info("{} is rolling the dice: {}", player.get(), result); - } else { - logger.info("Anonymous player is rolling the dice: {}", result); - } - return result; - } -} -``` - -To ensure that it is working, run the application with the following command and -open in your web browser: - -```shell -gradle assemble -java -jar ./build/libs/java-simple.jar -``` - -You should get a list of 12 numbers in your browser window, for example: - -```text -[5,6,5,3,6,1,2,5,4,4,2,4] -``` - -## Manual instrumentation setup - -For both library and app instrumentation, the first step is to install the -dependencies for the OpenTelemetry API. - -Throughout this documentation you will add dependencies. For a full list of -artifact coordinates, see [releases]. For semantic convention releases, see -[semantic-conventions-java]. - -[releases]: https://github.com/open-telemetry/opentelemetry-java#releases -[semantic-conventions-java]: - https://github.com/open-telemetry/semantic-conventions-java/releases - -### Dependency management - -A Bill of Material -([BOM](https://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html#bill-of-materials-bom-poms)) -ensures that versions of dependencies (including transitive ones) are aligned. -Importing the `opentelemetry-bom` BOM is important to ensure version alignment -across all OpenTelemetry dependencies. - -{{< tabpane text=true >}} {{% tab Gradle %}} - -```kotlin { hl_lines=["1-5",9] } -dependencyManagement { - imports { - mavenBom("io.opentelemetry:opentelemetry-bom:{{% param vers.otel %}}") - } -} - -dependencies { - implementation("org.springframework.boot:spring-boot-starter-web"); - implementation("io.opentelemetry:opentelemetry-api"); -} -``` - -If you are not using Spring and its `io.spring.dependency-management` dependency -management plugin, install the OpenTelemetry BOM and API using Gradle -dependencies only. - -```kotlin -dependencies { - implementation(platform("io.opentelemetry:opentelemetry-bom:{{% param vers.otel %}}")); - implementation("io.opentelemetry:opentelemetry-api"); -} -``` - -{{% /tab %}} {{% tab Maven %}} - -```xml - - - - - io.opentelemetry - opentelemetry-bom - {{% param vers.otel %}} - pom - import - - - - - - io.opentelemetry - opentelemetry-api - - - -``` - -{{% /tab %}} {{% /tabpane %}} - -## Traces - -The following sections describe the OpenTelemetry Java tracing API. See -[SdkTracerProvider](../sdk/#sdktracerprovider) for an overview of trace SDK -concepts and configuration. - -### Acquiring a tracer - -To do [Tracing](/docs/concepts/signals/traces/) you'll need to acquire a -[`Tracer`](/docs/concepts/signals/traces/#tracer). - -**Note:** Methods of the OpenTelemetry SDK should never be called. - -First, a `Tracer` must be acquired, which is responsible for creating spans and -interacting with the [Context](#context-propagation). A tracer is acquired by -using the OpenTelemetry API specifying the name and version of the [library -instrumenting][instrumentation library] the [instrumented library] or application -to be monitored. More information is available in the specification chapter [Obtaining -a -Tracer]. - -Anywhere in your application where you write manual tracing code should call -`getTracer` to acquire a tracer. For example: - -```java -import io.opentelemetry.api.trace.Tracer; - -Tracer tracer = openTelemetry.getTracer("instrumentation-scope-name", "instrumentation-scope-version"); -``` - -The values of `instrumentation-scope-name` and `instrumentation-scope-version` -should uniquely identify the -[Instrumentation Scope](/docs/concepts/instrumentation-scope/), such as the -package, module or class name. This will help later help determining what the -source of telemetry is. While the name is required, the version is still -recommended despite being optional. Note, that all `Tracer`s that are created by -a single `OpenTelemetry` instance will interoperate, regardless of name. - -It's generally recommended to call `getTracer` in your app when you need it -rather than exporting the `tracer` instance to the rest of your app. This helps -avoid trickier application load issues when other required dependencies are -involved. - -In the case of the [example app](#example-app), there are two places where a -tracer may be acquired with an appropriate Instrumentation Scope: - -First, in the `index` method of the `RollController` as follows: - -```java { hl_lines=["4-6",11,"13-16"] } -package otel; - -// ... -import org.springframework.beans.factory.annotation.Autowired; -import io.opentelemetry.api.OpenTelemetry; -import io.opentelemetry.api.trace.Tracer; - -@RestController -public class RollController { - private static final Logger logger = LoggerFactory.getLogger(RollController.class); - private final Tracer tracer; - - @Autowired - RollController(OpenTelemetry openTelemetry) { - tracer = openTelemetry.getTracer(RollController.class.getName(), "0.1.0"); - } - // ... -} -``` - -And second, in the _library file_ `Dice.java`: - -```java { hl_lines=["2-3","9-19"]} -// ... -import io.opentelemetry.api.OpenTelemetry; -import io.opentelemetry.api.trace.Tracer; - -public class Dice { - - private int min; - private int max; - private Tracer tracer; - - public Dice(int min, int max, OpenTelemetry openTelemetry) { - this.min = min; - this.max = max; - this.tracer = openTelemetry.getTracer(Dice.class.getName(), "0.1.0"); - } - - public Dice(int min, int max) { - this(min, max, OpenTelemetry.noop()); - } - - // ... -} -``` - -As an aside, if you are writing library instrumentation, it is strongly -recommended that you provide your users the ability to inject an instance of -`OpenTelemetry` into your instrumentation code. If this is not possible for some -reason, you can fall back to using an instance from the `GlobalOpenTelemetry` -class: - -```java -import io.opentelemetry.api.GlobalOpenTelemetry; - -Tracer tracer = GlobalOpenTelemetry.getTracer("instrumentation-scope-name", "instrumentation-scope-version"); -``` - -Note that you can't force end users to configure the global, so this is the most -brittle option for library instrumentation. - -### Acquiring a tracer in Java agent - -If you are using the [Java agent], you can acquire a `Tracer` from the global OpenTelemetry -instance: - -```java -import io.opentelemetry.api.GlobalOpenTelemetry; - -Tracer tracer = GlobalOpenTelemetry.getTracer("application"); -``` - -If you are using Spring Boot, you can add the following bean to your -`@SpringBootApplication` class - to acquire a `Tracer` as in the -[Spring Boot starter](#acquiring-a-tracer-in-spring-boot-starter) section below: - -```java -import io.opentelemetry.api.OpenTelemetry; -import io.opentelemetry.api.GlobalOpenTelemetry; - -@Configuration -public class OpenTelemetryConfig { - @Bean - public OpenTelemetry openTelemetry() { - return GlobalOpenTelemetry.get(); - } -} -``` - -### Acquiring a tracer in Spring Boot starter - -If you are using the [Spring Boot starter], you can acquire a `Tracer` from the -autowired OpenTelemetry instance: - -```java -import io.opentelemetry.api.OpenTelemetry; -import io.opentelemetry.api.trace.Tracer; - -@Controller -public class MyController { - private final Tracer tracer; - - public MyController(OpenTelemetry openTelemetry) { - this.tracer = openTelemetry.getTracer("application"); - } -} -``` - -### Create Spans - -Now that you have [tracers](/docs/concepts/signals/traces/#tracer) initialized, -you can create [spans](/docs/concepts/signals/traces/#spans). - -To create [Spans](/docs/concepts/signals/traces/#spans), you only need to -specify the name of the span. The start and end time of the span is -automatically set by the OpenTelemetry SDK. - -The code below illustrates how to create a span: - -```java { hl_lines=["1-2","8-11","25-30"] } -import io.opentelemetry.api.trace.Span; -import io.opentelemetry.context.Scope; - -// ... - @GetMapping("/rolldice") - public List index(@RequestParam("player") Optional player, - @RequestParam("rolls") Optional rolls) { - Span span = tracer.spanBuilder("rollTheDice").startSpan(); - - // Make the span the current span - try (Scope scope = span.makeCurrent()) { - - if (!rolls.isPresent()) { - throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Missing rolls parameter", null); - } - - List result = new Dice(1, 6).rollTheDice(rolls.get()); - - if (player.isPresent()) { - logger.info("{} is rolling the dice: {}", player.get(), result); - } else { - logger.info("Anonymous player is rolling the dice: {}", result); - } - return result; - } catch(Throwable t) { - span.recordException(t); - throw t; - } finally { - span.end(); - } - } -``` - -It's required to call `end()` to end the span when you want it to end. - -If you followed the instructions using the [example app](#example-app) up to -this point, you can copy the code above into the `index` method of the -`RollController`. You should now be able to see spans emitted from your app. - -Start your app as follows, and then send it requests by visiting - with your browser or `curl`: - -```shell -gradle assemble -env \ -OTEL_SERVICE_NAME=dice-server \ -OTEL_TRACES_EXPORTER=logging \ -OTEL_METRICS_EXPORTER=logging \ -OTEL_LOGS_EXPORTER=logging \ -java -jar ./build/libs/java-simple.jar -``` - -After a while, you should see the spans printed in the console by the -`LoggingSpanExporter`, something like this: - -```log -2023-08-02T17:22:22.658+02:00 INFO 2313 --- [nio-8080-exec-1] i.o.e.logging.LoggingSpanExporter : 'rollTheDice' : 565232b11b9933fa6be8d6c4a1307fe2 6e1e011e2e8c020b INTERNAL [tracer: otel.RollController:0.1.0] {} -``` - -### Create nested Spans - -Most of the time, we want to correlate -[spans](/docs/concepts/signals/traces/#spans) for nested operations. -OpenTelemetry supports tracing within processes and across remote processes. For -more details how to share context between remote processes, see -[Context Propagation](#context-propagation). - -For example in the `Dice` class method `rollTheDice` calling method `rollOnce`, -the spans could be manually linked in the following way: - -```java { hl_lines=["1-2","5","7","9","12-14","17-21","23-25"]} -import io.opentelemetry.api.trace.Span; -import io.opentelemetry.context.Context; -// ... - public List rollTheDice(int rolls) { - Span parentSpan = tracer.spanBuilder("parent").startSpan(); - List results = new ArrayList(); - try { - for (int i = 0; i < rolls; i++) { - results.add(this.rollOnce(parentSpan)); - } - return results; - } finally { - parentSpan.end(); - } - } - - private int rollOnce(Span parentSpan) { - Span childSpan = tracer.spanBuilder("child") - .setParent(Context.current().with(parentSpan)) - .startSpan(); - try { - return ThreadLocalRandom.current().nextInt(this.min, this.max + 1); - } finally { - childSpan.end(); - } - } -``` - -The OpenTelemetry API offers also an automated way to propagate the parent span -on the current thread: - -```java { hl_lines=["1-2","5-6","12-14","18-22","24-26"]} -import io.opentelemetry.api.trace.Span; -import io.opentelemetry.context.Scope; -// ... - public List rollTheDice(int rolls) { - Span parentSpan = tracer.spanBuilder("parent").startSpan(); - try (Scope scope = parentSpan.makeCurrent()) { - List results = new ArrayList(); - for (int i = 0; i < rolls; i++) { - results.add(this.rollOnce()); - } - return results; - } finally { - parentSpan.end(); - } - } - - private int rollOnce() { - Span childSpan = tracer.spanBuilder("child") - // NOTE: setParent(...) is not required; - // `Span.current()` is automatically added as the parent - .startSpan(); - try(Scope scope = childSpan.makeCurrent()) { - return ThreadLocalRandom.current().nextInt(this.min, this.max + 1); - } finally { - childSpan.end(); - } - } -} -``` - -To link spans from remote processes, it is sufficient to set the -[Remote Context](#context-propagation) as parent. - -```java -Span childRemoteParent = tracer.spanBuilder("Child").setParent(remoteContext).startSpan(); -``` - -### Get the current span - -Sometimes it's helpful to do something with the current/active -[span](/docs/concepts/signals/traces/#spans) at a particular point in program -execution. - -```java -Span span = Span.current() -``` - -And if you want the current span for a particular `Context` object: - -```java -Span span = Span.fromContext(context) -``` - -### Span Attributes - -In OpenTelemetry [spans](/docs/concepts/signals/traces/#spans) can be created -freely and it's up to the implementor to annotate them with attributes specific -to the represented operation. -[Attributes](/docs/concepts/signals/traces/#attributes) provide additional -context on a span about the specific operation it tracks, such as results or -operation properties. - -```java -Span span = tracer.spanBuilder("/resource/path").setSpanKind(SpanKind.CLIENT).startSpan(); -span.setAttribute("http.method", "GET"); -span.setAttribute("http.url", url.toString()); -``` - -### Semantic Attributes - -There are semantic conventions for spans representing operations in well-known -protocols like HTTP or database calls. Semantic conventions for these spans are -defined in the specification at -[Trace Semantic Conventions](/docs/specs/semconv/general/trace/). - -First add the semantic conventions as a dependency to your application: - -{{< tabpane text=true >}} {{% tab Gradle %}} - -```kotlin -dependencies { - implementation("io.opentelemetry.semconv:opentelemetry-semconv:{{% param vers.semconv %}}-alpha") -} -``` - -{{% /tab %}} {{% tab Maven %}} - -```xml - - io.opentelemetry.semconv - opentelemetry-semconv - {{% param vers.semconv %}}-alpha - -``` - -{{% /tab %}} {{< /tabpane>}} - -Finally, you can update your file to include semantic attributes: - -```java -Span span = tracer.spanBuilder("/resource/path").setSpanKind(SpanKind.CLIENT).startSpan(); -span.setAttribute(SemanticAttributes.HTTP_METHOD, "GET"); -span.setAttribute(SemanticAttributes.HTTP_URL, url.toString()); -``` - -### Create Spans with events - -[Spans](/docs/concepts/signals/traces/#spans) can be annotated with named events -(called [Span Events](/docs/concepts/signals/traces/#span-events)) that can -carry zero or more [Span Attributes](#span-attributes), each of which itself is -a key:value map paired automatically with a timestamp. - -```java -span.addEvent("Init"); -... -span.addEvent("End"); -``` - -```java -Attributes eventAttributes = Attributes.of( - AttributeKey.stringKey("key"), "value", - AttributeKey.longKey("result"), 0L); - -span.addEvent("End Computation", eventAttributes); -``` - -### Create Spans with links - -A [Span](/docs/concepts/signals/traces/#spans) may be linked to zero or more -other Spans that are causally related via a -[Span Link](/docs/concepts/signals/traces/#span-links). Links can be used to -represent batched operations where a Span was initiated by multiple initiating -Spans, each representing a single incoming item being processed in the batch. - -```java -Span child = tracer.spanBuilder("childWithLink") - .addLink(parentSpan1.getSpanContext()) - .addLink(parentSpan2.getSpanContext()) - .addLink(parentSpan3.getSpanContext()) - .addLink(remoteSpanContext) - .startSpan(); -``` - -For more details how to read context from remote processes, see -[Context Propagation](#context-propagation). - -### Set span status - -A [status](/docs/concepts/signals/traces/#span-status) can be set on a -[span](/docs/concepts/signals/traces/#spans), typically used to specify that a -span has not completed successfully - `SpanStatus.Error`. In rare scenarios, you -could override the `Error` status with `OK`, but don't set `OK` on -successfully-completed spans. - -The status can be set at any time before the span is finished: - -```java -Span span = tracer.spanBuilder("my span").startSpan(); -// put the span into the current Context -try (Scope scope = span.makeCurrent()) { - // do something -} catch (Throwable t) { - span.setStatus(StatusCode.ERROR, "Something bad happened!"); - throw t; -} finally { - span.end(); // Cannot set a span after this call -} -``` - -### Record exceptions in spans - -It can be a good idea to record exceptions when they happen. It's recommended to -do this in conjunction with setting [span status](#set-span-status). - -```java -Span span = tracer.spanBuilder("my span").startSpan(); -// put the span into the current Context -try (Scope scope = span.makeCurrent()) { - // do something -} catch (Throwable throwable) { - span.setStatus(StatusCode.ERROR, "Something bad happened!"); - span.recordException(throwable); -} finally { - span.end(); // Cannot set a span after this call -} -``` - -This will capture things like the current stack trace in the span. - -### Context Propagation - -OpenTelemetry provides a text-based approach to propagate context to remote -services using the [W3C Trace Context](https://www.w3.org/TR/trace-context/) -HTTP headers. - -### Context propagation between threads - -The following example demonstrates how to propagate the context between threads: - -```java -io.opentelemetry.context.Context context = io.opentelemetry.context.Context.current(); -Thread thread = new Thread(context.wrap(new Runnable() { - @Override - public void run() { - // Code for which you want to propagate the context - } -})); -thread.start(); -``` - -### Context propagation between HTTP requests - -The following presents an example of an outgoing HTTP request using -`HttpURLConnection`. - -```java -// Tell OpenTelemetry to inject the context in the HTTP headers -TextMapSetter setter = - new TextMapSetter() { - @Override - public void set(HttpURLConnection carrier, String key, String value) { - // Insert the context as Header - carrier.setRequestProperty(key, value); - } -}; - -URL url = new URL("http://127.0.0.1:8080/resource"); -Span outGoing = tracer.spanBuilder("/resource").setSpanKind(SpanKind.CLIENT).startSpan(); -try (Scope scope = outGoing.makeCurrent()) { - // Use the Semantic Conventions. - // (Note that to set these, Span does not *need* to be the current instance in Context or Scope.) - outGoing.setAttribute(SemanticAttributes.HTTP_METHOD, "GET"); - outGoing.setAttribute(SemanticAttributes.HTTP_URL, url.toString()); - HttpURLConnection transportLayer = (HttpURLConnection) url.openConnection(); - // Inject the request with the *current* Context, which contains our current Span. - openTelemetry.getPropagators().getTextMapPropagator().inject(Context.current(), transportLayer, setter); - // Make outgoing call -} finally { - outGoing.end(); -} -... -``` - -Similarly, the text-based approach can be used to read the W3C Trace Context -from incoming requests. The following presents an example of processing an -incoming HTTP request using [HttpExchange][]. - -```java -TextMapGetter getter = - new TextMapGetter<>() { - @Override - public String get(HttpExchange carrier, String key) { - if (carrier.getRequestHeaders().containsKey(key)) { - return carrier.getRequestHeaders().get(key).get(0); - } - return null; - } - - @Override - public Iterable keys(HttpExchange carrier) { - return carrier.getRequestHeaders().keySet(); - } -}; -... -public void handle(HttpExchange httpExchange) { - // Extract the SpanContext and other elements from the request. - Context extractedContext = openTelemetry.getPropagators().getTextMapPropagator() - .extract(Context.current(), httpExchange, getter); - try (Scope scope = extractedContext.makeCurrent()) { - // Automatically use the extracted SpanContext as parent. - Span serverSpan = tracer.spanBuilder("GET /resource") - .setSpanKind(SpanKind.SERVER) - .startSpan(); - try { - // Add the attributes defined in the Semantic Conventions - serverSpan.setAttribute(SemanticAttributes.HTTP_METHOD, "GET"); - serverSpan.setAttribute(SemanticAttributes.HTTP_SCHEME, "http"); - serverSpan.setAttribute(SemanticAttributes.HTTP_HOST, "localhost:8080"); - serverSpan.setAttribute(SemanticAttributes.HTTP_TARGET, "/resource"); - // Serve the request - ... - } finally { - serverSpan.end(); - } - } -} -``` - -The following code presents an example to read the W3C Trace Context from -incoming request, add spans, and further propagate the context. The example -utilizes -[HttpHeaders](https://docs.oracle.com/en/java/javase/11/docs/api/java.net.http/java/net/http/HttpHeaders.html) -to fetch the traceparent header for context propagation. - -```java -TextMapGetter getter = - new TextMapGetter() { - @Override - public String get(HttpHeaders headers, String s) { - assert headers != null; - return headers.getHeaderString(s); - } - - @Override - public Iterable keys(HttpHeaders headers) { - List keys = new ArrayList<>(); - MultivaluedMap requestHeaders = headers.getRequestHeaders(); - requestHeaders.forEach((k, v) ->{ - keys.add(k); - }); - } -}; - -TextMapSetter setter = - new TextMapSetter() { - @Override - public void set(HttpURLConnection carrier, String key, String value) { - // Insert the context as Header - carrier.setRequestProperty(key, value); - } -}; - -//... -public void handle( HttpHeaders headers){ - Context extractedContext = opentelemetry.getPropagators().getTextMapPropagator() - .extract(Context.current(), headers, getter); - try (Scope scope = extractedContext.makeCurrent()) { - // Automatically use the extracted SpanContext as parent. - Span serverSpan = tracer.spanBuilder("GET /resource") - .setSpanKind(SpanKind.SERVER) - .startSpan(); - - try(Scope ignored = serverSpan.makeCurrent()) { - // Add the attributes defined in the Semantic Conventions - serverSpan.setAttribute(SemanticAttributes.HTTP_METHOD, "GET"); - serverSpan.setAttribute(SemanticAttributes.HTTP_SCHEME, "http"); - serverSpan.setAttribute(SemanticAttributes.HTTP_HOST, "localhost:8080"); - serverSpan.setAttribute(SemanticAttributes.HTTP_TARGET, "/resource"); - - HttpURLConnection transportLayer = (HttpURLConnection) url.openConnection(); - // Inject the request with the *current* Context, which contains our current Span. - openTelemetry.getPropagators().getTextMapPropagator().inject(Context.current(), transportLayer, setter); - // Make outgoing call - }finally { - serverSpan.end(); - } - } -} -``` - -## Metrics - -[Spans](/docs/concepts/signals/traces/#spans) provide detailed information about -your application, but produce data that is proportional to the load on the -system. In contrast, [metrics](/docs/concepts/signals/metrics) combine -individual measurements into aggregations, and produce data which is constant as -a function of system load. The aggregations lack details required to diagnose -low level issues, but complement spans by helping to identify trends and -providing application runtime telemetry. - -The metrics API defines a variety of instruments. Instruments record -measurements, which are aggregated by the metrics SDK and eventually exported -out of process. Instruments come in synchronous and asynchronous varieties. -Synchronous instruments record measurements as they happen. Asynchronous -instruments register a callback, which is invoked once per collection, and which -records measurements at that point in time. - -The following sections describe the OpenTelemetry Java metrics API. See -[SdkMeterProvider](../sdk/#sdkmeterprovider) for an overview of metrics SDK -concepts and configuration. - -### Acquiring a meter - -Anywhere in your application where you have manually instrumented code you can -call `opentelemetry.meterBuilder(instrumentationScopeName)` to get or create a -new meter instance using the builder pattern, or -`opentelemetry.getMeter(instrumentationScopeName)` to get or create a meter -based on just the instrument scope name. - -```java -// Get or create a named meter instance with instrumentation version using builder -Meter meter = openTelemetry.meterBuilder("dice-server") - .setInstrumentationVersion("0.1.0") - .build(); - -// Get or create a named meter instance by name only -Meter meter = openTelemetry.getMeter("dice-server"); -``` - -Now that you have [meters](/docs/concepts/signals/metrics/#meter) initialized. -you can create -[metric instruments](/docs/concepts/signals/metrics/#metric-instruments). - -### Acquiring a meter in Java agent - -If you are using the [Java agent], you can acquire a `Meter` from the global OpenTelemetry -instance: - -```java -import io.opentelemetry.api.GlobalOpenTelemetry; - -Meter meter = GlobalOpenTelemetry.getMeter("application"); -``` - -If you are using Spring Boot, you can add the following bean to your -`@SpringBootApplication` class - to acquire a `Meter` as in the -[Spring Boot starter](#acquiring-a-meter-in-spring-boot-starter) section below: - -```java -import io.opentelemetry.api.OpenTelemetry; -import io.opentelemetry.api.GlobalOpenTelemetry; - -@Configuration -public class OpenTelemetryConfig { - @Bean - public OpenTelemetry openTelemetry() { - return GlobalOpenTelemetry.get(); - } -} -``` - -### Acquiring a meter in Spring Boot starter - -If you are using the [Spring Boot starter], you can acquire a `Meter` from the -autowired OpenTelemetry instance: - -```java -import io.opentelemetry.api.OpenTelemetry; -import io.opentelemetry.api.metrics.Meter; - -@Controller -public class MyController { - private final Meter meter; - - public MyController(OpenTelemetry openTelemetry) { - this.meter = openTelemetry.getMeter("application"); - } -} -``` - -### Using Counters - -Counters can be used to measure non-negative, increasing values. - -```java -LongCounter counter = meter.counterBuilder("dice-lib.rolls.counter") - .setDescription("How many times the dice have been rolled.") - .setUnit("rolls") - .build(); - -counter.add(1, attributes); -``` - -### Using Observable (Async) Counters - -Observable counters can be used to measure an additive, non-negative, -monotonically increasing value. These counters specifically focus on the total -accumulated amount, which is gathered from external sources. Unlike synchronous -counters where each increment is recorded as it happens, observable counters -allow you to asynchronously monitor the overall sum of multiple increments. - -```java -ObservableLongCounter counter = meter.counterBuilder("dice-lib.uptime") - .buildWithCallback(measurement -> measurement.record(getUpTime())); -``` - -### Using UpDown Counters - -UpDown counters can increment and decrement, allowing you to observe a value -that goes up or down. - -```java -LongUpDownCounter counter = meter.upDownCounterBuilder("dice-lib.score") - .setDescription("Score from dice rolls.") - .setUnit("points") - .build(); - -//... - -counter.add(10, attributes); - -//... - -counter.add(-20, attributes); -``` - -### Using Observable (Async) UpDown Counters - -Observable UpDown counters can increment and decrement, allowing you to measure -an additive, non-negative, non-monotonically increasing cumulative value. These -UpDown counters specifically focus on the total accumulated amount, which is -gathered from external sources. Unlike synchronous UpDown counters where each -increment is recorded as it happens, observable counters allow you to -asynchronously monitor the overall sum of multiple increments. - -```java -ObservableDoubleUpDownCounter upDownCounter = meter.upDownCounterBuilder("dice-lib.score") - .buildWithCallback(measurement -> measurement.record(calculateScore())); -``` - -### Using Histograms - -Histograms are used to measure a distribution of values over time. - -```java -LongHistogram histogram = meter.histogramBuilder("dice-lib.rolls") - .ofLongs() // Required to get a LongHistogram, default is DoubleHistogram - .setDescription("A distribution of the value of the rolls.") - .setExplicitBucketBoundariesAdvice(Arrays.asList(1L, 2L, 3L, 4L, 5L, 6L, 7L)) - .setUnit("points") - .build(); - -histogram.record(7, attributes); -``` - -### Using Observable (Async) Gauges - -Observable Gauges should be used to measure non-additive values. - -```java -ObservableDoubleGauge gauge = meter.gaugeBuilder("jvm.memory.used") - .buildWithCallback(measurement -> measurement.record(getMemoryUsed())); -``` - -### Adding Attributes - -When you generate metrics, adding attributes creates unique metric series based -on each distinct set of attributes that receive measurements. This leads to the -concept of 'cardinality', which is the total number of unique series. -Cardinality directly affects the size of the metric payloads that are exported. -Therefore, it's important to carefully select the dimensions included in these -attributes to prevent a surge in cardinality, often referred to as 'cardinality -explosion'. - -```java -Attributes attrs = Attributes.of( - stringKey("hostname"), "i-98c3d4938", - stringKey("region"), "us-east-1"); - -histogram.record(7, attrs); -``` - -## Logs - -Logs are distinct from metrics and traces in that **there is no user-facing -OpenTelemetry logs API**. Instead, there is tooling to bridge logs from existing -popular log frameworks (e.g. SLF4j, JUL, Logback, Log4j) into the OpenTelemetry -ecosystem. For rationale behind this design decision, see -[Logging specification](/docs/specs/otel/logs/). - -The two typical workflows discussed below each cater to different application -requirements. +When writing instrumentation, consult the semantic conventions and conform to +any which are applicable to the domain. + +OpenTelemetry Java [publishes artifacts](../api-components/#semantic-attributes) +to assist in conforming to the semantic conventions, including generated +constants for attribute keys and values. + +TODO: discuss instrumentation API and how it helps conform to semantic +conventions + +## Log instrumentation + +While the [LoggerProvider](../api-components/#loggerprovider) / +[Logger](../api-components/#logger) APIs are structurally similar to the +equivalent [trace](../api-components/#tracerprovider) and +[metric](../api-components/#meterprovider) APIs, they serve a different use +case. As of now, `LoggerProvider` / `Logger` and associated classes represent +the [Log Bridge API](/docs/specs/otel/logs/bridge-api/), which exists to write +log appenders to bridge logs recorded through other log APIs / frameworks into +OpenTelemetry. They are not intended for end user use as a replacement for Log4j +/ SLF4J / Logback / etc. + +There are two typical workflows for consuming log instrumentation in +OpenTelemetry catering to different application requirements: ### Direct to collector @@ -1104,47 +205,23 @@ In the direct to collector workflow, logs are emitted directly from an application to a collector using a network protocol (e.g. OTLP). This workflow is simple to set up as it doesn't require any additional log forwarding components, and allows an application to easily emit structured logs that -conform to the [log data model][log data model]. However, the overhead required -for applications to queue and export logs to a network location may not be -suitable for all applications. +conform to the [log data model](/docs/specs/otel/logs/data-model/). However, the +overhead required for applications to queue and export logs to a network +location may not be suitable for all applications. To use this workflow: -- Install appropriate [Log Appender](#log-appenders). +- Install appropriate log appender. **[1]** - Configure the OpenTelemetry [Log SDK](../sdk/#sdkloggerprovider) to export log records to desired target destination (the - [collector][opentelemetry collector] or other). - -#### Log appenders - -A log appender bridges logs from a log framework into the OpenTelemetry -[Log SDK](../sdk/#sdkloggerprovider) using the [Logs Bridge -API][logs bridge API]. Log appenders are available for various popular Java log -frameworks: - -- [Log4j2 Appender][log4j2 appender] -- [Logback Appender][logback appender] - -The links above contain full usage and installation documentation, but -installation is generally as follows: - -- Add required dependency via gradle or maven. -- Extend the application's log configuration (i.e. `logback.xml`, `log4j.xml`, - etc) to include a reference to the OpenTelemetry log appender. - - Optionally configure the log framework to determine which logs (i.e. filter - by severity or logger name) are passed to the appender. - - Optionally configure the appender to indicate how logs are mapped to - OpenTelemetry Log Records (i.e. capture thread information, context data, - markers, etc). - -Log appenders automatically include the trace context in log records, enabling -log correlation with traces. - -The [Log Appender example][log appender example] demonstrates setup for a -variety of scenarios. + [collector](https://github.com/open-telemetry/opentelemetry-collector) or + other). -See [SdkLoggerProvider](../sdk/#sdkloggerprovider) for an overview of log SDK -concepts and configuration. +**[1]**: Log appenders are a type of [shim](#shims) which bridges logs from a +log framework into the OpenTelemetry log SDK. See "Bridge Log4j into +OpenTelemetry", "Bridge Logback into OpenTelemetry" entries. See +[Log Appender example](https://github.com/open-telemetry/opentelemetry-java-docs/tree/main/log-appender) +for demonstration of a variety of scenarios. ### Via file or stdout @@ -1155,48 +232,11 @@ as the collector. This workflow may be preferable in situations where application requirements do not permit additional overhead from [direct to collector](#direct-to-collector). However, it requires that all log fields required down stream are encoded into the logs, and that the component -reading the logs parse the data into the [log data model][log data model]. The -installation and configuration of log forwarding components is outside the scope -of this document. - -Log correlation with traces is available by installing -[log context instrumentation](#log-context-instrumentation). - -#### Log context instrumentation - -OpenTelemetry provides components which enrich log context with trace context -for various popular Java log frameworks: - -- [Log4j context data instrumentation][log4j context instrumentation] -- [Logback MDC instrumentation][logback context instrumentation] - -This links above contain full usage and installation documentation, but -installation is generally as follows: - -- Add required dependency via gradle or maven. -- Extend the application's log configuration (i.e. `logback.xml` or `log4j.xml`, - etc) to reference the trace context fields in the log pattern. - -[httpexchange]: - https://docs.oracle.com/javase/8/docs/jre/api/net/httpserver/spec/com/sun/net/httpserver/HttpExchange.html -[java-vers]: - https://github.com/open-telemetry/opentelemetry-java/blob/main/VERSIONING.md#language-version-compatibility -[instrumentation library]: /docs/specs/otel/glossary/#instrumentation-library -[instrumented library]: /docs/specs/otel/glossary/#instrumented-library -[logs bridge API]: /docs/specs/otel/logs/bridge-api -[log data model]: /docs/specs/otel/logs/data-model -[log4j2 appender]: - https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation/log4j/log4j-appender-2.17/library -[logback appender]: - https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation/logback/logback-appender-1.0/library -[log appender example]: - https://github.com/open-telemetry/opentelemetry-java-docs/tree/main/log-appender -[log4j context instrumentation]: - https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation/log4j/log4j-context-data/log4j-context-data-2.17/library-autoconfigure -[logback context instrumentation]: - https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation/logback/logback-mdc-1.0/library -[obtaining a tracer]: /docs/specs/otel/trace/api/#get-a-tracer -[opentelemetry collector]: - https://github.com/open-telemetry/opentelemetry-collector -[Java agent]: /docs/zero-code/java/agent/ -[Spring Boot starter]: /docs/zero-code/java/spring-boot-starter/ +reading the logs parse the data into the +[log data model](/docs/specs/otel/logs/data-model). The installation and +configuration of log forwarding components is outside the scope of this +document. + +Log correlation with traces is available by installing a [shim](#shims) to +bridge OpenTelemetry context into the log framework. See "Bridge OpenTelemetry +context into Log4j", "Bridge OpenTelemetry context into Logback" entries. diff --git a/content/en/docs/languages/java/intro.md b/content/en/docs/languages/java/intro.md new file mode 100644 index 000000000000..fd57761b6e32 --- /dev/null +++ b/content/en/docs/languages/java/intro.md @@ -0,0 +1,183 @@ +--- +title: Intro to OpenTelemetry Java +description: Intro to the OpenTelemetry Java ecosystem +weight: 9 +--- + +OpenTelemetry Java is the set of OpenTelemetry observability tools for the Java +ecosystem. At a high level, it consists of the API, the SDK, and +instrumentation. + +This page introduces the ecosystem, with a conceptual [overview](#overview), a +guide to [navigating the docs](#navigating-the-docs), a list of +[repositories](#repositories) with key details about releases and artifacts. + +## Overview + +The API is a set of classes and interfaces for recording telemetry across key +observability signals. It supports multiple implementations, with a low-overhead +minimalist Noop (i.e. pronounced "no-op") and SDK reference implementation +provided out of the box. It is designed to be taken as a direct dependency by +libraries, frameworks, and application owners looking to add instrumentation. It +comes with strong backwards compatibility guarantees, zero transitive +dependencies, and supports Java 8+. + +The SDK is the built-in reference implementation of the API, processing and +exporting telemetry produced by instrumentation API calls. Configuring the SDK +to process and export appropriately is an essential step to integrating +OpenTelemetry into an application. The SDK has autoconfiguration and +programmatic configuration options. + +Instrumentation records telemetry using the API. There are a variety of +categories of instrumentation, including: zero-code Java agent, zero-code Spring +Boot starter, library, native, manual, and shims. + +For a language-agnostic overview, see [OpenTelemetry concepts](/docs/concepts/). + +## Navigating the docs + +The OpenTelemetry Java documentation is organized as follows: + +- [Getting Started by Example](../getting-started/): A quick example to get off + the ground running with OpenTelemetry Java, demonstrating integration of the + OpenTelemetry Java agent into a simple web application. +- [Instrumentation ecosystem](../instrumentation/): A guide to the OpenTelemetry + Java instrumentation ecosystem. This is a key resource for application authors + looking to integrate OpenTelemetry Java into applications. Learn about the + different categories of instrumentation, and decide which is right for you. +- [Record Telemetry with API](../api-components/): A technical reference for the + OpenTelemetry API, exploring all key aspects of the API with working code + examples. Most users will use this page like an encyclopedia, consulting the + index of sections as needed, rather than reading front to back. +- [Manage Telemetry with SDK](../sdk/) A technical reference for the + OpenTelemetry SDK, exploring all SDK plugin extension points and the + programmatic configuration API with working code examples. Most users will use + this page like an encyclopedia, consulting the index of sections as needed, + rather than reading front to back. +- [Configure the SDK](../configuration/): A technical reference for configuring + the SDK, focussing on zero-code autoconfiguration. Includes a reference of all + supported environment variables and system properties for configuring the SDK. + Explores all programmatic customization points with working code examples. + Most users will use this page like an encyclopedia, consulting the index of + sections as needed, rather than reading front to back. +- **Learn More**: Supplementary resources, including end-to-end + [examples](../examples/), [Javadoc](../api/), component + [registry](../registry/), and a [performance reference](../performance/). + +## Repositories + +OpenTelemetry Java source code is organized into several repositories: + +| Repository | Description | Group ID | Current Version | Release cadence | +| ---------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- | ---------------------------------- | ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------- | +| [opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java) | Core API and SDK components | `io.opentelemetry` | `{{% param vers.otel %}}` | [Friday after first Monday of the month](https://github.com/open-telemetry/opentelemetry-java/blob/main/RELEASING.md#release-cadence) | +| [opentelemetry-java-instrumentation](https://github.com/open-telemetry/opentelemetry-java-instrumentation) | Instrumentation maintained by OpenTelemetry, including OpenTelemetry Java agent | `io.opentelemetry.instrumentation` | `{{% param vers.instrumentation %}}` | [Wednesday after second Monday of the month](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/RELEASING.md#release-cadence) | +| [opentelemetry-java-contrib](https://github.com/open-telemetry/opentelemetry-java-contrib) | Community maintained components that don't fit the express scope of other repositories | `io.opentelemetry.contrib` | `{{% param vers.contrib %}}` | [Friday after second Monday of the month](https://github.com/open-telemetry/opentelemetry-java-contrib/blob/main/RELEASING.md#release-cadence) | +| [semantic-conventions-java](https://github.com/open-telemetry/semantic-conventions-java) | Generated code for semantic conventions | `io.opentelemetry.semconv` | `{{% param vers.semconv %}}` | Following releases of [semantic-conventions](https://github.com/open-telemetry/semantic-conventions) | +| [opentelemetry-proto-java](https://github.com/open-telemetry/opentelemetry-proto-java) | Generated bindings for OTLP | `io.opentelemetry.proto` | `1.3.2-alpha` | Following releases of [opentelemetry-proto](https://github.com/open-telemetry/opentelemetry-proto) | +| [opentelemetry-java-examples](https://github.com/open-telemetry/opentelemetry-java-examples) | End-to-end code examples demonstrating a variety of patterns using the API, SDK, and instrumentation | n/a | n/a | n/a | + +`opentelemetry-java`, `opentelemetry-java-instrumentation`, and +`opentelemetry-java-contrib` each publish large catalogs of artifacts. Please +consult repositories for details, or see the "Managed Dependencies" column in +the [Bill of Materials](#dependencies-and-boms) table to see a full list of +managed dependencies. + +As a general rule, artifacts published from the same repository have the same +version. The exception to this is `opentelemetry-java-contrib`, which can be +thought of as a group of independent projects that are co-located in the same +repository to take advantage of shared tooling. For now, the artifacts of +`opentelemetry-java-contrib` are aligned but this is a coincidence and will +change in the future. + +The repositories have a release cadence which mirrors their high level +dependency structure: + +- `opentelemetry-java` is the core and releases first each month. +- `opentelemetry-java-instrumentation` depends on `opentelemetry-java` and is + next to publish. +- `opentelemetry-java-contrib` depends on `opentelemetry-java-instrumentation` + and `opentelemetry-java` and is last to publish. +- Although `semantic-conventions-java` is a dependency of + `opentelemetry-java-instrumentation`, it is an independent artifact with an + independent release schedule. + +## Dependencies and BOMs + +A +[bill of materials](https://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html#bill-of-materials-bom-poms), +or BOM for short, is an artifact that helps keep the versions of related +dependencies aligned. OpenTelemetry Java publishes several BOMs catering to +different use cases, listed below in order of increasing scope. We highly +recommend using a BOM. + +{{% alert %}} Because the BOMs are hierarchical, adding dependencies on multiple +BOMs is not recommended, as it is redundant and can lead unintuitive dependency +version resolution. {{% /alert %}} + +Click the link in the "Managed Dependencies" column to see a list of the +artifacts managed by the BOM. + +| Description | Repository | Group ID | Artifact ID | Current Version | Managed Dependencies | +| -------------------------------------------------------------------------------------------- | ------------------------------------ | ---------------------------------- | ----------------------------------------- | ------------------------------------------ | --------------------------------------------------------- | +| Stable core API and SDK artifacts | `opentelemetry-java` | `io.opentelemetry` | `opentelemetry-bom` | `{{% param vers.otel %}}` | [latest pom.xml][opentelemetry-bom] | +| Experimental core API and SDK artifacts, including all of `opentelemetry-bom` | `opentelemetry-java` | `io.opentelemetry` | `opentelemetry-bom-alpha` | `{{% param vers.otel %}}-alpha` | [latest pom.xml][opentelemetry-bom-alpha] | +| Stable instrumentation artifacts, including all of `opentelemetry-bom` | `opentelemetry-java-instrumentation` | `io.opentelemetry.instrumentation` | `opentelemetry-instrumentation-bom` | `{{% param vers.instrumentation %}}` | [latest pom.xml][opentelemetry-instrumentation-bom] | +| Experimental instrumentation artifacts, including all of `opentelemetry-instrumentation-bom` | `opentelemetry-java-instrumentation` | `io.opentelemetry.instrumentation` | `opentelemetry-instrumentation-bom-alpha` | `{{% param vers.instrumentation %}}-alpha` | [latest pom.xml][opentelemetry-instrumentation-alpha-bom] | + +The following code snippet demonstrates adding a BOM dependency, +with`{{bomGroupId}}`, `{{bomArtifactId}}`, and `{{bomVersion}}` referring to the +"Group ID", "Artifact ID", and "Current Version" table columns, respectively. + +{{< tabpane text=true >}} {{% tab "Gradle" %}} + +```kotlin +dependencies { + implementation(platform("{{bomGroupId}}:{{bomArtifactId}}:{{bomVersion}}")) + // Add a dependency on an artifact whose version is managed by the bom + implementation("io.opentelemetry:opentelemetry-api") +} +``` + +{{% /tab %}} {{% tab Maven %}} + +```xml + + + + + {{bomGroupId}} + {{bomArtifactId}} + {{bomVersion}} + pom + import + + + + + + + io.opentelemetry + opentelemetry-api + + + +``` + +{{% /tab %}} {{< /tabpane >}} + +[opentelemetry-bom]: +https://repo1.maven.org/maven2/io/opentelemetry/opentelemetry-bom/{{% param +vers.otel %}}/opentelemetry-bom-{{% param vers.otel %}}.pom +[opentelemetry-bom-alpha]: +https://repo1.maven.org/maven2/io/opentelemetry/opentelemetry-bom-alpha/{{% +param vers.otel +%}}-alpha/opentelemetry-bom-alpha-{{% param vers.otel %}}-alpha.pom +[opentelemetry-instrumentation-bom]: +https://repo1.maven.org/maven2/io/opentelemetry/instrumentation/opentelemetry-instrumentation-bom/{{% +param vers.instrumentation +%}}/opentelemetry-instrumentation-bom-{{% param vers.instrumentation %}}.pom +[opentelemetry-instrumentation-alpha-bom]: +https://repo1.maven.org/maven2/io/opentelemetry/instrumentation/opentelemetry-instrumentation-bom-alpha/{{% +param vers.instrumentation +%}}-alpha/opentelemetry-instrumentation-bom-alpha-{{% param vers.instrumentation %}}-alpha.pom diff --git a/content/en/docs/languages/java/libraries.md b/content/en/docs/languages/java/libraries.md deleted file mode 100644 index e222378b2738..000000000000 --- a/content/en/docs/languages/java/libraries.md +++ /dev/null @@ -1,187 +0,0 @@ ---- -title: Using instrumentation libraries -linkTitle: Libraries -weight: 40 -cSpell:ignore: getenv httpclient println ---- - -{{% docs/languages/libraries-intro "java" %}} - -## Use Instrumentation Libraries - -If a library does not come with OpenTelemetry out of the box, you can use -[instrumentation libraries](/docs/specs/otel/glossary/#instrumentation-library) -in order to generate telemetry data for a library or framework. - -The Java agent for automatic instrumentation includes instrumentation libraries -for many common Java frameworks. Most are turned on by default. If you need to -turn off certain instrumentation libraries, you can -[suppress them](/docs/zero-code/java/agent/disable/). - -If you use [code-based instrumentation](../instrumentation), you can leverage -some instrumentation libraries for your dependencies standalone. To find out -which standalone instrumentation libraries are available, take a look at -[this list](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/docs/supported-libraries.md#libraries--frameworks). -Follow the instructions of each instrumentation library to set them up. - -## Example app - -The following example instruments an HTTP client application using library -instrumentation which calls an HTTP server. - -You can use the dice example app as HTTP server from -[Getting Started](../getting-started/) or you can create your own HTTP server. - -### Dependencies - -Set up an environment in a new directory named `java-simple-http-client`. Inside -the directory, create a file named `build.gradle.kts` with the following -content: - -{{% alert title="Note" color="info" %}} The example is built using Gradle. You -might need to amend the directory structure and `pom.xml` to run using Maven. -{{% /alert %}} - -{{< tabpane text=true >}} {{% tab Gradle %}} - -```kotlin -plugins { - id("java") - id("application") -} - -application { - mainClass.set("otel.SampleHttpClient") -} - -sourceSets { - main { - java.setSrcDirs(setOf(".")) - } -} - -repositories { - mavenCentral() -} - -dependencies { - implementation("io.opentelemetry:opentelemetry-api:{{% param vers.otel %}}"); - implementation("io.opentelemetry:opentelemetry-sdk:{{% param vers.otel %}}"); - implementation("io.opentelemetry:opentelemetry-exporter-logging:{{% param vers.otel %}}"); - implementation("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure:{{% param vers.otel %}}"); - implementation("io.opentelemetry.instrumentation:opentelemetry-java-http-client:{{% param vers.instrumentation %}}-alpha"); -} -``` - -{{% /tab %}} {{% tab Maven %}} - -```xml - - - io.opentelemetry.instrumentation - opentelemetry-java-http-client - {{% param vers.instrumentation %}}-alpha - - -``` - -{{< /tab >}} {{< /tabpane>}} - -### Setup - -The following example shows how you can instrument external API calls using -[Java HTTP client library](https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation/java-http-client/library): - -```java -// SampleHttpClient.java -package otel; - -import io.opentelemetry.api.OpenTelemetry; -import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdk; -import io.opentelemetry.instrumentation.httpclient.JavaHttpClientTelemetry; -import java.net.http.HttpClient; - -import java.net.URI; -import java.net.http.HttpClient; -import java.net.http.HttpHeaders; -import java.net.http.HttpRequest; -import java.net.http.HttpResponse; - -public final class SampleHttpClient { - //Init OpenTelemetry - private static final OpenTelemetry openTelemetry = AutoConfiguredOpenTelemetrySdk.initialize().getOpenTelemetrySdk(); - - //Use this HttpClient implementation for making standard http client calls. - public HttpClient createTracedClient(OpenTelemetry openTelemetry) { - return JavaHttpClientTelemetry.builder(openTelemetry).build().newHttpClient(createClient()); - } - - //your configuration of the Java HTTP Client goes here: - private HttpClient createClient() { - return HttpClient.newBuilder().build(); - } - - public static void main(String[] args) throws Exception { - HttpRequest request = HttpRequest.newBuilder() - .GET() - .uri(URI.create(System.getenv().getOrDefault("EXTERNAL_API_ENDPOINT", "http://localhost:8080/rolldice"))) - //.setHeader("User-Agent", "Java 11 HttpClient Bot") // add request header - .build(); - - SampleHttpClient s = new SampleHttpClient(); - HttpResponse response = s.createTracedClient(openTelemetry).send(request, HttpResponse.BodyHandlers.ofString()); - // print response headers - HttpHeaders headers = response.headers(); - headers.map().forEach((k, v) -> System.out.println(k + ":" + v)); - // print status code - System.out.println(response.statusCode()); - // print response body - System.out.println(response.body()); - - } -} -``` - -### Run - -Set the `EXTERNAL_API_ENDPOINT` environment variable to specify the external API -endpoint. By default, it points to `http://localhost:8080/rolldice`, where -[example dice app](../getting-started/#example-application) is running. - -To check your code, run the app: - -```sh -env \ -OTEL_SERVICE_NAME=http-client \ -OTEL_TRACES_EXPORTER=logging \ -OTEL_METRICS_EXPORTER=logging \ -OTEL_LOGS_EXPORTER=logging \ -gradle run -``` - -When you run the app, the instrumentation libraries do the following: - -- Start a new trace. -- Generate a span that represents the request made to the external API endpoint. -- If you use an instrumented HTTP server, as in the - [dice app](../getting-started/#example-application), more trace spans are - generated with the same trace ID. - -## Available instrumentation libraries - -For a full list of instrumentation libraries, see -[opentelemetry-java-instrumentation](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/docs/supported-libraries.md#libraries--frameworks). - -## Next steps - -After you've set up instrumentation libraries, you might want to add -[additional instrumentation](../instrumentation) to collect custom telemetry -data. - -You might also want to [configure the SDK](../configuration/) to export to one -or more telemetry backends. - -For existing library instrumentations, also see -[Java agent](/docs/zero-code/java/agent/). - -[opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java) diff --git a/content/en/docs/languages/java/sdk.md b/content/en/docs/languages/java/sdk.md index 11aa6f478ab5..f2c58896dbce 100644 --- a/content/en/docs/languages/java/sdk.md +++ b/content/en/docs/languages/java/sdk.md @@ -1,6 +1,6 @@ --- title: Manage Telemetry with SDK -weight: 11 +weight: 12 cSpell:ignore: autoconfigured FQCNs Interceptable Logback okhttp --- @@ -8,7 +8,7 @@ cSpell:ignore: autoconfigured FQCNs Interceptable Logback okhttp The SDK is the built-in reference implementation of the -[API](../instrumentation/), processing and exporting telemetry produced by +[API](../api-components/), processing and exporting telemetry produced by instrumentation API calls. This page is a conceptual overview of the SDK, including descriptions, links to relevant Javadocs, artifact coordinates, sample programmatic configurations and more. See @@ -55,6 +55,9 @@ implementing various plugin extension interfaces: ## SDK components +The `io.opentelemetry:opentelemetry-sdk:{{% param vers.otel %}}` artifact +contains the OpenTelemetry SDK. + The following sections describe the core user-facing components of the SDK. Each component section includes: @@ -71,8 +74,7 @@ component section includes: ### OpenTelemetrySdk [OpenTelemetrySdk](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-sdk/latest/io/opentelemetry/sdk/OpenTelemetrySdk.html) -is the SDK implementation of -[OpenTelemetry](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/OpenTelemetry.html). +is the SDK implementation of [OpenTelemetry](../api-components/#opentelemetry). It is a holder for top-level SDK components which makes it convenient to pass fully-configured SDK components to instrumentation. @@ -150,8 +152,8 @@ public class ResourceConfig { [SdkTracerProvider](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-sdk-trace/latest/io/opentelemetry/sdk/trace/SdkTracerProvider.html) is the SDK implementation of -[TracerProvider](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/trace/TracerProvider.html), -and is responsible for handling trace telemetry produced by the API. +[TracerProvider](../api-components/#tracerprovider), and is responsible for +handling trace telemetry produced by the API. `SdkTracerProvider` is configured by the application owner, and consists of: @@ -557,8 +559,7 @@ public class SpanLimitsConfig { ### SdkMeterProvider [SdkMeterProvider](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-sdk-metrics/latest/io/opentelemetry/sdk/metrics/SdkMeterProvider.html) -is the SDK implementation of -[MeterProvider](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/MeterProvider.html), +is the SDK implementation of [MeterProvider](../api-components/#meterprovider), and is responsible for handling metric telemetry produced by the API. `SdkMeterProvider` is configured by the application owner, and consists of: @@ -927,8 +928,8 @@ public class ViewConfig { [SdkLoggerProvider](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-sdk-logs/latest/io/opentelemetry/sdk/logs/SdkLoggerProvider.html) is the SDK implementation of -[LoggerProvider](https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/logs/LoggerProvider.html), -and is responsible for handling log telemetry produced by the log bridge API. +[LoggerProvider](../api-components/#loggerprovider), and is responsible for +handling log telemetry produced by the log bridge API. `SdkLoggerProvider` is configured by the application owner, and consists of: @@ -1198,6 +1199,9 @@ public class LogLimitsConfig { is a [plugin extension interface](#sdk-plugin-extension-interfaces) responsible for propagating context across process boundaries in a text format. +TextMapPropagators built-in to the SDK and maintained by the community in +`opentelemetry-java-contrib`: + | Class | Artifact | Description | | --------------------------- | --------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- | | `W3CTraceContextPropagator` | `io.opentelemetry:opentelemetry-api:{{% param vers.otel %}}` | Propagate trace context using W3C trace context propagation protocol. | diff --git a/content/en/docs/languages/js/instrumentation.md b/content/en/docs/languages/js/instrumentation.md index 6e21ab2c95c6..33613f51ea14 100644 --- a/content/en/docs/languages/js/instrumentation.md +++ b/content/en/docs/languages/js/instrumentation.md @@ -1508,7 +1508,7 @@ Now that you have [meters](/docs/concepts/signals/metrics/#meter) initialized. you can create [metric instruments](/docs/concepts/signals/metrics/#metric-instruments). -### Create counters +### Using counters Counters can be used to measure a non-negative, increasing value. diff --git a/content/en/docs/languages/net/instrumentation.md b/content/en/docs/languages/net/instrumentation.md index 509e87d6b0ed..b1394c13fad4 100644 --- a/content/en/docs/languages/net/instrumentation.md +++ b/content/en/docs/languages/net/instrumentation.md @@ -636,14 +636,6 @@ var activity = MyActivitySource.StartActivity( {{% docs/languages/span-status-preamble %}} -A [status](/docs/concepts/signals/traces/#span-status) can be set on a -[span](/docs/concepts/signals/traces/#spans), typically used to specify that a -span has not completed successfully - `SpanStatus.Error`. - -By default, all spans are `Unset`, which means a span completed without error. -The `Ok` status is reserved for when you need to explicitly mark a span as -successful rather than stick with the default of Unset (i.e., “without error”). - The status can be set at any time before the span is finished. It can be a good idea to record exceptions when they happen. It's recommended to diff --git a/content/en/docs/languages/swift/instrumentation.md b/content/en/docs/languages/swift/instrumentation.md index 074981241bef..c4ccc47b8e4a 100644 --- a/content/en/docs/languages/swift/instrumentation.md +++ b/content/en/docs/languages/swift/instrumentation.md @@ -77,7 +77,7 @@ operation. Spans are the building blocks of Traces. To create a span use the span builder associated with the tracer: ```swift -let span = let builder = tracer.spanBuilder(spanName: "\(name)").startSpan() +let span = tracer.spanBuilder(spanName: "\(name)").startSpan() ... span.end() ``` diff --git a/content/en/docs/security/_index.md b/content/en/docs/security/_index.md index 85c229f08e23..1fd43aef309d 100644 --- a/content/en/docs/security/_index.md +++ b/content/en/docs/security/_index.md @@ -2,3 +2,40 @@ title: Security weight: 970 --- + +In this section, learn how the OpenTelemetry project discloses vulnerabilities +and responds to incidents and discover what you can do to securely collect and +transmit your observability data. + +## Common Vulnerabilities and Exposures (CVEs) + +For CVEs across all repositories, see +[Common Vulnerabilities and Exposures](cve/). + +## Incident response + +Learn how to report a vulnerability or find out how incident responses are +handled in [Community incident response guidelines](security-response/). + +## Collector security + +When setting up the OpenTelemetry Collector, consider implementing security best +practices in both your hosting infrastructure and your Collector configuration. +Running a secure Collector can help you + +- Protect telemetry that shouldn't but might contain sensitive information, such + as personally identifiable information (PII), application-specific data, or + network traffic patterns. +- Prevent data tampering that makes telemetry unreliable and disrupts incident + responses. +- Comply with data privacy and security regulations. +- Defend against denial of service (DoS) attacks. + +See [Hosting best practices](hosting-best-practices/) to learn how to secure +your Collector's infrastructure. + +See [Configuration best practices](config-best-practices/) to learn how to +securely configure your Collector. + +For Collector component developers, see +[Security best practices](https://github.com/open-telemetry/opentelemetry-collector/blob/main/docs/security-best-practices.md). diff --git a/content/en/docs/security/config-best-practices.md b/content/en/docs/security/config-best-practices.md new file mode 100644 index 000000000000..f751d3ec3ff2 --- /dev/null +++ b/content/en/docs/security/config-best-practices.md @@ -0,0 +1,208 @@ +--- +title: Collector configuration best practices +linkTitle: Collector configuration +weight: 112 +cSpell:ignore: exporterhelper +--- + +When configuring the OpenTelemetry (OTel) Collector, consider these best +practices to better secure your Collector instance. + +## Create secure configurations + +Follow these guidelines to secure your Collector's configuration and its +pipelines. + +### Store your configuration securely + +The Collector's configuration might contain sensitive information including: + +- Authentication information such as API tokens. +- TLS certificates including private keys. + +You should store sensitive information securely such as on an encrypted +filesystem or secret store. You can use environment variables to handle +sensitive and non-sensitive data as the Collector supports +[environment variable expansion](/docs/collector/configuration/#environment-variables). + +### Use encryption and authentication + +Your OTel Collector configuration should include encryption and authentication. + +- For communication encryption, see + [Configuring certificates](/docs/collector/configuration/#setting-up-certificates). +- For authentication, use the OTel Collector's authentication mechanism, as + described in [Authentication](/docs/collector/configuration/#authentication). + +### Minimize the number of components + +We recommend limiting the set of components in your Collector configuration to +only those you need. Minimizing the number of components you use minimizes the +attack surface exposed. + +- Use the + [OpenTelemetry Collector Builder (`ocb`)](/docs/collector/custom-collector) to + create a Collector distribution that uses only the components you need. +- Remove unused components from your configuration. + +### Configure with care + +Some components can increase the security risk of your Collector pipelines. + +- Receivers, exporters, and other components should establish network + connections over a secure channel, potentially authenticated as well. +- Receivers and exporters might expose buffer, queue, payload, and worker + settings using configuration parameters. If these settings are available, you + should proceed with caution before modifying the default configuration values. + Improperly setting these values might expose the OpenTelemetry Collector to + additional attack vectors. + +## Set permissions carefully + +Avoid running the Collector as a root user. Some components might require +special permissions, however. In those cases, follow the principle of least +privilege and make sure your components only have the access they need to do +their job. + +### Observers + +Observers are implemented as extensions. Extensions are a type of component that +adds capabilities on top of the primary functions of the Collector. Extensions +don't require direct access to telemetry and aren't part of pipelines, but they +can still pose security risks if they require special permissions. + +An observer discovers networked endpoints such as a Kubernetes pod, Docker +container, or local listening port on behalf of the +[receiver creator](https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/receiver/receivercreator/README.md). +In order to discover services, observers might require greater access. For +example, the `k8s_observer` requires +[role-based access control (RBAC) permissions](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/extension/observer/k8sobserver#setting-up-rbac-permissions) +in Kubernetes. + +## Manage specific security risks + +Configure your Collector to block these security threats. + +### Protect against denial of service attacks + +For server-like receivers and extensions, you can protect your Collector from +exposure to the public internet or to wider networks than necessary by binding +these components' endpoints to addresses that limit connections to authorized +users. Try to always use specific interfaces, such as a pod's IP, or `localhost` +instead of `0.0.0.0`. For more information, see +[CWE-1327: Binding to an Unrestricted IP Address](https://cwe.mitre.org/data/definitions/1327.html). + +From Collector v0.110.0, the default host for all servers in Collector +components is `localhost`. For earlier versions of the Collector, change the +default endpoint from `0.0.0.0` to `localhost` in all components by enabling the +`component.UseLocalHostAsDefaultHost` +[feature gate](https://github.com/open-telemetry/opentelemetry-collector/tree/main/featuregate). + +If `localhost` resolves to a different IP due to your DNS settings, then +explicitly use the loopback IP instead: `127.0.0.1` for IPv4 or `::1` for IPv6. +For example, here's an IPv4 configuration using a gRPC port: + +```yaml +receivers: + otlp: + protocols: + grpc: + endpoint: 127.0.0.1:4317 +``` + +In IPv6 setups, make sure your system supports both IPv4 and IPv6 loopback +addresses so the network functions properly in dual-stack environments and +applications, where both protocol versions are used. + +If you are working in environments that have nonstandard networking setups, such +as Docker or Kubernetes, see the +[example configurations](https://github.com/open-telemetry/opentelemetry-collector/blob/main/docs/security-best-practices.md#safeguards-against-denial-of-service-attacks) +in our component developer documentation for ideas on how to bind your component +endpoints. + +### Scrub sensitive data + +[Processors](/docs/collector/configuration/#processors) are the Collector +components that sit between receivers and exporters. They are responsible for +processing telemetry before it's analyzed. You can use the OpenTelemetry +Collector's `redaction` processor to obfuscate or scrub sensitive data before +exporting it to a backend. + +The +[`redaction` processor](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/redactionprocessor) +deletes span, log, and metric datapoint attributes that don't match a list of +allowed attributes. It also masks attribute values that match a blocked value +list. Attributes that aren't on the allowed list are removed before any value +checks are done. + +For example, here is a configuration that masks values containing credit card +numbers: + +```yaml +processors: + redaction: + allow_all_keys: false + allowed_keys: + - description + - group + - id + - name + ignored_keys: + - safe_attribute + blocked_values: # Regular expressions for blocking values of allowed span attributes + - '4[0-9]{12}(?:[0-9]{3})?' # Visa credit card number + - '(5[1-5][0-9]{14})' # MasterCard number + summary: debug +``` + +See the +[documentation](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/redactionprocessor) +to learn how to add the `redaction` processor to your Collector configuration. + +### Safeguard resource utilization + +After implementing safeguards for resource utilization in your +[hosting infrastructure](../hosting-best-practices/), consider also adding these +safeguards to your OpenTelemetry Collector configuration. + +Batching your telemetry and limiting the memory available to your Collector can +prevent out-of-memory errors and usage spikes. You can also handle traffic +spikes by adjusting queue sizes to manage memory usage while avoiding data loss. +For example, use the +[`exporterhelper`](https://github.com/open-telemetry/opentelemetry-collector/blob/main/exporter/exporterhelper/README.md) +to manage queue size for your `otlp` exporter: + +```yaml +exporters: + otlp: + endpoint: + sending_queue: + queue_size: 800 +``` + +Filtering unwanted telemetry is another way you can protect your Collector's +resources. Not only does filtering protect your Collector instance, but it also +reduces the load on your backend. You can use the +[`filter` processor](/docs/collector/transforming-telemetry/#basic-filtering) to +drop logs, metrics, and spans you don't need. For example, here's a +configuration that drops non-HTTP spans: + +```yaml +processors: + filter: + error_mode: ignore + traces: + span: + - attributes["http.request.method"] == nil +``` + +You can also configure your components with appropriate timeout and retry +limits. These limits should allow your Collector to handle failures without +accumulating too much data in memory. See the +[`exporterhelper` documentation](https://github.com/open-telemetry/opentelemetry-collector/blob/main/exporter/exporterhelper/README.md) +for more information. + +Finally, consider using compression with your exporters to reduce the send size +of your data and conserve network and CPU resources. By default, the +[`otlp` exporter](https://github.com/open-telemetry/opentelemetry-collector/tree/main/exporter/otlpexporter) +uses `gzip` compression. diff --git a/content/en/docs/security/cve.md b/content/en/docs/security/cve.md index 3c6b8fb18730..208406d36109 100644 --- a/content/en/docs/security/cve.md +++ b/content/en/docs/security/cve.md @@ -1,6 +1,6 @@ --- title: Common Vulnerabilities and Exposures -weight: 102 +weight: 100 --- This is a list of reported Common Vulnerabilities and Exposures (CVEs) across diff --git a/content/en/docs/security/hosting-best-practices.md b/content/en/docs/security/hosting-best-practices.md new file mode 100644 index 000000000000..531c959ff635 --- /dev/null +++ b/content/en/docs/security/hosting-best-practices.md @@ -0,0 +1,63 @@ +--- +title: Collector hosting best practices +linkTitle: Collector hosting +weight: 115 +--- + +When setting up hosting for OpenTelemetry (OTel) Collector, consider these best +practices to better secure your hosting instance. + +## Store data securely + +Your Collector configuration file might contain sensitive data, including +authentication tokens or TLS certificates. See the best practices for +[securing your configuration](../config-best-practices/#create-secure-configurations). + +If you are storing telemetry for processing, make sure to restrict access to +those directories to prevent tampering with raw data. + +## Keep your secrets safe + +Kubernetes [secrets](https://kubernetes.io/docs/concepts/configuration/secret/) +are credentials that hold confidential data. They authenticate and authorize +privileged access. If you're using a Kubernetes deployment for your Collector, +make sure to follow these +[recommended practices](https://kubernetes.io/docs/concepts/security/secrets-good-practices/) +to improve security for your clusters. + +## Apply the principle of least privilege + +The Collector should not require privileged access, except where the data it's +collecting is in a privileged location. For example, in a Kubernetes deployment, +system logs, application logs, and container runtime logs are often stored in a +node volume that requires special permission to access. If your Collector is +running as a daemonset on the node, make sure to grant only the specific volume +mount permissions it needs to access these logs and no more. You can configure +privilege access with role-based access control (RBAC). See +[RBAC good practices](https://kubernetes.io/docs/concepts/security/rbac-good-practices/) +for more information. + +## Control access to server-like components + +Some Collector components such as receivers and exporters can function like +servers. To limit access to authorized users, you should: + +- Enable authentication by using bearer token authentication extensions and + basic authentication extensions, for example. +- Restrict the IPs that your Collector runs on. + +## Safeguard resource utilization + +Use the Collector's own +[internal telemetry](/docs/collector/internal-telemetry/) to monitor its +performance. Collect metrics from the Collector about its CPU, memory, and +throughput usage and set alerts for resource exhaustion. + +If resource limits are reached, consider horizontally +[scaling the Collector](/docs/collector/scaling/) by deploying multiple +instances in a load-balanced configuration. Scaling your Collector distributes +the resource demands and prevents bottlenecks. + +Once you secure resource utilization in your deployment, make sure your +Collector instance also uses +[safeguards in its configuration](../config-best-practices/#safeguard-resource-utilization). diff --git a/content/en/docs/security/security-response.md b/content/en/docs/security/security-response.md index a20ba04cfcfe..39adb1d12017 100644 --- a/content/en/docs/security/security-response.md +++ b/content/en/docs/security/security-response.md @@ -1,5 +1,5 @@ --- -title: Community Incident Response Guidelines +title: Community incident response guidelines weight: 102 --- diff --git a/content/en/docs/zero-code/python/operator.md b/content/en/docs/zero-code/python/operator.md index a08fd5e0219d..9f5e6761b6dd 100644 --- a/content/en/docs/zero-code/python/operator.md +++ b/content/en/docs/zero-code/python/operator.md @@ -3,7 +3,8 @@ title: Using the OpenTelemetry Operator to Inject Auto-Instrumentation linkTitle: Operator aliases: [/docs/languages/python/automatic/operator] weight: 30 -cSpell:ignore: distro mkdir uninstrumented virtualenv +# prettier-ignore +cSpell:ignore: distro grpcio mkdir myapp psutil PYTHONPATH uninstrumented virtualenv --- If you run your Python service in Kubernetes, you can take advantage of the @@ -11,3 +12,28 @@ If you run your Python service in Kubernetes, you can take advantage of the to inject auto-instrumentation without having to modify each of your services directly. [See the OpenTelemetry Operator Auto-instrumentation docs for more details.](/docs/kubernetes/operator/automatic/) + +### Python-specific topics + +#### Libraries with binary wheels + +Some Python packages we instrument or need in our instrumentation libraries, +might ship with some binary code. This is the case, for example, of `grpcio` and +`psutil` (used in `opentelemetry-instrumentation-system-metrics`). + +The binary code is tied to a specific C library version (glibc or musl) and to a +specific Python version. The +[OpenTelemetry Operator](https://github.com/open-telemetry/opentelemetry-operator) +provides images for a single Python version based on the glibc C library. If you +want to use it you might need to build your own image operator Docker image for +Python auto-instrumentation. + +#### Django applications + +Applications that run from their own executable like Django requires to set in +your deployment file two environment variables: + +- `PYTHONPATH`, with the path to the Django application root directory, e.g. + "/app" +- `DJANGO_SETTINGS_MODULE`, with the name of the Django settings module, e.g. + "myapp.settings" diff --git a/content/es/docs/concepts/components.md b/content/es/docs/concepts/components.md new file mode 100644 index 000000000000..be665264af10 --- /dev/null +++ b/content/es/docs/concepts/components.md @@ -0,0 +1,146 @@ +--- +title: Componentes +description: Componentes que forman OpenTelemetry +aliases: [data-collection] +weight: 20 +default_lang_commit: 9b7da35fd7abd77d867177902b36d95e5f322182 +--- + +OpenTelemetry está compuesto por varios componentes principales: + +- [Especificación](#especificación) +- [Collector](#collector) +- [Implementaciones de API y SDK específicas del lenguaje](#implementaciones-de-api-y-sdk-específicas-del-lenguaje) + - [Librerías de Instrumentación](#librerías-de-instrumentación) + - [Exportadores](#exportadores) + - [Instrumentación sin código](#instrumentación-sin-código) + - [Detectores de Recursos](#detectores-de-recursos) + - [Propagadores entre servicios](#propagadores-entre-servicios) + - [Muestreadores](#muestreadores) +- [Operador de Kubernetes](#operador-de-kubernetes) +- [Elementos de Función como Servicio](#elementos-de-función-como-servicio) + +OpenTelemetry te permite reemplazar la necesidad de SDKs y herramientas +específicas de proveedores para generar y exportar datos de telemetría. + +## Especificación + +Describe los requisitos y expectativas multilenguaje para todas las +implementaciones. Más allá de la definición de términos, la especificación +define lo siguiente: + +- **API:** Define tipos de datos y operaciones para generar y correlacionar + datos de trazas, métricas y logs. +- **SDK:** Define requisitos para una implementación específica del lenguaje de + la API. La configuración, procesamiento de datos y conceptos de exportación + también se definen aquí. +- **Datos:** Define el Protocolo de OpenTelemetry (OTLP) y convenciones + semánticas neutrales que un backend de telemetría puede soportar. + +Para más información, consulta las [especificaciones](/docs/specs/). + +## Collector + +El Collector de OpenTelemetry es un proxy neutral que puede recibir, procesar y +exportar datos de telemetría. Soporta recibir datos de telemetría en múltiples +formatos (por ejemplo, OTLP, Jaeger, Prometheus, así como muchas herramientas +comerciales/proprietarias) y enviar datos a uno o más backends. También permite +procesar y filtrar datos de telemetría antes de exportarlos. + +Para más información, consulta el [Collector](/docs/collector/). + +## Implementaciones de API y SDK específicas del lenguaje + +OpenTelemetry también cuenta con SDKs específicos para cada lenguaje que te +permiten usar la API de OpenTelemetry para generar datos de telemetría en el +lenguaje de tu elección y exportarlos a un backend preferido. Estos SDKs también +permiten incorporar librerías de instrumentación para librerías y frameworks +comunes, que puedes utilizar para conectar la instrumentación manual en tu +aplicación. + +Para más información, consulta +[Instrumentación](/docs/concepts/instrumentation/). + +### Librerías de instrumentación + +OpenTelemetry soporta una amplia gama de componentes que generan datos de +telemetría relevantes desde librerías y frameworks populares para los lenguajes +soportados. Por ejemplo, las solicitudes HTTP entrantes y salientes desde una +librería HTTP generan datos sobre esas solicitudes. + +Un objetivo aspiracional de OpenTelemetry es que todas las librerías populares +estén diseñadas para ser observables por defecto, para que no se requieran +dependencias separadas. + +Para más información, consulta +[Instrumentación de librerías](/docs/concepts/instrumentation/libraries/). + +### Exportadores + +{{% docs/languages/exporters/intro %}} + +### Instrumentación sin código + +Si aplica, una implementación específica de OpenTelemetry en un lenguaje +proporciona una forma de instrumentar tu aplicación sin tocar el código fuente. +Aunque el mecanismo subyacente depende del lenguaje, la instrumentación sin +código añade las capacidades de API y SDK de OpenTelemetry a tu aplicación. +Adicionalmente, puede añadir un conjunto de librerías de instrumentación y +dependencias de exportador. + +Para más información, consulta +[Instrumentación sin código](/docs/concepts/instrumentation/zero-code/). + +### Detectores de recursos + +Un [recurso](/docs/concepts/resources/) representa la entidad que produce +telemetría como atributos de tipo recurso. Por ejemplo, un proceso que produce +telemetría y que se está ejecutando en un contenedor en Kubernetes tiene el +nombre del Pod, un nombre del namespace y posiblemente un nombre del Deployment. +Puedes incluir todos estos atributos como tipo recurso. + +Las implementaciones específicas de OpenTelemetry para cada lenguaje +proporcionan detección de recursos desde la variable de entorno +`OTEL_RESOURCE_ATTRIBUTES` y para muchas entidades comunes, como el runtime del +proceso, servicio, host o sistema operativo. + +Para más información, consulta [Recursos](/docs/concepts/resources/). + +### Propagadores entre servicios + +La propagación es el mecanismo que transfiere datos entre servicios y procesos. +Aunque no está limitado a las trazas, la propagación permite que las trazas +construyan información causal sobre un sistema a través de servicios +distribuidos arbitrariamente entre fronteras de procesos y redes. + +Para la gran mayoría de los casos, la propagación de contexto ocurre a través de +librerías de instrumentación. Si es necesario, puedes utilizar propagadores tú +mismo para serializar y deserializar intereses compartidos, como el contexto de +un span y el [equipaje](/docs/concepts/signals/baggage/). + +### Muestreadores + +El muestreo es un proceso que restringe la cantidad de trazas generadas por un +sistema. Cada implementación específica de OpenTelemetry para un lenguaje ofrece +varios [muestreadores de cabecera](/docs/concepts/sampling/#head-sampling). + +Para más información, consulta [Muestreo](/docs/concepts/sampling). + +## Operador de Kubernetes + +El Operador de OpenTelemetry es una implementación de un Operador de Kubernetes. +El operador gestiona el Collector de OpenTelemetry y la auto-instrumentación de +las aplicaciones usando OpenTelemetry. + +Para más información, consulta el [Operador K8s](/docs/kubernetes/operator/). + +## Elementos de Función como Servicio + +OpenTelemetry soporta varios métodos de monitoreo para Function-as-a-Service +proporcionados por diferentes proveedores de servicios en la nube. La comunidad +de OpenTelemetry proporciona capas Lambda prefabricadas capaces de +auto-instrumentar tu aplicación, así como la opción de una capa Lambda de +Collector independiente que puede usarse al instrumentar aplicaciones manual o +automáticamente. + +Para más información, consulta [Funciones como Servicio](/docs/faas/). diff --git a/content/es/docs/contributing/pull-requests.md b/content/es/docs/contributing/pull-requests.md new file mode 100644 index 000000000000..624db9e6e20a --- /dev/null +++ b/content/es/docs/contributing/pull-requests.md @@ -0,0 +1,512 @@ +--- +title: Agregar nuevo contenido +description: + Aprende a agregar contenido nuevo utilizando la interfaz de GitHub o desde tu + editor de código. +weight: 2 +default_lang_commit: f724c15be360e5059fb89e696d9a5cc8d00496f6 +cSpell:ignore: aplícala vincúlalos solucionándolas +--- + +Para contribuir con nuevas páginas de contenido o mejorar las páginas de +contenido existentes, abre un Pull Request (PR): + +- Si tu cambio es pequeño, o no estás familiarizado con Git, lee + [Editar con GitHub](#changes-using-github) para aprender a editar la página + desde la interfaz de GitHub. +- Si tu cambio es más complejo, lee + [Editar desde una rama local](#fork-the-repo) para aprender cómo realizar + cambios desde tu editor de código. + +{{% alert title="Consejo" %}} + +Convierte tu Pull Request en borrador para indicar que el contenido aún no está +listo para su revisión. Los miembros aún pueden comentar o realizar revisiones +de alto nivel, aunque no revisarán el contenido en su totalidad hasta que +indiques que ya no es un borrador. + +{{% /alert %}} + +La siguiente figura ilustra cómo contribuir con nueva documentación. + +```mermaid +flowchart LR + subgraph first[Cómo contribuir] + direction TB + T[ ] -.- + B[Haz un fork al repo de GitHub] --- C[Escribe el nuevo contenido utilizando Markdown
y compila la página web en Hugo] + C --- D[Sube tus cambios locales al Fork] + D --- E[Abre un Pull Request] + E --- F[Firma el CNCF CLA] + end + +classDef grey fill:#dddddd,stroke:#ffffff,stroke-width:px,color:#000000, font-size:15px; +classDef white fill:#ffffff,stroke:#000,stroke-width:px,color:#000,font-weight:bold +classDef spacewhite fill:#ffffff,stroke:#fff,stroke-width:0px,color:#000 +class A,B,C,D,E,F,G,H grey +class S,T spacewhite +class first,second white +``` + +_Figura 1. Contribuyendo con nuevo contenido._ + +## Editar con GitHub {#changes-using-github} + +Si no tienes mucha experiencia con Git, aquí tienes un método más sencillo para +abrir un Pull Request. La Figura 2 describe los pasos y los detalles a +continuación. + +```mermaid +flowchart LR +A([fa:fa-user Nuevo
Contribuyente]) --- id1[(open-telemetry/opentelemetry.io
GitHub)] +subgraph tasks[Editando en GitHub] +direction TB + 0[ ] -.- + 1[Edita esta página] --> 2[Usa el editor de markdown en GitHub
para hacer tus cambios] + 2 --> 3[Agrega tus propuesta de cambios] + +end +subgraph tasks2[ ] +direction TB +4[Selecciona los archivos a cambiar] --> 5[Haz click en Crear Pull Request] --> 6[Llena los cambios en Abriendo un Pull Request] +6 --> 7[Haz click en Crear pull request] +end + +id1 --> tasks --> tasks2 + +classDef grey fill:#dddddd,stroke:#ffffff,stroke-width:px,color:#000000, font-size:15px; +classDef white fill:#ffffff,stroke:#000,stroke-width:px,color:#000,font-weight:bold +classDef k8s fill:#326ce5,stroke:#fff,stroke-width:1px,color:#fff; +classDef spacewhite fill:#ffffff,stroke:#fff,stroke-width:0px,color:#000 +class A,1,2,3,4,5,6,7 grey +class 0 spacewhite +class tasks,tasks2 white +class id1 k8s +``` + +_Figura 2. Pasos para abrir un Pull Request desde GitHub._ + +1. En la página de la tarea en GitHub, selecciona **Editar esta página** en el + panel de navegación en la derecha. + +1. Si no eres miembro de este proyecto, puedes hacer fork al repositorio de + GitHub. Selecciona **Fork**. + +1. Haz tus cambios desde el editor de GitHub. + +1. Llena el formulario de **Subir cambios**. + +1. Selecciona **Proponer cambios**. + +1. Selecciona **Crear pull request**. + +1. Cuando la pantalla de **Abrir un pull request** aparezca. Agrega una + descripción para que los supervisores puedan comprender tus cambios. + +1. Selecciona **Crear pull request**. + +Antes de hacer merge de tus cambios, Los miembros de la comunidad de +OpenTelemetry harán revisión de tus cambios y los aprobarán. + +Si un miembro te pide hacer cambios: + +1. Ve a la pestaña de **Archivos cambiados**. +1. Selecciona el icono del lápiz (Editar) en cualquiera de los archivos + cambiados en tu pull request. +1. Haz los cambios solicitados. Si hay alguna sugerencia de código, aplícala. +1. Haz commit de tus cambios. + +Cuando la revisión a terminado, un miembro de la comunidad hará merge de tu pull +request y tus cambios estarán disponibles al público en algunos minutos. + +{{% alert title="Tip" %}} + +Haz un comentario con `/fix:format` en tu pull request para realizar una +revisión automática de formateo de tus cambios. + +{{% /alert %}} + +## Editar desde una rama local {#fork-the-repo} + +Si eres un usuario más experimentado con Git, o tus cambios afectan varios +archivos a la vez, trabaja desde una rama local. + +Asegúrate de que tienes +[Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git) instalado +en tu computadora. También puedes usar una interfaz gráfica de Git. + +La figura 3 muestra los pasos a seguir cuando se trabaja desde una rama local. A +continuación se detallan los pasos. + +```mermaid +flowchart LR +1[Haz fork del repositorio
open-telemetry/opentelemetry] --> 2[Crea una rama local
y agrega el remote upstream] +subgraph changes[Tus cambios] +direction TB +S[ ] -.- +3[Crea una rama
ejemplo: mi_nueva_rama] --> 3a[Haz los cambios
en un editor de texto] --> 4["Revisa tus cambios
localmente usando Hugo
(localhost:1313)"] +end +subgraph changes2[Haz Commit / Push] +direction TB +T[ ] -.- +5[Haz commit de tus cambios] --> 6[Haz push de tus cambios
origin/mi_nueva_rama] +end + +2 --> changes --> changes2 + +classDef grey fill:#dddddd,stroke:#ffffff,stroke-width:px,color:#000000, font-size:15px; +classDef white fill:#ffffff,stroke:#000,stroke-width:px,color:#000,font-weight:bold +classDef k8s fill:#326ce5,stroke:#fff,stroke-width:1px,color:#fff; +classDef spacewhite fill:#ffffff,stroke:#fff,stroke-width:0px,color:#000 +class 1,2,3,3a,4,5,6 grey +class S,T spacewhite +class changes,changes2 white +``` + +_Figura 3. Trabajando desde una rama local para hacer cambios._ + +### Haz fork al repositorio de opentelemetry.io + +1. Navega al repositorio + [`opentelemetry.io`](https://github.com/open-telemetry/opentelemetry.io/) . +1. Selecciona **Fork**. + +### Crea un clon local y agrega el upstream + +1. En tu terminal, clona tu fork y instala las dependencias: + + ```shell + git clone git@github.com:/opentelemetry.io.git + cd opentelemetry.io + npm install + ``` + +1. Coloca el repositorio de `open-telemetry/opentelemetry.io` como el `upstream` + remote: + + ```shell + git remote add upstream https://github.com/open-telemetry/opentelemetry.io.git + ``` + +1. Confirma los valores de los remotes `origin` y `upstream`: + + ```shell + git remote -v + ``` + + La salida debe ser similar a: + + ```none + origin git@github.com:/opentelemetry.io.git (fetch) + origin git@github.com:/opentelemetry.io.git (push) + upstream https://github.com/open-telemetry/opentelemetry.io.git (fetch) + upstream https://github.com/open-telemetry/opentelemetry.io.git (push) + ``` + +1. Actualiza los cambios de la rama `origin/main` en tu fork y la rama + `upstream/main` del repositorio original `open-telemetry/opentelemetry.io`: + + ```shell + git fetch origin + git fetch upstream + ``` + +Esto se asegura de que tu repositorio local está actualizado antes de que +empieces a hacer tus cambios localmente. Realiza esto frecuentemente para +mantener tu copia local sincronizada con la versión en el repositorio original. + +### Crea una rama + +1. Crea una rama. Este ejemplo asume que tomaremos de referencia la rama + `upstream/main`: + + ```shell + git checkout -b upstream/main + ``` + +1. Haz tus cambios en tu editor de código favorito. + +Usa el comando `git status` con regularidad para visualizar los archivos que has +cambiado. + +### Haz commit de tus cambios + +Cuando estás listo para subir tu pull request, haz commit de tus cambios. + +1. En tu repositorio local, revisa los cambios que quieres subir a GitHub: + + ```shell + git status + ``` + + La salida debe ser similar a: + + ```none + On branch + Your branch is up to date with 'origin/'. + + Changes not staged for commit: + (use "git add ..." to update what will be committed) + (use "git checkout -- ..." to discard changes in working directory) + + modified: content/en/docs/nombre_de_tu_archivo.md + + no changes added to commit (use "git add" and/or "git commit -a") + ``` + +1. Agrega los archivos listados debajo de **Changes not staged for commit** al + commit: + + ```shell + git add + ``` + + Repite esto para cada uno de los archivos a subir. + +1. Luego de modificar todos los archivos, crea un commit: + + ```shell + git commit -m "Mensaje de tu commit" + ``` + +1. Sube los cambios a tu rama local: + + ```shell + git push origin + ``` + +1. Una vez tus cambios fueron subidos, GitHub te notifica si quieres crear un + Pull Request (PR) de tus cambios. + +### Abrir un Pull Request de tu Fork {#open-a-pr} + +La Figura 4 muestra los pasos para abrir un PR desde tu rama a +[opentelemetry.io](https://github.com/open-telemetry/opentelemetry.io). + +```mermaid +flowchart LR +subgraph first[ ] +direction TB +1[Abre el repositorio opentelemetry.io] --> 2[Haz click en nuevo Pull Request] +2 --> 3[Haz click en comparar entre forks] +3 --> 4[Selecciona tu fork
desde el drop-down] +end +subgraph second [ ] +direction TB +5[Selleciona tu rama desde
el menu de comparación] --> 6[Haz click en crear nuevo Pull Request] +6 --> 7[Agrega una descripción
a tu PR] +7 --> 8[Haz click en crear pull request] +end + +first --> second + +classDef grey fill:#dddddd,stroke:#ffffff,stroke-width:px,color:#000000, font-size:15px; +classDef white fill:#ffffff,stroke:#000,stroke-width:px,color:#000,font-weight:bold +class 1,2,3,4,5,6,7,8 grey +class first,second white +``` + +\_Figura 4. Pasos para abrir un PR desde tu fork a +[opentelemetry.io](https://github.com/open-telemetry/opentelemetry.io). + +1. En un navegador web, ve al repositorio + [`opentelemetry.io`](https://github.com/open-telemetry/opentelemetry.io) . +1. Selecciona **Nuevo Pull Request**. +1. Selecciona **Comparar ramas**. +1. En el menú desplegable **repositorio principal**, selecciona su rama. +1. En el menú desplegable **Comparar**, selecciona tu rama. +1. Selecciona **Crear Pull Request**. +1. Agrega una descripción para tu pull request: + + - **Título** (50 caracteres o menos): Resume la intención del cambio. + - **Descripción**: Describe el cambio con más detalle. + + - Si hay un problema de GitHub relacionado, incluye `Fixes #12345` o + `Closes #12345` en la descripción para que la automatización de GitHub + cierre el problema mencionado después de fusionar el PR. Si hay otros PR + relacionados, vincúlalos también. + - Si quieres asesoramiento sobre algo específico, incluye cualquier pregunta + que te gustaría que los miembros consideren en tu descripción. + +1 Haz click en el botón **Crear pull request**. + +Tu pull request estará disponible en +[pull Requests](https://github.com/open-telemetry/opentelemetry.io/pulls). + +Después de abrir un PR, GitHub ejecuta pruebas automatizadas e intenta +implementar una vista previa usando [Netlify](https://www.netlify.com/). + +- Si la compilación de Netlify falla, selecciona **Detalles** para obtener más + información. +- Si la compilación de Netlify se realiza correctamente, selecciona **Detalles** + para abrir una versión preparada del sitio web de OpenTelemetry con los + cambios aplicados. Así es como los revisores verifican sus cambios. + +También pueden fallar otras comprobaciones. Consulta la +[lista de todas las comprobaciones de PR](/docs/contributing/pr-checks). + +### Soluciona problemas de contenido automáticamente {#fix-content-issues-automatically} + +Antes de enviar un cambio al repositorio, ejecuta el siguiente comando y (i) +aborda los problemas informados, (ii) confirma los archivos modificados por el +script: + +```sh +npm run test-and-fix +``` + +Para probar y solucionar por separado todos los problemas con tus archivos, +ejecuta: + +```sh +npm run test # Checks but does not update any files +npm run fix:all # May update files +``` + +Para enumerar los scripts NPM disponibles, ejecuta `npm run`. Consulta los +[Pre-requisitos de PR](/docs/contributing/pr-checks) para obtener más +información sobre las verificaciones de los Pull Request y cómo solucionar +errores automáticamente. + +### Obtén una vista previa de tus cambios localmente {#preview-locally} + +Obtén una vista previa de tus cambios localmente antes de enviarlos o abrir un +pull request. Una vista previa te permite detectar errores de compilación o +problemas de formato de Markdown. + +Para crear y servir el sitio localmente con Hugo, ejecuta el siguiente comando: + +```shell +npm run serve +``` + +Navega a `http://localhost:1313` en su navegador web para ver la vista previa +local. Hugo observa los cambios y reconstruye el sitio según sea necesario. + +Para detener la instancia local de Hugo, vuelve a la terminal y escriba +`Ctrl+C`, o cierre la ventana de la terminal. + +### Implementaciones del sitio y vistas previas de PR + +Si envías una PR, Netlify crea una [Vista Previa de Implementación][] para que puedas +revisar sus cambios. Una vez que se fusiona su PR, Netlify implementa el sitio actualizado +en el servidor de producción. + +> **Nota**: Las vistas previas de PR incluyen _páginas de borrador_, pero las +> compilaciones de producción no. + +Para ver los registros de implementación y más, visita el [Panel de Control][] +del proyecto. Se requiere inicio de sesión en Netlify. + +### Pautas de PR + +Antes de fusionar un PR, a veces se requieren algunas iteraciones de revisión y +edición. Para ayudarnos a nosotros y a ti mismo a hacer que este proceso sea lo +más sencillo posible, te pedimos que respetes lo siguiente: + +- Si su PR no es una solución rápida, entonces **trabaja desde una copia**: + selecciona el botón + [Fork](https://github.com/open-telemetry/opentelemetry.io/fork) en la parte + superior del repositorio y clone el repositorio localmente. Cuando esté listo, + genere un PR al repositorio original. +- **No trabajes desde la rama `main`** de su fork: crea una rama específica para + el PR. +- Asegúrate de que los mantenedores tengan permiso para + [aplicar cambios a tu solicitud de incorporación de cambios](https://docs.github.com/es/pull-requests/collaborating-with-pull-requests/working-with-forks/allowing-changes-to-a-pull-request-branch-created-from-a-fork). + +### Cambios de los revisores + +A veces, los revisores suben cambios en tu pull request. Antes de realizar +cualquier otro cambio, actualiza tu rama. + +1. Actualiza los commits de tu fork y haz rebase de tu rama actual: + + ```shell + git fetch origin + git rebase origin/ + ``` + +1. Luego de hacer rebase, sube tus nuevos cambios a tu fork: + + ```shell + git push --force-with-lease origin + ``` + +También puedes resolver conflictos de fusión desde la interfaz de usuario de +GitHub. + +### Conflictos en ramas y git rebase + +Si otro colaborador realiza cambios en el mismo archivo en otro pull request, +puedes crear un merge. Es tu responsabilidad resolver todos los conflictos en tu +Pull Request. + +1. Actualiza tu fork y haz git rebase de tu rama local: + + ```shell + git fetch origin + git rebase origin/ + ``` + + Luego haz force-push de tus cambios a tu fork: + + ```shell + git push --force-with-lease origin + ``` + +1. Actualiza los cambios de la rama `upstream/main` en + `open-telemetry/opentelemetry.io` y haz git rebase a tu rama actual: + + ```shell + git fetch upstream + git rebase upstream/main + ``` + +1. Inspecciona los resultados del git rebase: + + ```shell + git status + ``` + + Esto indicará la cantidad de archivos marcados con conflictos. + +1. Abra cada archivo en conflicto y busque los marcadores de conflicto: `>>>`, + `<<<`, y `===`. Resuelva el conflicto y elimine el marcador de conflicto. + +Para obtener más información, consulta +[Cómo se presentan los conflictos](https://git-scm.com/docs/git-merge#_how_conflicts_are_presented). + +1. Agrega los archivos al conjunto de cambios: + + ```shell + git add + ``` + +1. Haz force push de los cambios en tu rama a tu fork: + + ```shell + git push --force-with-lease origin + ``` + + El pull request ya no muestra ningún conflicto. + +### Requisitos para hacer merge + +Los pull request se hacen merge cuando cumplen con los siguientes criterios: + +- Todas las revisiones realizadas por aprobadores, mantenedores, miembros del + comité técnico o expertos en la materia tienen el estado "Aprobado". +- No hay conversaciones sin resolver. +- Aprobado por al menos un aprobador. +- No hay comprobaciones de PR fallidas. +- La rama de PR está actualizada con la rama base. + +> **Importante** +> +> No te preocupes demasiado por las comprobaciones de PR fallidas. Los miembros +> de la comunidad te ayudarán a solucionarlas, ya sea proporcionándote +> instrucciones sobre cómo solucionarlas o solucionándolas en tu nombre. + +[Panel de Control]: https://app.netlify.com/sites/opentelemetry/overview +[Vista Previa de Implementación]: + https://www.netlify.com/blog/2016/07/20/introducing-deploy-previews-in-netlify/ diff --git a/content/fr/_index.md b/content/fr/_index.md new file mode 100644 index 000000000000..35510acdf412 --- /dev/null +++ b/content/fr/_index.md @@ -0,0 +1,100 @@ +--- +title: OpenTelemetry +description: >- + Une télémétrie de qualité, universelle et portable pour une observabilité + efficace +outputs: + - HTML + - REDIRECTS # Include this `content/fr` ONLY +developer_note: + La macro "blocks/cover" définie ci-dessous permet d'utiliser comme image de + fond tout visuel contenant "background" dans son nom. +show_banner: true +default_lang_commit: 90dcedd7f692a505eb86145734b1e323ec988820 +--- + +
+ +{{< blocks/cover image_anchor="top" height="max" color="primary" >}} + + +![OpenTelemetry](/img/logos/opentelemetry-horizontal-color.svg) +{.otel-logo} + + +{{% param description %}} +{.display-6} + +
+ +- [En savoir plus](docs/what-is-opentelemetry/) +- [Tester la démo](docs/demo/) + +
+ +
+Découvrez OpenTelemetry en tant que: +
+
+ +- [Dev](docs/getting-started/dev/) +- [Ops](docs/getting-started/ops/) + +
+{{< /blocks/cover >}} + +{{% blocks/lead color="white" %}} + +OpenTelemetry met à votre disposition un ensemble d'APIs, de SDKs et d'outils +vous permettant d'instrumenter, de générer, de collecter et d'exporter des +métriques, des logs et des traces (les "données de télémétrie") pour analyser la +performance et le comportement de vos logiciels. + +> OpenTelemetry [supporte](/status/) de nombreux [langages](docs/languages/) et +> peut être utilisé en production. + +{{% /blocks/lead %}} + +{{% blocks/section color="dark" type="row" %}} + +{{% blocks/feature icon="fas fa-chart-line" title="Traces, Métriques, Logs" url="docs/concepts/observability-primer/" %}} + +Créez et collectez des données de télémétrie pour vos services et vos logiciels, +transmettez-les à une multitude d'outils d'analyse. + +{{% /blocks/feature %}} + +{{% blocks/feature icon="fas fa-magic" title="Instrumentation & Intégrations clé en main" %}} + +OpenTelemetry [s'intègre] avec de nombreuses librairies et frameworks et propose +une [instrumentation] _code et no-code_. + +[instrumentation]: /docs/concepts/instrumentation/ +[s'intègre]: /ecosystem/integrations/ + +{{% /blocks/feature %}} + +{{% blocks/feature icon="fab fa-github" title="Open Source, Indépendant" %}} + +Entièrement gratuit et open source, OpenTelemetry est [utilisé] et supporté par +des [leaders] du marché de l'observabilité. + +[utilisé]: /ecosystem/adopters/ +[leaders]: /ecosystem/vendors/ + +{{% /blocks/feature %}} + +{{% /blocks/section %}} + +{{% blocks/section color="secondary" type="cncf" %}} + +**OpenTelemetry est un projet [CNCF][] en phase d'[incubation]**.
Né de la +fusion des projets OpenTracing et OpenCensus. + +[![CNCF logo][]][cncf] + +[cncf]: https://cncf.io +[cncf logo]: /img/logos/cncf-white.svg +[incubation]: https://www.cncf.io/projects/ + +{{% /blocks/section %}} diff --git a/content/fr/docs/what-is-opentelemetry.md b/content/fr/docs/what-is-opentelemetry.md new file mode 100644 index 000000000000..e6e7ea1bcfe3 --- /dev/null +++ b/content/fr/docs/what-is-opentelemetry.md @@ -0,0 +1,133 @@ +--- +title: Qu'est-ce qu'OpenTelemetry ? +description: + Une brève explication de ce qu'est OpenTelemetry, et de ce qu'il n'est pas. +weight: 150 +default_lang_commit: 71833a5f8b84110dadf1e98604b87a900724ac33 +--- + +OpenTelemetry, c'est : + +- Un framework + d'[observabilité](/docs/concepts/observability-primer/#what-is-observability) + et des outils conçus pour créer et gérer des données de télémétrie telles que + des [traces](/docs/concepts/signals/traces/), des + [metriques](/docs/concepts/signals/metrics/), et des + [logs](/docs/concepts/signals/logs/) +- Indépendant d'un fournisseur et d'un outil, ce qui signifie qu'il peut être + utilisé avec une grande variété de backends d'observabilité, y compris des + outils open source tels que [Jaeger](https://www.jaegertracing.io/) et + [Prometheus](https://prometheus.io/), ainsi que des outils commerciaux +- Pas un backend d'observabilité tel que Jaeger, Prometheus ou d'autres outils + commerciaux +- Axé sur la génération, la collecte, la gestion et l'export de données de + télémétrie. L'un des objectifs principaux d'OpenTelemetry est de pouvoir + aisément instrumenter vos applications ou systèmes, quelque soit leur langage, + infrastructure, ou environnement d'exécution. Le stockage et la visualisation + des données sont intentionnellement laissés à d'autres outils + +## Qu'est-ce que l'observabilité ? + +L'[observabilité](/docs/concepts/observability-primer/#what-is-observability) +est la capacité de comprendre l'état interne d'un système en examinant ses +données sortantes. Dans un contexte logiciel, cela signifie être capable de +comprendre l'état interne d'un système en examinant ses données de télémétrie, +qui incluent les traces, métriques et logs. + +Pour rendre un système observable, il doit être +[instrumenté](/docs/concepts/instrumentation). Cela signifie que le code doit +émettre des [traces](/docs/concepts/signals/traces/), des +[métriques](/docs/concepts/signals/metrics/), et/ou des +[logs](/docs/concepts/signals/logs/). Les données produites doivent être +transmises à un backend d'observabilité. + +## Pourquoi OpenTelemetry ? + +Avec l'essor du cloud computing, des architectures en microservices, et des +exigences commerciales de plus en plus complexes, le besoin +d'[observabilité](/docs/concepts/observability-primer/#what-is-observability) +des logiciels et de l'infrastructure est plus grand que jamais. + +OpenTelemetry répond au besoin d'observabilité tout en suivant deux principes +clés : + +1. Vous êtes propriétaire des données que vous générez. Il n'y a pas de + dépendance vis-à-vis d'un fournisseur +2. Vous n'avez besoin d'apprendre qu'un seul ensemble d'APIs et de conventions + +Ces deux principes combinés offrent aux équipes et aux organisations la +flexibilité dont elles ont besoin dans le monde informatique moderne +d’aujourd’hui. + +Si vous souhaitez en savoir plus, jetez un oeil à la +[mission, la vision et les valeurs](/community/mission/) d'OpenTelemetry. + +## Composants principaux d'OpenTelemetry + +OpenTelemetry se compose des principaux composants suivants : + +- Une [spécification](/docs/specs/otel) pour tous les composants +- Un [protocole](/docs/specs/otlp/) standardisé définissant le format des + données de télémétrie +- Des [conventions sémantiques](/docs/specs/semconv/) définissant une + nomenclature standardisée pour décrire les données de télémétrie +- Des APIs décrivant comment générer des données de télémétrie +- Des [SDKs par langage](/docs/languages) qui implémentent les spécifications, + les APIs et l'export des données de télémétrie +- Un [écosystème de bibliothèques](/ecosystem/registry) qui instrumentent des + bibliothèques et frameworks +- Des composants d'instrumentation automatique qui génèrent des données de + télémétrie sans requérir de modifications de code +- Le [Collector OpenTelemetry](/docs/collector), un proxy qui reçoit, modifie et + exporte les données de télémétrie +- Divers autres outils, tels que + l'[Opérateur Kubernetes pour OpenTelemetry](/docs/kubernetes/operator/), les + [Helm Charts pour OpenTelemetry](/docs/kubernetes/helm/) et des + [ressources communautaires pour les FaaS](/docs/faas/) + +OpenTelemetry est utilisé par une grande variété de +[bibliothèques, services et applications](/ecosystem/integrations/) qui +intègrent OpenTelemetry afin de fournir de l'observabilité par défaut. + +OpenTelemetry est pris en charge par de nombreux +[fournisseurs](/ecosystem/vendors/), dont beaucoup fournissent un support +commercial à OpenTelemetry et contribuent au projet directement. + +## Extensibilité + +OpenTelemetry est conçu pour être extensible. Quelques exemples de la façon dont +il peut être étendu incluent : + +- Ajouter un receveur au Collecteur OpenTelemetry afin de prendre en charge les + données de télémétrie venant d'une source de données personnalisée +- Charger des bibliothèques d'instrumentation personnalisées dans un SDK +- Créer une [distribution](/docs/concepts/distributions/) d'un SDK, ou du + collecteur adapté à une utilisation spécifique +- Créer un nouvel exportateur pour un backend personnalisé qui ne prend pas + encore en charge le protocole OpenTelemetry (OTLP) +- Créer un propagateur personnalisé pour un format de propagation de contexte + non standard + +Bien que la plupart des utilisateurs n’aient pas besoin d’étendre OpenTelemetry, +le projet est conçu pour rendre cela possible presque à tous les niveaux. + +## Histoire + +OpenTelemetry est un projet de la +[Cloud Native Computing Foundation (CNCF)](https://www.cncf.io) qui trouve son +origine dans la fusion de deux projets antérieurs, +[OpenTracing](https://opentracing.io) et [OpenCensus](https://opencensus.io). +Ces deux projets ont été créés pour résoudre le même problème : l'absence d'une +norme décrivant la manière d'instrumenter du code et de transmettre des données +de télémétrie à un backend d'observabilité. Aucun des projets n'étant en mesure +de résoudre ce problème de manière indépendante, ils ont fusionné pour former +OpenTelemetry et combiner leurs forces tout en offrant une solution unique. + +Si vous utilisez actuellement OpenTracing ou OpenCensus, vous pouvez découvrir +comment migrer vers OpenTelemetry dans le +[guide de migration](/docs/migration/). + +## Et ensuite ? + +- [Pour commencer](/docs/getting-started/) — Lancez-vous directement ! +- Découvrez les [concepts d'OpenTelemetry](/docs/concepts/) diff --git a/content/ja/docs/concepts/instrumentation/libraries.md b/content/ja/docs/concepts/instrumentation/libraries.md index e7c89111f324..38d1ed962104 100644 --- a/content/ja/docs/concepts/instrumentation/libraries.md +++ b/content/ja/docs/concepts/instrumentation/libraries.md @@ -3,6 +3,10 @@ title: ライブラリ description: ライブラリにネイティブ計装を追加する方法を紹介します。 weight: 40 default_lang_commit: d8c5612 +htmltest: + IgnoreDirs: + # TODO drop next line after https://github.com/open-telemetry/opentelemetry.io/issues/5423 is fixed for ja pages: + - ^ja/docs/concepts/instrumentation/libraries/ --- OpenTelemetryは、多くのライブラリに[計装ライブラリ][instrumentation libraries]を提供していて、これは通常、ライブラリフックやモンキーパッチライブラリコードを通して行われます。 diff --git a/content/pt/docs/concepts/components.md b/content/pt/docs/concepts/components.md new file mode 100644 index 000000000000..b7a74b6823b0 --- /dev/null +++ b/content/pt/docs/concepts/components.md @@ -0,0 +1,143 @@ +--- +title: Componentes +description: Os principais componentes que compõem o OpenTelemetry +weight: 20 +default_lang_commit: 2f34c456ab38b4d3502cd07bc36fa1455d4ef875 +--- + +O OpenTelemetry é atualmente composto por vários componentes principais: + +- [Especificação](#specification) +- [Collector](#collector) +- [Implementações de API e SDK específicas](#language-specific-api--sdk-implementations) + - [Bibliotecas de Instrumentação](#instrumentation-libraries) + - [Exporters](#exporters) + - [Instrumentação sem código](#zero-code-instrumentation) + - [Detectores de Recursos](#resource-detectors) + - [Propagadores entre Serviços](#cross-service-propagators) + - [Amostragens](#samplers) +- [Kubernetes Operator](#kubernetes-operator) +- [Função como Serviço](#function-as-a-service-assets) + +O OpenTelemetry permite que você substitua o uso de SDKs ou ferramentas +específicas para gerar e exportar dados de telemetria. + +## Especificação {#specification} + +Descreve os requisitos e expectativas entre diferentes linguagens para todas as +implementações. Além de uma definição de termos, a especificação define o +seguinte: + +- **API:** Define tipos de dados e operações para gerar e correlacionar dados de + rastreamento, métricas e logs. +- **SDK:** Define os requisitos para implementação específica de linguagem da + API. São definidos aqui também os conceitos de configuração, processamento e + exportação de dados. +- **Data:** Define o Protocolo OpenTelemetry (OTLP) e as convenções semânticas + independentes de fornecedores que um backend de telemetria pode suportar. + +Para mais informações, consulte [especificação](/docs/specs/). + +## Collector + +O Collector é um proxy para qualquer sistema de telemetria que pode receber..., +processar e exportar dados de telemetria. Ele suporta o recebimento de dados de +telemetria em vários formatos. (Por exemplo, OTLP, Jaeger, Prometheus, bem como +muitas outras ferramentas ) .e enviar dados para um ou mais sistema de +telemetria. Ele também suporta o processamento e a filtragem de dados de +telemetria antes de serem exportados. + +Para mais informações, consulte [Coletor](/docs/collector/). + +## Implementações de API e SDK específicas {#language-specific-api--sdk-implementations} + +O OpenTelemetry também possui SDKs para as linguagens mais populares do mercado +e permitem usar a API do OpenTelemetry para gerar dados de telemetria e exportar +esses dados para qualquer sistema de telemetria. Esses SDKs também permitem que +você utilize qualquer biblioteca e ou frameworks dessas linguagens da +instrumentação manual. + +Para mais informações, consulte +[Instrumentando](/docs/concepts/instrumentation/). + +### Bibliotecas de instrumentação {#instrumentation-libraries} + +O OpenTelemetry suporta um grande número de componentes que geram dados de +telemetria relevantes a partir de bibliotecas e frameworks populares para as +linguagens suportadas. Por exemplo, requisições HTTP de entrada e saída de uma +biblioteca HTTP geram dados sobre essas requisições. Um objetivo aspiracional do +OpenTelemetry é que todas as bibliotecas populares sejam construídas para serem +observáveis por padrão, de modo que dependências separadas não sejam +necessárias. + +Para mais informações, consulte +[Bibliotecas de instrumentação](/docs/concepts/instrumentation/libraries/). + +### Exporters + +{{% docs/languages/exporters/intro %}} + +### Instrumentação sem código {#zero-code-instrumentation} + +O OpenTelemetry possibilita essa forma de instrumentar sua aplicação sem alterar +seu código-fonte. Embora o mecanismo dependa da linguagem, a instrumentação sem +código adiciona as capacidades da API e do SDK do OpenTelemetry à sua aplicação. +Além disso, pode adicionar um conjunto de bibliotecas de instrumentação e +dependências do exportador. + +Para mais informações, consulte +[Instrumentação sem código](/docs/concepts/instrumentation/zero-code/). + +### Detectores de recursos {#resource-detectors} + +Um [recurso](/docs/concepts/resources/) representa a entidade que produz +telemetria como atributos de recurso. Por exemplo, um processo que produz +telemetria que está sendo executado em um contêiner no Kubernetes tem um nome de +Pod, um namespace e possivelmente um nome de implantação. Você pode incluir +todos esses atributos no recurso. As implementações específicas de linguagem do +OpenTelemetry fornecem detecção de recursos a partir da variável de ambiente +`OTEL_RESOURCE_ATTRIBUTES` e para muitas entidades comuns, como tempo de +execução do processo, serviço, host ou sistema operacional. + +Para mais informações, consulte [Recursos](/docs/concepts/resources/). + +### Propagadores entre serviços {#cross-service-propagators} + +A propagação é o mecanismo que move dados entre serviços e processos. Embora não +se limite ao rastreamento, a propagação permite que os rastros construam +informações sobre um sistema através de serviços que estão distribuídos +arbitrariamente entre limites de processos e redes. + +Na grande maioria dos casos de uso, a propagação de contexto ocorre por meio de +bibliotecas de instrumentação. Se for necessário, você pode usar propagadores +manualmente para serializar e desserializar aspectos como o contexto de um +trecho e a [bagagem](/docs/concepts/signals/baggage/). + +### Amostragem {#samplers} + +A amostragem é um processo que restringe a quantidade de rastros que são gerados +por um sistema. Cada implementação específica de linguagem do OpenTelemetry +oferece [amostradores pela cabeça](/docs/concepts/sampling/#head-sampling). +[Amostragem](/docs/concepts/sampling/#head-sampling). + +Para mais informações, consulte [Amostragem](/docs/concepts/sampling). + +## Operador Kubernetes {#kubernetes-operator} + +O OpenTelemetry Operator é a implementação de um Operador Kubernetes. O operador +gerencia o OpenTelemetry Collector e a instrumentação sem código das cargas de +trabalho que utilizam OpenTelemetry. + +Para mais informações, consulte +[Kubernetes Operator](/docs/kubernetes/operator/). + +## Função como Serviço {#function-as-a-service-assets} + +O OpenTelemetry oferece vários métodos de monitoramento de Function-as-a-Service +fornecidos por diferentes provedores de nuvem. A comunidade OpenTelemetry +atualmente disponibiliza camadas Lambda pré-construídas, capazes de realizar +instrumentação sem código na sua aplicação, bem como a opção de uma camada +Lambda do Coletor independente, que pode ser usada ao instrumentar aplicações +manualmente ou automaticamente. + +Para mais informações, consulte [Função como Serviço](/docs/faas/). diff --git a/content/pt/docs/concepts/instrumentation/_index.md b/content/pt/docs/concepts/instrumentation/_index.md new file mode 100644 index 000000000000..539373707905 --- /dev/null +++ b/content/pt/docs/concepts/instrumentation/_index.md @@ -0,0 +1,56 @@ +--- +title: Instrumentação +description: Como o OpenTelemetry facilita a instrumentação +weight: 15 +default_lang_commit: 82bd738d51426acb34e126b230a8a1281f193e3e +--- + +Para que um sistema seja observável, ele deve ser **instrumentado**: ou seja, o +código dos componentes do sistema deve emitir +[rastros](/docs/concepts/signals/traces/), +[métricas](/docs/concepts/signals/metrics/) e +[logs](/docs/concepts/signals/logs/). + +Com o OpenTelemetry, você pode instrumentar seu código de duas maneiras: + +1. [Soluções manuais](/docs/concepts/instrumentation/code-based) por meio das + [APIs e SDKs oficiais para a maioria das linguagens](/docs/languages/) +2. [Soluções sem código](/docs/concepts/instrumentation/zero-code/) + +As **soluções manuais** permitem obter uma visão mais aprofundada e telemetria +rica diretamente da sua aplicação. Possibilitando o uso da API OpenTelemetry +para gerar telemetria a partir da sua aplicação, atuando como um complemento +essencial para telemetria gerada pelas soluções sem código. + +As **soluções sem código** são ótimas para começar ou quando você não pode +modificar a aplicação da qual precisa extrair telemetria. Provendo telemetria +rica das bibliotecas que você utiliza e/ou do ambiente em que sua aplicação está +sendo executada. Outra forma de pensar nisso é que elas oferecem informações +sobre o que está acontecendo _nas bordas_ da sua aplicação. + +Você pode utilizar ambas as soluções simultaneamente. + +## Benefícios adicionais do OpenTelemetry + +O OpenTelemetry oferece mais do que apenas soluções de telemetria manuais e sem +código. Os seguintes recursos também fazem parte do OpenTelemetry: + +- Bibliotecas podem utilizar a API OpenTelemetry como dependência, sem impactar + as aplicações que usam essa biblioteca, a menos que o SDK do OpenTelemetry + seja importado. +- Para cada [sinal](/docs/concepts/signals) (rastros, métricas, logs), você tem + à disposição diversos métodos para criá-los, processá-los e exportá-los. +- Com a [propagação de contexto](/docs/concepts/context-propagation) integrada + nas implementações, você pode correlacionar sinais, independentemente de onde + eles são gerados. +- [Recursos](/docs/concepts/resources) e + [Escopo de instrumentação](/docs/concepts/instrumentation-scope) permitem + agrupar sinais por diferentes entidades, como + [host](/docs/specs/semconv/resource/host/), + [sistema operacional](/docs/specs/semconv/resource/os/) ou + [cluster K8s](/docs/specs/semconv/resource/k8s/#cluster). +- Cada implementação específica de linguagem da API e SDK segue os requisitos e + expectativas da [especificação OpenTelemetry](/docs/specs/otel/). +- As [Convenções Semânticas](/docs/concepts/semantic-conventions) fornecem um + esquema de nomenclatura comum que pode ser usado para padronização em + diferentes bases de código e plataformas. diff --git a/content/pt/docs/concepts/instrumentation/libraries.md b/content/pt/docs/concepts/instrumentation/libraries.md index 3410ddd032f4..f9dd1e39938d 100644 --- a/content/pt/docs/concepts/instrumentation/libraries.md +++ b/content/pt/docs/concepts/instrumentation/libraries.md @@ -3,6 +3,10 @@ title: Bibliotecas description: Aprenda como adicionar instrumentação nativa à sua biblioteca. weight: 40 default_lang_commit: a570a00c7a238ffe26528d7bfb20efdbaf939c39 +htmltest: + IgnoreDirs: + # TODO drop next line after https://github.com/open-telemetry/opentelemetry.io/issues/5423 is fixed for pt pages: + - ^pt/docs/concepts/instrumentation/libraries/ --- O OpenTelemetry fornece [bibliotecas de instrumentação][] para várias diff --git a/content/pt/docs/languages/_index.md b/content/pt/docs/languages/_index.md new file mode 100644 index 000000000000..322681ad4122 --- /dev/null +++ b/content/pt/docs/languages/_index.md @@ -0,0 +1,62 @@ +--- +title: APIs e SDKs de Linguagens +description: + A instrumentação de código do OpenTelemetry é suportada para muitas linguagens + populares de programação. +weight: 250 +redirects: [{ from: /docs/instrumentation/*, to: ':splat' }] +default_lang_commit: b3a087c468094eb144ab3114aff06838c8fb06ca +--- + +A [instrumentação][] de código do OpenTelemetry é suportada para as linguagens +listadas na tabela de [Estado e Lançamentos](#status-and-releases) abaixo. +Implementações não oficiais para [outras linguagens](/docs/languages/other) +também estão disponíveis. Você pode encontrá-las no +[registro](/ecosystem/registry/). + +Para Go, .NET, PHP, Python, Java e JavaScript, você pode usar +[soluções de instrumentação automática](/docs/zero-code) para instrumentar suas +aplicações sem alterações de código. + +Se você estiver usando Kubernetes, você pode usar o [OpenTelemetry Operator para +Kubernetes][otel-op] para [injetar soluções de implementação +automática][implementação automática] em suas aplicações. + +## Estado e Lançamentos {#status-and-releases} + +O estado atual dos principais componentes funcionais do OpenTelemetry estão a +seguir: + +{{% alert title="Importante" color="warning" %}} + +Independente do estado de um API/SDK, se a sua instrumentação depende de +[convenções semânticas] que são marcadas como [Experimental] na [especificação +de +convenções semânticas], seu fluxo de dados pode estar sujeito à **quebra de +compatibilidade** + +[convenções semânticas]: /docs/concepts/semantic-conventions/ +[Experimental]: /docs/specs/otel/document-status/ +[especificação de convenções semânticas]: /docs/specs/semconv/ + +{{% /alert %}} + +{{% telemetry-support-table " " %}} + +## Referências da API + +Os Grupos de Interesse Especial (SIGs), que implementam a API e o SDK do +OpenTelemetry em diferentes linguagens e também disponibilizam referências da +API para desenvolvedores. As referências a seguir estão disponíveis: + +{{% apidocs %}} + +{{% alert title="Nota" color="info" %}} + +A lista acima é um alias para [`/api`](/api). + +{{% /alert %}} + +[implementação automática]: /docs/kubernetes/operator/automatic/ +[instrumentação]: /docs/concepts/instrumentation/ +[otel-op]: /docs/kubernetes/operator/ diff --git a/content/pt/docs/languages/go/_index.md b/content/pt/docs/languages/go/_index.md new file mode 100644 index 000000000000..390662a5e28d --- /dev/null +++ b/content/pt/docs/languages/go/_index.md @@ -0,0 +1,15 @@ +--- +title: Go +description: >- + Go A language-specific implementation of OpenTelemetry in Go. +aliases: [/golang, /golang/metrics, /golang/tracing] +weight: 16 +default_lang_commit: 06837fe15457a584f6a9e09579be0f0400593d57 +--- + +{{% pt/docs/languages/index-intro go /%}} + +## Mais + +- [Repositório Contrib](https://github.com/open-telemetry/opentelemetry-go-contrib) diff --git a/content/pt/docs/languages/go/api.md b/content/pt/docs/languages/go/api.md new file mode 100644 index 000000000000..f241e1951cf5 --- /dev/null +++ b/content/pt/docs/languages/go/api.md @@ -0,0 +1,9 @@ +--- +title: Referências da API +linkTitle: API +redirect: https://pkg.go.dev/go.opentelemetry.io/otel +manualLinkTarget: _blank +_build: { render: link } +weight: 210 +default_lang_commit: 06837fe15457a584f6a9e09579be0f0400593d57 +--- diff --git a/content/pt/docs/languages/go/examples.md b/content/pt/docs/languages/go/examples.md new file mode 100644 index 000000000000..2865a43ff16f --- /dev/null +++ b/content/pt/docs/languages/go/examples.md @@ -0,0 +1,8 @@ +--- +title: Exemplos +redirect: https://github.com/open-telemetry/opentelemetry-go/tree/main/example +manualLinkTarget: _blank +_build: { render: link } +weight: 220 +default_lang_commit: 06837fe15457a584f6a9e09579be0f0400593d57 +--- diff --git a/content/pt/docs/languages/go/getting-started.md b/content/pt/docs/languages/go/getting-started.md new file mode 100644 index 000000000000..a794d812d46b --- /dev/null +++ b/content/pt/docs/languages/go/getting-started.md @@ -0,0 +1,1177 @@ +--- +title: Primeiros Passos +weight: 10 +default_lang_commit: 7fd0d2a6b87d6bbf2d5a35340c7afbd2bb33ca1c +# prettier-ignore +cSpell:ignore: chan fatalln funcs intn itoa khtml otelhttp rolldice stdouttrace strconv +--- + + + + +Esta página mostrará como começar a utilizar o OpenTelemetry em Go. + +Você aprenderá como instrumentar manualmente uma aplicação simples, de modo que +os [rastros][traces], [métricas][metrics] e [logs][logs] sejam emitidos no +console. + +{{% alert title="Note" %}} + +Os sinais de logs ainda são experimentais. Alterações que quebrem a +compatibilidade podem ser introduzidas em versões futuras. + +{{% /alert %}} + +## Pré-requisitos {#prerequisites} + +Certifique-se de que você tenha a seguinte instalação localmente: + +- [Go](https://go.dev/) versão 1.22 ou superior + +## Aplicação de exemplo {#example-application} + +O seguinte exemplo usa uma aplicação [`net/http`](https://pkg.go.dev/net/http) +básica. Caso você não esteja usando `net/http`, não há problema — você pode +utilizar OpenTelemetry Go com outros frameworks da web, como Gin e Echo. Para +uma lista completa de bibliotecas para frameworks suportados, consulte o +[registro](/ecosystem/registry/?component=instrumentation&language=go). + +Para exemplos mais elaborados, consulte +[exemplos](/docs/languages/go/examples/). + +### Configuração {#setup} + +Para começar, configure um `go.mod` em um novo diretório: + +```shell +go mod init dice +``` + +### Criar e iniciar um servidor HTTP {#create-and-launch-an-http-server} + +Na mesma pasta, crie um arquivo chamado `main.go` e adicione o seguinte código +ao arquivo: + +```go +package main + +import ( + "log" + "net/http" +) + +func main() { + http.HandleFunc("/rolldice", rolldice) + + log.Fatal(http.ListenAndServe(":8080", nil)) +} +``` + +Crie outro arquivo chamado `rolldice.go` e adicione o seguinte código ao +arquivo: + +```go +package main + +import ( + "io" + "log" + "math/rand" + "net/http" + "strconv" +) + +func rolldice(w http.ResponseWriter, r *http.Request) { + roll := 1 + rand.Intn(6) + + resp := strconv.Itoa(roll) + "\n" + if _, err := io.WriteString(w, resp); err != nil { + log.Printf("Write failed: %v\n", err) + } +} +``` + +Compile e execute a aplicação utilizando o seguinte comando: + +```shell +go run . +``` + +Abra no seu navegador para garantir que está +funcionando. + +## Adicionar instrumentação do OpenTelemetry {#add-open-telemetry-instrumentation} + +Agora, vamos mostrar como adicionar instrumentação do OpenTelemetry à aplicação +de exemplo. Se você estiver usando sua própria aplicação, também pode acompanhar +os passos a seguir. Apenas note que seu código pode ser um pouco diferente do +exemplo. + +### Adicionar Dependências {#add-dependencies} + +Instale os seguintes pacotes: + +```shell +go get "go.opentelemetry.io/otel" \ + "go.opentelemetry.io/otel/exporters/stdout/stdoutmetric" \ + "go.opentelemetry.io/otel/exporters/stdout/stdouttrace" \ + "go.opentelemetry.io/otel/exporters/stdout/stdoutlog" \ + "go.opentelemetry.io/otel/sdk/log" \ + "go.opentelemetry.io/otel/log/global" \ + "go.opentelemetry.io/otel/propagation" \ + "go.opentelemetry.io/otel/sdk/metric" \ + "go.opentelemetry.io/otel/sdk/resource" \ + "go.opentelemetry.io/otel/sdk/trace" \ + "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"\ + "go.opentelemetry.io/contrib/bridges/otelslog" +``` + +Este comando instala os componentes do SDK OpenTelemetry e a instrumentação do +`net/http`. + +Se você estiver instrumentando uma biblioteca diferente para solicitações de +rede, precisará instalar a biblioteca de instrumentação apropriada. Consulte a +seção [bibliotecas](/docs/languages/go/libraries/) para mais informações. + +### Inicializar o SDK OpenTelemetry {#initialize-the-opentelemetry-sdk} + +Primeiro, vamos inicializar o SDK OpenTelemetry. Isso é _obrigatório_ para +qualquer aplicação que exporte telemetria. + +Crie um arquivo `otel.go` com o código de inicialização do SDK OpenTelemetry: + + + +```go +package main + +import ( + "context" + "errors" + "time" + + "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/exporters/stdout/stdoutlog" + "go.opentelemetry.io/otel/exporters/stdout/stdoutmetric" + "go.opentelemetry.io/otel/exporters/stdout/stdouttrace" + "go.opentelemetry.io/otel/log/global" + "go.opentelemetry.io/otel/propagation" + "go.opentelemetry.io/otel/sdk/log" + "go.opentelemetry.io/otel/sdk/metric" + "go.opentelemetry.io/otel/sdk/trace" +) + +// setupOTelSDK inicializa o pipeline do OpenTelemetry. +// Caso não retorne um erro, certifique-se de executar o método shutdown para realizar a finalização adequada. +func setupOTelSDK(ctx context.Context) (shutdown func(context.Context) error, err error) { + var shutdownFuncs []func(context.Context) error + + // shutdown chama as funções de finalização registradas via shutdownFuncs. + // Os erros das chamadas são concatenados. + // Cada função de finalização registrada será invocada uma única vez. + shutdown = func(ctx context.Context) error { + var err error + for _, fn := range shutdownFuncs { + err = errors.Join(err, fn(ctx)) + } + shutdownFuncs = nil + return err + } + + // handleErr chama a função shutdown para finalizar corretamente e garante que todos os erros serão retornados. + handleErr := func(inErr error) { + err = errors.Join(inErr, shutdown(ctx)) + } + + // Inicializa o Propagator. + prop := newPropagator() + otel.SetTextMapPropagator(prop) + + // Inicializa o Trace Provider. + tracerProvider, err := newTraceProvider() + if err != nil { + handleErr(err) + return + } + shutdownFuncs = append(shutdownFuncs, tracerProvider.Shutdown) + otel.SetTracerProvider(tracerProvider) + + // Inicializa o Meter Provider. + meterProvider, err := newMeterProvider() + if err != nil { + handleErr(err) + return + } + shutdownFuncs = append(shutdownFuncs, meterProvider.Shutdown) + otel.SetMeterProvider(meterProvider) + + // Inicializa o Logger Provider. + loggerProvider, err := newLoggerProvider() + if err != nil { + handleErr(err) + return + } + shutdownFuncs = append(shutdownFuncs, loggerProvider.Shutdown) + global.SetLoggerProvider(loggerProvider) + + return +} + +func newPropagator() propagation.TextMapPropagator { + return propagation.NewCompositeTextMapPropagator( + propagation.TraceContext{}, + propagation.Baggage{}, + ) +} + +func newTraceProvider() (*trace.TracerProvider, error) { + traceExporter, err := stdouttrace.New( + stdouttrace.WithPrettyPrint()) + if err != nil { + return nil, err + } + + traceProvider := trace.NewTracerProvider( + trace.WithBatcher(traceExporter, + // O valor padrão é 5s. Definimos em 1s para propósito de demonstração. + trace.WithBatchTimeout(time.Second)), + ) + return traceProvider, nil +} + +func newMeterProvider() (*metric.MeterProvider, error) { + metricExporter, err := stdoutmetric.New() + if err != nil { + return nil, err + } + + meterProvider := metric.NewMeterProvider( + metric.WithReader(metric.NewPeriodicReader(metricExporter, + // O valor padrão é 1m. Definimos em 3s para propósito de demonstração. + metric.WithInterval(3*time.Second))), + ) + return meterProvider, nil +} + +func newLoggerProvider() (*log.LoggerProvider, error) { + logExporter, err := stdoutlog.New() + if err != nil { + return nil, err + } + + loggerProvider := log.NewLoggerProvider( + log.WithProcessor(log.NewBatchProcessor(logExporter)), + ) + return loggerProvider, nil +} +``` + + +Caso você esteja utilizando apenas rastros ou métricas, você pode omitir o +código de inicialização do TracerProvider ou MeterProvider correspondente. + +### Instrumentação do servidor HTTP {#instrument-the-http-server} + +Agora que temos o SDK do OpenTelemetry inicializado, podemos instrumentar o +servidor HTTP. + +Modifique o arquivo `main.go` para incluir o código que configura o SDK do +OpenTelemetry e instrumenta o servidor HTTP utilizando a biblioteca de +instrumentação `otelhttp`: + + + +```go +package main + +import ( + "context" + "errors" + "log" + "net" + "net/http" + "os" + "os/signal" + "time" + + "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp" +) + +func main() { + if err := run(); err != nil { + log.Fatalln(err) + } +} + +func run() (err error) { + // Lidamos com o SIGINT (CTRL+C) de maneira segura. + ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt) + defer stop() + + // Configura o OpenTelemetry. + otelShutdown, err := setupOTelSDK(ctx) + if err != nil { + return + } + // Lidamos com a finalização corretamente, evitando leaks. + defer func() { + err = errors.Join(err, otelShutdown(context.Background())) + }() + + // Inicializamos o servidor HTTP. + srv := &http.Server{ + Addr: ":8080", + BaseContext: func(_ net.Listener) context.Context { return ctx }, + ReadTimeout: time.Second, + WriteTimeout: 10 * time.Second, + Handler: newHTTPHandler(), + } + srvErr := make(chan error, 1) + go func() { + srvErr <- srv.ListenAndServe() + }() + + // Aguardamos por uma interrupção. + select { + case err = <-srvErr: + // Erro ao inicializar o servidor HTTP. + return + case <-ctx.Done(): + // Aguardamos o primeiro CTRL+C. + // Para de receber sinais o mais rápido possível. + stop() + } + + // Quando o método Shutdown é chamado, ListenAndServe retornará imediatamente ErrServerClosed. + err = srv.Shutdown(context.Background()) + return +} + +func newHTTPHandler() http.Handler { + mux := http.NewServeMux() + + // handleFunc é uma substituição para mux.HandleFunc + // enriquecendo ainda mais a instrumentação HTTP utilizando padrões como http.route. + handleFunc := func(pattern string, handlerFunc func(http.ResponseWriter, *http.Request)) { + // Configura o "http.route" para a instrumentação HTTP. + handler := otelhttp.WithRouteTag(pattern, http.HandlerFunc(handlerFunc)) + mux.Handle(pattern, handler) + } + + // Registra os handlers. + handleFunc("/rolldice/", rolldice) + handleFunc("/rolldice/{player}", rolldice) + + // Adiciona a instrumentação HTTP para todo o servidor. + handler := otelhttp.NewHandler(mux, "/") + return handler +} +``` + + +### Adicionar instrumentação personalizada {#add-custom-instrumentation} + +As bibliotecas de instrumentação capturam telemetria nas bordas de seus +sistemas, como por exemplo requisições HTTP de entrada e saída, porém não +capturam o que está acontecendo dentro da sua aplicação. Para isso, você +precisará implementar uma [instrumentação manual](../instrumentation/) +personalizada. + +Modifique o arquivo `rolldice.go` para incluir instrumentação personalizada +usando a API do OpenTelemetry: + + + +```go +package main + +import ( + "fmt" + "io" + "log" + "math/rand" + "net/http" + "strconv" + + "go.opentelemetry.io/contrib/bridges/otelslog" + "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/metric" +) + +const name = "go.opentelemetry.io/otel/example/dice" + +var ( + tracer = otel.Tracer(name) + meter = otel.Meter(name) + logger = otelslog.NewLogger(name) + rollCnt metric.Int64Counter +) + +func init() { + var err error + rollCnt, err = meter.Int64Counter("dice.rolls", + metric.WithDescription("O número de lançamentos por valor obtido"), + metric.WithUnit("{roll}")) + if err != nil { + panic(err) + } +} + +func rolldice(w http.ResponseWriter, r *http.Request) { + ctx, span := tracer.Start(r.Context(), "roll") + defer span.End() + + roll := 1 + rand.Intn(6) + + var msg string + if player := r.PathValue("player"); player != "" { + msg = fmt.Sprintf("%s está lançando o dado", player) + } else { + msg = "Jogador anônimo está lançando o dado" + } + logger.InfoContext(ctx, msg, "result", roll) + + rollValueAttr := attribute.Int("roll.value", roll) + span.SetAttributes(rollValueAttr) + rollCnt.Add(ctx, 1, metric.WithAttributes(rollValueAttr)) + + resp := strconv.Itoa(roll) + "\n" + if _, err := io.WriteString(w, resp); err != nil { + log.Printf("Falha na escrita: %v\n", err) + } +} +``` + + +Observe que caso você esteja utilizando apenas rastros ou métricas, poderá +omitir o código de instrumentação correspondente ao componente que não está +sendo utilizado. + +### Executando a Aplicação {#run-the-application} + +Compile e execute a aplicação utilizando o seguinte comando: + +```sh +go mod tidy +export OTEL_RESOURCE_ATTRIBUTES="service.name=dice,service.version=0.1.0" +go run . +``` + +Abra no seu navegador. Ao enviar uma +solicitação para o servidor, você verá dois trechos no rastro emitido no +console. O trecho gerado pela biblioteca de instrumentação rastreia a duração da +solicitação para a rota `/rolldice/{player}`. O trecho chamado `roll` é criado +manualmente e é um filho do trecho mencionado anteriormente. + +
+Visualizar exemplo de saída + +```json +{ + "Name": "roll", + "SpanContext": { + "TraceID": "829fb7ceb787403c96eac3caf285c965", + "SpanID": "8b6b408b6c1a35e5", + "TraceFlags": "01", + "TraceState": "", + "Remote": false + }, + "Parent": { + "TraceID": "829fb7ceb787403c96eac3caf285c965", + "SpanID": "612be4bbdf450de6", + "TraceFlags": "01", + "TraceState": "", + "Remote": false + }, + "SpanKind": 1, + "StartTime": "2023-09-25T12:42:06.177119576+02:00", + "EndTime": "2023-09-25T12:42:06.177136776+02:00", + "Attributes": [ + { + "Key": "roll.value", + "Value": { + "Type": "INT64", + "Value": 6 + } + } + ], + "Events": null, + "Links": null, + "Status": { + "Code": "Unset", + "Description": "" + }, + "DroppedAttributes": 0, + "DroppedEvents": 0, + "DroppedLinks": 0, + "ChildSpanCount": 0, + "Resource": [ + { + "Key": "service.name", + "Value": { + "Type": "STRING", + "Value": "dice" + } + }, + { + "Key": "service.version", + "Value": { + "Type": "STRING", + "Value": "0.1.0" + } + }, + { + "Key": "telemetry.sdk.language", + "Value": { + "Type": "STRING", + "Value": "go" + } + }, + { + "Key": "telemetry.sdk.name", + "Value": { + "Type": "STRING", + "Value": "opentelemetry" + } + }, + { + "Key": "telemetry.sdk.version", + "Value": { + "Type": "STRING", + "Value": "1.19.0-rc.1" + } + } + ], + "InstrumentationLibrary": { + "Name": "rolldice", + "Version": "", + "SchemaURL": "" + } +} +{ + "Name": "/", + "SpanContext": { + "TraceID": "829fb7ceb787403c96eac3caf285c965", + "SpanID": "612be4bbdf450de6", + "TraceFlags": "01", + "TraceState": "", + "Remote": false + }, + "Parent": { + "TraceID": "00000000000000000000000000000000", + "SpanID": "0000000000000000", + "TraceFlags": "00", + "TraceState": "", + "Remote": false + }, + "SpanKind": 2, + "StartTime": "2023-09-25T12:42:06.177071077+02:00", + "EndTime": "2023-09-25T12:42:06.177158076+02:00", + "Attributes": [ + { + "Key": "http.method", + "Value": { + "Type": "STRING", + "Value": "GET" + } + }, + { + "Key": "http.scheme", + "Value": { + "Type": "STRING", + "Value": "http" + } + }, + { + "Key": "http.flavor", + "Value": { + "Type": "STRING", + "Value": "1.1" + } + }, + { + "Key": "net.host.name", + "Value": { + "Type": "STRING", + "Value": "localhost" + } + }, + { + "Key": "net.host.port", + "Value": { + "Type": "INT64", + "Value": 8080 + } + }, + { + "Key": "net.sock.peer.addr", + "Value": { + "Type": "STRING", + "Value": "::1" + } + }, + { + "Key": "net.sock.peer.port", + "Value": { + "Type": "INT64", + "Value": 49046 + } + }, + { + "Key": "http.user_agent", + "Value": { + "Type": "STRING", + "Value": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36" + } + }, + { + "Key": "http.route", + "Value": { + "Type": "STRING", + "Value": "/rolldice/Alice" + } + }, + { + "Key": "http.wrote_bytes", + "Value": { + "Type": "INT64", + "Value": 2 + } + }, + { + "Key": "http.status_code", + "Value": { + "Type": "INT64", + "Value": 200 + } + } + ], + "Events": null, + "Links": null, + "Status": { + "Code": "Unset", + "Description": "" + }, + "DroppedAttributes": 0, + "DroppedEvents": 0, + "DroppedLinks": 0, + "ChildSpanCount": 1, + "Resource": [ + { + "Key": "service.name", + "Value": { + "Type": "STRING", + "Value": "dice" + } + }, + { + "Key": "service.version", + "Value": { + "Type": "STRING", + "Value": "0.1.0" + } + }, + { + "Key": "telemetry.sdk.language", + "Value": { + "Type": "STRING", + "Value": "go" + } + }, + { + "Key": "telemetry.sdk.name", + "Value": { + "Type": "STRING", + "Value": "opentelemetry" + } + }, + { + "Key": "telemetry.sdk.version", + "Value": { + "Type": "STRING", + "Value": "1.19.0-rc.1" + } + } + ], + "InstrumentationLibrary": { + "Name": "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp", + "Version": "0.44.0", + "SchemaURL": "" + } +} +``` + +
+ +Junto com o rastro, mensagens de log são emitidas no console. + +
+Visualizar exemplo de saída + +```json +{ + "Timestamp": "2023-09-25T12:42:05.177136776+02:00", + "ObservedTimestamp": "2023-09-25T12:42:06.809396011+02:00", + "Severity": 9, + "SeverityText": "", + "Body": { + "Type": "String", + "Value": "Alice está lançando o dado" + }, + "Attributes": [ + { + "Key": "result", + "Value": { + "Type": "Int64", + "Value": 6 + } + } + ], + "TraceID": "829fb7ceb787403c96eac3caf285c965", + "SpanID": "8b6b408b6c1a35e5", + "TraceFlags": "01", + "Resource": [ + { + "Key": "service.name", + "Value": { + "Type": "STRING", + "Value": "dice" + } + }, + { + "Key": "service.version", + "Value": { + "Type": "STRING", + "Value": "0.1.0" + } + }, + { + "Key": "telemetry.sdk.language", + "Value": { + "Type": "STRING", + "Value": "go" + } + }, + { + "Key": "telemetry.sdk.name", + "Value": { + "Type": "STRING", + "Value": "opentelemetry" + } + }, + { + "Key": "telemetry.sdk.version", + "Value": { + "Type": "STRING", + "Value": "1.19.0-rc.1" + } + } + ], + "Scope": { + "Name": "rolldice", + "Version": "", + "SchemaURL": "" + }, + "DroppedAttributes": 0 +} +``` + +
+ +Atualize a página algumas vezes, e então +você pode esperar um pouco ou encerrar a execução da aplicação e verá as +métricas como na saída do console. Você verá a métrica `dice.rolls` emitida no +console, com contagens distintas para cada valor obtido, bem como as métricas +HTTP geradas pela biblioteca de instrumentação. + +
+Visualizar exemplo de saída + +```json +{ + "Resource": [ + { + "Key": "service.name", + "Value": { + "Type": "STRING", + "Value": "dice" + } + }, + { + "Key": "service.version", + "Value": { + "Type": "STRING", + "Value": "0.1.0" + } + }, + { + "Key": "telemetry.sdk.language", + "Value": { + "Type": "STRING", + "Value": "go" + } + }, + { + "Key": "telemetry.sdk.name", + "Value": { + "Type": "STRING", + "Value": "opentelemetry" + } + }, + { + "Key": "telemetry.sdk.version", + "Value": { + "Type": "STRING", + "Value": "1.19.0-rc.1" + } + } + ], + "ScopeMetrics": [ + { + "Scope": { + "Name": "rolldice", + "Version": "", + "SchemaURL": "" + }, + "Metrics": [ + { + "Name": "dice.rolls", + "Description": "Número de lançamentos por valor obtido", + "Unit": "{roll}", + "Data": { + "DataPoints": [ + { + "Attributes": [ + { + "Key": "roll.value", + "Value": { + "Type": "INT64", + "Value": 1 + } + } + ], + "StartTime": "2023-09-25T12:42:04.279204638+02:00", + "Time": "2023-09-25T12:42:15.482694258+02:00", + "Value": 4 + }, + { + "Attributes": [ + { + "Key": "roll.value", + "Value": { + "Type": "INT64", + "Value": 5 + } + } + ], + "StartTime": "2023-09-25T12:42:04.279204638+02:00", + "Time": "2023-09-25T12:42:15.482694258+02:00", + "Value": 3 + }, + { + "Attributes": [ + { + "Key": "roll.value", + "Value": { + "Type": "INT64", + "Value": 3 + } + } + ], + "StartTime": "2023-09-25T12:42:04.279204638+02:00", + "Time": "2023-09-25T12:42:15.482694258+02:00", + "Value": 4 + }, + { + "Attributes": [ + { + "Key": "roll.value", + "Value": { + "Type": "INT64", + "Value": 2 + } + } + ], + "StartTime": "2023-09-25T12:42:04.279204638+02:00", + "Time": "2023-09-25T12:42:15.482694258+02:00", + "Value": 2 + }, + { + "Attributes": [ + { + "Key": "roll.value", + "Value": { + "Type": "INT64", + "Value": 6 + } + } + ], + "StartTime": "2023-09-25T12:42:04.279204638+02:00", + "Time": "2023-09-25T12:42:15.482694258+02:00", + "Value": 5 + }, + { + "Attributes": [ + { + "Key": "roll.value", + "Value": { + "Type": "INT64", + "Value": 4 + } + } + ], + "StartTime": "2023-09-25T12:42:04.279204638+02:00", + "Time": "2023-09-25T12:42:15.482694258+02:00", + "Value": 9 + } + ], + "Temporality": "CumulativeTemporality", + "IsMonotonic": true + } + } + ] + }, + { + "Scope": { + "Name": "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp", + "Version": "0.44.0", + "SchemaURL": "" + }, + "Metrics": [ + { + "Name": "http.server.request_content_length", + "Description": "", + "Unit": "", + "Data": { + "DataPoints": [ + { + "Attributes": [ + { + "Key": "http.flavor", + "Value": { + "Type": "STRING", + "Value": "1.1" + } + }, + { + "Key": "http.method", + "Value": { + "Type": "STRING", + "Value": "GET" + } + }, + { + "Key": "http.route", + "Value": { + "Type": "STRING", + "Value": "/rolldice/Alice" + } + }, + { + "Key": "http.scheme", + "Value": { + "Type": "STRING", + "Value": "http" + } + }, + { + "Key": "http.status_code", + "Value": { + "Type": "INT64", + "Value": 200 + } + }, + { + "Key": "net.host.name", + "Value": { + "Type": "STRING", + "Value": "localhost" + } + }, + { + "Key": "net.host.port", + "Value": { + "Type": "INT64", + "Value": 8080 + } + } + ], + "StartTime": "2023-09-25T12:42:04.279212238+02:00", + "Time": "2023-09-25T12:42:15.482695758+02:00", + "Value": 0 + } + ], + "Temporality": "CumulativeTemporality", + "IsMonotonic": true + } + }, + { + "Name": "http.server.response_content_length", + "Description": "", + "Unit": "", + "Data": { + "DataPoints": [ + { + "Attributes": [ + { + "Key": "http.flavor", + "Value": { + "Type": "STRING", + "Value": "1.1" + } + }, + { + "Key": "http.method", + "Value": { + "Type": "STRING", + "Value": "GET" + } + }, + { + "Key": "http.route", + "Value": { + "Type": "STRING", + "Value": "/rolldice/Alice" + } + }, + { + "Key": "http.scheme", + "Value": { + "Type": "STRING", + "Value": "http" + } + }, + { + "Key": "http.status_code", + "Value": { + "Type": "INT64", + "Value": 200 + } + }, + { + "Key": "net.host.name", + "Value": { + "Type": "STRING", + "Value": "localhost" + } + }, + { + "Key": "net.host.port", + "Value": { + "Type": "INT64", + "Value": 8080 + } + } + ], + "StartTime": "2023-09-25T12:42:04.279214438+02:00", + "Time": "2023-09-25T12:42:15.482696158+02:00", + "Value": 54 + } + ], + "Temporality": "CumulativeTemporality", + "IsMonotonic": true + } + }, + { + "Name": "http.server.duration", + "Description": "", + "Unit": "", + "Data": { + "DataPoints": [ + { + "Attributes": [ + { + "Key": "http.flavor", + "Value": { + "Type": "STRING", + "Value": "1.1" + } + }, + { + "Key": "http.method", + "Value": { + "Type": "STRING", + "Value": "GET" + } + }, + { + "Key": "http.route", + "Value": { + "Type": "STRING", + "Value": "/rolldice/Alice" + } + }, + { + "Key": "http.scheme", + "Value": { + "Type": "STRING", + "Value": "http" + } + }, + { + "Key": "http.status_code", + "Value": { + "Type": "INT64", + "Value": 200 + } + }, + { + "Key": "net.host.name", + "Value": { + "Type": "STRING", + "Value": "localhost" + } + }, + { + "Key": "net.host.port", + "Value": { + "Type": "INT64", + "Value": 8080 + } + } + ], + "StartTime": "2023-09-25T12:42:04.279219438+02:00", + "Time": "2023-09-25T12:42:15.482697158+02:00", + "Count": 27, + "Bounds": [ + 0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, + 7500, 10000 + ], + "BucketCounts": [ + 0, 27, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + ], + "Min": {}, + "Max": {}, + "Sum": 2.1752759999999993 + } + ], + "Temporality": "CumulativeTemporality" + } + } + ] + } + ] +} +``` + +
+ +## Próximos passos {#next-steps} + +Para mais informações sobre como instrumentar seu código, consulte a +documentação de [instrumentação manual](/docs/languages/go/instrumentation/). + +Você também vai querer configurar um Exporter apropriado para +[exportar os seus dados de telemetria](/docs/languages/go/exporters/) para um ou +mais backends de telemetria. + +Caso queira explorar um exemplo mais complexo, dê uma olhada na +[demonstração do OpenTelemetry](/docs/demo/), que inclui o +[Serviço de Checkout](/docs/demo/services/checkout/), o +[Serviço de Catálogo de Produtos](/docs/demo/services/product-catalog/), e o +[Serviço de Contabilidade](/docs/demo/services/accounting/), baseados em Go + +[traces]: /docs/concepts/signals/traces/ +[metrics]: /docs/concepts/signals/metrics/ +[logs]: /docs/concepts/signals/logs/ diff --git a/content/zh/blogs/2024/_index.md b/content/zh/blog/2024/_index.md similarity index 100% rename from content/zh/blogs/2024/_index.md rename to content/zh/blog/2024/_index.md diff --git a/content/zh/blogs/2024/docs-localized.md b/content/zh/blog/2024/docs-localized.md similarity index 100% rename from content/zh/blogs/2024/docs-localized.md rename to content/zh/blog/2024/docs-localized.md diff --git a/content/zh/blog/_index.md b/content/zh/blog/_index.md new file mode 100644 index 000000000000..28910ac4a474 --- /dev/null +++ b/content/zh/blog/_index.md @@ -0,0 +1,7 @@ +--- +title: 博客 +menu: { main: { weight: 50 } } +redirects: [{ from: '', to: '2024/ 301!' }] +outputs: [HTML, RSS] +default_lang_commit: 4c5468f8d16434f25f335e1b45922ca0f4cec18f +--- diff --git a/content/zh/blogs/_index.md b/content/zh/blogs/_index.md deleted file mode 100644 index 00f668f1f558..000000000000 --- a/content/zh/blogs/_index.md +++ /dev/null @@ -1,8 +0,0 @@ ---- -title: 博客 -menu: - main: { weight: 50 } -redirects: [{ from: '', to: '2024/ 301!' }] -outputs: [HTML, RSS] -default_lang_commit: aca2e07f0d3a6 ---- diff --git a/content/zh/docs/contributing/style-guide.md b/content/zh/docs/contributing/style-guide.md index 24ad8a816096..c9800905d6cc 100644 --- a/content/zh/docs/contributing/style-guide.md +++ b/content/zh/docs/contributing/style-guide.md @@ -4,7 +4,7 @@ description: 编写 OpenTelemetry 文档时的术语和风格指南。 linkTitle: 风格指南 weight: 20 cSpell:ignore: open-telemetry postgre style-guide textlintrc -default_lang_commit: d78e63a +default_lang_commit: 2394fa1f1c693e547093e46e83a6819d3c26e9d5 --- OpenTelemetry 还没有官方的风格指南，当前版本的 OpenTelemetry 文档风格受到以下风格指南的启发： @@ -23,22 +23,24 @@ OpenTelemetry 还没有官方的风格指南，当前版本的 OpenTelemetry 文 {{% /alert %}} -## OpenTelemetry.io 单词列表 +## OpenTelemetry.io 单词列表 {#opentelemetryio-word-list} 请在整个网站上统一使用以下 OpenTelemetry 特定术语和词语列表。 -| Term | Usage | -| ---------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| OpenTelemetry | OpenTelemetry 应始终大写。请勿使用 Open-Telemetry。 | -| OTel | OTel 是 OpenTelemetry 的公认缩写形式。请勿使用 OTEL。 | -| Collector | 当引用 OpenTelemetry Collector 时，请始终将 Collector 大写。在句子开头请使用 `The Collector` 或 `The Opentelemetry Collector`， 在句中或句尾则使用 `the Collector` 或 `the OpenTelemetry Collector`。如果您要将 Collector 用作形容词（例如， `Collector 配置` ），请只使用 `Collector` 。 | -| OTEP | OpenTelemetry 增强提案（OpenTelemetry Enhancement Proposal）。复数形式请写作 `OTEPs` 。请不要写成 `OTep` 或 `otep`。 | -| OpAMP | 开放代理管理协议（Open Agent Management Protocol）。请勿在描述或说明中写成 `OPAMP` 或 `opamp`。 | -| | | +| 术语 | 用法 | +| ---- | ----- | +| OpenTelemetry | OpenTelemetry 应始终大写。请勿使用 Open-Telemetry。| +| OTel | OTel 是 OpenTelemetry 的公认缩写形式。请勿使用 OTEL。| +| Collector | 当引用 OpenTelemetry Collector 时，请始终将 Collector 大写。在句子开头请使用 `The Collector` 或 `The Opentelemetry Collector`， 在句中或句尾则使用 `the Collector` 或 `the OpenTelemetry Collector`。如果您要将 Collector 用作形容词（例如， `Collector 配置` ），请只使用 `Collector`。| +| OTEP | OpenTelemetry 增强提案（OpenTelemetry Enhancement Proposal）。复数形式请写作 `OTEPs` 。请不要写成 `OTep` 或 `otep`。| +| OpAMP | 开放代理管理协议（Open Agent Management Protocol）。请勿在描述或说明中写成 `OPAMP` 或 `opamp`。| + -确保正确书写专有名词（例如其他 CNCF 项目或第三方工具）并使用原始大写字母。例如，书写 `PostgreSQL` 而不是 `postgre`。有关完整列表，请查看 [`.textlintrc.yml`](https://github.com/open-telemetry/opentelemetry.io/blob/main/.textlintrc.yml) 文件。 +确保正确书写专有名词（例如其他 CNCF 项目或第三方工具）并使用原始大写字母。例如， +书写 `PostgreSQL` 而不是 `postgre`。有关完整列表，请查看 +[`.textlintrc.yml`](https://github.com/open-telemetry/opentelemetry.io/blob/main/.textlintrc.yml) 文件。 另请参阅 [词汇表](/docs/concepts/glossary/) 以获取 OpenTelemetry术语及其定义的列表。 @@ -46,19 +48,27 @@ OpenTelemetry 还没有官方的风格指南，当前版本的 OpenTelemetry 文 运行 `npm run check:text -- --fix` 命令以修复书写不正确的术语和单词。 -## Markdown 标准 +## Markdown 标准 {#markdown-standards} -为了增强 Markdown 文件的标准性和一致性，所有文件都应遵循 [markdownlint](https://github.com/DavidAnson/markdownlint) 确定的相关规则。有关完整列表，请查看 [`.markdownlint.json`](https://github.com/open-telemetry/opentelemetry.io/blob/main/.markdownlint.json) 文件。 +为了增强 Markdown 文件的标准性和一致性，所有文件都应遵循 +[markdownlint](https://github.com/DavidAnson/markdownlint) +确定的相关规则。有关完整列表，请查看 +[`.markdownlint.json`](https://github.com/open-telemetry/opentelemetry.io/blob/main/.markdownlint.json) +文件。 运行 `npm run check:markdown` 命令以验证所有文件是否遵循标准。 运行 `npm run fix:markdown` 命令以修复与 Markdown 相关的格式问题。 -## 拼写检查 +## 拼写检查 {#spell-checking} -使用 [CSpell](https://github.com/streetsidesoftware/cspell) 确保所有文本拼写正确。有关 OpenTelemetry 网站特定单词的列表，请参阅 [`.cspell.yml`](https://github.com/open-telemetry/opentelemetry.io/blob/main/.cspell.yml) 文件。 +使用 [CSpell](https://github.com/streetsidesoftware/cspell) 确保所有文本拼写正确。 +有关 OpenTelemetry 网站特定单词的列表，请参阅 +[`.cspell.yml`](https://github.com/open-telemetry/opentelemetry.io/blob/main/.cspell.yml) 文件。 -运行 `npm run check:spelling` 命令以验证所有单词拼写是否正确。如果 `cspell` 指示 `Unknown word` 错误，请验证您是否正确编写了该单词。如果正确，请将此单词添加到文件顶部的 `cSpell:ignore` 部分。如果不存在这样的部分，您可以将其添加到 Markdown 文件的元数据中： +运行 `npm run check:spelling` 命令以验证所有单词拼写是否正确。如果 `cspell` 指示 +`Unknown word` 错误，请验证您是否正确编写了该单词。如果正确，请将此单词添加到文件顶部的 +`cSpell:ignore` 部分。如果不存在这样的部分，您可以将其添加到 Markdown 文件的元数据中： ```markdown --- @@ -67,19 +77,23 @@ cSpell:ignore: --- ``` -对于任何其他文件，请在适合文件上下文的注释行中添加 `cSpell:ignore `。对于 [registry](/ecosystem/registry/) 条目 YAML 文件，它可能看起来像这样： +对于任何其他文件，请在适合文件上下文的注释行中添加 `cSpell:ignore `。 +对于 [registry](/ecosystem/registry/) 条目 YAML 文件，它可能看起来像这样： ```yaml # cSpell:ignore title: registryEntryTitle ``` -网站工具通过移除重复单词、删除全局单词列表中的单词以及对单词进行排序来规范特定于页面的词典（即 `cSpell:ignore` 单词列表）。要规范特定于页面的词典，请运行 `npm run fix:dict`。 +网站工具通过移除重复单词、删除全局单词列表中的单词以及对单词进行排序来规范特定于页面的词典（即 +`cSpell:ignore` 单词列表）。要规范特定于页面的词典，请运行 `npm run fix:dict`。 -## 文件格式 +## 文件格式 {#file-format} -为了执行关于文件结构的特定标准，所有文件都应使用 [prettier](https://prettier.io) 进行格式化。在提交 PR 之前运行 `npm run fix:format`，或者在提交 PR 之后运行它并推送额外的提交。 +为了执行关于文件结构的特定标准，所有文件都应使用 [prettier](https://prettier.io) +进行格式化。在提交 PR 之前运行 `npm run fix:format`，或者在提交 PR 之后运行它并推送额外的提交。 -## 文件名 +## 文件名 {#file-names} -所有文件名都应采用[短横线命名](https://en.wikipedia.org/wiki/Letter_case#Kebab_case)。运行 `npm run fix:filenames` 以自动重命名文件。 +所有文件名都应采用[短横线命名](https://en.wikipedia.org/wiki/Letter_case#Kebab_case)。 +运行 `npm run fix:filenames` 以自动重命名文件。 diff --git a/data/ecosystem/adopters.yaml b/data/ecosystem/adopters.yaml index a7adc8bdcf23..f8d243799426 100644 --- a/data/ecosystem/adopters.yaml +++ b/data/ecosystem/adopters.yaml @@ -69,6 +69,12 @@ reference: 'https://medium.com/mercadolibre-tech/building-a-large-scale-observability-ecosystem-1edf654b249e' referenceTitle: blog post contact: 'https://github.com/mercadolibre' +- name: NAV - Norwegian Government + url: https://nav.no + components: [Collector, Go, Java, JavaScript, Python] + reference: 'https://nais.io/blog/posts/otel-from-0-to-100/' + referenceTitle: blog post + contact: 'https://github.com/Starefossen' - name: OrderMyGear url: https://www.ordermygear.com/ components: [] diff --git a/data/ecosystem/distributions.yaml b/data/ecosystem/distributions.yaml index 943360f48e63..6a6bc924e38f 100644 --- a/data/ecosystem/distributions.yaml +++ b/data/ecosystem/distributions.yaml @@ -103,3 +103,11 @@ url: https://github.com/elastic/elastic-otel-python docsUrl: https://github.com/elastic/elastic-otel-python components: [Python] +- name: Embrace Android Distribution for OpenTelemetry + url: https://github.com/embrace-io/embrace-android-sdk + docsUrl: https://embrace.io/docs/open-telemetry/integration/?android-language=java + components: [Java] +- name: Embrace Apple Distribution for OpenTelemetry + url: https://github.com/embrace-io/embrace-apple-sdk + docsUrl: https://embrace.io/docs/open-telemetry/integration/#apple + components: [Swift] diff --git a/data/ecosystem/vendors.yaml b/data/ecosystem/vendors.yaml index fc3e626255b8..146c9e458f29 100644 --- a/data/ecosystem/vendors.yaml +++ b/data/ecosystem/vendors.yaml @@ -90,6 +90,12 @@ contact: hello@cribl.io oss: false commercial: true +- name: Dash0 + nativeOTLP: true + url: https://www.dash0.com/ + contact: hi@dash0.com + oss: false + commercial: true - name: DaoCloud nativeOTLP: true url: https://docs.daocloud.io/en/insight/06UserGuide/01quickstart/otel/otel/ @@ -380,7 +386,7 @@ commercial: true - name: GreptimeDB nativeOTLP: true - url: https://docs.greptime.com/user-guide/clients/otlp + url: https://docs.greptime.com/user-guide/ingest-data/for-observerbility/opentelemetry contact: info@greptime.com oss: true commercial: true diff --git a/data/registry/application-integration-java-keycloak.yml b/data/registry/application-integration-java-keycloak.yml new file mode 100644 index 000000000000..7b7bcc0867a0 --- /dev/null +++ b/data/registry/application-integration-java-keycloak.yml @@ -0,0 +1,22 @@ +# cSpell:ignore keycloak +title: Keycloak +registryType: application integration +language: java +tags: + - keycloak + - iam + - sso +urls: + website: https://www.keycloak.org + repo: https://github.com/keycloak/keycloak + docs: https://www.keycloak.org/server/tracing +license: Apache 2.0 +description: + Keycloak utilizes OpenTelemetry for distributed tracing provided by the + Quarkus OpenTelemetry extension. +authors: + - name: Keycloak Contributors + url: https://github.com/keycloak +createdAt: '2024-10-29' +isNative: false +cncfProjectLevel: incubating diff --git a/data/registry/application-integration-python-mlflow.yml b/data/registry/application-integration-python-mlflow.yml new file mode 100644 index 000000000000..39e6fa3c8ed2 --- /dev/null +++ b/data/registry/application-integration-python-mlflow.yml @@ -0,0 +1,20 @@ +title: MLflow +registryType: application integration +language: python +tags: + - python + - MLflow + - LLMs +license: Apache-2.0 +description: + The MLflow tracing feature is built using OpenTelemetry, and allows users to + trace the execution of their generative AI applications. +authors: + - name: MLflow Authors + url: https://github.com/mlflow +urls: + website: https://mlflow.org/ + repo: https://github.com/mlflow/mlflow/ + docs: https://mlflow.org/docs/latest/llms/tracing/index.html +createdAt: '2024-10-24' +isNative: true diff --git a/data/registry/collector-builder.yml b/data/registry/collector-builder.yml index c9c81e027c39..74ed5068a5ee 100644 --- a/data/registry/collector-builder.yml +++ b/data/registry/collector-builder.yml @@ -17,5 +17,5 @@ createdAt: 2023-12-18 package: registry: go name: go.opentelemetry.io/collector/cmd/builder - version: v0.111.0 + version: v0.112.0 quickInstall: false diff --git a/data/registry/collector-exporter-alertmanager.yml b/data/registry/collector-exporter-alertmanager.yml index ae2c432f146f..36ccc1f7da93 100644 --- a/data/registry/collector-exporter-alertmanager.yml +++ b/data/registry/collector-exporter-alertmanager.yml @@ -17,7 +17,7 @@ authors: package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/alertmanagerexporter - version: v0.111.0 + version: v0.112.0 urls: repo: https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/alertmanagerexporter createdAt: 2023-12-05 diff --git a/data/registry/collector-exporter-alibaba-cloud-log-service.yml b/data/registry/collector-exporter-alibaba-cloud-log-service.yml index ac71376cadc6..0b8f09ca9ebd 100644 --- a/data/registry/collector-exporter-alibaba-cloud-log-service.yml +++ b/data/registry/collector-exporter-alibaba-cloud-log-service.yml @@ -17,4 +17,4 @@ createdAt: 2021-02-24 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/alibabacloudlogserviceexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-aws-xray.yml b/data/registry/collector-exporter-aws-xray.yml index a2feab9bca71..9083d1dcb2f7 100644 --- a/data/registry/collector-exporter-aws-xray.yml +++ b/data/registry/collector-exporter-aws-xray.yml @@ -16,4 +16,4 @@ createdAt: 2020-06-06 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/awsxrayexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-awscloudwatchlogs.yml b/data/registry/collector-exporter-awscloudwatchlogs.yml index 3f79f7e6722d..9e5747570a6b 100644 --- a/data/registry/collector-exporter-awscloudwatchlogs.yml +++ b/data/registry/collector-exporter-awscloudwatchlogs.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/awscloudwatchlogsexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-awsemf.yml b/data/registry/collector-exporter-awsemf.yml index 47b61ed4ad23..ccda4e2996f4 100644 --- a/data/registry/collector-exporter-awsemf.yml +++ b/data/registry/collector-exporter-awsemf.yml @@ -16,4 +16,4 @@ createdAt: 2020-06-06 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/awsemfexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-awss3.yml b/data/registry/collector-exporter-awss3.yml index 2f989422d1d9..908bfeb0f60c 100644 --- a/data/registry/collector-exporter-awss3.yml +++ b/data/registry/collector-exporter-awss3.yml @@ -17,4 +17,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/awss3exporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-azure-monitor.yml b/data/registry/collector-exporter-azure-monitor.yml index 49550a386262..0cbd886a5332 100644 --- a/data/registry/collector-exporter-azure-monitor.yml +++ b/data/registry/collector-exporter-azure-monitor.yml @@ -16,4 +16,4 @@ createdAt: 2020-06-06 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/azuremonitorexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-azuredataexplorer.yml b/data/registry/collector-exporter-azuredataexplorer.yml index 9a081f5196a7..18d72f6cefed 100644 --- a/data/registry/collector-exporter-azuredataexplorer.yml +++ b/data/registry/collector-exporter-azuredataexplorer.yml @@ -17,4 +17,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/azuredataexplorerexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-carbon.yml b/data/registry/collector-exporter-carbon.yml index 042407c41d91..f8f1f5c80cc6 100644 --- a/data/registry/collector-exporter-carbon.yml +++ b/data/registry/collector-exporter-carbon.yml @@ -16,4 +16,4 @@ createdAt: 2020-06-06 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/carbonexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-cassandra.yml b/data/registry/collector-exporter-cassandra.yml index 5e8f00a26578..c408ede1acba 100644 --- a/data/registry/collector-exporter-cassandra.yml +++ b/data/registry/collector-exporter-cassandra.yml @@ -17,4 +17,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/cassandraexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-clickhouse.yml b/data/registry/collector-exporter-clickhouse.yml index f320b3afc445..d65b87b5c705 100644 --- a/data/registry/collector-exporter-clickhouse.yml +++ b/data/registry/collector-exporter-clickhouse.yml @@ -17,4 +17,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/clickhouseexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-coralogix.yml b/data/registry/collector-exporter-coralogix.yml index 226e10abb4bc..29b1d1f0ff33 100644 --- a/data/registry/collector-exporter-coralogix.yml +++ b/data/registry/collector-exporter-coralogix.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/coralogixexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-datadog.yml b/data/registry/collector-exporter-datadog.yml index 817550f1f894..4e43127f2196 100644 --- a/data/registry/collector-exporter-datadog.yml +++ b/data/registry/collector-exporter-datadog.yml @@ -16,4 +16,4 @@ createdAt: 2020-06-06 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/datadogexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-dataset.yml b/data/registry/collector-exporter-dataset.yml index 6c17beea67d9..913dd41455da 100644 --- a/data/registry/collector-exporter-dataset.yml +++ b/data/registry/collector-exporter-dataset.yml @@ -16,4 +16,4 @@ createdAt: 2020-06-06 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/datasetexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-debug.yml b/data/registry/collector-exporter-debug.yml index 7740608d7d32..e3d30cad056f 100644 --- a/data/registry/collector-exporter-debug.yml +++ b/data/registry/collector-exporter-debug.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: go.opentelemetry.io/collector/exporter/debugexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-elasticsearch.yml b/data/registry/collector-exporter-elasticsearch.yml index c4d2d270c759..1a4344ef62f8 100644 --- a/data/registry/collector-exporter-elasticsearch.yml +++ b/data/registry/collector-exporter-elasticsearch.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/elasticsearchexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-file.yml b/data/registry/collector-exporter-file.yml index 749fb5db1c92..9a13fab32f32 100644 --- a/data/registry/collector-exporter-file.yml +++ b/data/registry/collector-exporter-file.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/fileexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-googlecloud.yml b/data/registry/collector-exporter-googlecloud.yml index 53ea9c150f72..0a680185ce2e 100644 --- a/data/registry/collector-exporter-googlecloud.yml +++ b/data/registry/collector-exporter-googlecloud.yml @@ -17,4 +17,4 @@ createdAt: 2020-06-06 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/googlecloudexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-googlecloudpubsub.yml b/data/registry/collector-exporter-googlecloudpubsub.yml index bd7f125cad72..14c9a8e13cbe 100644 --- a/data/registry/collector-exporter-googlecloudpubsub.yml +++ b/data/registry/collector-exporter-googlecloudpubsub.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/googlecloudpubsubexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-googlemanagedprometheus.yml b/data/registry/collector-exporter-googlemanagedprometheus.yml index ddac492527f6..1abc8034019b 100644 --- a/data/registry/collector-exporter-googlemanagedprometheus.yml +++ b/data/registry/collector-exporter-googlemanagedprometheus.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-27 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/googlemanagedprometheusexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-honeycombmarker.yml b/data/registry/collector-exporter-honeycombmarker.yml index c807acf91d27..fd41cb0a54a9 100644 --- a/data/registry/collector-exporter-honeycombmarker.yml +++ b/data/registry/collector-exporter-honeycombmarker.yml @@ -18,4 +18,4 @@ createdAt: 2023-10-17 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/honeycombmarkerexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-influxdb.yml b/data/registry/collector-exporter-influxdb.yml index 901684ea8dd2..aff89782a21c 100644 --- a/data/registry/collector-exporter-influxdb.yml +++ b/data/registry/collector-exporter-influxdb.yml @@ -17,4 +17,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/influxdbexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-kafka.yml b/data/registry/collector-exporter-kafka.yml index b4c6e89c0ca6..8472b1c6f067 100644 --- a/data/registry/collector-exporter-kafka.yml +++ b/data/registry/collector-exporter-kafka.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/kafkaexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-kinetica.yml b/data/registry/collector-exporter-kinetica.yml index c02de83bc378..1858476a6c4e 100644 --- a/data/registry/collector-exporter-kinetica.yml +++ b/data/registry/collector-exporter-kinetica.yml @@ -18,4 +18,4 @@ createdAt: 2023-09-19 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/kineticaexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-load-balancing.yml b/data/registry/collector-exporter-load-balancing.yml index 0440f3b7b5c6..7f185a55f2d5 100644 --- a/data/registry/collector-exporter-load-balancing.yml +++ b/data/registry/collector-exporter-load-balancing.yml @@ -16,4 +16,4 @@ createdAt: 2020-10-22 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/loadbalancingexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-logicmonitor.yml b/data/registry/collector-exporter-logicmonitor.yml index 52fe776cccb2..e1771775eddb 100644 --- a/data/registry/collector-exporter-logicmonitor.yml +++ b/data/registry/collector-exporter-logicmonitor.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/logicmonitorexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-logzio.yml b/data/registry/collector-exporter-logzio.yml index 99afe36868ea..f6610b48c335 100644 --- a/data/registry/collector-exporter-logzio.yml +++ b/data/registry/collector-exporter-logzio.yml @@ -16,4 +16,4 @@ createdAt: 2020-10-22 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/logzioexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-loki.yml b/data/registry/collector-exporter-loki.yml index 3b9fdd69f41b..e08841990d9b 100644 --- a/data/registry/collector-exporter-loki.yml +++ b/data/registry/collector-exporter-loki.yml @@ -16,4 +16,4 @@ createdAt: 2020-10-22 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/lokiexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-mezmo.yml b/data/registry/collector-exporter-mezmo.yml index c8438b43d0bb..e1c298d3cd5d 100644 --- a/data/registry/collector-exporter-mezmo.yml +++ b/data/registry/collector-exporter-mezmo.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/mezmoexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-nop.yml b/data/registry/collector-exporter-nop.yml index 01ab07f95980..8f56e0dc6b7f 100644 --- a/data/registry/collector-exporter-nop.yml +++ b/data/registry/collector-exporter-nop.yml @@ -19,4 +19,4 @@ createdAt: 2024-04-18 package: registry: go-collector name: go.opentelemetry.io/collector/exporter/nopexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-opencensus.yml b/data/registry/collector-exporter-opencensus.yml index f699e3ad26e0..0f5ecf59750c 100644 --- a/data/registry/collector-exporter-opencensus.yml +++ b/data/registry/collector-exporter-opencensus.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/opencensusexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-opensearch.yml b/data/registry/collector-exporter-opensearch.yml index 6440004ba83b..8ae7a49398c5 100644 --- a/data/registry/collector-exporter-opensearch.yml +++ b/data/registry/collector-exporter-opensearch.yml @@ -18,4 +18,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/opensearchexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-otelarrow.yml b/data/registry/collector-exporter-otelarrow.yml index 5b9b431e8ede..a689190ad230 100644 --- a/data/registry/collector-exporter-otelarrow.yml +++ b/data/registry/collector-exporter-otelarrow.yml @@ -21,4 +21,4 @@ createdAt: 2024-02-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/otelarrowexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-otlp.yml b/data/registry/collector-exporter-otlp.yml index 1b9210c18429..61b4edbf5ee5 100644 --- a/data/registry/collector-exporter-otlp.yml +++ b/data/registry/collector-exporter-otlp.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: go.opentelemetry.io/collector/exporter/otlpexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-prometheus-remote-write.yml b/data/registry/collector-exporter-prometheus-remote-write.yml index cf28aa979b27..a3422d67796b 100644 --- a/data/registry/collector-exporter-prometheus-remote-write.yml +++ b/data/registry/collector-exporter-prometheus-remote-write.yml @@ -17,4 +17,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/prometheusremotewriteexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-prometheus.yml b/data/registry/collector-exporter-prometheus.yml index 219c41539ff7..9aa74c50a20e 100644 --- a/data/registry/collector-exporter-prometheus.yml +++ b/data/registry/collector-exporter-prometheus.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/prometheusexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-pulsar.yml b/data/registry/collector-exporter-pulsar.yml index bee759d92527..8e82743fc999 100644 --- a/data/registry/collector-exporter-pulsar.yml +++ b/data/registry/collector-exporter-pulsar.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-27 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/pulsarexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-rabbitmq.yml b/data/registry/collector-exporter-rabbitmq.yml index a4ca904b03b0..890818d7add6 100644 --- a/data/registry/collector-exporter-rabbitmq.yml +++ b/data/registry/collector-exporter-rabbitmq.yml @@ -17,4 +17,4 @@ createdAt: 2024-04-18 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/rabbitmqexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-sapm.yml b/data/registry/collector-exporter-sapm.yml index d7b46d691baf..be05021e3716 100644 --- a/data/registry/collector-exporter-sapm.yml +++ b/data/registry/collector-exporter-sapm.yml @@ -18,4 +18,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/sapmexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-sentry.yml b/data/registry/collector-exporter-sentry.yml index 9b85fc0d53f1..e49fe991b66f 100644 --- a/data/registry/collector-exporter-sentry.yml +++ b/data/registry/collector-exporter-sentry.yml @@ -16,4 +16,4 @@ createdAt: 2020-06-06 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/sentryexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-signalfx.yml b/data/registry/collector-exporter-signalfx.yml index 7d747a790dc0..dae8c9b3e00a 100644 --- a/data/registry/collector-exporter-signalfx.yml +++ b/data/registry/collector-exporter-signalfx.yml @@ -16,4 +16,4 @@ createdAt: 2020-06-06 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/signalfxexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-splunk-hec.yml b/data/registry/collector-exporter-splunk-hec.yml index d6b0a9ba8d9b..df1614136b23 100644 --- a/data/registry/collector-exporter-splunk-hec.yml +++ b/data/registry/collector-exporter-splunk-hec.yml @@ -18,4 +18,4 @@ createdAt: 2020-06-06 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/splunkhecexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-splunk-sapm.yml b/data/registry/collector-exporter-splunk-sapm.yml index e1716575422b..1a4eca68c2d1 100644 --- a/data/registry/collector-exporter-splunk-sapm.yml +++ b/data/registry/collector-exporter-splunk-sapm.yml @@ -16,4 +16,4 @@ createdAt: 2020-06-06 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/sapmexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-sumologic.yml b/data/registry/collector-exporter-sumologic.yml index b56ef54ca089..9fe46157699d 100644 --- a/data/registry/collector-exporter-sumologic.yml +++ b/data/registry/collector-exporter-sumologic.yml @@ -16,4 +16,4 @@ createdAt: 2020-10-22 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/sumologicexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-syslog.yml b/data/registry/collector-exporter-syslog.yml index 6e3c9247509f..b2f4a01a6aca 100644 --- a/data/registry/collector-exporter-syslog.yml +++ b/data/registry/collector-exporter-syslog.yml @@ -17,4 +17,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/syslogexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-tencentcloudlogservice.yml b/data/registry/collector-exporter-tencentcloudlogservice.yml index f7b58670a207..0fde1d071bb2 100644 --- a/data/registry/collector-exporter-tencentcloudlogservice.yml +++ b/data/registry/collector-exporter-tencentcloudlogservice.yml @@ -17,4 +17,4 @@ createdAt: 2022-10-27 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/tencentcloudlogserviceexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-exporter-zipkin.yml b/data/registry/collector-exporter-zipkin.yml index ce247c50f500..0f980d9da374 100644 --- a/data/registry/collector-exporter-zipkin.yml +++ b/data/registry/collector-exporter-zipkin.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/exporter/zipkinexporter - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-extension-ack.yml b/data/registry/collector-extension-ack.yml index f1215414f353..163e7c3e738d 100644 --- a/data/registry/collector-extension-ack.yml +++ b/data/registry/collector-extension-ack.yml @@ -18,4 +18,4 @@ createdAt: 2024-04-18 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/extension/ackextension - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-extension-asapauth.yml b/data/registry/collector-extension-asapauth.yml index d916820aef68..e7e3e5fbc66c 100644 --- a/data/registry/collector-extension-asapauth.yml +++ b/data/registry/collector-extension-asapauth.yml @@ -19,4 +19,4 @@ createdAt: 2022-11-07 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/extension/asapauthextension - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-extension-basicauth.yml b/data/registry/collector-extension-basicauth.yml index 3d429868e820..c24a476ca289 100644 --- a/data/registry/collector-extension-basicauth.yml +++ b/data/registry/collector-extension-basicauth.yml @@ -19,4 +19,4 @@ createdAt: 2022-11-07 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/extension/basicauthextension - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-extension-bearertokenauth.yml b/data/registry/collector-extension-bearertokenauth.yml index a7f5a9634929..637355eefcae 100644 --- a/data/registry/collector-extension-bearertokenauth.yml +++ b/data/registry/collector-extension-bearertokenauth.yml @@ -18,4 +18,4 @@ createdAt: 2021-06-22 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/extension/bearertokenauthextension - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-extension-encoding.yml b/data/registry/collector-extension-encoding.yml index 0541d2832406..a157816b81d4 100644 --- a/data/registry/collector-extension-encoding.yml +++ b/data/registry/collector-extension-encoding.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/extension/encoding - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-extension-googleclientauth.yml b/data/registry/collector-extension-googleclientauth.yml index 62fe4c947530..ba3a8d7c7494 100644 --- a/data/registry/collector-extension-googleclientauth.yml +++ b/data/registry/collector-extension-googleclientauth.yml @@ -20,4 +20,4 @@ createdAt: 2024-04-18 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/extension/googleclientauthextension - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-extension-headerssetter.yml b/data/registry/collector-extension-headerssetter.yml index 2a9f28ebd2ad..b86ba2d67a2a 100644 --- a/data/registry/collector-extension-headerssetter.yml +++ b/data/registry/collector-extension-headerssetter.yml @@ -20,4 +20,4 @@ createdAt: 2022-11-07 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/extension/headerssetterextension - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-extension-healthcheck.yml b/data/registry/collector-extension-healthcheck.yml index b301a34fee73..da8c59b58b86 100644 --- a/data/registry/collector-extension-healthcheck.yml +++ b/data/registry/collector-extension-healthcheck.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-24 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/extension/healthcheckextension - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-extension-http-forwarder.yml b/data/registry/collector-extension-http-forwarder.yml index d526093dfe7a..62402340bbc3 100644 --- a/data/registry/collector-extension-http-forwarder.yml +++ b/data/registry/collector-extension-http-forwarder.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-24 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/extension/httpforwarderextension - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-extension-jaegerremotesampling.yml b/data/registry/collector-extension-jaegerremotesampling.yml index 8b02399ae886..303ad2095aa9 100644 --- a/data/registry/collector-extension-jaegerremotesampling.yml +++ b/data/registry/collector-extension-jaegerremotesampling.yml @@ -19,4 +19,4 @@ createdAt: 2022-11-07 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/extension/jaegerremotesampling - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-extension-memorylimiter.yml b/data/registry/collector-extension-memorylimiter.yml index 6f0c38e2b24a..3d8748d3f8be 100644 --- a/data/registry/collector-extension-memorylimiter.yml +++ b/data/registry/collector-extension-memorylimiter.yml @@ -18,4 +18,4 @@ createdAt: 2024-04-18 package: registry: go-collector name: go.opentelemetry.io/collector/extension/memorylimiterextension - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-extension-oauth2clientauth.yml b/data/registry/collector-extension-oauth2clientauth.yml index e090bafb91b0..e30d4ff5e78e 100644 --- a/data/registry/collector-extension-oauth2clientauth.yml +++ b/data/registry/collector-extension-oauth2clientauth.yml @@ -18,4 +18,4 @@ createdAt: 2021-06-22 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/extension/oauth2clientauthextension - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-extension-oidcauth.yml b/data/registry/collector-extension-oidcauth.yml index eaf2697890f8..49cad0d8dc88 100644 --- a/data/registry/collector-extension-oidcauth.yml +++ b/data/registry/collector-extension-oidcauth.yml @@ -19,4 +19,4 @@ createdAt: 2021-02-24 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/extension/oidcauthextension - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-extension-opamp.yml b/data/registry/collector-extension-opamp.yml index 48d10d38632d..3ded8d5d841a 100644 --- a/data/registry/collector-extension-opamp.yml +++ b/data/registry/collector-extension-opamp.yml @@ -16,4 +16,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/extension/opampextension - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-extension-pprof.yml b/data/registry/collector-extension-pprof.yml index c12b4e3b5d4b..4d389b8e99bf 100644 --- a/data/registry/collector-extension-pprof.yml +++ b/data/registry/collector-extension-pprof.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-24 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/extension/pprofextension - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-extension-remotetap.yml b/data/registry/collector-extension-remotetap.yml index a46c52591a8a..fb3747534d6b 100644 --- a/data/registry/collector-extension-remotetap.yml +++ b/data/registry/collector-extension-remotetap.yml @@ -19,4 +19,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/extension/remotetapextension - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-extension-sigv4auth.yml b/data/registry/collector-extension-sigv4auth.yml index b4d40febb9e5..787638b91025 100644 --- a/data/registry/collector-extension-sigv4auth.yml +++ b/data/registry/collector-extension-sigv4auth.yml @@ -19,4 +19,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/extension/sigv4authextension - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-extension-solarwindsapmsettings.yml b/data/registry/collector-extension-solarwindsapmsettings.yml index 18bee2aa1abf..434c86e59984 100644 --- a/data/registry/collector-extension-solarwindsapmsettings.yml +++ b/data/registry/collector-extension-solarwindsapmsettings.yml @@ -21,4 +21,4 @@ createdAt: 2024-02-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/extension/solarwindsapmsettingsextension - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-extension-sumologic.yml b/data/registry/collector-extension-sumologic.yml index a78646e3f11d..7afd15944aed 100644 --- a/data/registry/collector-extension-sumologic.yml +++ b/data/registry/collector-extension-sumologic.yml @@ -18,4 +18,4 @@ createdAt: 2024-04-18 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/extension/sumologicextension - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-attributes.yml b/data/registry/collector-processor-attributes.yml index 78fffd31d57c..83e574933c06 100644 --- a/data/registry/collector-processor-attributes.yml +++ b/data/registry/collector-processor-attributes.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-24 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/attributesprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-batch.yml b/data/registry/collector-processor-batch.yml index 6de9e7dc995c..0da9d6f66529 100644 --- a/data/registry/collector-processor-batch.yml +++ b/data/registry/collector-processor-batch.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-24 package: registry: go-collector name: go.opentelemetry.io/collector/processor/batchprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-cumulativetodelta.yml b/data/registry/collector-processor-cumulativetodelta.yml index 8b5d6512ccdd..9cdf9eeb9676 100644 --- a/data/registry/collector-processor-cumulativetodelta.yml +++ b/data/registry/collector-processor-cumulativetodelta.yml @@ -19,4 +19,4 @@ createdAt: 2022-10-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/cumulativetodeltaprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-deltatocumulative.yml b/data/registry/collector-processor-deltatocumulative.yml index 27c7bcf6249a..2162568c6d59 100644 --- a/data/registry/collector-processor-deltatocumulative.yml +++ b/data/registry/collector-processor-deltatocumulative.yml @@ -19,4 +19,4 @@ createdAt: 2024-02-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/deltatocumulativeprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-deltatorate.yml b/data/registry/collector-processor-deltatorate.yml index 616af282915c..4b5e6f8caad5 100644 --- a/data/registry/collector-processor-deltatorate.yml +++ b/data/registry/collector-processor-deltatorate.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/deltatorateprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-filter.yml b/data/registry/collector-processor-filter.yml index 7c5e6a4bfe34..538050032285 100644 --- a/data/registry/collector-processor-filter.yml +++ b/data/registry/collector-processor-filter.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-24 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/filterprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-group-by-trace.yml b/data/registry/collector-processor-group-by-trace.yml index 0ef7b8a12191..05b4b2b8af3c 100644 --- a/data/registry/collector-processor-group-by-trace.yml +++ b/data/registry/collector-processor-group-by-trace.yml @@ -19,4 +19,4 @@ createdAt: 2021-02-24 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/groupbytraceprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-groupbyattrs.yml b/data/registry/collector-processor-groupbyattrs.yml index ce2830ace087..3c51c92a02e8 100644 --- a/data/registry/collector-processor-groupbyattrs.yml +++ b/data/registry/collector-processor-groupbyattrs.yml @@ -20,4 +20,4 @@ createdAt: 2021-02-24 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/groupbyattrsprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-interval.yml b/data/registry/collector-processor-interval.yml index 20396c618a40..c6641571c838 100644 --- a/data/registry/collector-processor-interval.yml +++ b/data/registry/collector-processor-interval.yml @@ -18,4 +18,4 @@ createdAt: 2024-02-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/intervalprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-k8sattributes.yml b/data/registry/collector-processor-k8sattributes.yml index a13976e38952..db7bbd27e4e3 100644 --- a/data/registry/collector-processor-k8sattributes.yml +++ b/data/registry/collector-processor-k8sattributes.yml @@ -19,4 +19,4 @@ createdAt: 2022-03-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/k8sattributesprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-logstransform.yml b/data/registry/collector-processor-logstransform.yml index c8b87b7ee19d..3afda4cfe641 100644 --- a/data/registry/collector-processor-logstransform.yml +++ b/data/registry/collector-processor-logstransform.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/logstransformprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-metrics-transform.yml b/data/registry/collector-processor-metrics-transform.yml index 826d15eedc00..2864a67b1727 100644 --- a/data/registry/collector-processor-metrics-transform.yml +++ b/data/registry/collector-processor-metrics-transform.yml @@ -19,4 +19,4 @@ createdAt: 2021-02-24 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/metricstransformprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-metricsgeneration.yml b/data/registry/collector-processor-metricsgeneration.yml index 45b086d31afb..496bcd65860e 100644 --- a/data/registry/collector-processor-metricsgeneration.yml +++ b/data/registry/collector-processor-metricsgeneration.yml @@ -19,4 +19,4 @@ createdAt: 2022-10-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/metricsgenerationprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-probabilisticsampler.yml b/data/registry/collector-processor-probabilisticsampler.yml index 1fd003f0a929..b7693a5f94e1 100644 --- a/data/registry/collector-processor-probabilisticsampler.yml +++ b/data/registry/collector-processor-probabilisticsampler.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-24 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/probabilisticsamplerprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-redaction.yml b/data/registry/collector-processor-redaction.yml index 5e09741bd81b..e2c22d821ce5 100644 --- a/data/registry/collector-processor-redaction.yml +++ b/data/registry/collector-processor-redaction.yml @@ -17,4 +17,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/redactionprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-remotetap.yml b/data/registry/collector-processor-remotetap.yml index e888c5febba0..3b711ece3cda 100644 --- a/data/registry/collector-processor-remotetap.yml +++ b/data/registry/collector-processor-remotetap.yml @@ -20,4 +20,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/remotetapprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-resource-detection.yml b/data/registry/collector-processor-resource-detection.yml index eddf6aebfc46..5b6b1c588249 100644 --- a/data/registry/collector-processor-resource-detection.yml +++ b/data/registry/collector-processor-resource-detection.yml @@ -20,4 +20,4 @@ createdAt: 2021-02-24 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/resourcedetectionprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-resource.yml b/data/registry/collector-processor-resource.yml index f726e0619b13..c1c5526b9dbb 100644 --- a/data/registry/collector-processor-resource.yml +++ b/data/registry/collector-processor-resource.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-24 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/resourceprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-routing.yml b/data/registry/collector-processor-routing.yml index a5cd4ccb5cc3..4370b19dd085 100644 --- a/data/registry/collector-processor-routing.yml +++ b/data/registry/collector-processor-routing.yml @@ -19,4 +19,4 @@ createdAt: 2021-02-24 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/routingprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-schema.yml b/data/registry/collector-processor-schema.yml index e397a57d2b96..1bc1ef05d7e7 100644 --- a/data/registry/collector-processor-schema.yml +++ b/data/registry/collector-processor-schema.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/schemaprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-span.yml b/data/registry/collector-processor-span.yml index 93c8c9e1d0db..94071902af53 100644 --- a/data/registry/collector-processor-span.yml +++ b/data/registry/collector-processor-span.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-24 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/spanprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-sumologic.yml b/data/registry/collector-processor-sumologic.yml index 393dfa71166c..5bf683ac4aef 100644 --- a/data/registry/collector-processor-sumologic.yml +++ b/data/registry/collector-processor-sumologic.yml @@ -20,4 +20,4 @@ createdAt: 2023-12-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/sumologicprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-tail-sampling.yml b/data/registry/collector-processor-tail-sampling.yml index a65119aeed76..f15d0f59307f 100644 --- a/data/registry/collector-processor-tail-sampling.yml +++ b/data/registry/collector-processor-tail-sampling.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-24 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/tailsamplingprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-processor-transform.yml b/data/registry/collector-processor-transform.yml index ace9b7ce518a..fdc4e376d2cb 100644 --- a/data/registry/collector-processor-transform.yml +++ b/data/registry/collector-processor-transform.yml @@ -20,4 +20,4 @@ createdAt: 2022-10-11 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/processor/transformprocessor - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-activedirectoryds.yml b/data/registry/collector-receiver-activedirectoryds.yml index 850e1715090b..60476a16f2b5 100644 --- a/data/registry/collector-receiver-activedirectoryds.yml +++ b/data/registry/collector-receiver-activedirectoryds.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/activedirectorydsreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-aerospike.yml b/data/registry/collector-receiver-aerospike.yml index fb9758ace993..4a3d69a1d281 100644 --- a/data/registry/collector-receiver-aerospike.yml +++ b/data/registry/collector-receiver-aerospike.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/aerospikereceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-apache.yml b/data/registry/collector-receiver-apache.yml index 754e5ef25654..cf7d74fc9bf2 100644 --- a/data/registry/collector-receiver-apache.yml +++ b/data/registry/collector-receiver-apache.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/apachereceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-apachespark.yml b/data/registry/collector-receiver-apachespark.yml index 43bc6655e407..3b1dc4b890d4 100644 --- a/data/registry/collector-receiver-apachespark.yml +++ b/data/registry/collector-receiver-apachespark.yml @@ -19,4 +19,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/apachesparkreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-aws-ecs-container-metrics.yml b/data/registry/collector-receiver-aws-ecs-container-metrics.yml index 139ed58351cd..252cc54da0e8 100644 --- a/data/registry/collector-receiver-aws-ecs-container-metrics.yml +++ b/data/registry/collector-receiver-aws-ecs-container-metrics.yml @@ -20,4 +20,4 @@ createdAt: 2021-02-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/awsecscontainermetricsreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-aws-xray.yml b/data/registry/collector-receiver-aws-xray.yml index 3db37f674b51..6fcfc04e395b 100644 --- a/data/registry/collector-receiver-aws-xray.yml +++ b/data/registry/collector-receiver-aws-xray.yml @@ -19,4 +19,4 @@ createdAt: 2021-02-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/awsxrayreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-awscloudwatch.yml b/data/registry/collector-receiver-awscloudwatch.yml index f1d7b1b2ca0f..5c8d3f339ea4 100644 --- a/data/registry/collector-receiver-awscloudwatch.yml +++ b/data/registry/collector-receiver-awscloudwatch.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/awscloudwatchreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-awscloudwatchmetrics.yml b/data/registry/collector-receiver-awscloudwatchmetrics.yml index 09d71277f5a0..820111809c86 100644 --- a/data/registry/collector-receiver-awscloudwatchmetrics.yml +++ b/data/registry/collector-receiver-awscloudwatchmetrics.yml @@ -20,4 +20,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/awscloudwatchmetricsreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-awscontainerinsight.yml b/data/registry/collector-receiver-awscontainerinsight.yml index 84b803fb1417..b8916612fc04 100644 --- a/data/registry/collector-receiver-awscontainerinsight.yml +++ b/data/registry/collector-receiver-awscontainerinsight.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/awscontainerinsightreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-awsfirehose.yml b/data/registry/collector-receiver-awsfirehose.yml index 98b031cebde8..b7e73df2add3 100644 --- a/data/registry/collector-receiver-awsfirehose.yml +++ b/data/registry/collector-receiver-awsfirehose.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/awsfirehosereceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-awss3.yml b/data/registry/collector-receiver-awss3.yml index 9838b8d3800b..fbebf3b49c7c 100644 --- a/data/registry/collector-receiver-awss3.yml +++ b/data/registry/collector-receiver-awss3.yml @@ -18,4 +18,4 @@ createdAt: 2024-04-18 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/awss3receiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-azureblob.yml b/data/registry/collector-receiver-azureblob.yml index 718542c6b047..598767a5fed4 100644 --- a/data/registry/collector-receiver-azureblob.yml +++ b/data/registry/collector-receiver-azureblob.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/azureblobreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-azureeventhub.yml b/data/registry/collector-receiver-azureeventhub.yml index 15f7cdbf9e37..e3926f126f42 100644 --- a/data/registry/collector-receiver-azureeventhub.yml +++ b/data/registry/collector-receiver-azureeventhub.yml @@ -17,4 +17,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/azureeventhubreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-azuremonitor.yml b/data/registry/collector-receiver-azuremonitor.yml index 35b94d3b603d..a18d1fb51e63 100644 --- a/data/registry/collector-receiver-azuremonitor.yml +++ b/data/registry/collector-receiver-azuremonitor.yml @@ -17,4 +17,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/azuremonitorreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-bigip.yml b/data/registry/collector-receiver-bigip.yml index 7691e128c4f3..088a098a39f7 100644 --- a/data/registry/collector-receiver-bigip.yml +++ b/data/registry/collector-receiver-bigip.yml @@ -17,4 +17,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/bigipreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-carbon.yml b/data/registry/collector-receiver-carbon.yml index 4f2ef51e0f64..11390bcac93d 100644 --- a/data/registry/collector-receiver-carbon.yml +++ b/data/registry/collector-receiver-carbon.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/carbonreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-chrony.yml b/data/registry/collector-receiver-chrony.yml index 59d643b9bdbb..4bcdf3d4f63f 100644 --- a/data/registry/collector-receiver-chrony.yml +++ b/data/registry/collector-receiver-chrony.yml @@ -18,4 +18,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/chronyreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-cloudflare.yml b/data/registry/collector-receiver-cloudflare.yml index 92dad9897427..66de3a78106a 100644 --- a/data/registry/collector-receiver-cloudflare.yml +++ b/data/registry/collector-receiver-cloudflare.yml @@ -18,4 +18,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/cloudflarereceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-cloudfoundry.yml b/data/registry/collector-receiver-cloudfoundry.yml index 7585f8eb239c..d48fc2a94205 100644 --- a/data/registry/collector-receiver-cloudfoundry.yml +++ b/data/registry/collector-receiver-cloudfoundry.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/cloudfoundryreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-collectd.yml b/data/registry/collector-receiver-collectd.yml index 83097cea40cb..6fee85dadabb 100644 --- a/data/registry/collector-receiver-collectd.yml +++ b/data/registry/collector-receiver-collectd.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/collectdreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-couchdb.yml b/data/registry/collector-receiver-couchdb.yml index 9a46c7ec949a..86aa292064db 100644 --- a/data/registry/collector-receiver-couchdb.yml +++ b/data/registry/collector-receiver-couchdb.yml @@ -17,4 +17,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/couchdbreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-datadog.yml b/data/registry/collector-receiver-datadog.yml index 232c7ac322f4..ee1d12acb70d 100644 --- a/data/registry/collector-receiver-datadog.yml +++ b/data/registry/collector-receiver-datadog.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/datadogreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-docker-stats.yml b/data/registry/collector-receiver-docker-stats.yml index aa136c245121..dfd8d7146345 100644 --- a/data/registry/collector-receiver-docker-stats.yml +++ b/data/registry/collector-receiver-docker-stats.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/dockerstatsreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-elasticsearch.yml b/data/registry/collector-receiver-elasticsearch.yml index a4f40fecaf85..87df5f2abf1e 100644 --- a/data/registry/collector-receiver-elasticsearch.yml +++ b/data/registry/collector-receiver-elasticsearch.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/elasticsearchreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-expvar.yml b/data/registry/collector-receiver-expvar.yml index 0eef6dd72820..fb6ab3a07a49 100644 --- a/data/registry/collector-receiver-expvar.yml +++ b/data/registry/collector-receiver-expvar.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/expvarreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-filelog.yml b/data/registry/collector-receiver-filelog.yml index 5b153718bf4e..1b76ddd83687 100644 --- a/data/registry/collector-receiver-filelog.yml +++ b/data/registry/collector-receiver-filelog.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/filelogreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-filestats.yml b/data/registry/collector-receiver-filestats.yml index 485d15b1af9d..dc18a66aab5f 100644 --- a/data/registry/collector-receiver-filestats.yml +++ b/data/registry/collector-receiver-filestats.yml @@ -18,4 +18,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/filestatsreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-flinkmetrics.yml b/data/registry/collector-receiver-flinkmetrics.yml index aca58b0d674d..5a2271e74d5f 100644 --- a/data/registry/collector-receiver-flinkmetrics.yml +++ b/data/registry/collector-receiver-flinkmetrics.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/flinkmetricsreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-fluent-forward.yml b/data/registry/collector-receiver-fluent-forward.yml index 51e3e95b1f4e..9513fcd72f9d 100644 --- a/data/registry/collector-receiver-fluent-forward.yml +++ b/data/registry/collector-receiver-fluent-forward.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/fluentforwardreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-googlecloudpubsub.yml b/data/registry/collector-receiver-googlecloudpubsub.yml index 7d9197b6320f..5e42e6b45db1 100644 --- a/data/registry/collector-receiver-googlecloudpubsub.yml +++ b/data/registry/collector-receiver-googlecloudpubsub.yml @@ -17,4 +17,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/googlecloudpubsubreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-googlecloudspanner.yml b/data/registry/collector-receiver-googlecloudspanner.yml index 362cf104b623..87e81386f9b5 100644 --- a/data/registry/collector-receiver-googlecloudspanner.yml +++ b/data/registry/collector-receiver-googlecloudspanner.yml @@ -17,4 +17,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/googlecloudspannerreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-haproxy.yml b/data/registry/collector-receiver-haproxy.yml index d9472371c1da..9663cc470b0b 100644 --- a/data/registry/collector-receiver-haproxy.yml +++ b/data/registry/collector-receiver-haproxy.yml @@ -18,4 +18,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/haproxyreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-host-metrics.yml b/data/registry/collector-receiver-host-metrics.yml index 06f50c8c13a4..2df519f747a9 100644 --- a/data/registry/collector-receiver-host-metrics.yml +++ b/data/registry/collector-receiver-host-metrics.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/hostmetricsreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-httpcheck.yml b/data/registry/collector-receiver-httpcheck.yml index 898b8fbccee4..c187868b83ce 100644 --- a/data/registry/collector-receiver-httpcheck.yml +++ b/data/registry/collector-receiver-httpcheck.yml @@ -19,4 +19,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/httpcheckreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-iis.yml b/data/registry/collector-receiver-iis.yml index 95c6061e57bf..dc3a83a72569 100644 --- a/data/registry/collector-receiver-iis.yml +++ b/data/registry/collector-receiver-iis.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/iisreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-influxdb.yml b/data/registry/collector-receiver-influxdb.yml index 037b52e2eaf4..fe870b2df4f3 100644 --- a/data/registry/collector-receiver-influxdb.yml +++ b/data/registry/collector-receiver-influxdb.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/influxdbreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-jaeger.yml b/data/registry/collector-receiver-jaeger.yml index 1f8ebe551b9d..dc1341d72dcd 100644 --- a/data/registry/collector-receiver-jaeger.yml +++ b/data/registry/collector-receiver-jaeger.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/jaegerreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-jmx.yml b/data/registry/collector-receiver-jmx.yml index eeffca363275..3f38179f5c04 100644 --- a/data/registry/collector-receiver-jmx.yml +++ b/data/registry/collector-receiver-jmx.yml @@ -19,4 +19,4 @@ createdAt: 2021-02-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/jmxreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-journald.yml b/data/registry/collector-receiver-journald.yml index 745bc0c3c8e8..830b020fe4ad 100644 --- a/data/registry/collector-receiver-journald.yml +++ b/data/registry/collector-receiver-journald.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/journaldreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-k8s-cluster.yml b/data/registry/collector-receiver-k8s-cluster.yml index 1e62b5feeed1..d1c9aa18a0f5 100644 --- a/data/registry/collector-receiver-k8s-cluster.yml +++ b/data/registry/collector-receiver-k8s-cluster.yml @@ -20,4 +20,4 @@ createdAt: 2021-02-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sclusterreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-k8sevents.yml b/data/registry/collector-receiver-k8sevents.yml index 729ce58344a1..c0304af7793f 100644 --- a/data/registry/collector-receiver-k8sevents.yml +++ b/data/registry/collector-receiver-k8sevents.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8seventsreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-k8sobjects.yml b/data/registry/collector-receiver-k8sobjects.yml index c6dfb6d8851b..8188cd23afec 100644 --- a/data/registry/collector-receiver-k8sobjects.yml +++ b/data/registry/collector-receiver-k8sobjects.yml @@ -18,4 +18,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/k8sobjectsreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-kafka.yml b/data/registry/collector-receiver-kafka.yml index 80b19ccd8d83..df73f25b1f62 100644 --- a/data/registry/collector-receiver-kafka.yml +++ b/data/registry/collector-receiver-kafka.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/kafkareceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-kafkametrics.yml b/data/registry/collector-receiver-kafkametrics.yml index f171dc3d1dcc..b41772933a77 100644 --- a/data/registry/collector-receiver-kafkametrics.yml +++ b/data/registry/collector-receiver-kafkametrics.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/kafkametricsreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-kubelet-stats.yml b/data/registry/collector-receiver-kubelet-stats.yml index 57b36bbffabf..09f56b69ef68 100644 --- a/data/registry/collector-receiver-kubelet-stats.yml +++ b/data/registry/collector-receiver-kubelet-stats.yml @@ -19,4 +19,4 @@ createdAt: 2021-02-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/kubeletstatsreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-loki.yml b/data/registry/collector-receiver-loki.yml index eb5c1895ef33..f672fc78c90c 100644 --- a/data/registry/collector-receiver-loki.yml +++ b/data/registry/collector-receiver-loki.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/lokireceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-memcached.yml b/data/registry/collector-receiver-memcached.yml index 730aec7928b9..bbdd4759fd2b 100644 --- a/data/registry/collector-receiver-memcached.yml +++ b/data/registry/collector-receiver-memcached.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/memcachedreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-mongodb.yml b/data/registry/collector-receiver-mongodb.yml index 8c8543d139ba..5501a74e78aa 100644 --- a/data/registry/collector-receiver-mongodb.yml +++ b/data/registry/collector-receiver-mongodb.yml @@ -17,4 +17,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/mongodbreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-mongodbatlas.yml b/data/registry/collector-receiver-mongodbatlas.yml index 5e397f9011e1..d49cbf1afa6a 100644 --- a/data/registry/collector-receiver-mongodbatlas.yml +++ b/data/registry/collector-receiver-mongodbatlas.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/mongodbatlasreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-mysql.yml b/data/registry/collector-receiver-mysql.yml index 0c5c82e71cf1..93d9ea65e6bd 100644 --- a/data/registry/collector-receiver-mysql.yml +++ b/data/registry/collector-receiver-mysql.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/mysqlreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-namedpipe.yml b/data/registry/collector-receiver-namedpipe.yml index 6f3f79320f40..0dc1ef99da21 100644 --- a/data/registry/collector-receiver-namedpipe.yml +++ b/data/registry/collector-receiver-namedpipe.yml @@ -18,4 +18,4 @@ createdAt: 2024-01-19 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/namedpipereceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-nginx.yml b/data/registry/collector-receiver-nginx.yml index efa2df89eb98..1b528fadfaec 100644 --- a/data/registry/collector-receiver-nginx.yml +++ b/data/registry/collector-receiver-nginx.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/nginxreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-nop.yml b/data/registry/collector-receiver-nop.yml index d251aed4a172..946d3d603967 100644 --- a/data/registry/collector-receiver-nop.yml +++ b/data/registry/collector-receiver-nop.yml @@ -18,4 +18,4 @@ createdAt: 2024-04-18 package: registry: go-collector name: go.opentelemetry.io/collector/receiver/nopreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-nsxt.yml b/data/registry/collector-receiver-nsxt.yml index 9d652215fb8e..14b586e7751e 100644 --- a/data/registry/collector-receiver-nsxt.yml +++ b/data/registry/collector-receiver-nsxt.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/nsxtreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-opencensus.yml b/data/registry/collector-receiver-opencensus.yml index e32dbb9a6cb8..e85fafe3b7e4 100644 --- a/data/registry/collector-receiver-opencensus.yml +++ b/data/registry/collector-receiver-opencensus.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/opencensusreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-oracledb.yml b/data/registry/collector-receiver-oracledb.yml index 0fc2404b1b91..6766249e1ac5 100644 --- a/data/registry/collector-receiver-oracledb.yml +++ b/data/registry/collector-receiver-oracledb.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/oracledbreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-osquery.yml b/data/registry/collector-receiver-osquery.yml index ebb1c30622d9..99ca334e7fe1 100644 --- a/data/registry/collector-receiver-osquery.yml +++ b/data/registry/collector-receiver-osquery.yml @@ -18,4 +18,4 @@ createdAt: 2024-01-19 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/osqueryreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-otelarrow.yml b/data/registry/collector-receiver-otelarrow.yml index ff2314a0c6e5..68826d62eaec 100644 --- a/data/registry/collector-receiver-otelarrow.yml +++ b/data/registry/collector-receiver-otelarrow.yml @@ -18,4 +18,4 @@ createdAt: 2024-04-18 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/otelarrowreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-otlp.yml b/data/registry/collector-receiver-otlp.yml index 857555351f12..44b11f08a500 100644 --- a/data/registry/collector-receiver-otlp.yml +++ b/data/registry/collector-receiver-otlp.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: go.opentelemetry.io/collector/receiver/otlpreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-otlpjsonfile.yml b/data/registry/collector-receiver-otlpjsonfile.yml index 08afb9546407..b5352dd0a212 100644 --- a/data/registry/collector-receiver-otlpjsonfile.yml +++ b/data/registry/collector-receiver-otlpjsonfile.yml @@ -17,4 +17,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/otlpjsonfilereceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-podman.yml b/data/registry/collector-receiver-podman.yml index 40bc951d7c2e..a068e0ff37d9 100644 --- a/data/registry/collector-receiver-podman.yml +++ b/data/registry/collector-receiver-podman.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/podmanreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-postgresql.yml b/data/registry/collector-receiver-postgresql.yml index 9a24f4e8901c..adff17dc4da4 100644 --- a/data/registry/collector-receiver-postgresql.yml +++ b/data/registry/collector-receiver-postgresql.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/postgresqlreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-prometheus.yml b/data/registry/collector-receiver-prometheus.yml index 2ace9afcdaeb..c0fe526604c6 100644 --- a/data/registry/collector-receiver-prometheus.yml +++ b/data/registry/collector-receiver-prometheus.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/prometheusreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-pulsar.yml b/data/registry/collector-receiver-pulsar.yml index de619e0f77b7..a62414b9cf2a 100644 --- a/data/registry/collector-receiver-pulsar.yml +++ b/data/registry/collector-receiver-pulsar.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/pulsarreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-purefa.yml b/data/registry/collector-receiver-purefa.yml index a5ea80cf6ab3..2f16ed5bb57a 100644 --- a/data/registry/collector-receiver-purefa.yml +++ b/data/registry/collector-receiver-purefa.yml @@ -18,4 +18,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/purefareceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-purefb.yml b/data/registry/collector-receiver-purefb.yml index a13739d37a9d..9ed3a6e49c93 100644 --- a/data/registry/collector-receiver-purefb.yml +++ b/data/registry/collector-receiver-purefb.yml @@ -19,4 +19,4 @@ createdAt: 2023-02-01 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/purefbreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-rabbitmq.yml b/data/registry/collector-receiver-rabbitmq.yml index 640c5a453a5e..863984302090 100644 --- a/data/registry/collector-receiver-rabbitmq.yml +++ b/data/registry/collector-receiver-rabbitmq.yml @@ -18,4 +18,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/rabbitmqreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-receiver-creator.yml b/data/registry/collector-receiver-receiver-creator.yml index fa87eaf8d89c..0249b4342c1b 100644 --- a/data/registry/collector-receiver-receiver-creator.yml +++ b/data/registry/collector-receiver-receiver-creator.yml @@ -19,4 +19,4 @@ createdAt: 2021-02-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/receivercreator - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-redis.yml b/data/registry/collector-receiver-redis.yml index ddfc3ebe5fc1..a0058a393988 100644 --- a/data/registry/collector-receiver-redis.yml +++ b/data/registry/collector-receiver-redis.yml @@ -19,4 +19,4 @@ createdAt: 2021-02-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/redisreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-riak.yml b/data/registry/collector-receiver-riak.yml index dc4a38784b2c..480ae3009267 100644 --- a/data/registry/collector-receiver-riak.yml +++ b/data/registry/collector-receiver-riak.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/riakreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-saphana.yml b/data/registry/collector-receiver-saphana.yml index 8d830131abab..cbdbf98ec8b8 100644 --- a/data/registry/collector-receiver-saphana.yml +++ b/data/registry/collector-receiver-saphana.yml @@ -19,4 +19,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/saphanareceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-sapm.yml b/data/registry/collector-receiver-sapm.yml index 30626ddf7393..e127dc911c63 100644 --- a/data/registry/collector-receiver-sapm.yml +++ b/data/registry/collector-receiver-sapm.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/sapmreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-signalfx.yml b/data/registry/collector-receiver-signalfx.yml index 9a60cf56db70..5bc89a6a704a 100644 --- a/data/registry/collector-receiver-signalfx.yml +++ b/data/registry/collector-receiver-signalfx.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/signalfxreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-simple-prometheus.yml b/data/registry/collector-receiver-simple-prometheus.yml index 2c0b750848be..cc1d83b2d6fc 100644 --- a/data/registry/collector-receiver-simple-prometheus.yml +++ b/data/registry/collector-receiver-simple-prometheus.yml @@ -19,4 +19,4 @@ createdAt: 2021-02-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/simpleprometheusreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-skywalking.yml b/data/registry/collector-receiver-skywalking.yml index 4ef03caee433..9be3532b74c3 100644 --- a/data/registry/collector-receiver-skywalking.yml +++ b/data/registry/collector-receiver-skywalking.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/skywalkingreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-snmp.yml b/data/registry/collector-receiver-snmp.yml index a749784abf31..ac2a3176414e 100644 --- a/data/registry/collector-receiver-snmp.yml +++ b/data/registry/collector-receiver-snmp.yml @@ -19,4 +19,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/snmpreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-snowflake.yml b/data/registry/collector-receiver-snowflake.yml index 60982a8367d2..02e30697d770 100644 --- a/data/registry/collector-receiver-snowflake.yml +++ b/data/registry/collector-receiver-snowflake.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/snowflakereceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-solace.yml b/data/registry/collector-receiver-solace.yml index ebfe8ac5daa5..74c8eb7543e0 100644 --- a/data/registry/collector-receiver-solace.yml +++ b/data/registry/collector-receiver-solace.yml @@ -17,4 +17,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/solacereceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-splunk-hec.yml b/data/registry/collector-receiver-splunk-hec.yml index a294b6fe259a..1757f22b6129 100644 --- a/data/registry/collector-receiver-splunk-hec.yml +++ b/data/registry/collector-receiver-splunk-hec.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/splunkhecreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-splunkenterprise.yml b/data/registry/collector-receiver-splunkenterprise.yml index a9995c15be54..d2f12d0ed7b7 100644 --- a/data/registry/collector-receiver-splunkenterprise.yml +++ b/data/registry/collector-receiver-splunkenterprise.yml @@ -19,4 +19,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/splunkenterprisereceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-sqlquery.yml b/data/registry/collector-receiver-sqlquery.yml index 103710d5bff3..a306d05449b6 100644 --- a/data/registry/collector-receiver-sqlquery.yml +++ b/data/registry/collector-receiver-sqlquery.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/sqlqueryreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-sqlserver.yml b/data/registry/collector-receiver-sqlserver.yml index 1f236b05c8e4..12d02102c685 100644 --- a/data/registry/collector-receiver-sqlserver.yml +++ b/data/registry/collector-receiver-sqlserver.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/sqlserverreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-sshcheck.yml b/data/registry/collector-receiver-sshcheck.yml index 69ea3acae4f4..dfe68466cc5a 100644 --- a/data/registry/collector-receiver-sshcheck.yml +++ b/data/registry/collector-receiver-sshcheck.yml @@ -19,4 +19,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/sshcheckreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-statsd.yml b/data/registry/collector-receiver-statsd.yml index 1cfd926fed74..9158a94946f2 100644 --- a/data/registry/collector-receiver-statsd.yml +++ b/data/registry/collector-receiver-statsd.yml @@ -17,4 +17,4 @@ createdAt: 2020-06-06 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/statsdreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-syslog.yml b/data/registry/collector-receiver-syslog.yml index c8d1bf4cb582..5311d474be63 100644 --- a/data/registry/collector-receiver-syslog.yml +++ b/data/registry/collector-receiver-syslog.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/syslogreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-tcplog.yml b/data/registry/collector-receiver-tcplog.yml index a7bdeb4ccf29..62e32835f4f9 100644 --- a/data/registry/collector-receiver-tcplog.yml +++ b/data/registry/collector-receiver-tcplog.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/tcplogreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-udplog.yml b/data/registry/collector-receiver-udplog.yml index 064416d11ca7..5803c8115bcf 100644 --- a/data/registry/collector-receiver-udplog.yml +++ b/data/registry/collector-receiver-udplog.yml @@ -16,4 +16,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/udplogreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-vcenter.yml b/data/registry/collector-receiver-vcenter.yml index 0145b93334e2..d82a85074e4f 100644 --- a/data/registry/collector-receiver-vcenter.yml +++ b/data/registry/collector-receiver-vcenter.yml @@ -18,4 +18,4 @@ createdAt: 2020-11-05 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/vcenterreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-wavefront.yml b/data/registry/collector-receiver-wavefront.yml index d1bfc770a21b..b570037eb3af 100644 --- a/data/registry/collector-receiver-wavefront.yml +++ b/data/registry/collector-receiver-wavefront.yml @@ -16,4 +16,4 @@ createdAt: 2020-06-06 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/wavefrontreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-webhookevent.yml b/data/registry/collector-receiver-webhookevent.yml index e17d7e1422e1..551fef871d34 100644 --- a/data/registry/collector-receiver-webhookevent.yml +++ b/data/registry/collector-receiver-webhookevent.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/webhookeventreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-windows-perf-counters.yml b/data/registry/collector-receiver-windows-perf-counters.yml index cb3504379ad8..07755c264a91 100644 --- a/data/registry/collector-receiver-windows-perf-counters.yml +++ b/data/registry/collector-receiver-windows-perf-counters.yml @@ -19,4 +19,4 @@ createdAt: 2021-02-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/windowsperfcountersreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-windowseventlog.yml b/data/registry/collector-receiver-windowseventlog.yml index 547bd52159cc..00fdc3669d46 100644 --- a/data/registry/collector-receiver-windowseventlog.yml +++ b/data/registry/collector-receiver-windowseventlog.yml @@ -18,4 +18,4 @@ createdAt: 2022-10-25 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/windowseventlogreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/collector-receiver-zipkin.yml b/data/registry/collector-receiver-zipkin.yml index 17e3b594e248..4887cf1927a1 100644 --- a/data/registry/collector-receiver-zipkin.yml +++ b/data/registry/collector-receiver-zipkin.yml @@ -13,7 +13,7 @@ authors: package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/zipkinreceiver - version: v0.111.0 + version: v0.112.0 urls: repo: https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/zipkinreceiver createdAt: 2020-11-05 diff --git a/data/registry/collector-receiver-zookeeper.yml b/data/registry/collector-receiver-zookeeper.yml index 2a3f084187ea..53dd67c52d9d 100644 --- a/data/registry/collector-receiver-zookeeper.yml +++ b/data/registry/collector-receiver-zookeeper.yml @@ -18,4 +18,4 @@ createdAt: 2021-02-26 package: registry: go-collector name: github.com/open-telemetry/opentelemetry-collector-contrib/receiver/zookeeperreceiver - version: v0.111.0 + version: v0.112.0 diff --git a/data/registry/exporter-dotnet-azure.yml b/data/registry/exporter-dotnet-azure.yml index b5e646a86e0a..ae205e61a51a 100644 --- a/data/registry/exporter-dotnet-azure.yml +++ b/data/registry/exporter-dotnet-azure.yml @@ -13,7 +13,7 @@ authors: package: name: Azure.Monitor.OpenTelemetry.Exporter registry: nuget - version: 1.4.0-beta.1 + version: 1.4.0-beta.2 urls: repo: https://github.com/Azure/azure-sdk-for-net/tree/main/sdk/monitor/Azure.Monitor.OpenTelemetry.Exporter createdAt: 2021-11-01 diff --git a/data/registry/exporter-dotnet-inmemory.yml b/data/registry/exporter-dotnet-inmemory.yml index 7c7e0a8208b2..07cf5e6fc115 100644 --- a/data/registry/exporter-dotnet-inmemory.yml +++ b/data/registry/exporter-dotnet-inmemory.yml @@ -17,4 +17,4 @@ createdAt: 2022-11-07 package: registry: nuget name: OpenTelemetry.Exporter.InMemory - version: 1.10.0-beta.1 + version: 1.10.0-rc.1 diff --git a/data/registry/exporter-js-azure.yml b/data/registry/exporter-js-azure.yml index 2495796e2dc4..790856f34548 100644 --- a/data/registry/exporter-js-azure.yml +++ b/data/registry/exporter-js-azure.yml @@ -13,7 +13,7 @@ authors: package: name: '@azure/monitor-opentelemetry-exporter' registry: npm - version: 1.0.0-beta.26 + version: 1.0.0-beta.27 urls: repo: https://github.com/Azure/azure-sdk-for-js/tree/main/sdk/monitor/monitor-opentelemetry-exporter createdAt: 2021-11-01 diff --git a/data/registry/exporter-js-instana.yml b/data/registry/exporter-js-instana.yml index dd5a314734c4..59123ac21ad2 100644 --- a/data/registry/exporter-js-instana.yml +++ b/data/registry/exporter-js-instana.yml @@ -15,4 +15,4 @@ createdAt: 2022-04-18 package: registry: npm name: '@instana/opentelemetry-exporter' - version: 3.20.2 + version: 4.0.1 diff --git a/data/registry/exporter-js-jaeger.yml b/data/registry/exporter-js-jaeger.yml index a3238cf96a4e..0aabb60da310 100644 --- a/data/registry/exporter-js-jaeger.yml +++ b/data/registry/exporter-js-jaeger.yml @@ -14,4 +14,4 @@ createdAt: 2020-02-06 package: registry: npm name: '@opentelemetry/exporter-jaeger' - version: 1.26.0 + version: 1.27.0 diff --git a/data/registry/exporter-js-prometheus.yml b/data/registry/exporter-js-prometheus.yml index 281c404aa293..e2fc09614efc 100644 --- a/data/registry/exporter-js-prometheus.yml +++ b/data/registry/exporter-js-prometheus.yml @@ -14,4 +14,4 @@ createdAt: 2020-02-06 package: registry: npm name: '@opentelemetry/exporter-prometheus' - version: 0.53.0 + version: 0.54.0 diff --git a/data/registry/exporter-js-zipkin.yml b/data/registry/exporter-js-zipkin.yml index eff9d385bc53..935eb193fd15 100644 --- a/data/registry/exporter-js-zipkin.yml +++ b/data/registry/exporter-js-zipkin.yml @@ -11,7 +11,7 @@ authors: package: name: '@opentelemetry/exporter-zipkin' registry: npm - version: 1.26.0 + version: 1.27.0 urls: repo: https://github.com/open-telemetry/opentelemetry-js/tree/main/packages/opentelemetry-exporter-zipkin docs: /docs/languages/js/exporters/#zipkin diff --git a/data/registry/exporter-php-zipkin.yml b/data/registry/exporter-php-zipkin.yml index dc74f13d5ac8..c66455a83588 100644 --- a/data/registry/exporter-php-zipkin.yml +++ b/data/registry/exporter-php-zipkin.yml @@ -12,7 +12,7 @@ authors: package: name: open-telemetry/exporter-zipkin registry: packagist - version: 1.1.0 + version: 1.1.1 urls: repo: https://github.com/open-telemetry/opentelemetry-php/tree/main/src/Contrib/Zipkin createdAt: 2022-12-14 diff --git a/data/registry/instrumentation-dotnet-wcf.yml b/data/registry/instrumentation-dotnet-wcf.yml index 4480d36da7aa..d235ffa3e58d 100644 --- a/data/registry/instrumentation-dotnet-wcf.yml +++ b/data/registry/instrumentation-dotnet-wcf.yml @@ -18,4 +18,4 @@ isFirstParty: false package: registry: nuget name: OpenTelemetry.Instrumentation.Wcf - version: 1.0.0-rc.17 + version: 1.0.0-rc.18 diff --git a/data/registry/instrumentation-erlang-bandit.yml b/data/registry/instrumentation-erlang-bandit.yml index d4c720cba68e..73364f9dffa1 100644 --- a/data/registry/instrumentation-erlang-bandit.yml +++ b/data/registry/instrumentation-erlang-bandit.yml @@ -18,4 +18,4 @@ isFirstParty: false package: registry: hex name: opentelemetry_bandit - version: 0.1.4 + version: 0.2.0-rc.1 diff --git a/data/registry/instrumentation-go-gorm.yml b/data/registry/instrumentation-go-gorm.yml index efc7f88556fd..aebc7f3f6e35 100644 --- a/data/registry/instrumentation-go-gorm.yml +++ b/data/registry/instrumentation-go-gorm.yml @@ -18,4 +18,4 @@ isFirstParty: true package: registry: go name: gorm.io/plugin/opentelemetry - version: v0.1.7 + version: v0.1.8 diff --git a/data/registry/instrumentation-go-otelmacaron.yml b/data/registry/instrumentation-go-otelmacaron.yml deleted file mode 100644 index 731c52ae1dbd..000000000000 --- a/data/registry/instrumentation-go-otelmacaron.yml +++ /dev/null @@ -1,16 +0,0 @@ -# cSpell:ignore otelmacaron macaron gopkg -title: Macaron Instrumentation -registryType: instrumentation -language: go -tags: - - macaron - - instrumentation - - go -license: Apache 2.0 -description: Package otelmacaron instruments gopkg.in/macaron.v1. -authors: - - name: OpenTelemetry Authors -urls: - repo: https://go.opentelemetry.io/contrib/instrumentation/gopkg.in/macaron.v1/otelmacaron -createdAt: 2023-12-05 -isFirstParty: false diff --git a/data/registry/instrumentation-go-xsam-database-sql.yml b/data/registry/instrumentation-go-xsam-database-sql.yml index 61a3c46e1d62..0a22dce3358b 100644 --- a/data/registry/instrumentation-go-xsam-database-sql.yml +++ b/data/registry/instrumentation-go-xsam-database-sql.yml @@ -16,7 +16,7 @@ isFirstParty: false package: name: github.com/XSAM/otelsql registry: go - version: v0.34.0 + version: v0.35.0 urls: repo: https://github.com/XSAM/otelsql createdAt: 2021-10-12 diff --git a/data/registry/instrumentation-java-jdbi.yml b/data/registry/instrumentation-java-jdbi.yml new file mode 100644 index 000000000000..e400e221a906 --- /dev/null +++ b/data/registry/instrumentation-java-jdbi.yml @@ -0,0 +1,20 @@ +# cSpell:ignore JDBI jdbi Jdbi +title: JDBI +registryType: instrumentation +language: java +tags: + - java + - jdbi +urls: + repo: https://github.com/jdbi/jdbi + docs: https://jdbi.org/#_opentelemetry_tracing + website: https://jdbi.org/ +license: Apache-2.0 +description: + Installing the JdbiOpenTelemetryPlugin enables Jdbi statements to emit trace + spans recording metadata like SQL, parameters, and execution time. +authors: + - name: JDBI Authors + url: https://github.com/jdbi +createdAt: '2024-11-02' +isNative: true diff --git a/data/registry/instrumentation-js-amqplib.yml b/data/registry/instrumentation-js-amqplib.yml index f9459577a47d..ffe335c3bb7f 100644 --- a/data/registry/instrumentation-js-amqplib.yml +++ b/data/registry/instrumentation-js-amqplib.yml @@ -14,7 +14,7 @@ authors: package: name: '@opentelemetry/instrumentation-amqplib' registry: npm - version: 0.42.0 + version: 0.43.0 urls: repo: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/main/plugins/node/instrumentation-amqplib createdAt: 2020-06-15 diff --git a/data/registry/instrumentation-js-aws-lambda.yml b/data/registry/instrumentation-js-aws-lambda.yml index 823775774773..17fa7dc4ec12 100644 --- a/data/registry/instrumentation-js-aws-lambda.yml +++ b/data/registry/instrumentation-js-aws-lambda.yml @@ -15,5 +15,5 @@ createdAt: 2021-07-08 package: name: '@opentelemetry/instrumentation-aws-lambda' registry: npm - version: 0.45.0 + version: 0.46.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-aws-sdk.yml b/data/registry/instrumentation-js-aws-sdk.yml index 52f1339519c0..761cd1bd7eed 100644 --- a/data/registry/instrumentation-js-aws-sdk.yml +++ b/data/registry/instrumentation-js-aws-sdk.yml @@ -21,5 +21,5 @@ createdAt: 2020-06-15 package: name: '@opentelemetry/instrumentation-aws-sdk' registry: npm - version: 0.44.0 + version: 0.45.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-bunyan.yml b/data/registry/instrumentation-js-bunyan.yml index dcdb05dc6bf2..27c171bcf6ac 100644 --- a/data/registry/instrumentation-js-bunyan.yml +++ b/data/registry/instrumentation-js-bunyan.yml @@ -16,5 +16,5 @@ createdAt: 2021-07-08 package: name: '@opentelemetry/instrumentation-bunyan' registry: npm - version: 0.41.0 + version: 0.42.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-cassandra-driver.yml b/data/registry/instrumentation-js-cassandra-driver.yml index 29f5cd314c22..39b61f5ae311 100644 --- a/data/registry/instrumentation-js-cassandra-driver.yml +++ b/data/registry/instrumentation-js-cassandra-driver.yml @@ -16,5 +16,5 @@ createdAt: 2021-07-08 package: name: '@opentelemetry/instrumentation-cassandra-driver' registry: npm - version: 0.41.0 + version: 0.42.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-cassandra.yml b/data/registry/instrumentation-js-cassandra.yml index 40c76e78c2c8..819b44804048 100644 --- a/data/registry/instrumentation-js-cassandra.yml +++ b/data/registry/instrumentation-js-cassandra.yml @@ -17,5 +17,5 @@ createdAt: 2021-07-08 package: registry: npm name: '@opentelemetry/instrumentation-cassandra-driver' - version: 0.41.0 + version: 0.42.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-cerbos.yml b/data/registry/instrumentation-js-cerbos.yml index ecaf0ebc7218..1f0017739da3 100644 --- a/data/registry/instrumentation-js-cerbos.yml +++ b/data/registry/instrumentation-js-cerbos.yml @@ -21,5 +21,5 @@ createdAt: 2023-09-13 package: name: '@cerbos/opentelemetry' registry: npm - version: 0.5.3 + version: 0.5.4 isFirstParty: true diff --git a/data/registry/instrumentation-js-connect.yml b/data/registry/instrumentation-js-connect.yml index 1036a2db8cce..ee7813943e64 100644 --- a/data/registry/instrumentation-js-connect.yml +++ b/data/registry/instrumentation-js-connect.yml @@ -14,5 +14,5 @@ createdAt: 2020-11-09 package: name: '@opentelemetry/instrumentation-connect' registry: npm - version: 0.39.0 + version: 0.40.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-cucumber.yml b/data/registry/instrumentation-js-cucumber.yml index d3534a040326..e1893f518a1b 100644 --- a/data/registry/instrumentation-js-cucumber.yml +++ b/data/registry/instrumentation-js-cucumber.yml @@ -17,5 +17,5 @@ createdAt: 2022-10-27 package: registry: npm name: '@opentelemetry/instrumentation-cucumber' - version: 0.9.0 + version: 0.10.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-dataloader.yml b/data/registry/instrumentation-js-dataloader.yml index 6d2ad781f57d..71876b461897 100644 --- a/data/registry/instrumentation-js-dataloader.yml +++ b/data/registry/instrumentation-js-dataloader.yml @@ -17,5 +17,5 @@ createdAt: 2022-10-27 package: registry: npm name: '@opentelemetry/instrumentation-dataloader' - version: 0.12.0 + version: 0.13.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-dns.yml b/data/registry/instrumentation-js-dns.yml index c2b2f9545b9f..b72a2a3cdb80 100644 --- a/data/registry/instrumentation-js-dns.yml +++ b/data/registry/instrumentation-js-dns.yml @@ -14,5 +14,5 @@ createdAt: 2020-11-09 package: registry: npm name: '@opentelemetry/instrumentation-dns' - version: 0.39.0 + version: 0.40.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-document-load.yml b/data/registry/instrumentation-js-document-load.yml index 0d94450ddbc1..13b92edc69ce 100644 --- a/data/registry/instrumentation-js-document-load.yml +++ b/data/registry/instrumentation-js-document-load.yml @@ -14,5 +14,5 @@ createdAt: 2020-11-09 package: registry: npm name: '@opentelemetry/instrumentation-document-load' - version: 0.40.0 + version: 0.41.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-express.yml b/data/registry/instrumentation-js-express.yml index e1c017a6c0f5..f82ebf0dee3e 100644 --- a/data/registry/instrumentation-js-express.yml +++ b/data/registry/instrumentation-js-express.yml @@ -14,5 +14,5 @@ createdAt: 2020-11-09 package: registry: npm name: '@opentelemetry/instrumentation-express' - version: 0.43.0 + version: 0.44.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-fastify.yml b/data/registry/instrumentation-js-fastify.yml index 7dd29e97ea7d..2a5f65da794f 100644 --- a/data/registry/instrumentation-js-fastify.yml +++ b/data/registry/instrumentation-js-fastify.yml @@ -15,5 +15,5 @@ createdAt: 2020-08-28 package: registry: npm name: '@opentelemetry/instrumentation-fastify' - version: 0.40.0 + version: 0.41.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-fetch.yml b/data/registry/instrumentation-js-fetch.yml index f687cf504d34..939dc1923062 100644 --- a/data/registry/instrumentation-js-fetch.yml +++ b/data/registry/instrumentation-js-fetch.yml @@ -14,5 +14,5 @@ createdAt: 2020-11-09 package: registry: npm name: '@opentelemetry/instrumentation-fetch' - version: 0.53.0 + version: 0.54.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-fs.yml b/data/registry/instrumentation-js-fs.yml index 17617ea0aa3e..30c20a2b72a8 100644 --- a/data/registry/instrumentation-js-fs.yml +++ b/data/registry/instrumentation-js-fs.yml @@ -15,5 +15,5 @@ createdAt: 2021-07-08 package: registry: npm name: '@opentelemetry/instrumentation-fs' - version: 0.15.0 + version: 0.16.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-generic-pool.yml b/data/registry/instrumentation-js-generic-pool.yml index 6282ffa47af6..3d88caf363ee 100644 --- a/data/registry/instrumentation-js-generic-pool.yml +++ b/data/registry/instrumentation-js-generic-pool.yml @@ -16,5 +16,5 @@ createdAt: 2020-11-09 package: registry: npm name: '@opentelemetry/instrumentation-generic-pool' - version: 0.39.0 + version: 0.40.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-graphql.yml b/data/registry/instrumentation-js-graphql.yml index d3452c06606a..658d7cec68f7 100644 --- a/data/registry/instrumentation-js-graphql.yml +++ b/data/registry/instrumentation-js-graphql.yml @@ -14,5 +14,5 @@ createdAt: 2020-11-09 package: registry: npm name: '@opentelemetry/instrumentation-graphql' - version: 0.43.0 + version: 0.44.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-grpc.yml b/data/registry/instrumentation-js-grpc.yml index 1bf65a95daac..ca6353b31d8c 100644 --- a/data/registry/instrumentation-js-grpc.yml +++ b/data/registry/instrumentation-js-grpc.yml @@ -14,5 +14,5 @@ createdAt: 2020-11-09 package: registry: npm name: '@opentelemetry/instrumentation-grpc' - version: 0.53.0 + version: 0.54.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-hapi.yml b/data/registry/instrumentation-js-hapi.yml index 8a8ae6a78e10..79475103811b 100644 --- a/data/registry/instrumentation-js-hapi.yml +++ b/data/registry/instrumentation-js-hapi.yml @@ -15,5 +15,5 @@ createdAt: 2020-11-09 package: registry: npm name: '@opentelemetry/instrumentation-hapi' - version: 0.41.0 + version: 0.42.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-http.yml b/data/registry/instrumentation-js-http.yml index 845dfe2f7c19..cb20d8b27d03 100644 --- a/data/registry/instrumentation-js-http.yml +++ b/data/registry/instrumentation-js-http.yml @@ -14,5 +14,5 @@ createdAt: 2020-11-09 package: registry: npm name: '@opentelemetry/instrumentation-http' - version: 0.53.0 + version: 0.54.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-ioredis.yml b/data/registry/instrumentation-js-ioredis.yml index 7086fb533b3f..fdc1db7eb41a 100644 --- a/data/registry/instrumentation-js-ioredis.yml +++ b/data/registry/instrumentation-js-ioredis.yml @@ -15,5 +15,5 @@ createdAt: 2020-11-09 package: registry: npm name: '@opentelemetry/instrumentation-ioredis' - version: 0.43.0 + version: 0.44.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-knex.yml b/data/registry/instrumentation-js-knex.yml index 61de037a35d4..63acb01bc33d 100644 --- a/data/registry/instrumentation-js-knex.yml +++ b/data/registry/instrumentation-js-knex.yml @@ -17,5 +17,5 @@ createdAt: 2021-07-08 package: registry: npm name: '@opentelemetry/instrumentation-knex' - version: 0.40.0 + version: 0.41.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-koa.yml b/data/registry/instrumentation-js-koa.yml index 07de8981cbea..20d2a3e37084 100644 --- a/data/registry/instrumentation-js-koa.yml +++ b/data/registry/instrumentation-js-koa.yml @@ -14,5 +14,5 @@ createdAt: 2020-11-09 package: registry: npm name: '@opentelemetry/instrumentation-koa' - version: 0.43.0 + version: 0.44.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-langchain.yml b/data/registry/instrumentation-js-langchain.yml index 405dfcb50d35..feb8aa54a273 100644 --- a/data/registry/instrumentation-js-langchain.yml +++ b/data/registry/instrumentation-js-langchain.yml @@ -18,5 +18,5 @@ createdAt: 2024-06-05 package: registry: npm name: '@arizeai/openinference-instrumentation-langchain' - version: 0.2.0 + version: 1.0.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-long-task.yml b/data/registry/instrumentation-js-long-task.yml index 8a3bac0c7148..64b9976a38ee 100644 --- a/data/registry/instrumentation-js-long-task.yml +++ b/data/registry/instrumentation-js-long-task.yml @@ -14,5 +14,5 @@ createdAt: 2021-07-08 package: registry: npm name: '@opentelemetry/instrumentation-long-task' - version: 0.40.0 + version: 0.41.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-lru-memoizer.yml b/data/registry/instrumentation-js-lru-memoizer.yml index 5f94fc71c476..759b3bc353c9 100644 --- a/data/registry/instrumentation-js-lru-memoizer.yml +++ b/data/registry/instrumentation-js-lru-memoizer.yml @@ -17,5 +17,5 @@ createdAt: 2022-10-27 package: registry: npm name: '@opentelemetry/instrumentation-lru-memoizer' - version: 0.40.0 + version: 0.41.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-memcached.yml b/data/registry/instrumentation-js-memcached.yml index 50ae19fcfc5d..c6eb4c2fe8b2 100644 --- a/data/registry/instrumentation-js-memcached.yml +++ b/data/registry/instrumentation-js-memcached.yml @@ -15,5 +15,5 @@ createdAt: 2021-07-08 package: registry: npm name: '@opentelemetry/instrumentation-memcached' - version: 0.39.0 + version: 0.40.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-mongodb.yml b/data/registry/instrumentation-js-mongodb.yml index add69c2c7656..22198af3e172 100644 --- a/data/registry/instrumentation-js-mongodb.yml +++ b/data/registry/instrumentation-js-mongodb.yml @@ -14,5 +14,5 @@ createdAt: 2020-11-09 package: registry: npm name: '@opentelemetry/instrumentation-mongodb' - version: 0.47.0 + version: 0.48.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-mongoose-instrumentation.yml b/data/registry/instrumentation-js-mongoose-instrumentation.yml index 54ce3bc29aee..e0916a68b13f 100644 --- a/data/registry/instrumentation-js-mongoose-instrumentation.yml +++ b/data/registry/instrumentation-js-mongoose-instrumentation.yml @@ -16,5 +16,5 @@ createdAt: 2021-02-17 package: registry: npm name: '@opentelemetry/instrumentation-mongoose' - version: 0.42.0 + version: 0.43.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-mysql.yml b/data/registry/instrumentation-js-mysql.yml index 4636e825d096..1ec1ff0f0bce 100644 --- a/data/registry/instrumentation-js-mysql.yml +++ b/data/registry/instrumentation-js-mysql.yml @@ -14,5 +14,5 @@ createdAt: 2020-11-09 package: registry: npm name: '@opentelemetry/instrumentation-mysql' - version: 0.41.0 + version: 0.42.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-mysql2.yml b/data/registry/instrumentation-js-mysql2.yml index a9035b181e60..8314b54d30f5 100644 --- a/data/registry/instrumentation-js-mysql2.yml +++ b/data/registry/instrumentation-js-mysql2.yml @@ -18,5 +18,5 @@ createdAt: 2021-07-08 package: registry: npm name: '@opentelemetry/instrumentation-mysql2' - version: 0.41.0 + version: 0.42.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-nestjs-core.yml b/data/registry/instrumentation-js-nestjs-core.yml index 772dcc7bfa32..3d5412eef3fc 100644 --- a/data/registry/instrumentation-js-nestjs-core.yml +++ b/data/registry/instrumentation-js-nestjs-core.yml @@ -17,5 +17,5 @@ createdAt: 2021-07-09 package: registry: npm name: '@opentelemetry/instrumentation-nestjs-core' - version: 0.40.0 + version: 0.41.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-nestjs.yml b/data/registry/instrumentation-js-nestjs.yml index 66f578d12088..0ac98f06c7d0 100644 --- a/data/registry/instrumentation-js-nestjs.yml +++ b/data/registry/instrumentation-js-nestjs.yml @@ -16,5 +16,5 @@ createdAt: 2021-07-09 package: registry: npm name: '@opentelemetry/instrumentation-nestjs-core' - version: 0.40.0 + version: 0.41.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-net.yml b/data/registry/instrumentation-js-net.yml index 8d1f1ed2f9da..a6a78ff14593 100644 --- a/data/registry/instrumentation-js-net.yml +++ b/data/registry/instrumentation-js-net.yml @@ -14,5 +14,5 @@ createdAt: 2021-07-08 package: registry: npm name: '@opentelemetry/instrumentation-net' - version: 0.39.0 + version: 0.40.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-openai.yml b/data/registry/instrumentation-js-openai.yml index 1b371fc5fdca..8c57c7241851 100644 --- a/data/registry/instrumentation-js-openai.yml +++ b/data/registry/instrumentation-js-openai.yml @@ -18,5 +18,5 @@ createdAt: 2024-06-05 package: registry: npm name: '@arizeai/openinference-instrumentation-openai' - version: 0.5.0 + version: 1.0.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-pg.yml b/data/registry/instrumentation-js-pg.yml index a063b2296fcb..5a4dee7c7b8e 100644 --- a/data/registry/instrumentation-js-pg.yml +++ b/data/registry/instrumentation-js-pg.yml @@ -14,5 +14,5 @@ createdAt: 2020-11-09 package: registry: npm name: '@opentelemetry/instrumentation-pg' - version: 0.45.1 + version: 0.47.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-pillarjs-router.yml b/data/registry/instrumentation-js-pillarjs-router.yml index 5ace3a140b26..29cf8268ed5c 100644 --- a/data/registry/instrumentation-js-pillarjs-router.yml +++ b/data/registry/instrumentation-js-pillarjs-router.yml @@ -20,5 +20,5 @@ createdAt: 2021-07-08 package: registry: npm name: '@opentelemetry/instrumentation-restify' - version: 0.41.0 + version: 0.42.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-pino.yml b/data/registry/instrumentation-js-pino.yml index b4f2e853d380..8e0c00dca658 100644 --- a/data/registry/instrumentation-js-pino.yml +++ b/data/registry/instrumentation-js-pino.yml @@ -16,5 +16,5 @@ createdAt: 2021-07-08 package: registry: npm name: '@opentelemetry/instrumentation-pino' - version: 0.42.0 + version: 0.43.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-postgres.yml b/data/registry/instrumentation-js-postgres.yml index 92e0cbc5396d..baa1c11c5aab 100644 --- a/data/registry/instrumentation-js-postgres.yml +++ b/data/registry/instrumentation-js-postgres.yml @@ -17,5 +17,5 @@ createdAt: 2020-11-09 package: registry: npm name: '@opentelemetry/instrumentation-pg' - version: 0.45.1 + version: 0.47.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-prisma.yml b/data/registry/instrumentation-js-prisma.yml index 6e822eb2f803..646f60052e95 100644 --- a/data/registry/instrumentation-js-prisma.yml +++ b/data/registry/instrumentation-js-prisma.yml @@ -17,5 +17,5 @@ createdAt: 2022-08-25 package: registry: npm name: '@prisma/instrumentation' - version: 5.20.0 + version: 5.21.1 isFirstParty: true diff --git a/data/registry/instrumentation-js-redis-4.yml b/data/registry/instrumentation-js-redis-4.yml index 9f2c491ad783..901bc073a903 100644 --- a/data/registry/instrumentation-js-redis-4.yml +++ b/data/registry/instrumentation-js-redis-4.yml @@ -16,5 +16,5 @@ createdAt: 2022-10-27 package: registry: npm name: '@opentelemetry/instrumentation-redis-4' - version: 0.42.1 + version: 0.43.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-redis.yml b/data/registry/instrumentation-js-redis.yml index ee453a6923dc..a56a3460821c 100644 --- a/data/registry/instrumentation-js-redis.yml +++ b/data/registry/instrumentation-js-redis.yml @@ -14,5 +14,5 @@ createdAt: 2020-11-09 package: registry: npm name: '@opentelemetry/instrumentation-redis' - version: 0.42.0 + version: 0.43.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-remix.yml b/data/registry/instrumentation-js-remix.yml index 06d3463808a0..54ccaa42ca29 100644 --- a/data/registry/instrumentation-js-remix.yml +++ b/data/registry/instrumentation-js-remix.yml @@ -17,5 +17,5 @@ createdAt: 2022-02-10 package: registry: npm name: opentelemetry-instrumentation-remix - version: 0.7.1 + version: 0.8.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-restify.yml b/data/registry/instrumentation-js-restify.yml index abfd85006d6f..bd63f02c2b20 100644 --- a/data/registry/instrumentation-js-restify.yml +++ b/data/registry/instrumentation-js-restify.yml @@ -15,5 +15,5 @@ createdAt: 2021-07-08 package: registry: npm name: '@opentelemetry/instrumentation-restify' - version: 0.41.0 + version: 0.42.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-router.yml b/data/registry/instrumentation-js-router.yml index 70a93f53ac7c..16c047e1bf62 100644 --- a/data/registry/instrumentation-js-router.yml +++ b/data/registry/instrumentation-js-router.yml @@ -14,5 +14,5 @@ createdAt: 2020-11-09 package: registry: npm name: '@opentelemetry/instrumentation-router' - version: 0.40.0 + version: 0.41.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-runtimenode.yml b/data/registry/instrumentation-js-runtimenode.yml index f490d56e072b..52a18b6df3eb 100644 --- a/data/registry/instrumentation-js-runtimenode.yml +++ b/data/registry/instrumentation-js-runtimenode.yml @@ -19,5 +19,5 @@ createdAt: 2024-04-18 package: registry: npm name: '@opentelemetry/instrumentation-runtime-node' - version: 0.7.0 + version: 0.8.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-socket.io.yml b/data/registry/instrumentation-js-socket.io.yml index c19c6087b6cb..31469d9ba5a5 100644 --- a/data/registry/instrumentation-js-socket.io.yml +++ b/data/registry/instrumentation-js-socket.io.yml @@ -16,5 +16,5 @@ createdAt: 2022-10-27 package: registry: npm name: '@opentelemetry/instrumentation-socket.io' - version: 0.42.0 + version: 0.43.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-tedious.yml b/data/registry/instrumentation-js-tedious.yml index 3d9e2131326d..114408f4b404 100644 --- a/data/registry/instrumentation-js-tedious.yml +++ b/data/registry/instrumentation-js-tedious.yml @@ -16,5 +16,5 @@ createdAt: 2022-10-27 package: registry: npm name: '@opentelemetry/instrumentation-tedious' - version: 0.14.0 + version: 0.15.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-undici.yml b/data/registry/instrumentation-js-undici.yml index abb5a08ed9ce..9631b68e4ea5 100644 --- a/data/registry/instrumentation-js-undici.yml +++ b/data/registry/instrumentation-js-undici.yml @@ -19,5 +19,5 @@ createdAt: 2024-04-18 package: registry: npm name: '@opentelemetry/instrumentation-undici' - version: 0.6.0 + version: 0.7.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-user-interaction.yml b/data/registry/instrumentation-js-user-interaction.yml index 703f01086d39..5f991e06fcd5 100644 --- a/data/registry/instrumentation-js-user-interaction.yml +++ b/data/registry/instrumentation-js-user-interaction.yml @@ -14,5 +14,5 @@ createdAt: 2020-11-09 package: registry: npm name: '@opentelemetry/instrumentation-user-interaction' - version: 0.40.0 + version: 0.41.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-winston.yml b/data/registry/instrumentation-js-winston.yml index f29f3ad2f63f..070873c2f1d6 100644 --- a/data/registry/instrumentation-js-winston.yml +++ b/data/registry/instrumentation-js-winston.yml @@ -16,5 +16,5 @@ createdAt: 2021-07-08 package: registry: npm name: '@opentelemetry/instrumentation-winston' - version: 0.40.0 + version: 0.41.0 isFirstParty: false diff --git a/data/registry/instrumentation-js-xml-http-request.yml b/data/registry/instrumentation-js-xml-http-request.yml index b0b4e86b0707..a237be330c88 100644 --- a/data/registry/instrumentation-js-xml-http-request.yml +++ b/data/registry/instrumentation-js-xml-http-request.yml @@ -14,5 +14,5 @@ createdAt: 2020-11-09 package: registry: npm name: '@opentelemetry/instrumentation-xml-http-request' - version: 0.53.0 + version: 0.54.0 isFirstParty: false diff --git a/data/registry/instrumentation-php-guzzle.yml b/data/registry/instrumentation-php-guzzle.yml index 53d07f4f7576..95212624294a 100644 --- a/data/registry/instrumentation-php-guzzle.yml +++ b/data/registry/instrumentation-php-guzzle.yml @@ -15,5 +15,5 @@ createdAt: 2024-01-19 package: registry: packagist name: open-telemetry/opentelemetry-auto-guzzle - version: 1.0.0 + version: 1.0.1 isFirstParty: false diff --git a/data/registry/instrumentation-php-laravel.yml b/data/registry/instrumentation-php-laravel.yml index 1aaf1e2f4ace..bee5f2b34eec 100644 --- a/data/registry/instrumentation-php-laravel.yml +++ b/data/registry/instrumentation-php-laravel.yml @@ -15,5 +15,5 @@ createdAt: 2023-05-22 package: registry: packagist name: open-telemetry/opentelemetry-auto-laravel - version: 0.0.28 + version: 1.0.0 isFirstParty: false diff --git a/data/registry/instrumentation-php-pdo.yml b/data/registry/instrumentation-php-pdo.yml index 92522edd52e5..32d0d71aabff 100644 --- a/data/registry/instrumentation-php-pdo.yml +++ b/data/registry/instrumentation-php-pdo.yml @@ -15,5 +15,5 @@ createdAt: 2023-05-22 package: registry: packagist name: open-telemetry/opentelemetry-auto-pdo - version: 0.0.15 + version: 0.0.16 isFirstParty: false diff --git a/data/registry/instrumentation-php-psr3.yml b/data/registry/instrumentation-php-psr3.yml index d30f73eead7a..ff0ba130d1cc 100644 --- a/data/registry/instrumentation-php-psr3.yml +++ b/data/registry/instrumentation-php-psr3.yml @@ -17,5 +17,5 @@ createdAt: 2023-07-10 package: registry: packagist name: open-telemetry/opentelemetry-auto-psr3 - version: 0.0.7 + version: 0.0.8 isFirstParty: false diff --git a/data/registry/instrumentation-php-symfony.yml b/data/registry/instrumentation-php-symfony.yml index 3a2f3a721397..a3660b093f17 100644 --- a/data/registry/instrumentation-php-symfony.yml +++ b/data/registry/instrumentation-php-symfony.yml @@ -15,5 +15,5 @@ createdAt: 2023-05-22 package: registry: packagist name: open-telemetry/opentelemetry-auto-symfony - version: 1.0.0beta29 + version: 1.0.0beta30 isFirstParty: false diff --git a/data/registry/instrumentation-ruby-actionmailer.yml b/data/registry/instrumentation-ruby-actionmailer.yml index 5c3de4fc1eff..f013df9712ba 100644 --- a/data/registry/instrumentation-ruby-actionmailer.yml +++ b/data/registry/instrumentation-ruby-actionmailer.yml @@ -19,5 +19,5 @@ createdAt: 2024-07-08 package: registry: gems name: opentelemetry-instrumentation-action_mailer - version: 0.1.0 + version: 0.2.0 isFirstParty: false diff --git a/data/registry/instrumentation-ruby-active-job.yml b/data/registry/instrumentation-ruby-active-job.yml index 8403c88d95fd..5017df229f84 100644 --- a/data/registry/instrumentation-ruby-active-job.yml +++ b/data/registry/instrumentation-ruby-active-job.yml @@ -15,5 +15,5 @@ createdAt: 2020-11-09 package: registry: gems name: opentelemetry-instrumentation-active_job - version: 0.7.7 + version: 0.7.8 isFirstParty: false diff --git a/data/registry/instrumentation-ruby-active-record.yml b/data/registry/instrumentation-ruby-active-record.yml index c02056ef45fb..aca1b3aecd93 100644 --- a/data/registry/instrumentation-ruby-active-record.yml +++ b/data/registry/instrumentation-ruby-active-record.yml @@ -15,5 +15,5 @@ createdAt: 2020-11-09 package: registry: gems name: opentelemetry-instrumentation-active_record - version: 0.7.4 + version: 0.8.0 isFirstParty: false diff --git a/data/registry/instrumentation-ruby-all.yml b/data/registry/instrumentation-ruby-all.yml index 193690e310a4..809a5b3f9a05 100644 --- a/data/registry/instrumentation-ruby-all.yml +++ b/data/registry/instrumentation-ruby-all.yml @@ -14,5 +14,5 @@ createdAt: 2020-11-09 package: registry: gems name: opentelemetry-instrumentation-all - version: 0.66.0 + version: 0.68.0 isFirstParty: false diff --git a/data/registry/instrumentation-ruby-rack.yml b/data/registry/instrumentation-ruby-rack.yml index a14f3ee1fd06..07774887bd88 100644 --- a/data/registry/instrumentation-ruby-rack.yml +++ b/data/registry/instrumentation-ruby-rack.yml @@ -14,5 +14,5 @@ createdAt: 2020-11-09 package: registry: gems name: opentelemetry-instrumentation-rack - version: 0.24.6 + version: 0.25.0 isFirstParty: false diff --git a/data/registry/instrumentation-ruby-rails.yml b/data/registry/instrumentation-ruby-rails.yml index f9ef6fc07857..3cf3a839f759 100644 --- a/data/registry/instrumentation-ruby-rails.yml +++ b/data/registry/instrumentation-ruby-rails.yml @@ -14,5 +14,5 @@ createdAt: 2020-11-09 package: registry: gems name: opentelemetry-instrumentation-rails - version: 0.31.2 + version: 0.32.0 isFirstParty: false diff --git a/data/registry/resource-detector-js-alibabacloud.yml b/data/registry/resource-detector-js-alibabacloud.yml index 017fa0620752..71c4a9fb792d 100644 --- a/data/registry/resource-detector-js-alibabacloud.yml +++ b/data/registry/resource-detector-js-alibabacloud.yml @@ -16,4 +16,4 @@ createdAt: 2022-12-07 package: registry: npm name: '@opentelemetry/resource-detector-alibaba-cloud' - version: 0.29.3 + version: 0.29.4 diff --git a/data/registry/resource-detector-js-aws.yml b/data/registry/resource-detector-js-aws.yml index de31d958789e..7f873a68e493 100644 --- a/data/registry/resource-detector-js-aws.yml +++ b/data/registry/resource-detector-js-aws.yml @@ -15,4 +15,4 @@ createdAt: 2022-12-07 package: registry: npm name: '@opentelemetry/resource-detector-aws' - version: 1.6.2 + version: 1.7.0 diff --git a/data/registry/resource-detector-js-azure.yml b/data/registry/resource-detector-js-azure.yml index c68c198b4d58..95d2a252fd51 100644 --- a/data/registry/resource-detector-js-azure.yml +++ b/data/registry/resource-detector-js-azure.yml @@ -15,4 +15,4 @@ createdAt: 2022-12-07 package: registry: npm name: '@opentelemetry/resource-detector-azure' - version: 0.2.11 + version: 0.2.12 diff --git a/data/registry/resource-detector-js-container.yml b/data/registry/resource-detector-js-container.yml index 143c76f68072..f5180bccaabc 100644 --- a/data/registry/resource-detector-js-container.yml +++ b/data/registry/resource-detector-js-container.yml @@ -17,4 +17,4 @@ createdAt: 2022-12-07 package: registry: npm name: '@opentelemetry/resource-detector-container' - version: 0.4.3 + version: 0.5.0 diff --git a/data/registry/resource-detector-js-gcp.yml b/data/registry/resource-detector-js-gcp.yml index e4193857d08b..a213d8d17d98 100644 --- a/data/registry/resource-detector-js-gcp.yml +++ b/data/registry/resource-detector-js-gcp.yml @@ -15,4 +15,4 @@ createdAt: 2022-12-07 package: registry: npm name: '@opentelemetry/resource-detector-gcp' - version: 0.29.12 + version: 0.29.13 diff --git a/data/registry/resource-detector-js-instana.yml b/data/registry/resource-detector-js-instana.yml index d64864f80b94..4fddf94f3241 100644 --- a/data/registry/resource-detector-js-instana.yml +++ b/data/registry/resource-detector-js-instana.yml @@ -17,4 +17,4 @@ createdAt: 2022-12-07 package: registry: npm name: '@opentelemetry/resource-detector-instana' - version: 0.13.0 + version: 0.14.0 diff --git a/data/registry/tools-java-druid-extension-otlp.yaml b/data/registry/tools-java-druid-extension-otlp.yaml new file mode 100644 index 000000000000..f0020a71f6ad --- /dev/null +++ b/data/registry/tools-java-druid-extension-otlp.yaml @@ -0,0 +1,28 @@ +title: Apache Druid extension for OTLP +registryType: utilities +language: java +tags: + - java + - druid + - utilities + - analytics + - dashboards + - monitoring +license: Apache 2.0 +description: This extension allows [Apache Druid](https://druid.apache.org/) to + ingest OpenTelemetry signals. + + An example setup would be to use the [Kafka + Exporter](https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/exporter/kafkaexporter/README.md) + to publish OTLP data into Kafka topics, and then setup Druid ingestion jobs, + using this extension, to populate tables. +authors: + - name: mishmash io + email: opensourcemaintainers@mishmash.io + url: https://mishmash.io +urls: + repo: https://github.com/mishmash-io/opentelemetry-server-embedded + docs: https://github.com/mishmash-io/opentelemetry-server-embedded/tree/main/druid-otlp-format +createdAt: 2024-10-17 +isNative: false +isFirstParty: false diff --git a/hugo.yaml b/hugo.yaml index c102ecf54a22..9c044f2e19e3 100644 --- a/hugo.yaml +++ b/hugo.yaml @@ -20,6 +20,10 @@ languages: languageName: Español params: description: Sitio del proyecto OpenTelemetry + fr: + languageName: Français + params: + description: Site du projet OpenTelemetry ja: languageName: 日本語 (Japanese) params: @@ -259,6 +263,19 @@ module: target: content/docs lang: es + ## fr + - source: content/fr + target: content + lang: fr + # fallback pages + - source: content/en/announcements + target: content/announcements + lang: fr + - excludeFiles: specs/* + source: content/en/docs + target: content/docs + lang: fr + ## ja - source: content/ja target: content diff --git a/layouts/partials/docs/native-libraries.md b/layouts/partials/docs/native-libraries.md new file mode 100644 index 000000000000..15f392695be0 --- /dev/null +++ b/layouts/partials/docs/native-libraries.md @@ -0,0 +1,31 @@ + +{{ $howMany := .Get 1 | default 10 -}} +{{ $langIndex := .Get 0 }} +{{ $lang := index $.Site.Data.instrumentation $langIndex -}} +{{ $integrations := where (slice ) ".language" $langIndex -}} + +{{ $integrations := slice }} {{ range $entry := $.Site.Data.registry }} +{{ if and (and (eq $entry.language $langIndex) (eq $entry.isNative true)) (eq $entry.registryType "instrumentation") }} +{{ $integrations = $integrations | append $entry }} {{ end }} {{ end }} + +{{ range first $howMany (sort $integrations "name") -}} + + +- [{{ .title }}]({{ .urls.docs }}) +{{- end }} + +{{ if eq (len $integrations) 0 -}} + + +{{ else -}} + +{{ end -}} diff --git a/layouts/partials/pt/docs/latest-release.md b/layouts/partials/pt/docs/latest-release.md new file mode 100644 index 000000000000..26df2998e6e3 --- /dev/null +++ b/layouts/partials/pt/docs/latest-release.md @@ -0,0 +1,7 @@ +{{ $relUrl := printf "https://github.com/open-telemetry/opentelemetry-%s/releases" .lang -}} + +Para lançamentos, incluindo a [última versão][latest release], consulte a página de [Lançamentos][Releases]. +{{- .Inner }} + +[latest release]: {{ $relUrl }}/latest +[Releases]: {{ $relUrl }} diff --git a/layouts/shortcodes/docs/languages/libraries-intro.md b/layouts/shortcodes/docs/languages/libraries-intro.md index 00a40302dbe3..614e46f3ae41 100644 --- a/layouts/shortcodes/docs/languages/libraries-intro.md +++ b/layouts/shortcodes/docs/languages/libraries-intro.md @@ -31,24 +31,4 @@ OpenTelemetry SDK with your app. The library might require some additional configuration for the instrumentation. Go to the documentation for that library to learn more. -{{ range first $howMany (sort $integrations "name") -}} - - -- [{{ .title }}]({{ .urls.docs }}) -{{- end }} - -{{ if eq (len $integrations) 0 -}} - - -{{ else -}} - -{{ end -}} +{{ partial "docs/native-libraries.md" . }} diff --git a/layouts/shortcodes/docs/languages/native-libraries.md b/layouts/shortcodes/docs/languages/native-libraries.md new file mode 100644 index 000000000000..53f520730de3 --- /dev/null +++ b/layouts/shortcodes/docs/languages/native-libraries.md @@ -0,0 +1 @@ +{{ partial "docs/native-libraries.md" . }} diff --git a/layouts/shortcodes/pt/docs/languages/index-intro.md b/layouts/shortcodes/pt/docs/languages/index-intro.md new file mode 100644 index 000000000000..0492c4e57401 --- /dev/null +++ b/layouts/shortcodes/pt/docs/languages/index-intro.md @@ -0,0 +1,28 @@ +{{/* +default_lang_commit: 2e21274a01a24a62c67595591d8f4255bef640fc +*/ -}} +{{ $prettier_ignore := ` + + +` -}} +{{ $lang := .Get 0 -}} +{{ $data := index $.Site.Data.instrumentation $lang }} +{{ $name := $data.name -}} + +{{ $tracesStatus := partial "docs/get-signal-status.html" (dict "lang" $lang "signal" "traces") -}} +{{ $metricsStatus := partial "docs/get-signal-status.html" (dict "lang" $lang "signal" "metrics") -}} +{{ $logsStatus := partial "docs/get-signal-status.html" (dict "lang" $lang "signal" "logs") -}} + +Esta é a documentação do OpenTelemetry para a linguagem {{ $name }}. O OpenTelemetry é um +framework de observabilidade -- API, SDKs, e ferramentas que são desenvolvidas para auxiliar na +geração e coleta de dados de telemetria de aplicações, como métricas, logs e rastros. Esta documentação foi criada para te auxiliar a entender como começar a utilizar o OpenTelemetry em {{ $name }}. + +## Estado e Lançamentos + +O estado atual dos principais componentes funcionais do OpenTelemetry para {{ $name }} é o seguinte: + +| Rastros | Métricas | Logs | +| ------------------- | -------------------- | ----------------- | +| {{ $tracesStatus }} | {{ $metricsStatus }} | {{ $logsStatus }} | + +{{ partial "pt/docs/latest-release.md" (dict "lang" $lang "Inner" .Inner) -}} diff --git a/package.json b/package.json index 983391a16dac..530e10113633 100644 --- a/package.json +++ b/package.json @@ -1,5 +1,4 @@ { - "spelling": "cSpell:ignore docsy elemetry htmltest hugo loglevel netlify nowrap prebuild precheck preinstall postbuild postget refcache textlint -", "Notes": [ "The 'all' runs _all_ named scripts in sequence, even if one fails; and exits with failure in that case." ], @@ -86,8 +85,8 @@ "prebuild:preview": "npm run _prebuild", "prebuild:production": "npm run _prebuild", "prebuild": "npm run _prebuild", - "precheck:links:internal": "npm run build", - "precheck:links": "npm run build", + "precheck:links:internal": "npm run build && npm run update:htmltest-config", + "precheck:links": "npm run build && npm run update:htmltest-config", "prefix:submodules": "npm run update:submodule", "prenetlify-build:production": "echo 'IgnoreTagAttribute: rel' >> .htmltest.yml", "prepare": "npm run seq -- get:submodule _prepare:docsy", @@ -102,6 +101,7 @@ "test-and-fix": "npm run seq -- check fix:dict fix:filenames", "test": "npm run check", "update:docsy-dep": "npm install --save-dev autoprefixer@latest postcss-cli@latest", + "update:htmltest-config": "scripts/htmltest-config.sh", "update:hugo": "npm install --save-dev --save-exact hugo-extended@latest", "update:hugo+": "npm run update:hugo && npm run update:docsy-dep", "update:netlify": "npm install --save-optional netlify-cli@latest", @@ -111,22 +111,23 @@ "update:submodule": "set -x && git submodule update --remote ${DEPTH:- --depth 999}" }, "devDependencies": { - "@cspell/dict-es-es": "^3.0.0", - "@cspell/dict-pt-br": "^2.3.0", + "@cspell/dict-es-es": "^3.0.3", + "@cspell/dict-fr-fr": "^2.2.5", + "@cspell/dict-pt-br": "^2.3.3", "ajv": "^8.17.1", "ajv-errors": "^3.0.0", "ajv-formats": "^3.0.1", "autoprefixer": "^10.4.20", - "cspell": "^8.14.4", + "cspell": "^8.15.5", "gulp": "^5.0.0", - "hugo-extended": "0.133.0", + "hugo-extended": "0.136.5", "js-yaml": "^4.1.0", "markdown-link-check": "^3.12.2", - "markdownlint": "^0.35.0", + "markdownlint": "^0.36.1", "postcss-cli": "^11.0.0", "prettier": "^3.3.3", "require-dir": "^1.2.0", - "textlint": "^14.2.0", + "textlint": "^14.3.0", "textlint-filter-rule-allowlist": "^4.0.0", "textlint-filter-rule-comments": "^1.2.2", "textlint-rule-terminology": "^5.2.12", @@ -135,29 +136,30 @@ }, "dependencies": { "@opentelemetry/api": "^1.9.0", - "@opentelemetry/auto-instrumentations-web": "^0.41.0", - "@opentelemetry/context-zone": "^1.26.0", - "@opentelemetry/core": "^1.26.0", - "@opentelemetry/exporter-trace-otlp-http": "^0.53.0", - "@opentelemetry/instrumentation": "^0.53.0", - "@opentelemetry/resources": "^1.26.0", - "@opentelemetry/sdk-trace-base": "^1.26.0", - "@opentelemetry/sdk-trace-web": "^1.26.0", + "@opentelemetry/auto-instrumentations-web": "^0.42.0", + "@opentelemetry/context-zone": "^1.27.0", + "@opentelemetry/core": "^1.27.0", + "@opentelemetry/exporter-trace-otlp-http": "^0.54.0", + "@opentelemetry/instrumentation": "^0.54.0", + "@opentelemetry/resources": "^1.27.0", + "@opentelemetry/sdk-trace-base": "^1.27.0", + "@opentelemetry/sdk-trace-web": "^1.27.0", "@opentelemetry/semantic-conventions": "^1.27.0", "path": "^0.12.7" }, "optionalDependencies": { - "netlify-cli": "^17.36.4", - "npm-check-updates": "^17.1.3" + "netlify-cli": "^17.37.2", + "npm-check-updates": "^17.1.9" }, "enginesComment": "Ensure that engines.node value stays consistent with the project's .nvmrc", "engines": { - "node": "20.x" + "node": "22.x" }, "gitHubActionCacheKey": "2023-07-13 - change this key to force cache refresh", "private": true, "prettier": { "proseWrap": "always", "singleQuote": true - } + }, + "spelling": "cSpell:ignore docsy elemetry htmltest hugo loglevel netlify nowrap postnetlify prebuild precheck preinstall postbuild postget refcache textlint -" } diff --git a/scripts/content-modules/adjust-pages.pl b/scripts/content-modules/adjust-pages.pl index c0d7fc219dc5..ae801b5728eb 100755 --- a/scripts/content-modules/adjust-pages.pl +++ b/scripts/content-modules/adjust-pages.pl @@ -127,15 +127,15 @@ () # Images s|(\.\./)?internal(/img/[-\w]+\.png)|$2|g; s|(\]\()(img/.*?\))|$1../$2|g if $ARGV !~ /(logs|schemas)._index/ && $ARGV !~ /otlp\/docs/; - s|(\]\()([^)]+\.png\))|$1../$2|g if $ARGV =~ /\/tmp\/semconv\/docs\/general\/attributes/; - s|(\]\()([^)]+\.png\))|$1../$2|g if $ARGV =~ /\/tmp\/semconv\/docs\/http\/http-spans/; + s|(\]\()([^)]+\.png\))|$1../$2|g if $ARGV =~ /\btmp\/semconv\/docs\/general\/attributes/; + s|(\]\()([^)]+\.png\))|$1../$2|g if $ARGV =~ /\btmp\/semconv\/docs\/http\/http-spans/; s|\.\.\/README.md\b|$otelSpecRepoUrl/|g if $ARGV =~ /specification._index/; s|\.\.\/README.md\b|..| if $ARGV =~ /specification.library-guidelines.md/; - s|\.\./(opentelemetry/proto/?.*)|$otlpSpecRepoUrl/tree/v$otlpSpecVers/$1|g if $ARGV =~ /\/tmp\/otlp/; - s|\.\./README.md\b|$otlpSpecRepoUrl/|g if $ARGV =~ /\/tmp\/otlp/; - s|\.\./examples/README.md\b|$otlpSpecRepoUrl/tree/v$otlpSpecVers/examples/|g if $ARGV =~ /\/tmp\/otlp/; + s|\.\./(opentelemetry/proto/?.*)|$otlpSpecRepoUrl/tree/v$otlpSpecVers/$1|g if $ARGV =~ /\btmp\/otlp/; + s|\.\./README.md\b|$otlpSpecRepoUrl/|g if $ARGV =~ /\btmp\/otlp/; + s|\.\./examples/README.md\b|$otlpSpecRepoUrl/tree/v$otlpSpecVers/examples/|g if $ARGV =~ /\btmp\/otlp/; s|\bREADME.md\b|_index.md|g if $ARGV !~ /otel\/specification\/protocol\/_index.md/; @@ -144,7 +144,7 @@ () s|(\.\.\/)+(supplementary-guidelines\/compatibility\/[^)]+)|$otelSpecRepoUrl/tree/v$otelSpecVers/$2|g; # Rewrite inline links - if ($ARGV =~ /\/tmp\/opamp/) { + if ($ARGV =~ /\btmp\/opamp/) { s|\]\(([^:\)]*?)\.md((#.*?)?)\)|]($1/$2)|g; } else { s|\]\(([^:\)]*?\.md(#.*?)?)\)|]({{% relref "$1" %}})|g; diff --git a/scripts/content-modules/cp-pages.sh b/scripts/content-modules/cp-pages.sh index a561afcf54a3..074d7652287b 100755 --- a/scripts/content-modules/cp-pages.sh +++ b/scripts/content-modules/cp-pages.sh @@ -1,7 +1,7 @@ #!/usr/bin/env bash -SCRIPT_DIR="$(cd `dirname $0`; pwd)" -DEST_BASE="$(cd $SCRIPT_DIR; cd ../../; pwd)/tmp" +SCRIPT_DIR=$(dirname $0) +DEST_BASE=tmp ## OTel specification diff --git a/scripts/htmltest-config.pl b/scripts/htmltest-config.pl new file mode 100755 index 000000000000..8e187b084079 --- /dev/null +++ b/scripts/htmltest-config.pl @@ -0,0 +1,135 @@ +#!/usr/bin/perl + +use strict; +use warnings; + +my $gD = 0; + +sub main { + my @ignore_dirs; + + collect_htmltest_config_from_front_matter(\@ignore_dirs, @ARGV); + update_htmltest_config_file(\@ignore_dirs); +} + +sub collect_htmltest_config_from_front_matter { + my ($ignore_dirs_ref, @files) = @_; + + foreach my $file_path (sort @files) { + my @htmltest_config = extract_htmltest_config($file_path); + next unless @htmltest_config; + push @$ignore_dirs_ref, @htmltest_config; + } +} + +sub extract_htmltest_config { + # Returns list of htmlconfig lines extracted from the front matter of $file_path + my ($file_path) = @_; + + open my $fh, '<', $file_path or die "Could not open '$file_path': $!"; + my $content = do { local $/; <$fh> }; + close $fh; + + return unless $content =~ /---\n(.*?)\n---/s; + + my $front_matter = $1; + my @htmltest_config = _extract_htmltest_config($front_matter); + + return unless @htmltest_config; + + if (@htmltest_config == 1) { + warn "Warning: Failed to extract htmltest config from front matter in file '$file_path'.\n"; + return; + } + + shift @htmltest_config; + + if (@htmltest_config >= 1 && $htmltest_config[0] =~ /^IgnoreDirs:/i) { + return _extract_ignore_dirs($file_path, @htmltest_config) + } + + # TODO: Add support for `IgnoreURLs`. + + warn "Warning: Unrecognized htmltest config from front matter in file '$file_path'.\n"; +} + +sub _extract_ignore_dirs { + my ($file_path, + @ignore_dirs_config_lines # Can include comment lines + ) = @_; + my @config; + + foreach my $line (@ignore_dirs_config_lines) { + next if $line =~ /^IgnoreDirs:\s*$/i; + if ($line =~ /\s*#/) { + push @config, $line; + } elsif ($line =~ /^IgnoreDirs:\s*\[\s*(.*?)\s*\]/i || $line =~ /^\s*-\s*(.*?)$/) { + push @config, (split /\s*,\s*/, $1); + } else { + warn "Warning: Unrecognized htmltest IgnoreDirs config from front matter in file '$file_path': $line\n"; + } + } + return @config; +} + +sub _extract_htmltest_config { + # Returns a list of htmltext config lines with whitespace trimmed away. + + my ($front_matter) = @_; + my @lines = split /\n/, $front_matter; + my @htmltest_lines; + my $in_htmltest_section = 0; + + foreach my $line (@lines) { + if ($line =~ /^htmltest:(.*?)(#.*)?$/) { + $in_htmltest_section = 1; + push @htmltest_lines, $line; + } elsif ($in_htmltest_section) { + if ($line =~ /^(\s{2,})(.*)$/) { + push @htmltest_lines, $2; + printf " > Config line: $line" if $gD; + } else { + last; + } + } + } + return @htmltest_lines; +} + +sub update_htmltest_config_file { + my ($ignore_dirs_ref) = @_; + my $htmltest_config_path = '.htmltest.yml'; + my $do_not_edit_msg = " # DO NOT EDIT! IgnoreDirs list is auto-generated from markdown file front matter.\n"; + + # Read config file as array of lines + open my $fh, '<', $htmltest_config_path or die "Could not open '$htmltest_config_path' for reading: $!"; + my @lines = <$fh>; + close $fh; + + # Replace the existing IgnoreDirs entries with the new ones + my $in_ignore_dirs = 0; + my @new_lines; + foreach my $line (@lines) { + if ($line =~ /^IgnoreDirs:/) { + push @new_lines, ($line, $do_not_edit_msg); + foreach my $ignore_dir (@$ignore_dirs_ref) { + my $prefix = $ignore_dir =~ /^#/ ? ' ' : ' - '; + push @new_lines, "$prefix$ignore_dir\n"; + } + push @new_lines, $do_not_edit_msg; + $in_ignore_dirs = 1; + } elsif ($in_ignore_dirs) { + next if $line =~ /^\s*([#-]|$)/; + $in_ignore_dirs = 0; + push @new_lines, $line; + } else { + push @new_lines, $line; + } + } + + open my $fh_out, '>', $htmltest_config_path or die "Could not open '$htmltest_config_path' for writing: $!"; + print $fh_out @new_lines; + close $fh_out; +} + +main(); diff --git a/scripts/htmltest-config.sh b/scripts/htmltest-config.sh new file mode 100755 index 000000000000..02696c7c919c --- /dev/null +++ b/scripts/htmltest-config.sh @@ -0,0 +1,8 @@ +#!/usr/bin/env bash +# +# We handle listing all markdown files here because it is more portable across +# supported operating systems. + +SCRIPT_DIR=$(dirname $0) +FILES=$(find content -name "*.md") +exec $SCRIPT_DIR/htmltest-config.pl $FILES diff --git a/static/img/libraries-instrumentation.svg b/static/img/libraries-instrumentation.svg new file mode 100755 index 000000000000..d606fe0b27f6 --- /dev/null +++ b/static/img/libraries-instrumentation.svg @@ -0,0 +1,186 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/static/img/otel-diagram.svg b/static/img/otel-diagram.svg index 0bca7d5433b4..f7f198f4e4b3 100644 --- a/static/img/otel-diagram.svg +++ b/static/img/otel-diagram.svg @@ -1,6 +1,6 @@ - + diff --git a/static/img/waterfall-trace.svg b/static/img/waterfall-trace.svg index 794f85b9926f..e662435657d6 100644 --- a/static/img/waterfall-trace.svg +++ b/static/img/waterfall-trace.svg @@ -1,6 +1,6 @@ - + diff --git a/static/refcache.json b/static/refcache.json index adad2b4c45fd..7e8866a3e710 100644 --- a/static/refcache.json +++ b/static/refcache.json @@ -1831,6 +1831,10 @@ "StatusCode": 200, "LastSeen": "2024-08-09T10:45:49.257983-04:00" }, + "https://cloud-native.slack.com/archives/C03J794L0BV": { + "StatusCode": 200, + "LastSeen": "2024-10-24T15:10:31.184402+02:00" + }, "https://cloud-native.slack.com/archives/C041APFBYQP": { "StatusCode": 200, "LastSeen": "2024-01-30T05:18:18.947225-05:00" @@ -2631,6 +2635,10 @@ "StatusCode": 206, "LastSeen": "2024-06-12T11:21:20.570863+02:00" }, + "https://docs.github.com/es/pull-requests/collaborating-with-pull-requests/working-with-forks/allowing-changes-to-a-pull-request-branch-created-from-a-fork": { + "StatusCode": 206, + "LastSeen": "2024-10-30T15:12:28.788328409Z" + }, "https://docs.google.com/document/d/1-23Sf7-xZK3OL5Ogv2pK0NP9YotlSa0PKU9bvvtQwp8": { "StatusCode": 200, "LastSeen": "2024-08-15T15:44:20.868165+02:00" @@ -2743,6 +2751,10 @@ "StatusCode": 200, "LastSeen": "2024-01-30T15:24:43.194115-05:00" }, + "https://docs.greptime.com/user-guide/ingest-data/for-observerbility/opentelemetry": { + "StatusCode": 200, + "LastSeen": "2024-10-29T16:21:59.273877+08:00" + }, "https://docs.groundcover.com/integrations/data-sources/opentelemetry/traces-and-logs": { "StatusCode": 200, "LastSeen": "2024-08-18T14:44:07.000049769Z" @@ -3047,6 +3059,10 @@ "StatusCode": 200, "LastSeen": "2024-08-09T10:45:54.649845-04:00" }, + "https://docs.oracle.com/javase/7/docs/technotes/guides/management/agent.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:17.488566-05:00" + }, "https://docs.oracle.com/javase/8/docs/api/java/lang/Runtime.html#availableProcessors--": { "StatusCode": 200, "LastSeen": "2024-01-30T16:04:00.071297-05:00" @@ -3219,6 +3235,10 @@ "StatusCode": 200, "LastSeen": "2024-08-09T10:47:09.376386-04:00" }, + "https://docs.splunk.com/Documentation/Splunk/latest/Updating/Aboutdeploymentserver": { + "StatusCode": 200, + "LastSeen": "2024-11-02T23:00:07.34114093Z" + }, "https://docs.splunk.com/Observability/gdi/opentelemetry/opentelemetry.html": { "StatusCode": 206, "LastSeen": "2024-01-30T06:06:25.583516-05:00" @@ -3295,6 +3315,10 @@ "StatusCode": 206, "LastSeen": "2024-01-30T16:14:30.370824-05:00" }, + "https://docs.vmware.com/en/vRealize-Log-Insight/8.10/com.vmware.log-insight.agent.admin.doc/GUID-40C13E10-1554-4F1B-B832-69CEBF85E7A0.html": { + "StatusCode": 206, + "LastSeen": "2024-11-02T23:00:10.422732673Z" + }, "https://docs.vmware.com/en/vRealize-Log-Insight/8.4/com.vmware.log-insight.agent.admin.doc/GUID-40C13E10-1554-4F1B-B832-69CEBF85E7A0.html": { "StatusCode": 206, "LastSeen": "2024-08-09T10:47:15.455246-04:00" @@ -3331,6 +3355,10 @@ "StatusCode": 200, "LastSeen": "2024-01-30T15:24:54.677789-05:00" }, + "https://druid.apache.org/": { + "StatusCode": 206, + "LastSeen": "2024-10-18T16:50:18.107656338+03:00" + }, "https://dyladan.me/histograms/2023/05/02/why-histograms/": { "StatusCode": 206, "LastSeen": "2024-01-30T06:01:18.587594-05:00" @@ -3355,6 +3383,14 @@ "StatusCode": 200, "LastSeen": "2024-01-30T16:14:47.246698-05:00" }, + "https://embrace.io/docs/open-telemetry/integration/": { + "StatusCode": 206, + "LastSeen": "2024-11-02T22:02:32.429124483Z" + }, + "https://embrace.io/docs/open-telemetry/integration/#apple": { + "StatusCode": 206, + "LastSeen": "2024-11-02T22:02:37.069605183Z" + }, "https://embrace.io/opentelemetry-for-mobile/": { "StatusCode": 206, "LastSeen": "2024-04-25T10:29:55.539338+02:00" @@ -3435,6 +3471,10 @@ "StatusCode": 200, "LastSeen": "2024-01-18T19:02:13.980094-05:00" }, + "https://en.wikipedia.org/wiki/ISO_639-1": { + "StatusCode": 200, + "LastSeen": "2024-10-11T11:10:12.725968+02:00" + }, "https://en.wikipedia.org/wiki/In-band_signaling": { "StatusCode": 200, "LastSeen": "2024-01-18T19:01:54.201621-05:00" @@ -3711,6 +3751,10 @@ "StatusCode": 200, "LastSeen": "2024-05-01T16:48:59.737619-04:00" }, + "https://forms.gle/ioqFNmDhKNYYAtRs7": { + "StatusCode": 200, + "LastSeen": "2024-10-25T10:27:00.363272+01:00" + }, "https://forms.gle/mEDWyn6G7iCe4bvJ7": { "StatusCode": 200, "LastSeen": "2024-01-18T19:02:03.877372-05:00" @@ -4831,6 +4875,14 @@ "StatusCode": 200, "LastSeen": "2024-08-09T11:17:19.10152+02:00" }, + "https://github.com/embrace-io/embrace-android-sdk": { + "StatusCode": 200, + "LastSeen": "2024-11-02T22:02:28.968321617Z" + }, + "https://github.com/embrace-io/embrace-apple-sdk": { + "StatusCode": 200, + "LastSeen": "2024-11-02T22:02:35.245741377Z" + }, "https://github.com/emdneto": { "StatusCode": 200, "LastSeen": "2024-08-09T11:16:41.547073+02:00" @@ -4987,6 +5039,10 @@ "StatusCode": 200, "LastSeen": "2024-06-12T11:21:46.656082+02:00" }, + "https://github.com/google/pprof": { + "StatusCode": 200, + "LastSeen": "2024-10-24T15:10:16.695786+02:00" + }, "https://github.com/gosnmp/gosnmp": { "StatusCode": 200, "LastSeen": "2024-01-18T19:55:40.84138-05:00" @@ -5219,6 +5275,14 @@ "StatusCode": 200, "LastSeen": "2024-08-06T15:18:28.014809+02:00" }, + "https://github.com/jdbi": { + "StatusCode": 200, + "LastSeen": "2024-11-02T06:14:06.865612-04:00" + }, + "https://github.com/jdbi/jdbi": { + "StatusCode": 200, + "LastSeen": "2024-11-02T06:14:05.661704-04:00" + }, "https://github.com/jeanbisutti": { "StatusCode": 200, "LastSeen": "2024-01-30T16:14:42.388742-05:00" @@ -5391,6 +5455,14 @@ "StatusCode": 200, "LastSeen": "2024-08-09T11:17:29.568811+02:00" }, + "https://github.com/keycloak": { + "StatusCode": 200, + "LastSeen": "2024-10-30T21:34:00.859928291Z" + }, + "https://github.com/keycloak/keycloak": { + "StatusCode": 200, + "LastSeen": "2024-10-30T21:33:58.058084045Z" + }, "https://github.com/kieronlanning": { "StatusCode": 200, "LastSeen": "2024-04-26T09:57:50.019728503+01:00" @@ -5647,6 +5719,10 @@ "StatusCode": 200, "LastSeen": "2024-04-19T17:43:49.897716918Z" }, + "https://github.com/mishmash-io/opentelemetry-server-embedded": { + "StatusCode": 200, + "LastSeen": "2024-10-18T16:50:17.016614951+03:00" + }, "https://github.com/mjwolf": { "StatusCode": 200, "LastSeen": "2024-08-06T15:18:44.682117+02:00" @@ -5655,6 +5731,14 @@ "StatusCode": 200, "LastSeen": "2024-01-30T16:04:58.425652-05:00" }, + "https://github.com/mlflow": { + "StatusCode": 200, + "LastSeen": "2024-10-24T09:04:39.209525077Z" + }, + "https://github.com/mlflow/mlflow/": { + "StatusCode": 200, + "LastSeen": "2024-10-24T09:04:36.357311431Z" + }, "https://github.com/mlocati/docker-php-extension-installer": { "StatusCode": 200, "LastSeen": "2024-01-18T19:55:35.599232-05:00" @@ -5899,6 +5983,10 @@ "StatusCode": 200, "LastSeen": "2024-08-23T20:33:47.852068252Z" }, + "https://github.com/open-telemetry/community/issues/2329": { + "StatusCode": 200, + "LastSeen": "2024-10-15T15:52:36.027937+01:00" + }, "https://github.com/open-telemetry/community/issues/828": { "StatusCode": 200, "LastSeen": "2024-01-18T19:37:16.771654-05:00" @@ -5963,6 +6051,10 @@ "StatusCode": 200, "LastSeen": "2024-01-30T16:14:54.058976-05:00" }, + "https://github.com/open-telemetry/opentelemetry-collector-contrib/issues": { + "StatusCode": 200, + "LastSeen": "2024-10-24T15:10:27.834953+02:00" + }, "https://github.com/open-telemetry/opentelemetry-collector-contrib/issues/16462": { "StatusCode": 200, "LastSeen": "2024-01-30T05:18:40.093521-05:00" @@ -6215,6 +6307,10 @@ "StatusCode": 200, "LastSeen": "2024-07-02T09:23:49.72181125Z" }, + "https://github.com/open-telemetry/opentelemetry-collector/releases/tag/v0.112.0": { + "StatusCode": 200, + "LastSeen": "2024-10-24T15:10:25.832305+02:00" + }, "https://github.com/open-telemetry/opentelemetry-collector/releases/tag/v0.63.0": { "StatusCode": 200, "LastSeen": "2024-01-30T16:04:58.261649-05:00" @@ -6475,6 +6571,10 @@ "StatusCode": 200, "LastSeen": "2024-01-30T16:15:25.802104-05:00" }, + "https://github.com/open-telemetry/opentelemetry-ebpf-profiler": { + "StatusCode": 200, + "LastSeen": "2024-10-24T15:10:22.597683+02:00" + }, "https://github.com/open-telemetry/opentelemetry-erlang": { "StatusCode": 200, "LastSeen": "2024-01-18T19:10:24.771487-05:00" @@ -6603,6 +6703,10 @@ "StatusCode": 200, "LastSeen": "2024-01-18T19:37:32.008516-05:00" }, + "https://github.com/open-telemetry/opentelemetry-java-examples": { + "StatusCode": 200, + "LastSeen": "2024-10-23T20:19:13.793874-05:00" + }, "https://github.com/open-telemetry/opentelemetry-java-instrumentation": { "StatusCode": 200, "LastSeen": "2024-01-18T19:10:45.254006-05:00" @@ -6943,10 +7047,18 @@ "StatusCode": 200, "LastSeen": "2024-01-18T19:37:06.679199-05:00" }, + "https://github.com/open-telemetry/opentelemetry-proto/issues/567#issuecomment-2286565449": { + "StatusCode": 200, + "LastSeen": "2024-10-24T15:10:18.85325+02:00" + }, "https://github.com/open-telemetry/opentelemetry-proto/issues/new": { "StatusCode": 200, "LastSeen": "2024-08-09T10:45:27.522647-04:00" }, + "https://github.com/open-telemetry/opentelemetry-proto/releases/tag/v1.3.0": { + "StatusCode": 200, + "LastSeen": "2024-10-24T15:10:14.278497+02:00" + }, "https://github.com/open-telemetry/opentelemetry-python": { "StatusCode": 200, "LastSeen": "2024-01-18T19:37:16.269952-05:00" @@ -7095,6 +7207,10 @@ "StatusCode": 200, "LastSeen": "2024-01-18T20:05:26.46768-05:00" }, + "https://github.com/open-telemetry/opentelemetry-specification/pull/4197": { + "StatusCode": 200, + "LastSeen": "2024-10-24T15:10:29.718998+02:00" + }, "https://github.com/open-telemetry/opentelemetry-specification/releases/tag/v1.17.0": { "StatusCode": 200, "LastSeen": "2024-01-30T05:18:18.661983-05:00" @@ -7175,6 +7291,10 @@ "StatusCode": 200, "LastSeen": "2024-06-13T15:48:00.42543+02:00" }, + "https://github.com/open-telemetry/opentelemetry.io/issues/": { + "StatusCode": 200, + "LastSeen": "2024-10-11T11:10:11.918895+02:00" + }, "https://github.com/open-telemetry/opentelemetry.io/issues/4427": { "StatusCode": 200, "LastSeen": "2024-05-06T15:32:24.49099-04:00" @@ -7199,6 +7319,10 @@ "StatusCode": 200, "LastSeen": "2024-01-30T15:26:01.154768-05:00" }, + "https://github.com/open-telemetry/opentelemetry.io/pull/5386/files": { + "StatusCode": 200, + "LastSeen": "2024-11-02T12:26:48.450866-04:00" + }, "https://github.com/open-telemetry/opentelemetry.io/pulls": { "StatusCode": 200, "LastSeen": "2024-01-30T16:15:25.833527-05:00" @@ -7507,6 +7631,10 @@ "StatusCode": 200, "LastSeen": "2024-01-30T06:06:25.505322-05:00" }, + "https://github.com/prometheus/client_java": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:19.363961-05:00" + }, "https://github.com/prometheus/prometheus/commit/d9d51c565c622cdc7d626d3e7569652bc28abe15#diff-bdaf80ebc5fa26365f45db53435b960ce623ea6f86747fb8870ad1abc355f64fR76-R83": { "StatusCode": 200, "LastSeen": "2024-01-18T19:37:11.409183-05:00" @@ -7767,6 +7895,10 @@ "StatusCode": 200, "LastSeen": "2024-02-15T11:30:50.628118+01:00" }, + "https://github.com/streetsidesoftware/cspell-dicts": { + "StatusCode": 200, + "LastSeen": "2024-11-02T12:26:45.305184-04:00" + }, "https://github.com/strimzi": { "StatusCode": 200, "LastSeen": "2024-01-18T20:05:40.859417-05:00" @@ -8535,6 +8667,14 @@ "StatusCode": 200, "LastSeen": "2024-01-30T15:25:04.309715-05:00" }, + "https://jdbi.org/": { + "StatusCode": 206, + "LastSeen": "2024-11-02T06:13:48.275274-04:00" + }, + "https://jdbi.org/#_opentelemetry_tracing": { + "StatusCode": 206, + "LastSeen": "2024-11-02T06:13:48.208691-04:00" + }, "https://jessitron.com/": { "StatusCode": 200, "LastSeen": "2024-01-18T19:02:03.729447-05:00" @@ -8647,6 +8787,10 @@ "StatusCode": 206, "LastSeen": "2024-08-09T10:44:30.895853-04:00" }, + "https://kubernetes.io/docs/concepts/configuration/secret/": { + "StatusCode": 206, + "LastSeen": "2024-10-17T20:41:39.419625448-07:00" + }, "https://kubernetes.io/docs/concepts/configuration/secret/#using-a-secret": { "StatusCode": 206, "LastSeen": "2024-04-25T00:01:05.630302-04:00" @@ -8675,6 +8819,14 @@ "StatusCode": 206, "LastSeen": "2024-08-09T10:45:22.265624-04:00" }, + "https://kubernetes.io/docs/concepts/security/rbac-good-practices/": { + "StatusCode": 206, + "LastSeen": "2024-10-28T23:48:13.923440181Z" + }, + "https://kubernetes.io/docs/concepts/security/secrets-good-practices/": { + "StatusCode": 206, + "LastSeen": "2024-10-17T20:41:39.602462106-07:00" + }, "https://kubernetes.io/docs/concepts/services-networking/service/": { "StatusCode": 206, "LastSeen": "2024-01-30T06:06:10.439014-05:00" @@ -9007,6 +9159,14 @@ "StatusCode": 200, "LastSeen": "2024-08-09T10:43:55.405438-04:00" }, + "https://logback.qos.ch/": { + "StatusCode": 206, + "LastSeen": "2024-09-30T10:42:23.585047-05:00" + }, + "https://logging.apache.org/log4j/2.x/index.html": { + "StatusCode": 206, + "LastSeen": "2024-09-30T10:42:20.642504-05:00" + }, "https://lookerstudio.google.com/s/tSTKxK1ECeU": { "StatusCode": 200, "LastSeen": "2024-03-06T14:56:05.033361-05:00" @@ -9187,6 +9347,18 @@ "StatusCode": 206, "LastSeen": "2024-01-18T19:02:08.769984-05:00" }, + "https://mishmash.io": { + "StatusCode": 200, + "LastSeen": "2024-10-18T16:50:17.995881058+03:00" + }, + "https://mlflow.org/": { + "StatusCode": 206, + "LastSeen": "2024-10-24T09:04:26.938953245Z" + }, + "https://mlflow.org/docs/latest/llms/tracing/index.html": { + "StatusCode": 206, + "LastSeen": "2024-10-24T09:04:29.562895157Z" + }, "https://mobyproject.org/": { "StatusCode": 206, "LastSeen": "2024-08-07T15:43:31.13946+02:00" @@ -9195,6 +9367,10 @@ "StatusCode": 200, "LastSeen": "2024-01-18T19:02:19.249572-05:00" }, + "https://nais.io/blog/posts/otel-from-0-to-100/": { + "StatusCode": 206, + "LastSeen": "2024-10-16T06:19:11.246616643Z" + }, "https://netlify.com": { "StatusCode": 206, "LastSeen": "2024-06-12T11:21:36.089536+02:00" @@ -9899,6 +10075,10 @@ "StatusCode": 206, "LastSeen": "2024-02-23T22:55:04.014798-05:00" }, + "https://opentelemetry.io/docs/concepts/glossary/#instrumentation-library": { + "StatusCode": 206, + "LastSeen": "2024-10-18T16:49:48.155152358+03:00" + }, "https://opentelemetry.io/docs/concepts/instrumentation/libraries/": { "StatusCode": 206, "LastSeen": "2024-04-30T09:31:37.735092936Z" @@ -9943,6 +10123,10 @@ "StatusCode": 206, "LastSeen": "2024-09-04T09:48:32.91926+02:00" }, + "https://opentelemetry.io/docs/specs/otel/document-status": { + "StatusCode": 206, + "LastSeen": "2024-10-18T16:49:48.125677461+03:00" + }, "https://opentelemetry.io/docs/specs/otel/glossary/#instrumentation-library": { "StatusCode": 206, "LastSeen": "2024-04-30T09:31:37.929550219Z" @@ -10047,6 +10231,10 @@ "StatusCode": 206, "LastSeen": "2024-01-18T19:07:33.813401-05:00" }, + "https://opentracing.io/": { + "StatusCode": 206, + "LastSeen": "2024-09-30T10:42:13.94789-05:00" + }, "https://operatorhub.io/operator/opentelemetry-operator": { "StatusCode": 206, "LastSeen": "2024-01-18T19:10:45.627677-05:00" @@ -11479,6 +11667,38 @@ "StatusCode": 200, "LastSeen": "2024-01-30T05:18:35.161372-05:00" }, + "https://repo1.maven.org/maven2/io/opentelemetry/instrumentation/opentelemetry-instrumentation-bom-alpha/2.7.0-alpha/opentelemetry-instrumentation-bom-alpha-2.7.0-alpha.pom": { + "StatusCode": 206, + "LastSeen": "2024-10-23T20:20:08.34491-05:00" + }, + "https://repo1.maven.org/maven2/io/opentelemetry/instrumentation/opentelemetry-instrumentation-bom-alpha/2.9.0-alpha/opentelemetry-instrumentation-bom-alpha-2.9.0-alpha.pom": { + "StatusCode": 206, + "LastSeen": "2024-10-23T20:19:21.596018-05:00" + }, + "https://repo1.maven.org/maven2/io/opentelemetry/instrumentation/opentelemetry-instrumentation-bom/2.7.0/opentelemetry-instrumentation-bom-2.7.0.pom": { + "StatusCode": 206, + "LastSeen": "2024-10-23T20:20:07.402964-05:00" + }, + "https://repo1.maven.org/maven2/io/opentelemetry/instrumentation/opentelemetry-instrumentation-bom/2.9.0/opentelemetry-instrumentation-bom-2.9.0.pom": { + "StatusCode": 206, + "LastSeen": "2024-10-23T20:19:19.595194-05:00" + }, + "https://repo1.maven.org/maven2/io/opentelemetry/opentelemetry-bom-alpha/1.42.1-alpha/opentelemetry-bom-alpha-1.42.1-alpha.pom": { + "StatusCode": 206, + "LastSeen": "2024-10-23T20:20:05.963898-05:00" + }, + "https://repo1.maven.org/maven2/io/opentelemetry/opentelemetry-bom-alpha/1.43.0-alpha/opentelemetry-bom-alpha-1.43.0-alpha.pom": { + "StatusCode": 206, + "LastSeen": "2024-10-23T20:19:18.147885-05:00" + }, + "https://repo1.maven.org/maven2/io/opentelemetry/opentelemetry-bom/1.42.1/opentelemetry-bom-1.42.1.pom": { + "StatusCode": 206, + "LastSeen": "2024-10-23T20:20:05.242921-05:00" + }, + "https://repo1.maven.org/maven2/io/opentelemetry/opentelemetry-bom/1.43.0/opentelemetry-bom-1.43.0.pom": { + "StatusCode": 206, + "LastSeen": "2024-10-23T20:19:16.148466-05:00" + }, "https://research.facebook.com/file/877841159827226/holistic-configuration-management-at-facebook.pdf": { "StatusCode": 206, "LastSeen": "2024-01-30T16:14:42.741857-05:00" @@ -12363,6 +12583,10 @@ "StatusCode": 200, "LastSeen": "2024-01-18T19:37:17.279668-05:00" }, + "https://web.archive.org/web/20240223142649/https://kofo.dev/how-to-mtls-in-golang": { + "StatusCode": 200, + "LastSeen": "2024-11-02T23:00:15.805376094Z" + }, "https://wicg.github.io/ua-client-hints/#interface": { "StatusCode": 206, "LastSeen": "2024-01-18T19:36:42.997199-05:00" @@ -12579,6 +12803,10 @@ "StatusCode": 200, "LastSeen": "2024-01-18T19:06:23.804112-05:00" }, + "https://www.dash0.com/": { + "StatusCode": 200, + "LastSeen": "2024-10-28T11:30:33.016936+01:00" + }, "https://www.datadoghq.com/blog/engineering/php-8-observability-baked-right-in/": { "StatusCode": 206, "LastSeen": "2024-01-30T05:18:29.107161-05:00" @@ -12799,6 +13027,10 @@ "StatusCode": 206, "LastSeen": "2024-01-18T19:07:50.513752-05:00" }, + "https://www.ietf.org/archive/id/draft-ietf-uuidrev-rfc4122bis-14.html#name-uuid-version-7": { + "StatusCode": 200, + "LastSeen": "2024-11-02T23:00:01.024560709Z" + }, "https://www.ietf.org/rfc/rfc4122.txt": { "StatusCode": 206, "LastSeen": "2024-04-04T20:00:31.717502-04:00" @@ -12907,22 +13139,134 @@ "StatusCode": 200, "LastSeen": "2024-01-18T19:55:46.525923-05:00" }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/GlobalOpenTelemetry.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:23.12239-05:00" + }, "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/OpenTelemetry.html": { "StatusCode": 200, "LastSeen": "2024-08-05T15:19:48.24217-05:00" }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/baggage/Baggage.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:43:07.738549-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/baggage/propagation/W3CBaggagePropagator.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:43:07.651421-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/common/Attributes.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:20.917364-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/logs/LogRecordBuilder.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:43:04.945711-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/logs/Logger.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:43:01.318503-05:00" + }, "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/logs/LoggerProvider.html": { "StatusCode": 200, "LastSeen": "2024-08-05T15:59:36.584528-05:00" }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/DoubleCounter.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T11:26:12.546964-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/DoubleGauge.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:56.762156-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/DoubleHistogram.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:51.433911-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/DoubleUpDownCounter.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:39.724087-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/LongCounter.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T11:26:11.401131-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/LongGauge.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:57.12662-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/LongHistogram.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:52.311487-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/LongUpDownCounter.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:37.428847-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/Meter.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:27.180222-05:00" + }, "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/MeterProvider.html": { "StatusCode": 200, "LastSeen": "2024-08-05T15:59:35.353354-05:00" }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/ObservableDoubleCounter.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:35.879775-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/ObservableDoubleGauge.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:57.769016-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/ObservableDoubleUpDownCounter.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:49.469015-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/ObservableLongCounter.htmll": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:34.290165-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/ObservableLongGauge.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:43:02.724791-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/metrics/ObservableLongUpDownCounter.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:45.458127-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/trace/Span.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:25.46897-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/trace/SpanBuilder.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:25.000171-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/trace/Tracer.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:23.509988-05:00" + }, "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/trace/TracerProvider.html": { "StatusCode": 200, "LastSeen": "2024-08-05T15:19:51.603241-05:00" }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-api/latest/io/opentelemetry/api/trace/propagation/W3CTraceContextPropagator.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:26.645518-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-context/latest/io/opentelemetry/context/Context.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:14.126006-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-context/latest/io/opentelemetry/context/ContextStorage.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T11:26:04.981525-05:00" + }, + "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-context/latest/io/opentelemetry/context/propagation/ContextPropagators.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:19.966187-05:00" + }, "https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-context/latest/io/opentelemetry/context/propagation/TextMapPropagator.html": { "StatusCode": 200, "LastSeen": "2024-08-05T15:20:15.97313-05:00" @@ -13015,6 +13359,10 @@ "StatusCode": 200, "LastSeen": "2024-08-05T15:19:47.672179-05:00" }, + "https://www.javadoc.io/static/io.opentelemetry/opentelemetry-context/1.41.0/io/opentelemetry/context/ContextStorage.html": { + "StatusCode": 200, + "LastSeen": "2024-09-30T10:42:16.987832-05:00" + }, "https://www.jenkins.io": { "StatusCode": 206, "LastSeen": "2024-01-30T05:18:35.317496-05:00" @@ -13031,10 +13379,18 @@ "StatusCode": 206, "LastSeen": "2024-01-18T19:36:55.905893-05:00" }, + "https://www.keycloak.org": { + "StatusCode": 206, + "LastSeen": "2024-10-30T21:33:55.346508746Z" + }, "https://www.keycloak.org/": { "StatusCode": 206, "LastSeen": "2024-01-18T19:55:51.649479-05:00" }, + "https://www.keycloak.org/server/tracing": { + "StatusCode": 206, + "LastSeen": "2024-10-30T21:33:56.91911467Z" + }, "https://www.konghq.com/": { "StatusCode": 200, "LastSeen": "2024-01-30T15:37:02.403477-05:00" @@ -13171,6 +13527,10 @@ "StatusCode": 200, "LastSeen": "2024-01-18T19:55:41.775458-05:00" }, + "https://www.npmjs.com/search": { + "StatusCode": 200, + "LastSeen": "2024-11-02T12:26:46.909401-04:00" + }, "https://www.nuget.org/packages/": { "StatusCode": 200, "LastSeen": "2024-01-30T15:25:18.124486-05:00" diff --git a/themes/docsy b/themes/docsy index 795119495470..68aa7b39fc81 160000 --- a/themes/docsy +++ b/themes/docsy @@ -1 +1 @@ -Subproject commit 7951194954708d7cc992e3540c8fc823cc99a953 +Subproject commit 68aa7b39fc81e2239f3984cacf4c7dc09e7d6b0f