Name

sn_int_studio.CMDBIntegrationStudioImportLogUtils

Description

No description available

Script

var CMDBIntegrationStudioImportLogUtils = Class.create();
CMDBIntegrationStudioImportLogUtils.prototype = {
  initialize: function() {},

  TABLE: {
      IMPORT_LOG: 'import_log'
  },

  FIELDS: {
      LEVEL: 'level',
      RUN_HISTORY: 'run_history',
      ACTIVITY: 'activity',
      MESSAGE: 'message',
      SOURCE: 'source',
      SYS_CREATED_ON: 'sys_created_on'
  },

  CONST: {
      IRE_SUMMARY_LOG_PREFIX: 'Identification Reconciliation Engine(IRE) detailed summary',
      IRE_ERROR_LOG_PREFIX: 'Identification Reconciliation Engine(IRE) Processing errors',
      IRE_WARNING_LOG_PREFIX: 'Identification Reconciliation Engine(IRE) Processing warnings',
      INT_STUDIO_SOURCE: 'Integration Studio',
      OTHER_CATEGORY: 'OTHER'
  },

  LOG_LEVEL: {
      DEBUG: 'Debug',
      INFO: 'Information',
      WARNING: 'Warning',
      ERROR: 'Error'
  },

  getAllLogs: function(runHistoryIds) {
      var allLogs = this._loadAllLogs(runHistoryIds);
      return this._processLogs(allLogs);
  },

  _loadAllLogs: function(runHistoryIds) {
      if (!runHistoryIds) {
          gs.error('Missing Run History IDs');
          throw new sn_ws_err.BadRequestError(gs.getMessage('Missing Run History IDs'));
      }

      var result = {};
      runHistoryIds = runHistoryIds.split(',');

      var gr = new GlideRecord(this.TABLE.IMPORT_LOG);
      gr.addQuery(this.FIELDS.RUN_HISTORY, runHistoryIds);
      gr.addQuery(this.FIELDS.SOURCE, this.CONST.INT_STUDIO_SOURCE);

      // Add range check on sys_created_on
      var nowTime = new GlideDateTime();
      gr.addQuery(this.FIELDS.SYS_CREATED_ON, '<=', nowTime.getValue());

      var olderTime = new GlideDateTime();
      olderTime.addSeconds(-1 * 30 * 60); // Created in last 30 mins
      gr.addQuery(this.FIELDS.SYS_CREATED_ON, '>=', olderTime.getValue());

      gr.query();
      while (gr.next()) {
          var id = gr.getDisplayValue(this.FIELDS.RUN_HISTORY + '.sys_id');
          result[id] = result[id] || [];

          var log = {};
          log.created = gr.getDisplayValue(this.FIELDS.SYS_CREATED_ON);
          log.level = gr.getDisplayValue(this.FIELDS.LEVEL);
          log.logMessage = gr.getDisplayValue(this.FIELDS.MESSAGE);
          log.source = gr.getDisplayValue(this.FIELDS.SOURCE);
          result[id].push(log);
      }
      return result;
  },

  _processLogs: function(allLogs) {
      var result = {};
      var activityLogs = [];
      var errorLogs = [];
      var warningLogs = [];
      var runHistoryIds = Object.keys(allLogs);
      for (var r = 0; r < runHistoryIds.length; r++) {
          var currRunHistoryId = runHistoryIds[r];
          var logs = allLogs[currRunHistoryId];
          for (var i = 0; i < logs.length; i++) {
              var currLog = logs[i];
              var logLevel = currLog.level;
              var logMessage = currLog.logMessage;

              switch (logLevel.toLowerCase()) {
                  case this.LOG_LEVEL.ERROR.toLowerCase():
                      // filter out IRE error logs as these will be parsed from raw IRE summary logs
                      if (this._isIreErrorLog(logMessage)) {
                          break;
                      }
                      currLog.category = this.CONST.OTHER_CATEGORY;
                      errorLogs.push(currLog);
                      break;
                  case this.LOG_LEVEL.WARNING.toLowerCase():
                      // filter out IRE warning logs as these will be parsed from raw IRE summary logs
                      if (this._isIreWarningLog(logMessage)) {
                          break;
                      }
                      currLog.category = this.CONST.OTHER_CATEGORY;
                      warningLogs.push(currLog);
                      break;
                  case this.LOG_LEVEL.INFO.toLowerCase():
                      // filter out IRE warning logs as these will be parsed from raw IRE summary logs
                      if (this._isIreWarningLog(logMessage)) {
                          break;
                      }
                      // parse warning and errors from raw IRE summary log
                      if (this._isIreRawSummaryLog(logMessage)) {
                          var parsedLog = this._parseWarningAndErrorFromIreSummaryLog(currLog);
                          var errors = parsedLog.errors;
                          var warnings = parsedLog.warnings;
                          if (errors.length === 0 && warnings.length === 0) {
                              activityLogs.push(currLog);
                          } else {
                              for (var j = 0; j < errors.length; j++) {
                                  errorLogs.push(errors[j]);
                              }
                              for (var k = 0; k < warnings.length; k++) {
                                  warningLogs.push(warnings[k]);
                              }
                          }
                      } else {
                          activityLogs.push(currLog);
                      }
                      break;
                  default:
                      activityLogs.push(currLog);
                      break;
              }
          }
          result[currRunHistoryId] = {};
          result[currRunHistoryId].error = errorLogs;
          result[currRunHistoryId].warning = warningLogs;
          result[currRunHistoryId].activity = activityLogs;
      }

      return result;
  },

  _isIreRawSummaryLog: function(logMessage) {
      return logMessage.startsWith(this.CONST.IRE_SUMMARY_LOG_PREFIX);
  },

  _isIreErrorLog: function(logMessage) {
      return logMessage.startsWith(this.CONST.IRE_ERROR_LOG_PREFIX);
  },

  _isIreWarningLog: function(logMessage) {
      return logMessage.startsWith(this.CONST.IRE_WARNING_LOG_PREFIX);
  },

  _parseWarningAndErrorFromIreSummaryLog: function(log) {
      var result = {
          errors: [],
          warnings: []
      };
      var logMessage = log.logMessage;
      var firstColonIndex = logMessage.indexOf(':');
      var ireSummaryPayload = JSON.parse(logMessage.substring(firstColonIndex + 1, logMessage.length).trim());
      var resultClasses = Object.keys(ireSummaryPayload);
      for (var i = 0; i < resultClasses.length; i++) {
          var currentClass = resultClasses[i];
          var currentClassSummary = ireSummaryPayload[currentClass];
          if (currentClassSummary.errors.length > 0) {
              for (var j = 0; j < currentClassSummary.errors.length; j++) {
                  var currentError = currentClassSummary.errors[j];
                  var errorLog = this._createIreLog(this.LOG_LEVEL.ERROR, currentClass, currentError, log);
                  result.errors.push(errorLog);
              }
          }
          if (currentClassSummary.warnings.length > 0) {
              for (var k = 0; k < currentClassSummary.warnings.length; k++) {
                  var currentWarning = currentClassSummary.warnings[k];
                  var warningLog = this._createIreLog(this.LOG_LEVEL.WARNING, currentClass, currentWarning, log);
                  result.warnings.push(warningLog);
              }
          }
      }
      return result;
  },

  _createIreLog: function(level, currentClass, parsedSummaryObj, originalLog) {
      var ireLog = {};
      ireLog.created = originalLog.created;
      ireLog.source = originalLog.source;
      ireLog.level = level;
      ireLog.logMessage = originalLog.logMessage;
      ireLog.category = parsedSummaryObj.error;
  	ireLog.classname = currentClass;
  	ireLog.message = this._cleanIREMessage(parsedSummaryObj.message);
      return ireLog;
  },

  _cleanIREMessage: function(message) {
      // Remove the leading number.
      message = message.replace(/^\d+:\s*/, "");
      // Some errors have two sentences. The second sentence isn't unique.
      if (message.indexOf(". ") > 0) {
          message = message.substring(0, message.indexOf(". ") + 1);
      }
  	return message;
  },

  type: 'CMDBIntegrationStudioImportLogUtils'
};

Sys ID

04bec511eb61301094bbb5d5d85228bc

Offical Documentation

Official Docs: