@microsoft/agents-hosting 1.5.0-beta.6.ga236d9a19c → 1.5.1

package/src/oauth/userTokenClient.ts

@@ -3,13 +3,15 @@
 
 import axios, { AxiosInstance } from 'axios'
 import { Activity, ConversationReference } from '@microsoft/agents-activity'
-import { debug } from '@microsoft/agents-activity/logger'
+import { debug } from '@microsoft/agents-telemetry'
 import { normalizeTokenExchangeState } from '../activityWireCompat'
 import { AadResourceUrls, SignInResource, TokenExchangeRequest, TokenOrSinginResourceResponse, TokenResponse, TokenStatus } from './userTokenClient.types'
 import { getProductInfo } from '../getProductInfo'
 import { AuthProvider } from '../auth'
 import { HeaderPropagation, HeaderPropagationCollection } from '../headerPropagation'
 import { getTokenServiceEndpoint } from './customUserTokenAPI'
+import { trace } from '@microsoft/agents-telemetry'
+import { UserTokenClientTraceDefinitions } from '../observability'
 
 const logger = debug('agents:user-token-client')
 
@@ -144,13 +146,17 @@ export class UserTokenClient {
    * @returns A promise that resolves to the user token.
    */
   async getUserToken (connectionName: string, channelIdComposite: string, userId: string, code?: string) : Promise<TokenResponse> {
-    const [channelId] = Activity.parseChannelId(channelIdComposite)
-    const params = { connectionName, channelId, userId, code }
-    const response = await this.client.get('/api/usertoken/GetToken', { params })
-    if (response?.data) {
-      return response.data as TokenResponse
-    }
-    return { token: undefined }
+    return trace(UserTokenClientTraceDefinitions.getUserToken, async ({ record }) => {
+      const [channelId] = Activity.parseChannelId(channelIdComposite)
+      const params = { connectionName, channelId, userId, code }
+      const response = await this.client.get('/api/usertoken/GetToken', { params })
+      record({ connectionName, channelId, userId, httpStatusCode: response.status?.toString() })
+
+      if (response?.data) {
+        return response.data as TokenResponse
+      }
+      return { token: undefined }
+    })
   }
 
   /**
@@ -161,12 +167,15 @@ export class UserTokenClient {
    * @returns A promise that resolves when the sign-out operation is complete.
    */
   async signOut (userId: string, connectionName: string, channelIdComposite: string) : Promise<void> {
-    const [channelId] = Activity.parseChannelId(channelIdComposite)
-    const params = { userId, connectionName, channelId }
-    const response = await this.client.delete('/api/usertoken/SignOut', { params })
-    if (response.status !== 200) {
-      throw new Error('Failed to sign out')
-    }
+    return trace(UserTokenClientTraceDefinitions.signOut, async ({ record }) => {
+      const [channelId] = Activity.parseChannelId(channelIdComposite)
+      const params = { userId, connectionName, channelId }
+      const response = await this.client.delete('/api/usertoken/SignOut', { params })
+      record({ userId, connectionName, channelId, httpStatusCode: response.status?.toString() })
+      if (response.status !== 200) {
+        throw new Error('Failed to sign out')
+      }
+    })
   }
 
   /**
@@ -178,17 +187,20 @@ export class UserTokenClient {
    * @returns A promise that resolves to the signing resource.
    */
   async getSignInResource (msAppId: string, connectionName: string, conversation: ConversationReference, relatesTo?: ConversationReference) : Promise<SignInResource> {
-    const tokenExchangeState = {
-      connectionName,
-      conversation,
-      relatesTo,
-      msAppId
-    }
-    const tokenExchangeStateNormalized = normalizeTokenExchangeState(tokenExchangeState)
-    const state = Buffer.from(JSON.stringify(tokenExchangeStateNormalized)).toString('base64')
-    const params = { state }
-    const response = await this.client.get('/api/botsignin/GetSignInResource', { params })
-    return response.data as SignInResource
+    return trace(UserTokenClientTraceDefinitions.getSignInResource, async ({ record }) => {
+      const tokenExchangeState = {
+        connectionName,
+        conversation,
+        relatesTo,
+        msAppId
+      }
+      const tokenExchangeStateNormalized = normalizeTokenExchangeState(tokenExchangeState)
+      const state = Buffer.from(JSON.stringify(tokenExchangeStateNormalized)).toString('base64')
+      const params = { state }
+      const response = await this.client.get('/api/botsignin/GetSignInResource', { params })
+      record({ connectionName, httpStatusCode: response.status?.toString() })
+      return response.data as SignInResource
+    })
   }
 
   /**
@@ -200,14 +212,17 @@ export class UserTokenClient {
    * @returns A promise that resolves to the exchanged token.
    */
   async exchangeTokenAsync (userId: string, connectionName: string, channelIdComposite: string, tokenExchangeRequest: TokenExchangeRequest) : Promise<TokenResponse> {
-    const [channelId] = Activity.parseChannelId(channelIdComposite)
-    const params = { userId, connectionName, channelId }
-    const response = await this.client.post('/api/usertoken/exchange', tokenExchangeRequest, { params })
-    if (response?.data) {
-      return response.data as TokenResponse
-    } else {
-      return { token: undefined }
-    }
+    return trace(UserTokenClientTraceDefinitions.exchangeToken, async ({ record }) => {
+      const [channelId] = Activity.parseChannelId(channelIdComposite)
+      const params = { userId, connectionName, channelId }
+      const response = await this.client.post('/api/usertoken/exchange', tokenExchangeRequest, { params })
+      record({ userId, connectionName, channelId, httpStatusCode: response.status?.toString() })
+      if (response?.data) {
+        return response.data as TokenResponse
+      } else {
+        return { token: undefined }
+      }
+    })
   }
 
   /**
@@ -223,11 +238,14 @@ export class UserTokenClient {
    * @returns A promise that resolves to the token or sign-in resource response.
    */
   async getTokenOrSignInResource (userId: string, connectionName: string, channelIdComposite: string, conversation: ConversationReference, relatesTo: ConversationReference, code: string, finalRedirect: string = '', fwdUrl: string = '') : Promise<TokenOrSinginResourceResponse> {
-    const [channelId] = Activity.parseChannelId(channelIdComposite)
-    const state = Buffer.from(JSON.stringify({ conversation, relatesTo, connectionName, msAppId: this.msAppId })).toString('base64')
-    const params = { userId, connectionName, channelId, state, code, finalRedirect, fwdUrl }
-    const response = await this.client.get('/api/usertoken/GetTokenOrSignInResource', { params })
-    return response.data as TokenOrSinginResourceResponse
+    return trace(UserTokenClientTraceDefinitions.getTokenOrSignInResource, async ({ record }) => {
+      const [channelId] = Activity.parseChannelId(channelIdComposite)
+      const state = Buffer.from(JSON.stringify({ conversation, relatesTo, connectionName, msAppId: this.msAppId })).toString('base64')
+      const params = { userId, connectionName, channelId, state, code, finalRedirect, fwdUrl }
+      const response = await this.client.get('/api/usertoken/GetTokenOrSignInResource', { params })
+      record({ userId, connectionName, channelId, httpStatusCode: response.status?.toString() })
+      return response.data as TokenOrSinginResourceResponse
+    })
   }
 
   /**
@@ -238,10 +256,13 @@ export class UserTokenClient {
    * @returns A promise that resolves to the token status.
    */
   async getTokenStatus (userId: string, channelIdComposite: string, include: string = null!): Promise<TokenStatus[]> {
-    const [channelId] = Activity.parseChannelId(channelIdComposite)
-    const params = { userId, channelId, include }
-    const response = await this.client.get('/api/usertoken/GetTokenStatus', { params })
-    return response.data as TokenStatus[]
+    return trace(UserTokenClientTraceDefinitions.getTokenStatus, async ({ record }) => {
+      const [channelId] = Activity.parseChannelId(channelIdComposite)
+      const params = { userId, channelId, include }
+      const response = await this.client.get('/api/usertoken/GetTokenStatus', { params })
+      record({ userId, channelId, httpStatusCode: response.status?.toString() })
+      return response.data as TokenStatus[]
+    })
   }
 
   /**
@@ -253,10 +274,13 @@ export class UserTokenClient {
    * @returns A promise that resolves to the AAD tokens.
    */
   async getAadTokens (userId: string, connectionName: string, channelIdComposite: string, resourceUrls: AadResourceUrls) : Promise<Record<string, TokenResponse>> {
-    const [channelId] = Activity.parseChannelId(channelIdComposite)
-    const params = { userId, connectionName, channelId }
-    const response = await this.client.post('/api/usertoken/GetAadTokens', resourceUrls, { params })
-    return response.data as Record<string, TokenResponse>
+    return trace(UserTokenClientTraceDefinitions.getAadTokens, async ({ record }) => {
+      const [channelId] = Activity.parseChannelId(channelIdComposite)
+      const params = { userId, connectionName, channelId }
+      const response = await this.client.post('/api/usertoken/GetAadTokens', resourceUrls, { params })
+      record({ userId, connectionName, channelId, httpStatusCode: response.status?.toString() })
+      return response.data as Record<string, TokenResponse>
+    })
   }
 
   public updateAuthToken (token: string): void {

package/src/observability/index.ts

@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+export * from './metrics'
+export * from './traces'

package/src/observability/metrics.ts

@@ -0,0 +1,103 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { metric, MetricNames } from '@microsoft/agents-telemetry'
+
+export const HostingMetrics = {
+  // Counters
+  activitiesReceivedCounter: metric.counter(MetricNames.ACTIVITIES_RECEIVED, {
+    unit: 'activities',
+    description: 'Total number of activities received by the adapter'
+  }),
+
+  activitiesSentCounter: metric.counter(MetricNames.ACTIVITIES_SENT, {
+    unit: 'activities',
+    description: 'Total number of outbound activities sent by the adapter'
+  }),
+
+  activitiesUpdatedCounter: metric.counter(MetricNames.ACTIVITIES_UPDATED, {
+    unit: 'activities',
+    description: 'Total number of activities updated by the adapter'
+  }),
+
+  activitiesDeletedCounter: metric.counter(MetricNames.ACTIVITIES_DELETED, {
+    unit: 'activities',
+    description: 'Total number of activities deleted by the adapter'
+  }),
+
+  connectorRequestsCounter: metric.counter(MetricNames.CONNECTOR_REQUESTS, {
+    unit: 'request',
+    description: 'Total number of outbound connector HTTP requests'
+  }),
+
+  agentClientRequestsCounter: metric.counter(MetricNames.AGENT_CLIENT_REQUESTS, {
+    unit: 'request',
+    description: 'Total number of inter-agent calls'
+  }),
+
+  turnsTotalCounter: metric.counter(MetricNames.TURNS_COUNT, {
+    unit: 'turn',
+    description: 'Total turns processed'
+  }),
+
+  turnsErrorsCounter: metric.counter(MetricNames.TURNS_ERRORS, {
+    unit: 'turn',
+    description: 'Total turns that resulted in an error'
+  }),
+
+  authTokenRequestsCounter: metric.counter(MetricNames.AUTH_TOKEN_REQUEST_COUNT, {
+    unit: 'request',
+    description: 'Total number of token acquisition attempts'
+  }),
+
+  userTokenClientRequestsCounter: metric.counter(MetricNames.USER_TOKEN_CLIENT_REQUESTS, {
+    unit: 'request',
+    description: 'Total number of user token client HTTP requests'
+  }),
+
+  proactiveOperationCounter: metric.counter(MetricNames.PROACTIVE_OPERATION_COUNT, {
+    unit: 'operation',
+    description: 'Total number of proactive operations (sendActivity, continueConversation, createConversation)'
+  }),
+
+  // Duration Histograms
+  adapterProcessDuration: metric.histogram(MetricNames.ADAPTER_PROCESS_DURATION, {
+    unit: 'ms',
+    description: 'Duration of the adapter process method in milliseconds'
+  }),
+
+  connectorRequestDuration: metric.histogram(MetricNames.CONNECTOR_REQUEST_DURATION, {
+    unit: 'ms',
+    description: 'Duration of outbound connector HTTP requests in milliseconds'
+  }),
+
+  agentClientRequestDuration: metric.histogram(MetricNames.AGENT_CLIENT_REQUEST_DURATION, {
+    unit: 'ms',
+    description: 'Duration of inter-agent call latency in milliseconds'
+  }),
+
+  turnDuration: metric.histogram(MetricNames.TURN_DURATION, {
+    unit: 'ms',
+    description: 'Duration of end-to-end turn processing in milliseconds'
+  }),
+
+  storageOperationDuration: metric.histogram(MetricNames.STORAGE_OPERATION_DURATION, {
+    unit: 'ms',
+    description: 'Duration of storage operations in milliseconds'
+  }),
+
+  authTokenDuration: metric.histogram(MetricNames.AUTH_TOKEN_DURATION, {
+    unit: 'ms',
+    description: 'Duration of token acquisition latency in milliseconds'
+  }),
+
+  userTokenClientRequestDuration: metric.histogram(MetricNames.USER_TOKEN_CLIENT_REQUEST_DURATION, {
+    unit: 'ms',
+    description: 'Duration of user token client HTTP requests in milliseconds'
+  }),
+
+  proactiveOperationDuration: metric.histogram(MetricNames.PROACTIVE_OPERATION_DURATION, {
+    unit: 'ms',
+    description: 'Duration of proactive operations in milliseconds'
+  })
+}