@name info
@memberof logger
@method
@param {Arguments} messages Variable argument message
@example
logger.info('hoge', 'foo', 'bar', 10);

> hoge foo bar 10
162698
function () {
        var prefix = 'INFO';
        this.output(prefix, prefix.green, Array.prototype.slice.call(arguments));
    }
1186324
public final void info(Object message) {

        if (isLevelEnabled(SimpleLog.LOG_LEVEL_INFO)) {
            log(SimpleLog.LOG_LEVEL_INFO, message, null);
        }
    }
1187280
public void info(Marker marker, String format, Object arg) {
        if (!logger.isInfoEnabled(marker))
            return;
        if (instanceofLAL) {
            String formattedMessage = MessageFormatter.format(format, arg).getMessage();
            ((LocationAwareLogger) logger).log(marker, fqcn, LocationAwareLogger.INFO_INT, formattedMessage, new Object[] { arg }, null);
        } else {
            logger.info(marker, format, arg);
        }
    }
1325872
function () {
        const args = [this.chalk.cyan('INFO')].concat(Array.from(arguments));
        return this.log.apply(this, args);
    }
256110
public void info(Object message) {
        differentiatedLog(null, CATEGORY_FQCN, LocationAwareLogger.INFO_INT, message, null);
    }
1090515
function(message, level) {
            level = level || Base.LOGLEVEL.INFO;

            if (message instanceof Error) {
                message = message.toString() + (message.stack || "");
            }

            if (Base.logger.length) {
                for (var i = 0; i < Base.logger.length; i++) {
                    Base.logger[i].log(message, level);
                }
            } else if (typeof console !== "undefined") {
                var method = (console[level] || console.log);
                if(method){
                    try {
                        method.call(console, "[ " + (new Date()) + " ]: ", message);
                    } catch (e) {
                        // nothing to do here
                    }
                }
            }
        }
1365228
protected void info(String message) {
		final Log log = getLog();
		if (log != null)
			log.info(message);
	}
244505
function logMessage(messageType, message) {
  if (Object.values(messageTypes).includes(messageType)) {
    console[messageType](message)
  } else {
    console.info(message)
  }
}
560851
def info(message)
      (m = filter(message, :info)) && each {|l| l.info(m)}
    end
1037433
def info(self, message):
        '''
        
        '''
        return self._log(
            message=message.upper(),
            stream=sys.stdout
        )
145249
function (message, important) {
            /** @type {string} */
            const prefix = 'VarGate SG1 Log:';
            /** @type {Array} */
            let args = [];
            if (window['DEBUG_MODE']) {
                if (typeof message !== 'string' && message.length) {
                    args = message;
                } else {
                    args.push(message);
                }
                args.unshift(prefix);
                try {
                    switch (window['DEBUG_MODE']) {
                        case 'verbose':
                            console['warn'].apply(console, args);
                            break;
                        case 'static':
                            console['warn'].apply(console, JSON.parse(JSON.stringify(args)));
                            break;
                        case 'minimal':
                            if (important) console['warn'].apply(console, args);
                            break;
                        default:
                        // do nothing
                    }
                } catch (e) {
                    // Looks like we can't log anything
                }
            }
        }
812818
public static void i(String tag, String msg, Object... args) {
        if (sLevel > LEVEL_INFO) {
            return;
        }
        if (args.length > 0) {
            msg = String.format(msg, args);
        }
        Log.i(tag, msg);
    }
487393
public void info(Object message, Throwable t) {
        differentiatedLog(null, CATEGORY_FQCN, LocationAwareLogger.INFO_INT, message, t);
    }
772171
def info(self, msg=None, *args, **kwargs):
        """"""

        return self._log(logging.INFO, msg, args, kwargs)
372241
def info(self, message, *args, **kwargs):
        """"""
        self.log("info", message, *args, **kwargs)
249383
function info() {
	if ( env.opts.verbose || env.opts.debug ) {
		console.log.apply(console, arguments);
	}
}
89958
public void info(Enum<?> key, Object... args) {
        if (!logger.isInfoEnabled()) {
            return;
        }
        String translatedMsg = imc.getMessage(key, args);
        MessageParameterObj mpo = new MessageParameterObj(key, args);

        if (instanceofLAL) {
            ((LocationAwareLogger) logger).log(LOCALIZED, FQCN, LocationAwareLogger.INFO_INT, translatedMsg, args, null);
        } else {
            logger.info(LOCALIZED, translatedMsg, mpo);
        }
    }