Udp release workflow

.github/workflows/release-udp-exporter.yml

@@ -0,0 +1,76 @@
+name: Release ADOT OTLP UDP Exporter
+
+on:
+  push:
+    branches:
+      - "udp-*"
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Version number for deployment e.g. 0.0.1'
+        required: true
+        type: string
+
+jobs:
+  build-test-publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Java
+        uses: actions/setup-java@v3
+        with:
+          java-version: '17'  # or your preferred version
+          distribution: 'temurin'
+          cache: 'gradle'    # Add gradle caching
+
+      - name: Build, Test and Publish UDP exporter
+        working-directory: exporters/aws-opentelemetry-xray-udp-span-exporter
+        run: |
+          gradle build 
+          gradle publishToMavenLocal
+
+      - name: Download and run X-Ray Daemon
+        run: |
+          mkdir xray-daemon
+          cd xray-daemon
+          wget https://s3.us-west-2.amazonaws.com/aws-xray-assets.us-west-2/xray-daemon/aws-xray-daemon-linux-3.x.zip
+          unzip aws-xray-daemon-linux-3.x.zip
+          ./xray -o -n us-west-2 -f ./daemon-logs.log --log-level debug &
+
+      - name: Run Sample App in Background
+        working-directory: sample-apps/integ-test-app
+        run: |
+          gradle build
+          java -jar build/libs/integ-test-app.jar &
+          sleep 5
+
+      - name: Call Sample App Endpoint
+        run: |
+          echo "traceId=$(curl localhost:8080/test)" >> $GITHUB_OUTPUT
+
+      - name: Verify X-Ray daemon received traces
+        run: |
+          sleep 10
+          echo "X-Ray daemon logs:"
+          cat xray-daemon/daemon-logs.log
+
+          # Check if the daemon received and processed some data
+          if grep -q "sending.*batch" xray-daemon/daemon-logs.log; then
+            echo "✅ X-Ray daemon processed trace data (AWS upload errors are expected)"
+            exit 0
+          elif grep -q "processor:.*segment" xray-daemon/daemon-logs.log; then
+            echo "✅ X-Ray daemon processed segment data (AWS upload errors are expected)"
+            exit 0
+          else
+            echo "❌ No evidence of traces being received by X-Ray daemon"
+            exit 1
+          fi
+
+      # TODO: Steps to publish to Maven Central
+      # - name: Publish to Maven Central
+      #   env:
+      #     MAVEN_USERNAME: ${{ secrets.OSSRH_USERNAME }}
+      #     MAVEN_PASSWORD: ${{ secrets.OSSRH_TOKEN }}
+      #   working-directory: exporters/aws-otel-otlp-udp-exporter
+      #   run: ../../gradlew publish

exporters/aws-opentelemetry-xray-udp-span-exporter/build.gradle.kts

@@ -0,0 +1,101 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+plugins {
+  id("java")
+  id("java-library")
+  id("maven-publish")
+}
+
+group = "software.amazon.distro.opentelemetry.exporter.xray.udp.trace"
+version = "0.1.0"
+
+dependencies {
+  implementation(platform("io.opentelemetry.instrumentation:opentelemetry-instrumentation-bom:2.10.0"))
+  compileOnly("io.opentelemetry:opentelemetry-api")
+  compileOnly("io.opentelemetry:opentelemetry-sdk")
+  compileOnly("io.opentelemetry:opentelemetry-exporter-otlp-common")
+  compileOnly("com.google.code.findbugs:jsr305:3.0.2")
+  testImplementation("io.opentelemetry:opentelemetry-api")
+  testImplementation("io.opentelemetry:opentelemetry-sdk")
+  testImplementation("io.opentelemetry:opentelemetry-exporter-otlp-common")
+  testImplementation(platform("org.junit:junit-bom:5.9.2"))
+  testImplementation("org.junit.jupiter:junit-jupiter-api")
+  testImplementation("org.junit.jupiter:junit-jupiter-engine")
+  testImplementation("org.mockito:mockito-core:5.3.1")
+  testImplementation("org.assertj:assertj-core:3.24.2")
+  testImplementation("org.mockito:mockito-junit-jupiter:5.3.1")
+}
+
+java {
+  withSourcesJar()
+  withJavadocJar()
+}
+
+tasks.javadoc {
+  options {
+    (this as CoreJavadocOptions).addStringOption("Xdoclint:none", "-quiet")
+  }
+  isFailOnError = false
+}
+
+sourceSets {
+  main {
+    java {
+      srcDirs("src/main/java")
+    }
+  }
+  test {
+    java {
+      srcDirs("src/test/java")
+    }
+  }
+}
+
+tasks.test {
+  useJUnitPlatform()
+  testLogging {
+    events("passed", "skipped", "failed")
+  }
+}
+
+tasks.jar {
+  manifest {
+    attributes(
+      "Implementation-Title" to project.name,
+      "Implementation-Version" to project.version,
+    )
+  }
+  duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+}
+
+tasks.named<Jar>("javadocJar") {
+  duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+}
+
+tasks.named<Jar>("sourcesJar") {
+  duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+}
+
+publishing {
+  publications {
+    create<MavenPublication>("mavenJava") {
+      from(components["java"])
+      groupId = project.group.toString()
+      artifactId = "aws-opentelemetry-xray-udp-span-exporter"
+      version = project.version.toString()
+    }
+  }
+}

exporters/aws-opentelemetry-xray-udp-span-exporter/settings.gradle.kts

@@ -0,0 +1,12 @@
+rootProject.name = "aws-opentelemetry-xray-udp-span-exporter"
+
+dependencyResolutionManagement {
+  repositories {
+    mavenCentral()
+    mavenLocal()
+
+    maven {
+      setUrl("https://oss.sonatype.org/content/repositories/snapshots")
+    }
+  }
+}

exporters/aws-opentelemetry-xray-udp-span-exporter/src/main/java/software/amazon/distro/opentelemetry/exporter/xray/udp/trace/AwsXrayUdpSpanExporter.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package software.amazon.distro.opentelemetry.exporter.xray.udp.trace;
+
+import io.opentelemetry.exporter.internal.otlp.traces.TraceRequestMarshaler;
+import io.opentelemetry.sdk.common.CompletableResultCode;
+import io.opentelemetry.sdk.trace.data.SpanData;
+import io.opentelemetry.sdk.trace.export.SpanExporter;
+import java.io.ByteArrayOutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import java.util.Collection;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * Exports spans via UDP, using OpenTelemetry's protobuf model. The protobuf modelled spans are
+ * Base64 encoded and prefixed with AWS X-Ray specific information before being sent over to {@link
+ * UdpSender}.
+ *
+ * <p>This exporter is NOT meant for generic use since the payload is prefixed with AWS X-Ray
+ * specific information.
+ */
+@Immutable
+public class AwsXrayUdpSpanExporter implements SpanExporter {
+
+  private static final Logger logger = Logger.getLogger(AwsXrayUdpSpanExporter.class.getName());
+
+  private final AtomicBoolean isShutdown = new AtomicBoolean();
+
+  private final UdpSender sender;
+  private final String payloadPrefix;
+
+  AwsXrayUdpSpanExporter(UdpSender sender, String payloadPrefix) {
+    this.sender = sender;
+    this.payloadPrefix = payloadPrefix;
+  }
+
+  @Override
+  public CompletableResultCode export(Collection<SpanData> spans) {
+    if (isShutdown.get()) {
+      return CompletableResultCode.ofFailure();
+    }
+
+    TraceRequestMarshaler exportRequest = TraceRequestMarshaler.create(spans);
+    ByteArrayOutputStream baos = new ByteArrayOutputStream();
+    try {
+      exportRequest.writeBinaryTo(baos);
+      String payload = payloadPrefix + Base64.getEncoder().encodeToString(baos.toByteArray());
+      sender.send(payload.getBytes(StandardCharsets.UTF_8));
+      return CompletableResultCode.ofSuccess();
+    } catch (Exception e) {
+      logger.log(Level.SEVERE, "Failed to export spans. Error: " + e.getMessage(), e);
+      return CompletableResultCode.ofFailure();
+    }
+  }
+
+  @Override
+  public CompletableResultCode flush() {
+    // TODO: implement
+    return CompletableResultCode.ofSuccess();
+  }
+
+  @Override
+  public CompletableResultCode shutdown() {
+    if (!isShutdown.compareAndSet(false, true)) {
+      logger.log(Level.INFO, "Calling shutdown() multiple times.");
+      return CompletableResultCode.ofSuccess();
+    }
+    return sender.shutdown();
+  }
+
+  // Visible for testing
+  UdpSender getSender() {
+    return sender;
+  }
+
+  // Visible for testing
+  String getPayloadPrefix() {
+    return payloadPrefix;
+  }
+}