Whether to log the supplied message based on the current filter if any
554732
def include_message?(log)
      return true if @filter.nil?

      if @filter.is_a?(Regexp)
        !(@filter =~ log.name).nil?
      elsif @filter.is_a?(Proc)
        @filter.call(log) == true
      end
    end
158982
function trackEOL(msg) {
  if (msg === true || Boolean(msg.match(/(\n|\r)$/))) {
    gIn.tracePrefix = '';
  } else {
    gIn.tracePrefix = '\n';
  }
}
122923
def filter(self, record):
        """"""
        fmt = LogManager.spec.context_format
        if fmt:
            data = self.context.to_dict()
            if data:
                record.context = fmt % ",".join("%s=%s" % (key, val) for key, val in sorted(data.items()) if key and val)
            else:
                record.context = ""
        return True
705569
function log(level, message) {
  if(!~map[this._level].indexOf(level)) return false;
  var pid = process.pid
    , time = logtime()
    , args = slice.call(arguments, 1)
    , cb = typeof args[args.length - 1] === 'function'
      ? args.pop() : null
    , stream = level === LEVELS.WARNING ? this._err : this._out;
  var msg = '[' + pid + '] ' + time + ' '
    + getPrefix(level, stream.isTTY) + ' ';

  if(args.length > 1) {
    message = util.format.apply(util, args);
  }else{
    message = args[0];
  }
  msg += message + EOL;
  stream.write(msg, cb);
  return message;
}
25954
def log(cls, message):
        
        if cls.verbose > 0:
            msg = '[INFO] %s' % message
            cls.echo(msg)
375267
def log(self, msg):
        
        self._execActions('log', msg)
        msg = self._execFilters('log', msg)
        self._processMsg('log', msg)
        self._sendMsg('log', msg)
7222
def log(self, msg, *args):
        """"""
        if args:
            msg %= args
        click.echo(msg, file=sys.stderr)
1344498
private void filterLogEvent(final LogEvent logEvent) {
        for ( ILogEventFilter filter: this.filters) {
            // do nothing if one of the filters doesn't accept the event
            if ( !filter.acceptEvent( logEvent ) ) {
                return;
            }
        }
        // if all the filters accepted the event, signal the creation
        // of the event
        logEventCreated( logEvent );
    }
770218
def trace(message = nil, ex = nil, data = nil, &block)
      log(TRACE, message, ex, data, block)
    end
957691
function log (message) {
  if (!global.testing && !global.isModuleUse) {
    console.log(message)
  } else {
    debug(message)
  }
}
218907
def filter(self, record):
        

        def modify(value):
            """
            Modify logged record, truncating it to max length and logging remaining length
            :param value: Record to modify
            :return:
            """
            if isinstance(value, six.string_types):
                if len(value) < ContextFilter.MAXIMUM_LENGTH:
                    return value

                try:
                    return "{}...[{} more bytes]".format(
                        value[:ContextFilter.REVEAL_LENGTH],
                        len(value) - ContextFilter.REVEAL_LENGTH)
                except UnicodeError:
                    return "{}...[{} more bytes]".format(
                        repr(value[:ContextFilter.REVEAL_LENGTH]),
                        len(value) - ContextFilter.REVEAL_LENGTH)
            elif isinstance(value, six.binary_type):
                return "{}...[{} more bytes]".format(
                    repr(value[:ContextFilter.REVEAL_LENGTH]),
                    len(value) - ContextFilter.REVEAL_LENGTH)

            else:
                return value

        record.msg = traverse_json_obj(record.msg, callback=modify)
        return True
1048824
def status_log(func, message, *args, **kwargs):
    """"""

    click.echo(message)
    log = func(*args, **kwargs)

    if log:
        out = []

        for line in log.split('\n'):
            if not line.startswith('#'):
                out.append(line)
        click.echo(black('\n'.join(out)))
1228851
function FilteraddMessage(arg, options) {
  Message.call(this, options);
  this.command = 'filteradd';
  $.checkArgument(
    _.isUndefined(arg) || BufferUtil.isBuffer(arg),
    'First argument is expected to be a Buffer or undefined'
  );
  this.data = arg || BufferUtil.EMPTY_BUFFER;
}
933054
public
  int decide(LoggingEvent event) {
    String msg = event.getRenderedMessage();

    if(msg == null ||  stringToMatch == null)
      return Filter.NEUTRAL;
    

    if( msg.indexOf(stringToMatch) == -1 ) {
      return Filter.NEUTRAL;
    } else { // we've got a match
      if(acceptOnMatch) {
	return Filter.ACCEPT;
      } else {
	return Filter.DENY;
      }
    }
  }
1041192
def log_message(self, msg, *args):
        """"""
        if args:
            msg = msg % args
        self.logger.info(msg)
1363048
def msg(message, *args, **kwargs):
    """"""
    global log_file
    if log_file is None:
        log_file = sys.stderr
    if long_msg:
        file_name, line = caller_trace()
        file_name, file_type = os.path.splitext(file_name)
        if file_name.endswith('/__init__'):
            file_name = os.path.basename(os.path.dirname(file_name))
        elif file_name.endswith('/__main__'):
            file_name = "(-m) {0}".format(
                os.path.basename(os.path.dirname(file_name)))
        else:
            file_name = os.path.basename(file_name)
        head = '{0}{1} ({2}): '.format(file_name, file_type, line)
    else:
        head = '[SERVER] '
    out = StringIO()
    for line in message.format(*args, **kwargs).split('\n'):
        out.write('{0}{1}\n'.format(head, line))
    out.flush()
    out.seek(0)
    if _msg_stderr:
        sys.stderr.write(out.read())
        sys.stderr.flush()
    else:
        log_file.write(out.read())
        log_file.flush()
    out.close()
649354
function (msg,verbosity)
		{
			if (!_debug || verbosity>_verbosity)
				return false;
			this.e.log.apply(this,[msg||'','debug',verbosity||0]);
			return self;
		}