log the message to the log
483387
def _dlog(self, msg, indent_increase=0):
        """"""
        self._log.debug("interp", msg, indent_increase, filename=self._orig_filename, coord=self._coord)
1312845
static void log(Object targetObj, String msg) {
        if (EventsParams.isDebug()) {
            Log.d(TAG, toLogStr(targetObj, msg));
        }
    }
1246151
def log_(
    message: str,
    logger: logging.Logger,
    level: int = logging.INFO,
    extra: Optional[Dict] = None,
    trim: bool = False,
) -> None:
    
    if extra is None:
        extra = {}
    # Clean up the message for logging
    if message:
        message = message.replace("\n", "").replace("  ", " ").replace("{ ", "{")
    if trim:
        message = _trim_message(message)
    # Log.
    logger.log(level, message, extra=extra)
591922
def log(self, level, msg=None, *args, **kwargs):
        """"""

        return self._log(level, msg, args, kwargs)
684345
def log(_self, _level, _message, *args, **kwargs):
        """
        logger = _self.opt(
            exception=_self._exception,
            record=_self._record,
            lazy=_self._lazy,
            ansi=_self._ansi,
            raw=_self._raw,
            depth=_self._depth + 1,
        )
        logger._make_log_function(_level)(logger, _message, *args, **kwargs)
1207353
def log(self, message, type='notice'):
        
        if self.logger and not callable(self.logger):
            raise ValueError(u"Invalid logger set, must be a callable")
        if self.verbose and self.logger:
            self.logger(message, type)
522678
def log(self, *args):
        """"""
        print("%s %s" % (str(self).ljust(8), " ".join([str(x) for x in args])))
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()
760191
def log(message, type):
    """"""

    (sys.stdout if type == 'notice' else sys.stderr).write(message + "\n")
31676
def log(self, *msg, sep='', end='\n', flush=False):
        """"""
        if not self.quiet:
            print(*msg, sep=sep, end=end, flush=flush)
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;
}
1119821
def log(self):
        '''
        
        '''

        log = self._log(num=10, format='%h::%b').get('stdout')
        if log:
            return [
                dict(commit=c, message=m) for c, m in [
                    l.split('::') for l in log
                ]
            ]
819323
def dump(cls, message):
        
        if cls.verbose > 2:
            msg = '[DUMP] %s' % message
            cls.echo(msg)
1310757
function logMessage (message) {
  if (!process.send) {
    console.log(message)
  } else {
    process.send(message)
  }
}
1314833
def _log(self, message, severity=Logger.DEBUG):
        
        return self.logger.log(message, severity, self.TAG)
1095351
def log(self, message, level='info'):
        
        getattr(self.logger, level)('[%s] %s' % (self.id, message))
1183877
def write_log(self, message):
        
        if self._is_write_log and self.log_file and not self.log_file.closed:
            self.log_file.write(message + '\n')