From 6be4ea9bf52dba8e7d5ec39019aa31e41abe0748 Mon Sep 17 00:00:00 2001
From: Dilshat Hewzulla <hewzulla@gmail.com>
Date: Tue, 7 Nov 2017 16:07:20 +0000
Subject: [PATCH 1/9] injecting log to any javascript function

---
 src/loggly.tracker.js | 95 ++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 93 insertions(+), 2 deletions(-)

diff --git a/src/loggly.tracker.js b/src/loggly.tracker.js
index be46e49..8273001 100644
--- a/src/loggly.tracker.js
+++ b/src/loggly.tracker.js
@@ -43,7 +43,7 @@
             var _onerror = window.onerror;
             //send console error messages to Loggly
             window.onerror = function (msg, url, line, col, err){
-                tracker.push({ 
+                tracker.push({
                     category: 'BrowserJsException',
                     exception: {
                         message: msg,
@@ -181,7 +181,98 @@
         },
         setCookie: function (value) {
             document.cookie = LOGGLY_SESSION_KEY + '=' + value;
-        }
+        },
+        injectedList:{},
+        getTargetObjectFromString:function(targetObjectName){
+          try{
+                 return eval(targetObjectName);
+            }
+          catch(error){
+            return null;
+          }
+        },
+        injectLog:function(request){
+                if(!request.enable){
+                    return;
+                }
+                if(request.enable<(Math.random()*100)){
+                    return;
+                }
+                if(!request.target){
+                    return;
+                }
+
+                if(!request.name){
+                  return;
+                }
+                if(this.injectedList[request.target]){
+                     return;
+                }
+                var targetparts=request.target.split(".");
+                if(targetparts.length<=1){
+                  return;
+                }
+                var targetObject=this.getTargetObjectFromString(targetparts[0]);
+                for(var i=1;(i+1)<targetparts.length;i++){
+                    if(!targetObject){
+                        return null;
+                    }
+                    targetObject=targetObject[targetparts[i]];
+                }
+                if(!targetObject){
+                    return;
+                }
+                var methodName=targetparts[targetparts.length-1];
+                var targetFunction=targetObject[methodName];
+                if(!targetFunction){
+                    return;
+                }
+                this.injectedList[request.target]=targetFunction;
+
+                var that=this;
+                targetObject[methodName]=function(){
+                    var ret=targetFunction.apply(targetObject, arguments);
+                    var data={};
+                    if((!arguments) || arguments.length==0){
+                        if(ret){
+                            data[request.name]=ret;
+                        }
+                        else{
+                            data[request.name]="empty";
+                        }
+                    }
+                    else if(arguments.length==1){
+                        if(!ret){
+                            data[request.name]=arguments[0];
+                        }
+                        else{
+                            data[request.name]={input:arguments[0],
+                                           output:ret};
+                        }
+                    }
+                    else {
+                        if(!ret){
+                            data[request.name]={};
+                            for(var i=0;i<arguments.length;i++){
+                                data[request.name]['param'+(i+1)]=arguments[i];
+                            }
+                        }
+                        else{
+                            data[request.name]={
+                                    input:{},
+                                    output:ret
+                            };
+                            for(var i=0;i<arguments.length;i++){
+                                data[request.name].input['param'+(i+1)]=arguments[i];
+                            }
+                        }
+
+                    }
+                    that.track(data);
+                    return ret;
+                };
+            },
+
     };
 
     var existing = window._LTracker;

From e1acf44dc255f102d99eedcb0c1426dad69ae6bd Mon Sep 17 00:00:00 2001
From: Dilshat Hewzulla <hewzulla@gmail.com>
Date: Wed, 8 Nov 2017 10:50:40 +0000
Subject: [PATCH 2/9] modified readme to include the code injection

---
 README.md | 85 +++++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 82 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 8e5ce01..0c70327 100644
--- a/README.md
+++ b/README.md
@@ -1,14 +1,15 @@
 loggly-jslogger
 ===============
 
-Client-side (browser) logger to use with Loggly gen2. Check out Loggly's [Javascript logging documentation](https://www.loggly.com/docs/javascript/) to learn more. 
+Client-side (browser) logger to use with Loggly gen2. Check out Loggly's [Javascript logging documentation](https://www.loggly.com/docs/javascript/) to learn more.
 
 Installation
 ------------
 
+
 Place the following on your page, and replace the logglyKey value with the key provided by the website:
 ```html
-<script type="text/javascript" src="//cloudfront.loggly.com/js/loggly.tracker-latest.min.js" async></script>
+<script type="text/javascript" src="https://rawgit.com/aws-logger/loggly-jslogger/master/src/loggly.tracker.js" async></script>
 <script>
   var _LTracker = _LTracker || [];
   _LTracker.push({
@@ -48,7 +49,7 @@ myBetterLogger.push({'logglyKey': 'your-customer-token' });  // push a loggly ke
 
 Send Console Errors to Loggly
 ----
-Keeping <strong>sendConsoleErrors</strong> value to <i>true</i> will send all the unhandled errors to the Loggly with the detailed information like error message, URL, line number and column number. This script also take cares of all the previously defined window.onerror functions. 
+Keeping <strong>sendConsoleErrors</strong> value to <i>true</i> will send all the unhandled errors to the Loggly with the detailed information like error message, URL, line number and column number. This script also take cares of all the previously defined window.onerror functions.
 
 Send Tags to Loggly
 ----
@@ -98,3 +99,81 @@ You can build min and map file by using the command below:
 npm install
 grunt
 ```
+
+Intercept and log any JavaScript function calls
+----------
+
+You may not like the mixing the Loggly logging codes everywhere inside your application codes. This creates undesirable dependencies on the Loggly  and makes your codes ugly.
+
+Instead you may rather prefer transparently send messages passed into the console.log, console.warn, console.info and console.error to the Loggly. Or you may even not like the console.log() functions as well. You prefer to decide which part of the code you would like to log when some issues happens on live instead of making decisition at development time. So you would like to use the configuration to control the logging behaviour transparently from the applications.
+
+Also you may like to enable this automatic logging for only some percentage of user sessions, instead of all users.
+
+
+For example if you would to log the console.error() function, you just need to put the code below as soon as you have initialised the Loggly:
+```Javascript
+    _LTracker.injectLog({
+        enable:100
+        target:"console.error",
+        name:"error"
+    });
+```
+The value of ```enable``` attribute is set 100. This means thar the Loggly will log the console.error() function for 100% percent of the users, which means all user sessions.
+
+The value of the ```target``` attribute specifies which javascript function it needs to monitor. It has to have atleast one "." to specify the target object and target method the Loggly needs to monitor.
+
+The functions that the Loggly intercept will not be affected. For example, console.error() will still continually print messages to the console as usual. The injected codes will simply send the messages to loggly after executing the original console function. For example, if the application executes the following code:
+```Javascript   
+      console.error("Something wrong");
+```   
+Then the injected code will transparently executes the following code:
+
+```Javascript
+_LTracker.push({
+   error:"Something wrong"
+});
+```
+
+The name of the variable ```error``` is coming from the ```name``` attribute passed into the ```_LTracker.injectLog```  in the previous example.
+
+The input parameter is an object, for example:
+```Javascript
+console.error({errorcode:"Error01", description:"Something goes wrong"});
+```
+The injected code will execute:
+
+```Javascript
+_LTracker.push({
+error:{errorcode:"Error01", description:"Something goes wrong"}
+})
+```
+If multiple parameters are passed in:
+```Javascript
+console.error("Something wrong", {errorCode:"001", errorCotent:"wierd error"});
+```
+The injected code will execute:
+```Javascript
+_LTracker.push({
+error:{param1:"Something wrong", param2:{errorCode:"001", errorCotent:"wierd error"}}
+})
+```
+
+On other hand if the injected function has the return value, for example if we have the following:
+
+LTracker.injectLog({
+name:"LocalStorageLog"
+target:"localStorage.getItem",
+enable:100
+});
+
+if the application executes:
+
+var username=localStorage.getItem("username");
+
+and if the returned value from the localStorage is "dilshat"
+
+then injected code executes the following:
+
+_LTracker.push({
+LocalStorageLog:{input:"username", output:"dilshat}
+})

From 32c09786df2b757e10d7071e3913d71e95fcd11d Mon Sep 17 00:00:00 2001
From: Dilshat Hewzulla <hewzulla@gmail.com>
Date: Wed, 8 Nov 2017 11:00:15 +0000
Subject: [PATCH 3/9] ReadMe to explain how to use the log injection

---
 README.md | 22 +++++++++++++++-------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index 0c70327..35b7eb0 100644
--- a/README.md
+++ b/README.md
@@ -136,21 +136,24 @@ _LTracker.push({
 
 The name of the variable ```error``` is coming from the ```name``` attribute passed into the ```_LTracker.injectLog```  in the previous example.
 
-The input parameter is an object, for example:
+If the input parameter is an object, for example:
+
 ```Javascript
 console.error({errorcode:"Error01", description:"Something goes wrong"});
 ```
-The injected code will execute:
+the injected code will execute:
 
 ```Javascript
 _LTracker.push({
 error:{errorcode:"Error01", description:"Something goes wrong"}
 })
 ```
-If multiple parameters are passed in:
+If multiple parameters are passed in to the function:
+
 ```Javascript
 console.error("Something wrong", {errorCode:"001", errorCotent:"wierd error"});
 ```
+
 The injected code will execute:
 ```Javascript
 _LTracker.push({
@@ -158,22 +161,27 @@ error:{param1:"Something wrong", param2:{errorCode:"001", errorCotent:"wierd err
 })
 ```
 
-On other hand if the injected function has the return value, for example if we have the following:
+On other hand if the injected function has the return value, for example if the following is executed as soon as the Loggly is initializez:
 
+```Javascript
 LTracker.injectLog({
 name:"LocalStorageLog"
 target:"localStorage.getItem",
 enable:100
 });
+```
+The Loggly will monitor ```localStorage.getUten``` function.
 
-if the application executes:
-
+So if the application executes:
+```Javascript
 var username=localStorage.getItem("username");
+```
 
 and if the returned value from the localStorage is "dilshat"
 
 then injected code executes the following:
-
+```Javascript
 _LTracker.push({
 LocalStorageLog:{input:"username", output:"dilshat}
 })
+```

From 7bcf0f50b7d36927a631e16ea78040913b266d27 Mon Sep 17 00:00:00 2001
From: Dilshat Hewzulla <hewzulla@gmail.com>
Date: Wed, 8 Nov 2017 11:00:54 +0000
Subject: [PATCH 4/9] ReadMe to explain how to use the log injection

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 35b7eb0..9434dfa 100644
--- a/README.md
+++ b/README.md
@@ -182,6 +182,6 @@ and if the returned value from the localStorage is "dilshat"
 then injected code executes the following:
 ```Javascript
 _LTracker.push({
-LocalStorageLog:{input:"username", output:"dilshat}
+LocalStorageLog:{input:"username", output:"dilshat"}
 })
 ```

From 6dd1a84dcffddaae1abe19a818bbc8d4137c58cf Mon Sep 17 00:00:00 2001
From: Dilshat Hewzulla <hewzulla@gmail.com>
Date: Wed, 8 Nov 2017 13:04:41 +0000
Subject: [PATCH 5/9] refactored

---
 src/loggly.tracker.js | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/src/loggly.tracker.js b/src/loggly.tracker.js
index 8273001..593abaf 100644
--- a/src/loggly.tracker.js
+++ b/src/loggly.tracker.js
@@ -183,14 +183,6 @@
             document.cookie = LOGGLY_SESSION_KEY + '=' + value;
         },
         injectedList:{},
-        getTargetObjectFromString:function(targetObjectName){
-          try{
-                 return eval(targetObjectName);
-            }
-          catch(error){
-            return null;
-          }
-        },
         injectLog:function(request){
                 if(!request.enable){
                     return;
@@ -212,7 +204,14 @@
                 if(targetparts.length<=1){
                   return;
                 }
-                var targetObject=this.getTargetObjectFromString(targetparts[0]);
+                var targetObject=null;
+                if(request.targetBase && typeof request.targetBase === 'object'){
+                  targetObject=request.targetBase;
+                }
+                else{
+                         targetObject=this.getTargetObjectFromString(targetparts[0]);
+                }
+
                 for(var i=1;(i+1)<targetparts.length;i++){
                     if(!targetObject){
                         return null;
@@ -272,6 +271,14 @@
                     return ret;
                 };
             },
+            getTargetObjectFromString:function(targetObjectName){
+              try{
+                     return eval(targetObjectName);
+                }
+              catch(error){
+                    this.track({logglyconfigerror: "loggly config eval error:"+error+" the device may not support evail, consider use targetBase"});
+              }
+            }
 
     };
 

From 47ac7920878c1a1bea25f4edec123dc20d8f040b Mon Sep 17 00:00:00 2001
From: Dilshat Hewzulla <hewzulla@gmail.com>
Date: Wed, 8 Nov 2017 13:09:13 +0000
Subject: [PATCH 6/9] Readme to describe how to use log injection

---
 README.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 9434dfa..1b82fa2 100644
--- a/README.md
+++ b/README.md
@@ -165,12 +165,12 @@ On other hand if the injected function has the return value, for example if the
 
 ```Javascript
 LTracker.injectLog({
-name:"LocalStorageLog"
-target:"localStorage.getItem",
-enable:100
+"name":"localStorageGetItem",
+"target":"localStorage.getItem",
+"enable":100
 });
 ```
-The Loggly will monitor ```localStorage.getUten``` function.
+The Loggly will monitor ```localStorage.getItem``` function.
 
 So if the application executes:
 ```Javascript
@@ -182,6 +182,6 @@ and if the returned value from the localStorage is "dilshat"
 then injected code executes the following:
 ```Javascript
 _LTracker.push({
-LocalStorageLog:{input:"username", output:"dilshat"}
+localStorageGetItem:{input:"username", output:"dilshat"}
 })
 ```

From c0d316fb918ed6344cd746cb29a41cbe8c43d23c Mon Sep 17 00:00:00 2001
From: Dilshat Hewzulla <hewzulla@gmail.com>
Date: Wed, 8 Nov 2017 16:09:16 +0000
Subject: [PATCH 7/9] Readme to describe how to use log injection

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 1b82fa2..acab3a0 100644
--- a/README.md
+++ b/README.md
@@ -185,3 +185,4 @@ _LTracker.push({
 localStorageGetItem:{input:"username", output:"dilshat"}
 })
 ```
+You can test it here https://jsfiddle.net/dilshat/1t0y6dp1/

From d656fe0deb7339d0787ab180ae1b304cba499274 Mon Sep 17 00:00:00 2001
From: Dilshat Hewzulla <hewzulla@gmail.com>
Date: Wed, 8 Nov 2017 16:11:32 +0000
Subject: [PATCH 8/9] Readme to describe how to use log injection

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index acab3a0..a77b8ba 100644
--- a/README.md
+++ b/README.md
@@ -113,7 +113,7 @@ Also you may like to enable this automatic logging for only some percentage of u
 For example if you would to log the console.error() function, you just need to put the code below as soon as you have initialised the Loggly:
 ```Javascript
     _LTracker.injectLog({
-        enable:100
+        enable:100,
         target:"console.error",
         name:"error"
     });

From 72a141453bbdae22cd150d268707b66858cd4457 Mon Sep 17 00:00:00 2001
From: Dilshat Hewzulla <hewzulla@gmail.com>
Date: Fri, 1 Dec 2017 11:19:04 +0000
Subject: [PATCH 9/9] fixed the infinite loop in JSON.stringify in Samsung TV
 Orsay when circular reference

---
 src/loggly.tracker.js | 120 ++++++++++++++++++++++++++++--------------
 1 file changed, 80 insertions(+), 40 deletions(-)

diff --git a/src/loggly.tracker.js b/src/loggly.tracker.js
index 593abaf..3e92a06 100644
--- a/src/loggly.tracker.js
+++ b/src/loggly.tracker.js
@@ -150,13 +150,36 @@
         track: function (data) {
             // inject session id
             data.sessionId = this.session_id;
+            var toStringValue=function(obj){
+                //In Samsung TV Orsay, JSON.stringify will be in infinite loop when in circular reference, and a difference reference passed in the second parameter. So we have to use counter to get out of the infinite loop.
+                var objectData=[];
+                var objectName=[];
+                var count=0;
+                return JSON.stringify(obj, function(key, val) {
+                    count++;
+                    if(count>10){
+                        return;
+                    }
+                if (typeof val === "object") {
+                      var ind=objectData.indexOf(val);
+                      if (ind >= 0) {
+                         return "$"+objectName[ind];
+                      }
+                      else{
+                          objectData.push(val);
+                          objectName.push(key);
+                      }
+                 }
+                 return val;
+               });
 
+            };
             try {
                 //creating an asynchronous XMLHttpRequest
                 var xmlHttp = new XMLHttpRequest();
                 xmlHttp.open('POST', this.inputUrl, true); //true for asynchronous request
                 xmlHttp.setRequestHeader('Content-Type', 'text/plain');
-                xmlHttp.send(JSON.stringify(data));
+                xmlHttp.send(toStringValue(data));
 
             } catch (ex) {
                 if (window && window.console && typeof window.console.log === 'function') {
@@ -183,6 +206,47 @@
             document.cookie = LOGGLY_SESSION_KEY + '=' + value;
         },
         injectedList:{},
+        buildInjectLog: function(inputParameters, outputParameters, errorObject){
+            if(errorObject){
+                if(!inputParameters){
+                    inputParameters="";
+                }
+                if(!outputParameters){
+                    outputParameters="";
+                }
+                return {
+                    error:errorObject,
+                    input:inputParameters,
+                    output:outputParameters
+                };
+            }
+            else if(outputParameters){
+                if(!inputParameters){
+                    inputParameters="";
+                }
+                return {
+                    input:inputParameters,
+                    output:outputParameters
+                };
+            }
+            else if((!inputParameters) || inputParameters.length==0){
+                return "";
+            }
+            else if(inputParameters.length==1){
+                if(inputParameters[0]){
+                    return inputParameters[0];
+                }
+                else{
+                    return "";
+                }
+
+            }
+            else {
+                return inputParameters;
+            }
+
+        },
+
         injectLog:function(request){
                 if(!request.enable){
                     return;
@@ -227,48 +291,24 @@
                     return;
                 }
                 this.injectedList[request.target]=targetFunction;
-
                 var that=this;
                 targetObject[methodName]=function(){
-                    var ret=targetFunction.apply(targetObject, arguments);
-                    var data={};
-                    if((!arguments) || arguments.length==0){
-                        if(ret){
-                            data[request.name]=ret;
-                        }
-                        else{
-                            data[request.name]="empty";
-                        }
-                    }
-                    else if(arguments.length==1){
-                        if(!ret){
-                            data[request.name]=arguments[0];
-                        }
-                        else{
-                            data[request.name]={input:arguments[0],
-                                           output:ret};
-                        }
-                    }
-                    else {
-                        if(!ret){
-                            data[request.name]={};
-                            for(var i=0;i<arguments.length;i++){
-                                data[request.name]['param'+(i+1)]=arguments[i];
-                            }
-                        }
-                        else{
-                            data[request.name]={
-                                    input:{},
-                                    output:ret
-                            };
-                            for(var i=0;i<arguments.length;i++){
-                                data[request.name].input['param'+(i+1)]=arguments[i];
-                            }
-                        }
 
-                    }
-                    that.track(data);
-                    return ret;
+                            var returnValue=null;
+                            var errorObject=null;
+                            try{
+                                     returnValue=targetFunction.apply(targetObject, arguments);
+                               }
+                             catch(error){
+                                     errorObject=error;
+                             }
+                              var data={};
+                              data[request.name]=that.buildInjectLog(arguments,returnValue,errorObject);
+                              that.track(data);
+                             if(errorObject){
+                                  throw errorObject;
+                              }
+                             return returnValue;
                 };
             },
             getTargetObjectFromString:function(targetObjectName){