display an informational message to the logger, if there is one.
 @yield return a message or hash
767472
def info(msg = nil)
      if @logger
        msg = build_log(msg || yield, ActionCommand::LOG_KIND_INFO)
        @logger.info(format_log(msg))
      end
    end
891097
def info (logname, msg, *args, **kwargs):
    
    log = logging.getLogger(logname)
    if log.isEnabledFor(logging.INFO):
        _log(log.info, msg, args, **kwargs)
1038215
def log(type, message)
      case type.to_sym
      when :info
        msg = message
      when :error
        msg = message
      end

      @messages << msg
      puts msg if verbose?
    end
1103139
public void info(Object message, Throwable t)
    {
        getLogger().info(message.toString(), t);
    }
509543
def msg(message):
    
    to_stdout(" --- {message}".format(message=message))
    if _logger:
        _logger.info(message)
1129711
def print_input message, level=:debug
      return if LEVELS.index(level) > LEVELS.index(@@log_level)
      puts format_lhs("", "", "<") + message, :default
    end
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
343293
def info(message = nil, &block)
      logger.add(Logger::INFO, message, self.logging_prefix, &block)
    end
563070
@Override
    public void info(String format, Object arg) {
        if (logger.isInfoEnabled()) {
            FormattingTuple ft = MessageFormatter.format(format, arg);
            logger.info(ft.getMessage(), ft.getThrowable());
        }
    }
381466
def logger(level = nil)
      unless @logger
        @logger = Logger.new(STDOUT)
        @logger.level = level || Logger::INFO
        @logger.formatter = proc do |severity, _datetime, _progname, msg|
          "#{identity} | " << "#{severity.downcase.capitalize}:".ljust(7) << " #{msg}\n"
        end
      end

      @logger.level = level unless level.nil?
      @logger
    end
1146065
def emit_message(self, message, log_level):
        """"""
        self.log(message)
        if log_level == logging.ERROR:
            if self._error_msg_callback:
                self._error_msg_callback(message)
                return

        if log_level == logging.WARNING:
            if self._warning_msg_callback:
                self._warning_msg_callback(message)
                return

        if log_level == logging.INFO:
            if self._info_msg_callback:
                self._info_msg_callback(message)
                return

        if self._msg_callback:
            self._msg_callback(message)
1243033
def messages(self):
        ''''''

        # the file contains the fixed-size file header followed by
        # fixed-size message structures. start after the file header and
        # then simply return the message structures in sequence until the
        # end of the file.

        offset = self.LENGTH
        while offset < len(self.mmap):
            yield Message(mm=self.mmap, offset=offset)
            offset += Message.LENGTH
477412
def __check_hash(self, message):
        
        return message[W_HASH] == self.__make_hash(message[W_MESSAGE], self.__token, message[W_SEQ])
634886
def message_iter(evt):
        
        for msg in evt:
            if logger.isEnabledFor(log.logging.DEBUG):
                logger.debug(msg.toString())
            if msg.asElement().hasElement('responseError'):
                raise Exception(msg.toString())
            yield msg
68031
def log_message(self, format, *args):
        
        self.log(format, args, logging.INFO)
1118264
def info(self, *args, **kwargs):
        """"""
        self.lock()
        try:
            return logger.info(*args, **kwargs)
        finally:
            self.unlock()
1181827
def unknown(message = nil, ex = nil, data = nil, &block)
      args = block ? yield : [message, ex, data]
      append(UNKNOWN, args)
    end