mousereco 0.0.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YTI3YjRjZmNhZWMwN2M3NGUwYTcyMmFlOWI2ZDg0ZDlhNjg1ZjhkNw==
+  data.tar.gz: !binary |-
+    NDJjZjQ1NTJhMWI5ZGM1MGIxOWI2NWI1YzIzNDMzMGJjZWFjYWJlNg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NWY4YWJhYjIyNjFhYTM4ZjNmYzVkNzI0YThmYjI2ZjQzMmQ5ZDc4M2U3OGZl
+    OWM2NmRlN2E2YjkyYmQzNzVlZDAzNDRkZGY1ZGI3NjA0MWVmYjI3MzM5MDY1
+    ZjVjZTRjZTUzZDIzZjljN2NmNDY5MjBmYTNlYTlmYTFhZmMyMjA=
+  data.tar.gz: !binary |-
+    NTkzMWEzM2VlMTEyYTM1OWI0YmJlMmZlZTFkMDFhYjE4MmIzMTQ3ZGEwODU4
+    MWE0NmQyYjE3ZDI3N2VhNzc5YTAwOGZhZThkMjE1ODI5YzE1MTdiY2Y2YTNm
+    ZDY5YjQ1M2I1MDE3MTdjN2VmOTNmOTc0ODIzZDJlYmJkYTZkODQ=

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Paweł Nguyen
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,34 @@
+# Mousereco
+
+Mousereco is a mouse recording Rails engine with a web interface used to replay user visits
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'mousereco'
+
+Execute:
+
+    $ bundle
+
+And then run install generator:
+
+    $ rails generate mousereco:install
+
+It will:
+ - add a tracker js code to your application.js file
+ - mount Mousereco at ```/mousereco``` route
+ - install and run migrations needed for Mousereco
+
+## Usage
+
+By default Mousereco engine will be mounted at ```/mousereco``` path in your application. You can replay your recordings there
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Mousereco'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/javascripts/mousereco/mousereco.js

@@ -0,0 +1,15 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require jquery
+//= require jquery_ujs
+//= require mousereco/pageviews

data/app/assets/javascripts/mousereco/pageviews.js

@@ -0,0 +1,244 @@
+var mouseRecorder = mouseRecorder || {};
+mouseRecorder.modules = mouseRecorder.modules || {};
+mouseRecorder.views = mouseRecorder.views || {};
+
+
+
+(function(namespace) {
+
+    var EVENTS = {
+        MOVE: 'mousemove',
+        SCROLL: 'scroll'
+    },
+    playDelay = 500,
+    duartionInterval = 100,
+    Player = function(events, $iframe){
+        this.mouseEvents = [];
+        this.scrollEvents = [];
+        this.currentMouseEvent = 0;
+        this.currentScrollEvent = 0;
+
+        this.currentMouseEventTimestamp = events[0].timestamp - playDelay;
+        this.mouseRealTimestamp = 0;
+        this.mousePauseTimeout = 0;
+
+        this.currentScrollEventTimestamp = events[0].timestamp - playDelay;
+        this.scrollRealTimestamp = 0;
+        this.scrollPauseTimeout = 0;
+
+        this.currentPlayPosition = 0;
+
+        this.$iframe = $iframe;
+        this.$mouse = null;
+
+        this.getDuration(events);
+        this.groupEvents(events);
+        this.createMouse();
+    };
+    Player.prototype = {
+        getDuration: function(events) {
+            if(events === undefined) {
+                return this.duration;
+            }
+            else {
+                this.duration = playDelay + (events[events.length - 1].timestamp - events[0].timestamp);
+            }
+        },
+        getPlayPosition: function() {
+            return Math.min(this.currentPlayPosition, this.duration);
+        },
+        groupEvents: function(events) {
+            for(var i in events) {
+                events[i].type = events[i].type.toLowerCase();
+                if(events[i].type == EVENTS.SCROLL) {
+                    this.scrollEvents.push(events[i]);
+                }
+                else {
+                    this.mouseEvents.push(events[i]);
+                }
+            }
+        },
+        createMouse: function() {
+            if(!this.$mouse) {
+                this.$iframe.append('<div id="mouse" style="max-width:50px;min-width:10px;position:absolute;top:' + 0 + 'px;left:' + 0 + 'px;color:blue;font-size:10px;z-index:99999;background-color:black;">Mouse</div>');
+                this.$mouse = this.$iframe.find('#mouse');
+            }
+        },
+        play: function() {
+            this.paused = false;
+            this.playScroll();
+            this.playMouse();
+            this.playDuration();
+        },
+        pause: function() {
+            this.paused = true;
+            clearTimeout(this.scrollTimeout);
+            clearTimeout(this.mouseTimeout);
+            clearInterval(this.durationTicker);
+            this.$mouse.stop();
+            this.mousePauseTimeout += (new Date()).getTime() - this.mouseRealTimestamp;
+            this.scrollPauseTimeout += (new Date()).getTime() - this.scrollRealTimestamp;
+        },
+        playDuration: function() {
+            var self = this,
+                $self = $(this);
+            this.durationTicker = setInterval(function() {
+                self.currentPlayPosition += duartionInterval;
+                $self.trigger('duration.update');
+                self.end();
+            }, duartionInterval);
+        },
+        playMouse: function() {
+            if(!this.paused && this.mouseEvents[this.currentMouseEvent]) {
+                var self = this;
+                if(this.currentMouseEvent === 0) {
+                    var event = this.mouseEvents[this.currentMouseEvent],
+                        timeout = event.timestamp - this.currentMouseEventTimestamp;
+                    this.mouseRealTimestamp = (new Date()).getTime();
+                    this.mouseTimeout = setTimeout(function() {
+                        if(!self.paused) {
+                            self.currentMouseEvent++;
+                            self.currentMouseEventTimestamp = event.timestamp;
+                            self.showEvent(event);
+                            self.playMouse();
+                        }
+                    }, timeout);
+                }
+                else {
+                    var currentEvent = this.mouseEvents[this.currentMouseEvent],
+                        previousEvent = this.mouseEvents[this.currentMouseEvent - 1],
+                        tmpPauseTimestamp = this.mousePauseTimeout;
+                    this.mouseRealTimestamp = (new Date()).getTime();
+                    this.$mouse.animate({
+                        top: currentEvent.y,
+                        left: currentEvent.x
+                    }, currentEvent.timestamp - previousEvent.timestamp - tmpPauseTimestamp, function() {
+                        if(!self.paused) {
+                            self.mousePauseTimeout = 0;
+                            self.currentMouseEvent++;
+                            self.currentMouseEventTimestamp = currentEvent.timestamp;
+                            self.showEvent(currentEvent);
+                            self.playMouse();
+                        }
+                    });
+                }
+            }
+        },
+        playScroll: function() {
+            if(!this.paused && this.scrollEvents[this.currentScrollEvent]) {
+                var self = this,
+                    event = this.scrollEvents[this.currentScrollEvent],
+                    timeout = event.timestamp - this.currentScrollEventTimestamp - this.scrollPauseTimeout;
+                this.scrollRealTimestamp = (new Date()).getTime();
+                this.scrollTimeout = setTimeout(function() {
+                    if(!self.paused) {
+                        self.scrollPauseTimeout = 0;
+                        self.currentScrollEvent++;
+                        self.currentScrollEventTimestamp = event.timestamp;
+                        self.showEvent(event);
+                        self.playScroll();
+                    }
+                }, timeout);
+            }
+        },
+        end: function() {
+            if(this.currentPlayPosition >= this.duration) {
+                this.pause();
+//                @TODO emit finished event
+            }
+        },
+        showEvent: function(event) {
+            switch(event.type) {
+                case EVENTS.SCROLL:
+                    this.$iframe.scrollTop(event.y);
+                    this.$iframe.scrollLeft(event.x);
+                    break;
+                default:
+                    this.$iframe.append('<div style="position:absolute;top:' + event.y + 'px;left:' + event.x + 'px;color:red;z-index:99998;">' + this.currentMouseEvent + '-' + event.type + '</div>');
+                    break;
+            }
+        }
+    };
+
+    namespace.Player = Player;
+})(mouseRecorder.modules);
+
+
+(function(namespace) {
+
+    var EVENTS = 'data-events',
+        WIDTH = 'data-window-width',
+        HEIGHT = 'data-window-height',
+        URL = 'data-url',
+    Pageviews = function(events) {
+        this.$events = $(events);
+        this.$iframe = this.getIframe();
+        this.$progressbar = $('.progress-bar');
+        this.events = this.parseEvents();
+        this.init();
+
+    };
+    Pageviews.prototype = {
+        parseEvents: function() {
+            return $.parseJSON(this.$events.attr(EVENTS));
+        },
+        getIframe: function() {
+            var $iframe = $('#pageview_window');
+            $iframe.attr('src', this.$events.attr(URL));
+            $iframe.attr('width', this.$events.attr(WIDTH));
+            $iframe.attr('height', this.$events.attr(HEIGHT));
+            return $iframe;
+        },
+        formatTime: function(timeMs) {
+            var time = timeMs / 100,
+                h = Math.floor(time / (10 * 60 * 60)),
+                m = Math.floor(time / (10 * 60)) % 60,
+                s = Math.floor(time / 10) % 60,
+                ms = Math.floor(time % 10);
+
+            return this.padTime(m) + ':' + this.padTime(s) + ':' + ms;
+        },
+        padTime: function(time) {
+            return time < 10 ? '0' + time : time;
+        },
+        getTime: function(current, duration) {
+            return this.formatTime(current) + ' / ' + this.formatTime(duration);
+        },
+        init: function() {
+            var player,
+                self = this;
+            this.$iframe.on('load', $.proxy(function() {
+                this.player = player = new mouseRecorder.modules.Player(this.events, this.$iframe.contents().find('body'));
+                var duration = player.getDuration(),
+                    $label = self.$progressbar.next();
+                $label.text(self.getTime(0, duration));
+                $(this.player).on('duration.update', function() {
+                    self.$progressbar.width(Math.round((this.getPlayPosition() / this.getDuration() * 100 * 100))/100 + '%');
+                    $label.text(self.getTime(this.getPlayPosition(), duration));
+                });
+            }, this));
+            $('button.play').on('click', function() {
+                if(player) {
+                    var $el = $(this);
+                    if($el.hasClass('play')) {
+                        $el.toggleClass('play').text('pause');
+                        player.play()
+                    }
+                    else {
+                        $el.toggleClass('play').text('play');
+                        player.pause();
+                    }
+                }
+            });
+        }
+    };
+
+    namespace.Pageviews = Pageviews;
+})(mouseRecorder.views);
+
+
+$(document).on('ready', function() {
+    if($('body').hasClass('pageviews')) {
+        var pageviews = new mouseRecorder.views.Pageviews('#events');
+    }
+});

data/app/assets/javascripts/mousereco/tracker.js.erb

@@ -0,0 +1,312 @@
+(function(){
+    var MouseRecorder = {};
+
+
+    /**
+     * MouseRecorder.Events
+     */
+    MouseRecorder.Events = {
+        CLICK: 'click',
+        MOVE: 'mousemove',
+        SCROLL: 'scroll',
+        OVER: 'mouseover'
+    },
+
+
+    /**
+     * MouseRecorder.Tracker
+     */
+    (function(namespace){
+
+        var instance,
+            mousePositionTrackInterval = 100,
+            mouseScrollTrackInterval = 100,
+            mouseOverTrackInterval = 250,
+            body = document.getElementsByTagName('body')[0],
+        Tracker = function() {
+            this.pusher = new MouseRecorder.Pusher();
+            this.pusher.html();
+
+            this.coords = {};
+            this.initListeners();
+        };
+        Tracker.prototype = {
+            on: {},
+            initListeners: function() {
+                MouseRecorder.Util.addEventListener(window, MouseRecorder.Events.OVER, this.withInterval(MouseRecorder.Events.OVER, mouseOverTrackInterval, MouseRecorder.Events.MOVE), this)
+                MouseRecorder.Util.addEventListener(window, MouseRecorder.Events.SCROLL, this.withInterval(MouseRecorder.Events.SCROLL, mouseScrollTrackInterval), this);
+                MouseRecorder.Util.addEventListener(document, MouseRecorder.Events.MOVE, this.withInterval(MouseRecorder.Events.MOVE, mousePositionTrackInterval), this);
+                MouseRecorder.Util.addEventListener(document, MouseRecorder.Events.CLICK, this.pusher.receive, this.pusher);
+            },
+            withInterval: function(eventType, interval, asEvent) {
+                var self = this,
+                    sourceEvent = eventType,
+                    destEvent = (asEvent === undefined ? eventType : asEvent);
+                setInterval(function() {
+                    if(self.coords[sourceEvent] && self.coords[sourceEvent].update === true) {
+                        self.coords[sourceEvent].update = false;
+                        self.pusher.receive(self.coords[sourceEvent], destEvent);
+                    }
+                }, interval);
+                return function(event) {
+                    var data = self.on[sourceEvent](event);
+                    self.coords[sourceEvent] = self.coords[sourceEvent] || {};
+                    self.coords[sourceEvent].update = true;
+                    self.coords[sourceEvent].pageX = data[0];
+                    self.coords[sourceEvent].pageY = data[1];
+                };
+            }
+        };
+        Tracker.prototype.on[MouseRecorder.Events.SCROLL] = function(event) {
+            return [body.scrollLeft, body.scrollTop];
+        };
+        Tracker.prototype.on[MouseRecorder.Events.MOVE] = function(event) {
+            return [event.pageX, event.pageY];
+        };
+        Tracker.prototype.on[MouseRecorder.Events.OVER] = function(event) {
+            return [event.pageX, event.pageY];
+        }
+
+        namespace.Tracker = {
+            instance: function() {
+                if(!instance) {
+                    instance = new Tracker();
+                }
+                return instance;
+            }
+        };
+    })(MouseRecorder);
+
+
+    /**
+     * MouseRecorder.Pusher
+     */
+    (function(namespace) {
+
+        <% url_helpers = Mousereco::Engine.routes.url_helpers %>
+        var eventsPath = '<%= url_helpers.api_v1_events_path %>',
+            htmlPath = '<%= url_helpers.api_v1_pageviews_path %>',
+            cookie = 'MouseRecorder_visitorKey',
+            pushTimeout = 2500,
+        Pusher = function(){
+            this.url = MouseRecorder.Util.getUrl();
+            this.visitorKey = this.getVisitorKey();
+            this.pageviewKey = MouseRecorder.Util.getUID();
+            this.events = [];
+            this.pushTimer = undefined;
+        };
+        Pusher.prototype = {
+            preflight: function() {
+//                @TODO this.push(this.basicData(), preflightUrl);
+            },
+            html: function() {
+                var data = this.basicData();
+                var window_size = MouseRecorder.Util.getWindowSize();
+                data.window_height = window_size.height;
+                data.window_width = window_size.width;
+                data.page_html = MouseRecorder.Util.getHTML();
+                this.push(data, htmlPath);
+            },
+            receive: function(event, type) {
+                var type = type || MouseRecorder.Events.CLICK,
+                    push = (type == MouseRecorder.Events.CLICK);
+                this.events.push({
+                    x: event.pageX,
+                    y: event.pageY,
+                    timestamp: (new Date()).getTime(),
+                    type: type
+                });
+                if(push) {
+                    this.prePush();
+                }
+                else {
+                    var self = this;
+                    if(!this.pushTimer) {
+                        this.pushTimer = setTimeout(function() {
+                            clearTimeout(self.pushTimer);
+                            self.pushTimer = undefined;
+                            self.prePush();
+                        }, pushTimeout);
+                    }
+                }
+            },
+            prePush: function() {
+                var data = this.basicData();
+                data.events = this.events;
+                this.events = [];
+                this.push(data, eventsPath);
+            },
+            push: function(data, url, callback) {
+                var request = false,
+                    self = this;
+                if (window.ActiveXObject) {
+                    var types = ['MSXML2.XmlHttp.5.0', 'MSXML2.XmlHttp.4.0', 'MSXML2.XmlHttp.3.0', 'MSXML2.XmlHttp.2.0', 'Microsoft.XmlHttp'];
+                    for(var i in types) {
+                        try {
+                            request = new ActiveXObject(types[i]);
+                            break;
+                        } catch(e){}
+                    }
+                }
+                else if (window.XMLHttpRequest) {
+                    request = new XMLHttpRequest();
+                }
+
+                if(request) {
+                    request.open('POST', url, true);
+                    if(callback) {
+                        request.onreadystatechange = function() {
+                            if(this.status === 200 && this.readyState === 4) {
+                                callback.apply(self, JSON.parse(this.responseText));
+                            }
+                        };
+                    }
+                    request.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
+                    request.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');
+                    if(request.readyState != 4) {
+                        request.send(MouseRecorder.Util.toString(data));
+                    }
+                }
+            },
+            basicData: function() {
+                return {
+                    url: this.url,
+                    visitor_key: this.visitorKey,
+                    pageview_key: this.pageviewKey,
+                    timestamp: (new Date()).getTime()
+                };
+            },
+            getVisitorKey: function() {
+                var visitorKeyCookie = MouseRecorder.CookieMonster.get(cookie);
+                if(visitorKeyCookie === null || visitorKeyCookie === undefined || visitorKeyCookie.length === 0) {
+                    visitorKeyCookie = MouseRecorder.Util.getUID();
+                }
+                MouseRecorder.CookieMonster.set(cookie, visitorKeyCookie, 60 * 60, '/')
+                return visitorKeyCookie;
+            }
+        };
+
+        namespace.Pusher = Pusher;
+    })(MouseRecorder);
+
+
+    /**
+     * MouseRecorder.Util
+     */
+    (function(namespace) {
+        namespace.Util = {
+            addEventListener: function(el, event, callback, scope) {
+                var _callback = function() {
+                    callback.apply(scope, arguments);
+                };
+                if(el.addEventListener != undefined) {
+                    el.addEventListener(event, _callback, false);
+                }
+                else if(el.attachEvent != undefined) {
+                    el.attachEvent('on' + event, _callback);
+                }
+                else {
+                    el['on' + event] = _callback;
+                }
+            },
+            getUID: function() {
+                return ((((1+Math.random())*0x10000)|0).toString(16) + (new Date().getTime()).toString(16)).substring(1);
+            },
+            getUrl: function() {
+                return document.URL;
+            },
+            toString: function(obj, index) {
+                var params = [];
+                for(var i in obj) {
+                    var key = (index == undefined) ? i : index + '[' + i + ']';
+                    if(Array.isArray(obj[i])) {
+                        params.push(this.toString(obj[i], key));
+                    }
+                    else if(typeof obj[i] === 'object') {
+                        params.push(this.toString(obj[i], key));
+                    }
+                    else {
+                        params.push(key + '=' + obj[i]);
+                    }
+                }
+                return params.join('&');
+            },
+            getHTML: function() {
+                var html = document.documentElement.outerHTML.replace(/\s+/g, ' ').replace(/\r?\n|\r/g, ' ').replace(
+                    /<head>(.*)<\/head>/, '<base href="' + this.getUrlRoot() + '">' + document.getElementsByTagName('head')[0].innerHTML);
+                return encodeURIComponent(html.replace(/\s+/g, ' ').replace(/\r?\n|\r/g, ' '))
+            },
+            getUrlRoot: function() {
+              return this.getUrl().match(/(.*\/)/)[0];
+            },
+            getWindowSize: function() {
+                return {width: window.innerWidth, height: window.innerHeight};
+            }
+        };
+    })(MouseRecorder);
+
+
+    /**
+     * MouseRecorder.CookieMonster
+     */
+    (function(namespace){
+        /*!
+         * cookie-monster - a simple cookie library
+         * v0.2.0
+         * https://github.com/jgallen23/cookie-monster
+         * copyright Greg Allen 2013
+         * MIT License
+         */
+        var monster = {
+            set: function(name, value, seconds, path) {
+                var date = new Date(),
+                        expires = '',
+                        type = typeof(value),
+                        valueToUse = '';
+                path = path || "/";
+                if (seconds) {
+                    date.setTime(date.getTime() + seconds * 1000);
+                    expires = "; expires=" + date.toUTCString();
+                }
+                if (type === "object"  && type !== "undefined") {
+                    if(!("JSON" in window)) throw "Bummer, your browser doesn't support JSON parsing.";
+                    valueToUse = JSON.stringify({v:value});
+                } else {
+                    valueToUse = encodeURIComponent(value);
+                }
+
+                document.cookie = name + "=" + valueToUse + expires + "; path=" + path;
+            },
+            get: function(name) {
+                var nameEQ = name + "=",
+                        ca = document.cookie.split(';'),
+                        value = '',
+                        firstChar = '',
+                        parsed={};
+                for (var i = 0; i < ca.length; i++) {
+                    var c = ca[i];
+                    while (c.charAt(0) == ' ') c = c.substring(1, c.length);
+                    if (c.indexOf(nameEQ) === 0) {
+                        value = c.substring(nameEQ.length, c.length);
+                        firstChar = value.substring(0, 1);
+                        if(firstChar=="{"){
+                            parsed = JSON.parse(value);
+                            if("v" in parsed) return parsed.v;
+                        }
+                        if (value=="undefined") return undefined;
+                        return decodeURIComponent(value);
+                    }
+                }
+                return null;
+            },
+            remove: function(name) {
+                this.set(name, "", -1);
+            }
+        };
+
+        namespace.CookieMonster = monster;
+    })(MouseRecorder);
+
+
+    MouseRecorder.Tracker.instance();
+})();