Update more

Author: jaydeluca

instrumentation/ratpack/ratpack-1.7/library/README.md

@@ -1,6 +1,7 @@
 # Library Instrumentation for Ratpack version 1.7 and higher
 
-Provides OpenTelemetry instrumentation for [Ratpack](https://ratpack.io/), enabling CLIENT and SERVER spans.
+Provides OpenTelemetry instrumentation for [Ratpack](https://ratpack.io/), enabling HTTP client and server spans and
+metrics.
 
 ## Quickstart
 
@@ -37,7 +38,8 @@ import ratpack.http.client.HttpClient;
 
 public class RatpackExample {
   public static void main(String[] args) throws Exception {
-    OpenTelemetry openTelemetry = OpenTelemetry.noop();
+    // Get an OpenTelemetry instance
+    OpenTelemetry openTelemetry = ...;
 
     // Server instrumentation
     RatpackServerTelemetry serverTelemetry = RatpackServerTelemetry.create(openTelemetry);

instrumentation/reactor/reactor-3.1/library/README.md

@@ -1,8 +1,7 @@
 # Library Instrumentation for Project Reactor version 3.1 and higher
 
-Provides OpenTelemetry instrumentation for [Project Reactor](https://projectreactor.io/).
-
-This instrumentation generates spans for each reactive operation.
+Provides OpenTelemetry instrumentation for [Project Reactor](https://projectreactor.io/), enabling
+context propagation through Reactor's execution model.
 
 ## Quickstart
 
@@ -38,8 +37,6 @@ import reactor.core.publisher.Flux;
 
 public class ReactorExample {
   public static void main(String[] args) {
-    OpenTelemetry openTelemetry = OpenTelemetry.noop();
-
     ContextPropagationOperator contextPropagationOperator = ContextPropagationOperator.create();
     contextPropagationOperator.registerOnEachOperator();
 

instrumentation/restlet/restlet-1.1/library/README.md

@@ -1,8 +1,7 @@
 # Library Instrumentation for Restlet version 1.1 and higher
 
-Provides OpenTelemetry instrumentation for [Restlet](https://restlet.talend.com/).
-
-This instrumentation generates SERVER spans for each HTTP request.
+Provides OpenTelemetry instrumentation for [Restlet](https://restlet.talend.com/), enabling HTTP
+server spans.
 
 ## Quickstart
 
@@ -39,7 +38,8 @@ import org.restlet.Restlet;
 
 public class RestletExample {
   public static void main(String[] args) throws Exception {
-    OpenTelemetry openTelemetry = OpenTelemetry.noop();
+    // Get an OpenTelemetry instance
+    OpenTelemetry openTelemetry = ...;
 
     RestletTelemetry restletTelemetry = RestletTelemetry.create(openTelemetry);
     Filter tracingFilter = restletTelemetry.newFilter("/api");

instrumentation/restlet/restlet-2.0/library/README.md

@@ -0,0 +1,55 @@
+# Library Instrumentation for Restlet version 2.0 and higher
+
+Provides OpenTelemetry instrumentation for [Restlet](https://restlet.talend.com/), enabling HTTP
+server spans.
+
+## Quickstart
+
+### Add these dependencies to your project
+
+Replace `OPENTELEMETRY_VERSION` with the [latest release](https://central.sonatype.com/artifact/io.opentelemetry.instrumentation/opentelemetry-restlet-2.0).
+
+For Maven, add to your `pom.xml` dependencies:
+
+```xml
+<dependencies>
+  <dependency>
+    <groupId>io.opentelemetry.instrumentation</groupId>
+    <artifactId>opentelemetry-restlet-2.0</artifactId>
+    <version>OPENTELEMETRY_VERSION</version>
+  </dependency>
+</dependencies>
+```
+
+For Gradle, add to your dependencies:
+
+```kotlin
+implementation("io.opentelemetry.instrumentation:opentelemetry-restlet-2.0:OPENTELEMETRY_VERSION")
+```
+
+### Usage
+
+```java
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.instrumentation.restlet.v2_0.RestletTelemetry;
+import org.restlet.Application;
+import org.restlet.Restlet;
+import org.restlet.routing.Filter;
+
+public class RestletExample {
+  public static void main(String[] args) throws Exception {
+    // Get an OpenTelemetry instance
+    OpenTelemetry openTelemetry = ...;
+
+    RestletTelemetry restletTelemetry = RestletTelemetry.create(openTelemetry);
+    Filter tracingFilter = restletTelemetry.newFilter("/api");
+
+    Application application = new Application() {
+      @Override
+      public Restlet createInboundRoot() {
+        return tracingFilter;
+      }
+    };
+  }
+}
+```

instrumentation/rxjava/rxjava-1.0/library/README.md

@@ -0,0 +1,67 @@
+# Library Instrumentation for RxJava version 1.0 and higher
+
+Provides OpenTelemetry instrumentation utilities for [RxJava](https://github.com/ReactiveX/RxJava/tree/1.x),
+enabling context propagation through RxJava's execution model.
+
+**Note**: This library is primarily designed for use by other OpenTelemetry instrumentation
+libraries and framework integrations, not for direct end-user application usage.
+
+## Quickstart
+
+### Add these dependencies to your project
+
+Replace `OPENTELEMETRY_VERSION` with the [latest release](https://central.sonatype.com/artifact/io.opentelemetry.instrumentation/opentelemetry-rxjava-1.0).
+
+For Maven, add to your `pom.xml` dependencies:
+
+```xml
+<dependencies>
+  <dependency>
+    <groupId>io.opentelemetry.instrumentation</groupId>
+    <artifactId>opentelemetry-rxjava-1.0</artifactId>
+    <version>OPENTELEMETRY_VERSION</version>
+  </dependency>
+</dependencies>
+```
+
+For Gradle, add to your dependencies:
+
+```kotlin
+implementation("io.opentelemetry.instrumentation:opentelemetry-rxjava-1.0:OPENTELEMETRY_VERSION")
+```
+
+### Usage
+
+This library provides the `TracedOnSubscribe` class for instrumenting RxJava Observables with
+OpenTelemetry spans:
+
+```java
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter;
+import io.opentelemetry.instrumentation.rxjava.v1_0.TracedOnSubscribe;
+import rx.Observable;
+
+public class RxJavaExample {
+  public static void main(String[] args) {
+    // Get an OpenTelemetry instance
+    OpenTelemetry openTelemetry = ...;
+
+    // Create an instrumenter for your specific request type
+    Instrumenter<String, Void> instrumenter = Instrumenter.<String, Void>builder(
+        openTelemetry,
+        "instrumentation-name",
+        request -> "operation-name")
+        .buildInstrumenter();
+
+    // Create a regular Observable
+    Observable<String> originalObservable = Observable.just("Hello", "World");
+
+    // Wrap it with tracing
+    Observable<String> tracedObservable = Observable.create(
+        new TracedOnSubscribe<>(originalObservable, instrumenter, "request-context"));
+
+    // Subscribe to the traced observable
+    tracedObservable.subscribe(System.out::println);
+  }
+}
+```

instrumentation/rxjava/rxjava-2.0/library/README.md

@@ -0,0 +1,54 @@
+# Library Instrumentation for RxJava version 2.0 and higher
+
+Provides OpenTelemetry instrumentation for [RxJava](https://github.com/ReactiveX/RxJava), enabling
+context propagation through RxJava's execution model.
+
+## Quickstart
+
+### Add these dependencies to your project
+
+Replace `OPENTELEMETRY_VERSION` with the [latest release](https://central.sonatype.com/artifact/io.opentelemetry.instrumentation/opentelemetry-rxjava-2.0).
+
+For Maven, add to your `pom.xml` dependencies:
+
+```xml
+<dependencies>
+  <dependency>
+    <groupId>io.opentelemetry.instrumentation</groupId>
+    <artifactId>opentelemetry-rxjava-2.0</artifactId>
+    <version>OPENTELEMETRY_VERSION</version>
+  </dependency>
+</dependencies>
+```
+
+For Gradle, add to your dependencies:
+
+```kotlin
+implementation("io.opentelemetry.instrumentation:opentelemetry-rxjava-2.0:OPENTELEMETRY_VERSION")
+```
+
+### Usage
+
+Enable RxJava instrumentation by calling `TracingAssembly.enable()` once during application startup.
+This will automatically instrument all RxJava operations in your application:
+
+```java
+import io.opentelemetry.instrumentation.rxjava.v2_0.TracingAssembly;
+import io.reactivex.Observable;
+import io.reactivex.Flowable;
+
+public class RxJavaExample {
+  public static void main(String[] args) {
+    // Enable RxJava instrumentation globally
+    TracingAssembly tracingAssembly = TracingAssembly.create();
+    tracingAssembly.enable();
+
+    // All RxJava operations will now be automatically instrumented
+    Observable<String> observable = Observable.just("Hello", "World");
+    Flowable<String> flowable = Flowable.just("Hello", "World");
+
+    observable.subscribe(System.out::println);
+    flowable.subscribe(System.out::println);
+  }
+}
+```

instrumentation/rxjava/rxjava-3.1.1/library/README.md

@@ -0,0 +1,54 @@
+# Library Instrumentation for RxJava version 3.1.1 and higher
+
+Provides OpenTelemetry instrumentation for [RxJava](https://github.com/ReactiveX/RxJava), enabling
+context propagation through RxJava's execution model.
+
+## Quickstart
+
+### Add these dependencies to your project
+
+Replace `OPENTELEMETRY_VERSION` with the [latest release](https://central.sonatype.com/artifact/io.opentelemetry.instrumentation/opentelemetry-rxjava-3.1.1).
+
+For Maven, add to your `pom.xml` dependencies:
+
+```xml
+<dependencies>
+  <dependency>
+    <groupId>io.opentelemetry.instrumentation</groupId>
+    <artifactId>opentelemetry-rxjava-3.1.1</artifactId>
+    <version>OPENTELEMETRY_VERSION</version>
+  </dependency>
+</dependencies>
+```
+
+For Gradle, add to your dependencies:
+
+```kotlin
+implementation("io.opentelemetry.instrumentation:opentelemetry-rxjava-3.1.1:OPENTELEMETRY_VERSION")
+```
+
+### Usage
+
+Enable RxJava instrumentation by calling `TracingAssembly.enable()` once during application startup.
+This will automatically instrument all RxJava operations in your application:
+
+```java
+import io.opentelemetry.instrumentation.rxjava.v3_1_1.TracingAssembly;
+import io.reactivex.rxjava3.core.Observable;
+import io.reactivex.rxjava3.core.Flowable;
+
+public class RxJavaExample {
+  public static void main(String[] args) {
+    // Enable RxJava instrumentation globally
+    TracingAssembly tracingAssembly = TracingAssembly.create();
+    tracingAssembly.enable();
+
+    // All RxJava operations will now be automatically instrumented
+    Observable<String> observable = Observable.just("Hello", "World");
+    Flowable<String> flowable = Flowable.just("Hello", "World");
+
+    observable.subscribe(System.out::println);
+    flowable.subscribe(System.out::println);
+  }
+}
+```