feat(profiling): Add RecordingData reference counting and OTLP configuration constants

Implement foundation for parallel OTLP profile uploads alongside JFR format.

**Step 1: RecordingData Reference Counting**
Add thread-safe reference counting to support multiple listeners accessing the same RecordingData:
- Add AtomicInteger refCount and volatile boolean released flag
- Add retain() method to increment reference count before passing to additional listeners
- Make release() final with automatic reference counting (decrements and calls doRelease at 0)
- Add protected doRelease() for actual cleanup (called when refcount reaches 0)
- Update all implementations: OpenJdkRecordingData, DatadogProfilerRecordingData,
  OracleJdkRecordingData, CompositeRecordingData

Reference counting pattern enables multiple uploaders (JFR + OTLP) to safely share
RecordingData without double-release or resource leaks. Each listener calls retain()
before use and release() when done. Actual cleanup happens only when refcount reaches zero.

**Step 2: OTLP Configuration Constants**
Add configuration property keys to ProfilingConfig for OTLP profile format support:
- profiling.otlp.enabled (default: false) - Enable parallel OTLP upload
- profiling.otlp.include.original.payload (default: false) - Embed source JFR in OTLP
- profiling.otlp.url (default: "") - OTLP endpoint URL (empty = derive from agent URL)
- profiling.otlp.compression (default: "gzip") - Compression type for OTLP upload

Configuration will be read directly from ConfigProvider in OtlpProfileUploader for testability.

Next steps:
- Step 3: Implement OtlpProfileUploader class (reads config from ConfigProvider)
- Step 4: Integrate with ProfilingAgent
- Step 5: Add tests

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: jbachorik

dd-java-agent/agent-profiling/profiling-controller-openjdk/src/main/java/com/datadog/profiling/controller/openjdk/OpenJdkRecordingData.java

@@ -44,7 +44,7 @@ public RecordingInputStream getStream() throws IOException {
   }
 
   @Override
-  public void release() {
+  protected void doRelease() {
     recording.close();
   }
 

dd-java-agent/agent-profiling/profiling-controller-oracle/src/main/java/com/datadog/profiling/controller/oracle/OracleJdkRecordingData.java

@@ -51,7 +51,7 @@ public RecordingInputStream getStream() throws IOException {
   }
 
   @Override
-  public void release() {
+  protected void doRelease() {
     // noop
   }
 

dd-java-agent/agent-profiling/profiling-ddprof/src/main/java/com/datadog/profiling/ddprof/DatadogProfilerRecordingData.java

@@ -23,7 +23,7 @@ public RecordingInputStream getStream() throws IOException {
   }
 
   @Override
-  public void release() {
+  protected void doRelease() {
     try {
       Files.deleteIfExists(recordingFile);
     } catch (IOException e) {

dd-java-agent/agent-profiling/src/main/java/com/datadog/profiling/agent/CompositeController.java

@@ -117,7 +117,7 @@ public RecordingInputStream getStream() throws IOException {
     }
 
     @Override
-    public void release() {
+    protected void doRelease() {
       for (RecordingData data : data) {
         data.release();
       }

dd-trace-api/src/main/java/datadog/trace/api/config/ProfilingConfig.java

@@ -263,5 +263,19 @@ public final class ProfilingConfig {
   public static final String PROFILING_DETAILED_DEBUG_LOGGING = "profiling.detailed.debug.logging";
   public static final boolean PROFILING_DETAILED_DEBUG_LOGGING_DEFAULT = false;
 
+  // OTLP Profiles Format Support
+  public static final String PROFILING_OTLP_ENABLED = "profiling.otlp.enabled";
+  public static final boolean PROFILING_OTLP_ENABLED_DEFAULT = false;
+
+  public static final String PROFILING_OTLP_INCLUDE_ORIGINAL_PAYLOAD =
+      "profiling.otlp.include.original.payload";
+  public static final boolean PROFILING_OTLP_INCLUDE_ORIGINAL_PAYLOAD_DEFAULT = false;
+
+  public static final String PROFILING_OTLP_URL = "profiling.otlp.url";
+  public static final String PROFILING_OTLP_URL_DEFAULT = ""; // Empty = derive from agent URL
+
+  public static final String PROFILING_OTLP_COMPRESSION = "profiling.otlp.compression";
+  public static final String PROFILING_OTLP_COMPRESSION_DEFAULT = "gzip";
+
   private ProfilingConfig() {}
 }

internal-api/src/main/java/datadog/trace/api/profiling/RecordingData.java

@@ -18,6 +18,7 @@
 import java.io.IOException;
 import java.nio.file.Path;
 import java.time.Instant;
+import java.util.concurrent.atomic.AtomicInteger;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
@@ -27,6 +28,10 @@ public abstract class RecordingData implements ProfilingSnapshot {
   protected final Instant end;
   protected final Kind kind;
 
+  // Reference counting for multiple listeners
+  private final AtomicInteger refCount = new AtomicInteger(1); // Start at 1
+  private volatile boolean released = false;
+
   public RecordingData(final Instant start, final Instant end, Kind kind) {
     this.start = start;
     this.end = end;
@@ -40,10 +45,30 @@ public RecordingData(final Instant start, final Instant end, Kind kind) {
   @Nonnull
   public abstract RecordingInputStream getStream() throws IOException;
 
+  /**
+   * Increment reference count. Must be called before passing RecordingData to additional listeners
+   * beyond the first.
+   *
+   * @return this instance for chaining
+   * @throws IllegalStateException if the recording has already been released
+   */
+  @Nonnull
+  public final RecordingData retain() {
+    if (released) {
+      throw new IllegalStateException("Cannot retain released RecordingData");
+    }
+    refCount.incrementAndGet();
+    return this;
+  }
+
   /**
    * Releases the resources associated with the recording, for example the underlying file.
    *
-   * <p>Forgetting to releasing this when done streaming, will lead to one or more of the following:
+   * <p>This method uses reference counting to support multiple listeners. Each call to {@link
+   * #retain()} must be matched with a call to {@code release()}. The actual resource cleanup
+   * happens when the reference count reaches zero.
+   *
+   * <p>Forgetting to release this when done streaming will lead to one or more of the following:
    *
    * <ul>
    *   <li>Memory leak
@@ -52,7 +77,28 @@ public RecordingData(final Instant start, final Instant end, Kind kind) {
    *
    * <p>Please don't forget to call release when done streaming...
    */
-  public abstract void release();
+  public final void release() {
+    if (released) {
+      return; // Already released, no-op
+    }
+
+    int remaining = refCount.decrementAndGet();
+    if (remaining == 0) {
+      released = true;
+      doRelease();
+    } else if (remaining < 0) {
+      // Should never happen, but guard against it
+      throw new IllegalStateException("RecordingData over-released");
+    }
+  }
+
+  /**
+   * Actual resource cleanup implementation. Subclasses must override this method instead of {@link
+   * #release()}.
+   *
+   * <p>This method is called exactly once when the reference count reaches zero.
+   */
+  protected abstract void doRelease();
 
   /**
    * Returns the name of the recording from which the data is originating.