feat: telemetry v2

.changeset/smooth-peaches-trade.md

@@ -0,0 +1,9 @@
+---
+'@aws-amplify/backend-deployer': minor
+'@aws-amplify/platform-core': minor
+'@aws-amplify/cli-core': minor
+'@aws-amplify/sandbox': minor
+'@aws-amplify/backend-cli': patch
+---
+
+add new version of telemetry

packages/backend-deployer/API.md

@@ -8,6 +8,7 @@ import { AmplifyIOHost } from '@aws-amplify/plugin-types';
 import { BackendIdentifier } from '@aws-amplify/plugin-types';
 import { PackageManagerController } from '@aws-amplify/plugin-types';
 import { SDKProfileResolver } from '@aws-amplify/plugin-types';
+import { TelemetryDataEmitter } from '@aws-amplify/platform-core';
 
 // @public
 export type BackendDeployer = {
@@ -17,7 +18,7 @@ export type BackendDeployer = {
 
 // @public
 export class BackendDeployerFactory {
-    constructor(packageManagerController: PackageManagerController, formatter: BackendDeployerOutputFormatter, backendDeployerIOHost: AmplifyIOHost, sdkProfileResolver: SDKProfileResolver);
+    constructor(packageManagerController: PackageManagerController, formatter: BackendDeployerOutputFormatter, backendDeployerIOHost: AmplifyIOHost, sdkProfileResolver: SDKProfileResolver, telemetryDataEmitter: TelemetryDataEmitter);
     getInstance(): BackendDeployer;
 }
 

packages/backend-deployer/src/cdk_deployer.test.ts

@@ -5,6 +5,7 @@ import {
   AmplifyError,
   AmplifyUserError,
   BackendLocator,
+  TelemetryDataEmitter,
 } from '@aws-amplify/platform-core';
 import { DeployProps } from './cdk_deployer_singleton_factory.js';
 import { CDKDeploymentError, CdkErrorMapper } from './cdk_error_mapper.js';
@@ -76,12 +77,24 @@ void describe('invokeCDKCommand', () => {
     fromAssemblyDirectory: fromAssemblyDirectoryMock,
   } as unknown as Toolkit;
 
+  const mockTelemetryEmitSuccess = mock.fn();
+  const mockTelemetryEmitFailure = mock.fn();
+  const mockTelemetryEmitAbortion = mock.fn();
+  const telemetryDataEmitter = {
+    emitSuccess: mockTelemetryEmitSuccess,
+    emitFailure: mockTelemetryEmitFailure,
+    emitAbortion: mockTelemetryEmitAbortion,
+  } as unknown as TelemetryDataEmitter;
+
+  const cdkErrorMapper = new CdkErrorMapper(formatterStub);
+
   const invoker = new CDKDeployer(
-    new CdkErrorMapper(formatterStub),
+    cdkErrorMapper,
     backendLocator,
     packageManagerControllerMock as never,
     cdkToolkit,
     mockIoHost,
+    telemetryDataEmitter,
   );
 
   const tsCompilerMock = mock.method(invoker, 'compileProject', () => {});
@@ -94,6 +107,7 @@ void describe('invokeCDKCommand', () => {
     fromAssemblyBuilderMock.mock.resetCalls();
     fromAssemblyDirectoryMock.mock.resetCalls();
     tsCompilerMock.mock.resetCalls();
+    mockTelemetryEmitFailure.mock.resetCalls();
   });
 
   void it('handles options for branch deployments', async () => {
@@ -203,6 +217,9 @@ void describe('invokeCDKCommand', () => {
       contextualTsCompilerCommandMock.mock.calls[0].arguments,
       ['amplify'],
     );
+
+    // can't test arguments of mockTelemetryEmitFailure because of flakiness around stack trace and latency times
+    assert.strictEqual(mockTelemetryEmitFailure.mock.callCount(), 1);
   });
 
   void it('throws the original synth error if the synth failed but tsc succeeded', async () => {
@@ -232,6 +249,9 @@ void describe('invokeCDKCommand', () => {
     assert.equal(synthMock.mock.callCount(), 1);
 
     assert.deepStrictEqual(tsCompilerMock.mock.calls[0].arguments, ['amplify']);
+
+    // can't test arguments of mockTelemetryEmitFailure because of flakiness around stack trace and latency times
+    assert.strictEqual(mockTelemetryEmitFailure.mock.callCount(), 1);
   });
 
   void it('throws the original synth error if the synth failed to generate function env declaration files', async () => {
@@ -275,11 +295,15 @@ void describe('invokeCDKCommand', () => {
     assert.strictEqual(tsCompilerMock.mock.callCount(), 1);
 
     assert.deepStrictEqual(tsCompilerMock.mock.calls[0].arguments, ['amplify']);
+
+    // can't test arguments of mockTelemetryEmitFailure because of flakiness around stack trace and latency times
+    assert.strictEqual(mockTelemetryEmitFailure.mock.callCount(), 1);
   });
 
   void it('returns human readable errors', async () => {
+    const accessDeniedError = new Error('Access Denied');
     synthMock.mock.mockImplementationOnce(() => {
-      throw new Error('Access Denied');
+      throw accessDeniedError;
     });
 
     await assert.rejects(
@@ -294,6 +318,9 @@ void describe('invokeCDKCommand', () => {
         return true;
       },
     );
+
+    // can't test arguments of mockTelemetryEmitFailure because of flakiness around stack trace and latency times
+    assert.strictEqual(mockTelemetryEmitFailure.mock.callCount(), 1);
   });
 
   void it('displays actionable error when older version of node is used during branch deployments', async () => {
@@ -321,6 +348,9 @@ void describe('invokeCDKCommand', () => {
       },
     );
 
+    // can't test arguments of mockTelemetryEmitFailure because of flakiness around stack trace and latency times
+    assert.strictEqual(mockTelemetryEmitFailure.mock.callCount(), 1);
+
     synthMock.mock.mockImplementationOnce(() => {
       throw olderNodeVersionError;
     });
@@ -341,5 +371,8 @@ void describe('invokeCDKCommand', () => {
         return true;
       },
     );
+
+    // can't test arguments of mockTelemetryEmitFailure because of flakiness around stack trace and latency times
+    assert.strictEqual(mockTelemetryEmitFailure.mock.callCount(), 2);
   });
 });

packages/backend-deployer/src/cdk_deployer.ts

@@ -15,6 +15,8 @@ import {
   AmplifyFault,
   BackendLocator,
   CDKContextKey,
+  LatencyDetails,
+  TelemetryDataEmitter,
 } from '@aws-amplify/platform-core';
 import path from 'path';
 import {
@@ -47,6 +49,7 @@ export class CDKDeployer implements BackendDeployer {
     private readonly packageManagerController: PackageManagerController,
     private readonly cdkToolkit: Toolkit,
     private readonly ioHost: AmplifyIOHost,
+    private readonly telemetryDataEmitter: TelemetryDataEmitter,
   ) {}
 
   /**
@@ -94,7 +97,9 @@ export class CDKDeployer implements BackendDeployer {
       action: 'amplify',
       time: new Date(),
       level: 'result',
-      data: undefined,
+      data: {
+        duration: synthTimeSeconds * 1000, // convert back to ms for telemetry
+      },
     });
 
     // Typescript compilation. For type related errors, we prefer to show errors from TS to customers rather than synth
@@ -112,16 +117,36 @@ export class CDKDeployer implements BackendDeployer {
       try {
         await this.compileProject(path.dirname(this.backendLocator.locate()));
       } catch (typeError) {
+        const synthTime = synthTimeSeconds * 1000; // convert back to ms
+        const totalTime = synthTime + (Date.now() - typeCheckStartTime);
+        const latencyDetails: LatencyDetails = {
+          total: totalTime,
+          synthesis: synthTime,
+        };
         if (
           synthError &&
           AmplifyError.isAmplifyError(typeError) &&
           typeError.name === 'FunctionEnvVarFileNotGeneratedError'
         ) {
+          const error = this.cdkErrorMapper.getAmplifyError(
+            synthError,
+            backendId.type,
+          );
+          await this.telemetryDataEmitter.emitFailure(error, latencyDetails, {
+            subCommands: 'SandboxEvent',
+          });
           // synth has failed and we don't have auto generated function environment definition files. This
           // resulted in the exception caught here, which is not very useful for the customers.
           // We instead throw the synth error for customers to fix what caused the synth to fail.
-          throw this.cdkErrorMapper.getAmplifyError(synthError, backendId.type);
+          throw error;
         }
+        const error = this.cdkErrorMapper.getAmplifyError(
+          typeError as Error,
+          backendId.type,
+        );
+        await this.telemetryDataEmitter.emitFailure(error, latencyDetails, {
+          subCommands: 'SandboxEvent',
+        });
         throw typeError;
       } finally {
         const typeCheckTimeSeconds =
@@ -132,14 +157,29 @@ export class CDKDeployer implements BackendDeployer {
           action: 'amplify',
           time: new Date(),
           level: 'result',
-          data: undefined,
+          data: {
+            duration: typeCheckTimeSeconds * 1000, // convert back to ms for telemetry
+          },
         });
       }
     }
 
     // If typescript compilation was successful but synth had failed, we throw synth error
     if (synthError) {
-      throw this.cdkErrorMapper.getAmplifyError(synthError, backendId.type);
+      const synthTime = synthTimeSeconds * 1000; // convert back to ms
+      const totalTime = synthTime + (Date.now() - typeCheckStartTime);
+      const latencyDetails: LatencyDetails = {
+        total: totalTime,
+        synthesis: synthTime,
+      };
+      const error = this.cdkErrorMapper.getAmplifyError(
+        synthError,
+        backendId.type,
+      );
+      await this.telemetryDataEmitter.emitFailure(error, latencyDetails, {
+        subCommands: 'SandboxEvent',
+      });
+      throw error;
     }
 
     // Perform actual deployment. CFN or hotswap
@@ -157,8 +197,24 @@ export class CDKDeployer implements BackendDeployer {
         requireApproval:
           backendId.type !== 'sandbox' ? RequireApproval.NEVER : undefined,
       });
-    } catch (error) {
-      throw this.cdkErrorMapper.getAmplifyError(error as Error, backendId.type);
+    } catch (deployError) {
+      const synthTime = synthTimeSeconds * 1000; // convert back to ms
+      const deploymentTime = Date.now() - deployStartTime;
+      const totalTime =
+        synthTime + (Date.now() - typeCheckStartTime) + deploymentTime;
+      const latencyDetails: LatencyDetails = {
+        total: totalTime,
+        synthesis: synthTime,
+        deployment: deploymentTime,
+      };
+      const error = this.cdkErrorMapper.getAmplifyError(
+        deployError as Error,
+        backendId.type,
+      );
+      await this.telemetryDataEmitter.emitFailure(error, latencyDetails, {
+        subCommands: 'SandboxEvent',
+      });
+      throw error;
     }
 
     return {

packages/backend-deployer/src/cdk_deployer_singleton_factory.ts

@@ -6,7 +6,10 @@ import {
 } from '@aws-amplify/plugin-types';
 import { CDKDeployer } from './cdk_deployer.js';
 import { CdkErrorMapper } from './cdk_error_mapper.js';
-import { BackendLocator } from '@aws-amplify/platform-core';
+import {
+  BackendLocator,
+  TelemetryDataEmitter,
+} from '@aws-amplify/platform-core';
 import { BackendDeployerOutputFormatter } from './types.js';
 import { Toolkit } from '@aws-cdk/toolkit-lib';
 
@@ -53,6 +56,7 @@ export class BackendDeployerFactory {
     private readonly formatter: BackendDeployerOutputFormatter,
     private readonly backendDeployerIOHost: AmplifyIOHost,
     private readonly sdkProfileResolver: SDKProfileResolver,
+    private readonly telemetryDataEmitter: TelemetryDataEmitter,
   ) {}
 
   /**
@@ -73,6 +77,7 @@ export class BackendDeployerFactory {
           },
         }),
         this.backendDeployerIOHost,
+        this.telemetryDataEmitter,
       );
     }
     return BackendDeployerFactory.instance;

packages/backend-deployer/src/cdk_error_mapper.ts

@@ -169,7 +169,7 @@ export class CdkErrorMapper {
         (errorName) => errorName === error.name,
       )
     ) {
-      throw new AmplifyUserError(
+      return new AmplifyUserError(
         'SyntaxError',
         {
           message: 'Unable to build the Amplify backend definition.',

packages/cli-core/API.md

@@ -6,12 +6,13 @@
 
 import { AmplifyIOHost } from '@aws-amplify/plugin-types';
 import { PackageManagerController } from '@aws-amplify/plugin-types';
+import { TelemetryDataEmitter } from '@aws-amplify/platform-core';
 import { WriteStream } from 'node:tty';
 import z from 'zod';
 
 // @public
 export class AmplifyIOEventsBridgeSingletonFactory {
-    constructor(printer?: Printer);
+    constructor(telemetryDataEmitter: TelemetryDataEmitter, printer?: Printer);
     getInstance: () => AmplifyIOHost;
 }