Add experimental GitHub telemetry redirection across all SDKs

dotnet/src/Client.cs

@@ -8,6 +8,7 @@
 using Microsoft.Extensions.Logging.Abstractions;
 using System.Collections.Concurrent;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Net.Sockets;
 using System.Runtime.ExceptionServices;
@@ -1037,7 +1038,8 @@
                 Providers: config.Providers,
                 Models: config.Models,
                 ToolFilterPrecedence: toolFilter.ToolFilterPrecedence,
-                ExpAssignments: config.ExpAssignments);
+                ExpAssignments: config.ExpAssignments,
+                EnableGitHubTelemetryForwarding: _options.OnGitHubTelemetry != null ? true : null);
 
             var rpcTimestamp = Stopwatch.GetTimestamp();
 
@@ -1246,7 +1248,8 @@
                 Providers: config.Providers,
                 Models: config.Models,
                 ToolFilterPrecedence: toolFilter.ToolFilterPrecedence,
-                ExpAssignments: config.ExpAssignments);
+                ExpAssignments: config.ExpAssignments,
+                EnableGitHubTelemetryForwarding: _options.OnGitHubTelemetry != null ? true : null);
 
             var rpcTimestamp = Stopwatch.GetTimestamp();
             var response = await InvokeRpcAsync<ResumeSessionResponse>(
@@ -1724,21 +1727,24 @@
     }
 
     /// <summary>
-    /// Builds the client-global RPC handler bag at construction time. Currently
-    /// only the LLM inference provider adapter is registered; returns null when no
+    /// Builds the client-global RPC handler bag at construction time. Registers
+    /// the LLM inference provider adapter and/or the GitHub telemetry adapter
+    /// depending on which options are configured; returns null when no
     /// client-global API is configured so the registration is skipped entirely.
     /// </summary>
     private ClientGlobalApiHandlers? BuildClientGlobalApis()
     {
         var handler = _options.RequestHandler;
-        if (handler is null)
+        var onGitHubTelemetry = _options.OnGitHubTelemetry;
+        if (handler is null && onGitHubTelemetry is null)
         {
             return null;
         }
 
         return new ClientGlobalApiHandlers
         {
-            LlmInference = new LlmInferenceAdapter(handler, () => _serverRpc),
+            LlmInference = handler is null ? null : new LlmInferenceAdapter(handler, () => _serverRpc),
+            GitHubTelemetry = onGitHubTelemetry is null ? null : new GitHubTelemetryAdapter(onGitHubTelemetry, _logger),
         };
     }
 
@@ -2495,7 +2501,8 @@
         IList<NamedProviderConfig>? Providers = null,
         IList<ProviderModelConfig>? Models = null,
         OptionsUpdateToolFilterPrecedence? ToolFilterPrecedence = null,
-        [property: JsonPropertyName("expAssignments")] JsonElement? ExpAssignments = null);
+        [property: JsonPropertyName("expAssignments")] JsonElement? ExpAssignments = null,
+        bool? EnableGitHubTelemetryForwarding = null);
 #pragma warning restore GHCP001
 
     internal record ToolDefinition(
@@ -2594,7 +2601,8 @@
         IList<NamedProviderConfig>? Providers = null,
         IList<ProviderModelConfig>? Models = null,
         OptionsUpdateToolFilterPrecedence? ToolFilterPrecedence = null,
-        [property: JsonPropertyName("expAssignments")] JsonElement? ExpAssignments = null);
+        [property: JsonPropertyName("expAssignments")] JsonElement? ExpAssignments = null,
+        bool? EnableGitHubTelemetryForwarding = null);
 #pragma warning restore GHCP001
 
     internal record ResumeSessionResponse(
@@ -2713,3 +2721,29 @@
     /// </summary>
     public ToolResultObject Result => toolResult;
 }
+
+/// <summary>
+/// Bridges the generated <see cref="Rpc.IGitHubTelemetryHandler"/> client-global handler to
+/// the public <c>OnGitHubTelemetry</c> callback, forwarding the generated
+/// <see cref="Rpc.GitHubTelemetryNotification"/> payload unchanged.
+/// </summary>
+[Experimental(Diagnostics.Experimental)]
+internal sealed class GitHubTelemetryAdapter(Action<Rpc.GitHubTelemetryNotification> callback, ILogger logger) : Rpc.IGitHubTelemetryHandler
+{
+    private readonly Action<Rpc.GitHubTelemetryNotification> _callback = callback ?? throw new ArgumentNullException(nameof(callback));
+    private readonly ILogger _logger = logger ?? NullLogger.Instance;
+
+    public Task EventAsync(Rpc.GitHubTelemetryNotification request, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(request);
+        try
+        {
+            _callback(request);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Error handling gitHubTelemetry.event notification");
+        }
+        return Task.CompletedTask;
+    }
+}

dotnet/src/Types.cs

@@ -281,6 +281,7 @@ private CopilotClientOptions(CopilotClientOptions? other)
         OnListModels = other.OnListModels;
         SessionFs = other.SessionFs;
         RequestHandler = other.RequestHandler;
+        OnGitHubTelemetry = other.OnGitHubTelemetry;
         SessionIdleTimeoutSeconds = other.SessionIdleTimeoutSeconds;
         EnableRemoteSessions = other.EnableRemoteSessions;
         Mode = other.Mode;
@@ -378,6 +379,14 @@ private CopilotClientOptions(CopilotClientOptions? other)
     [Experimental(Diagnostics.Experimental)]
     public CopilotRequestHandler? RequestHandler { get; set; }
 
+    /// <summary>
+    /// Experimental. Receives GitHub telemetry events the runtime forwards to this
+    /// connection; setting a handler opts created/resumed sessions into forwarding.
+    /// </summary>
+    [Experimental(Diagnostics.Experimental)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public Action<Rpc.GitHubTelemetryNotification>? OnGitHubTelemetry { get; set; }
+
     /// <summary>
     /// OpenTelemetry configuration for the runtime.
     /// When set to a non-<see langword="null"/> instance, the runtime is started with OpenTelemetry instrumentation enabled.

dotnet/test/E2E/GitHubTelemetryForwardingE2ETests.cs

@@ -0,0 +1,59 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+
+using System.Collections.Concurrent;
+using GitHub.Copilot.Rpc;
+using GitHub.Copilot.Test.Harness;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace GitHub.Copilot.Test.E2E;
+
+#pragma warning disable GHCP001 // GitHub telemetry forwarding is experimental.
+
+public class GitHubTelemetryForwardingE2ETests(E2ETestFixture fixture, ITestOutputHelper output)
+    : E2ETestBase(fixture, "github_telemetry", output)
+{
+    [Fact]
+    public async Task Should_Forward_GitHub_Telemetry_For_A_Live_Session()
+    {
+        var notifications = new ConcurrentQueue<GitHubTelemetryNotification>();
+
+        await using var client = Ctx.CreateClient(options: new CopilotClientOptions
+        {
+            OnGitHubTelemetry = notifications.Enqueue,
+        });
+
+        CopilotSession? session = null;
+        try
+        {
+            session = await client.CreateSessionAsync(new SessionConfig
+            {
+                OnPermissionRequest = PermissionHandler.ApproveAll,
+            });
+
+            await TestHelper.WaitForConditionAsync(
+                () => !notifications.IsEmpty,
+                timeout: TimeSpan.FromSeconds(30),
+                timeoutMessage: "Timed out waiting for GitHub telemetry notification.");
+
+            Assert.True(notifications.TryPeek(out var notification));
+            Assert.NotEmpty(notification.SessionId);
+            Assert.NotNull(notification.Event);
+            Assert.NotEmpty(notification.Event.Kind);
+            Assert.IsType<bool>(notification.Restricted);
+        }
+        finally
+        {
+            if (session is not null)
+            {
+                await session.DisposeAsync();
+            }
+
+            await client.StopAsync();
+        }
+    }
+}
+
+#pragma warning restore GHCP001