Last batch of library readmes (open-telemetry#14832)

Author: jaydeluca

instrumentation/aws-sdk/aws-sdk-1.11/library/README.md

@@ -0,0 +1,54 @@
+# Library Instrumentation for AWS SDK for Java version 1.11 and higher
+
+Provides OpenTelemetry instrumentation for the [AWS SDK for Java](https://aws.amazon.com/sdk-for-java/).
+
+## Quickstart
+
+### Add these dependencies to your project
+
+Replace `OPENTELEMETRY_VERSION` with the [latest release](https://central.sonatype.com/artifact/io.opentelemetry.instrumentation/opentelemetry-aws-sdk-1.11).
+
+For Maven, add to your `pom.xml` dependencies:
+
+```xml
+<dependencies>
+  <dependency>
+    <groupId>io.opentelemetry.instrumentation</groupId>
+    <artifactId>opentelemetry-aws-sdk-1.11</artifactId>
+    <version>OPENTELEMETRY_VERSION</version>
+  </dependency>
+</dependencies>
+```
+
+For Gradle, add to your dependencies:
+
+```kotlin
+implementation("io.opentelemetry.instrumentation:opentelemetry-aws-sdk-1.11:OPENTELEMETRY_VERSION")
+```
+
+### Usage
+
+The instrumentation library provides a `RequestHandler2` that can be added to any AWS SDK v1
+client builder to provide spans and context propagation.
+
+```java
+import com.amazonaws.services.s3.AmazonS3;
+import com.amazonaws.services.s3.AmazonS3ClientBuilder;
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.instrumentation.awssdk.v1_11.AwsSdkTelemetry;
+
+public class AwsSdkConfiguration {
+
+  // Use this to create instrumented AWS SDK clients.
+  public AmazonS3 createS3Client(OpenTelemetry openTelemetry) {
+    return AmazonS3ClientBuilder.standard()
+        .withRequestHandlers(
+            AwsSdkTelemetry.builder(openTelemetry)
+                .build()
+                .newRequestHandler())
+        .build();
+  }
+
+  // This pattern works for all AWS SDK v1 client builders (S3, SQS, DynamoDB, etc.).
+}
+```

instrumentation/spring/spring-integration-4.1/library/README.md

@@ -0,0 +1,51 @@
+# Library Instrumentation for Spring Integration version 4.1 and higher
+
+Provides OpenTelemetry instrumentation for [Spring Integration](https://spring.io/projects/spring-integration),
+enabling producer and consumer messaging spans for Spring Integration.
+
+## Quickstart
+
+### Add these dependencies to your project
+
+Replace `OPENTELEMETRY_VERSION` with the [latest release](https://central.sonatype.com/artifact/io.opentelemetry.instrumentation/opentelemetry-spring-integration-4.1).
+
+For Maven, add to your `pom.xml` dependencies:
+
+```xml
+<dependencies>
+  <dependency>
+    <groupId>io.opentelemetry.instrumentation</groupId>
+    <artifactId>opentelemetry-spring-integration-4.1</artifactId>
+    <version>OPENTELEMETRY_VERSION</version>
+  </dependency>
+</dependencies>
+```
+
+For Gradle, add to your dependencies:
+
+```kotlin
+implementation("io.opentelemetry.instrumentation:opentelemetry-spring-integration-4.1:OPENTELEMETRY_VERSION")
+```
+
+### Usage
+
+The instrumentation library provides a `ChannelInterceptor` implementation that can be added
+to your Spring Integration message channels to provide spans and context propagation.
+
+```java
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.instrumentation.spring.integration.v4_1.SpringIntegrationTelemetry;
+import org.springframework.messaging.support.ChannelInterceptor;
+
+public class SpringIntegrationConfiguration {
+
+  // Use this ChannelInterceptor for intercepting Spring Integration message channels.
+  public ChannelInterceptor createInterceptor(OpenTelemetry openTelemetry) {
+    return SpringIntegrationTelemetry.builder(openTelemetry)
+        .build()
+        .newChannelInterceptor();
+  }
+
+  // Apply the interceptor to your message channels in your Spring configuration.
+}
+```

instrumentation/spring/spring-kafka-2.7/library/README.md

@@ -0,0 +1,67 @@
+# Library Instrumentation for Spring Kafka version 2.7 and higher
+
+Provides OpenTelemetry instrumentation for [Spring Kafka](https://spring.io/projects/spring-kafka),
+enabling consumer and producer messaging spans.
+
+## Quickstart
+
+### Add these dependencies to your project
+
+Replace `OPENTELEMETRY_VERSION` with the [latest release](https://central.sonatype.com/artifact/io.opentelemetry.instrumentation/opentelemetry-spring-kafka-2.7).
+
+For Maven, add to your `pom.xml` dependencies:
+
+```xml
+<dependencies>
+  <dependency>
+    <groupId>io.opentelemetry.instrumentation</groupId>
+    <artifactId>opentelemetry-spring-kafka-2.7</artifactId>
+    <version>OPENTELEMETRY_VERSION</version>
+  </dependency>
+</dependencies>
+```
+
+For Gradle, add to your dependencies:
+
+```kotlin
+implementation("io.opentelemetry.instrumentation:opentelemetry-spring-kafka-2.7:OPENTELEMETRY_VERSION")
+```
+
+### Usage
+
+The instrumentation library provides interceptors that can be added to Spring Kafka message
+listener containers and producers to provide spans and context propagation.
+
+```java
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.instrumentation.kafkaclients.v2_6.KafkaTelemetry;
+import io.opentelemetry.instrumentation.spring.kafka.v2_7.SpringKafkaTelemetry;
+import org.springframework.boot.autoconfigure.kafka.DefaultKafkaProducerFactoryCustomizer;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.kafka.config.ContainerCustomizer;
+import org.springframework.kafka.listener.ConcurrentMessageListenerContainer;
+
+@Configuration
+public class KafkaInstrumentationConfig {
+
+  // Instrument Kafka producers
+  @Bean
+  public DefaultKafkaProducerFactoryCustomizer producerInstrumentation(
+      OpenTelemetry openTelemetry) {
+    KafkaTelemetry kafkaTelemetry = KafkaTelemetry.create(openTelemetry);
+    return producerFactory -> producerFactory.addPostProcessor(kafkaTelemetry::wrap);
+  }
+
+  // Instrument Kafka consumers
+  @Bean
+  public ContainerCustomizer<String, String, ConcurrentMessageListenerContainer<String, String>>
+      listenerCustomizer(OpenTelemetry openTelemetry) {
+    SpringKafkaTelemetry springKafkaTelemetry = SpringKafkaTelemetry.create(openTelemetry);
+    return container -> {
+      container.setRecordInterceptor(springKafkaTelemetry.createRecordInterceptor());
+      container.setBatchInterceptor(springKafkaTelemetry.createBatchInterceptor());
+    };
+  }
+}
+```