@aws/lsp-codewhisperer 0.0.15 → 0.0.17

package/out/language-server/telemetry/userTriggerDecision.test.js

@@ -7,6 +7,7 @@ const ts_sinon_1 = require("ts-sinon");
 const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
 const codeWhispererServer_1 = require("../codeWhispererServer");
 const sessionManager_1 = require("../session/sessionManager");
+const telemetryService_1 = require("../telemetryService");
 describe('Telemetry', () => {
     const sandbox = ts_sinon_1.default.createSandbox();
     let SESSION_IDS_LOG = [];
@@ -14,6 +15,7 @@ describe('Telemetry', () => {
     let sessionManagerSpy;
     let generateSessionIdStub;
     let clock;
+    let telemetryServiceSpy;
     beforeEach(() => {
         const StubSessionIdGenerator = () => {
             let id = 'some-random-session-uuid-' + SESSION_IDS_LOG.length;
@@ -30,11 +32,13 @@ describe('Telemetry', () => {
         clock = ts_sinon_1.default.useFakeTimers({
             now: 1483228800000,
         });
+        telemetryServiceSpy = ts_sinon_1.default.spy(telemetryService_1.TelemetryService.prototype, 'emitUserTriggerDecision');
     });
     afterEach(() => {
         generateSessionIdStub.restore();
         clock.restore();
         sandbox.restore();
+        telemetryServiceSpy.restore();
     });
     describe('User Trigger Decision telemetry', () => {
         const HELLO_WORLD_IN_CSHARP = `class HelloWorld
@@ -155,28 +159,70 @@ describe('Telemetry', () => {
         });
         const aUserTriggerDecision = (override = {}) => {
             return {
-                name: 'codewhisperer_userTriggerDecision',
-                data: {
+                id: 'some-random-session-uuid-0',
+                document: {
+                    _uri: 'file:///test.cs',
+                    _languageId: 'csharp',
+                    _version: 1,
+                    _content: 'class HelloWorld\n' +
+                        '{\n' +
+                        '    static void Main()\n' +
+                        '    {\n' +
+                        '        Console.WriteLine("Hello World!");\n' +
+                        '    }\n' +
+                        '}\n',
+                    _lineOffsets: [0, 17, 19, 42, 48, 91, 97, 99],
+                },
+                startTime: 1483228800000,
+                closeTime: 1483228802000,
+                state: 'CLOSED',
+                codewhispererSessionId: 'cwspr-session-id',
+                startPosition: { line: 2, character: 21 },
+                suggestions: [
+                    { itemId: 'cwspr-item-id-1', content: '' },
+                    { itemId: 'cwspr-item-id-2', content: '' },
+                    { itemId: 'cwspr-item-id-3', content: '' },
+                ],
+                suggestionsStates: new Map([
+                    ['cwspr-item-id-1', 'Empty'],
+                    ['cwspr-item-id-2', 'Empty'],
+                    ['cwspr-item-id-3', 'Empty'],
+                ]),
+                acceptedSuggestionId: undefined,
+                responseContext: {
+                    requestId: 'cwspr-request-id',
                     codewhispererSessionId: 'cwspr-session-id',
-                    codewhispererFirstRequestId: 'cwspr-request-id',
-                    credentialStartUrl: 'teststarturl',
-                    codewhispererSuggestionState: 'Reject',
-                    codewhispererCompletionType: 'Line',
-                    codewhispererLanguage: 'csharp',
-                    codewhispererTriggerType: 'AutoTrigger',
-                    codewhispererAutomatedTriggerType: 'SpecialCharacters',
-                    codewhispererTriggerCharacter: '(',
-                    codewhispererLineNumber: 2,
-                    codewhispererCursorOffset: 21,
-                    codewhispererSuggestionCount: 3,
-                    codewhispererTotalShownTime: 0,
-                    codewhispererTypeaheadLength: 0,
-                    codewhispererTimeSinceLastDocumentChange: 0,
-                    codewhispererSupplementalContextTimeout: undefined,
-                    codewhispererSupplementalContextIsUtg: undefined,
-                    codewhispererSupplementalContextLength: undefined,
-                    ...override,
                 },
+                triggerType: 'AutoTrigger',
+                autoTriggerType: 'SpecialCharacters',
+                triggerCharacter: '(',
+                classifierResult: 0.46733811481459187,
+                classifierThreshold: 0.43,
+                language: 'csharp',
+                requestContext: {
+                    fileContext: {
+                        filename: 'file:///test.cs',
+                        programmingLanguage: {
+                            languageName: 'csharp',
+                        },
+                        leftFileContent: 'class HelloWorld\n{\n    static void Main(',
+                        rightFileContent: ')\n    {\n        Console.WriteLine("Hello World!");\n    }\n}\n',
+                    },
+                    maxResults: 1,
+                    supplementalContexts: [],
+                },
+                supplementalMetadata: undefined,
+                timeToFirstRecommendation: 2000,
+                credentialStartUrl: 'teststarturl',
+                completionSessionResult: undefined,
+                firstCompletionDisplayLatency: undefined,
+                totalSessionDisplayTime: undefined,
+                typeaheadLength: undefined,
+                previousTriggerDecision: undefined,
+                previousTriggerDecisionTime: undefined,
+                reportedUserDecision: true,
+                customizationArn: undefined,
+                ...override,
             };
         };
         describe('Case 1. Session is processed by server without sending results', () => {
@@ -192,10 +238,8 @@ describe('Telemetry', () => {
                 assert(currentSession);
                 assert.equal(currentSession.state, 'CLOSED');
                 ts_sinon_1.default.assert.calledOnceWithExactly(sessionManagerSpy.closeSession, currentSession);
-                const expectedUserTriggerDecisionMetric = aUserTriggerDecision({
-                    codewhispererSuggestionState: 'Empty',
-                });
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, expectedUserTriggerDecisionMetric);
+                const expectedUserTriggerDecisionMetric = aUserTriggerDecision();
+                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 0);
             });
             it('should send Empty User Decision when Codewhisperer returned empty list of suggestions', async () => {
                 const SUGGESTIONS = [];
@@ -206,11 +250,10 @@ describe('Telemetry', () => {
                 assert.equal(currentSession.state, 'CLOSED');
                 ts_sinon_1.default.assert.calledOnceWithExactly(sessionManagerSpy.closeSession, currentSession);
                 const expectedUserTriggerDecisionMetric = aUserTriggerDecision({
-                    codewhispererSuggestionState: 'Empty',
-                    codewhispererCompletionType: undefined,
-                    codewhispererSuggestionCount: 0,
+                    suggestions: [],
+                    suggestionsStates: new Map([]),
                 });
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, expectedUserTriggerDecisionMetric);
+                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 0);
             });
             it('should send Discard User Decision when all suggestions are filtered out by includeSuggestionsWithCodeReferences setting filter', async () => {
                 features.lsp.workspace.getConfiguration.returns(Promise.resolve({ includeSuggestionsWithCodeReferences: false }));
@@ -238,9 +281,30 @@ describe('Telemetry', () => {
                 assert.equal(currentSession.state, 'CLOSED');
                 ts_sinon_1.default.assert.calledOnceWithExactly(sessionManagerSpy.closeSession, currentSession);
                 const expectedUserTriggerDecisionMetric = aUserTriggerDecision({
-                    codewhispererSuggestionState: 'Discard',
+                    suggestions: [
+                        {
+                            itemId: 'cwspr-item-id-1',
+                            content: 'recommendation with reference',
+                            references: [EXPECTED_REFERENCE],
+                        },
+                        {
+                            itemId: 'cwspr-item-id-2',
+                            content: 'recommendation with reference',
+                            references: [EXPECTED_REFERENCE],
+                        },
+                        {
+                            itemId: 'cwspr-item-id-3',
+                            content: 'recommendation with reference',
+                            references: [EXPECTED_REFERENCE],
+                        },
+                    ],
+                    suggestionsStates: new Map([
+                        ['cwspr-item-id-1', 'Filter'],
+                        ['cwspr-item-id-2', 'Filter'],
+                        ['cwspr-item-id-3', 'Filter'],
+                    ]),
                 });
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, expectedUserTriggerDecisionMetric);
+                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 0);
             });
             it('should send Discard User Decision when all suggestions are discarded after right context merge', async () => {
                 const SUGGESTIONS = [
@@ -255,15 +319,68 @@ describe('Telemetry', () => {
                 assert.equal(currentSession?.state, 'CLOSED');
                 ts_sinon_1.default.assert.calledOnceWithExactly(sessionManagerSpy.closeSession, currentSession);
                 const expectedUserTriggerDecisionMetric = aUserTriggerDecision({
-                    codewhispererSuggestionState: 'Discard',
-                    codewhispererCompletionType: 'Block',
-                    codewhispererTriggerType: 'OnDemand',
-                    codewhispererAutomatedTriggerType: undefined,
-                    codewhispererTriggerCharacter: undefined,
-                    codewhispererLineNumber: 0,
-                    codewhispererCursorOffset: 0,
+                    startPosition: { line: 0, character: 0 },
+                    suggestions: [
+                        {
+                            itemId: 'cwspr-item-id-1',
+                            content: 'class HelloWorld\n' +
+                                '{\n' +
+                                '    static void Main()\n' +
+                                '    {\n' +
+                                '        Console.WriteLine("Hello World!");\n' +
+                                '    }\n' +
+                                '}\n',
+                        },
+                        {
+                            itemId: 'cwspr-item-id-2',
+                            content: 'class HelloWorld\n' +
+                                '{\n' +
+                                '    static void Main()\n' +
+                                '    {\n' +
+                                '        Console.WriteLine("Hello World!");\n' +
+                                '    }\n' +
+                                '}\n',
+                        },
+                        {
+                            itemId: 'cwspr-item-id-3',
+                            content: 'class HelloWorld\n' +
+                                '{\n' +
+                                '    static void Main()\n' +
+                                '    {\n' +
+                                '        Console.WriteLine("Hello World!");\n' +
+                                '    }\n' +
+                                '}\n',
+                        },
+                    ],
+                    suggestionsStates: new Map([
+                        ['cwspr-item-id-1', 'Discard'],
+                        ['cwspr-item-id-2', 'Discard'],
+                        ['cwspr-item-id-3', 'Discard'],
+                    ]),
+                    triggerType: 'OnDemand',
+                    autoTriggerType: undefined,
+                    triggerCharacter: '',
+                    classifierResult: -0.8524073111924992,
+                    requestContext: {
+                        fileContext: {
+                            filename: 'file:///test.cs',
+                            programmingLanguage: {
+                                languageName: 'csharp',
+                            },
+                            leftFileContent: '',
+                            rightFileContent: 'class HelloWorld\n' +
+                                '{\n' +
+                                '    static void Main()\n' +
+                                '    {\n' +
+                                '        Console.WriteLine("Hello World!");\n' +
+                                '    }\n' +
+                                '}\n',
+                        },
+                        maxResults: 5,
+                        supplementalContexts: [],
+                    },
                 });
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, expectedUserTriggerDecisionMetric);
+                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 0);
             });
         });
         describe('Case 2. Session returns recommendation to client and is closed by LogInlineCompletionSessionResults notification', () => {
@@ -274,13 +391,9 @@ describe('Telemetry', () => {
                 assert(currentSession);
                 assert.equal(currentSession?.state, 'ACTIVE');
                 ts_sinon_1.default.assert.notCalled(sessionManagerSpy.closeSession);
-                ts_sinon_1.default.assert.neverCalledWithMatch(features.telemetry.emitMetric, {
-                    name: 'codewhisperer_userTriggerDecision',
-                });
+                ts_sinon_1.default.assert.notCalled(telemetryServiceSpy);
                 await features.doLogInlineCompletionSessionResults(DEFAULT_SESSION_RESULT_DATA);
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, {
-                    name: 'codewhisperer_userTriggerDecision',
-                });
+                ts_sinon_1.default.assert.called(telemetryServiceSpy);
             });
             it('should emit User Decision event with correct typeaheadLength value when session results are received', async () => {
                 setServiceResponse(DEFAULT_SUGGESTIONS, EXPECTED_RESPONSE_CONTEXT);
@@ -289,19 +402,12 @@ describe('Telemetry', () => {
                 assert(currentSession);
                 assert.equal(currentSession?.state, 'ACTIVE');
                 ts_sinon_1.default.assert.notCalled(sessionManagerSpy.closeSession);
-                ts_sinon_1.default.assert.neverCalledWithMatch(features.telemetry.emitMetric, {
-                    name: 'codewhisperer_userTriggerDecision',
-                });
+                ts_sinon_1.default.assert.notCalled(telemetryServiceSpy);
                 await features.doLogInlineCompletionSessionResults({
                     ...DEFAULT_SESSION_RESULT_DATA,
                     typeaheadLength: 20,
                 });
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, {
-                    name: 'codewhisperer_userTriggerDecision',
-                    data: {
-                        codewhispererTypeaheadLength: 20,
-                    },
-                });
+                ts_sinon_1.default.assert.called(telemetryServiceSpy);
             });
             it('should not emit User Decision event when session results are received after session was closed', async () => {
                 setServiceResponse(DEFAULT_SUGGESTIONS, {
@@ -313,9 +419,7 @@ describe('Telemetry', () => {
                 assert(firstSession);
                 assert.equal(firstSession.state, 'ACTIVE');
                 ts_sinon_1.default.assert.notCalled(sessionManagerSpy.closeSession);
-                ts_sinon_1.default.assert.neverCalledWithMatch(features.telemetry.emitMetric, {
-                    name: 'codewhisperer_userTriggerDecision',
-                });
+                ts_sinon_1.default.assert.notCalled(telemetryServiceSpy);
                 // Send second completion request to close first one
                 setServiceResponse(DEFAULT_SUGGESTIONS, {
                     ...EXPECTED_RESPONSE_CONTEXT,
@@ -326,22 +430,32 @@ describe('Telemetry', () => {
                 assert.notEqual(firstSession, sessionManager.getCurrentSession());
                 ts_sinon_1.default.assert.calledWithExactly(sessionManagerSpy.closeSession, firstSession);
                 // Test that session reports it's status when second request is received
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, {
-                    name: 'codewhisperer_userTriggerDecision',
-                    data: {
+                const expectedEvent = aUserTriggerDecision({
+                    state: 'DISCARD',
+                    codewhispererSessionId: 'cwspr-session-id-1',
+                    suggestions: [
+                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
+                    ],
+                    suggestionsStates: new Map([
+                        ['cwspr-item-id-1', 'Discard'],
+                        ['cwspr-item-id-2', 'Discard'],
+                        ['cwspr-item-id-3', 'Discard'],
+                    ]),
+                    responseContext: {
+                        requestId: 'cwspr-request-id',
                         codewhispererSessionId: 'cwspr-session-id-1',
-                        codewhispererSuggestionState: 'Discard',
                     },
                 });
-                features.telemetry.emitMetric.resetHistory();
+                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedEvent, 0);
+                telemetryServiceSpy.resetHistory();
                 // Send session results for closed first session
                 await features.doLogInlineCompletionSessionResults({
                     ...DEFAULT_SESSION_RESULT_DATA,
                     sessionId: firstSession.id,
                 });
-                ts_sinon_1.default.assert.neverCalledWithMatch(features.telemetry.emitMetric, {
-                    name: 'codewhisperer_userTriggerDecision',
-                });
+                ts_sinon_1.default.assert.notCalled(telemetryServiceSpy);
             });
             it('should not emit User Decision event when session results received for session that does not exist', async () => {
                 // Send session results for closed first session
@@ -349,12 +463,7 @@ describe('Telemetry', () => {
                     ...DEFAULT_SESSION_RESULT_DATA,
                     sessionId: 'cwspr-session-id-never-created',
                 });
-                ts_sinon_1.default.assert.neverCalledWithMatch(features.telemetry.emitMetric, {
-                    name: 'codewhisperer_userTriggerDecision',
-                    data: {
-                        codewhispererSessionId: 'cwspr-session-id-never-created',
-                    },
-                });
+                ts_sinon_1.default.assert.notCalled(telemetryServiceSpy);
             });
             it('should emit Accept User Decision event for current active completion session when session results are received with accepted suggestion', async () => {
                 setServiceResponse(DEFAULT_SUGGESTIONS, EXPECTED_RESPONSE_CONTEXT);
@@ -379,15 +488,28 @@ describe('Telemetry', () => {
                     },
                 };
                 await autoTriggerInlineCompletionWithReferences();
-                ts_sinon_1.default.assert.neverCalledWithMatch(features.telemetry.emitMetric, {
-                    name: 'codewhisperer_userTriggerDecision',
-                });
+                ts_sinon_1.default.assert.notCalled(telemetryServiceSpy);
                 // Send session results for closed first session
                 await features.doLogInlineCompletionSessionResults(SESSION_RESULT_DATA);
                 const expectedUserTriggerDecisionMetric = aUserTriggerDecision({
-                    codewhispererSuggestionState: 'Accept',
+                    completionSessionResult: {
+                        'cwspr-item-id-1': { seen: true, accepted: false, discarded: false },
+                        'cwspr-item-id-2': { seen: true, accepted: true, discarded: false },
+                        'cwspr-item-id-3': { seen: true, accepted: false, discarded: false },
+                    },
+                    suggestions: [
+                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
+                    ],
+                    suggestionsStates: new Map([
+                        ['cwspr-item-id-1', 'Ignore'],
+                        ['cwspr-item-id-2', 'Accept'],
+                        ['cwspr-item-id-3', 'Ignore'],
+                    ]),
+                    acceptedSuggestionId: 'cwspr-item-id-2',
                 });
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, expectedUserTriggerDecisionMetric);
+                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 0);
             });
             it('should emit Reject User Decision event for current active completion session when session results are received without accepted suggestion', async () => {
                 setServiceResponse(DEFAULT_SUGGESTIONS, EXPECTED_RESPONSE_CONTEXT);
@@ -412,15 +534,27 @@ describe('Telemetry', () => {
                     },
                 };
                 await autoTriggerInlineCompletionWithReferences();
-                ts_sinon_1.default.assert.neverCalledWithMatch(features.telemetry.emitMetric, {
-                    name: 'codewhisperer_userTriggerDecision',
-                });
+                ts_sinon_1.default.assert.notCalled(telemetryServiceSpy);
                 // Send session results for closed first session
                 await features.doLogInlineCompletionSessionResults(SESSION_RESULT_DATA);
                 const expectedUserTriggerDecisionMetric = aUserTriggerDecision({
-                    codewhispererSuggestionState: 'Reject',
+                    suggestions: [
+                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
+                    ],
+                    suggestionsStates: new Map([
+                        ['cwspr-item-id-1', 'Reject'],
+                        ['cwspr-item-id-2', 'Discard'],
+                        ['cwspr-item-id-3', 'Discard'],
+                    ]),
+                    completionSessionResult: {
+                        'cwspr-item-id-1': { seen: true, accepted: false, discarded: false },
+                        'cwspr-item-id-2': { seen: false, accepted: false, discarded: true },
+                        'cwspr-item-id-3': { seen: false, accepted: false, discarded: true },
+                    },
                 });
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, expectedUserTriggerDecisionMetric);
+                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 0);
             });
             it('should send Discard User Decision when all suggestions have Discard state', async () => {
                 setServiceResponse(DEFAULT_SUGGESTIONS, EXPECTED_RESPONSE_CONTEXT);
@@ -445,15 +579,27 @@ describe('Telemetry', () => {
                     },
                 };
                 await autoTriggerInlineCompletionWithReferences();
-                ts_sinon_1.default.assert.neverCalledWithMatch(features.telemetry.emitMetric, {
-                    name: 'codewhisperer_userTriggerDecision',
-                });
+                ts_sinon_1.default.assert.notCalled(telemetryServiceSpy);
                 // Send session results for closed first session
                 await features.doLogInlineCompletionSessionResults(SESSION_RESULT_DATA);
                 const expectedUserTriggerDecisionMetric = aUserTriggerDecision({
-                    codewhispererSuggestionState: 'Discard',
+                    suggestions: [
+                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
+                    ],
+                    suggestionsStates: new Map([
+                        ['cwspr-item-id-1', 'Discard'],
+                        ['cwspr-item-id-2', 'Discard'],
+                        ['cwspr-item-id-3', 'Discard'],
+                    ]),
+                    completionSessionResult: {
+                        'cwspr-item-id-1': { seen: false, accepted: false, discarded: true },
+                        'cwspr-item-id-2': { seen: false, accepted: false, discarded: true },
+                        'cwspr-item-id-3': { seen: false, accepted: false, discarded: true },
+                    },
                 });
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, expectedUserTriggerDecisionMetric);
+                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 0);
             });
             it('should set codewhispererTimeSinceLastDocumentChange as difference between 2 any document changes', async () => {
                 const typeSomething = async () => await features.doChangeTextDocument({
@@ -473,10 +619,24 @@ describe('Telemetry', () => {
                 await typeSomething();
                 await features.doLogInlineCompletionSessionResults(DEFAULT_SESSION_RESULT_DATA);
                 const expectedUserTriggerDecisionMetric = aUserTriggerDecision({
-                    codewhispererSuggestionState: 'Reject',
-                    codewhispererTimeSinceLastDocumentChange: 5678,
+                    completionSessionResult: {
+                        'cwspr-item-id-1': { seen: true, accepted: false, discarded: false },
+                        'cwspr-item-id-2': { seen: true, accepted: false, discarded: false },
+                        'cwspr-item-id-3': { seen: true, accepted: false, discarded: false },
+                    },
+                    suggestions: [
+                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
+                    ],
+                    suggestionsStates: new Map([
+                        ['cwspr-item-id-1', 'Reject'],
+                        ['cwspr-item-id-2', 'Reject'],
+                        ['cwspr-item-id-3', 'Reject'],
+                    ]),
+                    closeTime: clock.now,
                 });
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, expectedUserTriggerDecisionMetric);
+                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 5678);
             });
         });
         describe('Case 3. Active session is closed by subsequent trigger', function () {
@@ -492,16 +652,27 @@ describe('Telemetry', () => {
                 });
                 await manualTriggerInlineCompletionWithReferences();
                 const expectedUserTriggerDecisionMetric = aUserTriggerDecision({
+                    state: 'DISCARD',
                     codewhispererSessionId: 'cwspr-session-id-1',
-                    codewhispererSuggestionState: 'Discard',
-                });
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, expectedUserTriggerDecisionMetric);
-                ts_sinon_1.default.assert.neverCalledWithMatch(features.telemetry.emitMetric, {
-                    name: 'codewhisperer_userTriggerDecision',
-                    data: {
-                        codewhispererSessionId: 'cwspr-session-id-2',
+                    suggestions: [
+                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
+                    ],
+                    suggestionsStates: new Map([
+                        ['cwspr-item-id-1', 'Discard'],
+                        ['cwspr-item-id-2', 'Discard'],
+                        ['cwspr-item-id-3', 'Discard'],
+                    ]),
+                    responseContext: {
+                        requestId: 'cwspr-request-id',
+                        codewhispererSessionId: 'cwspr-session-id-1',
                     },
                 });
+                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 0);
+                ts_sinon_1.default.assert.neverCalledWithMatch(telemetryServiceSpy, {
+                    codewhispererSessionId: 'cwspr-session-id-2',
+                }, 0);
             });
             it('should close ACTIVE session and emit Discard user trigger decision event on Auto trigger', async () => {
                 setServiceResponse(DEFAULT_SUGGESTIONS, {
@@ -515,16 +686,27 @@ describe('Telemetry', () => {
                 });
                 await autoTriggerInlineCompletionWithReferences();
                 const expectedUserTriggerDecisionMetric = aUserTriggerDecision({
+                    state: 'DISCARD',
                     codewhispererSessionId: 'cwspr-session-id-1',
-                    codewhispererSuggestionState: 'Discard',
-                });
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, expectedUserTriggerDecisionMetric);
-                ts_sinon_1.default.assert.neverCalledWithMatch(features.telemetry.emitMetric, {
-                    name: 'codewhisperer_userTriggerDecision',
-                    data: {
-                        codewhispererSessionId: 'cwspr-session-id-2',
+                    suggestions: [
+                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
+                    ],
+                    suggestionsStates: new Map([
+                        ['cwspr-item-id-1', 'Discard'],
+                        ['cwspr-item-id-2', 'Discard'],
+                        ['cwspr-item-id-3', 'Discard'],
+                    ]),
+                    responseContext: {
+                        requestId: 'cwspr-request-id',
+                        codewhispererSessionId: 'cwspr-session-id-1',
                     },
                 });
+                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 0);
+                ts_sinon_1.default.assert.neverCalledWithMatch(telemetryServiceSpy, {
+                    codewhispererSessionId: 'cwspr-session-id-2',
+                }, 0);
             });
             it('should attach previous session trigger decision', async () => {
                 setServiceResponse(DEFAULT_SUGGESTIONS, {
@@ -543,22 +725,76 @@ describe('Telemetry', () => {
                     codewhispererSessionId: 'cwspr-session-id-3',
                 });
                 await autoTriggerInlineCompletionWithReferences();
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, aUserTriggerDecision({
+                ts_sinon_1.default.assert.calledTwice(telemetryServiceSpy);
+                const firstCallArgs = telemetryServiceSpy.getCall(0).args[0];
+                const secondCallArgs = telemetryServiceSpy.getCall(1).args[0];
+                ts_sinon_1.default.assert.match(firstCallArgs, {
+                    id: 'some-random-session-uuid-0',
+                    document: {
+                        _uri: 'file:///test.cs',
+                        _languageId: 'csharp',
+                        _version: 1,
+                        _content: 'class HelloWorld\n{\n    static void Main()\n    {\n        Console.WriteLine("Hello World!");\n    }\n}\n',
+                        _lineOffsets: [0, 17, 19, 42, 48, 91, 97, 99],
+                    },
+                    startTime: 1483228800000,
+                    closeTime: 1483228802000,
+                    state: 'DISCARD',
                     codewhispererSessionId: 'cwspr-session-id-1',
-                    codewhispererSuggestionState: 'Discard',
-                }));
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, aUserTriggerDecision({
-                    codewhispererSessionId: 'cwspr-session-id-2',
-                    codewhispererSuggestionState: 'Discard',
-                    codewhispererPreviousSuggestionState: firstSession?.getAggregatedUserTriggerDecision(), // 'Discard'
-                    codewhispererTimeSinceLastUserDecision: 0,
-                }));
-                ts_sinon_1.default.assert.neverCalledWithMatch(features.telemetry.emitMetric, {
-                    name: 'codewhisperer_userTriggerDecision',
-                    data: {
-                        codewhispererSessionId: 'cwspr-session-id-3',
+                    startPosition: { line: 2, character: 21 },
+                    suggestions: [
+                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
+                    ],
+                    suggestionsStates: {},
+                    responseContext: { requestId: 'cwspr-request-id', codewhispererSessionId: 'cwspr-session-id-1' },
+                    triggerType: 'AutoTrigger',
+                    autoTriggerType: 'SpecialCharacters',
+                    triggerCharacter: '(',
+                    classifierResult: 0.46733811481459187,
+                    classifierThreshold: 0.43,
+                    language: 'csharp',
+                    requestContext: {
+                        fileContext: {
+                            filename: 'file:///test.cs',
+                            programmingLanguage: { languageName: 'csharp' },
+                            leftFileContent: 'class HelloWorld\n{\n    static void Main(',
+                            rightFileContent: ')\n    {\n        Console.WriteLine("Hello World!");\n    }\n}\n',
+                        },
+                        maxResults: 1,
+                        supplementalContexts: [],
                     },
+                    timeToFirstRecommendation: 2000,
+                    credentialStartUrl: 'teststarturl',
+                    reportedUserDecision: true,
                 });
+                ts_sinon_1.default.assert.match(secondCallArgs, aUserTriggerDecision({
+                    previousTriggerDecision: 'Discard',
+                    previousTriggerDecisionTime: 1483228802000,
+                    responseContext: {
+                        requestId: 'cwspr-request-id',
+                        codewhispererSessionId: 'cwspr-session-id-2',
+                    },
+                    id: 'some-random-session-uuid-1',
+                    startTime: 1483228802000,
+                    closeTime: 1483228804000,
+                    state: 'DISCARD',
+                    codewhispererSessionId: 'cwspr-session-id-2',
+                    suggestions: [
+                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
+                    ],
+                    suggestionsStates: new Map([
+                        ['cwspr-item-id-1', 'Discard'],
+                        ['cwspr-item-id-2', 'Discard'],
+                        ['cwspr-item-id-3', 'Discard'],
+                    ]),
+                }));
+                ts_sinon_1.default.assert.neverCalledWithMatch(telemetryServiceSpy, aUserTriggerDecision({
+                    codewhispererSessionId: 'cwspr-session-id-3',
+                }), 0);
             });
             it('should set correct values for past trigger result fields', async () => {
                 setServiceResponse(DEFAULT_SUGGESTIONS, {
@@ -577,19 +813,100 @@ describe('Telemetry', () => {
                 // Trigger 3rd session to close second one
                 await autoTriggerInlineCompletionWithReferences();
                 // For first session previous data does not exist
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, aUserTriggerDecision({
+                ts_sinon_1.default.assert.calledTwice(telemetryServiceSpy);
+                const firstCallArgs = telemetryServiceSpy.getCall(0).args[0];
+                const secondCallArgs = telemetryServiceSpy.getCall(1).args[0];
+                ts_sinon_1.default.assert.match(firstCallArgs, aUserTriggerDecision({
+                    previousTriggerDecision: undefined,
+                    previousTriggerDecisionTime: undefined,
+                    responseContext: {
+                        requestId: 'cwspr-request-id',
+                        codewhispererSessionId: 'cwspr-session-id-1',
+                    },
+                    id: 'some-random-session-uuid-0',
+                    startTime: 1483228800000,
+                    closeTime: 1483228802000,
+                    state: 'CLOSED',
                     codewhispererSessionId: 'cwspr-session-id-1',
-                    codewhispererSuggestionState: 'Reject',
-                    codewhispererTimeSinceLastUserDecision: undefined,
-                    codewhispererPreviousSuggestionState: undefined,
+                    suggestions: [
+                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
+                    ],
+                    suggestionsStates: new Map([
+                        ['cwspr-item-id-1', 'Reject'],
+                        ['cwspr-item-id-2', 'Reject'],
+                        ['cwspr-item-id-3', 'Reject'],
+                    ]),
+                    completionSessionResult: {
+                        'cwspr-item-id-1': { seen: true, accepted: false, discarded: false },
+                        'cwspr-item-id-2': { seen: true, accepted: false, discarded: false },
+                        'cwspr-item-id-3': { seen: true, accepted: false, discarded: false },
+                    },
                 }));
-                // For second session previous data matches
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, aUserTriggerDecision({
+                ts_sinon_1.default.assert.match(secondCallArgs, {
+                    id: 'some-random-session-uuid-1',
+                    document: {
+                        _uri: 'file:///test.cs',
+                        _languageId: 'csharp',
+                        _version: 1,
+                        _content: 'class HelloWorld\n{\n    static void Main()\n    {\n        Console.WriteLine("Hello World!");\n    }\n}\n',
+                        _lineOffsets: [0, 17, 19, 42, 48, 91, 97, 99],
+                    },
+                    startTime: 1483228803234,
+                    closeTime: 1483228805234,
+                    state: 'DISCARD',
                     codewhispererSessionId: 'cwspr-session-id-2',
-                    codewhispererSuggestionState: 'Discard',
-                    codewhispererPreviousSuggestionState: firstSession?.getAggregatedUserTriggerDecision(), // 'Reject'
-                    codewhispererTimeSinceLastUserDecision: 1234,
-                }));
+                    startPosition: {
+                        line: 2,
+                        character: 21,
+                    },
+                    suggestions: [
+                        {
+                            itemId: 'cwspr-item-id-1',
+                            content: 'recommendation',
+                            insertText: 'recommendation',
+                        },
+                        {
+                            itemId: 'cwspr-item-id-2',
+                            content: 'recommendation',
+                            insertText: 'recommendation',
+                        },
+                        {
+                            itemId: 'cwspr-item-id-3',
+                            content: 'recommendation',
+                            insertText: 'recommendation',
+                        },
+                    ],
+                    suggestionsStates: {},
+                    responseContext: {
+                        requestId: 'cwspr-request-id',
+                        codewhispererSessionId: 'cwspr-session-id-2',
+                    },
+                    triggerType: 'AutoTrigger',
+                    autoTriggerType: 'SpecialCharacters',
+                    triggerCharacter: '(',
+                    classifierResult: 0.30173811481459184,
+                    classifierThreshold: 0.43,
+                    language: 'csharp',
+                    requestContext: {
+                        fileContext: {
+                            filename: 'file:///test.cs',
+                            programmingLanguage: {
+                                languageName: 'csharp',
+                            },
+                            leftFileContent: 'class HelloWorld\n{\n    static void Main(',
+                            rightFileContent: ')\n    {\n        Console.WriteLine("Hello World!");\n    }\n}\n',
+                        },
+                        maxResults: 1,
+                        supplementalContexts: [],
+                    },
+                    timeToFirstRecommendation: 2000,
+                    credentialStartUrl: 'teststarturl',
+                    previousTriggerDecision: 'Reject',
+                    previousTriggerDecisionTime: 1483228802000,
+                    reportedUserDecision: true,
+                });
             });
         });
         describe('Case 4. Inflight session is closed by subsequent completion request', function () {
@@ -624,34 +941,110 @@ describe('Telemetry', () => {
                 ]);
                 // 3 sessions were created, each one closes previous one in REQUESTING state
                 assert.equal(SESSION_IDS_LOG.length, 3);
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, aUserTriggerDecision({
+                ts_sinon_1.default.assert.calledTwice(telemetryServiceSpy);
+                const firstCallArgs = telemetryServiceSpy.getCall(0).args[0];
+                const secondCallArgs = telemetryServiceSpy.getCall(1).args[0];
+                ts_sinon_1.default.assert.match(firstCallArgs, aUserTriggerDecision({
                     codewhispererSessionId: 'cwspr-session-id-0',
-                    codewhispererSuggestionState: 'Discard',
-                    codewhispererTimeToFirstRecommendation: 1260,
+                    state: 'DISCARD',
+                    suggestions: [
+                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
+                    ],
+                    suggestionsStates: new Map([
+                        ['cwspr-item-id-1', 'Discard'],
+                        ['cwspr-item-id-2', 'Discard'],
+                        ['cwspr-item-id-3', 'Discard'],
+                    ]),
+                    responseContext: {
+                        requestId: 'cwspr-request-id',
+                        codewhispererSessionId: 'cwspr-session-id-0',
+                    },
+                    timeToFirstRecommendation: 1260,
+                    closeTime: 1483228801000,
                 }));
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, aUserTriggerDecision({
+                ts_sinon_1.default.assert.match(secondCallArgs, {
+                    id: 'some-random-session-uuid-1',
+                    document: {
+                        _uri: 'file:///test.cs',
+                        _languageId: 'csharp',
+                        _version: 1,
+                        _content: 'class HelloWorld\n{\n    static void Main()\n    {\n        Console.WriteLine("Hello World!");\n    }\n}\n',
+                        _lineOffsets: [0, 17, 19, 42, 48, 91, 97, 99],
+                    },
+                    startTime: 1483228801260,
+                    closeTime: 1483228802260,
+                    state: 'DISCARD',
                     codewhispererSessionId: 'cwspr-session-id-1',
-                    codewhispererSuggestionState: 'Discard',
-                    codewhispererTimeToFirstRecommendation: 1260,
-                    codewhispererPreviousSuggestionState: 'Discard',
-                }));
-                ts_sinon_1.default.assert.neverCalledWithMatch(features.telemetry.emitMetric, aUserTriggerDecision({
+                    startPosition: { line: 2, character: 21 },
+                    suggestions: [
+                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
+                    ],
+                    suggestionsStates: {},
+                    responseContext: { requestId: 'cwspr-request-id', codewhispererSessionId: 'cwspr-session-id-1' },
+                    triggerType: 'AutoTrigger',
+                    autoTriggerType: 'SpecialCharacters',
+                    triggerCharacter: '(',
+                    classifierResult: 0.46733811481459187,
+                    classifierThreshold: 0.43,
+                    language: 'csharp',
+                    requestContext: {
+                        fileContext: {
+                            filename: 'file:///test.cs',
+                            programmingLanguage: { languageName: 'csharp' },
+                            leftFileContent: 'class HelloWorld\n{\n    static void Main(',
+                            rightFileContent: ')\n    {\n        Console.WriteLine("Hello World!");\n    }\n}\n',
+                        },
+                        maxResults: 1,
+                        supplementalContexts: [],
+                    },
+                    timeToFirstRecommendation: 1260,
+                    credentialStartUrl: 'teststarturl',
+                    previousTriggerDecision: 'Discard',
+                    previousTriggerDecisionTime: 1483228801000,
+                    reportedUserDecision: true,
+                });
+                ts_sinon_1.default.assert.neverCalledWithMatch(telemetryServiceSpy, {
                     codewhispererSessionId: 'cwspr-session-id-2',
-                    codewhispererSuggestionState: 'Empty',
-                }));
+                });
+                telemetryServiceSpy.resetHistory();
                 const activeSession = sessionManager.getActiveSession();
                 assert.equal(activeSession?.id, SESSION_IDS_LOG[2]);
                 await features.doLogInlineCompletionSessionResults({
                     ...DEFAULT_SESSION_RESULT_DATA,
                     sessionId: SESSION_IDS_LOG[2],
                 });
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, aUserTriggerDecision({
+                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, aUserTriggerDecision({
+                    id: 'some-random-session-uuid-2',
+                    startTime: 1483228802520,
+                    closeTime: 1483228803770,
                     codewhispererSessionId: 'cwspr-session-id-2',
-                    codewhispererSuggestionState: 'Reject',
-                    codewhispererTimeSinceLastUserDecision: 260,
-                    codewhispererPreviousSuggestionState: 'Discard',
-                    codewhispererTimeToFirstRecommendation: 1250,
-                }));
+                    suggestions: [
+                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
+                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
+                    ],
+                    suggestionsStates: new Map([
+                        ['cwspr-item-id-1', 'Reject'],
+                        ['cwspr-item-id-2', 'Reject'],
+                        ['cwspr-item-id-3', 'Reject'],
+                    ]),
+                    previousTriggerDecision: 'Discard',
+                    previousTriggerDecisionTime: 1483228802260,
+                    timeToFirstRecommendation: 1250,
+                    completionSessionResult: {
+                        'cwspr-item-id-1': { seen: true, accepted: false, discarded: false },
+                        'cwspr-item-id-2': { seen: true, accepted: false, discarded: false },
+                        'cwspr-item-id-3': { seen: true, accepted: false, discarded: false },
+                    },
+                    responseContext: {
+                        requestId: 'cwspr-request-id',
+                        codewhispererSessionId: 'cwspr-session-id-2',
+                    },
+                }), 0);
             });
         });
         it('should report user trigger decision only once for a session', async () => {
@@ -661,19 +1054,33 @@ describe('Telemetry', () => {
             });
             await autoTriggerInlineCompletionWithReferences();
             const firstSession = sessionManager.getCurrentSession();
-            ts_sinon_1.default.assert.neverCalledWithMatch(features.telemetry.emitMetric, {
-                name: 'codewhisperer_userTriggerDecision',
-            });
+            ts_sinon_1.default.assert.neverCalledWithMatch(telemetryServiceSpy);
             // Record session results and close the session
             await features.doLogInlineCompletionSessionResults(DEFAULT_SESSION_RESULT_DATA);
-            ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, {
-                name: 'codewhisperer_userTriggerDecision',
-                data: {
+            ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, aUserTriggerDecision({
+                codewhispererSessionId: 'cwspr-session-id-1',
+                suggestions: [
+                    { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
+                    { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
+                    { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
+                ],
+                suggestionsStates: new Map([
+                    ['cwspr-item-id-1', 'Reject'],
+                    ['cwspr-item-id-2', 'Reject'],
+                    ['cwspr-item-id-3', 'Reject'],
+                ]),
+                responseContext: {
+                    requestId: 'cwspr-request-id',
                     codewhispererSessionId: 'cwspr-session-id-1',
                 },
-            });
+                completionSessionResult: {
+                    'cwspr-item-id-1': { seen: true, accepted: false, discarded: false },
+                    'cwspr-item-id-2': { seen: true, accepted: false, discarded: false },
+                    'cwspr-item-id-3': { seen: true, accepted: false, discarded: false },
+                },
+            }), 0);
             assert.equal(firstSession?.state, 'CLOSED');
-            features.telemetry.emitMetric.resetHistory();
+            telemetryServiceSpy.resetHistory();
             // Triggering new completion request creates new session
             // and should not emit telemetry for previous session, which was closed earlier
             setServiceResponse(DEFAULT_SUGGESTIONS, {
@@ -683,12 +1090,9 @@ describe('Telemetry', () => {
             await autoTriggerInlineCompletionWithReferences();
             // Or attempt to record data
             await features.doLogInlineCompletionSessionResults(DEFAULT_SESSION_RESULT_DATA);
-            ts_sinon_1.default.assert.neverCalledWithMatch(features.telemetry.emitMetric, {
-                name: 'codewhisperer_userTriggerDecision',
-                data: {
-                    codewhispererSessionId: 'cwspr-session-id-1',
-                },
-            });
+            ts_sinon_1.default.assert.neverCalledWithMatch(telemetryServiceSpy, {
+                codewhispererSessionId: 'cwspr-session-id-1',
+            }, 0);
         });
     });
     describe('User Decision Telemetry', () => {