remove kaltura-ng/kaltura-logger dependency from kaltura-ng/kaltura-c…

…ommon

kaltura-common/package.json

@@ -53,7 +53,6 @@
 		"@angular/core": "^5.2.0",
 		"@angular/http": "^5.2.0",
 		"@angular/router": "^5.2.0",
-		"@kaltura-ng/kaltura-logger": "^2.2.0",
 		"rxjs": "^5.5.6"
 	},
 	"devDependencies": {

kaltura-common/src/index.ts

@@ -5,3 +5,4 @@ export * from './upload-management';
 export * from './xml-parser';
 export * from './operation-tag';
 export * from './server-polls'
+export { KalturaLoggerInjectionToken } from './kaltura-logger';

kaltura-common/src/kaltura-common.module.ts

@@ -2,6 +2,7 @@ import { NgModule, ModuleWithProviders } from '@angular/core';
 import { CommonModule } from '@angular/common';
 import { KalturaUtils } from './utils/kaltura-utils';
 import { APP_STORAGE_TOKEN, AppStorage } from './app-storage.service';
+import { EmptyLogger, KalturaLoggerInjectionToken } from './kaltura-logger';
 
 
 @NgModule({
@@ -28,7 +29,8 @@ export class KalturaCommonModule {
             ngModule: KalturaCommonModule,
             providers: [
                 { provide: APP_STORAGE_TOKEN, useClass: AppStorage },
-	            KalturaUtils
+	            KalturaUtils,
+                { provide: KalturaLoggerInjectionToken, useClass: EmptyLogger}
             ]
         };
     }

kaltura-common/src/kaltura-logger.ts

@@ -0,0 +1,89 @@
+import { InjectionToken } from '@angular/core';
+
+export type Context = { [key: string]: any };
+export type DefferedContext = () => Context;
+
+export const KalturaLoggerInjectionToken = new InjectionToken<KalturaLogger>('kaltura-logger');
+
+export interface KalturaLogger {
+	trace(message: string, context?: Context): void;
+
+	trace(message: string, context?: DefferedContext): void;
+
+	trace(message: string, context?: Context | DefferedContext): void;
+
+	debug(message: string, context?: Context): void;
+
+	debug(message: string, context?: DefferedContext): void;
+
+	debug(message: string, context?: Context | DefferedContext): void;
+
+	info(message: string, context?: Context): void;
+
+	info(message: string, context?: DefferedContext): void;
+
+	info(message: string, context?: Context | DefferedContext): void;
+
+	warn(message: string, context?: Context): void;
+
+	warn(message: string, context?: DefferedContext): void;
+
+	warn(message: string, context?: Context | DefferedContext): void;
+
+	error(message: string, context?: Context): void;
+
+	error(message: string, error?: Error): void;
+
+	error(message: string, context?: Error | Context): void;
+
+	fatal(message: string, context?: Context): void;
+
+	fatal(message: string, error?: Error): void;
+
+	fatal(message: string, context?: Error | Context): void;
+
+	subLogger(name: string): KalturaLogger;
+}
+
+export class EmptyLogger implements KalturaLogger {
+	trace(message: string, context?: Context): void;
+	trace(message: string, context?: DefferedContext): void;
+	trace(message: string, context?: Context | DefferedContext): void;
+	trace(message: string, context?): void {
+	}
+
+	debug(message: string, context?: Context): void;
+	debug(message: string, context?: DefferedContext): void;
+	debug(message: string, context?: Context | DefferedContext): void;
+	debug(message: string, context?): void {
+	}
+
+	info(message: string, context?: Context): void;
+	info(message: string, context?: DefferedContext): void;
+	info(message: string, context?: Context | DefferedContext): void;
+	info(message: string, context?): void {
+	}
+
+	warn(message: string, context?: Context): void;
+	warn(message: string, context?: DefferedContext): void;
+	warn(message: string, context?: Context | DefferedContext): void;
+	warn(message: string, context?): void {
+	}
+
+	error(message: string, context?: Context): void;
+	error(message: string, error?: Error): void;
+	error(message: string, context?: Error | Context): void;
+	error(message: string, context?): void {
+	}
+
+	fatal(message: string, context?: Context): void;
+	fatal(message: string, error?: Error): void;
+	fatal(message: string, context?: Error | Context): void;
+	fatal(message: string, context?): void {
+	}
+
+	subLogger(name: string): KalturaLogger {
+		return new EmptyLogger();
+	}
+}
+

kaltura-common/src/rxjs/add/operators.ts

@@ -1,16 +1,11 @@
 import { Observable } from 'rxjs/Observable';
 import { _cancelOnDestroy as cancelOnDestroy } from '../operator/cancel-on-destroy/cancel-on-destroy';
-import { _monitor as monitor } from '../operator/monitor/monitor';
 import { _tag as tag } from '../operator/tag/tag';
 
 Observable.prototype.cancelOnDestroy = cancelOnDestroy;
-Observable.prototype.monitor = monitor;
 Observable.prototype.tag = tag;
 
 declare module 'rxjs/Observable' {
-    interface Observable<T> {
-        monitor: typeof monitor;
-    }
     interface Observable<T> {
         cancelOnDestroy: typeof cancelOnDestroy;
     }

kaltura-common/src/server-polls/server-polls.service.ts

@@ -3,7 +3,7 @@ import { Subscriber } from 'rxjs/Subscriber';
 import { FriendlyHashId } from '../friendly-hash-id';
 import { ISubscription } from 'rxjs/Subscription';
 import { BehaviorSubject } from 'rxjs/BehaviorSubject';
-import { KalturaLogger } from '@kaltura-ng/kaltura-logger';
+import { EmptyLogger, KalturaLogger } from '../kaltura-logger';
 import { Optional } from '@angular/core';
 
 export type PollInterval = 10 | 30 | 60 | 300;
@@ -31,25 +31,23 @@ export abstract class ServerPolls<TRequest, TError> {
     private _logger: KalturaLogger;
   public state$ = this._state.asObservable();
   private _queueInterval: number = null;
-  
+
   protected abstract _executeRequests(requests: TRequest[]): Observable<{ error: TError, result: any }[]>;
-  
+
   protected abstract _createGlobalError(error?: Error): TError;
-  
+
   protected abstract _getOnDestroy$(): Observable<void>;
-  
+
   protected abstract _canExecute(): boolean;
-
-  constructor(@Optional() kalturaLogger: KalturaLogger) {
-
-      if (kalturaLogger)
-      {
-          this._logger = kalturaLogger.subLogger('ServerPolls');
-      }else
-      {
-          this._logger = new KalturaLogger('ServerPolls',null, null);
-      }
-    this._initialize();
+
+  constructor(kalturaLogger: KalturaLogger) {
+
+	  if (kalturaLogger) {
+		  this._logger = kalturaLogger;
+	  } else {
+		  this._logger = new EmptyLogger();
+	  }
+	  this._initialize();
   }
 
   private _warnAboutMissingDestory(): void {
@@ -78,11 +76,11 @@ export abstract class ServerPolls<TRequest, TError> {
           }
       });
   }
-  
+
   private _cancelQueueInterval(): void {
     clearTimeout(this._queueTimeout);
   }
-  
+
   private _getPollQueueList(): PollItem<TError>[] {
     return Object.keys(this._pollQueue).map(key => this._pollQueue[key]);
   }
@@ -273,7 +271,7 @@ export abstract class ServerPolls<TRequest, TError> {
   public isBusy(): boolean {
       return this._state.getValue().busy;
   }
-  
+
   public register<TResponse>(intervalInSeconds: PollInterval, requestFactory: RequestFactory<TRequest, TResponse>): Observable<{ error: TError, result: TResponse }> {
     return Observable.create(observer => {
       const newPollId = this._tokenGenerator.generateUnique(Object.keys(this._pollQueue));
@@ -303,7 +301,7 @@ export abstract class ServerPolls<TRequest, TError> {
                   this._setupQueueTimer();
               }
           );
-      
+
       return () => {
           this._logger.info(`stop polling for ${newPollId}`);
           if (initialRequest) {
@@ -313,4 +311,4 @@ export abstract class ServerPolls<TRequest, TError> {
       }
     });
   }
-}
+}

kaltura-logger/src/kaltura-logger.module.ts

@@ -1,6 +1,6 @@
 import { NgModule, ModuleWithProviders, Optional, SkipSelf } from '@angular/core';
 import { CommonModule } from '@angular/common';
-import { KalturaLogger, KalturaDefaultLogger } from './kaltura-logger.service';
+import { KalturaLogger, KalturaLoggerName } from './kaltura-logger.service';
 import { JL } from 'jsnlog';
 import { KalturaLoggerRecordService } from './kaltura-logger-record.service';
 
@@ -25,31 +25,14 @@ if (window && window.onerror) {
     ]
 })
 export class KalturaLoggerModule {
-
-    // TODO check why this doesn't work with AOT
-    // static forRoot(name: string): ModuleWithProviders {
-    //     return {
-    //         ngModule: KalturaLoggerModule,
-    //         providers: [
-    //             {
-    //                 provide: KalturaLogger,
-    //                 useFactory(parentLogger)
-    //                 {
-    //                     const logger = new KalturaLogger(name, parentLogger);
-    //
-    //                     KalturaDefaultLogger.set(logger.subLogger('general'));
-    //
-    //                     return logger;
-    //                 },
-    //                 deps: [[new Optional(), new SkipSelf(), KalturaLogger]]
-    //             }
-    //         ]
-    //     };
-    // }
-    static forRoot(): ModuleWithProviders {
+    static forRoot(name: string): ModuleWithProviders {
         return {
           ngModule: KalturaLoggerModule,
           providers: [
+	          KalturaLogger,
+	          {
+		          provide: KalturaLoggerName, useValue: name
+	          },
             KalturaLoggerRecordService
           ]
         }