Logs event error
337890
static void logE(String eventKey, String msg) {
        Log.e(TAG, toLogStr(eventKey, msg));
    }
945937
public void error(String msg, Throwable e) {
        doLog(msg, LOG_ERROR, null, e);
    }
1314016
def safe_log_error(self, error: Exception, *info: str):
        """"""
        self.__do_safe(lambda: self.logger.error(error, *info))
266874
static SimpleLogEvent error(Logger logger, RuntimeException error, LogData data) {
    return new SimpleLogEvent(logger, error, data);
  }
563121
def log_error(cls, msg):
        
        cls.error_logger.error(msg)
        cls.debug_logger.debug(msg)
1175615
def log_events
      logger = Logging.logger[target.name]
      if (logs = value.dig('report', 'logs'))
        logs.each do |log|
          case log["level"]
          when 'err'
            logger.error(log['message'])
          when 'warn'
            logger.info(log['message'])
          when 'notice'
            logger.notice(log['message'])
          when 'info'
            logger.info(log['message'])
          else
            logger.debug(log["message"])
          end
        end
      end
    end
188942
function logEvents(crafty) {
  const loggedErrors = [];
  crafty.undertaker.on("start", evt => {
    crafty.log.info(`Starting '${chalk.cyan(evt.name)}' ...`);
  });
  crafty.undertaker.on("stop", evt => {
    const time = prettyTime(evt.duration);
    crafty.log.info(
      `Finished '${chalk.cyan(evt.name)}' after ${chalk.magenta(time)}`
    );
  });
  crafty.undertaker.on("error", evt => {
    const time = prettyTime(evt.duration);
    const level = evt.branch ? "info" : "error";
    crafty.log[level](
      `'${chalk.cyan(evt.name)}' ${chalk.red("errored after")} ${chalk.magenta(
        time
      )}`
    );
    // If we haven't logged this before, log it and add to list
    if (loggedErrors.indexOf(evt.error) === -1) {
      crafty.log.error(formatError(evt));
      loggedErrors.push(evt.error);
    }
  });
}
1215731
def log_event(event, logger=root_logger, **log_dict):
    
    msg = "event={}".format(event)
    msg = add_items_to_message(msg, log_dict)
    log_dict.update({'event': event})
    logger.info(msg, extra=log_dict)
176443
function (errors, throwsErrors) {
                if (errors.length === 0) {
                    return true;
                }
                if (!throwsErrors) {
                    for (var i = 0; i < errors.length; i++) {
                        this.$logError(errors[i].msgId, errors[i].msgArgs);
                    }
                } else {
                    var error, logs = aria.core.Log;
                    // aria.core.Log may not be available
                    if (logs) {
                        var messages = [];
                        for (var i = 0; i < errors.length; i++) {
                            errors[i].message = logs.prepareLoggedMessage(errors[i].msgId, errors[i].msgArgs);
                            messages.push(errors[i].message);
                        }
                        error = new Error(messages.join('\n'));
                    } else {
                        error = new Error();
                    }
                    error.errors = errors;
                    throw error;
                }
                return false;
            }
715186
function logEvents(verbInst) {
  verbInst.on('err', function () {
    failed = true;
  });

  verbInst.on('task_start', function (e) {
    verbLog('starting', '\'' + chalk.cyan(e.task) + '\'');
  });

  verbInst.on('task_stop', function (e) {
    var time = prettyTime(e.hrDuration);
    verbLog('finished', '\'' + chalk.cyan(e.task) + '\'', 'after', chalk.magenta(time));
  });

  verbInst.on('task_err', function (e) {
    var msg = formatError(e);
    var time = prettyTime(e.hrDuration);
    verbLog(chalk.cyan(e.task), chalk.red('errored after'), chalk.magenta(time));
    verbLog(msg);
  });

  verbInst.on('task_not_found', function (err) {
    verbLog(chalk.red('task \'' + err.task + '\' is not in your verbfile'));
    verbLog('please check the documentation for proper verbfile formatting');
    exit(1);
  });
}
696294
def log_error(self, msg):
        
        if self.__logger:
            self.__logger.error(msg)

        raise RuntimeError(msg)
711734
def log_error(self, msg, *args):
        """"""
        if self._logger is not None:
            self._logger.error(msg, *args)
        else:
            print(msg % args)
557966
def log_error(*error, cause=None):
    
    thread_id = threading.current_thread().ident
    text = " ".join(error)
    if cause:
        text += " due to " + str(cause)

    logger = get_logger()
    logger.error(LOG_THREAD_FORMAT.format(thread_id, text))
243003
function sendError (
  event, message, recordName, socketWrapper, onError, options, context, metaData
) {
  options.logger.error(event, message, metaData)
  if (socketWrapper) {
    socketWrapper.sendError(C.TOPIC.RECORD, event, message)
  }
  if (onError) {
    onError.call(context, event, message, recordName, socketWrapper)
  }
}
538550
def log(event = nil, timestamp = Time.now, **fields)
      ts = ::Instana::Util.time_to_ms(timestamp).to_s
      if custom?
        @data[:data][:sdk][:custom][:logs][ts] = fields
        @data[:data][:sdk][:custom][:logs][ts][:event] = event
      else
        set_tags(:log => fields)
      end
    rescue StandardError => e
      Instana.logger.debug "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
    end
997302
function showError(error) {
    console.error(logSymbols.error, "Error");
    console.error(`${error.message}\n`);
    console.error(logSymbols.error, "Stack trace");
    console.error(error.stack);
}
440117
function(msg) {
  if (window.console && window.console.error) {
    window.console.error(msg);
  } else {
    log(msg);
  }
}