From 3928845895ed6d14d3511055ee29bd0535f3d3d5 Mon Sep 17 00:00:00 2001
From: sis0k0 <stanimira.vlaeva@gmail.com>
Date: Mon, 27 Aug 2018 19:48:28 +0300
Subject: [PATCH] refactor: call tracer only after isEnabled check

original PR: https://github.com/NativeScript/nativescript-angular/pull/958
---
 .../animations/animation-player.ts            |  26 +++--
 .../directives/list-view-comp.ts              |  42 +++++--
 nativescript-angular/directives/tab-view.ts   |   6 +-
 nativescript-angular/dom-adapter.ts           |  12 +-
 nativescript-angular/platform-common.ts       |  62 +++++++---
 nativescript-angular/renderer.ts              | 106 ++++++++++++-----
 .../router/ns-location-strategy.ts            | 108 +++++++++++++-----
 .../router/ns-platform-location.ts            |   7 +-
 .../router/ns-route-reuse-strategy.ts         |  30 +++--
 nativescript-angular/router/ns-router-link.ts |  16 ++-
 .../router/page-router-outlet.ts              |  55 ++++++---
 nativescript-angular/trace.ts                 |   1 +
 nativescript-angular/view-util.ts             |  40 +++++--
 13 files changed, 368 insertions(+), 143 deletions(-)

diff --git a/nativescript-angular/animations/animation-player.ts b/nativescript-angular/animations/animation-player.ts
index 3e0472cdd..fa38f6782 100644
--- a/nativescript-angular/animations/animation-player.ts
+++ b/nativescript-angular/animations/animation-player.ts
@@ -4,7 +4,7 @@ import { KeyframeAnimation }
 
 import { Keyframe, createKeyframeAnimation } from "./utils";
 import { NgView } from "../element-registry";
-import { animationsLog as traceLog } from "../trace";
+import { animationsLog as traceLog, isLogEnabled } from "../trace";
 
 export class NativeScriptAnimationPlayer implements AnimationPlayer {
     public parentPlayer: AnimationPlayer = null;
@@ -41,7 +41,9 @@ export class NativeScriptAnimationPlayer implements AnimationPlayer {
     onDestroy(fn: Function): void { this._doneSubscriptions.push(fn); }
 
     play(): void {
-        traceLog(`NativeScriptAnimationPlayer.play`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptAnimationPlayer.play`);
+        }
 
         if (!this.animation) {
             return;
@@ -66,7 +68,9 @@ export class NativeScriptAnimationPlayer implements AnimationPlayer {
     }
 
     reset(): void {
-        traceLog(`NativeScriptAnimationPlayer.reset`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptAnimationPlayer.reset`);
+        }
 
         if (this.animation && this.animation.isPlaying) {
             this.animation.cancel();
@@ -74,14 +78,18 @@ export class NativeScriptAnimationPlayer implements AnimationPlayer {
     }
 
     restart(): void {
-        traceLog(`NativeScriptAnimationPlayer.restart`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptAnimationPlayer.restart`);
+        }
 
         this.reset();
         this.play();
     }
 
     destroy(): void {
-        traceLog(`NativeScriptAnimationPlayer.destroy`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptAnimationPlayer.destroy`);
+        }
         this.onFinish();
     }
 
@@ -94,13 +102,17 @@ export class NativeScriptAnimationPlayer implements AnimationPlayer {
     }
 
     private initKeyframeAnimation(keyframes: Keyframe[], duration: number, delay: number, easing: string) {
-        traceLog(`NativeScriptAnimationPlayer.initKeyframeAnimation`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptAnimationPlayer.initKeyframeAnimation`);
+        }
 
         this.animation = createKeyframeAnimation(keyframes, duration, delay, easing);
     }
 
     private onFinish() {
-        traceLog(`NativeScriptAnimationPlayer.onFinish`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptAnimationPlayer.onFinish`);
+        }
 
         if (this._finished) {
             return;
diff --git a/nativescript-angular/directives/list-view-comp.ts b/nativescript-angular/directives/list-view-comp.ts
index a04f244b4..eb0b951ff 100644
--- a/nativescript-angular/directives/list-view-comp.ts
+++ b/nativescript-angular/directives/list-view-comp.ts
@@ -26,7 +26,7 @@ import { ObservableArray } from "tns-core-modules/data/observable-array";
 import { profile } from "tns-core-modules/profiling";
 
 import { getSingleViewRecursive } from "../element-registry";
-import { listViewLog, listViewError } from "../trace";
+import { listViewLog, listViewError, isLogEnabled } from "../trace";
 
 const NG_VIEW = "_ngViewRef";
 
@@ -101,7 +101,9 @@ export class ListViewComponent implements DoCheck, OnDestroy, AfterContentInit {
     }
 
     ngAfterContentInit() {
-        listViewLog("ListView.ngAfterContentInit()");
+        if (isLogEnabled()) {
+            listViewLog("ListView.ngAfterContentInit()");
+        }
         this.setItemTemplates();
     }
 
@@ -115,7 +117,9 @@ export class ListViewComponent implements DoCheck, OnDestroy, AfterContentInit {
         this.itemTemplate = this.itemTemplateQuery;
 
         if (this._templateMap) {
-            listViewLog("Setting templates");
+            if (isLogEnabled()) {
+                listViewLog("Setting templates");
+            }
 
             const templates: KeyedTemplate[] = [];
             this._templateMap.forEach(value => {
@@ -126,7 +130,9 @@ export class ListViewComponent implements DoCheck, OnDestroy, AfterContentInit {
     }
 
     public registerTemplate(key: string, template: TemplateRef<ListItemContext>) {
-        listViewLog("registerTemplate for key: " + key);
+        if (isLogEnabled()) {
+            listViewLog(`registerTemplate for key: ${key}`);
+        }
         if (!this._templateMap) {
             this._templateMap = new Map<string, KeyedTemplate>();
         }
@@ -134,7 +140,9 @@ export class ListViewComponent implements DoCheck, OnDestroy, AfterContentInit {
         const keyedTemplate = {
             key,
             createView: () => {
-                listViewLog("registerTemplate for key: " + key);
+                if (isLogEnabled()) {
+                    listViewLog(`registerTemplate for key: ${key}`);
+                }
 
                 const viewRef = this.loader.createEmbeddedView(template, new ListItemContext(), 0);
                 const resultView = getItemViewRoot(viewRef);
@@ -159,7 +167,9 @@ export class ListViewComponent implements DoCheck, OnDestroy, AfterContentInit {
         let viewRef: EmbeddedViewRef<ListItemContext>;
 
         if (args.view) {
-            listViewLog("onItemLoading: " + index + " - Reusing existing view");
+            if (isLogEnabled()) {
+                listViewLog(`onItemLoading: ${index} - Reusing existing view`);
+            }
             viewRef = args.view[NG_VIEW];
             // Getting angular view from original element (in cases when ProxyViewContainer
             // is used NativeScript internally wraps it in a StackLayout)
@@ -168,12 +178,16 @@ export class ListViewComponent implements DoCheck, OnDestroy, AfterContentInit {
             }
 
             if (!viewRef) {
-                listViewError("ViewReference not found for item " + index + ". View recycling is not working");
+                if (isLogEnabled()) {
+                    listViewError(`ViewReference not found for item ${index}. View recycling is not working`);
+                }
             }
         }
 
         if (!viewRef) {
-            listViewLog("onItemLoading: " + index + " - Creating view from template");
+            if (isLogEnabled()) {
+                listViewLog(`onItemLoading: ${index} - Creating view from template`);
+            }
             viewRef = this.loader.createEmbeddedView(this.itemTemplate, new ListItemContext(), 0);
             args.view = getItemViewRoot(viewRef);
             args.view[NG_VIEW] = viewRef;
@@ -197,17 +211,23 @@ export class ListViewComponent implements DoCheck, OnDestroy, AfterContentInit {
 
     @profile
     private detectChangesOnChild(viewRef: EmbeddedViewRef<ListItemContext>, index: number) {
-        listViewLog("Manually detect changes in child: " + index);
+        if (isLogEnabled()) {
+            listViewLog(`Manually detect changes in child: ${index}`);
+        }
         viewRef.markForCheck();
         viewRef.detectChanges();
     }
 
     ngDoCheck() {
         if (this._differ) {
-            listViewLog("ngDoCheck() - execute differ");
+            if (isLogEnabled()) {
+                listViewLog("ngDoCheck() - execute differ");
+            }
             const changes = this._differ.diff(this._items);
             if (changes) {
-                listViewLog("ngDoCheck() - refresh");
+                if (isLogEnabled()) {
+                    listViewLog("ngDoCheck() - refresh");
+                }
                 this.listView.refresh();
             }
         }
diff --git a/nativescript-angular/directives/tab-view.ts b/nativescript-angular/directives/tab-view.ts
index c569f9fc8..787918658 100644
--- a/nativescript-angular/directives/tab-view.ts
+++ b/nativescript-angular/directives/tab-view.ts
@@ -11,7 +11,7 @@ import { TabView, TabViewItem } from "tns-core-modules/ui/tab-view";
 import { TextTransform  } from "tns-core-modules/ui/text-base";
 
 import { InvisibleNode } from "../element-registry";
-import { rendererLog } from "../trace";
+import { rendererLog, isLogEnabled } from "../trace";
 import { isBlank } from "../lang-facade";
 
 export interface TabViewItemDef {
@@ -46,7 +46,9 @@ export class TabViewDirective implements AfterViewInit {
 
     ngAfterViewInit() {
         this.viewInitialized = true;
-        rendererLog("this._selectedIndex: " + this._selectedIndex);
+        if (isLogEnabled()) {
+            rendererLog("this._selectedIndex: " + this._selectedIndex);
+        }
         if (!isBlank(this._selectedIndex)) {
             this.tabView.selectedIndex = this._selectedIndex;
         }
diff --git a/nativescript-angular/dom-adapter.ts b/nativescript-angular/dom-adapter.ts
index 2a112782f..7ddffb681 100644
--- a/nativescript-angular/dom-adapter.ts
+++ b/nativescript-angular/dom-adapter.ts
@@ -1,7 +1,7 @@
 /* tslint:disable */
 import { Type } from "@angular/core";
 import { ɵDomAdapter } from "@angular/platform-browser";
-import { rendererLog } from "./trace";
+import { rendererLog, isLogEnabled } from "./trace";
 
 export class NativeScriptDomAdapter implements ɵDomAdapter {
   static makeCurrent() {
@@ -12,12 +12,16 @@ export class NativeScriptDomAdapter implements ɵDomAdapter {
             const privateAPI = global.require("@angular/platform-browser");
             const setRootDomAdapter = privateAPI.ɵsetRootDomAdapter;
 
-            rendererLog("Setting root DOM adapter...");
+            if (isLogEnabled()) {
+              rendererLog("Setting root DOM adapter...");
+            }
             setRootDomAdapter(new NativeScriptDomAdapter());
         } catch (e) {
-            rendererLog("@angular/platform-browser package not present. NOT setting root DOM adapter...");
+            if (isLogEnabled()) {
+              rendererLog("@angular/platform-browser package not present. NOT setting root DOM adapter...");
+            }
         }
-    }
+      }
   }
 
   hasProperty(_element: any, _name: string) {
diff --git a/nativescript-angular/platform-common.ts b/nativescript-angular/platform-common.ts
index b74fcf983..6e61289aa 100644
--- a/nativescript-angular/platform-common.ts
+++ b/nativescript-angular/platform-common.ts
@@ -22,7 +22,7 @@ import {
 } from "@angular/core";
 import { DOCUMENT } from "@angular/common";
 
-import { bootstrapLog, bootstrapLogError } from "./trace";
+import { bootstrapLog, bootstrapLogError, isLogEnabled } from "./trace";
 import { defaultPageFactoryProvider, setRootPage, PageFactory, PAGE_FACTORY } from "./platform-providers";
 import { AppHostView } from "./app-host-view";
 
@@ -156,18 +156,24 @@ export class NativeScriptPlatformRef extends PlatformRef {
             setRootPage(<any>tempAppHostView);
         }
 
-        bootstrapLog("NativeScriptPlatform bootstrap started.");
+        if (isLogEnabled()) {
+            bootstrapLog("NativeScriptPlatform bootstrap started.");
+        }
         const launchCallback = profile(
             "nativescript-angular/platform-common.launchCallback",
             (args: LaunchEventData) => {
-                bootstrapLog("Application launch event fired");
+                if (isLogEnabled()) {
+                    bootstrapLog("Application launch event fired");
+                }
 
                 let bootstrapPromiseCompleted = false;
                 this._bootstrapper().then(
                     moduleRef => {
                         bootstrapPromiseCompleted = true;
 
-                        bootstrapLog(`Angular bootstrap bootstrap done. uptime: ${uptime()}`);
+                        if (isLogEnabled()) {
+                            bootstrapLog(`Angular bootstrap bootstrap done. uptime: ${uptime()}`);
+                        }
 
                         if (!autoCreateFrame) {
                             rootContent = tempAppHostView.content;
@@ -179,20 +185,30 @@ export class NativeScriptPlatformRef extends PlatformRef {
                         bootstrapPromiseCompleted = true;
 
                         const errorMessage = err.message + "\n\n" + err.stack;
-                        bootstrapLogError("ERROR BOOTSTRAPPING ANGULAR");
-                        bootstrapLogError(errorMessage);
+                        if (isLogEnabled()) {
+                            bootstrapLogError("ERROR BOOTSTRAPPING ANGULAR");
+                        }
+                        if (isLogEnabled()) {
+                            bootstrapLogError(errorMessage);
+                        }
 
                         rootContent = this.createErrorUI(errorMessage);
                     }
                 );
 
-                bootstrapLog("bootstrapAction called, draining micro tasks queue. Root: " + rootContent);
+                if (isLogEnabled()) {
+                    bootstrapLog("bootstrapAction called, draining micro tasks queue. Root: " + rootContent);
+                }
                 (<any>global).Zone.drainMicroTaskQueue();
-                bootstrapLog("bootstrapAction called, draining micro tasks queue finished! Root: " + rootContent);
+                if (isLogEnabled()) {
+                    bootstrapLog("bootstrapAction called, draining micro tasks queue finished! Root: " + rootContent);
+                }
 
                 if (!bootstrapPromiseCompleted) {
                     const errorMessage = "Bootstrap promise didn't resolve";
-                    bootstrapLogError(errorMessage);
+                    if (isLogEnabled()) {
+                        bootstrapLogError(errorMessage);
+                    }
                     rootContent = this.createErrorUI(errorMessage);
                 }
 
@@ -206,7 +222,9 @@ export class NativeScriptPlatformRef extends PlatformRef {
 
     @profile
     public _livesync() {
-        bootstrapLog("Angular livesync started.");
+        if (isLogEnabled()) {
+            bootstrapLog("Angular livesync started.");
+        }
         onBeforeLivesync.next(lastBootstrappedModule ? lastBootstrappedModule.get() : null);
 
         const autoCreateFrame = !!this.appOptions.createFrameOnBootstrap;
@@ -227,7 +245,9 @@ export class NativeScriptPlatformRef extends PlatformRef {
         this._bootstrapper().then(
             moduleRef => {
                 bootstrapPromiseCompleted = true;
-                bootstrapLog("Angular livesync done.");
+                if (isLogEnabled()) {
+                    bootstrapLog("Angular livesync done.");
+                }
                 onAfterLivesync.next({ moduleRef });
 
                 if (!autoCreateFrame) {
@@ -238,9 +258,13 @@ export class NativeScriptPlatformRef extends PlatformRef {
             },
             error => {
                 bootstrapPromiseCompleted = true;
-                bootstrapLogError("ERROR LIVESYNC BOOTSTRAPPING ANGULAR");
+                if (isLogEnabled()) {
+                    bootstrapLogError("ERROR LIVESYNC BOOTSTRAPPING ANGULAR");
+                }
                 const errorMessage = error.message + "\n\n" + error.stack;
-                bootstrapLogError(errorMessage);
+                if (isLogEnabled()) {
+                    bootstrapLogError(errorMessage);
+                }
 
                 rootContent = this.createErrorUI(errorMessage);
 
@@ -248,13 +272,19 @@ export class NativeScriptPlatformRef extends PlatformRef {
             }
         );
 
-        bootstrapLog("livesync bootstrapAction called, draining micro tasks queue. Root: " + rootContent);
+        if (isLogEnabled()) {
+            bootstrapLog("livesync bootstrapAction called, draining micro tasks queue. Root: " + rootContent);
+        }
         (<any>global).Zone.drainMicroTaskQueue();
-        bootstrapLog("livesync bootstrapAction called, draining micro tasks queue finished! Root: " + rootContent);
+        if (isLogEnabled()) {
+            bootstrapLog("livesync bootstrapAction called, draining micro tasks queue finished! Root: " + rootContent);
+        }
 
         if (!bootstrapPromiseCompleted) {
             const result = "Livesync bootstrap promise didn't resolve";
-            bootstrapLogError(result);
+            if (isLogEnabled()) {
+                bootstrapLogError(result);
+            }
             rootContent = this.createErrorUI(result);
 
             onAfterLivesync.next({ error: new Error(result) });
diff --git a/nativescript-angular/renderer.ts b/nativescript-angular/renderer.ts
index cad922ac2..ea6998cde 100644
--- a/nativescript-angular/renderer.ts
+++ b/nativescript-angular/renderer.ts
@@ -12,7 +12,7 @@ import { profile } from "tns-core-modules/profiling";
 import { APP_ROOT_VIEW, DEVICE, getRootPage } from "./platform-providers";
 import { ViewUtil } from "./view-util";
 import { NgView, InvisibleNode } from "./element-registry";
-import { rendererLog as traceLog } from "./trace";
+import { rendererLog as traceLog, isLogEnabled } from "./trace";
 
 // CONTENT_ATTR not exported from NativeScript_renderer - we need it for styles application.
 const COMPONENT_REGEX = /%COMP%/g;
@@ -84,31 +84,41 @@ export class NativeScriptRenderer extends Renderer2 {
         private viewUtil: ViewUtil
     ) {
         super();
-        traceLog("NativeScriptRenderer created");
+        if (isLogEnabled()) {
+            traceLog("NativeScriptRenderer created");
+        }
     }
 
     @profile
     appendChild(parent: NgView, newChild: NgView): void {
-        traceLog(`NativeScriptRenderer.appendChild child: ${newChild} parent: ${parent}`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.appendChild child: ${newChild} parent: ${parent}`);
+        }
         this.viewUtil.insertChild(parent, newChild);
     }
 
     @profile
     insertBefore(parent: NgView, newChild: NgView, { previous, next }: ElementReference): void {
-        traceLog(`NativeScriptRenderer.insertBefore child: ${newChild} ` +
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.insertBefore child: ${newChild} ` +
             `parent: ${parent} previous: ${previous} next: ${next}`);
+        }
         this.viewUtil.insertChild(parent, newChild, previous, next);
     }
 
     @profile
     removeChild(parent: any, oldChild: NgView): void {
-        traceLog(`NativeScriptRenderer.removeChild child: ${oldChild} parent: ${parent}`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.removeChild child: ${oldChild} parent: ${parent}`);
+        }
         this.viewUtil.removeChild(parent, oldChild);
     }
 
     @profile
     selectRootElement(selector: string): NgView {
-        traceLog("NativeScriptRenderer.selectRootElement: " + selector);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.selectRootElement: ${selector}`);
+        }
         if (selector && selector[0] === "#") {
             const result = getViewById(this.rootView, selector.slice(1));
             return (result || this.rootView) as NgView;
@@ -118,13 +128,17 @@ export class NativeScriptRenderer extends Renderer2 {
 
     @profile
     parentNode(node: NgView): any {
-        traceLog(`NativeScriptRenderer.parentNode for node: ${node}`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.parentNode for node: ${node}`);
+        }
         return node.parentNode;
     }
 
     @profile
     nextSibling(node: NgView): ElementReference {
-        traceLog(`NativeScriptRenderer.nextSibling of ${node} is ${node.nextSibling}`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.nextSibling of ${node} is ${node.nextSibling}`);
+        }
 
         return {
             previous: node,
@@ -134,79 +148,105 @@ export class NativeScriptRenderer extends Renderer2 {
 
     @profile
     createComment(_value: any): InvisibleNode {
-        traceLog(`NativeScriptRenderer.createComment ${_value}`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.createComment ${_value}`);
+        }
         return this.viewUtil.createComment();
     }
 
     @profile
     createElement(name: any, _namespace: string): NgView {
-        traceLog(`NativeScriptRenderer.createElement: ${name}`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.createElement: ${name}`);
+        }
         return this.viewUtil.createView(name);
     }
 
     @profile
     createText(_value: string): InvisibleNode {
-        traceLog(`NativeScriptRenderer.createText ${_value}`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.createText ${_value}`);
+        }
         return this.viewUtil.createText();
     }
 
     @profile
     createViewRoot(hostElement: NgView): NgView {
-        traceLog(`NativeScriptRenderer.createViewRoot ${hostElement.nodeName}`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.createViewRoot ${hostElement.nodeName}`);
+        }
         return hostElement;
     }
 
     @profile
     projectNodes(parentElement: NgView, nodes: NgView[]): void {
-        traceLog("NativeScriptRenderer.projectNodes");
+        if (isLogEnabled()) {
+            traceLog("NativeScriptRenderer.projectNodes");
+        }
         nodes.forEach((node) => this.viewUtil.insertChild(parentElement, node));
     }
 
     @profile
     destroy() {
-        traceLog("NativeScriptRenderer.destroy");
+        if (isLogEnabled()) {
+            traceLog("NativeScriptRenderer.destroy");
+        }
         // Seems to be called on component dispose only (router outlet)
         // TODO: handle this when we resolve routing and navigation.
     }
 
     @profile
     setAttribute(view: NgView, name: string, value: string, namespace?: string) {
-        traceLog(`NativeScriptRenderer.setAttribute ${view} : ${name} = ${value}, namespace: ${namespace}`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.setAttribute ${view} : ${name} = ${value}, namespace: ${namespace}`);
+        }
         return this.viewUtil.setProperty(view, name, value, namespace);
     }
 
     @profile
     removeAttribute(_el: NgView, _name: string): void {
-        traceLog(`NativeScriptRenderer.removeAttribute ${_el}: ${_name}`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.removeAttribute ${_el}: ${_name}`);
+        }
     }
 
     @profile
     setProperty(view: any, name: string, value: any) {
-        traceLog(`NativeScriptRenderer.setProperty ${view} : ${name} = ${value}`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.setProperty ${view} : ${name} = ${value}`);
+        }
         return this.viewUtil.setProperty(view, name, value);
     }
 
     @profile
     addClass(view: NgView, name: string): void {
-        traceLog(`NativeScriptRenderer.addClass ${name}`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.addClass ${name}`);
+        }
         this.viewUtil.addClass(view, name);
     }
 
     @profile
     removeClass(view: NgView, name: string): void {
-        traceLog(`NativeScriptRenderer.removeClass ${name}`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.removeClass ${name}`);
+        }
         this.viewUtil.removeClass(view, name);
     }
 
     @profile
     setStyle(view: NgView, styleName: string, value: any, _flags?: RendererStyleFlags2): void {
-        traceLog(`NativeScriptRenderer.setStyle: ${styleName} = ${value}`);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.setStyle: ${styleName} = ${value}`);
+        }
         this.viewUtil.setStyle(view, styleName, value);
     }
 
     @profile
     removeStyle(view: NgView, styleName: string, _flags?: RendererStyleFlags2): void {
-        traceLog("NativeScriptRenderer.removeStyle: ${styleName}");
+        if (isLogEnabled()) {
+            traceLog("NativeScriptRenderer.removeStyle: ${styleName}");
+        }
         this.viewUtil.removeStyle(view, styleName);
     }
 
@@ -214,32 +254,38 @@ export class NativeScriptRenderer extends Renderer2 {
     // such as <template> placeholders.
     @profile
     setBindingDebugInfo(renderElement: NgView, propertyName: string, propertyValue: string): void {
-        traceLog("NativeScriptRenderer.setBindingDebugInfo: " + renderElement + ", " +
-            propertyName + " = " + propertyValue);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.setBindingDebugInfo: ${renderElement}, ${propertyName} = ${propertyValue}`);
+        }
     }
 
     @profile
     setElementDebugInfo(renderElement: any, _info: any /*RenderDebugInfo*/): void {
-        traceLog("NativeScriptRenderer.setElementDebugInfo: " + renderElement);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.setElementDebugInfo: ${renderElement}`);
+        }
     }
 
     @profile
     invokeElementMethod(_renderElement: NgView, methodName: string, args: Array<any>) {
-        traceLog("NativeScriptRenderer.invokeElementMethod " + methodName + " " + args);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.invokeElementMethod ${methodName} ${args}`);
+        }
     }
 
     @profile
     setValue(_renderNode: any, _value: string) {
-        traceLog(
-            `NativeScriptRenderer.setValue ` +
-            `renderNode: ${_renderNode}, value: ${_value}`
-        );
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.setValue renderNode: ${_renderNode}, value: ${_value}`);
+        }
     }
 
     @profile
     listen(renderElement: any, eventName: string, callback: (event: any) => boolean):
         () => void {
-        traceLog("NativeScriptRenderer.listen: " + eventName);
+        if (isLogEnabled()) {
+            traceLog(`NativeScriptRenderer.listen: ${eventName}`);
+        }
         // Explicitly wrap in zone
         let zonedCallback = (...args) => {
             this.zone.run(() => {
diff --git a/nativescript-angular/router/ns-location-strategy.ts b/nativescript-angular/router/ns-location-strategy.ts
index 9db95c617..e266921c4 100644
--- a/nativescript-angular/router/ns-location-strategy.ts
+++ b/nativescript-angular/router/ns-location-strategy.ts
@@ -1,7 +1,7 @@
 import { Injectable } from "@angular/core";
 import { LocationStrategy } from "@angular/common";
 import { DefaultUrlSerializer, UrlSegmentGroup, UrlTree } from "@angular/router";
-import { routerLog, routerError } from "../trace";
+import { routerLog, routerError, isLogEnabled } from "../trace";
 import { NavigationTransition, Frame } from "tns-core-modules/ui/frame";
 import { isPresent } from "../lang-facade";
 import { FrameService } from "../platform-providers";
@@ -42,7 +42,9 @@ export class NSLocationStrategy extends LocationStrategy {
 
     constructor(private frameService: FrameService) {
         super();
-        routerLog("NSLocationStrategy.constructor()");
+        if (isLogEnabled()) {
+            routerLog("NSLocationStrategy.constructor()");
+        }
     }
 
     path(): string {
@@ -67,18 +69,24 @@ export class NSLocationStrategy extends LocationStrategy {
 
         const urlSerializer = new DefaultUrlSerializer();
         const url = urlSerializer.serialize(tree);
-        routerLog("NSLocationStrategy.path(): " + url);
+        if (isLogEnabled()) {
+            routerLog("NSLocationStrategy.path(): " + url);
+        }
         return url;
     }
 
     prepareExternalUrl(internal: string): string {
-        routerLog("NSLocationStrategy.prepareExternalUrl() internal: " + internal);
+        if (isLogEnabled()) {
+            routerLog("NSLocationStrategy.prepareExternalUrl() internal: " + internal);
+        }
         return internal;
     }
 
     pushState(state: any, title: string, url: string, queryParams: string): void {
-        routerLog("NSLocationStrategy.pushState state: " +
-            `${state}, title: ${title}, url: ${url}, queryParams: ${queryParams}`);
+        if (isLogEnabled()) {
+            routerLog("NSLocationStrategy.pushState state: " +
+                `${state}, title: ${title}, url: ${url}, queryParams: ${queryParams}`);
+        }
         this.pushStateInternal(state, title, url, queryParams);
     }
 
@@ -130,8 +138,10 @@ export class NSLocationStrategy extends LocationStrategy {
     replaceState(state: any, title: string, url: string, queryParams: string): void {
         const states = this.statesByOutlet[this.currentOutlet];
         if (states && states.length > 0) {
-            routerLog("NSLocationStrategy.replaceState changing existing state: " +
-                `${state}, title: ${title}, url: ${url}, queryParams: ${queryParams}`);
+            if (isLogEnabled()) {
+                routerLog("NSLocationStrategy.replaceState changing existing state: " +
+                    `${state}, title: ${title}, url: ${url}, queryParams: ${queryParams}`);
+            }
 
             const tree = this.currentUrlTree;
             if (url !== tree.toString()) {
@@ -149,8 +159,10 @@ export class NSLocationStrategy extends LocationStrategy {
                 });
             }
         } else {
-            routerLog("NSLocationStrategy.replaceState pushing new state: " +
-                `${state}, title: ${title}, url: ${url}, queryParams: ${queryParams}`);
+            if (isLogEnabled()) {
+                routerLog("NSLocationStrategy.replaceState pushing new state: " +
+                    `${state}, title: ${title}, url: ${url}, queryParams: ${queryParams}`);
+            }
             this.pushStateInternal(state, title, url, queryParams);
         }
     }
@@ -186,7 +198,9 @@ export class NSLocationStrategy extends LocationStrategy {
                 }
             }
 
-            routerLog("NSLocationStrategy.back() while closing modal. States popped: " + count);
+            if (isLogEnabled()) {
+                routerLog(`NSLocationStrategy.back() while closing modal. States popped: ${count}`);
+            }
 
             if (state) {
                 this.callPopState(state, true);
@@ -203,20 +217,26 @@ export class NSLocationStrategy extends LocationStrategy {
                 count++;
             }
 
-            routerLog("NSLocationStrategy.back() while navigating back. States popped: " + count);
+            if (isLogEnabled()) {
+                routerLog(`NSLocationStrategy.back() while navigating back. States popped: ${count}`);
+            }
             this.callPopState(state, true);
         } else {
             let state = this.peekState(this.currentOutlet);
             if (state.isPageNavigation) {
                 // This was a page navigation - so navigate through frame.
-                routerLog("NSLocationStrategy.back() while not navigating back but top" +
-                    " state is page - will call frame.goBack()");
+                if (isLogEnabled()) {
+                    routerLog("NSLocationStrategy.back() while not navigating back but top" +
+                        " state is page - will call frame.goBack()");
+                }
                 const frame = this.frameService.getFrame();
                 frame.goBack();
             } else {
                 // Nested navigation - just pop the state
-                routerLog("NSLocationStrategy.back() while not navigating back but top" +
-                    " state is not page - just pop");
+                if (isLogEnabled()) {
+                    routerLog("NSLocationStrategy.back() while not navigating back but top" +
+                        " state is not page - just pop");
+                }
 
                 this.callPopState(this.statesByOutlet[this.currentOutlet].pop(), true);
             }
@@ -229,12 +249,16 @@ export class NSLocationStrategy extends LocationStrategy {
     }
 
     onPopState(fn: (_: any) => any): void {
-        routerLog("NSLocationStrategy.onPopState");
+        if (isLogEnabled()) {
+            routerLog("NSLocationStrategy.onPopState");
+        }
         this.popStateCallbacks.push(fn);
     }
 
     getBaseHref(): string {
-        routerLog("NSLocationStrategy.getBaseHref()");
+        if (isLogEnabled()) {
+            routerLog("NSLocationStrategy.getBaseHref()");
+        }
         return "";
     }
 
@@ -287,10 +311,14 @@ export class NSLocationStrategy extends LocationStrategy {
     // Methods for syncing with page navigation in PageRouterOutlet
     public _beginBackPageNavigation(name: string, frame: Frame) {
         if (this._isPageNavigationBack) {
-            routerError("Attempted to call startGoBack while going back.");
+            if (isLogEnabled()) {
+                routerError("Attempted to call startGoBack while going back.");
+            }
             return;
         }
-        routerLog("NSLocationStrategy.startGoBack()");
+        if (isLogEnabled()) {
+            routerLog("NSLocationStrategy.startGoBack()");
+        }
         this._isPageNavigationBack = true;
 
         let { cachedFrame } = this.frameService.findFrame(frame);
@@ -304,10 +332,14 @@ export class NSLocationStrategy extends LocationStrategy {
 
     public _finishBackPageNavigation() {
         if (!this._isPageNavigationBack) {
-            routerError("Attempted to call endGoBack while not going back.");
+            if (isLogEnabled()) {
+                routerError("Attempted to call endGoBack while not going back.");
+            }
             return;
         }
-        routerLog("NSLocationStrategy.finishBackPageNavigation()");
+        if (isLogEnabled()) {
+            routerLog("NSLocationStrategy.finishBackPageNavigation()");
+        }
         this._isPageNavigationBack = false;
     }
 
@@ -316,7 +348,9 @@ export class NSLocationStrategy extends LocationStrategy {
     }
 
     public _beginModalNavigation(frame: Frame): void {
-      routerLog("NSLocationStrategy._beginModalNavigation()");
+        if (isLogEnabled()) {
+          routerLog("NSLocationStrategy._beginModalNavigation()");
+        }
 
       let { cachedFrameRootOutlet } = this.frameService.findFrame(frame);
 
@@ -331,26 +365,36 @@ export class NSLocationStrategy extends LocationStrategy {
 
     public _beginCloseModalNavigation(): void {
         if (this._isModalClosing) {
-            routerError("Attempted to call startCloseModal while closing modal.");
+            if (isLogEnabled()) {
+                routerError("Attempted to call startCloseModal while closing modal.");
+            }
             return;
         }
-        routerLog("NSLocationStrategy.startCloseModal()");
+        if (isLogEnabled()) {
+            routerLog("NSLocationStrategy.startCloseModal()");
+        }
         this._isModalClosing = true;
     }
 
     public _finishCloseModalNavigation() {
         if (!this._isModalClosing) {
-            routerError("Attempted to call startCloseModal while not closing modal.");
+            if (isLogEnabled()) {
+                routerError("Attempted to call startCloseModal while not closing modal.");
+            }
             return;
         }
 
-        routerLog("NSLocationStrategy.finishCloseModalNavigation()");
+        if (isLogEnabled()) {
+            routerLog("NSLocationStrategy.finishCloseModalNavigation()");
+        }
         this._isModalNavigation = false;
         this._isModalClosing = false;
     }
 
     public _beginPageNavigation(name: string, frame: Frame): NavigationOptions {
-        routerLog("NSLocationStrategy._beginPageNavigation()");
+        if (isLogEnabled()) {
+            routerLog("NSLocationStrategy._beginPageNavigation()");
+        }
 
         let { cachedFrame } = this.frameService.findFrame(frame);
 
@@ -372,7 +416,9 @@ export class NSLocationStrategy extends LocationStrategy {
 
         const navOptions = this._currentNavigationOptions || defaultNavOptions;
         if (navOptions.clearHistory) {
-            routerLog("NSLocationStrategy._beginPageNavigation clearing states history");
+            if (isLogEnabled()) {
+                routerLog("NSLocationStrategy._beginPageNavigation clearing states history");
+            }
             this.statesByOutlet[this.currentOutlet] = [lastState];
         }
 
@@ -386,8 +432,10 @@ export class NSLocationStrategy extends LocationStrategy {
             animated: isPresent(options.animated) ? options.animated : true,
             transition: options.transition
         };
-        routerLog("NSLocationStrategy._setNavigationOptions(" +
+        if (isLogEnabled()) {
+            routerLog("NSLocationStrategy._setNavigationOptions(" +
             `${JSON.stringify(this._currentNavigationOptions)})`);
+        }
     }
 
     public _getStates(): { [key: string]: Array<LocationState> } {
diff --git a/nativescript-angular/router/ns-platform-location.ts b/nativescript-angular/router/ns-platform-location.ts
index b941b13fe..311faa5b8 100644
--- a/nativescript-angular/router/ns-platform-location.ts
+++ b/nativescript-angular/router/ns-platform-location.ts
@@ -1,15 +1,16 @@
 import { NSLocationStrategy } from "./ns-location-strategy";
 import { PlatformLocation, LocationChangeListener } from "@angular/common";
 import { Injectable } from "@angular/core";
-import { routerLog } from "../trace";
-
+import { routerLog, isLogEnabled } from "../trace";
 
 @Injectable()
 export class NativescriptPlatformLocation extends PlatformLocation {
 
     constructor(private locationStartegy: NSLocationStrategy) {
         super();
-        routerLog("NativescriptPlatformLocation.constructor()");
+        if (isLogEnabled()) {
+            routerLog("NativescriptPlatformLocation.constructor()");
+        }
     }
 
     getBaseHrefFromDOM(): string {
diff --git a/nativescript-angular/router/ns-route-reuse-strategy.ts b/nativescript-angular/router/ns-route-reuse-strategy.ts
index e9b425020..b1f90b791 100644
--- a/nativescript-angular/router/ns-route-reuse-strategy.ts
+++ b/nativescript-angular/router/ns-route-reuse-strategy.ts
@@ -1,7 +1,7 @@
 import { Injectable } from "@angular/core";
 import { RouteReuseStrategy, ActivatedRouteSnapshot, DetachedRouteHandle } from "@angular/router";
 
-import { routeReuseStrategyLog as log } from "../trace";
+import { routeReuseStrategyLog as log, isLogEnabled } from "../trace";
 import { NSLocationStrategy } from "./ns-location-strategy";
 import {
     destroyComponentRef,
@@ -38,7 +38,9 @@ class DetachedStateCache {
     }
 
     public clear() {
-        log(`DetachedStateCache.clear() ${this.cache.length} items will be destroyed`);
+        if (isLogEnabled()) {
+            log(`DetachedStateCache.clear() ${this.cache.length} items will be destroyed`);
+        }
 
         while (this.cache.length > 0) {
             const state = <any>this.cache.pop().state;
@@ -77,7 +79,9 @@ class DetachedStateCache {
             }
         }
 
-        log(`DetachedStateCache.clearModalCache() ${removedItemsCount} items will be destroyed`);
+        if (isLogEnabled()) {
+            log(`DetachedStateCache.clearModalCache() ${removedItemsCount} items will be destroyed`);
+        }
     }
 }
 
@@ -100,7 +104,9 @@ export class NSRouteReuseStrategy implements RouteReuseStrategy {
         const isBack = this.location._isPageNavigatingBack();
         const shouldDetach = !isBack && isPageActivated;
 
-        log(`shouldDetach isBack: ${isBack} key: ${key} result: ${shouldDetach}`);
+        if (isLogEnabled()) {
+            log(`shouldDetach isBack: ${isBack} key: ${key} result: ${shouldDetach}`);
+        }
 
         return shouldDetach;
     }
@@ -117,7 +123,9 @@ export class NSRouteReuseStrategy implements RouteReuseStrategy {
         const isBack = this.location._isPageNavigatingBack();
         const shouldAttach = isBack && cache.peek().key === key;
 
-        log(`shouldAttach isBack: ${isBack} key: ${key} result: ${shouldAttach}`);
+        if (isLogEnabled()) {
+            log(`shouldAttach isBack: ${isBack} key: ${key} result: ${shouldAttach}`);
+        }
 
         return shouldAttach;
     }
@@ -126,7 +134,9 @@ export class NSRouteReuseStrategy implements RouteReuseStrategy {
         route = findTopActivatedRouteNodeForOutlet(route);
 
         const key = getSnapshotKey(route);
-        log(`store key: ${key}, state: ${state}`);
+        if (isLogEnabled()) {
+            log(`store key: ${key}, state: ${state}`);
+        }
 
         const cache = this.cacheByOutlet[route.outlet] = this.cacheByOutlet[route.outlet] || new DetachedStateCache();
 
@@ -166,7 +176,9 @@ export class NSRouteReuseStrategy implements RouteReuseStrategy {
             state = cachedItem.state;
         }
 
-        log(`retrieved isBack: ${isBack} key: ${key} state: ${state}`);
+        if (isLogEnabled()) {
+            log(`retrieved isBack: ${isBack} key: ${key} state: ${state}`);
+        }
 
         return state;
     }
@@ -180,7 +192,9 @@ export class NSRouteReuseStrategy implements RouteReuseStrategy {
             future[pageRouterActivatedSymbol] = curr[pageRouterActivatedSymbol];
         }
 
-        log(`shouldReuseRoute result: ${shouldReuse}`);
+        if (isLogEnabled()) {
+            log(`shouldReuseRoute result: ${shouldReuse}`);
+        }
 
         return shouldReuse;
     }
diff --git a/nativescript-angular/router/ns-router-link.ts b/nativescript-angular/router/ns-router-link.ts
index c6b220151..d5e73270f 100644
--- a/nativescript-angular/router/ns-router-link.ts
+++ b/nativescript-angular/router/ns-router-link.ts
@@ -1,7 +1,7 @@
 import { Directive, HostListener, Input } from "@angular/core";
 import { NavigationExtras } from "@angular/router";
 import { ActivatedRoute, Router, UrlTree } from "@angular/router";
-import { routerLog } from "../trace";
+import { routerLog, isLogEnabled } from "../trace";
 import { RouterExtensions } from "./router-extensions";
 import { NavigationOptions } from "./ns-location-strategy";
 import { NavigationTransition } from "tns-core-modules/ui/frame";
@@ -69,10 +69,12 @@ export class NSRouterLink { // tslint:disable-line:directive-class-suffix
 
     @HostListener("tap")
     onTap() {
-        routerLog(`nsRouterLink.tapped: ${this.commands} ` +
-            `clear: ${this.clearHistory} ` +
-            `transition: ${JSON.stringify(this.pageTransition)} ` +
-            `duration: ${this.pageTransitionDuration}`);
+        if (isLogEnabled()) {
+            routerLog(`nsRouterLink.tapped: ${this.commands} ` +
+                `clear: ${this.clearHistory} ` +
+                `transition: ${JSON.stringify(this.pageTransition)} ` +
+                `duration: ${this.pageTransitionDuration}`);
+        }
 
         const extras = this.getExtras();
         this.navigator.navigateByUrl(this.urlTree, extras);
@@ -100,7 +102,9 @@ export class NSRouterLink { // tslint:disable-line:directive-class-suffix
             preserveFragment: attrBoolValue(this.preserveFragment),
         });
 
-        routerLog(`nsRouterLink urlTree created: ${urlTree}`);
+        if (isLogEnabled()) {
+            routerLog(`nsRouterLink urlTree created: ${urlTree}`);
+        }
 
         return urlTree;
     }
diff --git a/nativescript-angular/router/page-router-outlet.ts b/nativescript-angular/router/page-router-outlet.ts
index d9dc46776..bccb43f70 100644
--- a/nativescript-angular/router/page-router-outlet.ts
+++ b/nativescript-angular/router/page-router-outlet.ts
@@ -20,7 +20,7 @@ import { profile } from "tns-core-modules/profiling";
 import { BehaviorSubject } from "rxjs";
 
 import { DEVICE, PAGE_FACTORY, PageFactory } from "../platform-providers";
-import { routerLog as log } from "../trace";
+import { routerLog as log, isLogEnabled } from "../trace";
 import { DetachedLoader } from "../common/detached-loader";
 import { ViewUtil } from "../view-util";
 import { NSLocationStrategy } from "./ns-location-strategy";
@@ -126,7 +126,9 @@ export class PageRouterOutlet implements OnDestroy { // tslint:disable-line:dire
 
     get component(): Object {
         if (!this.activated) {
-            log("Outlet is not activated");
+            if (isLogEnabled()) {
+                log("Outlet is not activated");
+            }
             return;
         }
 
@@ -134,7 +136,9 @@ export class PageRouterOutlet implements OnDestroy { // tslint:disable-line:dire
     }
     get activatedRoute(): ActivatedRoute {
         if (!this.activated) {
-            log("Outlet is not activated");
+            if (isLogEnabled()) {
+                log("Outlet is not activated");
+            }
             return;
         }
 
@@ -156,7 +160,9 @@ export class PageRouterOutlet implements OnDestroy { // tslint:disable-line:dire
         private frameService: FrameService
     ) {
         this.frame = elRef.nativeElement;
-        log("PageRouterOutlet.constructor frame:" + this.frame);
+        if (isLogEnabled()) {
+            log(`PageRouterOutlet.constructor frame: ${this.frame}`);
+        }
 
         this.name = name || PRIMARY_OUTLET;
         parentContexts.onChildOutletCreated(this.name, <any>this);
@@ -175,11 +181,16 @@ export class PageRouterOutlet implements OnDestroy { // tslint:disable-line:dire
 
     deactivate(): void {
         if (!this.locationStrategy._isPageNavigatingBack()) {
-          log("Currently not in page back navigation - component should be detached instead of deactivated.");
-          return;
+            if (isLogEnabled()) {
+                log("Currently not in page back navigation - component should be detached instead of deactivated.");
+            }
+
+            return;
         }
 
-        log("PageRouterOutlet.deactivate() while going back - should destroy");
+        if (isLogEnabled()) {
+            log("PageRouterOutlet.deactivate() while going back - should destroy");
+        }
 
         if (!this.isActivated) {
             return;
@@ -199,11 +210,15 @@ export class PageRouterOutlet implements OnDestroy { // tslint:disable-line:dire
      */
     detach(): ComponentRef<any> {
         if (!this.isActivated) {
-            log("Outlet is not activated");
+            if (isLogEnabled()) {
+                log("Outlet is not activated");
+            }
             return;
         }
 
-        log("PageRouterOutlet.detach() - " + routeToString(this._activatedRoute));
+        if (isLogEnabled()) {
+            log(`PageRouterOutlet.detach() - ${routeToString(this._activatedRoute)}`);
+        }
 
         const component = this.activated;
         this.activated = null;
@@ -215,7 +230,9 @@ export class PageRouterOutlet implements OnDestroy { // tslint:disable-line:dire
      * Called when the `RouteReuseStrategy` instructs to re-attach a previously detached subtree
      */
     attach(ref: ComponentRef<any>, activatedRoute: ActivatedRoute) {
-        log("PageRouterOutlet.attach() - " + routeToString(activatedRoute));
+        if (isLogEnabled()) {
+            log(`PageRouterOutlet.attach() - ${routeToString(activatedRoute)}`);
+        }
 
         this.activated = ref;
         this._activatedRoute = activatedRoute;
@@ -235,11 +252,15 @@ export class PageRouterOutlet implements OnDestroy { // tslint:disable-line:dire
         resolver: ComponentFactoryResolver | null): void {
 
         if (this.locationStrategy._isPageNavigatingBack()) {
-            log("Currently in page back navigation - component should be reattached instead of activated.");
+            if (isLogEnabled()) {
+                log("Currently in page back navigation - component should be reattached instead of activated.");
+            }
             this.locationStrategy._finishBackPageNavigation();
         }
 
-        log("PageRouterOutlet.activateWith() - " + routeToString(activatedRoute));
+        if (isLogEnabled()) {
+            log(`PageRouterOutlet.activateWith() - ${routeToString(activatedRoute)}`);
+        }
 
         this._activatedRoute = activatedRoute;
 
@@ -255,8 +276,10 @@ export class PageRouterOutlet implements OnDestroy { // tslint:disable-line:dire
         activatedRoute: ActivatedRoute,
         loadedResolver: ComponentFactoryResolver
     ): void {
-        log("PageRouterOutlet.activate() forward navigation - " +
-            "create detached loader in the loader container");
+        if (isLogEnabled()) {
+            log("PageRouterOutlet.activate() forward navigation - " +
+                "create detached loader in the loader container");
+        }
 
         const factory = this.getComponentFactory(activatedRoute, loadedResolver);
         const page = this.pageFactory({
@@ -321,7 +344,9 @@ export class PageRouterOutlet implements OnDestroy { // tslint:disable-line:dire
     private markActivatedRoute(activatedRoute: ActivatedRoute) {
         const nodeToMark = findTopActivatedRouteNodeForOutlet(activatedRoute.snapshot);
         nodeToMark[pageRouterActivatedSymbol] = true;
-        log("Activated route marked as page: " + routeToString(nodeToMark));
+        if (isLogEnabled()) {
+            log(`Activated route marked as page: ${routeToString(nodeToMark)}`);
+        }
     }
 
     private getComponentFactory(
diff --git a/nativescript-angular/trace.ts b/nativescript-angular/trace.ts
index 3758696b2..2ca450110 100644
--- a/nativescript-angular/trace.ts
+++ b/nativescript-angular/trace.ts
@@ -1,4 +1,5 @@
 import { write, categories, messageType } from "tns-core-modules/trace";
+export { isEnabled as isLogEnabled } from "tns-core-modules/trace";
 
 export const animationsTraceCategory = "ns-animations";
 export const rendererTraceCategory = "ns-renderer";
diff --git a/nativescript-angular/view-util.ts b/nativescript-angular/view-util.ts
index b9916d313..5a3dea4c8 100644
--- a/nativescript-angular/view-util.ts
+++ b/nativescript-angular/view-util.ts
@@ -18,7 +18,7 @@ import {
 } from "./element-registry";
 
 import { platformNames, Device } from "tns-core-modules/platform";
-import { viewUtilLog as traceLog } from "./trace";
+import { viewUtilLog as traceLog, isLogEnabled } from "./trace";
 
 const ELEMENT_NODE_TYPE = 1;
 const XML_ATTRIBUTES = Object.freeze(["style", "rows", "columns", "fontAttributes"]);
@@ -84,8 +84,10 @@ export class ViewUtil {
         previous: NgView,
         next: NgView
     ): void {
-        traceLog(`ViewUtil.addToQueue parent: ${parent}, view: ${child}, ` +
-            `previous: ${previous}, next: ${next}`);
+        if (isLogEnabled()) {
+            traceLog(`ViewUtil.addToQueue parent: ${parent}, view: ${child}, ` +
+                `previous: ${previous}, next: ${next}`);
+        }
 
         if (previous) {
             previous.nextSibling = child;
@@ -101,7 +103,9 @@ export class ViewUtil {
     }
 
     private appendToQueue(parent: NgView, view: NgView) {
-        traceLog(`ViewUtil.appendToQueue parent: ${parent} view: ${view}`);
+        if (isLogEnabled()) {
+            traceLog(`ViewUtil.appendToQueue parent: ${parent} view: ${view}`);
+        }
 
         if (parent.lastChild) {
             parent.lastChild.nextSibling = view;
@@ -111,7 +115,9 @@ export class ViewUtil {
     }
 
     private addToVisualTree(parent: NgView, child: NgView, next: NgView): void {
-        traceLog(`ViewUtil.addToVisualTree parent: ${parent}, view: ${child}, next: ${next}`);
+        if (isLogEnabled()) {
+            traceLog(`ViewUtil.addToVisualTree parent: ${parent}, view: ${child}, next: ${next}`);
+        }
 
         if (parent.meta && parent.meta.insertChild) {
             parent.meta.insertChild(parent, child, next);
@@ -152,7 +158,9 @@ export class ViewUtil {
     }
 
     public removeChild(parent: View, child: View) {
-       traceLog(`ViewUtil.removeChild parent: ${parent} child: ${child}`);
+        if (isLogEnabled()) {
+           traceLog(`ViewUtil.removeChild parent: ${parent} child: ${child}`);
+        }
 
         if (!parent) {
             return;
@@ -166,7 +174,9 @@ export class ViewUtil {
     }
 
     private removeFromQueue(parent: NgView, child: NgView) {
-        traceLog(`ViewUtil.removeFromQueue parent: ${parent} child: ${child}`);
+        if (isLogEnabled()) {
+            traceLog(`ViewUtil.removeFromQueue parent: ${parent} child: ${child}`);
+        }
 
         if (parent.firstChild === child && parent.lastChild === child) {
             parent.firstChild = null;
@@ -190,7 +200,9 @@ export class ViewUtil {
 
     // NOTE: This one is O(n) - use carefully
     private findPreviousElement(parent: NgView, child: NgView): NgView {
-        traceLog(`ViewUtil.findPreviousElement parent: ${parent} child: ${child}`);
+        if (isLogEnabled()) {
+            traceLog(`ViewUtil.findPreviousElement parent: ${parent} child: ${child}`);
+        }
 
         let previousVisual;
         if (isLayout(parent)) {
@@ -227,7 +239,9 @@ export class ViewUtil {
     }
 
     private removeFromVisualTree(parent: NgView, child: NgView) {
-        traceLog(`ViewUtil.findPreviousElement parent: ${parent} child: ${child}`);
+        if (isLogEnabled()) {
+            traceLog(`ViewUtil.findPreviousElement parent: ${parent} child: ${child}`);
+        }
 
         if (parent.meta && parent.meta.removeChild) {
             parent.meta.removeChild(parent, child);
@@ -259,7 +273,9 @@ export class ViewUtil {
     }
 
     public createView(name: string): NgView {
-        traceLog(`Creating view: ${name}`);
+        if (isLogEnabled()) {
+            traceLog(`Creating view: ${name}`);
+        }
 
         if (!isKnownView(name)) {
             name = "ProxyViewContainer";
@@ -331,7 +347,9 @@ export class ViewUtil {
     }
 
     private setPropertyInternal(view: NgView, attributeName: string, value: any): void {
-        traceLog(`Setting attribute: ${attributeName}=${value} to ${view}`);
+        if (isLogEnabled()) {
+            traceLog(`Setting attribute: ${attributeName}=${value} to ${view}`);
+        }
 
         if (attributeName === "class") {
             this.setClasses(view, value);