Initialize transport service in Performance Monitoring when performance() is called. (#2506)

* Initialize transport service after performance() is called.

* Run transport service setup only once.

* Add @ts-ignore and update naming of transportHandler.

* Remove done() and start transport timer right after component API instance is ready.

Author: zijianjoy

packages/performance/src/controllers/perf.ts

@@ -22,10 +22,12 @@ import { Api } from '../services/api_service';
 import { FirebaseApp } from '@firebase/app-types';
 import { FirebasePerformance } from '@firebase/performance-types';
 import { consoleLogger } from '../utils/console_logger';
+import { setupTransportService } from '../services/transport_service';
 
 export class PerformanceController implements FirebasePerformance {
   constructor(readonly app: FirebaseApp) {
     if (Api.getInstance().requiredApisAvailable()) {
+      setupTransportService();
       getInitializationPromise().then(setupOobResources, setupOobResources);
     } else {
       consoleLogger.info(

packages/performance/src/services/cc_service.test.ts

@@ -150,6 +150,7 @@ describe('Firebase Performance > oob_resources_service', () => {
     it('waits for first input delay if polyfill is available', () => {
       getIidStub.returns(MOCK_ID);
       const api = Api.getInstance();
+      //@ts-ignore Assignment to read-only property.
       api.onFirstInputDelay = stub();
       setupOobResources();
       clock.tick(1);
@@ -170,6 +171,7 @@ describe('Firebase Performance > oob_resources_service', () => {
       // Underscore is to avoid compiler comlaining about variable being declared but not used.
       type FirstInputDelayCallback = (firstInputDelay: number) => void;
       let firstInputDelayCallback: FirstInputDelayCallback = (): void => {};
+      //@ts-ignore Assignment to read-only property.
       api.onFirstInputDelay = (cb: FirstInputDelayCallback) => {
         firstInputDelayCallback = cb;
       };

packages/performance/src/services/oob_resources_service.test.ts

@@ -17,7 +17,7 @@
 
 import { stub, SinonStub, useFakeTimers, SinonFakeTimers } from 'sinon';
 import { Trace } from '../resources/trace';
-import * as ccService from './cc_service';
+import * as transportService from './transport_service';
 import * as iidService from './iid_service';
 import { expect } from 'chai';
 import { Api, setupApi } from './api_service';
@@ -48,7 +48,7 @@ describe('Performance Monitoring > perf_logger', () => {
   let getIidStub: SinonStub<[], string | undefined>;
   let clock: SinonFakeTimers;
 
-  function mockCcHandler(
+  function mockTransportHandler(
     serializer: (...args: any[]) => string
   ): (...args: any[]) => void {
     return (...args) => {
@@ -65,7 +65,7 @@ describe('Performance Monitoring > perf_logger', () => {
   beforeEach(() => {
     getIidStub = stub(iidService, 'getIid');
     addToQueueStub = stub();
-    stub(ccService, 'ccHandler').callsFake(mockCcHandler);
+    stub(transportService, 'transportHandler').callsFake(mockTransportHandler);
     stub(Api.prototype, 'getUrl').returns(PAGE_URL);
     stub(Api.prototype, 'getTimeOrigin').returns(TIME_ORIGIN);
     stub(initializationService, 'isPerfInitialized').returns(true);

packages/performance/src/services/perf_logger.test.ts

@@ -30,7 +30,7 @@ import {
   isPerfInitialized,
   getInitializationPromise
 } from './initialization_service';
-import { ccHandler } from './cc_service';
+import { transportHandler } from './transport_service';
 import { SDK_VERSION } from '../constants';
 
 const enum ResourceType {
@@ -95,7 +95,7 @@ function sendLog(
   resourceType: ResourceType
 ): void {
   if (!logger) {
-    logger = ccHandler(serializer);
+    logger = transportHandler(serializer);
   }
   logger(resource, resourceType);
 }

packages/performance/src/services/perf_logger.ts

@@ -0,0 +1,74 @@
+/**
+ * @license
+ * Copyright 2019 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { stub, useFakeTimers, SinonStub, SinonFakeTimers } from 'sinon';
+import { use, expect } from 'chai';
+import * as sinonChai from 'sinon-chai';
+import { transportHandler, setupTransportService } from './transport_service';
+
+use(sinonChai);
+
+describe('Firebase Performance > transport_service', () => {
+  let fetchStub: SinonStub<[RequestInfo, RequestInit?], Promise<Response>>;
+  const INITIAL_SEND_TIME_DELAY_MS = 5.5 * 1000;
+  const DEFAULT_SEND_INTERVAL_MS = 10 * 1000;
+  // Starts date at timestamp 1 instead of 0, otherwise it causes validation errors.
+  const clock: SinonFakeTimers = useFakeTimers(1);
+  setupTransportService();
+  const testTransportHandler = transportHandler((...args) => {
+    return args[0];
+  });
+
+  beforeEach(() => {
+    fetchStub = stub(window, 'fetch');
+  });
+
+  afterEach(() => {
+    fetchStub.restore();
+  });
+
+  it('throws an error when logging an empty message', () => {
+    expect(() => {
+      testTransportHandler('');
+    }).to.throw;
+  });
+
+  it('does not attempt to log an event to clearcut after INITIAL_SEND_TIME_DELAY_MS if queue is empty', () => {
+    fetchStub.resolves(
+      new Response('', {
+        status: 200,
+        headers: { 'Content-type': 'application/json' }
+      })
+    );
+
+    clock.tick(INITIAL_SEND_TIME_DELAY_MS);
+    expect(fetchStub).to.not.have.been.called;
+  });
+
+  it('attempts to log an event to clearcut after DEFAULT_SEND_INTERVAL_MS if queue not empty', () => {
+    fetchStub.resolves(
+      new Response('', {
+        status: 200,
+        headers: { 'Content-type': 'application/json' }
+      })
+    );
+
+    testTransportHandler('someEvent');
+    clock.tick(DEFAULT_SEND_INTERVAL_MS);
+    expect(fetchStub).to.have.been.calledOnce;
+  });
+});

packages/performance/src/services/transport_service.test.ts

@@ -52,6 +52,15 @@ interface Log {
 
 let queue: BatchEvent[] = [];
 
+let isTransportSetup: boolean = false;
+
+export function setupTransportService(): void {
+  if (!isTransportSetup) {
+    processQueue(INITIAL_SEND_TIME_DELAY_MS);
+    isTransportSetup = true;
+  }
+}
+
 function processQueue(timeOffset: number): void {
   setTimeout(() => {
     // If there is no remainingTries left, stop retrying.
@@ -120,8 +129,6 @@ function processQueue(timeOffset: number): void {
   }, timeOffset);
 }
 
-processQueue(INITIAL_SEND_TIME_DELAY_MS);
-
 function addToQueue(evt: BatchEvent): void {
   if (!evt.eventTime || !evt.message) {
     throw ERROR_FACTORY.create(ErrorCode.INVALID_CC_LOG);
@@ -131,7 +138,7 @@ function addToQueue(evt: BatchEvent): void {
 }
 
 /** Log handler for cc service to send the performance logs to the server. */
-export function ccHandler(
+export function transportHandler(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   serializer: (...args: any[]) => string
 ): (...args: unknown[]) => void {