fix(csharp): address PR review feedback - test isolation, assertions, resource cleanup

Jade Wang · Jade Wang · commit ebb8f6c82274 · 2026-03-13T21:56:22.000Z
- Restore AsyncLocal for ExporterOverride to prevent parallel test interference
- Add missing IsInternalCall assertion in InternalCallTests
- Replace silent-pass with Skip.If when no telemetry captured in baseline tests
- Use await instead of .Result for async calls in MetadataOperationTests
- Add TimestampMillis to metadata operation telemetry Context
- Cache Process.GetCurrentProcess() call in BuildSystemConfiguration
- Move reader disposal to finally blocks in ChunkMetricsReaderTests

Co-authored-by: Isaac
diff --git a/csharp/src/DatabricksConnection.cs b/csharp/src/DatabricksConnection.cs
@@ -527,6 +527,10 @@ public override IArrowArrayStream GetObjects(
                             {
                                 WorkspaceId = telemetryContext.WorkspaceId,
                                 FrontendLogEventId = Guid.NewGuid().ToString(),
+                                Context = new Telemetry.Models.FrontendLogContext
+                                {
+                                    TimestampMillis = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+                                },
                                 Entry = new Telemetry.Models.FrontendLogEntry
                                 {
                                     SqlDriverLog = telemetryLog
@@ -639,6 +643,10 @@ public override IArrowArrayStream GetTableTypes()
                             {
                                 WorkspaceId = telemetryContext.WorkspaceId,
                                 FrontendLogEventId = Guid.NewGuid().ToString(),
+                                Context = new Telemetry.Models.FrontendLogContext
+                                {
+                                    TimestampMillis = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+                                },
                                 Entry = new Telemetry.Models.FrontendLogEntry
                                 {
                                     SqlDriverLog = telemetryLog
@@ -971,6 +979,7 @@ private void InitializeTelemetry(Activity? activity = null)
         private Telemetry.Proto.DriverSystemConfiguration BuildSystemConfiguration()
         {
             var osVersion = System.Environment.OSVersion;
+            var processName = System.Diagnostics.Process.GetCurrentProcess().ProcessName;
             return new Telemetry.Proto.DriverSystemConfiguration
             {
                 DriverVersion = s_assemblyVersion,
@@ -983,16 +992,16 @@ private Telemetry.Proto.DriverSystemConfiguration BuildSystemConfiguration()
                 RuntimeVendor = "Microsoft",
                 LocaleName = System.Globalization.CultureInfo.CurrentCulture.Name,
                 CharSetEncoding = System.Text.Encoding.Default.WebName,
-                ProcessName = System.Diagnostics.Process.GetCurrentProcess().ProcessName,
-                ClientAppName = GetClientAppName()
+                ProcessName = processName,
+                ClientAppName = GetClientAppName(processName)
             };
         }
 
-        private string GetClientAppName()
+        private string GetClientAppName(string processName)
         {
             // Check connection property first, fall back to process name
             Properties.TryGetValue("adbc.databricks.client_app_name", out string? appName);
-            return appName ?? Process.GetCurrentProcess().ProcessName;
+            return appName ?? processName;
         }
 
         private Telemetry.Proto.DriverConnectionParameters BuildDriverConnectionParams(bool isAuthenticated)
diff --git a/csharp/src/Telemetry/TelemetryClientManager.cs b/csharp/src/Telemetry/TelemetryClientManager.cs
@@ -15,6 +15,7 @@
 */
 
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace AdbcDrivers.Databricks.Telemetry
@@ -46,12 +47,19 @@ internal sealed class TelemetryClientManager
         private readonly Dictionary<string, TelemetryClientHolder> _clients = new Dictionary<string, TelemetryClientHolder>();
         private readonly object _lock = new object();
 
+        private static readonly AsyncLocal<ITelemetryExporter?> s_exporterOverride = new AsyncLocal<ITelemetryExporter?>();
+
         /// <summary>
         /// Optional exporter override for testing. When set, newly created TelemetryClients
         /// use this exporter instead of the default DatabricksTelemetryExporter pipeline.
+        /// Uses AsyncLocal to prevent interference across parallel xUnit test classes.
         /// Must be set before connections are opened and cleared after tests complete.
         /// </summary>
-        internal static ITelemetryExporter? ExporterOverride { get; set; }
+        internal static ITelemetryExporter? ExporterOverride
+        {
+            get => s_exporterOverride.Value;
+            set => s_exporterOverride.Value = value;
+        }
 
         /// <summary>
         /// Internal constructor. Public API uses GetInstance() for the singleton.
diff --git a/csharp/test/E2E/Telemetry/ChunkMetricsReaderTests.cs b/csharp/test/E2E/Telemetry/ChunkMetricsReaderTests.cs
@@ -21,6 +21,7 @@
 using AdbcDrivers.Databricks.Reader.CloudFetch;
 using Apache.Arrow.Adbc;
 using Apache.Arrow.Adbc.Tests;
+using Apache.Arrow.Ipc;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -47,6 +48,7 @@ public ChunkMetricsReaderTests(ITestOutputHelper? outputHelper)
         public async Task Reader_GetChunkMetrics_ReturnsNonNull()
         {
             AdbcConnection? connection = null;
+            Apache.Arrow.Ipc.IArrowArrayStream? reader = null;
 
             try
             {
@@ -67,7 +69,7 @@ public async Task Reader_GetChunkMetrics_ReturnsNonNull()
                 statement.SqlQuery = "SELECT * FROM range(1000000)";
 
                 var result = statement.ExecuteQuery();
-                var reader = result.Stream;
+                reader = result.Stream;
 
                 // Consume at least one batch to ensure chunks are downloaded
                 var batch = await reader.ReadNextRecordBatchAsync();
@@ -87,11 +89,10 @@ public async Task Reader_GetChunkMetrics_ReturnsNonNull()
 
                 Assert.NotNull(chunkMetrics);
                 OutputHelper?.WriteLine($"ChunkMetrics retrieved successfully from reader");
-
-                reader?.Dispose();
             }
             finally
             {
+                reader?.Dispose();
                 connection?.Dispose();
             }
         }
@@ -104,6 +105,7 @@ public async Task Reader_GetChunkMetrics_ReturnsNonNull()
         public async Task Reader_GetChunkMetrics_MatchesDownloaderValues()
         {
             AdbcConnection? connection = null;
+            Apache.Arrow.Ipc.IArrowArrayStream? reader = null;
 
             try
             {
@@ -121,7 +123,7 @@ public async Task Reader_GetChunkMetrics_MatchesDownloaderValues()
                 statement.SqlQuery = "SELECT * FROM range(1000000)";
 
                 var result = statement.ExecuteQuery();
-                var reader = result.Stream;
+                reader = result.Stream;
 
                 // Consume several batches to ensure multiple chunks are processed
                 int batchCount = 0;
@@ -166,11 +168,10 @@ public async Task Reader_GetChunkMetrics_MatchesDownloaderValues()
                 OutputHelper?.WriteLine($"  InitialChunkLatencyMs: {initialChunkLatencyMs}");
                 OutputHelper?.WriteLine($"  SlowestChunkLatencyMs: {slowestChunkLatencyMs}");
                 OutputHelper?.WriteLine($"  SumChunksDownloadTimeMs: {sumChunksDownloadTimeMs}");
-
-                reader?.Dispose();
             }
             finally
             {
+                reader?.Dispose();
                 connection?.Dispose();
             }
         }
@@ -183,6 +184,7 @@ public async Task Reader_GetChunkMetrics_MatchesDownloaderValues()
         public async Task Reader_GetChunkMetrics_AvailableAfterBatchConsumption()
         {
             AdbcConnection? connection = null;
+            Apache.Arrow.Ipc.IArrowArrayStream? reader = null;
 
             try
             {
@@ -200,7 +202,7 @@ public async Task Reader_GetChunkMetrics_AvailableAfterBatchConsumption()
                 statement.SqlQuery = "SELECT * FROM range(1000000)";
 
                 var result = statement.ExecuteQuery();
-                var reader = result.Stream;
+                reader = result.Stream;
 
                 // Act - Consume all batches
                 int totalBatches = 0;
@@ -235,11 +237,10 @@ public async Task Reader_GetChunkMetrics_AvailableAfterBatchConsumption()
                 OutputHelper?.WriteLine($"Metrics available after full consumption:");
                 OutputHelper?.WriteLine($"  TotalChunksPresent: {totalChunksPresent}");
                 OutputHelper?.WriteLine($"  TotalChunksIterated: {totalChunksIterated}");
-
-                reader?.Dispose();
             }
             finally
             {
+                reader?.Dispose();
                 connection?.Dispose();
             }
         }
@@ -253,6 +254,7 @@ public async Task Reader_GetChunkMetrics_AvailableAfterBatchConsumption()
         public async Task Reader_GetChunkMetrics_ReflectsPartialConsumption()
         {
             AdbcConnection? connection = null;
+            Apache.Arrow.Ipc.IArrowArrayStream? reader = null;
 
             try
             {
@@ -270,7 +272,7 @@ public async Task Reader_GetChunkMetrics_ReflectsPartialConsumption()
                 statement.SqlQuery = "SELECT * FROM range(2000000)"; // Large enough to ensure multiple chunks
 
                 var result = statement.ExecuteQuery();
-                var reader = result.Stream;
+                reader = result.Stream;
 
                 // Act - Consume only a few batches, not all
                 int batchesToConsume = 3;
@@ -306,11 +308,10 @@ public async Task Reader_GetChunkMetrics_ReflectsPartialConsumption()
                 OutputHelper?.WriteLine($"  Batches consumed: {batchCount}");
                 OutputHelper?.WriteLine($"  TotalChunksPresent: {totalChunksPresent}");
                 OutputHelper?.WriteLine($"  TotalChunksIterated: {totalChunksIterated}");
-
-                reader?.Dispose();
             }
             finally
             {
+                reader?.Dispose();
                 connection?.Dispose();
             }
         }
@@ -323,6 +324,7 @@ public async Task Reader_GetChunkMetrics_ReflectsPartialConsumption()
         public async Task Reader_GetChunkMetrics_ConsistentAcrossMultipleCalls()
         {
             AdbcConnection? connection = null;
+            Apache.Arrow.Ipc.IArrowArrayStream? reader = null;
 
             try
             {
@@ -338,7 +340,7 @@ public async Task Reader_GetChunkMetrics_ConsistentAcrossMultipleCalls()
                 statement.SqlQuery = "SELECT * FROM range(1000000)";
 
                 var result = statement.ExecuteQuery();
-                var reader = result.Stream;
+                reader = result.Stream;
 
                 // Consume some batches
                 var batch = await reader.ReadNextRecordBatchAsync();
@@ -367,11 +369,10 @@ public async Task Reader_GetChunkMetrics_ConsistentAcrossMultipleCalls()
                 Assert.Equal(iterated1, iterated2);
 
                 OutputHelper?.WriteLine("Metrics are consistent across multiple calls");
-
-                reader?.Dispose();
             }
             finally
             {
+                reader?.Dispose();
                 connection?.Dispose();
             }
         }
diff --git a/csharp/test/E2E/Telemetry/InternalCallTests.cs b/csharp/test/E2E/Telemetry/InternalCallTests.cs
@@ -86,8 +86,9 @@ public async Task InternalCall_UseSchema_IsMarkedAsInternal()
                     return protoLog.SqlOperation?.OperationDetail != null;
                 }).ToList();
 
-                // If there are multiple operations, check if any are internal
+                // Check if any operations are marked as internal
                 // Internal operations would have been from SetSchema()
+                bool foundInternalCall = false;
                 foreach (var log in useSchemaLogs)
                 {
                     var protoLog = TelemetryTestHelpers.GetProtoLog(log);
@@ -97,10 +98,18 @@ public async Task InternalCall_UseSchema_IsMarkedAsInternal()
                     {
                         OutputHelper?.WriteLine($"Found operation: StatementType={protoLog.SqlOperation.StatementType}, " +
                                               $"IsInternalCall={opDetail.IsInternalCall}");
+                        if (opDetail.IsInternalCall)
+                        {
+                            foundInternalCall = true;
+                        }
                     }
                 }
 
-                OutputHelper?.WriteLine($"✓ Captured {logs.Count} telemetry event(s)");
+                // Assert that at least one log entry has IsInternalCall set to true
+                Assert.True(foundInternalCall,
+                    "Expected at least one telemetry log entry with IsInternalCall == true from the internal USE SCHEMA operation");
+
+                OutputHelper?.WriteLine($"✓ Captured {logs.Count} telemetry event(s), found internal call: {foundInternalCall}");
             }
             finally
             {
diff --git a/csharp/test/E2E/Telemetry/MetadataOperationTests.cs b/csharp/test/E2E/Telemetry/MetadataOperationTests.cs
@@ -60,7 +60,7 @@ public async Task Telemetry_GetObjects_Catalogs_EmitsListCatalogs()
                     columnNamePattern: null);
 
                 // Consume the stream
-                while (stream.ReadNextRecordBatchAsync().Result != null) { }
+                while (await stream.ReadNextRecordBatchAsync() != null) { }
 
                 // Wait for telemetry events
                 var logs = await TelemetryTestHelpers.WaitForTelemetryEvents(exporter, expectedCount: 1, timeoutMs: 5000);
@@ -113,7 +113,7 @@ public async Task Telemetry_GetObjects_Schemas_EmitsListSchemas()
                     columnNamePattern: null);
 
                 // Consume the stream
-                while (stream.ReadNextRecordBatchAsync().Result != null) { }
+                while (await stream.ReadNextRecordBatchAsync() != null) { }
 
                 // Wait for telemetry events
                 var logs = await TelemetryTestHelpers.WaitForTelemetryEvents(exporter, expectedCount: 1, timeoutMs: 5000);
@@ -166,7 +166,7 @@ public async Task Telemetry_GetObjects_Tables_EmitsListTables()
                     columnNamePattern: null);
 
                 // Consume the stream
-                while (stream.ReadNextRecordBatchAsync().Result != null) { }
+                while (await stream.ReadNextRecordBatchAsync() != null) { }
 
                 // Wait for telemetry events
                 var logs = await TelemetryTestHelpers.WaitForTelemetryEvents(exporter, expectedCount: 1, timeoutMs: 5000);
@@ -219,7 +219,7 @@ public async Task Telemetry_GetObjects_Columns_EmitsListColumns()
                     columnNamePattern: null);
 
                 // Consume the stream
-                while (stream.ReadNextRecordBatchAsync().Result != null) { }
+                while (await stream.ReadNextRecordBatchAsync() != null) { }
 
                 // Wait for telemetry events
                 var logs = await TelemetryTestHelpers.WaitForTelemetryEvents(exporter, expectedCount: 1, timeoutMs: 5000);
@@ -266,7 +266,7 @@ public async Task Telemetry_GetTableTypes_EmitsListTableTypes()
                 using var stream = connection.GetTableTypes();
 
                 // Consume the stream
-                while (stream.ReadNextRecordBatchAsync().Result != null) { }
+                while (await stream.ReadNextRecordBatchAsync() != null) { }
 
                 // Wait for telemetry events
                 var logs = await TelemetryTestHelpers.WaitForTelemetryEvents(exporter, expectedCount: 1, timeoutMs: 5000);
@@ -331,7 +331,7 @@ public async Task Telemetry_GetObjects_AllDepths_EmitCorrectOperationType()
                         columnNamePattern: null);
 
                     // Consume the stream
-                    while (stream.ReadNextRecordBatchAsync().Result != null) { }
+                    while (await stream.ReadNextRecordBatchAsync() != null) { }
 
                     // Flush telemetry
                     if (connection is DatabricksConnection dbConn && dbConn.TelemetrySession?.TelemetryClient != null)
diff --git a/csharp/test/E2E/Telemetry/TelemetryBaselineTests.cs b/csharp/test/E2E/Telemetry/TelemetryBaselineTests.cs

Original file line number	Diff line number	Diff line change
`@@ -527,6 +527,10 @@ public override IArrowArrayStream GetObjects(`
`527`	`527`	`{`
`528`	`528`	`WorkspaceId = telemetryContext.WorkspaceId,`
`529`	`529`	`FrontendLogEventId = Guid.NewGuid().ToString(),`
	`530`	`+ Context = new Telemetry.Models.FrontendLogContext`
	`531`	`+ {`
	`532`	`+ TimestampMillis = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),`
	`533`	`+ },`
`530`	`534`	`Entry = new Telemetry.Models.FrontendLogEntry`
`531`	`535`	`{`
`532`	`536`	`SqlDriverLog = telemetryLog`
`@@ -639,6 +643,10 @@ public override IArrowArrayStream GetTableTypes()`
`639`	`643`	`{`
`640`	`644`	`WorkspaceId = telemetryContext.WorkspaceId,`
`641`	`645`	`FrontendLogEventId = Guid.NewGuid().ToString(),`
	`646`	`+ Context = new Telemetry.Models.FrontendLogContext`
	`647`	`+ {`
	`648`	`+ TimestampMillis = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),`
	`649`	`+ },`
`642`	`650`	`Entry = new Telemetry.Models.FrontendLogEntry`
`643`	`651`	`{`
`644`	`652`	`SqlDriverLog = telemetryLog`
`@@ -971,6 +979,7 @@ private void InitializeTelemetry(Activity? activity = null)`
`971`	`979`	`private Telemetry.Proto.DriverSystemConfiguration BuildSystemConfiguration()`
`972`	`980`	`{`
`973`	`981`	`var osVersion = System.Environment.OSVersion;`
	`982`	`+ var processName = System.Diagnostics.Process.GetCurrentProcess().ProcessName;`
`974`	`983`	`return new Telemetry.Proto.DriverSystemConfiguration`
`975`	`984`	`{`
`976`	`985`	`DriverVersion = s_assemblyVersion,`
`@@ -983,16 +992,16 @@ private Telemetry.Proto.DriverSystemConfiguration BuildSystemConfiguration()`
`983`	`992`	`RuntimeVendor = "Microsoft",`
`984`	`993`	`LocaleName = System.Globalization.CultureInfo.CurrentCulture.Name,`
`985`	`994`	`CharSetEncoding = System.Text.Encoding.Default.WebName,`
`986`		`- ProcessName = System.Diagnostics.Process.GetCurrentProcess().ProcessName,`
`987`		`- ClientAppName = GetClientAppName()`
	`995`	`+ ProcessName = processName,`
	`996`	`+ ClientAppName = GetClientAppName(processName)`
`988`	`997`	`};`
`989`	`998`	`}`
`990`	`999`
`991`		`- private string GetClientAppName()`
	`1000`	`+ private string GetClientAppName(string processName)`
`992`	`1001`	`{`
`993`	`1002`	`// Check connection property first, fall back to process name`
`994`	`1003`	`Properties.TryGetValue("adbc.databricks.client_app_name", out string? appName);`
`995`		`- return appName ?? Process.GetCurrentProcess().ProcessName;`
	`1004`	`+ return appName ?? processName;`
`996`	`1005`	`}`
`997`	`1006`
`998`	`1007`	`private Telemetry.Proto.DriverConnectionParameters BuildDriverConnectionParams(bool isAuthenticated)`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,7 @@`
`21`	`21`	`using AdbcDrivers.Databricks.Reader.CloudFetch;`
`22`	`22`	`using Apache.Arrow.Adbc;`
`23`	`23`	`using Apache.Arrow.Adbc.Tests;`
	`24`	`+using Apache.Arrow.Ipc;`
`24`	`25`	`using Xunit;`
`25`	`26`	`using Xunit.Abstractions;`
`26`	`27`
`@@ -47,6 +48,7 @@ public ChunkMetricsReaderTests(ITestOutputHelper? outputHelper)`
`47`	`48`	`public async Task Reader_GetChunkMetrics_ReturnsNonNull()`
`48`	`49`	`{`
`49`	`50`	`AdbcConnection? connection = null;`
	`51`	`+ Apache.Arrow.Ipc.IArrowArrayStream? reader = null;`
`50`	`52`
`51`	`53`	`try`
`52`	`54`	`{`
`@@ -67,7 +69,7 @@ public async Task Reader_GetChunkMetrics_ReturnsNonNull()`
`67`	`69`	`statement.SqlQuery = "SELECT * FROM range(1000000)";`
`68`	`70`
`69`	`71`	`var result = statement.ExecuteQuery();`
`70`		`- var reader = result.Stream;`
	`72`	`+ reader = result.Stream;`
`71`	`73`
`72`	`74`	`// Consume at least one batch to ensure chunks are downloaded`
`73`	`75`	`var batch = await reader.ReadNextRecordBatchAsync();`
`@@ -87,11 +89,10 @@ public async Task Reader_GetChunkMetrics_ReturnsNonNull()`
`87`	`89`
`88`	`90`	`Assert.NotNull(chunkMetrics);`
`89`	`91`	`OutputHelper?.WriteLine($"ChunkMetrics retrieved successfully from reader");`
`90`		`-`
`91`		`- reader?.Dispose();`
`92`	`92`	`}`
`93`	`93`	`finally`
`94`	`94`	`{`
	`95`	`+ reader?.Dispose();`
`95`	`96`	`connection?.Dispose();`
`96`	`97`	`}`
`97`	`98`	`}`
`@@ -104,6 +105,7 @@ public async Task Reader_GetChunkMetrics_ReturnsNonNull()`
`104`	`105`	`public async Task Reader_GetChunkMetrics_MatchesDownloaderValues()`
`105`	`106`	`{`
`106`	`107`	`AdbcConnection? connection = null;`
	`108`	`+ Apache.Arrow.Ipc.IArrowArrayStream? reader = null;`
`107`	`109`
`108`	`110`	`try`
`109`	`111`	`{`
`@@ -121,7 +123,7 @@ public async Task Reader_GetChunkMetrics_MatchesDownloaderValues()`
`121`	`123`	`statement.SqlQuery = "SELECT * FROM range(1000000)";`
`122`	`124`
`123`	`125`	`var result = statement.ExecuteQuery();`
`124`		`- var reader = result.Stream;`
	`126`	`+ reader = result.Stream;`
`125`	`127`
`126`	`128`	`// Consume several batches to ensure multiple chunks are processed`
`127`	`129`	`int batchCount = 0;`
`@@ -166,11 +168,10 @@ public async Task Reader_GetChunkMetrics_MatchesDownloaderValues()`
`166`	`168`	`OutputHelper?.WriteLine($" InitialChunkLatencyMs: {initialChunkLatencyMs}");`
`167`	`169`	`OutputHelper?.WriteLine($" SlowestChunkLatencyMs: {slowestChunkLatencyMs}");`
`168`	`170`	`OutputHelper?.WriteLine($" SumChunksDownloadTimeMs: {sumChunksDownloadTimeMs}");`
`169`		`-`
`170`		`- reader?.Dispose();`
`171`	`171`	`}`
`172`	`172`	`finally`
`173`	`173`	`{`
	`174`	`+ reader?.Dispose();`
`174`	`175`	`connection?.Dispose();`
`175`	`176`	`}`
`176`	`177`	`}`
`@@ -183,6 +184,7 @@ public async Task Reader_GetChunkMetrics_MatchesDownloaderValues()`
`183`	`184`	`public async Task Reader_GetChunkMetrics_AvailableAfterBatchConsumption()`
`184`	`185`	`{`
`185`	`186`	`AdbcConnection? connection = null;`
	`187`	`+ Apache.Arrow.Ipc.IArrowArrayStream? reader = null;`
`186`	`188`
`187`	`189`	`try`
`188`	`190`	`{`
`@@ -200,7 +202,7 @@ public async Task Reader_GetChunkMetrics_AvailableAfterBatchConsumption()`
`200`	`202`	`statement.SqlQuery = "SELECT * FROM range(1000000)";`
`201`	`203`
`202`	`204`	`var result = statement.ExecuteQuery();`
`203`		`- var reader = result.Stream;`
	`205`	`+ reader = result.Stream;`
`204`	`206`
`205`	`207`	`// Act - Consume all batches`
`206`	`208`	`int totalBatches = 0;`
`@@ -235,11 +237,10 @@ public async Task Reader_GetChunkMetrics_AvailableAfterBatchConsumption()`
`235`	`237`	`OutputHelper?.WriteLine($"Metrics available after full consumption:");`
`236`	`238`	`OutputHelper?.WriteLine($" TotalChunksPresent: {totalChunksPresent}");`
`237`	`239`	`OutputHelper?.WriteLine($" TotalChunksIterated: {totalChunksIterated}");`
`238`		`-`
`239`		`- reader?.Dispose();`
`240`	`240`	`}`
`241`	`241`	`finally`
`242`	`242`	`{`
	`243`	`+ reader?.Dispose();`
`243`	`244`	`connection?.Dispose();`
`244`	`245`	`}`
`245`	`246`	`}`
`@@ -253,6 +254,7 @@ public async Task Reader_GetChunkMetrics_AvailableAfterBatchConsumption()`
`253`	`254`	`public async Task Reader_GetChunkMetrics_ReflectsPartialConsumption()`
`254`	`255`	`{`
`255`	`256`	`AdbcConnection? connection = null;`
	`257`	`+ Apache.Arrow.Ipc.IArrowArrayStream? reader = null;`
`256`	`258`
`257`	`259`	`try`
`258`	`260`	`{`
`@@ -270,7 +272,7 @@ public async Task Reader_GetChunkMetrics_ReflectsPartialConsumption()`
`270`	`272`	`statement.SqlQuery = "SELECT * FROM range(2000000)"; // Large enough to ensure multiple chunks`
`271`	`273`
`272`	`274`	`var result = statement.ExecuteQuery();`
`273`		`- var reader = result.Stream;`
	`275`	`+ reader = result.Stream;`
`274`	`276`
`275`	`277`	`// Act - Consume only a few batches, not all`
`276`	`278`	`int batchesToConsume = 3;`
`@@ -306,11 +308,10 @@ public async Task Reader_GetChunkMetrics_ReflectsPartialConsumption()`
`306`	`308`	`OutputHelper?.WriteLine($" Batches consumed: {batchCount}");`
`307`	`309`	`OutputHelper?.WriteLine($" TotalChunksPresent: {totalChunksPresent}");`
`308`	`310`	`OutputHelper?.WriteLine($" TotalChunksIterated: {totalChunksIterated}");`
`309`		`-`
`310`		`- reader?.Dispose();`
`311`	`311`	`}`
`312`	`312`	`finally`
`313`	`313`	`{`
	`314`	`+ reader?.Dispose();`
`314`	`315`	`connection?.Dispose();`
`315`	`316`	`}`
`316`	`317`	`}`
`@@ -323,6 +324,7 @@ public async Task Reader_GetChunkMetrics_ReflectsPartialConsumption()`
`323`	`324`	`public async Task Reader_GetChunkMetrics_ConsistentAcrossMultipleCalls()`
`324`	`325`	`{`
`325`	`326`	`AdbcConnection? connection = null;`
	`327`	`+ Apache.Arrow.Ipc.IArrowArrayStream? reader = null;`
`326`	`328`
`327`	`329`	`try`
`328`	`330`	`{`
`@@ -338,7 +340,7 @@ public async Task Reader_GetChunkMetrics_ConsistentAcrossMultipleCalls()`
`338`	`340`	`statement.SqlQuery = "SELECT * FROM range(1000000)";`
`339`	`341`
`340`	`342`	`var result = statement.ExecuteQuery();`
`341`		`- var reader = result.Stream;`
	`343`	`+ reader = result.Stream;`
`342`	`344`
`343`	`345`	`// Consume some batches`
`344`	`346`	`var batch = await reader.ReadNextRecordBatchAsync();`
`@@ -367,11 +369,10 @@ public async Task Reader_GetChunkMetrics_ConsistentAcrossMultipleCalls()`
`367`	`369`	`Assert.Equal(iterated1, iterated2);`
`368`	`370`
`369`	`371`	`OutputHelper?.WriteLine("Metrics are consistent across multiple calls");`
`370`		`-`
`371`		`- reader?.Dispose();`
`372`	`372`	`}`
`373`	`373`	`finally`
`374`	`374`	`{`
	`375`	`+ reader?.Dispose();`
`375`	`376`	`connection?.Dispose();`
`376`	`377`	`}`
`377`	`378`	`}`
Original file line number	Diff line number	Diff line change
`@@ -86,8 +86,9 @@ public async Task InternalCall_UseSchema_IsMarkedAsInternal()`
`86`	`86`	`return protoLog.SqlOperation?.OperationDetail != null;`
`87`	`87`	`}).ToList();`
`88`	`88`
`89`		`- // If there are multiple operations, check if any are internal`
	`89`	`+ // Check if any operations are marked as internal`
`90`	`90`	`// Internal operations would have been from SetSchema()`
	`91`	`+ bool foundInternalCall = false;`
`91`	`92`	`foreach (var log in useSchemaLogs)`
`92`	`93`	`{`
`93`	`94`	`var protoLog = TelemetryTestHelpers.GetProtoLog(log);`
`@@ -97,10 +98,18 @@ public async Task InternalCall_UseSchema_IsMarkedAsInternal()`
`97`	`98`	`{`
`98`	`99`	`OutputHelper?.WriteLine($"Found operation: StatementType={protoLog.SqlOperation.StatementType}, " +`
`99`	`100`	`$"IsInternalCall={opDetail.IsInternalCall}");`
	`101`	`+ if (opDetail.IsInternalCall)`
	`102`	`+ {`
	`103`	`+ foundInternalCall = true;`
	`104`	`+ }`
`100`	`105`	`}`
`101`	`106`	`}`
`102`	`107`
`103`		`- OutputHelper?.WriteLine($"✓ Captured {logs.Count} telemetry event(s)");`
	`108`	`+ // Assert that at least one log entry has IsInternalCall set to true`
	`109`	`+ Assert.True(foundInternalCall,`
	`110`	`+ "Expected at least one telemetry log entry with IsInternalCall == true from the internal USE SCHEMA operation");`
	`111`	`+`
	`112`	`+ OutputHelper?.WriteLine($"✓ Captured {logs.Count} telemetry event(s), found internal call: {foundInternalCall}");`
`104`	`113`	`}`
`105`	`114`	`finally`
`106`	`115`	`{`