profiling(ddprof): fix two reapply ordering bugs found by PR review bots

- setContextValue: a rejected native write (e.g. >255-byte UTF-8) clears the
  native slot but left the Java snapshot untouched, so the attribute read as
  unset until the next span boundary silently resurrected the stale prior
  value. Reapply immediately on rejection so the prior value stays visible
  continuously, matching pre-migration DBB behavior.
- setTraceContext: reapplyAppContext() ran unconditionally after the native
  call, so when profiling.context.attributes also names
  _dd.trace.operation/resource (with span-name/resource-name context
  enabled), the trailing reapply clobbered the span-derived value that
  setTraceContext just wrote to the same offset with a stale app-recorded
  one. reapplyAppContext now takes the operation/resource offsets to skip.

Both were flagged independently by Codex and Datadog Autotest PR review bots
on #11899, with a concrete repro for the first. Added regression coverage to
DatadogProfilerTest#testContextRegistration for both (verified each new
assertion fails without its corresponding fix).

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

Author: rkennke

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

@@ -524,7 +524,11 @@ public void setTraceContext(
     } catch (Throwable e) {
       log.debug("Failed to set trace context", e);
     }
-    reapplyAppContext();
+    // Skip operationOffset/resourceOffset: setTraceContext just wrote the span-derived values
+    // there natively. If profiling.context.attributes also names _dd.trace.operation/resource,
+    // that offset is app-owned too (see isAppOffset); reapplying it here would immediately
+    // overwrite the fresh span-derived value with a stale app-recorded one.
+    reapplyAppContext(operationOffset, resourceOffset);
   }
 
   /** Per-deactivation clear; reapplies app-managed attributes afterwards (see setTraceContext). */
@@ -555,6 +559,10 @@ public boolean setContextValue(int offset, String value) {
           recordAppContextValue(offset, value);
           return true;
         }
+        // Rejected (e.g. >255-byte UTF-8, dictionary full): the native call already cleared this
+        // slot. Restore it from the still-current Java snapshot so a rejected write doesn't blank
+        // the attribute until the next span boundary.
+        reapplyAppContext();
       } catch (Throwable e) {
         log.debug("Failed to set context value", e);
       }
@@ -615,6 +623,16 @@ public boolean clearContextValue(int offset) {
    * (java-profiler PROF-15361); per-slot is adequate for the typical small app-attribute count.
    */
   public void reapplyAppContext() {
+    reapplyAppContext(-1, -1);
+  }
+
+  /**
+   * Same as {@link #reapplyAppContext()}, but leaves {@code skipOffset1}/{@code skipOffset2} alone.
+   * Used by {@link #setTraceContext} to avoid clobbering the operation/resource offsets it just
+   * wrote natively, in the edge case where those offsets are also app-owned (see {@link
+   * #isAppOffset}). Pass -1 for either argument to skip nothing.
+   */
+  private void reapplyAppContext(int skipOffset1, int skipOffset2) {
     if (!hasAppContext) {
       return;
     }
@@ -625,6 +643,9 @@ public void reapplyAppContext() {
     try {
       int remaining = snapshot.nonZeroCount();
       for (int i = 0; i < isAppOffset.length && remaining > 0; i++) {
+        if (i == skipOffset1 || i == skipOffset2) {
+          continue;
+        }
         String s = snapshot.stringAt(i);
         if (s != null) {
           profiler.setContextValue(i, s);

dd-java-agent/agent-profiling/profiling-ddprof/src/test/java/com/datadog/profiling/ddprof/DatadogProfilerTest.java

@@ -478,6 +478,54 @@ public void testContextRegistration() {
         profiler.snapshot()[fooOffset],
         "Guard: zero-span activation must degrade to a clean clear that still reapplies app context");
     profiler.clearContextValue("foo");
+
+    // Regression: a native setContextValue rejection (e.g. an oversized value, >255 UTF-8 bytes)
+    // clears the native slot; the prior value must be resynced immediately instead of only
+    // reappearing on the next span boundary (a flicker the pre-migration DBB path never had,
+    // since it retained the prior value continuously).
+    fooSetter.set("valid-before-reject");
+    int validEncoding = profiler.snapshot()[fooOffset];
+    assertNotEquals(0, validEncoding, "foo must be live before the rejected write");
+    StringBuilder oversized = new StringBuilder();
+    for (int i = 0; i < 300; i++) {
+      oversized.append('x');
+    }
+    assertFalse(
+        profiler.setContextValue("foo", oversized.toString()),
+        "an oversized (>255 UTF-8 bytes) value must be rejected");
+    assertEquals(
+        validEncoding,
+        profiler.snapshot()[fooOffset],
+        "a rejected write must not blank the slot; the prior value must stay visible immediately");
+    profiler.clearContextValue("foo");
+
+    // Regression: setTraceContext's trailing reapplyAppContext must not clobber the span-derived
+    // value it just wrote natively to operationOffset/resourceOffset, even when that offset is
+    // also app-owned (e.g. profiling.context.attributes names _dd.trace.operation/resource while
+    // span-name/resource-name context is enabled). Reuses the "foo" app-owned offset as a stand-in
+    // operationOffset — the profiler is a process-wide singleton and its context attributes can't
+    // be reconfigured to register the real _dd.trace.operation/resource offsets here.
+    profiler.setContextValue(fooOffset, "span-derived-value");
+    int spanDerivedEncoding = profiler.snapshot()[fooOffset];
+    assertNotEquals(0, spanDerivedEncoding, "fixture sanity: span-derived value must be live");
+    profiler.clearContextValue("foo");
+
+    fooSetter.set("stale-app-value");
+    int appEncoding = profiler.snapshot()[fooOffset];
+    assertNotEquals(0, appEncoding, "foo app value must be recorded before the trace-context call");
+    assertNotEquals(
+        spanDerivedEncoding,
+        appEncoding,
+        "fixture sanity: span-derived and app values must have distinct encodings");
+
+    profiler.setTraceContext(1L, 1L, 0L, 1L, fooOffset, "span-derived-value", -1, null);
+    assertEquals(
+        spanDerivedEncoding,
+        profiler.snapshot()[fooOffset],
+        "setTraceContext's trailing reapplyAppContext must skip operationOffset/resourceOffset so"
+            + " it doesn't overwrite the span-derived value just written to an app-owned offset");
+    profiler.clearSpanContext();
+    profiler.clearContextValue("foo");
   }
 
   private static ConfigProvider configProvider(