initial log work

Author: hsubox76

packages/analytics/src/helpers.ts

@@ -31,6 +31,7 @@ import {
   GTAG_URL
 } from './constants';
 import { FirebaseInstallations } from '@firebase/installations-types';
+import { logger } from './logger';
 
 /**
  * Initialize the analytics instance in gtag.js by calling config command with fid.
@@ -146,7 +147,7 @@ function wrapGtag(
             gtagParams || {}
           )
         )
-        .catch(e => console.error(e));
+        .catch(e => logger.error(e));
     } else if (command === GtagCommand.CONFIG) {
       const initializationPromiseToWait =
         initializedIdPromisesMap[idOrNameOrParams as string] ||
@@ -155,7 +156,7 @@ function wrapGtag(
         .then(() => {
           gtagCore(GtagCommand.CONFIG, idOrNameOrParams as string, gtagParams);
         })
-        .catch(e => console.error(e));
+        .catch(e => logger.error(e));
     } else {
       // SET command.
       // Splitting calls for CONFIG and SET to make it clear which signature

packages/analytics/src/logger.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.
+ */
+
+import { Logger } from '@firebase/logger';
+
+export const logger = new Logger('@firebase/analytics');

packages/app-types/index.d.ts

@@ -1,3 +1,5 @@
+import { FirebaseService } from './private';
+
 /**
  * @license
  * Copyright 2017 Google Inc.
@@ -31,6 +33,25 @@ export interface FirebaseAppConfig {
   automaticDataCollectionEnabled?: boolean;
 }
 
+export type LogLevelString =
+  | 'debug'
+  | 'verbose'
+  | 'info'
+  | 'warn'
+  | 'error'
+  | 'silent';
+
+export interface LogOptions {
+  level: LogLevelString;
+}
+
+export type LogCallback = (callbackParams: {
+  level: LogLevelString;
+  message: string;
+  source: FirebaseService | FirebaseApp;
+  type: string;
+}) => void;
+
 export class FirebaseApp {
   /**
    * The (read-only) name (identifier) for this App. '[DEFAULT]' is the default
@@ -105,6 +126,12 @@ export interface FirebaseNamespace {
    */
   registerVersion(library: string, version: string, variant?: string): void;
 
+  // Sets log level for all Firebase components.
+  setLogLevel(logLevel: LogLevelString): void;
+
+  // Sets log handler for all Firebase components.
+  onLog(logCallback: LogCallback, options: LogOptions): void;
+
   // The current SDK version.
   SDK_VERSION: string;
 }

packages/app/src/firebaseNamespaceCore.ts

@@ -34,6 +34,7 @@ import { FirebaseAppLiteImpl } from './lite/firebaseAppLite';
 import { DEFAULT_ENTRY_NAME, PLATFORM_LOG_STRING } from './constants';
 import { version } from '../../firebase/package.json';
 import { logger } from './logger';
+import { addLogCallback, setLogLevel } from '@firebase/logger';
 import { Component, ComponentType, Name } from '@firebase/component';
 
 /**
@@ -60,6 +61,8 @@ export function createFirebaseNamespaceCore(
     // @ts-ignore
     app,
     registerVersion,
+    setLogLevel,
+    onLog: addLogCallback,
     // @ts-ignore
     apps: null,
     SDK_VERSION: version,

packages/logger/index.ts

@@ -15,12 +15,4 @@
  * limitations under the License.
  */
 
-import { instances, LogLevel } from './src/logger';
-
-export function setLogLevel(level: LogLevel): void {
-  instances.forEach(inst => {
-    inst.logLevel = level;
-  });
-}
-
-export { Logger, LogLevel, LogHandler } from './src/logger';
+export { setLogLevel, Logger, LogLevel, LogHandler, addLogCallback } from './src/logger';

packages/logger/src/logger.ts

@@ -15,6 +15,14 @@
  * limitations under the License.
  */
 
+import {
+  LogCallback,
+  LogLevelString,
+  FirebaseApp,
+  LogOptions
+} from '@firebase/app-types';
+import { FirebaseService } from '@firebase/app-types/private';
+
 /**
  * A container for all of the Logger instances
  */
@@ -40,6 +48,15 @@ export enum LogLevel {
   SILENT
 }
 
+const levelStringToEnum = {
+  'debug': LogLevel.DEBUG,
+  'verbose': LogLevel.VERBOSE,
+  'info': LogLevel.INFO,
+  'warn': LogLevel.WARN,
+  'error': LogLevel.ERROR,
+  'silent': LogLevel.SILENT
+};
+
 /**
  * The default log level
  */
@@ -53,45 +70,45 @@ const defaultLogLevel: LogLevel = LogLevel.INFO;
 export type LogHandler = (
   loggerInstance: Logger,
   logType: LogLevel,
+  message: string,
+  source?: FirebaseService | FirebaseApp,
   ...args: unknown[]
 ) => void;
 
+/**
+ * By default, `console.debug` is not displayed in the developer console (in
+ * chrome). To avoid forcing users to have to opt-in to these logs twice
+ * (i.e. once for firebase, and once in the console), we are sending `DEBUG`
+ * logs to the `console.log` function.
+ */
+const ConsoleMethod = {
+  [LogLevel.DEBUG]: 'log',
+  [LogLevel.VERBOSE]: 'log',
+  [LogLevel.INFO]: 'info',
+  [LogLevel.WARN]: 'warn',
+  [LogLevel.ERROR]: 'error'
+};
+
 /**
  * The default log handler will forward DEBUG, VERBOSE, INFO, WARN, and ERROR
  * messages on to their corresponding console counterparts (if the log method
  * is supported by the current log level)
  */
-const defaultLogHandler: LogHandler = (instance, logType, ...args): void => {
+const defaultLogHandler: LogHandler = (instance, logType, message): void => {
   if (logType < instance.logLevel) {
     return;
   }
   const now = new Date().toISOString();
-  switch (logType) {
-    /**
-     * By default, `console.debug` is not displayed in the developer console (in
-     * chrome). To avoid forcing users to have to opt-in to these logs twice
-     * (i.e. once for firebase, and once in the console), we are sending `DEBUG`
-     * logs to the `console.log` function.
-     */
-    case LogLevel.DEBUG:
-      console.log(`[${now}]  ${instance.name}:`, ...args);
-      break;
-    case LogLevel.VERBOSE:
-      console.log(`[${now}]  ${instance.name}:`, ...args);
-      break;
-    case LogLevel.INFO:
-      console.info(`[${now}]  ${instance.name}:`, ...args);
-      break;
-    case LogLevel.WARN:
-      console.warn(`[${now}]  ${instance.name}:`, ...args);
-      break;
-    case LogLevel.ERROR:
-      console.error(`[${now}]  ${instance.name}:`, ...args);
-      break;
-    default:
-      throw new Error(
-        `Attempted to log a message with an invalid logType (value: ${logType})`
-      );
+  const method = ConsoleMethod[logType as keyof typeof ConsoleMethod];
+  if (method) {
+    console[method as 'log' | 'info' | 'warn' | 'error'](
+      `[${now}]  ${instance.name}:`,
+      message
+    );
+  } else {
+    throw new Error(
+      `Attempted to log a message with an invalid logType (value: ${logType})`
+    );
   }
 };
 
@@ -141,19 +158,67 @@ export class Logger {
    * The functions below are all based on the `console` interface
    */
 
-  debug(...args: unknown[]): void {
-    this._logHandler(this, LogLevel.DEBUG, ...args);
+  debug(
+    message: string,
+    source?: FirebaseService | FirebaseApp
+  ): void {
+    this._logHandler(this, LogLevel.DEBUG, message, source);
+  }
+  log(
+    message: string,
+    source?: FirebaseService | FirebaseApp
+  ): void {
+    this._logHandler(this, LogLevel.VERBOSE, message, source);
   }
-  log(...args: unknown[]): void {
-    this._logHandler(this, LogLevel.VERBOSE, ...args);
+  info(
+    message: string,
+    source?: FirebaseService | FirebaseApp
+  ): void {
+    this._logHandler(this, LogLevel.INFO, message, source);
   }
-  info(...args: unknown[]): void {
-    this._logHandler(this, LogLevel.INFO, ...args);
+  warn(
+    message: string,
+    source?: FirebaseService | FirebaseApp
+  ): void {
+    this._logHandler(this, LogLevel.WARN, message, source);
   }
-  warn(...args: unknown[]): void {
-    this._logHandler(this, LogLevel.WARN, ...args);
+  error(
+    message: string,
+    source?: FirebaseService | FirebaseApp
+  ): void {
+    this._logHandler(this, LogLevel.ERROR, message, source);
   }
-  error(...args: unknown[]): void {
-    this._logHandler(this, LogLevel.ERROR, ...args);
+}
+
+export function setLogLevel(level: LogLevelString | LogLevel): void {
+  const newLevel = typeof level === 'string' ? levelStringToEnum[level] : level;
+  instances.forEach(inst => {
+    inst.logLevel = newLevel;
+  });
+}
+
+export function addLogCallback(logCallback: LogCallback, options: LogOptions) {
+  for (const index in instances) {
+    const instance = instances[index];
+    let threshhold = instance.logLevel;
+    if (options && options.level) {
+      threshhold = levelStringToEnum[options.level];
+    }
+    instance.logHandler = (
+      instance: Logger,
+      level: LogLevel,
+      message: string,
+      source?: FirebaseService | FirebaseApp
+    ) => {
+      if (level >= threshhold && message && source) {
+        logCallback({
+          level: LogLevel[level].toLowerCase() as LogLevelString,
+          message,
+          type: instance.name,
+          source
+        });
+      }
+      defaultLogHandler(instance, level, message);
+    };
   }
 }