{"version":3,"sources":["../splunk/tracekit.js","../splunk/hrbl-splunklogging.js","../splunk/logging.js"],"names":["TraceKit","getLocationHref","document","location","href","collectWindowErrors","debug","_window","window","global","self","_slice","slice","UNKNOWN_FUNCTION","ERROR_TYPES_RE","report","subscribe","handler","installGlobalHandler","handlers","push","unsubscribe","i","length","splice","unsubscribeAll","uninstallGlobalHandler","notifyHandlers","stack","isWindowError","exception","hasOwnProperty","apply","concat","call","arguments","inner","isError","value","toString","Error","traceKitWindowOnError","message","url","lineNo","colNo","ex","lastExceptionStack","computeStackTrace","augmentStackTraceWithInitialElement","processLastException","groups","line","column","name","undefined","msg","match","func","_oldOnerrorHandler","this","_onErrorHandlerInstalled","onerror","_lastExceptionStack","_lastArgs","lastArgs","lastException","rethrow","args","setTimeout","incomplete","uninstall","computeStackTraceFromStackProp","submatch","parts","element","chrome","gecko","winjs","geckoEval","chromeEval","lines","split","exec","j","isNative","indexOf","isEval","columnNumber","exstack","stackInfo","initial","unshift","partial","computeStackTraceByWalkingCallerChain","depth","item","functionName","funcs","recursion","curr","caller","input","substring","e","result","sourceURL","fileName","lineNumber","description","exports","_err","err","context","console","log","_defaultEventFormatter","severity","event","lengthInUtf8Bytes","str","m","encodeURIComponent","utils","formatTime","time","cleanTime","Date","valueOf","parseFloat","toFixed","toArray","iterable","Array","prototype","chain","tasks","callback","nextTask","task","remainingTasks","taskCallback","shift","whilst","condition","body","done","wrappedCallback","expBackoff","opts","min","max","rand","Math","random","timeout","round","pow","attempt","bind","fn","copyObject","obj","ret","key","copyArray","arr","orByProp","prop","orByFalseyProp","validateNonNegativeInt","label","parseInt","isNaN","SplunkLogger","config","_timerID","_timerDuration","_initializeConfig","requestOptions","_initializeRequestOptions","serializedContextQueue","eventsBatchSize","eventFormatter","error","_enableTimer","_disableTimer","_validateMessage","_initializeMetadata","_initializeContext","_makeBody","_post","_sendEvents","send","flush","levels","DEBUG","INFO","WARN","ERROR","defaultConfig","host","path","protocol","authorization","port","level","maxRetries","batchInterval","maxBatchSize","maxBatchCount","defaultRequestOptions","json","strictSSL","clearInterval","interval","that","setInterval","token","startTimer","changeTimer","options","headers","metadata","source","sourcetype","index","now","xhr","XMLHttpRequest","open","Object","keys","forEach","setRequestHeader","onload","status","statusCode","responseText","splunkError","requestError","_response","_body","numRetries","resp","JSON","parse","code","text","currentEvent","stringify","batchOverSize","batchOverCount","queue","data","join","wrapLog","appSource","payload","getSource","posibleLocale","splunkLogger","warn","info","wrapped","configHerbalifeHEC","splunk","userAgent","navigator","platform","language","SplunkConfig","application","SpluLogger"],"mappings":"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","file":"splunk-bundle.min.js","sourcesContent":["'use strict';\r\n\r\n// Converted from module\r\nvar TraceKit = (function () {\r\n\r\n\r\n    /*\r\n     TraceKit - Cross brower stack traces\r\n    \r\n     This was originally forked from github.com/occ/TraceKit, but has since been\r\n     largely re-written and is now maintained as part of raven-js.  Tests for\r\n     this are in test/vendor.\r\n    \r\n     MIT license\r\n    */\r\n\r\n    var TraceKit = {\r\n        collectWindowErrors: true,\r\n        debug: false\r\n    };\r\n\r\n    // This is to be defensive in environments where window does not exist (see https://github.com/getsentry/raven-js/pull/785)\r\n    var _window = typeof window !== 'undefined' ? window\r\n        : typeof global !== 'undefined' ? global\r\n            : typeof self !== 'undefined' ? self\r\n                : {};\r\n\r\n    // global reference to slice\r\n    var _slice = [].slice;\r\n    var UNKNOWN_FUNCTION = '?';\r\n\r\n    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types\r\n    var ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/;\r\n\r\n    function getLocationHref() {\r\n        if (typeof document === 'undefined' || typeof document.location === 'undefined')\r\n            return '';\r\n\r\n        return document.location.href;\r\n    }\r\n\r\n\r\n    /**\r\n     * TraceKit.report: cross-browser processing of unhandled exceptions\r\n     *\r\n     * Syntax:\r\n     *   TraceKit.report.subscribe(function(stackInfo) { ... })\r\n     *   TraceKit.report.unsubscribe(function(stackInfo) { ... })\r\n     *   TraceKit.report(exception)\r\n     *   try { ...code... } catch(ex) { TraceKit.report(ex); }\r\n     *\r\n     * Supports:\r\n     *   - Firefox: full stack trace with line numbers, plus column number\r\n     *              on top frame; column number is not guaranteed\r\n     *   - Opera:   full stack trace with line and column numbers\r\n     *   - Chrome:  full stack trace with line and column numbers\r\n     *   - Safari:  line and column number for the top frame only; some frames\r\n     *              may be missing, and column number is not guaranteed\r\n     *   - IE:      line and column number for the top frame only; some frames\r\n     *              may be missing, and column number is not guaranteed\r\n     *\r\n     * In theory, TraceKit should work on all of the following versions:\r\n     *   - IE5.5+ (only 8.0 tested)\r\n     *   - Firefox 0.9+ (only 3.5+ tested)\r\n     *   - Opera 7+ (only 10.50 tested; versions 9 and earlier may require\r\n     *     Exceptions Have Stacktrace to be enabled in opera:config)\r\n     *   - Safari 3+ (only 4+ tested)\r\n     *   - Chrome 1+ (only 5+ tested)\r\n     *   - Konqueror 3.5+ (untested)\r\n     *\r\n     * Requires TraceKit.computeStackTrace.\r\n     *\r\n     * Tries to catch all unhandled exceptions and report them to the\r\n     * subscribed handlers. Please note that TraceKit.report will rethrow the\r\n     * exception. This is REQUIRED in order to get a useful stack trace in IE.\r\n     * If the exception does not reach the top of the browser, you will only\r\n     * get a stack trace from the point where TraceKit.report was called.\r\n     *\r\n     * Handlers receive a stackInfo object as described in the\r\n     * TraceKit.computeStackTrace docs.\r\n     */\r\n    TraceKit.report = (function reportModuleWrapper() {\r\n        var handlers = [],\r\n            lastArgs = null,\r\n            lastException = null,\r\n            lastExceptionStack = null;\r\n\r\n        /**\r\n         * Add a crash handler.\r\n         * @param {Function} handler\r\n         */\r\n        function subscribe(handler) {\r\n            installGlobalHandler();\r\n            handlers.push(handler);\r\n        }\r\n\r\n        /**\r\n         * Remove a crash handler.\r\n         * @param {Function} handler\r\n         */\r\n        function unsubscribe(handler) {\r\n            for (var i = handlers.length - 1; i >= 0; --i) {\r\n                if (handlers[i] === handler) {\r\n                    handlers.splice(i, 1);\r\n                }\r\n            }\r\n        }\r\n\r\n        /**\r\n         * Remove all crash handlers.\r\n         */\r\n        function unsubscribeAll() {\r\n            uninstallGlobalHandler();\r\n            handlers = [];\r\n        }\r\n\r\n        /**\r\n         * Dispatch stack information to all handlers.\r\n         * @param {Object.<string, *>} stack\r\n         */\r\n        function notifyHandlers(stack, isWindowError) {\r\n            var exception = null;\r\n            if (isWindowError && !TraceKit.collectWindowErrors) {\r\n                return;\r\n            }\r\n            for (var i in handlers) {\r\n                if (handlers.hasOwnProperty(i)) {\r\n                    try {\r\n                        handlers[i].apply(null, [stack].concat(_slice.call(arguments, 2)));\r\n                    } catch (inner) {\r\n                        exception = inner;\r\n                    }\r\n                }\r\n            }\r\n\r\n            if (exception) {\r\n                throw exception;\r\n            }\r\n        }\r\n\r\n        var _oldOnerrorHandler, _onErrorHandlerInstalled;\r\n\r\n        // Yanked from https://git.io/vS8DV re-used under CC0\r\n        // with some tiny modifications\r\n        function isError(value) {\r\n            switch ({}.toString.call(value)) {\r\n                case '[object Error]': return true;\r\n                case '[object Exception]': return true;\r\n                case '[object DOMException]': return true;\r\n                default: return value instanceof Error;\r\n            }\r\n        }\r\n\r\n        /**\r\n         * Ensures all global unhandled exceptions are recorded.\r\n         * Supported by Gecko and IE.\r\n         * @param {string} message Error message.\r\n         * @param {string} url URL of script that generated the exception.\r\n         * @param {(number|string)} lineNo The line number at which the error\r\n         * occurred.\r\n         * @param {?(number|string)} colNo The column number at which the error\r\n         * occurred.\r\n         * @param {?Error} ex The actual Error object.\r\n         */\r\n        function traceKitWindowOnError(message, url, lineNo, colNo, ex) {\r\n            var stack = null;\r\n\r\n            if (lastExceptionStack) {\r\n                TraceKit.computeStackTrace.augmentStackTraceWithInitialElement(lastExceptionStack, url, lineNo, message);\r\n                processLastException();\r\n            } else if (ex && isError(ex)) {\r\n                // non-string `ex` arg; attempt to extract stack trace\r\n\r\n                // New chrome and blink send along a real error object\r\n                // Let's just report that like a normal error.\r\n                // See: https://mikewest.org/2013/08/debugging-runtime-errors-with-window-onerror\r\n                stack = TraceKit.computeStackTrace(ex);\r\n                notifyHandlers(stack, true);\r\n            } else {\r\n                var location = {\r\n                    'url': url,\r\n                    'line': lineNo,\r\n                    'column': colNo\r\n                };\r\n\r\n                var name = undefined;\r\n                var msg = message; // must be new var or will modify original `arguments`\r\n                var groups;\r\n                if ({}.toString.call(message) === '[object String]') {\r\n                    var groups = message.match(ERROR_TYPES_RE);\r\n                    if (groups) {\r\n                        name = groups[1];\r\n                        msg = groups[2];\r\n                    }\r\n                }\r\n\r\n                location.func = UNKNOWN_FUNCTION;\r\n\r\n                stack = {\r\n                    'name': name,\r\n                    'message': msg,\r\n                    'url': getLocationHref(),\r\n                    'stack': [location]\r\n                };\r\n                notifyHandlers(stack, true);\r\n            }\r\n\r\n            if (_oldOnerrorHandler) {\r\n                return _oldOnerrorHandler.apply(this, arguments);\r\n            }\r\n\r\n            return false;\r\n        }\r\n\r\n        function installGlobalHandler() {\r\n            if (_onErrorHandlerInstalled) {\r\n                return;\r\n            }\r\n            _oldOnerrorHandler = _window.onerror;\r\n            _window.onerror = traceKitWindowOnError;\r\n            _onErrorHandlerInstalled = true;\r\n        }\r\n\r\n        function uninstallGlobalHandler() {\r\n            if (!_onErrorHandlerInstalled) {\r\n                return;\r\n            }\r\n            _window.onerror = _oldOnerrorHandler;\r\n            _onErrorHandlerInstalled = false;\r\n            _oldOnerrorHandler = undefined;\r\n        }\r\n\r\n        function processLastException() {\r\n            var _lastExceptionStack = lastExceptionStack,\r\n                _lastArgs = lastArgs;\r\n            lastArgs = null;\r\n            lastExceptionStack = null;\r\n            lastException = null;\r\n            notifyHandlers.apply(null, [_lastExceptionStack, false].concat(_lastArgs));\r\n        }\r\n\r\n        /**\r\n         * Reports an unhandled Error to TraceKit.\r\n         * @param {Error} ex\r\n         * @param {?boolean} rethrow If false, do not re-throw the exception.\r\n         * Only used for window.onerror to not cause an infinite loop of\r\n         * rethrowing.\r\n         */\r\n        function report(ex, rethrow) {\r\n            var args = _slice.call(arguments, 1);\r\n            if (lastExceptionStack) {\r\n                if (lastException === ex) {\r\n                    return; // already caught by an inner catch block, ignore\r\n                } else {\r\n                    processLastException();\r\n                }\r\n            }\r\n\r\n            var stack = TraceKit.computeStackTrace(ex);\r\n            lastExceptionStack = stack;\r\n            lastException = ex;\r\n            lastArgs = args;\r\n\r\n            // If the stack trace is incomplete, wait for 2 seconds for\r\n            // slow slow IE to see if onerror occurs or not before reporting\r\n            // this exception; otherwise, we will end up with an incomplete\r\n            // stack trace\r\n            setTimeout(function () {\r\n                if (lastException === ex) {\r\n                    processLastException();\r\n                }\r\n            }, (stack.incomplete ? 2000 : 0));\r\n\r\n            if (rethrow !== false) {\r\n                throw ex; // re-throw to propagate to the top level (and cause window.onerror)\r\n            }\r\n        }\r\n\r\n        report.subscribe = subscribe;\r\n        report.unsubscribe = unsubscribe;\r\n        report.uninstall = unsubscribeAll;\r\n        return report;\r\n    }());\r\n\r\n    /**\r\n     * TraceKit.computeStackTrace: cross-browser stack traces in JavaScript\r\n     *\r\n     * Syntax:\r\n     *   s = TraceKit.computeStackTrace(exception) // consider using TraceKit.report instead (see below)\r\n     * Returns:\r\n     *   s.name              - exception name\r\n     *   s.message           - exception message\r\n     *   s.stack[i].url      - JavaScript or HTML file URL\r\n     *   s.stack[i].func     - function name, or empty for anonymous functions (if guessing did not work)\r\n     *   s.stack[i].args     - arguments passed to the function, if known\r\n     *   s.stack[i].line     - line number, if known\r\n     *   s.stack[i].column   - column number, if known\r\n     *\r\n     * Supports:\r\n     *   - Firefox:  full stack trace with line numbers and unreliable column\r\n     *               number on top frame\r\n     *   - Opera 10: full stack trace with line and column numbers\r\n     *   - Opera 9-: full stack trace with line numbers\r\n     *   - Chrome:   full stack trace with line and column numbers\r\n     *   - Safari:   line and column number for the topmost stacktrace element\r\n     *               only\r\n     *   - IE:       no line numbers whatsoever\r\n     *\r\n     * Tries to guess names of anonymous functions by looking for assignments\r\n     * in the source code. In IE and Safari, we have to guess source file names\r\n     * by searching for function bodies inside all page scripts. This will not\r\n     * work for scripts that are loaded cross-domain.\r\n     * Here be dragons: some function names may be guessed incorrectly, and\r\n     * duplicate functions may be mismatched.\r\n     *\r\n     * TraceKit.computeStackTrace should only be used for tracing purposes.\r\n     * Logging of unhandled exceptions should be done with TraceKit.report,\r\n     * which builds on top of TraceKit.computeStackTrace and provides better\r\n     * IE support by utilizing the window.onerror event to retrieve information\r\n     * about the top of the stack.\r\n     *\r\n     * Note: In IE and Safari, no stack trace is recorded on the Error object,\r\n     * so computeStackTrace instead walks its *own* chain of callers.\r\n     * This means that:\r\n     *  * in Safari, some methods may be missing from the stack trace;\r\n     *  * in IE, the topmost function in the stack trace will always be the\r\n     *    caller of computeStackTrace.\r\n     *\r\n     * This is okay for tracing (because you are likely to be calling\r\n     * computeStackTrace from the function you want to be the topmost element\r\n     * of the stack trace anyway), but not okay for logging unhandled\r\n     * exceptions (because your catch block will likely be far away from the\r\n     * inner function that actually caused the exception).\r\n     *\r\n     */\r\n    TraceKit.computeStackTrace = (function computeStackTraceWrapper() {\r\n        // Contents of Exception in various browsers.\r\n        //\r\n        // SAFARI:\r\n        // ex.message = Can't find variable: qq\r\n        // ex.line = 59\r\n        // ex.sourceId = 580238192\r\n        // ex.sourceURL = http://...\r\n        // ex.expressionBeginOffset = 96\r\n        // ex.expressionCaretOffset = 98\r\n        // ex.expressionEndOffset = 98\r\n        // ex.name = ReferenceError\r\n        //\r\n        // FIREFOX:\r\n        // ex.message = qq is not defined\r\n        // ex.fileName = http://...\r\n        // ex.lineNumber = 59\r\n        // ex.columnNumber = 69\r\n        // ex.stack = ...stack trace... (see the example below)\r\n        // ex.name = ReferenceError\r\n        //\r\n        // CHROME:\r\n        // ex.message = qq is not defined\r\n        // ex.name = ReferenceError\r\n        // ex.type = not_defined\r\n        // ex.arguments = ['aa']\r\n        // ex.stack = ...stack trace...\r\n        //\r\n        // INTERNET EXPLORER:\r\n        // ex.message = ...\r\n        // ex.name = ReferenceError\r\n        //\r\n        // OPERA:\r\n        // ex.message = ...message... (see the example below)\r\n        // ex.name = ReferenceError\r\n        // ex.opera#sourceloc = 11  (pretty much useless, duplicates the info in ex.message)\r\n        // ex.stacktrace = n/a; see 'opera:config#UserPrefs|Exceptions Have Stacktrace'\r\n\r\n        /**\r\n         * Computes stack trace information from the stack property.\r\n         * Chrome and Gecko use this property.\r\n         * @param {Error} ex\r\n         * @return {?Object.<string, *>} Stack trace information.\r\n         */\r\n        function computeStackTraceFromStackProp(ex) {\r\n            if (typeof ex.stack === 'undefined' || !ex.stack) return;\r\n\r\n            var chrome = /^\\s*at (.*?) ?\\(((?:file|https?|blob|chrome-extension|native|eval|webpack|<anonymous>|\\/).*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i,\r\n                gecko = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|\\[native).*?)(?::(\\d+))?(?::(\\d+))?\\s*$/i,\r\n                winjs = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i,\r\n\r\n                // Used to additionally parse URL/line/column from eval frames\r\n                geckoEval = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i,\r\n                chromeEval = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/,\r\n\r\n                lines = ex.stack.split('\\n'),\r\n                stack = [],\r\n                submatch,\r\n                parts,\r\n                element,\r\n                reference = /^(.*) is undefined$/.exec(ex.message);\r\n\r\n            for (var i = 0, j = lines.length; i < j; ++i) {\r\n                if ((parts = chrome.exec(lines[i]))) {\r\n                    var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\r\n                    var isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\r\n                    if (isEval && (submatch = chromeEval.exec(parts[2]))) {\r\n                        // throw out eval line/column and use top-most line/column number\r\n                        parts[2] = submatch[1]; // url\r\n                        parts[3] = submatch[2]; // line\r\n                        parts[4] = submatch[3]; // column\r\n                    }\r\n                    element = {\r\n                        'url': !isNative ? parts[2] : null,\r\n                        'func': parts[1] || UNKNOWN_FUNCTION,\r\n                        'args': isNative ? [parts[2]] : [],\r\n                        'line': parts[3] ? +parts[3] : null,\r\n                        'column': parts[4] ? +parts[4] : null\r\n                    };\r\n                } else if (parts = winjs.exec(lines[i])) {\r\n                    element = {\r\n                        'url': parts[2],\r\n                        'func': parts[1] || UNKNOWN_FUNCTION,\r\n                        'args': [],\r\n                        'line': +parts[3],\r\n                        'column': parts[4] ? +parts[4] : null\r\n                    };\r\n                } else if ((parts = gecko.exec(lines[i]))) {\r\n                    var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\r\n                    if (isEval && (submatch = geckoEval.exec(parts[3]))) {\r\n                        // throw out eval line/column and use top-most line number\r\n                        parts[3] = submatch[1];\r\n                        parts[4] = submatch[2];\r\n                        parts[5] = null; // no column when eval\r\n                    } else if (i === 0 && !parts[5] && typeof ex.columnNumber !== 'undefined') {\r\n                        // FireFox uses this awesome columnNumber property for its top frame\r\n                        // Also note, Firefox's column number is 0-based and everything else expects 1-based,\r\n                        // so adding 1\r\n                        // NOTE: this hack doesn't work if top-most frame is eval\r\n                        stack[0].column = ex.columnNumber + 1;\r\n                    }\r\n                    element = {\r\n                        'url': parts[3],\r\n                        'func': parts[1] || UNKNOWN_FUNCTION,\r\n                        'args': parts[2] ? parts[2].split(',') : [],\r\n                        'line': parts[4] ? +parts[4] : null,\r\n                        'column': parts[5] ? +parts[5] : null\r\n                    };\r\n                } else {\r\n                    continue;\r\n                }\r\n\r\n                if (!element.func && element.line) {\r\n                    element.func = UNKNOWN_FUNCTION;\r\n                }\r\n\r\n                stack.push(element);\r\n            }\r\n\r\n            if (!stack.length) {\r\n                return null;\r\n            }\r\n\r\n            return {\r\n                'name': ex.name,\r\n                'message': ex.message,\r\n                'url': getLocationHref(),\r\n                'stack': stack,\r\n                'exstack': ex.stack\r\n            };\r\n        }\r\n\r\n        /**\r\n         * Adds information about the first frame to incomplete stack traces.\r\n         * Safari and IE require this to get complete data on the first frame.\r\n         * @param {Object.<string, *>} stackInfo Stack trace information from\r\n         * one of the compute* methods.\r\n         * @param {string} url The URL of the script that caused an error.\r\n         * @param {(number|string)} lineNo The line number of the script that\r\n         * caused an error.\r\n         * @param {string=} message The error generated by the browser, which\r\n         * hopefully contains the name of the object that caused the error.\r\n         * @return {boolean} Whether or not the stack information was\r\n         * augmented.\r\n         */\r\n        function augmentStackTraceWithInitialElement(stackInfo, url, lineNo, message) {\r\n            var initial = {\r\n                'url': url,\r\n                'line': lineNo\r\n            };\r\n\r\n            if (initial.url && initial.line) {\r\n                stackInfo.incomplete = false;\r\n\r\n                if (!initial.func) {\r\n                    initial.func = UNKNOWN_FUNCTION;\r\n                }\r\n\r\n                if (stackInfo.stack.length > 0) {\r\n                    if (stackInfo.stack[0].url === initial.url) {\r\n                        if (stackInfo.stack[0].line === initial.line) {\r\n                            return false; // already in stack trace\r\n                        } else if (!stackInfo.stack[0].line && stackInfo.stack[0].func === initial.func) {\r\n                            stackInfo.stack[0].line = initial.line;\r\n                            return false;\r\n                        }\r\n                    }\r\n                }\r\n\r\n                stackInfo.stack.unshift(initial);\r\n                stackInfo.partial = true;\r\n                return true;\r\n            } else {\r\n                stackInfo.incomplete = true;\r\n            }\r\n\r\n            return false;\r\n        }\r\n\r\n        /**\r\n         * Computes stack trace information by walking the arguments.caller\r\n         * chain at the time the exception occurred. This will cause earlier\r\n         * frames to be missed but is the only way to get any stack trace in\r\n         * Safari and IE. The top frame is restored by\r\n         * {@link augmentStackTraceWithInitialElement}.\r\n         * @param {Error} ex\r\n         * @return {?Object.<string, *>} Stack trace information.\r\n         */\r\n        function computeStackTraceByWalkingCallerChain(ex, depth) {\r\n            var functionName = /function\\s+([_$a-zA-Z\\xA0-\\uFFFF][_$a-zA-Z0-9\\xA0-\\uFFFF]*)?\\s*\\(/i,\r\n                stack = [],\r\n                funcs = {},\r\n                recursion = false,\r\n                parts,\r\n                item,\r\n                source;\r\n\r\n            for (var curr = computeStackTraceByWalkingCallerChain.caller; curr && !recursion; curr = curr.caller) {\r\n                if (curr === computeStackTrace || curr === TraceKit.report) {\r\n                    // console.log('skipping internal function');\r\n                    continue;\r\n                }\r\n\r\n                item = {\r\n                    'url': null,\r\n                    'func': UNKNOWN_FUNCTION,\r\n                    'line': null,\r\n                    'column': null\r\n                };\r\n\r\n                if (curr.name) {\r\n                    item.func = curr.name;\r\n                } else if ((parts = functionName.exec(curr.toString()))) {\r\n                    item.func = parts[1];\r\n                }\r\n\r\n                if (typeof item.func === 'undefined') {\r\n                    try {\r\n                        item.func = parts.input.substring(0, parts.input.indexOf('{'));\r\n                    } catch (e) { }\r\n                }\r\n\r\n                if (funcs['' + curr]) {\r\n                    recursion = true;\r\n                } else {\r\n                    funcs['' + curr] = true;\r\n                }\r\n\r\n                stack.push(item);\r\n            }\r\n\r\n            if (depth) {\r\n                // console.log('depth is ' + depth);\r\n                // console.log('stack is ' + stack.length);\r\n                stack.splice(0, depth);\r\n            }\r\n\r\n            var result = {\r\n                'name': ex.name,\r\n                'message': ex.message,\r\n                'url': getLocationHref(),\r\n                'stack': stack\r\n            };\r\n            augmentStackTraceWithInitialElement(result, ex.sourceURL || ex.fileName, ex.line || ex.lineNumber, ex.message || ex.description);\r\n            return result;\r\n        }\r\n\r\n        /**\r\n         * Computes a stack trace for an exception.\r\n         * @param {Error} ex\r\n         * @param {(string|number)=} depth\r\n         */\r\n        function computeStackTrace(ex, depth) {\r\n            var stack = null;\r\n            depth = (depth == null ? 0 : +depth);\r\n\r\n            try {\r\n                stack = computeStackTraceFromStackProp(ex);\r\n                if (stack) {\r\n                    return stack;\r\n                }\r\n            } catch (e) {\r\n                if (TraceKit.debug) {\r\n                    throw e;\r\n                }\r\n            }\r\n\r\n            try {\r\n                stack = computeStackTraceByWalkingCallerChain(ex, depth + 1);\r\n                if (stack) {\r\n                    return stack;\r\n                }\r\n            } catch (e) {\r\n                if (TraceKit.debug) {\r\n                    throw e;\r\n                }\r\n            }\r\n            return {\r\n                'name': ex.name,\r\n                'message': ex.message,\r\n                'url': getLocationHref()\r\n            };\r\n        }\r\n\r\n        computeStackTrace.augmentStackTraceWithInitialElement = augmentStackTraceWithInitialElement;\r\n        computeStackTrace.computeStackTraceFromStackProp = computeStackTraceFromStackProp;\r\n\r\n        return computeStackTrace;\r\n    }());\r\n\r\n    return TraceKit;\r\n\r\n}());","/*\r\n * Copyright 2015 Splunk, Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\"): you may\r\n * not use this file except in compliance with the License. You may obtain\r\n * a copy of the License at\r\n *\r\n *     http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\r\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\r\n * License for the specific language governing permissions and limitations\r\n * under the License.\r\n */\r\n\r\n(function (exports) {\r\n\r\n    /**\r\n     * Utility functions.\r\n     * @exports utils\r\n     */\r\n    var utils = {};\r\n    /*\r\n     * Copyright 2015 Splunk, Inc.\r\n     *\r\n     * Licensed under the Apache License, Version 2.0 (the \"License\"): you may\r\n     * not use this file except in compliance with the License. You may obtain\r\n     * a copy of the License at\r\n     *\r\n     *     http://www.apache.org/licenses/LICENSE-2.0\r\n     *\r\n     * Unless required by applicable law or agreed to in writing, software\r\n     * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\r\n     * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\r\n     * License for the specific language governing permissions and limitations\r\n     * under the License.\r\n     */\r\n\r\n\r\n    /* Utility Functions */\r\n\r\n    /**\r\n     * Formats the time for Splunk Enterprise or Splunk Cloud as a the epoch time in seconds.\r\n     *\r\n     * @param {(string|number|date)} time - A date string, timestamp, or <code>Date</code> object.\r\n     * @returns {number|null} Epoch time in seconds, or <code>null</code> if <code>time</code> is malformed.\r\n     * @static\r\n     */\r\n    utils.formatTime = function (time) {\r\n        var cleanTime;\r\n\r\n        // If time is a Date object, return its value.\r\n        if (time instanceof Date) {\r\n            time = time.valueOf();\r\n        }\r\n\r\n        if (!time || time === null) {\r\n            return null;\r\n        }\r\n\r\n        // Values with decimals\r\n        if (time.toString().indexOf(\".\") !== -1) {\r\n            cleanTime = parseFloat(time).toFixed(3); // Clean up the extra decimals right away.\r\n\r\n            // A perfect time in milliseconds, with the decimal in the right spot.\r\n            if (cleanTime.toString().indexOf(\".\") >= 10) {\r\n                cleanTime = parseFloat(cleanTime.toString().substring(0, 14)).toFixed(3);\r\n            }\r\n        }\r\n        // Values without decimals\r\n        else {\r\n            // A time in milliseconds, no decimal (ex: Date.now()).\r\n            if (time.toString().length === 13) {\r\n                cleanTime = (parseFloat(time) / 1000).toFixed(3);\r\n            }\r\n            // A time with fewer than expected digits.\r\n            else if (time.toString().length <= 12) {\r\n                cleanTime = parseFloat(time).toFixed(3);\r\n            }\r\n            // Any other value has more digits than the expected time format, get the first 14.\r\n            else {\r\n                cleanTime = parseFloat(time.toString().substring(0, 13) / 1000).toFixed(3);\r\n            }\r\n        }\r\n        return cleanTime;\r\n    };\r\n\r\n    /**\r\n     * Converts an iterable into to an array.\r\n     *\r\n     * @param {(Array|Object)} iterable - Thing to convert to an <code>Array</code>.\r\n     * @returns {Array}\r\n     * @static\r\n     */\r\n    utils.toArray = function (iterable) {\r\n        return Array.prototype.slice.call(iterable);\r\n    };\r\n\r\n    // TODO: this isn't used anymore, remove it\r\n    /**\r\n     * Run async function in a chain, like {@link https://github.com/caolan/async#waterfall|Async.waterfall}.\r\n     *\r\n     * @param {(function[]|function)} tasks - <code>Array</code> of callback functions.\r\n     * @param {function} [callback] - Final callback.\r\n     * @static\r\n     */\r\n    utils.chain = function (tasks, callback) {\r\n        // Allow for just a list of functions\r\n        if (arguments.length > 1 && typeof arguments[0] === \"function\") {\r\n            var args = utils.toArray(arguments);\r\n            tasks = args.slice(0, args.length - 1);\r\n            callback = args[args.length - 1];\r\n        }\r\n\r\n        tasks = tasks || [];\r\n        callback = callback || function () {\r\n        };\r\n\r\n        if (tasks.length === 0) {\r\n            callback();\r\n        }\r\n        else {\r\n            var nextTask = function (task, remainingTasks, result) {\r\n                var taskCallback = function (err) {\r\n                    if (err) {\r\n                        callback(err);\r\n                    }\r\n                    else {\r\n                        var args = utils.toArray(arguments);\r\n                        args.shift();\r\n                        nextTask(remainingTasks[0], remainingTasks.slice(1), args);\r\n                    }\r\n                };\r\n\r\n                var args = result;\r\n                if (remainingTasks.length === 0) {\r\n                    args.push(callback);\r\n                }\r\n                else {\r\n                    args.push(taskCallback);\r\n                }\r\n\r\n                task.apply(null, args);\r\n            };\r\n\r\n            nextTask(tasks[0], tasks.slice(1), []);\r\n        }\r\n    };\r\n\r\n    /**\r\n     * Asynchronous while loop.\r\n     *\r\n     * @param {function} [condition] - A function returning a boolean, the loop condition.\r\n     * @param {function} [body] - A function, the loop body.\r\n     * @param {function} [callback] - Final callback.\r\n     * @static\r\n     */\r\n    utils.whilst = function (condition, body, callback) {\r\n        condition = condition || function () {\r\n            return false;\r\n        };\r\n        body = body || function (done) {\r\n            done();\r\n        };\r\n        callback = callback || function () {\r\n        };\r\n\r\n        var wrappedCallback = function (err) {\r\n            if (err) {\r\n                callback(err);\r\n            }\r\n            else {\r\n                utils.whilst(condition, body, callback);\r\n            }\r\n        };\r\n\r\n        if (condition()) {\r\n            body(wrappedCallback);\r\n        }\r\n        else {\r\n            callback(null);\r\n        }\r\n    };\r\n\r\n    /**\r\n     * Waits using exponential backoff.\r\n     *\r\n     * @param {object} [opts] - Settings for this function. Expected keys: attempt, rand.\r\n     * @param {function} [callback] - A callback function: <code>function(err, timeout)</code>.\r\n     */\r\n    utils.expBackoff = function (opts, callback) {\r\n        callback = callback || function () {\r\n        };\r\n        if (!opts || typeof opts !== \"object\") {\r\n            callback(new Error(\"Must send opts as an object.\"));\r\n        }\r\n        else if (opts && !opts.hasOwnProperty(\"attempt\")) {\r\n            callback(new Error(\"Must set opts.attempt.\"));\r\n        }\r\n        else {\r\n\r\n            var min = 10;\r\n            var max = 1000 * 60 * 2; // 2 minutes is a reasonable max delay\r\n\r\n            var rand = Math.random();\r\n            if (opts.hasOwnProperty(\"rand\")) {\r\n                rand = opts.rand;\r\n            }\r\n            rand++;\r\n\r\n            var timeout = Math.round(rand * min * Math.pow(2, opts.attempt));\r\n\r\n            timeout = Math.min(timeout, max);\r\n            setTimeout(\r\n                function () {\r\n                    callback(null, timeout);\r\n                },\r\n                timeout\r\n            );\r\n        }\r\n    };\r\n\r\n    /**\r\n     * Binds a function to an instance of an object.\r\n     *\r\n     * @param {object} [self] - An object to bind the <code>fn</code> function parameter to.\r\n     * @param {object} [fn] - A function to bind to the <code>self</code> argument.\r\n     * @returns {function}\r\n     * @static\r\n     */\r\n    utils.bind = function (self, fn) {\r\n        return function () {\r\n            return fn.apply(self, arguments);\r\n        };\r\n    };\r\n\r\n    /**\r\n     * Copies all properties into a new object which is returned.\r\n     *\r\n     * @param {object} [obj] - Object to copy properties from.\r\n     */\r\n    utils.copyObject = function (obj) {\r\n        var ret = {};\r\n        for (var key in obj) {\r\n            if (obj.hasOwnProperty(key)) {\r\n                ret[key] = obj[key];\r\n            }\r\n        }\r\n        return ret;\r\n    };\r\n\r\n    /**\r\n     * Copies all elements into a new array, which is returned.\r\n     *\r\n     * @param {array} [arr] - Array to copy elements from.\r\n     * @returns {array}\r\n     * @static\r\n     */\r\n    utils.copyArray = function (arr) {\r\n        var ret = [];\r\n        for (var i = 0; arr && i < arr.length; i++) {\r\n            ret[i] = arr[i];\r\n        }\r\n        return ret;\r\n    };\r\n\r\n    /**\r\n     * Takes a property name, then any number of objects as arguments\r\n     * and performs logical OR operations on them one at a time\r\n     * Returns true as soon as a truthy\r\n     * value is found, else returning false.\r\n     *\r\n     * @param {string} [prop] - property name for other arguments.\r\n     * @returns {boolean}\r\n     * @static\r\n     */\r\n    utils.orByProp = function (prop) {\r\n        var ret = false;\r\n        for (var i = 1; !ret && i < arguments.length; i++) {\r\n            if (arguments[i]) {\r\n                ret = ret || arguments[i][prop];\r\n            }\r\n        }\r\n        return ret;\r\n    };\r\n\r\n    /**\r\n     * Like <code>utils.orByProp()</code> but for a falsey property.\r\n     * The first argument after <code>prop</code> with that property\r\n     * defined will be returned.\r\n     * Useful for Booleans and numbers.\r\n     *\r\n     * @param {string} [prop] - property name for other arguments.\r\n     * @returns {boolean}\r\n     * @static\r\n     */\r\n    utils.orByFalseyProp = function (prop) {\r\n        var ret = null;\r\n        // Logic is reversed here, first value wins\r\n        for (var i = arguments.length - 1; i > 0; i--) {\r\n            if (arguments[i] && arguments[i].hasOwnProperty(prop)) {\r\n                ret = arguments[i][prop];\r\n            }\r\n        }\r\n        return ret;\r\n    };\r\n\r\n    /**\r\n     * Tries to validate the <code>value</code> parameter as a non-negative\r\n     * integer.\r\n     *\r\n     * @param {number} [value] - Some value, expected to be a positive integer.\r\n     * @param {number} [label] - Human readable name for <code>value</code>\r\n     * for error messages.\r\n     * @returns {number}\r\n     * @throws Will throw an error if the <code>value</code> parameter cannot by parsed as an integer.\r\n     * @static\r\n     */\r\n    utils.validateNonNegativeInt = function (value, label) {\r\n        value = parseInt(value, 10);\r\n        if (isNaN(value)) {\r\n            throw new Error(label + \" must be a number, found: \" + value);\r\n        }\r\n        else if (value < 0) {\r\n            throw new Error(label + \" must be a positive number, found: \" + value);\r\n        }\r\n        return value;\r\n    };\r\n\r\n\r\n    /**\r\n     * Default error handler for <code>SplunkLogger</code>.\r\n     * Prints the <code>err</code> and <code>context</code> to console.\r\n     *\r\n     * @param {Error|string} err - The error message, or an <code>Error</code> object.\r\n     * @param {object} [context] - The <code>context</code> of an event.\r\n     * @private\r\n     */\r\n    /* istanbul ignore next*/\r\n    function _err(err, context) {\r\n        console.log(\"ERROR:\", err, \" CONTEXT\", context);\r\n    }\r\n\r\n    /**\r\n     * The default format for Splunk Enterprise or Splunk Cloud events.\r\n     *\r\n     * This function can be overwritten, and can return any type (string, object, array, and so on).\r\n     *\r\n     * @param {anything} [message] - The event message.\r\n     * @param {string} [severity] - The event severity.\r\n     * @return {any} The event format to send to Splunk,\r\n     */\r\n    function _defaultEventFormatter(message, severity) {\r\n        var event = {\r\n            message: message,\r\n            severity: severity\r\n        };\r\n        return event;\r\n    }\r\n\r\n    /**\r\n     * Constructs a SplunkLogger, to send events to Splunk Enterprise or Splunk Cloud\r\n     * via HTTP Event Collector. See <code>defaultConfig</code> for default\r\n     * configuration settings.\r\n     *\r\n     * @example\r\n     * var SplunkLogger = require(\"splunk-logging\").Logger;\r\n     *\r\n     * var config = {\r\n     *     token: \"your-token-here\",\r\n     *     name: \"my application\",\r\n     *     url: \"https://splunk.local:8088\"\r\n     * };\r\n     *\r\n     * var logger = new SplunkLogger(config);\r\n     *\r\n     * @property {object} config - Configuration settings for this <code>SplunkLogger</code> instance.\r\n     * @param {object} requestOptions - Options to pass to <code>{@link https://github.com/request/request#requestpost|request.post()}</code>.\r\n     * See the {@link http://github.com/request/request|request documentation} for all available options.\r\n     * @property {object[]} serializedContextQueue - Queue of serialized <code>context</code> objects to be sent to Splunk Enterprise or Splunk Cloud.\r\n     * @property {function} eventFormatter - Formats events, returning an event as a string, <code>function(message, severity)</code>.\r\n     * Can be overwritten, the default event formatter will display event and severity as properties in a JSON object.\r\n     * @property {function} error - A callback function for errors: <code>function(err, context)</code>.\r\n     * Defaults to <code>console.log</code> both values;\r\n     *\r\n     * @param {object} config - Configuration settings for a new [SplunkLogger]{@link SplunkLogger}.\r\n     * @param {string} config.token - HTTP Event Collector token, required.\r\n     * @param {string} [config.name=splunk-javascript-logging/0.9.2] - Name for this logger.\r\n     * @param {string} [config.host=localhost] - Hostname or IP address of Splunk Enterprise or Splunk Cloud server.\r\n     * @param {string} [config.maxRetries=0] - How many times to retry when HTTP POST to Splunk Enterprise or Splunk Cloud fails.\r\n     * @param {string} [config.path=/services/collector/event/1.0] - URL path to send data to on the Splunk Enterprise or Splunk Cloud server.\r\n     * @param {string} [config.protocol=https] - Protocol used to communicate with the Splunk Enterprise or Splunk Cloud server, <code>http</code> or <code>https</code>.\r\n     * @param {number} [config.port=8088] - HTTP Event Collector port on the Splunk Enterprise or Splunk Cloud server.\r\n     * @param {string} [config.url] - URL string to pass to {@link https://nodejs.org/api/url.html#url_url_parsing|url.parse}. This will try to set\r\n     * <code>host</code>, <code>path</code>, <code>protocol</code>, <code>port</code>, <code>url</code>. Any of these values will be overwritten if\r\n     * the corresponding property is set on <code>config</code>.\r\n     * @param {string} [config.level=info] - Logging level to use, will show up as the <code>severity</code> field of an event, see\r\n     *  [SplunkLogger.levels]{@link SplunkLogger#levels} for common levels.\r\n     * @param {number} [config.batchInterval=0] - Automatically flush events after this many milliseconds.\r\n     * When set to a non-positive value, events will be sent one by one. This setting is ignored when non-positive.\r\n     * @param {number} [config.maxBatchSize=0] - Automatically flush events after the size of queued\r\n     * events exceeds this many bytes. This setting is ignored when non-positive.\r\n     * @param {number} [config.maxBatchCount=1] - Automatically flush events after this many\r\n     * events have been queued. Defaults to flush immediately on sending an event. This setting is ignored when non-positive.\r\n     * @constructor\r\n     * @throws Will throw an error if the <code>config</code> parameter is malformed.\r\n     */\r\n    var SplunkLogger = function (config) {\r\n        this._timerID = null;\r\n        this._timerDuration = 0;\r\n        this.config = this._initializeConfig(config);\r\n        this.requestOptions = this._initializeRequestOptions();\r\n        this.serializedContextQueue = [];\r\n        this.eventsBatchSize = 0;\r\n        this.eventFormatter = _defaultEventFormatter;\r\n        this.error = _err;\r\n\r\n        this._enableTimer = utils.bind(this, this._enableTimer);\r\n        this._disableTimer = utils.bind(this, this._disableTimer);\r\n        this._initializeConfig = utils.bind(this, this._initializeConfig);\r\n        this._initializeRequestOptions = utils.bind(this, this._initializeRequestOptions);\r\n        this._validateMessage = utils.bind(this, this._validateMessage);\r\n        this._initializeMetadata = utils.bind(this, this._initializeMetadata);\r\n        this._initializeContext = utils.bind(this, this._initializeContext);\r\n        this._makeBody = utils.bind(this, this._makeBody);\r\n        this._post = utils.bind(this, this._post);\r\n        this._sendEvents = utils.bind(this, this._sendEvents);\r\n        this.send = utils.bind(this, this.send);\r\n        this.flush = utils.bind(this, this.flush);\r\n    };\r\n\r\n    /**\r\n     * Enum for common logging levels.\r\n     *\r\n     * @default info\r\n     * @readonly\r\n     * @enum {string}\r\n     */\r\n    SplunkLogger.prototype.levels = {\r\n        DEBUG: \"debug\",\r\n        INFO: \"info\",\r\n        WARN: \"warn\",\r\n        ERROR: \"error\"\r\n    };\r\n\r\n    var defaultConfig = {\r\n        name: \"splunk-javascript-logging/0.9.2\",\r\n        host: \"localhost\",\r\n        path: \"/services/collector/event/1.0\",\r\n        protocol: \"https\",\r\n        authorization: \"Splunk\",\r\n        port: 8088,\r\n        level: SplunkLogger.prototype.levels.INFO,\r\n        maxRetries: 0,\r\n        batchInterval: 0,\r\n        maxBatchSize: 0,\r\n        maxBatchCount: 1\r\n    };\r\n\r\n    var defaultRequestOptions = {\r\n        json: false,\r\n        strictSSL: false\r\n    };\r\n\r\n    /**\r\n     * Disables the interval timer set by <code>this._enableTimer()</code>.\r\n     *\r\n     * param {Number} interval - The batch interval.\r\n     * @private\r\n     */\r\n    SplunkLogger.prototype._disableTimer = function () {\r\n        if (this._timerID) {\r\n            clearInterval(this._timerID);\r\n            this._timerDuration = 0;\r\n            this._timerID = null;\r\n        }\r\n    };\r\n\r\n    /**\r\n     * Configures an interval timer to flush any events in\r\n     * <code>this.serializedContextQueue</code> at the specified interval.\r\n     *\r\n     * param {Number} interval - The batch interval in milliseconds.\r\n     * @private\r\n     */\r\n    SplunkLogger.prototype._enableTimer = function (interval) {\r\n        // Only enable the timer if possible\r\n        interval = utils.validateNonNegativeInt(interval, \"Batch interval\");\r\n\r\n        if (this._timerID) {\r\n            this._disableTimer();\r\n        }\r\n\r\n        // If batch interval is changed, update the config property\r\n        if (this.config) {\r\n            this.config.batchInterval = interval;\r\n        }\r\n\r\n        this._timerDuration = interval;\r\n\r\n        var that = this;\r\n        this._timerID = setInterval(function () {\r\n            if (that.serializedContextQueue.length > 0) {\r\n                that.flush();\r\n            }\r\n        }, interval);\r\n    };\r\n\r\n    /**\r\n     * Sets up the <code>config</code> with any default properties, and/or\r\n     * config properties set on <code>this.config</code>.\r\n     *\r\n     * @return {object} config\r\n     * @private\r\n     * @throws Will throw an error if the <code>config</code> parameter is malformed.\r\n     */\r\n    SplunkLogger.prototype._initializeConfig = function (config) {\r\n        // Copy over the instance config\r\n        var ret = utils.copyObject(this.config);\r\n\r\n        if (!config) {\r\n            throw new Error(\"Config is required.\");\r\n        }\r\n        else if (typeof config !== \"object\") {\r\n            throw new Error(\"Config must be an object.\");\r\n        }\r\n        else if (!ret.hasOwnProperty(\"token\") && !config.hasOwnProperty(\"token\")) {\r\n            throw new Error(\"Config object must have a token.\");\r\n        }\r\n        else if (typeof ret.token !== \"string\" && typeof config.token !== \"string\") {\r\n            throw new Error(\"Config token must be a string.\");\r\n        }\r\n        else {\r\n            // Specifying the url not supported, specify port, host, protocol\r\n            // if (config.url) {\r\n            //\r\n            //     /\r\n            //     var parsed = url.parse(config.url);\r\n            //\r\n            //     // Ignore the path if it's just \"/\"\r\n            //     var pathIsNotSlash = parsed.path && parsed.path !== \"/\";\r\n            //\r\n            //     if (parsed.protocol) {\r\n            //         config.protocol = parsed.protocol.replace(\":\", \"\");\r\n            //     }\r\n            //     if (parsed.port) {\r\n            //         config.port = parsed.port;\r\n            //     }\r\n            //     if (parsed.hostname && parsed.path) {\r\n            //         config.host = parsed.hostname;\r\n            //         if (pathIsNotSlash) {\r\n            //             config.path = parsed.path;\r\n            //         }\r\n            //     }\r\n            //     else if (pathIsNotSlash) {\r\n            //         // If hostname isn't set, but path is assume path is the host\r\n            //         config.host = parsed.path;\r\n            //     }\r\n            // }\r\n\r\n            // Take the argument's value, then instance value, then the default value\r\n            ret.token = utils.orByProp(\"token\", config, ret);\r\n            ret.name = utils.orByProp(\"name\", config, ret, defaultConfig);\r\n            ret.level = utils.orByProp(\"level\", config, ret, defaultConfig);\r\n\r\n            ret.host = utils.orByProp(\"host\", config, ret, defaultConfig);\r\n            ret.path = utils.orByProp(\"path\", config, ret, defaultConfig);\r\n            ret.protocol = utils.orByProp(\"protocol\", config, ret, defaultConfig);\r\n            ret.port = utils.orByFalseyProp(\"port\", config, ret, defaultConfig);\r\n            ret.port = utils.validateNonNegativeInt(ret.port, \"Port\");\r\n            if (ret.port < 1 || ret.port > 65535) {\r\n                throw new Error(\"Port must be an integer between 1 and 65535, found: \" + ret.port);\r\n            }\r\n\r\n            ret.authorization = utils.orByProp(\"authorization\", config, ret, defaultConfig);\r\n            ret.maxRetries = utils.orByProp(\"maxRetries\", config, ret, defaultConfig);\r\n            ret.maxRetries = utils.validateNonNegativeInt(ret.maxRetries, \"Max retries\");\r\n\r\n            // Batching settings\r\n            ret.maxBatchCount = utils.orByFalseyProp(\"maxBatchCount\", config, ret, defaultConfig);\r\n            ret.maxBatchCount = utils.validateNonNegativeInt(ret.maxBatchCount, \"Max batch count\");\r\n            ret.maxBatchSize = utils.orByFalseyProp(\"maxBatchSize\", config, ret, defaultConfig);\r\n            ret.maxBatchSize = utils.validateNonNegativeInt(ret.maxBatchSize, \"Max batch size\");\r\n            ret.batchInterval = utils.orByFalseyProp(\"batchInterval\", config, ret, defaultConfig);\r\n            ret.batchInterval = utils.validateNonNegativeInt(ret.batchInterval, \"Batch interval\");\r\n\r\n            // Has the interval timer not started, and needs to be started?\r\n            var startTimer = !this._timerID && ret.batchInterval > 0;\r\n            // Has the interval timer already started, and the interval changed to a different duration?\r\n            var changeTimer = this._timerID && this._timerDuration !== ret.batchInterval && ret.batchInterval > 0;\r\n\r\n            // Enable the timer\r\n            if (startTimer || changeTimer) {\r\n                this._enableTimer(ret.batchInterval);\r\n            }\r\n            // Disable timer - there is currently a timer, but config says we no longer need a timer\r\n            else if (this._timerID && (ret.batchInterval <= 0 || this._timerDuration < 0)) {\r\n                this._disableTimer();\r\n            }\r\n        }\r\n        return ret;\r\n    };\r\n\r\n    /**\r\n     * Initializes request options.\r\n     *\r\n     * @param {object} config\r\n     * @param {object} options - Options to pass to <code>{@link https://github.com/request/request#requestpost|request.post()}</code>.\r\n     * See the {@link http://github.com/request/request|request documentation} for all available options.\r\n     * @returns {object} requestOptions\r\n     * @private\r\n     */\r\n    SplunkLogger.prototype._initializeRequestOptions = function (options) {\r\n        var ret = utils.copyObject(options || defaultRequestOptions);\r\n\r\n        if (options) {\r\n            ret.json = options.hasOwnProperty(\"json\") ? options.json : defaultRequestOptions.json;\r\n            ret.strictSSL = options.strictSSL || defaultRequestOptions.strictSSL;\r\n        }\r\n\r\n        ret.headers = ret.headers || {};\r\n\r\n        return ret;\r\n    };\r\n\r\n    /**\r\n     * Throws an error if message is <code>undefined</code> or <code>null</code>.\r\n     *\r\n     * @private\r\n     * @throws Will throw an error if the <code>message</code> parameter is malformed.\r\n     */\r\n    SplunkLogger.prototype._validateMessage = function (message) {\r\n        if (typeof message === \"undefined\" || message === null) {\r\n            throw new Error(\"Message argument is required.\");\r\n        }\r\n        return message;\r\n    };\r\n\r\n    /**\r\n     * Initializes metadata. If <code>context.metadata</code> is false or empty,\r\n     * return an empty object.\r\n     *\r\n     * @param {object} context\r\n     * @returns {object} metadata\r\n     * @private\r\n     */\r\n    SplunkLogger.prototype._initializeMetadata = function (context) {\r\n        var metadata = {};\r\n        if (context && context.hasOwnProperty(\"metadata\")) {\r\n            if (context.metadata.hasOwnProperty(\"time\")) {\r\n                metadata.time = context.metadata.time;\r\n            }\r\n            if (context.metadata.hasOwnProperty(\"host\")) {\r\n                metadata.host = context.metadata.host;\r\n            }\r\n            if (context.metadata.hasOwnProperty(\"source\")) {\r\n                metadata.source = context.metadata.source;\r\n            }\r\n            if (context.metadata.hasOwnProperty(\"sourcetype\")) {\r\n                metadata.sourcetype = context.metadata.sourcetype;\r\n            }\r\n            if (context.metadata.hasOwnProperty(\"index\")) {\r\n                metadata.index = context.metadata.index;\r\n            }\r\n        }\r\n        return metadata;\r\n    };\r\n\r\n    /**\r\n     * Initializes a context object.\r\n     *\r\n     * @param context\r\n     * @returns {object} context\r\n     * @throws Will throw an error if the <code>context</code> parameter is malformed.\r\n     * @private\r\n     */\r\n    SplunkLogger.prototype._initializeContext = function (context) {\r\n        if (!context) {\r\n            throw new Error(\"Context argument is required.\");\r\n        }\r\n        else if (typeof context !== \"object\") {\r\n            throw new Error(\"Context argument must be an object.\");\r\n        }\r\n        else if (!context.hasOwnProperty(\"message\")) {\r\n            throw new Error(\"Context argument must have the message property set.\");\r\n        }\r\n\r\n        context.message = this._validateMessage(context.message);\r\n\r\n        context.severity = context.severity || defaultConfig.level;\r\n\r\n        context.metadata = context.metadata || this._initializeMetadata(context);\r\n\r\n        return context;\r\n    };\r\n\r\n    /**\r\n     * Takes anything and puts it in a JS object for the event/1.0 Splunk HTTP Event Collector format.\r\n     *\r\n     * @param {object} context\r\n     * @returns {object}\r\n     * @private\r\n     * @throws Will throw an error if the <code>context</code> parameter is malformed.\r\n     */\r\n    SplunkLogger.prototype._makeBody = function (context) {\r\n        if (!context) {\r\n            throw new Error(\"Context parameter is required.\");\r\n        }\r\n\r\n        var body = this._initializeMetadata(context);\r\n        var time = utils.formatTime(body.time || Date.now());\r\n        body.time = time.toString();\r\n\r\n        body.event = this.eventFormatter(context.message, context.severity || defaultConfig.level);\r\n        return body;\r\n    };\r\n\r\n    /**\r\n     * Makes an HTTP POST to the configured server.\r\n     *\r\n     * @param requestOptions\r\n     * @param {function} callback = A callback function: <code>function(err, response, body)</code>.\r\n     * @private\r\n     */\r\n    SplunkLogger.prototype._post = function (requestOptions, callback) {\r\n        // request.post(requestOptions, callback);\r\n\r\n        // AJAX the request instead of using request library, since it has 20 dependencies\r\n\r\n        var xhr = new XMLHttpRequest();\r\n        xhr.open('POST', requestOptions.url);\r\n\r\n        Object.keys(requestOptions.headers).forEach(function (key) {\r\n            xhr.setRequestHeader(key, requestOptions.headers[key])\r\n        });\r\n\r\n        xhr.onload = function () {\r\n            if (xhr.status === 200) {\r\n                callback(false, { \"statusCode\": xhr.status }, xhr.responseText)\r\n            }\r\n            else {\r\n                callback(true, { \"statusCode\": xhr.status }, xhr.responseText)\r\n            }\r\n        };\r\n        xhr.send(requestOptions.body);\r\n    };\r\n\r\n    /**\r\n     * Sends events to Splunk Enterprise or Splunk Cloud, optionally with retries on non-Splunk errors.\r\n     *\r\n     * @param context\r\n     * @param {function} callback - A callback function: <code>function(err, response, body)</code>\r\n     * @private\r\n     */\r\n    SplunkLogger.prototype._sendEvents = function (context, callback) {\r\n        callback = callback || /* istanbul ignore next*/ function () {\r\n        };\r\n\r\n        // Initialize the config once more to avoid undefined vals below\r\n        this.config = this._initializeConfig(this.config);\r\n\r\n        // Makes a copy of the request options so we can set the body\r\n        var requestOptions = this._initializeRequestOptions(this.requestOptions);\r\n        requestOptions.body = this._validateMessage(context.message);\r\n\r\n        requestOptions.headers[\"Authorization\"] = this.config.authorization + \" \" + this.config.token;\r\n        // Manually set the content-type header, the default is application/json\r\n        // since json is set to true.\r\n        requestOptions.headers[\"Content-Type\"] = \"application/x-www-form-urlencoded\";\r\n        requestOptions.url = this.config.protocol + \"://\" + this.config.host + this.config.path;\r\n\r\n        // Initialize the context again, right before using it\r\n        context = this._initializeContext(context);\r\n\r\n        var that = this;\r\n\r\n        var splunkError = null; // Errors returned by Splunk Enterprise or Splunk Cloud\r\n        var requestError = null; // Any non-Splunk errors\r\n\r\n        // References so we don't have to deal with callback parameters\r\n        var _response = null;\r\n        var _body = null;\r\n\r\n        var numRetries = 0;\r\n\r\n        utils.whilst(\r\n            function () {\r\n                // Continue if we can (re)try\r\n                return numRetries++ <= that.config.maxRetries;\r\n            },\r\n            function (done) {\r\n                that._post(requestOptions, function (err, resp, body) {\r\n                    // Store the latest error, response & body\r\n                    splunkError = null;\r\n                    requestError = err;\r\n                    _response = resp;\r\n\r\n                    // Retry if no Splunk error, a non-200 request response, and numRetries hasn't exceeded the limit\r\n                    if (requestError && numRetries <= that.config.maxRetries) {\r\n                        return utils.expBackoff({ attempt: numRetries }, done);\r\n                    }\r\n                    else if (requestError) {\r\n                        return done(err);\r\n                    }\r\n\r\n                    try {\r\n                        _body = JSON.parse(body);\r\n                    }\r\n                    catch (err) {\r\n                        _body = body;\r\n\r\n                        splunkError = new Error(\"Unexpected response from Splunk. Request body was: \" + _body);\r\n                        splunkError.code = -1;\r\n                    }\r\n\r\n                    // Try to parse an error response from Splunk Enterprise or Splunk Cloud\r\n                    if (!splunkError && _body && _body.code && _body.code.toString() !== \"0\") {\r\n                        splunkError = new Error(_body.text);\r\n                        splunkError.code = _body.code;\r\n                    }\r\n\r\n                    // Stop iterating\r\n                    done(true);\r\n                });\r\n            },\r\n            function () {\r\n                // Call error() for a request error or Splunk error\r\n                if (requestError || splunkError) {\r\n                    that.error(requestError || splunkError, context);\r\n                }\r\n\r\n                callback(requestError, _response, _body);\r\n            }\r\n        );\r\n    };\r\n\r\n    /**\r\n     * Sends or queues data to be sent based on batching settings.\r\n     * Default behavior is to send immediately.\r\n     *\r\n     * @example\r\n     * var SplunkLogger = require(\"splunk-logging\").Logger;\r\n     * var config = {\r\n     *     token: \"your-token-here\"\r\n     * };\r\n     *\r\n     * var logger = new SplunkLogger(config);\r\n     *\r\n     * // Payload to send to HTTP Event Collector.\r\n     * var payload = {\r\n     *     message: {\r\n     *         temperature: \"70F\",\r\n     *         chickenCount: 500\r\n     *     },\r\n     *     severity: \"info\",\r\n     *     metadata: {\r\n     *         source: \"chicken coop\",\r\n     *         sourcetype: \"httpevent\",\r\n     *         index: \"main\",\r\n     *         host: \"farm.local\",\r\n     *     }\r\n     * };\r\n     *\r\n     * // The callback is only used if maxBatchCount=1, or\r\n     * // batching thresholds have been exceeded.\r\n     * logger.send(payload, function(err, resp, body) {\r\n     *     if (err) {\r\n     *         console.log(\"error:\", err);\r\n     *     }\r\n     *     // If successful, body will be { text: 'Success', code: 0 }\r\n     *     console.log(\"body\", body);\r\n     * });\r\n     *\r\n     * @param {object} context - An object with at least the <code>data</code> property.\r\n     * @param {(object|string|Array|number|bool)} context.message - Data to send to Splunk.\r\n     * @param {string} [context.severity=info] - Severity level of this event.\r\n     * @param {object} [context.metadata] - Metadata for this event.\r\n     * @param {string} [context.metadata.host] - If not specified, Splunk Enterprise or Splunk Cloud will decide the value.\r\n     * @param {string} [context.metadata.index] - The Splunk Enterprise or Splunk Cloud index to send data to.\r\n     * If not specified, Splunk Enterprise or Splunk Cloud will decide the value.\r\n     * @param {string} [context.metadata.source] - If not specified, Splunk Enterprise or Splunk Cloud will decide the value.\r\n     * @param {string} [context.metadata.sourcetype] - If not specified, Splunk Enterprise or Splunk Cloud will decide the value.\r\n     * @param {function} [callback] - A callback function: <code>function(err, response, body)</code>.\r\n     * @throws Will throw an error if the <code>context</code> parameter is malformed.\r\n     * @public\r\n     */\r\n    SplunkLogger.prototype.send = function (context, callback) {\r\n        context = this._initializeContext(context);\r\n\r\n        // Store the context, and its estimated length\r\n        var currentEvent = JSON.stringify(this._makeBody(context));\r\n        this.serializedContextQueue.push(currentEvent);\r\n        this.eventsBatchSize += lengthInUtf8Bytes(currentEvent);\r\n\r\n        var batchOverSize = this.eventsBatchSize > this.config.maxBatchSize && this.config.maxBatchSize > 0;\r\n        var batchOverCount = this.serializedContextQueue.length >= this.config.maxBatchCount && this.config.maxBatchCount > 0;\r\n\r\n        // Only flush if the queue's byte size is too large, or has too many events\r\n        if (batchOverSize || batchOverCount) {\r\n            this.flush(callback || function () {\r\n            });\r\n        }\r\n    };\r\n\r\n    function lengthInUtf8Bytes(str) {\r\n        // Matches only the 10.. bytes that are non-initial characters in a multi-byte sequence.\r\n        var m = encodeURIComponent(str).match(/%[89ABab]/g);\r\n        return str.length + (m ? m.length : 0);\r\n    }\r\n\r\n    /**\r\n     * Manually send all events in <code>this.serializedContextQueue</code> to Splunk Enterprise or Splunk Cloud.\r\n     *\r\n     * @param {function} [callback] - A callback function: <code>function(err, response, body)</code>.\r\n     * @public\r\n     */\r\n    SplunkLogger.prototype.flush = function (callback) {\r\n        callback = callback || function () {\r\n        };\r\n\r\n        // Empty the queue, reset the eventsBatchSize\r\n        var queue = this.serializedContextQueue;\r\n        this.serializedContextQueue = [];\r\n        this.eventsBatchSize = 0;\r\n\r\n        // Send all queued events\r\n        var data = queue.join(\"\");\r\n        var context = {\r\n            message: data\r\n        };\r\n\r\n        this._sendEvents(context, callback);\r\n    };\r\n\r\n    exports.SplunkLogger = SplunkLogger;\r\n\r\n})(typeof exports === 'undefined' ? this['splunk'] = {} : exports);","(function (exports) {\r\n    var configHerbalifeHEC = {\r\n        token: \"5F0EDC1E-0C9D-5615-9E43-A5AA7CB0F8C1\",\r\n        host: \"http-inputs-hrbl.splunkcloud.com\"\r\n    };\r\n\r\n    var splunkLogger = new splunk.SplunkLogger(configHerbalifeHEC);\r\n\r\n    splunkLogger.eventFormatter = function (message, severity) {\r\n        var event = {\r\n            message: message,\r\n            severity: severity,\r\n            userAgent: navigator.userAgent,\r\n            platform: navigator.platform,\r\n            url: location.href,\r\n            language: navigator.language\r\n        }\r\n\r\n        return event;\r\n    }\r\n\r\n    function wrapLog(msg, severity, appSource) {\r\n        var payload = {\r\n            message: msg,\r\n            severity: severity,\r\n            metadata: {\r\n                host: window.location.host,\r\n                source: getSource()\r\n            }\r\n        };\r\n        return payload;\r\n    }\r\n\r\n    function getSource() {\r\n        var result = \"\";\r\n        var url = window.location.href;\r\n        var source = url.split(\"/\");\r\n        var posibleLocale = source[3];\r\n        if (source[3] === \"\") {\r\n            result = \"Root\";\r\n        } else {\r\n            if (posibleLocale[2] === \"-\") {\r\n                result = source[4];\r\n            } else {\r\n                result = source[3];\r\n            }\r\n\r\n        }\r\n        \r\n        return result;\r\n    }\r\n\r\n    function error(msg, source) { log(msg, splunkLogger.levels.ERROR, source); }\r\n\r\n    function warn(msg, source) { log(msg, splunkLogger.levels.WARN, source); }\r\n\r\n    function info(msg, source) { log(msg, splunkLogger.levels.INFO, source); }\r\n\r\n    function debug(msg, source) { log(msg, splunkLogger.levels.DEBUG, source); }\r\n\r\n    function log(msg, severity, source) {\r\n        var wrapped = wrapLog(msg, severity, source);\r\n\r\n        console.log(\"Splunk\", severity, msg);\r\n        splunkLogger.send(wrapped, function (err, resp, body) {\r\n            if (err) {\r\n                console.log(\"error:\", err);\r\n            }\r\n            // If successful, body will be { text: 'Success', code: 0 }\r\n            console.log(\"body\", body);\r\n        });\r\n    }\r\n\r\n    // Log all unhandled exceptions\r\n    TraceKit.report.subscribe(function (stackInfo) {\r\n        error(stackInfo, SplunkConfig.application || \"undefined\");\r\n    });\r\n\r\n    exports.SpluLogger = {\r\n        error: error,\r\n        warn: warn,\r\n        info: info,\r\n        debug: debug\r\n    };\r\n})(typeof exports === 'undefined' ? this : exports);"]}