For proactive refresh log error to otel and change token source to IDP

src/client/Microsoft.Identity.Client/AuthenticationResultMetadata.cs

@@ -24,7 +24,7 @@ public AuthenticationResultMetadata(TokenSource tokenSource)
         /// <summary>
         /// The source of the token in the result.
         /// </summary>
-        public TokenSource TokenSource { get; }
+        public TokenSource TokenSource { get; internal set; }
 
         /// <summary>
         /// The token endpoint used to contact the Identity Provider (e.g. Azure Active Directory). 

src/client/Microsoft.Identity.Client/Internal/Requests/ClientCredentialRequest.cs

@@ -71,6 +71,7 @@ protected override async Task<AuthenticationResult> ExecuteAsync(CancellationTok
                     if (proactivelyRefresh)
                     {
                         AuthenticationRequestParameters.RequestContext.ApiEvent.CacheInfo = CacheRefreshReason.ProactivelyRefreshed;
+                        authResult.AuthenticationResultMetadata.TokenSource = TokenSource.IdentityProvider;
 
                         SilentRequestHelper.ProcessFetchInBackground(
                         cachedAccessTokenItem,
@@ -79,7 +80,7 @@ protected override async Task<AuthenticationResult> ExecuteAsync(CancellationTok
                             // Use a linked token source, in case the original cancellation token source is disposed before this background task completes.
                             using var tokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
                             return GetAccessTokenAsync(tokenSource.Token, logger);
-                        }, logger);
+                        }, logger, ServiceBundle, AuthenticationRequestParameters.RequestContext.ApiEvent.ApiId.ToString());
                     }
                 }
                 catch (MsalServiceException e)

src/client/Microsoft.Identity.Client/Internal/Requests/ManagedIdentityAuthRequest.cs

@@ -61,6 +61,7 @@ protected override async Task<AuthenticationResult> ExecuteAsync(CancellationTok
                         logger.Info("[ManagedIdentityRequest] Initiating a proactive refresh.");
 
                         AuthenticationRequestParameters.RequestContext.ApiEvent.CacheInfo = CacheRefreshReason.ProactivelyRefreshed;
+                        authResult.AuthenticationResultMetadata.TokenSource = TokenSource.IdentityProvider;
 
                         SilentRequestHelper.ProcessFetchInBackground(
                         cachedAccessTokenItem,
@@ -69,7 +70,7 @@ protected override async Task<AuthenticationResult> ExecuteAsync(CancellationTok
                             // Use a linked token source, in case the original cancellation token source is disposed before this background task completes.
                             using var tokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
                             return GetAccessTokenAsync(tokenSource.Token, logger);
-                        }, logger);
+                        }, logger, ServiceBundle, AuthenticationRequestParameters.RequestContext.ApiEvent.ApiId.ToString());
                     }
                 }
                 catch (MsalServiceException e)
@@ -99,7 +100,6 @@ private async Task<AuthenticationResult> GetAccessTokenAsync(
             AuthenticationResult authResult;
             MsalAccessTokenCacheItem cachedAccessTokenItem = null;
 
-
             // Requests to a managed identity endpoint must be throttled; 
             // otherwise, the endpoint will throw a HTTP 429.
             logger.Verbose(() => "[ManagedIdentityRequest] Entering managed identity request semaphore.");

src/client/Microsoft.Identity.Client/Internal/Requests/OnBehalfOfRequest.cs

@@ -120,6 +120,7 @@ protected override async Task<AuthenticationResult> ExecuteAsync(CancellationTok
                     if (shouldRefresh)
                     {
                         AuthenticationRequestParameters.RequestContext.ApiEvent.CacheInfo = CacheRefreshReason.ProactivelyRefreshed;
+                        authResult.AuthenticationResultMetadata.TokenSource = TokenSource.IdentityProvider;
 
                         SilentRequestHelper.ProcessFetchInBackground(
                         cachedAccessToken,
@@ -128,7 +129,7 @@ protected override async Task<AuthenticationResult> ExecuteAsync(CancellationTok
                             // Use a linked token source, in case the original cancellation token source is disposed before this background task completes.
                             using var tokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
                             return RefreshRtOrFetchNewAccessTokenAsync(tokenSource.Token);
-                        }, logger);
+                        }, logger, ServiceBundle, AuthenticationRequestParameters.RequestContext.ApiEvent.ApiId.ToString());
                     }
                 }
 

src/client/Microsoft.Identity.Client/Internal/Requests/RequestBase.cs

@@ -106,7 +106,7 @@ public async Task<AuthenticationResult> RunAsync(CancellationToken cancellationT
                     AuthenticationRequestParameters.RequestContext.Logger.ErrorPii(ex);
                     LogMsalErrorTelemetryToClient(ex, telemetryEventDetails, telemetryClients);
 
-                    LogMsalFailedTelemetryToOtel(ex.ErrorCode);
+                    LogMsalFailedTelemetryToOtel(ex.ErrorCode, apiEvent.ApiId.ToString());
                     throw;
                 }
                 catch (Exception ex)
@@ -115,7 +115,7 @@ public async Task<AuthenticationResult> RunAsync(CancellationToken cancellationT
                     AuthenticationRequestParameters.RequestContext.Logger.ErrorPii(ex);
                     LogMsalErrorTelemetryToClient(ex, telemetryEventDetails, telemetryClients);
 
-                    LogMsalFailedTelemetryToOtel(ex.GetType().Name);
+                    LogMsalFailedTelemetryToOtel(ex.GetType().Name, apiEvent.ApiId.ToString());
                     throw;
                 }
                 finally
@@ -137,12 +137,14 @@ private void LogMsalSuccessTelemetryToOtel(AuthenticationResult authenticationRe
                         AuthenticationRequestParameters.RequestContext.Logger);
         }
 
-        private void LogMsalFailedTelemetryToOtel(string errorCodeToLog)
+        private void LogMsalFailedTelemetryToOtel(string errorCodeToLog, string apiId)
         {
             // Log metrics
             ServiceBundle.PlatformProxy.OtelInstrumentation.LogFailedMetrics(
                         ServiceBundle.PlatformProxy.GetProductName(),
-                        errorCodeToLog);
+                        errorCodeToLog,
+                        apiId, 
+                        false);
         }
 
         private void LogMsalErrorTelemetryToClient(Exception ex, MsalTelemetryEventDetails telemetryEventDetails, ITelemetryClient[] telemetryClients)

src/client/Microsoft.Identity.Client/Internal/Requests/Silent/CacheSilentStrategy.cs

@@ -90,6 +90,7 @@ public async Task<AuthenticationResult> ExecuteAsync(CancellationToken cancellat
                     if (shouldRefresh)
                     {
                         AuthenticationRequestParameters.RequestContext.ApiEvent.CacheInfo = CacheRefreshReason.ProactivelyRefreshed;
+                        authResult.AuthenticationResultMetadata.TokenSource = TokenSource.IdentityProvider;
 
                         SilentRequestHelper.ProcessFetchInBackground(
                         cachedAccessTokenItem,
@@ -98,7 +99,7 @@ public async Task<AuthenticationResult> ExecuteAsync(CancellationToken cancellat
                             // Use a linked token source, in case the original cancellation token source is disposed before this background task completes.
                             using var tokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
                             return RefreshRtOrFailAsync(tokenSource.Token);
-                        }, logger);
+                        }, logger, ServiceBundle, AuthenticationRequestParameters.RequestContext.ApiEvent.ApiId.ToString());
                     }
                 }
 

src/client/Microsoft.Identity.Client/Internal/Requests/SilentRequestHelper.cs

@@ -82,10 +82,14 @@ internal static bool NeedsRefresh(MsalAccessTokenCacheItem oldAccessToken, out D
         internal static void ProcessFetchInBackground(
             MsalAccessTokenCacheItem oldAccessToken,
             Func<Task<AuthenticationResult>> fetchAction,
-            ILoggerAdapter logger)
+            ILoggerAdapter logger, 
+            IServiceBundle serviceBundle, 
+            string apiId)
         {
             _ = Task.Run(async () =>
             {
+                string error = null;
+
                 try
                 {
                     await fetchAction().ConfigureAwait(false);
@@ -101,14 +105,29 @@ internal static void ProcessFetchInBackground(
                     {
                         logger.ErrorPiiWithPrefix(ex, logMsg);
                     }
+
+                    error = ex.ErrorCode;
                 }
                 catch (OperationCanceledException ex)
                 {
                     logger.WarningPiiWithPrefix(ex, ProactiveRefreshCancellationError);
+                    error = ex.GetType().Name;
                 }
                 catch (Exception ex)
                 {
                     logger.ErrorPiiWithPrefix(ex, ProactiveRefreshGeneralError);
+                    error = ex.GetType().Name;
+                }
+                finally
+                {
+                    if (!string.IsNullOrEmpty(error))
+                    {
+                        serviceBundle.PlatformProxy.OtelInstrumentation.LogFailedMetrics(
+                        serviceBundle.PlatformProxy.GetProductName(),
+                        error,
+                        apiId,
+                        true);
+                    }
                 }
             });
         }

src/client/Microsoft.Identity.Client/Platforms/Features/OpenTelemetry/OtelInstrumentation.cs

@@ -95,13 +95,20 @@ void IOtelInstrumentation.LogSuccessMetrics(
             AuthenticationResultMetadata authResultMetadata,
             ILoggerAdapter logger)
         {
+            var tokenSource = authResultMetadata.TokenSource;
+
+            //if (authResultMetadata.CacheRefreshReason == CacheRefreshReason.ProactivelyRefreshed)
+            //{
+            //    tokenSource = TokenSource.IdentityProvider;
+            //}
+
             if (s_successCounter.Value.Enabled)
             {
                 s_successCounter.Value.Add(1,
                         new(TelemetryConstants.MsalVersion, MsalIdHelper.GetMsalVersion()),
                         new(TelemetryConstants.Platform, platform),
                         new(TelemetryConstants.ApiId, apiId),
-                        new(TelemetryConstants.TokenSource, authResultMetadata.TokenSource),
+                        new(TelemetryConstants.TokenSource, tokenSource),
                         new(TelemetryConstants.CacheRefreshReason, authResultMetadata.CacheRefreshReason),
                         new(TelemetryConstants.CacheLevel, cacheLevel));
                 logger.Info("[OpenTelemetry] Completed incrementing to isSuccessful counter."); 
@@ -113,7 +120,7 @@ void IOtelInstrumentation.LogSuccessMetrics(
                         new(TelemetryConstants.MsalVersion, MsalIdHelper.GetMsalVersion()),
                         new(TelemetryConstants.Platform, platform),
                         new(TelemetryConstants.ApiId, apiId),
-                        new(TelemetryConstants.TokenSource, authResultMetadata.TokenSource),
+                        new(TelemetryConstants.TokenSource, tokenSource),
                         new(TelemetryConstants.CacheLevel, cacheLevel)); 
             }
 
@@ -127,7 +134,7 @@ void IOtelInstrumentation.LogSuccessMetrics(
             }
 
             // Only log duration in HTTP when token is fetched from IDP
-            if (s_durationInHttp.Value.Enabled && authResultMetadata.TokenSource.Equals(TokenSource.IdentityProvider))
+            if (s_durationInHttp.Value.Enabled && tokenSource.Equals(TokenSource.IdentityProvider))
             {
                 s_durationInHttp.Value.Record(authResultMetadata.DurationInHttpInMs,
                 new(TelemetryConstants.MsalVersion, MsalIdHelper.GetMsalVersion()),
@@ -136,26 +143,28 @@ void IOtelInstrumentation.LogSuccessMetrics(
             }
 
             // Only log duration in microseconds when the cache level is L1.
-            if (s_durationInL1CacheInUs.Value.Enabled && authResultMetadata.TokenSource.Equals(TokenSource.Cache) 
+            if (s_durationInL1CacheInUs.Value.Enabled && tokenSource.Equals(TokenSource.Cache) 
                 && authResultMetadata.CacheLevel.Equals(CacheLevel.L1Cache))
             {
                 s_durationInL1CacheInUs.Value.Record(totalDurationInUs,
                 new(TelemetryConstants.MsalVersion, MsalIdHelper.GetMsalVersion()),
                 new(TelemetryConstants.Platform, platform),
                 new(TelemetryConstants.ApiId, apiId),
-                new(TelemetryConstants.TokenSource, authResultMetadata.TokenSource),
+                new(TelemetryConstants.TokenSource, tokenSource),
                 new(TelemetryConstants.CacheLevel, cacheLevel));
             }
         }
 
-        void IOtelInstrumentation.LogFailedMetrics(string platform, string errorCode)
+        void IOtelInstrumentation.LogFailedMetrics(string platform, string errorCode, string apiId, bool isProactiveTokenRefresh)
         {
             if (s_failureCounter.Value.Enabled)
             {
                 s_failureCounter.Value.Add(1,
                         new(TelemetryConstants.MsalVersion, MsalIdHelper.GetMsalVersion()),
                         new(TelemetryConstants.Platform, platform),
-                        new(TelemetryConstants.ErrorCode, errorCode)); 
+                        new(TelemetryConstants.ErrorCode, errorCode), 
+                        new(TelemetryConstants.ApiId, apiId), 
+                        new(TelemetryConstants.IsProactiveRefresh, isProactiveTokenRefresh)); 
             }
         }
     }

src/client/Microsoft.Identity.Client/TelemetryCore/OpenTelemetry/IOtelInstrumentation.cs

@@ -16,6 +16,6 @@ internal void LogSuccessMetrics(
             long totalDurationInUs,
             AuthenticationResultMetadata authResultMetadata,
             ILoggerAdapter logger);
-        internal void LogFailedMetrics(string platform, string errorCode);
+        internal void LogFailedMetrics(string platform, string errorCode, string apiId, bool isProactiveTokenRefresh);
     }
 }

src/client/Microsoft.Identity.Client/TelemetryCore/OpenTelemetry/NullOtelInstrumentation.cs

@@ -23,7 +23,7 @@ public void LogSuccessMetrics(
             // No op
         }
 
-        public void LogFailedMetrics(string platform, string errorCode)
+        public void LogFailedMetrics(string platform, string errorCode, string apiId, bool isProactiveTokenRefresh)
         {
             // No op
         }

src/client/Microsoft.Identity.Client/TelemetryCore/TelemetryConstants.cs

@@ -44,6 +44,7 @@ internal static class TelemetryConstants
         public const string ClientId = "ClientId";
         public const string Platform = "Platform";
         public const string ApiId = "ApiId";
+        public const string IsProactiveRefresh = "IsProactiveRefresh";
 
 #endregion
     }