feat(profiling): Add OTLP profiles core infrastructure

Add profiling-otel module with core infrastructure for JFR to OTLP
profiles conversion:

- Dictionary tables for OTLP compression (StringTable, FunctionTable,
  LocationTable, StackTable, LinkTable, AttributeTable)
- ProtobufEncoder for hand-coded protobuf wire format encoding
- OtlpProtoFields constants for OTLP profiles proto field numbers
- Unit tests for all dictionary tables and encoder
- Architecture documentation

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

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

Author: jbachorik

dd-java-agent/agent-profiling/profiling-otel/build.gradle.kts

@@ -0,0 +1,13 @@
+plugins {
+  `java-library`
+}
+
+apply(from = "$rootDir/gradle/java.gradle")
+
+dependencies {
+  implementation("io.btrace", "jafar-parser", "0.0.1-SNAPSHOT")
+  implementation(project(":internal-api"))
+
+  testImplementation(libs.bundles.junit5)
+  testImplementation(libs.bundles.jmc)
+}

dd-java-agent/agent-profiling/profiling-otel/doc/ARCHITECTURE.md

@@ -0,0 +1,137 @@
+# OTLP Profiles Writer - Architecture & Implementation Journal
+
+## Overview
+
+This module provides a JFR to OTLP/profiles format converter. It reads JFR recordings via the `RecordingData` abstraction and produces OTLP-compliant profile data in both binary protobuf and JSON formats.
+
+## OTLP Profiles Format
+
+Based on: https://github.com/open-telemetry/opentelemetry-proto/blob/main/opentelemetry/proto/profiles/v1development/profiles.proto
+
+### Key Architectural Concepts
+
+1. **Dictionary-based Compression**: OTLP profiles use shared dictionary tables to minimize wire size. All repeated data (strings, functions, locations, stacks, links, attributes) is stored once in dictionary tables and referenced by integer indices.
+
+2. **Index 0 Semantics**: In all dictionary tables, index 0 is reserved for "null/unset" values. Index 0 should never be dereferenced - it represents the absence of a value.
+
+3. **Sample Identity**: A sample's identity is the tuple `{stack_index, set_of(attribute_indices), link_index}`. Samples with the same identity should be aggregated.
+
+### Message Hierarchy
+
+```
+ProfilesData
+├── dictionary: ProfilesDictionary (shared across all profiles)
+│   ├── string_table[]      - interned strings
+│   ├── function_table[]    - function metadata
+│   ├── location_table[]    - stack frame locations
+│   ├── mapping_table[]     - binary/library mappings
+│   ├── stack_table[]       - call stacks (arrays of location indices)
+│   ├── link_table[]        - trace context links
+│   └── attribute_table[]   - key-value attributes
+│
+└── resource_profiles[]
+    └── scope_profiles[]
+        └── profiles[]
+            ├── sample_type: ValueType
+            ├── period_type: ValueType
+            ├── samples[]
+            │   ├── stack_index      -> stack_table
+            │   ├── attribute_indices[] -> attribute_table
+            │   ├── link_index       -> link_table
+            │   ├── values[]
+            │   └── timestamps_unix_nano[]
+            └── time_unix_nano, duration_nano, profile_id, etc.
+```
+
+## Package Structure
+
+```
+com.datadog.profiling.otel/
+├── dictionary/           # Dictionary table implementations
+│   ├── StringTable       # String interning
+│   ├── FunctionTable     # Function deduplication
+│   ├── LocationTable     # Stack frame deduplication
+│   ├── StackTable        # Call stack deduplication
+│   ├── LinkTable         # Trace link deduplication
+│   └── AttributeTable    # Attribute deduplication
+│
+├── proto/                # Protobuf encoding
+│   ├── ProtobufEncoder   # Wire format encoder
+│   └── OtlpProtoFields   # Field number constants
+│
+└── (future: converter, writer classes)
+```
+
+## JFR Event to OTLP Mapping
+
+| JFR Event Type | OTLP Profile Type | Value Type | Unit |
+|----------------|-------------------|------------|------|
+| `datadog.ExecutionSample` | cpu | count | samples |
+| `datadog.MethodSample` | wall | count | samples |
+| `datadog.ObjectSample` | alloc-samples | bytes | bytes |
+| `jdk.JavaMonitorEnter` | lock-contention | duration | nanoseconds |
+| `jdk.JavaMonitorWait` | lock-contention | duration | nanoseconds |
+
+## Implementation Details
+
+### Phase 1: Core Infrastructure (Completed)
+
+#### Dictionary Tables
+
+All dictionary tables follow a common pattern:
+- Index 0 reserved for null/unset (pre-populated in constructor)
+- `intern()` method returns existing index or adds new entry
+- `get()` method retrieves entry by index
+- `reset()` method clears table to initial state
+- HashMap-based deduplication for O(1) lookup
+
+**StringTable**: Simple string interning. Null and empty strings map to index 0.
+
+**FunctionTable**: Functions identified by composite key (nameIndex, systemNameIndex, filenameIndex, startLine). All indices reference StringTable.
+
+**LocationTable**: Locations represent stack frames. Key is (mappingIndex, address, functionIndex, line, column). Supports multiple Line entries for inlined functions.
+
+**StackTable**: Stacks are arrays of location indices. Uses Arrays.hashCode/equals for array-based key comparison. Makes defensive copies of input arrays.
+
+**LinkTable**: Links connect samples to trace spans. Stores 16-byte traceId and 8-byte spanId. Provides convenience method for 64-bit DD trace/span IDs.
+
+**AttributeTable**: Supports STRING, BOOL, INT, DOUBLE value types. Key includes (keyIndex, valueType, value, unitIndex).
+
+#### ProtobufEncoder
+
+Hand-coded protobuf wire format encoder without external dependencies:
+
+- **Wire Types**: VARINT (0), FIXED64 (1), LENGTH_DELIMITED (2), FIXED32 (5)
+- **Varint Encoding**: Variable-length integers, 7 bits per byte, MSB indicates continuation
+- **ZigZag Encoding**: For signed varints, maps negative numbers to positive
+- **Fixed Encoding**: Little-endian for fixed32/fixed64
+- **Length-Delimited**: Length prefix (varint) followed by content
+- **Nested Messages**: Written to temporary buffer to compute length first
+
+Key methods:
+- `writeVarint()`, `writeFixed64()`, `writeFixed32()`
+- `writeTag()` - combines field number and wire type
+- `writeString()`, `writeBytes()` - length-delimited
+- `writeNestedMessage()` - for sub-messages
+- `writePackedVarintField()`, `writePackedFixed64Field()` - for repeated fields
+
+#### OtlpProtoFields
+
+Constants for all OTLP protobuf field numbers, organized by message type. Enables type-safe field references without magic numbers.
+
+### Phase 2: JFR Parsing & CPU Profile (In Progress)
+
+(To be documented as implementation progresses)
+
+## Testing Strategy
+
+- **Unit Tests**: Each dictionary table and encoder method tested independently
+- **Integration Tests**: End-to-end conversion with JMC JFR Writer API for creating test recordings
+- **Round-trip Validation**: Verify protobuf output can be parsed correctly
+
+## Dependencies
+
+- `jafar-parser` - JFR parsing library
+- `internal-api` - RecordingData abstraction
+- `libs.bundles.jmc` - JMC libraries for test JFR creation (test scope)
+- `libs.bundles.junit5` - Testing framework (test scope)

dd-java-agent/agent-profiling/profiling-otel/src/main/java/com/datadog/profiling/otel/dictionary/AttributeTable.java

@@ -0,0 +1,203 @@
+package com.datadog.profiling.otel.dictionary;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Attribute deduplication table for OTLP profiles. Index 0 is reserved for the null/unset
+ * attribute. Attributes are key-value pairs with optional unit.
+ */
+public final class AttributeTable {
+
+  /** Attribute value types. */
+  public enum ValueType {
+    STRING,
+    BOOL,
+    INT,
+    DOUBLE
+  }
+
+  /** Immutable key for attribute lookup. */
+  private static final class AttributeKey {
+    final int keyIndex;
+    final ValueType valueType;
+    final Object value;
+    final int unitIndex;
+
+    AttributeKey(int keyIndex, ValueType valueType, Object value, int unitIndex) {
+      this.keyIndex = keyIndex;
+      this.valueType = valueType;
+      this.value = value;
+      this.unitIndex = unitIndex;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) return true;
+      if (o == null || getClass() != o.getClass()) return false;
+      AttributeKey that = (AttributeKey) o;
+      return keyIndex == that.keyIndex
+          && unitIndex == that.unitIndex
+          && valueType == that.valueType
+          && Objects.equals(value, that.value);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(keyIndex, valueType, value, unitIndex);
+    }
+  }
+
+  /** Attribute entry stored in the table. */
+  public static final class AttributeEntry {
+    public final int keyIndex;
+    public final ValueType valueType;
+    public final Object value;
+    public final int unitIndex;
+
+    AttributeEntry(int keyIndex, ValueType valueType, Object value, int unitIndex) {
+      this.keyIndex = keyIndex;
+      this.valueType = valueType;
+      this.value = value;
+      this.unitIndex = unitIndex;
+    }
+
+    public String getStringValue() {
+      return valueType == ValueType.STRING ? (String) value : null;
+    }
+
+    public Boolean getBoolValue() {
+      return valueType == ValueType.BOOL ? (Boolean) value : null;
+    }
+
+    public Long getIntValue() {
+      return valueType == ValueType.INT ? (Long) value : null;
+    }
+
+    public Double getDoubleValue() {
+      return valueType == ValueType.DOUBLE ? (Double) value : null;
+    }
+  }
+
+  private final List<AttributeEntry> attributes;
+  private final Map<AttributeKey, Integer> attributeToIndex;
+
+  public AttributeTable() {
+    attributes = new ArrayList<>();
+    attributeToIndex = new HashMap<>();
+    // Index 0 is reserved for null/unset attribute
+    attributes.add(new AttributeEntry(0, ValueType.STRING, "", 0));
+  }
+
+  /**
+   * Interns a string attribute and returns its index.
+   *
+   * @param keyIndex index into string table for attribute key
+   * @param value string value
+   * @param unitIndex index into string table for unit (0 = no unit)
+   * @return the index of the interned attribute
+   */
+  public int internString(int keyIndex, String value, int unitIndex) {
+    if (keyIndex == 0) {
+      return 0;
+    }
+    return intern(keyIndex, ValueType.STRING, value, unitIndex);
+  }
+
+  /**
+   * Interns a boolean attribute and returns its index.
+   *
+   * @param keyIndex index into string table for attribute key
+   * @param value boolean value
+   * @param unitIndex index into string table for unit (0 = no unit)
+   * @return the index of the interned attribute
+   */
+  public int internBool(int keyIndex, boolean value, int unitIndex) {
+    if (keyIndex == 0) {
+      return 0;
+    }
+    return intern(keyIndex, ValueType.BOOL, value, unitIndex);
+  }
+
+  /**
+   * Interns an integer attribute and returns its index.
+   *
+   * @param keyIndex index into string table for attribute key
+   * @param value integer value
+   * @param unitIndex index into string table for unit (0 = no unit)
+   * @return the index of the interned attribute
+   */
+  public int internInt(int keyIndex, long value, int unitIndex) {
+    if (keyIndex == 0) {
+      return 0;
+    }
+    return intern(keyIndex, ValueType.INT, value, unitIndex);
+  }
+
+  /**
+   * Interns a double attribute and returns its index.
+   *
+   * @param keyIndex index into string table for attribute key
+   * @param value double value
+   * @param unitIndex index into string table for unit (0 = no unit)
+   * @return the index of the interned attribute
+   */
+  public int internDouble(int keyIndex, double value, int unitIndex) {
+    if (keyIndex == 0) {
+      return 0;
+    }
+    return intern(keyIndex, ValueType.DOUBLE, value, unitIndex);
+  }
+
+  private int intern(int keyIndex, ValueType valueType, Object value, int unitIndex) {
+    AttributeKey key = new AttributeKey(keyIndex, valueType, value, unitIndex);
+    Integer existing = attributeToIndex.get(key);
+    if (existing != null) {
+      return existing;
+    }
+
+    int index = attributes.size();
+    attributes.add(new AttributeEntry(keyIndex, valueType, value, unitIndex));
+    attributeToIndex.put(key, index);
+    return index;
+  }
+
+  /**
+   * Returns the attribute entry at the given index.
+   *
+   * @param index the index
+   * @return the attribute entry
+   * @throws IndexOutOfBoundsException if index is out of bounds
+   */
+  public AttributeEntry get(int index) {
+    return attributes.get(index);
+  }
+
+  /**
+   * Returns the number of attributes (including the null attribute at index 0).
+   *
+   * @return the size of the attribute table
+   */
+  public int size() {
+    return attributes.size();
+  }
+
+  /**
+   * Returns the list of all attribute entries.
+   *
+   * @return the list of attribute entries
+   */
+  public List<AttributeEntry> getAttributes() {
+    return attributes;
+  }
+
+  /** Resets the table to its initial state with only the null attribute at index 0. */
+  public void reset() {
+    attributes.clear();
+    attributeToIndex.clear();
+    attributes.add(new AttributeEntry(0, ValueType.STRING, "", 0));
+  }
+}