docs(java): Add Kotlin Kafka snippets

Add Kotlin variants for Kafka retry-count setup and consumer tracing examples. Update custom queue instrumentation docs with Kotlin examples and clarify Kafka queue instrumentation wording.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: adinauer

docs/platforms/java/common/integrations/kafka.mdx

@@ -3,7 +3,7 @@ title: Kafka Integration
 description: "Learn how to trace Kafka queue operations with Sentry."
 ---
 
-Sentry's Kafka integration lets you trace both production and consumption. In Spring Boot, this happens automatically. If you're using raw `kafka-clients`, you'll need to instrument producers and consumers with `sentry-kafka`. 
+Sentry's Kafka integration lets you trace both production and consumption. In Spring Boot, this happens automatically. If you're using raw `kafka-clients`, you'll need to instrument producers and consumers with `sentry-kafka`.
 
 Once configured, queue spans will appear in Sentry's [Queues dashboard](https://sentry.io/orgredirect/organizations/:orgslug/insights/backend/queues/).
 
@@ -157,6 +157,25 @@ ContainerCustomizer<Object, Object, ConcurrentMessageListenerContainer<Object, O
 }
 ```
 
+```kotlin {tabTitle:Kotlin}
+import org.springframework.context.annotation.Bean
+import org.springframework.kafka.config.ContainerCustomizer
+import org.springframework.kafka.listener.ConcurrentMessageListenerContainer
+import org.springframework.kafka.listener.DefaultErrorHandler
+import org.springframework.util.backoff.FixedBackOff
+
+@Bean
+fun kafkaErrorHandler(): DefaultErrorHandler {
+    return DefaultErrorHandler(FixedBackOff(0L, 1L))
+}
+
+@Bean
+fun kafkaContainerCustomizer() =
+    ContainerCustomizer<Any, Any, ConcurrentMessageListenerContainer<Any, Any>> { container ->
+        container.containerProperties.setDeliveryAttemptHeader(true)
+    }
+```
+
 Without that header, Sentry does not set `messaging.message.retry.count`.
 
 </PlatformSection>
@@ -183,7 +202,7 @@ implementation 'io.sentry:sentry-kafka:{{@inject packages.version('sentry.java.k
 libraryDependencies += "io.sentry" % "sentry-kafka" % "{{@inject packages.version('sentry.java.kafka', '8.37.0') }}"
 ```
 
-For other dependency managers, check out the [central Maven repository](https://search.maven.org/artifact/io.sentry/sentry-kafka).
+For other dependency managers, use the same Maven coordinates: `io.sentry:sentry-kafka`.
 
 ### Configure
 
@@ -286,6 +305,17 @@ SentryKafkaConsumerTracing.withTracing(record, () -> {
 });
 ```
 
+```kotlin {tabTitle:Kotlin (Callable)}
+import java.util.concurrent.Callable
+
+SentryKafkaConsumerTracing.withTracing(
+    record,
+    Callable {
+        processOrder(record.value())
+    },
+)
+```
+
 </PlatformSection>
 
 ## Span Data

docs/platforms/java/common/tracing/instrumentation/custom-instrumentation/queues-module.mdx

@@ -4,7 +4,7 @@ sidebar_order: 3000
 description: "Learn how to manually instrument your code to use Sentry's Queues module. "
 ---
 
-Sentry comes with automatic instrumentation for the most common messaging queue systems. If you're using Kafka, see the <PlatformLink to="/integrations/kafka/">Kafka integration</PlatformLink> — it instruments producers and consumers automatically without code changes. For other queue systems that aren't supported yet, you can still instrument custom spans and transactions around your queue producers and consumers to ensure that you have performance data about your messaging queues.
+Sentry provides queue instrumentation for Kafka. If you're using Kafka, see the <PlatformLink to="/integrations/kafka/">Kafka integration</PlatformLink> for the supported automatic and manual setup paths. For other queue systems, you can instrument custom spans and transactions around your queue producers and consumers to capture performance data about your messaging queues.
 
 ## Producer Instrumentation
 
@@ -20,7 +20,7 @@ Your `queue.publish` span must exist inside a transaction in order to be recogni
 
 You must also include trace headers in your message so that your consumers can continue your trace once your message is picked up.
 
-```java
+```java {tabTitle:Java}
 MyCustomQueue connection = MyCustomQueue.connect();
 
 // The message you want to send to the queue
@@ -62,6 +62,48 @@ try {
 }
 ```
 
+```kotlin {tabTitle:Kotlin}
+val connection = MyCustomQueue.connect()
+
+// The message you want to send to the queue
+val queue = "messages"
+val message = "Hello World!"
+val messageId = "abc123"
+
+// Create transaction
+val transaction = Sentry.startTransaction("queue_producer_transaction", "function")
+
+try {
+    val traceparent = Sentry.getTraceparent()
+    val baggage = Sentry.getBaggage()
+
+    val span = transaction.startChild("queue.publish", "queue_producer")
+    try {
+        // Set span data
+        span.setData("messaging.message.id", messageId)
+        span.setData("messaging.destination.name", queue)
+        span.setData("messaging.message.body.size", message.toByteArray(StandardCharsets.UTF_8).size)
+
+        // Publish the message to the queue (including current time stamp)
+        val now = Instant.now().epochSecond
+
+        connection.publish(queue, message, now, traceparent, baggage)
+    } catch (e: Exception) {
+        span.setThrowable(e)
+        span.setStatus(SpanStatus.INTERNAL_ERROR)
+        throw e
+    } finally {
+        span.finish()
+    }
+} catch (e: Exception) {
+    transaction.setThrowable(e)
+    transaction.setStatus(SpanStatus.INTERNAL_ERROR)
+    throw e
+} finally {
+    transaction.finish()
+}
+```
+
 ## Consumer Instrumentation
 
 To start capturing performance metrics, use the `startChild()` function to wrap your queue consumers. Your span `op` must be set to `queue.process`. Include the following span data to enrich your consumer spans with queue metrics:
@@ -78,7 +120,7 @@ Your `queue.process` span must exist inside a transaction in order to be recogni
 
 Use `Sentry.continueTrace()` to connect your consumer spans to their associated producer spans, and `setStatus()` to mark the trace of your message as success or failed.
 
-```java
+```java {tabTitle:Java}
 MyCustomQueue connection = MyCustomQueue.connect();
 
 // Pick up message from queues
@@ -90,18 +132,21 @@ Instant now = Instant.now();
 Instant messageTime = Instant.ofEpochSecond(message.getTimestamp());
 Duration latency = Duration.between(messageTime, now);
 
+// Extract the Sentry trace headers from the message
+SentryTraceHeader sentryTraceHeader = message.getSentryTraceHeader();
+BaggageHeader baggageHeader = message.getBaggageHeader();
+
 // Create transaction
 final TransactionContext transactionContext = Sentry.continueTrace(sentryTraceHeader, baggageHeader);
 ITransaction transaction = Sentry.startTransaction(transactionContext, "queue_consumer_transaction", "function");
 
 try {
-    ISpan span = transaction.startChild("queue.process", "queue_consumer")
+    ISpan span = transaction.startChild("queue.process", "queue_consumer");
 
     try {
         // Set span data
         span.setData("messaging.message.id", message.getMessageId());
         span.setData("messaging.destination.name", queue);
-        //
         span.setData("messaging.message.body.size", message.getBody().getBytes(StandardCharsets.UTF_8).length);
         span.setData("messaging.message.receive.latency", latency.toMillis());
         span.setData("messaging.message.retry.count", 0);
@@ -123,3 +168,52 @@ try {
     transaction.finish();
 }
 ```
+
+```kotlin {tabTitle:Kotlin}
+val connection = MyCustomQueue.connect()
+
+// Pick up message from queues
+val queue = "messages"
+val message = connection.consume(queue)
+
+// Calculate latency (optional, but valuable)
+val now = Instant.now()
+val messageTime = Instant.ofEpochSecond(message.getTimestamp())
+val latency = Duration.between(messageTime, now)
+
+// Extract the Sentry trace headers from the message
+val sentryTraceHeader = message.getSentryTraceHeader()
+val baggageHeader = message.getBaggageHeader()
+
+// Create transaction
+val transactionContext = Sentry.continueTrace(sentryTraceHeader, baggageHeader)
+val transaction = Sentry.startTransaction(transactionContext, "queue_consumer_transaction", "function")
+
+try {
+    val span = transaction.startChild("queue.process", "queue_consumer")
+
+    try {
+        // Set span data
+        span.setData("messaging.message.id", message.getMessageId())
+        span.setData("messaging.destination.name", queue)
+        span.setData("messaging.message.body.size", message.getBody().toByteArray(StandardCharsets.UTF_8).size)
+        span.setData("messaging.message.receive.latency", latency.toMillis())
+        span.setData("messaging.message.retry.count", 0)
+
+        // Process the message
+        processMessage(message)
+    } catch (e: Exception) {
+        span.setThrowable(e)
+        span.setStatus(SpanStatus.INTERNAL_ERROR)
+        throw e
+    } finally {
+        span.finish()
+    }
+} catch (e: Exception) {
+    transaction.setThrowable(e)
+    transaction.setStatus(SpanStatus.INTERNAL_ERROR)
+    throw e
+} finally {
+    transaction.finish()
+}
+```