Update Telemetry client with data outlined in spec

src/client/Microsoft.Identity.Client/Cache/CacheSessionManager.cs

@@ -129,7 +129,8 @@ private async Task RefreshCacheForReadOperationsAsync()
                                   requestScopes: _requestParams.Scope, 
                                   requestTenantId: _requestParams.AuthorityManager.OriginalAuthority.TenantId,
                                   identityLogger: _requestParams.RequestContext.Logger.IdentityLogger,
-                                  piiLoggingEnabled: _requestParams.RequestContext.Logger.PiiLoggingEnabled);
+                                  piiLoggingEnabled: _requestParams.RequestContext.Logger.PiiLoggingEnabled,
+                                  telemetryDatapoints: RequestContext.TelemetryDatapoints);
 
                                 stopwatch.Start();
                                 await TokenCacheInternal.OnBeforeAccessAsync(args).ConfigureAwait(false);
@@ -155,7 +156,8 @@ private async Task RefreshCacheForReadOperationsAsync()
                                   requestScopes: _requestParams.Scope,
                                   requestTenantId: _requestParams.AuthorityManager.OriginalAuthority.TenantId,
                                   identityLogger: _requestParams.RequestContext.Logger.IdentityLogger,
-                                  piiLoggingEnabled: _requestParams.RequestContext.Logger.PiiLoggingEnabled);
+                                  piiLoggingEnabled: _requestParams.RequestContext.Logger.PiiLoggingEnabled,
+                                  telemetryDatapoints: RequestContext.TelemetryDatapoints);
 
                                 await TokenCacheInternal.OnAfterAccessAsync(args).ConfigureAwait(false);
                                 RequestContext.ApiEvent.DurationInCacheInMs += stopwatch.ElapsedMilliseconds;

src/client/Microsoft.Identity.Client/Internal/RequestContext.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using System;
+using System.Collections.Generic;
 using System.Threading;
 using Microsoft.Identity.Client.Core;
 using Microsoft.Identity.Client.Internal.Logger;
@@ -24,6 +25,8 @@ internal class RequestContext
 
         public CancellationToken UserCancellationToken { get; }
 
+        public Dictionary<string, string> TelemetryDatapoints { get; } = new Dictionary<string, string>();
+
         public RequestContext(IServiceBundle serviceBundle, Guid correlationId, CancellationToken cancellationToken = default)
         {
             ServiceBundle = serviceBundle ?? throw new ArgumentNullException(nameof(serviceBundle));

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

@@ -96,7 +96,7 @@ public async Task<AuthenticationResult> RunAsync(CancellationToken cancellationT
                     LogReturnedToken(authenticationResult);
                     UpdateTelemetry(sw, apiEvent, authenticationResult);
                     LogMetricsFromAuthResult(authenticationResult, AuthenticationRequestParameters.RequestContext.Logger);
-                    LogSuccessfulTelemetryToClient(authenticationResult, telemetryEventDetails, telemetryClients);
+                    LogSuccessfulTelemetryToClient(authenticationResult, AuthenticationRequestParameters.RequestContext.TelemetryDatapoints, telemetryEventDetails, telemetryClients);
 
                     return authenticationResult;
                 }
@@ -129,7 +129,7 @@ private void LogErrorTelemetryToClient(string errorCode, MsalTelemetryEventDetai
             }
         }
 
-        private void LogSuccessfulTelemetryToClient(AuthenticationResult authenticationResult, MsalTelemetryEventDetails telemetryEventDetails, ITelemetryClient[] telemetryClients)
+        private void LogSuccessfulTelemetryToClient(AuthenticationResult authenticationResult, Dictionary<string, string> telemetryDatapoints, MsalTelemetryEventDetails telemetryEventDetails, ITelemetryClient[] telemetryClients)
         {
             if (telemetryClients.HasEnabledClients(TelemetryConstants.AcquireTokenEventName))
             {
@@ -142,6 +142,40 @@ private void LogSuccessfulTelemetryToClient(AuthenticationResult authenticationR
                 telemetryEventDetails.SetProperty(TelemetryConstants.PopToken, authenticationResult.TokenType.Equals(Constants.PoPTokenType));
                 telemetryEventDetails.SetProperty(TelemetryConstants.RemainingLifetime, (authenticationResult.ExpiresOn - DateTime.Now).TotalMilliseconds);
                 telemetryEventDetails.SetProperty(TelemetryConstants.ActivityId, authenticationResult.CorrelationId);
+                telemetryEventDetails.SetProperty(TelemetryConstants.RefreshOn, 
+                    authenticationResult.AuthenticationResultMetadata.RefreshOn.HasValue ?
+                    DateTimeHelpers.DateTimeToUnixTimestampMilliseconds(authenticationResult.AuthenticationResultMetadata.RefreshOn.Value)
+                    : 0);
+
+                LogDatapointsToTelemetryClient(telemetryDatapoints, telemetryEventDetails);
+            }
+        }
+
+        private void LogDatapointsToTelemetryClient(Dictionary<string, string> telemetryDatapoints, MsalTelemetryEventDetails telemetryEventDetails)
+        {
+            if ((telemetryDatapoints == null) || (telemetryDatapoints.Count() == 0)) return;
+
+            string value;
+
+            if (telemetryDatapoints.TryGetValue(TelemetryCacheConstants.CacheUsed, out value))
+            {
+                int cacheUsed;
+                int.TryParse(value, out cacheUsed);
+                telemetryEventDetails.SetProperty(TelemetryCacheConstants.CacheUsed, cacheUsed);
+            }
+
+            if (telemetryDatapoints.TryGetValue(TelemetryCacheConstants.L1Latency, out value))
+            {
+                long latency;
+                long.TryParse(value, out latency);
+                telemetryEventDetails.SetProperty(TelemetryCacheConstants.L1Latency, latency);
+            }
+
+            if (telemetryDatapoints.TryGetValue(TelemetryCacheConstants.L2Latency, out value))
+            {
+                long latency;
+                long.TryParse(value, out latency);
+                telemetryEventDetails.SetProperty(TelemetryCacheConstants.L2Latency, latency);
             }
         }
 

src/client/Microsoft.Identity.Client/TelemetryCore/TelemetryClient/TelemetryCacheConstants.cs

@@ -0,0 +1,49 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using Microsoft.IdentityModel.Abstractions;
+
+namespace Microsoft.Identity.Client.TelemetryCore.TelemetryClient
+{
+    /// <summary>
+    /// Contains the parameters of cache to log to telemetry.
+    /// </summary>
+    public class TelemetryCacheConstants
+    {
+        /// <summary>
+        /// Constant to use as key to Cache Details dictionary.
+        /// </summary>
+        public const string CacheUsed = "CacheUsed";
+
+        /// <summary>
+        /// Constant to use as key to Cache Details dictionary.
+        /// </summary>
+        public const string L1Latency = "L1Latency";
+
+        /// <summary>
+        /// Constant to use as key to Cache Details dictionary.
+        /// </summary>
+        public const string L2Latency = "L2Latency";
+    }
+
+    /// <summary>
+    /// Indicates the cache which was used to get the token.
+    /// </summary>
+    public enum CacheUsed
+    {
+        /// <summary>
+        /// Indicates that the token was not cached
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// Token was obtained from Memory Cache
+        /// </summary>
+        MemoryCache = 1,
+
+        /// <summary>
+        /// Token was obtained from Distributed Cache
+        /// </summary>
+        DistributedCache = 2
+    }
+}

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

@@ -30,6 +30,7 @@ internal static class TelemetryConstants
         public const string DurationInHttp = "DurationInHttp";
         public const string ActivityId = "ActivityId";
         public const string Resource = "Resource";
+        public const string RefreshOn = "RefreshOn";
 
 #endregion
     }

src/client/Microsoft.Identity.Client/TokenCache.ITokenCacheInternal.cs

@@ -177,7 +177,8 @@ async Task<Tuple<MsalAccessTokenCacheItem, MsalIdTokenCacheItem, Account>> IToke
                             requestScopes: requestParams.Scope,
                             requestTenantId: requestParams.AuthorityManager.OriginalAuthority.TenantId,
                             identityLogger: requestParams.RequestContext.Logger.IdentityLogger,
-                            piiLoggingEnabled: requestParams.RequestContext.Logger.PiiLoggingEnabled);
+                            piiLoggingEnabled: requestParams.RequestContext.Logger.PiiLoggingEnabled,
+                            telemetryDatapoints: requestParams.RequestContext.TelemetryDatapoints);
 
                         Stopwatch sw = Stopwatch.StartNew();
 
@@ -249,7 +250,8 @@ async Task<Tuple<MsalAccessTokenCacheItem, MsalIdTokenCacheItem, Account>> IToke
                             requestScopes: requestParams.Scope,
                             requestTenantId: requestParams.AuthorityManager.OriginalAuthority.TenantId,
                             identityLogger: requestParams.RequestContext.Logger.IdentityLogger,
-                            piiLoggingEnabled: requestParams.RequestContext.Logger.PiiLoggingEnabled);
+                            piiLoggingEnabled: requestParams.RequestContext.Logger.PiiLoggingEnabled,
+                            telemetryDatapoints: requestParams.RequestContext.TelemetryDatapoints);
 
                         Stopwatch sw = Stopwatch.StartNew();
                         await tokenCacheInternal.OnAfterAccessAsync(args).ConfigureAwait(false);
@@ -741,7 +743,8 @@ internal async Task ExpireAllAccessTokensForTestAsync()
                             requestScopes: null,
                             requestTenantId: null,
                             identityLogger: null,
-                            piiLoggingEnabled: false);
+                            piiLoggingEnabled: false,
+                            telemetryDatapoints: new Dictionary<string, string>());
 
                 await tokenCacheInternal.OnAfterAccessAsync(args).ConfigureAwait(false);
             }
@@ -1162,7 +1165,8 @@ async Task ITokenCacheInternal.RemoveAccountAsync(IAccount account, Authenticati
                             requestScopes: requestParameters.Scope,
                             requestTenantId: requestParameters.AuthorityManager.OriginalAuthority.TenantId,
                             identityLogger: requestParameters.RequestContext.Logger.IdentityLogger,
-                            piiLoggingEnabled: requestParameters.RequestContext.Logger.PiiLoggingEnabled);
+                            piiLoggingEnabled: requestParameters.RequestContext.Logger.PiiLoggingEnabled,
+                            telemetryDatapoints: requestParameters.RequestContext.TelemetryDatapoints);
 
 
                         await tokenCacheInternal.OnBeforeAccessAsync(args).ConfigureAwait(false);
@@ -1198,7 +1202,8 @@ async Task ITokenCacheInternal.RemoveAccountAsync(IAccount account, Authenticati
                            requestScopes: requestParameters.Scope,
                            requestTenantId: requestParameters.AuthorityManager.OriginalAuthority.TenantId,
                            identityLogger: requestParameters.RequestContext.Logger.IdentityLogger,
-                            piiLoggingEnabled: requestParameters.RequestContext.Logger.PiiLoggingEnabled);
+                           piiLoggingEnabled: requestParameters.RequestContext.Logger.PiiLoggingEnabled,
+                           telemetryDatapoints: requestParameters.RequestContext.TelemetryDatapoints);
 
 
                         await tokenCacheInternal.OnAfterAccessAsync(args).ConfigureAwait(false);

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

@@ -146,6 +146,44 @@ public TokenCacheNotificationArgs(    // only use this constructor in product co
             PiiLoggingEnabled = piiLoggingEnabled;
         }
 
+        /// <summary>
+        /// This constructor is for test purposes only. It allows apps to unit test their MSAL token cache implementation code.
+        /// </summary>
+        public TokenCacheNotificationArgs(    // only use this constructor in product code
+            ITokenCacheSerializer tokenCache,
+            string clientId,
+            IAccount account,
+            bool hasStateChanged,
+            bool isApplicationCache,
+            string suggestedCacheKey,
+            bool hasTokens,
+            DateTimeOffset? suggestedCacheExpiry,
+            CancellationToken cancellationToken,
+            Guid correlationId,
+            IEnumerable<string> requestScopes,
+            string requestTenantId,
+            IIdentityLogger identityLogger,
+            bool piiLoggingEnabled,
+            Dictionary<string, string> telemetryDatapoints)
+
+        {
+            TokenCache = tokenCache;
+            ClientId = clientId;
+            Account = account;
+            HasStateChanged = hasStateChanged;
+            IsApplicationCache = isApplicationCache;
+            SuggestedCacheKey = suggestedCacheKey;
+            HasTokens = hasTokens;
+            CancellationToken = cancellationToken;
+            CorrelationId = correlationId;
+            RequestScopes = requestScopes;
+            RequestTenantId = requestTenantId;
+            SuggestedCacheExpiry = suggestedCacheExpiry;
+            IdentityLogger = identityLogger;
+            PiiLoggingEnabled = piiLoggingEnabled;
+            TelemetryDatapoints = telemetryDatapoints;
+        }
+
         /// <summary>
         /// Gets the <see cref="ITokenCacheSerializer"/> involved in the transaction
         /// </summary>
@@ -248,5 +286,10 @@ public TokenCacheNotificationArgs(    // only use this constructor in product co
         /// Boolean used to determine if Personally Identifiable Information (PII) logging is enabled.
         /// </summary>
         public bool PiiLoggingEnabled { get; }
+
+        /// <summary>
+        /// Cache Details contains the details of L1/ L2 cache for telemetry logging.
+        /// </summary>
+        public Dictionary<string, string> TelemetryDatapoints { get; }
     }
 }