Add gRPC export for profiles signal type. (#7301)

Co-authored-by: Jack Berg <[email protected]>

Author: jhalliday

exporters/common/src/main/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterUtil.java

@@ -28,6 +28,19 @@ public final class GrpcExporterUtil {
   public static final int GRPC_STATUS_DATA_LOSS = 15;
 
   static void logUnimplemented(Logger logger, String type, @Nullable String fullErrorMessage) {
+
+    // hopefully temporary special handling for profile signal as it evolves towards stability.
+    if ("profile".equals(type)) {
+      logger.log(
+          Level.SEVERE,
+          "Failed to export profile. The profile signal type is still under development "
+              + "and the endpoint you are connecting to may not support it yet, "
+              + "or may support a different version. "
+              + "Full error message: "
+              + fullErrorMessage);
+      return;
+    }
+
     String envVar;
     switch (type) {
       case "span":

exporters/otlp/profiles/build.gradle.kts

@@ -15,10 +15,16 @@ dependencies {
   api(project(":exporters:common"))
   implementation(project(":exporters:otlp:common"))
 
+  implementation(project(":exporters:otlp:all"))
+  compileOnly("io.grpc:grpc-stub")
+
   annotationProcessor("com.google.auto.value:auto-value")
 
   testCompileOnly("com.google.guava:guava")
   testImplementation("com.fasterxml.jackson.core:jackson-databind")
   testImplementation("com.google.protobuf:protobuf-java-util")
   testImplementation("io.opentelemetry.proto:opentelemetry-proto")
+  testImplementation(project(":exporters:otlp:testing-internal"))
+  testImplementation(project(":exporters:sender:okhttp"))
+  testImplementation("io.grpc:grpc-stub")
 }

exporters/otlp/profiles/src/main/java/io/opentelemetry/exporter/otlp/profiles/ExportProfilesServiceResponse.java

@@ -0,0 +1,15 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.exporter.otlp.profiles;
+
+// A Java object to correspond to the gRPC response for the ProfilesService.Export method. If fields
+// are added to the type in the future, this can be converted to an actual class.
+//
+// It may seem like Void could be used instead but gRPC does not allow response values to be
+// null.
+enum ExportProfilesServiceResponse {
+  INSTANCE;
+}

exporters/otlp/profiles/src/main/java/io/opentelemetry/exporter/otlp/profiles/MarshalerProfilesServiceGrpc.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.exporter.otlp.profiles;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.MethodDescriptor;
+import io.grpc.stub.ClientCalls;
+import io.opentelemetry.exporter.internal.grpc.MarshalerInputStream;
+import io.opentelemetry.exporter.internal.grpc.MarshalerServiceStub;
+import io.opentelemetry.exporter.internal.marshal.Marshaler;
+import java.io.InputStream;
+import javax.annotation.Nullable;
+
+// Adapted from the protoc generated code for ProfilesServiceGrpc.
+final class MarshalerProfilesServiceGrpc {
+
+  private static final String SERVICE_NAME =
+      "opentelemetry.proto.collector.profiles.v1development.ProfilesService";
+
+  private static final MethodDescriptor.Marshaller<Marshaler> REQUEST_MARSHALLER =
+      new MethodDescriptor.Marshaller<Marshaler>() {
+        @Override
+        public InputStream stream(Marshaler value) {
+          return new MarshalerInputStream(value);
+        }
+
+        @Override
+        public Marshaler parse(InputStream stream) {
+          throw new UnsupportedOperationException("Only for serializing");
+        }
+      };
+
+  private static final MethodDescriptor.Marshaller<ExportProfilesServiceResponse>
+      RESPONSE_MARSHALER =
+          new MethodDescriptor.Marshaller<ExportProfilesServiceResponse>() {
+            @Override
+            public InputStream stream(ExportProfilesServiceResponse value) {
+              throw new UnsupportedOperationException("Only for parsing");
+            }
+
+            @Override
+            public ExportProfilesServiceResponse parse(InputStream stream) {
+              return ExportProfilesServiceResponse.INSTANCE;
+            }
+          };
+
+  private static final MethodDescriptor<Marshaler, ExportProfilesServiceResponse> getExportMethod =
+      MethodDescriptor.<Marshaler, ExportProfilesServiceResponse>newBuilder()
+          .setType(MethodDescriptor.MethodType.UNARY)
+          .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Export"))
+          .setRequestMarshaller(REQUEST_MARSHALLER)
+          .setResponseMarshaller(RESPONSE_MARSHALER)
+          .build();
+
+  static ProfilesServiceFutureStub newFutureStub(
+      Channel channel, @Nullable String authorityOverride) {
+    return ProfilesServiceFutureStub.newStub(
+        (c, options) -> new ProfilesServiceFutureStub(c, options.withAuthority(authorityOverride)),
+        channel);
+  }
+
+  static final class ProfilesServiceFutureStub
+      extends MarshalerServiceStub<
+          Marshaler, ExportProfilesServiceResponse, ProfilesServiceFutureStub> {
+    private ProfilesServiceFutureStub(Channel channel, CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @Override
+    protected MarshalerProfilesServiceGrpc.ProfilesServiceFutureStub build(
+        Channel channel, CallOptions callOptions) {
+      return new MarshalerProfilesServiceGrpc.ProfilesServiceFutureStub(channel, callOptions);
+    }
+
+    @Override
+    public ListenableFuture<ExportProfilesServiceResponse> export(Marshaler request) {
+      return ClientCalls.futureUnaryCall(
+          getChannel().newCall(getExportMethod, getCallOptions()), request);
+    }
+  }
+
+  private MarshalerProfilesServiceGrpc() {}
+}

exporters/otlp/profiles/src/main/java/io/opentelemetry/exporter/otlp/profiles/NoopProfileExporter.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.exporter.otlp.profiles;
+
+import io.opentelemetry.sdk.common.CompletableResultCode;
+import java.util.Collection;
+
+final class NoopProfileExporter implements ProfileExporter {
+
+  private static final ProfileExporter INSTANCE = new NoopProfileExporter();
+
+  static ProfileExporter getInstance() {
+    return INSTANCE;
+  }
+
+  @Override
+  public CompletableResultCode export(Collection<ProfileData> profiles) {
+    return CompletableResultCode.ofSuccess();
+  }
+
+  @Override
+  public CompletableResultCode flush() {
+    return CompletableResultCode.ofSuccess();
+  }
+
+  @Override
+  public CompletableResultCode shutdown() {
+    return CompletableResultCode.ofSuccess();
+  }
+
+  @Override
+  public String toString() {
+    return "NoopProfilesExporter{}";
+  }
+}

exporters/otlp/profiles/src/main/java/io/opentelemetry/exporter/otlp/profiles/OtlpGrpcProfileExporter.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.exporter.otlp.profiles;
+
+import io.opentelemetry.exporter.internal.grpc.GrpcExporter;
+import io.opentelemetry.exporter.internal.grpc.GrpcExporterBuilder;
+import io.opentelemetry.exporter.internal.marshal.Marshaler;
+import io.opentelemetry.sdk.common.CompletableResultCode;
+import java.util.Collection;
+import java.util.StringJoiner;
+import javax.annotation.concurrent.ThreadSafe;
+
+/** Exports profiles using OTLP via gRPC, using OpenTelemetry's protobuf model. */
+@ThreadSafe
+public class OtlpGrpcProfileExporter implements ProfileExporter {
+
+  private final GrpcExporterBuilder<Marshaler> builder;
+  private final GrpcExporter<Marshaler> delegate;
+
+  /**
+   * Returns a new {@link OtlpGrpcProfileExporter} using the default values.
+   *
+   * <p>To load configuration values from environment variables and system properties, use <a
+   * href="https://github.com/open-telemetry/opentelemetry-java/tree/main/sdk-extensions/autoconfigure">opentelemetry-sdk-extension-autoconfigure</a>.
+   *
+   * @return a new {@link OtlpGrpcProfileExporter} instance.
+   */
+  public static OtlpGrpcProfileExporter getDefault() {
+    return builder().build();
+  }
+
+  /**
+   * Returns a new builder instance for this exporter.
+   *
+   * @return a new builder instance for this exporter.
+   */
+  public static OtlpGrpcProfilesExporterBuilder builder() {
+    return new OtlpGrpcProfilesExporterBuilder();
+  }
+
+  OtlpGrpcProfileExporter(
+      GrpcExporterBuilder<Marshaler> builder, GrpcExporter<Marshaler> delegate) {
+    this.builder = builder;
+    this.delegate = delegate;
+  }
+
+  /**
+   * Returns a builder with configuration values equal to those for this exporter.
+   *
+   * <p>IMPORTANT: Be sure to {@link #shutdown()} this instance if it will no longer be used.
+   */
+  public OtlpGrpcProfilesExporterBuilder toBuilder() {
+    return new OtlpGrpcProfilesExporterBuilder(builder.copy());
+  }
+
+  /**
+   * Submits all the given profiles in a single batch to the OpenTelemetry collector.
+   *
+   * @param profiles the list of sampled profiles to be exported.
+   * @return the result of the operation
+   */
+  @Override
+  public CompletableResultCode export(Collection<ProfileData> profiles) {
+    ProfilesRequestMarshaler request = ProfilesRequestMarshaler.create(profiles);
+    return delegate.export(request, profiles.size());
+  }
+
+  /**
+   * The OTLP exporter does not batch items, so this method will immediately return with success.
+   *
+   * @return always Success
+   */
+  @Override
+  public CompletableResultCode flush() {
+    return CompletableResultCode.ofSuccess();
+  }
+
+  /**
+   * Initiates an orderly shutdown in which preexisting calls continue but new calls are immediately
+   * cancelled.
+   */
+  @Override
+  public CompletableResultCode shutdown() {
+    return delegate.shutdown();
+  }
+
+  @Override
+  public String toString() {
+    StringJoiner joiner = new StringJoiner(", ", "OtlpGrpcProfilesExporter{", "}");
+    joiner.add(builder.toString(false));
+    return joiner.toString();
+  }
+}