Log any one or more of a message, an exception and structured data as ERROR.
 @return [Boolean] true
 @see Logging#debug
350909
def error(message = nil, ex = nil, data = nil, &block)
      log(ERROR, message, ex, data, block)
    end
1149228
def log!(action)
      case action
      when :started
        Logger.info "Performing Backup for '#{label} (#{trigger})'!\n" \
            "[ backup #{VERSION} : #{RUBY_DESCRIPTION} ]"

      when :finished
        if exit_status > 1
          ex = exit_status == 2 ? Error : FatalError
          err = ex.wrap(exception, "Backup for #{label} (#{trigger}) Failed!")
          Logger.error err
          Logger.error "\nBacktrace:\n\s\s" + err.backtrace.join("\n\s\s") + "\n\n"

          Cleaner.warnings(self)
        else
          msg = "Backup for '#{label} (#{trigger})' "
          if exit_status == 1
            msg << "Completed Successfully (with Warnings) in #{duration}"
            Logger.warn msg
          else
            msg << "Completed Successfully in #{duration}"
            Logger.info msg
          end
        end
      end
    end
1298964
def fatal(message = nil, ex = nil, data = nil, &block)
      log(FATAL, message, ex, data, block)
    end
233957
@SuppressWarnings("unchecked") 
   private static boolean isDebugEnabled()
   {
      if (logging != null)
      {
         try
         {
            Class<?> clz = logging.getClass();
            Method mIsDebugEnabled = clz.getMethod("isDebugEnabled", (Class[])null);
            return ((Boolean)mIsDebugEnabled.invoke(logging, (Object[])null)).booleanValue();
         }
         catch (Throwable t)
         {
            // Nothing we can do
         }
      }
      return true;
   }
777721
def error(message, url, line, column, key)
      @procs[:html_parser].each { |handler| handler.call(message, url, line, column, key) }
    end
373633
def info(message = nil, ex = nil, data = nil, &block)
      log(INFO, message, ex, data, block)
    end
506871
def logdebug(logger, msg, *args, **kwargs):
    '''
    
    '''
    if esgfpid.defaults.LOG_DEBUG_TO_INFO:
        logger.info('DEBUG %s ' % msg, *args, **kwargs)
    else:
        logger.debug(msg, *args, **kwargs)
696294
def log_error(self, msg):
        
        if self.__logger:
            self.__logger.error(msg)

        raise RuntimeError(msg)
668184
def error(self, message, *args, **kwargs):
        
        self._log(logging.ERROR, message, *args, **kwargs)
887633
def print_log_for(logs, message, method)
      logs.each do |log|
        public_send(
          method,
          message,
          sticky: false,
          file: log.file,
          line: log.line
        )
      end
    end
664187
def error(self, message, set_error_state=False):
        
        if set_error_state:
            if message not in self._errors:
                self._errors.append(message)

            self.set_error_state()

        self.logger.error(message)
175188
def error_rendering(exception, symbol)
      Rails.logger.error exception

      @exception = exception
      @symbol = symbol
      @code = Rack::Utils::SYMBOL_TO_STATUS_CODE[symbol].to_i
      respond_with @exception, status: @code, template: ERROR_PATH, prefixes: _prefixes
    end
805943
def log(msg, log_level = :debug, force_raise_error = false)
      log("Log level not allowed: '#{log_level}", :error) if !allowed_log_level?(log_level)

      if log_enabled? and log_this?(log_level)
        @log_file ||= FileOps.new(JSONdb.settings.log_folder, JSONdb.settings.log_file, 'log', false)
        @log_file.write_line("#{Time.now} #{log_level.to_s.upcase} #{self.class.to_s} #{msg}")
        puts "#{Time.now} #{log_level.to_s.upcase} #{self.class.to_s}: #{msg} " if JSONdb.settings.verbose
      end
      raise "#{log_level.to_s.upcase} #{self.class.to_s} #{msg}" if (JSONdb.settings.raise_errors == true or force_raise_error == true) and log_level == :error 
    end
1168502
def error(message)
      length = (position > 0 ? Tokenizer.query(symbols[0..(position - 1)]).size + 1 : 0)
      raise "parsing query failed\n#{message}\n\n#{Tokenizer.query(symbols)}\n#{' ' * length}^"
    rescue
      logger.error $!
      raise $!
    end
1277105
def log(level, message = nil)
      level, message = :info, level if message.nil?
      Resqued::Logging.logger.send(level, self.class.name) { message }
    end
759250
def error(cls, message, prefix=True, traceflag=False):
        
        # print (message, prefix)
        message = message or ""
        if prefix:
            text = "ERROR: "
        else:
            text = ""
        if cls.color:
            cls.cprint('FAIL', text, str(message))
        else:
            print(cls.txt_msg(text + str(message)))

        if traceflag and cls.debug:
            trace = traceback.format_exc().strip()
            if trace:
                print()
                print("Trace:")
                print("\n    ".join(str(trace).splitlines()))
                print()
462985
def error(msg)
      msg = "Error in BigArray node @#{@_id}: #{msg}\n" + @tree.to_s
      $stderr.puts msg
      PEROBS.log.error msg
    end