Skip to content

Commit a409f82

Browse files
clementduveauopentelemetrybottiffany76theletterf
authored
[fr] Translation of Zero Code Java docs (#7389)
Co-authored-by: opentelemetrybot <107717825+opentelemetrybot@users.noreply.github.com> Co-authored-by: Tiffany Hrabusa <30397949+tiffany76@users.noreply.github.com> Co-authored-by: Fabrizio Ferri-Benedetti <algernon@fastmail.com>
1 parent 7845305 commit a409f82

22 files changed

+2646
-1
lines changed

‎.cspell/fr-mots.txt‎

Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,16 @@
1+
actuateur
2+
autocompléter
13
extensibilité
4+
glassfish
5+
jvms
26
observabilité
7+
otelinstrumentationmethodsinclude
8+
payara
9+
spanattribute
310
réexécuté
411
télémétrie
5-
traçage
12+
tomee
13+
traçage
14+
weblogic
15+
websphere
16+
wildfly

‎content/fr/docs/zero-code/java/_index.md‎

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
---
2+
title: Instrumentation Zero-code Java
3+
linkTitle: Java
4+
aliases:
5+
- /docs/java/automatic_instrumentation
6+
- /docs/languages/java/automatic_instrumentation
7+
cascade:
8+
vers:
9+
instrumentation: 2.17.0
10+
otel: 1.51.0
11+
default_lang_commit: 3d179dbe1270b83aafff0d3b6aa3311afd482649
12+
---
13+
14+
Les options les plus fréquentes pour l'instrumentation Zero-code avec Java sont
15+
l'agent Java avec un JAR, le Spring Boot Starter, et l'extension Quarkus
16+
OpenTelemetry. Pour apprendre comment instrumenter manuellement votre
17+
application, consultez
18+
[Instrumentation manuelle](/docs/languages/java/instrumentation/).

‎content/fr/docs/zero-code/java/agent/_index.md‎

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
---
2+
title: Agent Java
3+
linkTitle: Agent
4+
aliases:
5+
- /docs/java/automatic_instrumentation
6+
- /docs/languages/java/automatic_instrumentation
7+
redirects: [{ from: /docs/languages/java/automatic/*, to: ':splat' }]
8+
default_lang_commit: 3d179dbe1270b83aafff0d3b6aa3311afd482649
9+
---
10+
11+
L'instrumentation Zero-code avec Java utilise un agent Java sous forme de JAR
12+
attaché à toute application Java 8+. Il injecte dynamiquement du bytecode pour
13+
capturer la télémétrie de nombreuses bibliothèques et frameworks populaires. Il
14+
peut être utilisé pour capturer les données de télémétrie aux "bords" d'une
15+
application ou d'un service, comme les requêtes entrantes, les appels HTTP
16+
sortants, les appels de base de données, et ainsi de suite. Pour apprendre
17+
comment instrumenter manuellement votre application, consultez
18+
[Instrumentation manuelle](/docs/languages/java/instrumentation/).

‎content/fr/docs/zero-code/java/agent/annotations.md‎

Lines changed: 167 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,167 @@
1+
---
2+
title: Annotations
3+
description: Utilisation des annotations d'instrumentation avec un agent Java.
4+
aliases: [/docs/instrumentation/java/annotations]
5+
weight: 20
6+
default_lang_commit: 3d179dbe1270b83aafff0d3b6aa3311afd482649
7+
cSpell:ignore: Flowable javac reactivestreams reactivex
8+
---
9+
10+
Pour la plupart des utilisateurs, l'instrumentation fournie par défaut est
11+
complètement suffisante et rien de plus n'a besoin d'être fait. Parfois,
12+
cependant, les utilisateurs souhaitent créer des
13+
[spans](/docs/concepts/signals/traces/#spans) pour leur propre code sans avoir à
14+
changer beaucoup de code. Les annotations `WithSpan` et `SpanAttribute`
15+
supportent ces cas d'usage.
16+
17+
## Dépendances {#dependencies}
18+
19+
Vous devrez ajouter une dépendance à `opentelemetry-instrumentation-annotations`
20+
pour utiliser l'annotation `@WithSpan`.
21+
22+
{{< tabpane text=true >}} {{% tab "Maven" %}}
23+
24+
```xml
25+
<dependencies>
26+
<dependency>
27+
<groupId>io.opentelemetry.instrumentation</groupId>
28+
<artifactId>opentelemetry-instrumentation-annotations</artifactId>
29+
<version>{{% param vers.instrumentation %}}</version>
30+
</dependency>
31+
</dependencies>
32+
```
33+
34+
{{% /tab %}} {{% tab "Gradle" %}}
35+
36+
### Gradle {#gradle}
37+
38+
```groovy
39+
dependencies {
40+
implementation('io.opentelemetry.instrumentation:opentelemetry-instrumentation-annotations:{{% param vers.instrumentation %}}')
41+
}
42+
```
43+
44+
{{% /tab %}} {{< /tabpane >}}
45+
46+
## Créer des spans autour de méthodes avec `@WithSpan` {#creating-spans-around-methods-with-withspan}
47+
48+
Pour créer un [span](/docs/concepts/signals/traces/#spans) qui instrumente une
49+
méthode particulière, annotez la méthode avec `@WithSpan`.
50+
51+
```java
52+
import io.opentelemetry.instrumentation.annotations.WithSpan;
53+
54+
public class MyClass {
55+
@WithSpan
56+
public void myMethod() {
57+
<...>
58+
}
59+
}
60+
```
61+
62+
Chaque fois que l'application invoque la méthode annotée, elle crée un span qui
63+
indique sa durée et fournit toutes les exceptions levées. Par défaut, le nom du
64+
span sera `<className>.<methodName>`, sauf si un nom est fourni via le paramètre
65+
d'annotation `value`.
66+
67+
Si le type de retour de la méthode annotée par `@WithSpan` est l'un des types
68+
[future ou promise](http://en.wikipedia.org/wiki/Futures_and_promises) listés
69+
ci-dessous, alors le span ne sera pas terminé jusqu'à ce que le future se
70+
termine.
71+
72+
- [java.util.concurrent.CompletableFuture](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletableFuture.html)
73+
- [java.util.concurrent.CompletionStage](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletionStage.html)
74+
- [com.google.common.util.concurrent.ListenableFuture](http://guava.dev/releases/10.0/api/docs/com/google/common/util/concurrent/ListenableFuture.html)
75+
- [org.reactivestreams.Publisher](http://www.reactive-streams.org/reactive-streams-1.0.1-javadoc/org/reactivestreams/Publisher.html)
76+
- [reactor.core.publisher.Mono](http://projectreactor.io/docs/core/release/api/reactor/core/publisher/Mono.html)
77+
- [reactor.core.publisher.Flux](http://projectreactor.io/docs/core/release/api/reactor/core/publisher/Flux.html)
78+
- [io.reactivex.Completable](http://reactivex.io/RxJava/2.x/javadoc/index.html?io/reactivex/Completable.html)
79+
- [io.reactivex.Maybe](http://reactivex.io/RxJava/2.x/javadoc/index.html?io/reactivex/Maybe.html)
80+
- [io.reactivex.Single](http://reactivex.io/RxJava/2.x/javadoc/index.html?io/reactivex/Single.html)
81+
- [io.reactivex.Observable](http://reactivex.io/RxJava/2.x/javadoc/index.html?io/reactivex/Observable.html)
82+
- [io.reactivex.Flowable](http://reactivex.io/RxJava/2.x/javadoc/index.html?io/reactivex/Flowable.html)
83+
- [io.reactivex.parallel.ParallelFlowable](http://reactivex.io/RxJava/2.x/javadoc/index.html?io/reactivex/parallel/ParallelFlowable.html)
84+
85+
### Paramètres {#parameters}
86+
87+
L'attribut `@WithSpan` supporte les paramètres optionnels suivants pour
88+
permettre la personnalisation des spans :
89+
90+
| nom | type | défaut | description |
91+
| ---------------- | ----------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
92+
| `value` | `String` | `""` | Le nom du span. Si non spécifié, le défaut `<className>.<methodName>` est utilisé. |
93+
| `kind` | `SpanKind` (enum) | `INTERNAL` | Le [type de span](/docs/specs/otel/trace/api/#spankind). |
94+
| `inheritContext` | `boolean` | `true` | Depuis 2.14.0. Contrôle si le nouveau span sera ou non parent dans le contexte existant (actuel). Si `false`, un nouveau contexte est créé. |
95+
96+
Exemple d'utilisation des paramètres :
97+
98+
```java
99+
@WithSpan(kind = SpanKind.CLIENT, inheritContext = false, value = "my span name")
100+
public void myMethod() {
101+
<...>
102+
}
103+
104+
@WithSpan("my span name")
105+
public void myOtherMethod() {
106+
<...>
107+
}
108+
```
109+
110+
## Ajouter des attributs au span avec `@SpanAttribute` {#adding-attributes-to-the-span-with-spanattribute}
111+
112+
Quand un [span](/docs/concepts/signals/traces/#spans) est créé pour une méthode
113+
annotée, les valeurs des arguments de l'invocation de méthode peuvent être
114+
automatiquement ajoutées comme
115+
[attributs](/docs/concepts/signals/traces/#attributes) au span créé. Annotez
116+
simplement les paramètres de méthode avec l'annotation `@SpanAttribute` :
117+
118+
```java
119+
import io.opentelemetry.instrumentation.annotations.SpanAttribute;
120+
import io.opentelemetry.instrumentation.annotations.WithSpan;
121+
122+
public class MyClass {
123+
124+
@WithSpan
125+
public void myMethod(@SpanAttribute("parameter1") String parameter1,
126+
@SpanAttribute("parameter2") long parameter2) {
127+
<...>
128+
}
129+
}
130+
```
131+
132+
Sauf si spécifié comme argument de l'annotation, le nom de l'attribut sera
133+
dérivé des noms de paramètres formels s'ils sont compilés dans les fichiers
134+
`.class` en passant l'option `-parameters` au compilateur `javac`.
135+
136+
## Supprimer l'instrumentation `@WithSpan` {#suppressing-withspan-instrumentation}
137+
138+
Supprimer `@WithSpan` est utile si vous avez du code qui est sur-instrumenté en
139+
utilisant `@WithSpan` et que vous voulez en supprimer certains sans modifier le
140+
code.
141+
142+
{{% config_option
143+
name="otel.instrumentation.opentelemetry-instrumentation-annotations.exclude-methods" %}} Supprimer
144+
l'instrumentation `@WithSpan` pour des méthodes spécifiques. Le format est
145+
`my.package.MyClass1[method1,method2];my.package.MyClass2[method3]`.
146+
{{% /config_option %}}
147+
148+
## Créer des spans autour de méthodes avec `otel.instrumentation.methods.include` {#creating-spans-around-methods-with-otelinstrumentationmethodsinclude}
149+
150+
Dans les cas où vous ne pouvez pas modifier le code, vous pouvez toujours
151+
configurer l'agent Java pour capturer des spans autour de méthodes spécifiques.
152+
153+
{{% config_option name="otel.instrumentation.methods.include" %}} Ajouter
154+
l'instrumentation pour des méthodes spécifiques à la place de `@WithSpan`. Le
155+
format est `my.package.MyClass1[method1,method2];my.package.MyClass2[method3]`.
156+
{{%
157+
/config_option %}}
158+
159+
Si une méthode est surchargée (apparaît plus d'une fois sur la même classe avec
160+
le même nom mais des paramètres différents), toutes les versions de la méthode
161+
seront instrumentées.
162+
163+
## Prochaines étapes {#next-steps}
164+
165+
Au-delà de l'utilisation d'annotations, l'API OpenTelemetry vous permet
166+
d'obtenir un traceur qui peut être utilisé pour
167+
[l'instrumentation personnalisée](../api).

‎content/fr/docs/zero-code/java/agent/api.md‎

Lines changed: 87 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,87 @@
1+
---
2+
title: Étendre les instrumentations avec l'API
3+
linkTitle: Étendre avec l'API
4+
description:
5+
Utilisez l'API OpenTelemetry en combinaison avec l'agent Java pour étendre la
6+
télémétrie générée automatiquement avec des spans et métriques personnalisés
7+
weight: 21
8+
default_lang_commit: 3d179dbe1270b83aafff0d3b6aa3311afd482649
9+
---
10+
11+
## Introduction {#introduction}
12+
13+
En plus de l'instrumentation prête à l'emploi, vous pouvez étendre l'agent Java
14+
avec une instrumentation manuelle personnalisée en utilisant l'API
15+
OpenTelemetry. Cela vous permet de créer des
16+
[spans](/docs/concepts/signals/traces/#spans) et des
17+
[métriques](/docs/concepts/signals/metrics) pour votre propre code sans faire
18+
trop de changements de code.
19+
20+
## Dépendances {#dependencies}
21+
22+
Ajoutez une dépendance à la bibliothèque `opentelemetry-api`.
23+
24+
### Maven {#maven}
25+
26+
```xml
27+
<dependencies>
28+
<dependency>
29+
<groupId>io.opentelemetry</groupId>
30+
<artifactId>opentelemetry-api</artifactId>
31+
<version>{{% param vers.otel %}}</version>
32+
</dependency>
33+
</dependencies>
34+
```
35+
36+
### Gradle {#gradle}
37+
38+
```groovy
39+
dependencies {
40+
implementation('io.opentelemetry:opentelemetry-api:{{% param vers.otel %}}')
41+
}
42+
```
43+
44+
## OpenTelemetry {#opentelemetry}
45+
46+
L'agent Java est un cas particulier où `GlobalOpenTelemetry` est défini par l'
47+
agent. Appelez simplement `GlobalOpenTelemetry.get()` pour accéder à l'instance
48+
`OpenTelemetry`.
49+
50+
## Span {#span}
51+
52+
{{% alert title="Note" %}}
53+
54+
Pour les cas d'usage les plus courants, utilisez l'annotation `@WithSpan` au
55+
lieu de l'instrumentation manuelle. Consultez [Annotations](../annotations) pour
56+
plus d'informations.
57+
58+
{{% /alert %}}
59+
60+
```java
61+
import io.opentelemetry.api.GlobalOpenTelemetry;
62+
import io.opentelemetry.api.trace.Tracer;
63+
64+
Tracer tracer = GlobalOpenTelemetry.getTracer("application");
65+
```
66+
67+
Utilisez le `Tracer` pour créer un span comme expliqué dans la section
68+
[Span](/docs/languages/java/api/#span).
69+
70+
Un exemple complet peut être trouvé dans le [dépôt d'exemples].
71+
72+
## Meter {#meter}
73+
74+
```java
75+
import io.opentelemetry.api.GlobalOpenTelemetry;
76+
import io.opentelemetry.api.metrics.Meter;
77+
78+
Meter meter = GlobalOpenTelemetry.getMeter("application");
79+
```
80+
81+
Utilisez le `Meter` pour créer un compteur, une jauge ou un histogramme comme
82+
expliqué dans la section [Meter](/docs/languages/java/api/#meter).
83+
84+
Un exemple complet peut être trouvé dans le [dépôt d'exemples].
85+
86+
[dépôt d'exemples]:
87+
http://github.com/open-telemetry/opentelemetry-java-examples/tree/main/javaagent

0 commit comments

Comments
 (0)