feat(csharp): add statement-level trace parent support (#3896)

## Summary

Enable setting trace parent at the statement level for connection
pooling scenarios like Power BI, where multiple queries reuse the same
connection but need different trace IDs for distributed tracing.

## Changes

- **TracingStatement**: Add `_statementTraceParent` field and
`SetTraceParent()` method
- **TracingStatement**: `TraceParent` property now returns statement
override or falls back to connection's trace parent
- **HiveServer2Statement**: Add `SetOption` case for
`AdbcOptions.Telemetry.TraceParent`
- Add comprehensive test coverage for statement-level trace parent
functionality

## Motivation

This brings C# implementation to parity with Go drivers which already
support statement-level trace parent via `SetOption`.

### Power BI Use Case

Power BI uses connection pooling where multiple queries reuse the same
connection. Each Power BI query has its own trace ID for distributed
tracing correlation. Without statement-level trace parent support, all
queries from a pooled connection would share the same trace context,
making it impossible to correlate individual query traces.

With this change, Power BI can:
```csharp
var connection = pool.GetConnection();

// Query 1 with Trace ID A
var stmt1 = connection.CreateStatement();
stmt1.SetOption("adbc.telemetry.trace_parent", powerBiQueryTraceIdA);
stmt1.ExecuteQuery();

// Query 2 with Trace ID B (same connection!)
var stmt2 = connection.CreateStatement();
stmt2.SetOption("adbc.telemetry.trace_parent", powerBiQueryTraceIdB);
stmt2.ExecuteQuery();
```

## Test Plan

Added `CanSetTraceParentOnStatement` test that verifies:
1. Statement inherits connection's trace parent by default
2. Statement can override with its own trace parent via `SetOption`
3. Activities created by the statement use the statement's trace parent
4. Setting trace parent to null falls back to connection's trace parent

All existing tests pass.

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

Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: eric-wang-1990

csharp/src/Apache.Arrow.Adbc/Tracing/TracingStatement.cs

@@ -22,6 +22,7 @@ namespace Apache.Arrow.Adbc.Tracing
     public abstract class TracingStatement : AdbcStatement, ITracingStatement
     {
         private readonly ActivityTrace _trace;
+        private string? _statementTraceParent;
 
         public TracingStatement(TracingConnection connection)
         {
@@ -30,7 +31,12 @@ public TracingStatement(TracingConnection connection)
 
         ActivityTrace IActivityTracer.Trace => _trace;
 
-        string? IActivityTracer.TraceParent => _trace.TraceParent;
+        string? IActivityTracer.TraceParent => _statementTraceParent ?? _trace.TraceParent;
+
+        protected void SetTraceParent(string? traceParent)
+        {
+            _statementTraceParent = traceParent;
+        }
 
         public abstract string AssemblyVersion { get; }
 

csharp/src/Drivers/Apache/Hive2/HiveServer2Statement.cs

@@ -319,6 +319,9 @@ public override void SetOption(string key, string value)
                         this.EscapePatternWildcards = escapePatternWildcards;
                     }
                     break;
+                case AdbcOptions.Telemetry.TraceParent:
+                    SetTraceParent(string.IsNullOrWhiteSpace(value) ? null : value);
+                    break;
                 default:
                     throw AdbcException.NotImplemented($"Option '{key}' is not implemented.");
             }

csharp/test/Apache.Arrow.Adbc.Tests/Tracing/TracingTests.cs

@@ -255,6 +255,57 @@ internal async Task CanDetectInvalidAsyncCall()
             }
         }
 
+        [Fact]
+        internal void CanSetTraceParentOnStatement()
+        {
+            string activitySourceName = NewName();
+            Queue<Activity> exportedActivities = new();
+            using TracerProvider provider = Sdk.CreateTracerProviderBuilder()
+                .AddSource(activitySourceName)
+                .AddTestActivityQueueExporter(exportedActivities)
+                .Build();
+
+            // Create a connection with a connection-level trace parent
+            const string connectionTraceParent = "00-11111111111111111111111111111111-2222222222222222-01";
+            var connection = new MyTracingConnection(
+                new Dictionary<string, string> { { AdbcOptions.Telemetry.TraceParent, connectionTraceParent } },
+                activitySourceName);
+
+            // Create a statement and verify it uses the connection's trace parent
+            var statement = new MyTracingStatement(connection);
+            Assert.Equal(connectionTraceParent, ((IActivityTracer)statement).TraceParent);
+
+            // Test 1: Execute with connection's trace parent
+            string eventName1 = NewName();
+            statement.MethodWithActivity(eventName1);
+            Assert.Single(exportedActivities);
+            var activity1 = exportedActivities.First();
+            Assert.Equal(connectionTraceParent, activity1.ParentId);
+
+            // Test 2: Set statement-specific trace parent
+            exportedActivities.Clear();
+            const string statementTraceParent = "00-33333333333333333333333333333333-4444444444444444-01";
+            statement.SetOption(AdbcOptions.Telemetry.TraceParent, statementTraceParent);
+            Assert.Equal(statementTraceParent, ((IActivityTracer)statement).TraceParent);
+
+            string eventName2 = NewName();
+            statement.MethodWithActivity(eventName2);
+            Assert.Single(exportedActivities);
+            var activity2 = exportedActivities.First();
+            Assert.Equal(statementTraceParent, activity2.ParentId);
+
+            // Test 3: Set trace parent to null (should fall back to connection's trace parent)
+            exportedActivities.Clear();
+            statement.SetOption(AdbcOptions.Telemetry.TraceParent, null);
+            Assert.Equal(connectionTraceParent, ((IActivityTracer)statement).TraceParent);
+
+            string eventName3 = NewName();
+            statement.MethodWithActivity(eventName3);
+            Assert.Single(exportedActivities);
+            var activity3 = exportedActivities.First();
+            Assert.Equal(connectionTraceParent, activity3.ParentId);
+        }
+
         internal static string NewName() => Guid.NewGuid().ToString().Replace("-", "").ToLower();
 
         protected virtual void Dispose(bool disposing)
@@ -451,6 +502,33 @@ public void OnCompleted(Action continuation)
             public override IArrowArrayStream GetTableTypes() => throw new NotImplementedException();
         }
 
+        private class MyTracingStatement(TracingConnection connection) : TracingStatement(connection)
+        {
+            public override string AssemblyVersion => "1.0.0";
+            public override string AssemblyName => "TestStatement";
+
+            public void MethodWithActivity(string activityName)
+            {
+                this.TraceActivity(activity =>
+                {
+                    activity?.AddTag("testTag", "testValue");
+                }, activityName);
+            }
+
+            public override void SetOption(string key, string? value)
+            {
+                if (key == AdbcOptions.Telemetry.TraceParent)
+                {
+                    SetTraceParent(string.IsNullOrWhiteSpace(value) ? null : value);
+                    return;
+                }
+                throw AdbcException.NotImplemented($"Option '{key}' is not implemented.");
+            }
+
+            public override QueryResult ExecuteQuery() => throw new NotImplementedException();
+            public override UpdateResult ExecuteUpdate() => throw new NotImplementedException();
+        }
+
         internal class ActivityQueueExporter(Queue<Activity> exportedActivities) : BaseExporter<Activity>
         {
             private Queue<Activity> ExportedActivities { get; } = exportedActivities;