/**

* Copyright 2016 Nuance Inc.

*
* log-util
*
* log-util is wrapper on top of log4javascript. This is the
* only interface through which user will be able to access
* the required APIs to control logging at Java Script side
* similar to log4j.
*
* Author:
* Version: 1.0
* Edition: log-util
*/
var BATCH_SIZE = 50;
var MAX_LENGTH = 70;
var HANDLER_URI = "/topaz/n/coding/jsLogging/handleWriteLogs";
// To get logger instance
var log = log4javascript.getLogger("appLogger");
// To get the ajax appender instance
var ajaxAppender = new log4javascript.AjaxAppender(HANDLER_URI);
// To set batch size, layout etc. to appender
ajaxAppender.setBatchSize(BATCH_SIZE);
ajaxAppender.setLayout(new log4javascript.JsonLayout());
ajaxAppender.addHeader("Content-Type", "application/json");
ajaxAppender.setSendAllOnUnload(true);
ajaxAppender.setFailCallback(handleWriteLogFailure);
// Add appender to log instance
log.addAppender(ajaxAppender);
// Set default log level to ERROR
log.setLevel(log4javascript.Level.ERROR);
// By default logger is disabled
log4javascript.setEnabled(false);
/**
* function to handle the failure response from
* server of write logs request. On failure this
* function will disable the logging on client
* side.
*/
function handleWriteLogFailure() {
if (log4javascript.isEnabled()) {
log4javascript.setEnabled(false);
}
}
/**
* function to truncate the log message longer than
* 70 characters in length. It simply ignores the
* extra part of message.
*/
function truncateLongMessage (message) {
if (message.length > MAX_LENGTH) {
message = message.substring(MAX_LENGTH);

}
return message;
}
/**
* Returns a log instance
*
* @returns log
*/
function getLogger() {
return log;
}
/**
* Returns true or false depending on whether logging is enabled
.
*
* @returns {boolean} isEnabled
*/
function isLoggingEnabled() {
return log4javascript.isEnabled();
}
/**
* Enables or disables all logging, depending on enabled.
*
* @param {boolean} enabled
*/
function setLoggingEnabled(enabled) {
log4javascript.setEnabled(enabled);
}
/**
* Returns a flexible appender that asynchronously sends
* log messages to a server via HTTP.
*
* @returns {AjaxAppender} ajaxAppender
*/
function getAjaxAppender() {
if (ajaxAppender == null) {
ajaxAppender = new log4javascript.AjaxAppender(H
ANDLER_URI);
}
return ajaxAppender;
}
/**
* Adds the given appender.
*
* @param {Appender} appender
*/
function addAppenderToLogger(appender) {
this.getLogger().addAppender(appender);
}
/**
* Removes the given appender.
*
* @param {Appender} appender
*/

function removeAppenderFromLogger(appender) {
this.getLogger().removeAppender(appender);
}
/**
* First clears all appenders for the current
* logger and adds the given appender.
*
* @param {Appender} appender
*/
function changeAppender(appender) {
this.getLogger().removeAllAppenders();
this.getLogger().addAppender(appender);
}
/**
* Returns the level explicitly set for
* this logger or null if none has been set.
*
* @returns {Level} logLevel
*/
function getLogLevel() {
return this.getLogger().getLevel();
}
/**
* Sets the level. Log messages of a lower
* level than level will not be logged. Default
* value is DEBUG.
*
* @param {Level} logLevel
*/
function setLogLevel(logLevel) {
this.getLogger().setLevel(logLevel);
}
/**
* Returns the level at which the logger is operating.
* This is either the level explicitly set on the logger
* or, if no level has been set, the effective level
* of the logger's parent.
*
* @returns {Level} logLevel
* */
function getEffectiveLogLevel() {
return this.getLogger().getEffectiveLevel();
}
/**
* if requested logLevel is not same as the
* currently set logLevel then it sets the requested
* logLevel.
*
* @param {Level} newLogLevel
*/
function changeLogLevel(newLogLevel) {
if (!this.getLevel().equals(newLogLevel)) {
this.setLevel(newLogLevel);
}
}

/**
* Generic logging method
*
* @param {Level} logLevel
* @param {Object} message
*/
function log(logLevel, message) {
truncateLongMessage(message);
this.getLogger().log(logLevel, message);
}
/**
* Logs message at level TRACE
*
* @param {Object} message
*/
function trace(message) {
truncateLongMessage(message);
this.getLogger().trace(message);
}
/**
* Logs message at level DEBUG
*
* @param {Object} message
*/
function debug(message) {
truncateLongMessage(message);
this.getLogger().debug(message);
}
/**
* Logs message at level INFO
*
* @param {Object} message
*/
function info(message) {
truncateLongMessage(message);
this.getLogger().info(message);
}
/**
* Logs message at level WARN
*
* @param {Object} message
*/
function warn(message) {
truncateLongMessage(message);
this.getLogger().warn(message);
}
/**
* Logs message at level ERROR
*
* @param {Object} message
*/
function error(message) {
truncateLongMessage(message);
this.getLogger().error(message);

}
/**
* Logs message at level FATAL
*
* @param {Object} message
*/
function fatal(message) {
truncateLongMessage(message);
this.getLogger().fatal(message);
}
/**
* Returns whether the logger is enabled for TRACE messages.
*
* @returns {Boolean} enabled
*/
function isTraceEnabled() {
return this.getLogger().isTraceEnabled();
}
/**
* Returns whether the logger is enabled for DEBUG messages.
*
* @returns {Boolean} enabled
*/
function isDebugEnabled() {
return this.getLogger().isDebugEnabled();
}
/**
* Returns whether the logger is enabled for INFO messages.
*
* @returns {Boolean} enabled
*/
function isInfoEnabled() {
return this.getLogger().isInfoEnabled();
}
/**
* Returns whether the logger is enabled for WARN messages.
*
* @returns {Boolean} enabled
*/
function isWarnEnabled() {
return this.getLogger().isWarnEnabled();
}
/**
* Returns whether the logger is enabled for ERROR messages.
*
* @returns {Boolean} enabled
*/
function isErrorEnabled() {
return this.getLogger().isErrorEnabled();
}
/**
* Returns whether the logger is enabled for FATAL messages.
*

* @returns {Boolean} enabled

*/
function isFatalEnabled() {
return this.getLogger().isFatalEnabled();
}
/**
* returns JSONLayout instance.
*
* @returns {JsonLayout} jsonLayout
*/
function getJSONLayout() {
return new log4javascript.JsonLayout();
}
/**
* returns SimpleLayout instance.
*
* @returns {SimpleLayout} simpleLayout
*/
function getSimpleLayout() {
return new log4javascript.SimpleLayout();
}
/**
* returns XMLLayout instance.
*
* @returns {XmlLayout} xmlLayout
*/
function getXMLLayout() {
return new log4javascript.XmlLayout();
}
/**
* Sets the number of log messages to send in each
* request. If not specified, defaults to 1.
*
* @param {Number} sizeVal
*/
function setLogBatchSize(sizeVal) {
this.getAjaxAppender().setBatchSize(sizeVal);
}
/**
* Adds an HTTP header that is sent with each AJAX request.
*
* @param {String} headerName
* @param {String} headerVal
*/
function addAjaxReqHeader(headerName, headerVal) {
this.getAjaxAppender().addHeader(headerName, headerVal);
}
/**
* Sets the post variable name whose value will the
* formatted log message(s) for each request. Default
* value is data.
*
* @param {String} varName
*/

function setPostVarName(varName) {
this.getAjaxAppender().setPostVarName(varName);
}
/**
* Sets whether to wait for a response from a previous
* HTTP request from this appender before sending the
* next log message / batch of messages. Default value
* is false.
*
* @param {Boolean} waitForResp
*/
function setWaitForResponse(waitForResp) {
this.getAjaxAppender().setWaitForResponse(waitForResp);
}
/**
* Sets the session id sent to the server each time a
* request is made.
*
* @param {String} sessionId
*/
function setSessionId(sessionId) {
this.getAjaxAppender().setSessionId(sessionId);
}
/**
* Returns the session id sent to the server each time
* a request is made.
*
* @returns {String} sessionId
*/
function getSessionId() {
return this.getAjaxAppender().getSessionId();
}