[Telemetry] Remove from and to timestamps from usage stats APIs (#81579)

Co-authored-by: Kibana Machine <42973632+kibanamachine@users.noreply.github.com>

Author: Bamieh

src/plugins/telemetry/public/services/telemetry_service.test.ts

@@ -18,42 +18,30 @@
  */
 
 /* eslint-disable dot-notation */
-import { mockTelemetryService } from '../mocks';
-
-const mockSubtract = jest.fn().mockImplementation(() => {
-  return {
-    toISOString: jest.fn(),
-  };
-});
-
-const mockClone = jest.fn().mockImplementation(() => {
-  return {
-    clone: mockClone,
-    subtract: mockSubtract,
-    toISOString: jest.fn(),
-  };
-});
+const mockMomentValueOf = jest.fn();
 
 jest.mock('moment', () => {
   return jest.fn().mockImplementation(() => {
     return {
-      clone: mockClone,
-      subtract: mockSubtract,
-      toISOString: jest.fn(),
+      valueOf: mockMomentValueOf,
     };
   });
 });
 
+import { mockTelemetryService } from '../mocks';
+
 describe('TelemetryService', () => {
   describe('fetchTelemetry', () => {
     it('calls expected URL with 20 minutes - now', async () => {
+      const timestamp = Date.now();
+      mockMomentValueOf.mockReturnValueOnce(timestamp);
       const telemetryService = mockTelemetryService();
+
       await telemetryService.fetchTelemetry();
       expect(telemetryService['http'].post).toBeCalledWith('/api/telemetry/v2/clusters/_stats', {
-        body: JSON.stringify({ unencrypted: false, timeRange: {} }),
+        body: JSON.stringify({ unencrypted: false, timestamp }),
       });
-      expect(mockClone).toBeCalled();
-      expect(mockSubtract).toBeCalledWith(20, 'minutes');
+      expect(mockMomentValueOf).toBeCalled();
     });
   });
 

src/plugins/telemetry/public/services/telemetry_service.ts

@@ -121,17 +121,10 @@ export class TelemetryService {
   };
 
   public fetchTelemetry = async ({ unencrypted = false } = {}) => {
-    const now = moment();
     return this.http.post('/api/telemetry/v2/clusters/_stats', {
       body: JSON.stringify({
         unencrypted,
-        timeRange: {
-          min: now
-            .clone() // Need to clone it to avoid mutation (and max being the same value)
-            .subtract(20, 'minutes')
-            .toISOString(),
-          max: now.toISOString(),
-        },
+        timestamp: moment().valueOf(),
       }),
     });
   };

src/plugins/telemetry/server/fetcher.ts

@@ -213,8 +213,7 @@ export class FetcherTask {
   private async fetchTelemetry() {
     return await this.telemetryCollectionManager!.getStats({
       unencrypted: false,
-      start: moment().subtract(20, 'minutes').toISOString(),
-      end: moment().toISOString(),
+      timestamp: moment().valueOf(),
     });
   }
 

src/plugins/telemetry/server/routes/telemetry_opt_in.ts

@@ -86,8 +86,7 @@ export function registerTelemetryOptInRoutes({
       }
 
       const statsGetterConfig: StatsGetterConfig = {
-        start: moment().subtract(20, 'minutes').toISOString(),
-        end: moment().toISOString(),
+        timestamp: moment().valueOf(),
         unencrypted: false,
       };
 

src/plugins/telemetry/server/routes/telemetry_opt_in_stats.ts

@@ -72,8 +72,7 @@ export function registerTelemetryOptInStatsRoutes(
         const unencrypted = req.body.unencrypted;
 
         const statsGetterConfig: StatsGetterConfig = {
-          start: moment().subtract(20, 'minutes').toISOString(),
-          end: moment().toISOString(),
+          timestamp: moment().valueOf(),
           unencrypted,
           request: req,
         };

src/plugins/telemetry/server/routes/telemetry_usage_stats.ts

@@ -32,8 +32,6 @@ const validate: TypeOptions<string | number>['validate'] = (value) => {
   }
 };
 
-const dateSchema = schema.oneOf([schema.string({ validate }), schema.number({ validate })]);
-
 export function registerTelemetryUsageStatsRoutes(
   router: IRouter,
   telemetryCollectionManager: TelemetryCollectionManagerPluginSetup,
@@ -45,25 +43,20 @@ export function registerTelemetryUsageStatsRoutes(
       validate: {
         body: schema.object({
           unencrypted: schema.boolean({ defaultValue: false }),
-          timeRange: schema.object({
-            min: dateSchema,
-            max: dateSchema,
-          }),
+          timestamp: schema.oneOf([schema.string({ validate }), schema.number({ validate })]),
         }),
       },
     },
     async (context, req, res) => {
-      const start = moment(req.body.timeRange.min).toISOString();
-      const end = moment(req.body.timeRange.max).toISOString();
-      const unencrypted = req.body.unencrypted;
+      const { unencrypted, timestamp } = req.body;
 
       try {
         const statsConfig: StatsGetterConfig = {
-          unencrypted,
-          start,
-          end,
+          timestamp: moment(timestamp).valueOf(),
           request: req,
+          unencrypted,
         };
+
         const stats = await telemetryCollectionManager.getStats(statsConfig);
         return res.ok({ body: stats });
       } catch (err) {

src/plugins/telemetry/server/telemetry_collection/get_local_stats.test.ts

@@ -87,8 +87,7 @@ function mockStatsCollectionConfig(clusterInfo: any, clusterStats: any, kibana:
     ...createCollectorFetchContextMock(),
     esClient: mockGetLocalStats(clusterInfo, clusterStats),
     usageCollection: mockUsageCollection(kibana),
-    start: '',
-    end: '',
+    timestamp: Date.now(),
   };
 }
 

src/plugins/telemetry_collection_manager/server/plugin.ts

@@ -144,7 +144,7 @@ export class TelemetryCollectionManagerPlugin
     collectionSoService: SavedObjectsServiceStart,
     usageCollection: UsageCollectionSetup
   ): StatsCollectionConfig {
-    const { start, end, request } = config;
+    const { timestamp, request } = config;
 
     const callCluster = config.unencrypted
       ? collection.esCluster.asScoped(request).callAsCurrentUser
@@ -157,7 +157,7 @@ export class TelemetryCollectionManagerPlugin
     const soClient = config.unencrypted
       ? collectionSoService.getScopedClient(config.request)
       : collectionSoService.createInternalRepository();
-    return { callCluster, start, end, usageCollection, esClient, soClient };
+    return { callCluster, timestamp, usageCollection, esClient, soClient };
   }
 
   private async getOptInStats(optInStatus: boolean, config: StatsGetterConfig) {

src/plugins/telemetry_collection_manager/server/types.ts

@@ -56,8 +56,7 @@ export interface TelemetryOptInStats {
 
 export interface BaseStatsGetterConfig {
   unencrypted: boolean;
-  start: string;
-  end: string;
+  timestamp: number;
   request?: KibanaRequest;
 }
 
@@ -77,8 +76,7 @@ export interface ClusterDetails {
 export interface StatsCollectionConfig {
   usageCollection: UsageCollectionSetup;
   callCluster: LegacyAPICaller;
-  start: string | number;
-  end: string | number;
+  timestamp: number;
   esClient: ElasticsearchClient;
   soClient: SavedObjectsClientContract | ISavedObjectsRepository;
 }

test/api_integration/apis/telemetry/telemetry_local.js

@@ -53,15 +53,12 @@ export default function ({ getService }) {
     });
 
     it('should pull local stats and validate data types', async () => {
-      const timeRange = {
-        min: '2018-07-23T22:07:00Z',
-        max: '2018-07-23T22:13:00Z',
-      };
+      const timestamp = '2018-07-23T22:13:00Z';
 
       const { body } = await supertest
         .post('/api/telemetry/v2/clusters/_stats')
         .set('kbn-xsrf', 'xxx')
-        .send({ timeRange, unencrypted: true })
+        .send({ timestamp, unencrypted: true })
         .expect(200);
 
       expect(body.length).to.be(1);
@@ -98,15 +95,12 @@ export default function ({ getService }) {
     });
 
     it('should pull local stats and validate fields', async () => {
-      const timeRange = {
-        min: '2018-07-23T22:07:00Z',
-        max: '2018-07-23T22:13:00Z',
-      };
+      const timestamp = '2018-07-23T22:13:00Z';
 
       const { body } = await supertest
         .post('/api/telemetry/v2/clusters/_stats')
         .set('kbn-xsrf', 'xxx')
-        .send({ timeRange, unencrypted: true })
+        .send({ timestamp, unencrypted: true })
         .expect(200);
 
       const stats = body[0];
@@ -156,10 +150,7 @@ export default function ({ getService }) {
     });
 
     describe('application usage limits', () => {
-      const timeRange = {
-        min: '2018-07-23T22:07:00Z',
-        max: '2018-07-23T22:13:00Z',
-      };
+      const timestamp = '2018-07-23T22:13:00Z';
 
       function createSavedObject() {
         return supertest
@@ -191,7 +182,7 @@ export default function ({ getService }) {
           const { body } = await supertest
             .post('/api/telemetry/v2/clusters/_stats')
             .set('kbn-xsrf', 'xxx')
-            .send({ timeRange, unencrypted: true })
+            .send({ timestamp, unencrypted: true })
             .expect(200);
 
           expect(body.length).to.be(1);
@@ -242,7 +233,7 @@ export default function ({ getService }) {
           const { body } = await supertest
             .post('/api/telemetry/v2/clusters/_stats')
             .set('kbn-xsrf', 'xxx')
-            .send({ timeRange, unencrypted: true })
+            .send({ timestamp, unencrypted: true })
             .expect(200);
 
           expect(body.length).to.be(1);