Add platform version logging functionality.

Author: Feiyang1

config/tsconfig.base.json

@@ -17,6 +17,7 @@
     ],
     "module": "ES2015",
     "moduleResolution": "node",
+    "resolveJsonModule": true,
     "sourceMap": true,
     "target": "es5",
     "typeRoots": [

packages/analytics/index.ts

@@ -28,6 +28,8 @@ import {
 } from '@firebase/component';
 import { ERROR_FACTORY, AnalyticsError } from './src/errors';
 
+import { version } from './package.json';
+
 declare global {
   interface Window {
     [key: string]: unknown;
@@ -62,6 +64,8 @@ export function registerAnalytics(instance: _FirebaseNamespace): void {
     new Component('analytics-internal', internalFactory, ComponentType.PRIVATE)
   );
 
+  instance.registerVersion('ANALYTICS_TYPE', version);
+
   function internalFactory(
     container: ComponentContainer
   ): FirebaseAnalyticsInternal {

packages/analytics/package.json

@@ -35,6 +35,7 @@
     "rollup-plugin-commonjs": "10.1.0",
     "rollup-plugin-json": "4.0.0",
     "rollup-plugin-node-resolve": "5.2.0",
+    "rollup-plugin-typescript2": "0.25.2",
     "rollup-plugin-uglify": "6.0.3",
     "typescript": "3.7.2"
   },

packages/app-types/index.d.ts

@@ -98,12 +98,26 @@ export interface FirebaseNamespace {
    */
   apps: FirebaseApp[];
 
+  /**
+   * Registers a library's name and version for platform logging purposes.
+   * @param library Name of 1p or 3p library (e.g. firestore, angularfire)
+   * @param version Current version of that library.
+   */
+  registerVersion(library: string, version: string): void;
+
   // The current SDK version.
   SDK_VERSION: string;
 }
 
+export interface VersionService {
+  library: string;
+  version: string;
+}
+
 declare module '@firebase/component' {
   interface NameServiceMapping {
     'app': FirebaseApp;
+    'app-version': VersionService;
+    'platform-identifier': VersionService;
   }
 }

packages/app-types/private.d.ts

@@ -56,6 +56,10 @@ export interface FirebaseServiceFactory {
   ): FirebaseService;
 }
 
+export interface PlatformLoggerService {
+  getPlatformInfoString(): string;
+}
+
 /**
  * All ServiceNamespaces extend from FirebaseServiceNamespace
  */
@@ -154,3 +158,9 @@ export interface _FirebaseNamespace extends FirebaseNamespace {
     ErrorFactory: typeof ErrorFactory;
   };
 }
+
+declare module '@firebase/component' {
+  interface NameServiceMapping {
+    'platform-logger': PlatformLoggerService;
+  }
+}

packages/app/src/constants.ts

@@ -16,3 +16,23 @@
  */
 
 export const DEFAULT_ENTRY_NAME = '[DEFAULT]';
+
+export const PLATFORM_LOG_STRING = {
+  'app': 'fire-core',
+  'analytics': 'fire-analytics',
+  'auth': 'fire-auth',
+  'database': 'fire-rtdb',
+  'functions': 'fire-fn',
+  'messaging': 'fire-fcm',
+  'performance': 'fire-perf',
+  'remote-config': 'fire-rc',
+  'storage': 'fire-gcs',
+  'firestore': 'fire-fst',
+  'fire-js': 'fire-js', // Platform identifier for JS SDK.
+  'fire-js-all-app': 'fire-js-all-app', // firebase/app import
+  'fire-js-all': 'fire-js-all', // 'firebase' import
+  'fire-js-all-node': 'fire-js-all-node',
+  'fire-js-all-rn': 'fire-js-all-rn',
+  'fire-js-all-lite': 'fire-js-all-lite',
+  'fire-js-all-cdn': 'fire-js-all-cdn'
+} as const;

packages/app/src/firebaseApp.ts

@@ -35,6 +35,10 @@ import {
 import { AppError, ERROR_FACTORY } from './errors';
 import { DEFAULT_ENTRY_NAME } from './constants';
 import { logger } from './logger';
+import { PlatformLoggerService } from './platformLoggerService';
+import { VersionService } from './version-service';
+
+import { version } from '../package.json';
 
 /**
  * Global context object for a collection of services using
@@ -60,6 +64,28 @@ export class FirebaseAppImpl implements FirebaseApp {
 
     // add itself to container
     this._addComponent(new Component('app', () => this, ComponentType.PUBLIC));
+    this._addComponent(
+      new Component(
+        'platform-logger',
+        (container: ComponentContainer) => new PlatformLoggerService(container),
+        ComponentType.PRIVATE
+      )
+    );
+    this._addComponent(
+      new Component(
+        'app-version',
+        () => new VersionService('app', version),
+        ComponentType.VERSION
+      )
+    );
+    this._addComponent(
+      new Component(
+        'platform-identifier',
+        // Adds a string identifying version header as belonging to JS SDK
+        () => new VersionService('fire-js', ''),
+        ComponentType.VERSION
+      )
+    );
     // populate ComponentContainer with existing components
     for (const component of this.firebase_.INTERNAL.components.values()) {
       this._addComponent(component);

packages/app/src/firebaseNamespaceCore.ts

@@ -34,7 +34,8 @@ import { FirebaseAppLiteImpl } from './lite/firebaseAppLite';
 import { DEFAULT_ENTRY_NAME } from './constants';
 import { version } from '../../firebase/package.json';
 import { logger } from './logger';
-import { Component, ComponentType } from '@firebase/component';
+import { Component, ComponentType, Name } from '@firebase/component';
+import { VersionService } from './version-service';
 
 /**
  * Because auth can't share code with other components, we attach the utility functions
@@ -59,6 +60,7 @@ export function createFirebaseNamespaceCore(
     initializeApp,
     // @ts-ignore
     app,
+    registerVersion,
     // @ts-ignore
     apps: null,
     SDK_VERSION: version,
@@ -234,6 +236,22 @@ export function createFirebaseNamespaceCore(
       : null;
   }
 
+  function registerVersion(library: string, version: string): void {
+    if (library.match(/\s|\//)) {
+      logger.warn(
+        `Could not register ${library}: it contains illegal characters.`
+      );
+      return;
+    }
+    registerComponent(
+      new Component(
+        `${library}-version` as Name,
+        () => new VersionService(library, version),
+        ComponentType.VERSION
+      )
+    );
+  }
+
   // Map the requested service to a registered service name
   // (used to map auth to serverAuth service when needed).
   function useAsService(app: FirebaseApp, name: string): string | null {

packages/app/src/platformLoggerService.ts

@@ -0,0 +1,48 @@
+/**
+ * @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 { ComponentContainer, ComponentType } from '@firebase/component';
+import { VersionService } from './version-service';
+import { PLATFORM_LOG_STRING } from './constants';
+
+export class PlatformLoggerService {
+  constructor(private readonly container: ComponentContainer) {}
+  // In initial implementation, this will be called by installations on
+  // auth token refresh, and installations will send this string.
+  getPlatformInfoString(): string {
+    const providers = this.container.getProviders();
+    // Loop through providers and get library/version pairs from any that are
+    // version components.
+    return providers
+      .map(provider => {
+        const service = provider.getImmediate() as VersionService;
+        const component = provider.getComponent();
+        if (service && component?.type === ComponentType.VERSION) {
+          // TODO: We can use this check to whitelist strings when/if we set up
+          // a good whitelist system.
+          const platformString =
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (PLATFORM_LOG_STRING as any)[service.library] ?? service.library;
+          return `${platformString}/${service.version}`;
+        } else {
+          return null;
+        }
+      })
+      .filter(logString => logString)
+      .join(' ');
+  }
+}

packages/app/src/version-service.ts

@@ -0,0 +1,20 @@
+/**
+ * @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.
+ */
+
+export class VersionService {
+  constructor(readonly library: string, readonly version: string) {}
+}

packages/app/test/platformLogger.test.ts

@@ -0,0 +1,112 @@
+/**
+ * @license
+ * Copyright 2017 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 { FirebaseNamespace } from '@firebase/app-types';
+import { _FirebaseApp, _FirebaseNamespace } from '@firebase/app-types/private';
+import { createFirebaseNamespace } from '../src/firebaseNamespace';
+import { expect } from 'chai';
+import './setup';
+import { PlatformLoggerService } from '../src/platformLoggerService';
+import {
+  Component,
+  ComponentType,
+  ComponentContainer
+} from '@firebase/component';
+import { VersionService } from '../src/version-service';
+
+declare module '@firebase/component' {
+  interface NameServiceMapping {
+    'vs1': VersionService;
+    'vs2': VersionService;
+    'test-shell': Promise<void>;
+  }
+}
+
+describe('Platform Logger Service', () => {
+  describe('Unit Tests', () => {
+    it(`logs core version`, () => {
+      const container = new ComponentContainer('testContainer');
+      container.addComponent(
+        new Component(
+          'vs1',
+          () => new VersionService('vs1', '1.2.3'),
+          ComponentType.VERSION
+        )
+      );
+      container.addComponent(
+        new Component(
+          'vs2',
+          () => new VersionService('vs2', '3.02.01'),
+          ComponentType.VERSION
+        )
+      );
+      const platformLoggerService = new PlatformLoggerService(container);
+      const platformInfoString = platformLoggerService.getPlatformInfoString();
+      expect(platformInfoString).to.include('vs1/1.2.3');
+      expect(platformInfoString).to.include('vs2/3.02.01');
+    });
+  });
+
+  describe('Integration Tests', () => {
+    let firebase: FirebaseNamespace;
+
+    beforeEach(() => {
+      firebase = createFirebaseNamespace();
+    });
+
+    it(`logs core version`, () => {
+      firebase.initializeApp({});
+      (firebase as _FirebaseNamespace).INTERNAL.registerComponent(
+        new Component(
+          'test-shell',
+          async (container: ComponentContainer) => {
+            const platformLoggerProvider = container.getProvider(
+              'platform-logger'
+            );
+            const platformLogger = (await platformLoggerProvider.get()) as PlatformLoggerService;
+            const platformInfoString = platformLogger.getPlatformInfoString();
+            expect(platformInfoString).to.include('fire-core/');
+            expect(platformInfoString).to.include('fire-js/ ');
+          },
+          ComponentType.PUBLIC
+        )
+      );
+      (firebase as any)['test-shell']();
+    });
+
+    it(`logs other components' versions`, () => {
+      firebase.initializeApp({});
+      (firebase as _FirebaseNamespace).registerVersion('analytics', '1.2.3');
+      (firebase as _FirebaseNamespace).INTERNAL.registerComponent(
+        new Component(
+          'test-shell',
+          async (container: ComponentContainer) => {
+            const platformLoggerProvider = container.getProvider(
+              'platform-logger'
+            );
+            const platformLogger = (await platformLoggerProvider.get()) as PlatformLoggerService;
+            const platformInfoString = platformLogger.getPlatformInfoString();
+            expect(platformInfoString).to.include('fire-analytics/1.2.3');
+            expect(platformInfoString).to.include('fire-js/ ');
+          },
+          ComponentType.PUBLIC
+        )
+      );
+      (firebase as any)['test-shell']();
+    });
+  });
+});

packages/component/src/provider.ts

@@ -100,7 +100,6 @@ export class Provider<T extends Name> {
         }
         throw Error(`Service ${this.name} is not available`);
       }
-
       return instance;
     } catch (e) {
       if (optional) {
@@ -111,6 +110,10 @@ export class Provider<T extends Name> {
     }
   }
 
+  getComponent(): Component<T> | null {
+    return this.component;
+  }
+
   setComponent(component: Component<T>): void {
     if (component.name !== this.name) {
       throw Error(

packages/component/src/types.ts

@@ -32,7 +32,8 @@ export const enum InstantiationMode {
  */
 export const enum ComponentType {
   PUBLIC = 'PUBLIC',
-  PRIVATE = 'PRIVATE'
+  PRIVATE = 'PRIVATE',
+  VERSION = 'VERSION'
 }
 
 /**