Emitted when a node calls the pytest_logwarning hook.
553720
def worker_warning_captured(self, warning_message, when, item):
        """"""
        kwargs = dict(warning_message=warning_message, when=when, item=item)
        self.config.hook.pytest_warning_captured.call_historic(kwargs=kwargs)
1169994
def warning(self, message, *args, **kwargs):
        """"""
        self.log("warn", message, *args, **kwargs)
876488
function Logger() {
  this._level = LEVELS.NOTICE;
  this._out = process.stdout;
  this._err = process.stderr;

  /* istanbul ignore next: allow server to suppress logs */
  if(process.env.NODE_ENV === Constants.TEST && !process.env.TEST_DEBUG) {
    this.log = function noop(){};
  }
}
337443
def alert(self, msg):
        """"""
        if self.event_callback is not None:
            try:
                self.event_callback(msg)
            except Exception as exception:  # pylint: disable=broad-except
                _LOGGER.exception(exception)

        if self.persistence:
            self.persistence.need_save = True
609095
def warn(self, msg, *args, **kwargs):
    """"""
    if six.PY3:
      warnings.warn("The 'warn' method is deprecated, use 'warning' instead",
                    DeprecationWarning, 2)
    self.log(logging.WARN, msg, *args, **kwargs)
1148720
def redirect_warnings(capture=True, logger='py.warnings'):
    
    global _warnings_showwarning
    if capture:
        assert _warnings_showwarning is None
        _warnings_showwarning = warnings.showwarning
        # `warnings.showwarning` must be a function, a generic
        # callable object is not accepted ...
        warnings.showwarning = _WarningsLogger(logger, format_warning_oneline).__call__
    else:
        assert _warnings_showwarning is not None
        warnings.showwarning = _warnings_showwarning
        _warnings_showwarning = None
844315
def a_message_callback(ctx):
    """"""
    message = ctx.ctrl.after.strip().splitlines()[-1]
    ctx.device.chain.connection.emit_message(message, log_level=logging.INFO)
    return True
624046
def _warning(self, msg, node_id, ex, *args, **kwargs):
        

        raises = self.raises(ex) if callable(self.raises) else self.raises

        if raises and isinstance(ex, DispatcherError):
            ex.update(self)
            raise ex

        self._errors[node_id] = msg % ((node_id, ex) + args)
        node_id = '/'.join(self.full_name + (node_id,))

        if raises:
            raise DispatcherError(msg, node_id, ex, *args, sol=self, **kwargs)
        else:
            kwargs['exc_info'] = kwargs.get('exc_info', 1)
            log.error(msg, node_id, ex, *args, **kwargs)
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)
1222278
function Logger(pipeline, suppressErrors) {
        this.suppressErrors = true;
        this.pipeline = pipeline;
        this.suppressErrors = typeof suppressErrors === 'undefined' || suppressErrors;
    }
1090616
public static void warn(Logger log, String methodName) {
        if (log.isWarnEnabled())
            log.warn(buildMethodLogString(methodName));
    }
149811
def _log(self, message, stream, color=None, newline=False):
        '''
        
        '''

        if color and self.color_term:
            colorend = Logger.COLOR_END
        else:
            color = colorend = ''

        stream.write('{color}{message}{colorend}\n'.format(
            color=color,
            message=message,
            colorend=colorend
        ))

        if newline:
            sys.stdout.write('\n')

        stream.flush()
911036
def log_message(self, kind, alert):
        """"""
        if kind == 'ERROR':
            logging.error(alert)
        else:
            logging.warning(alert)
        return
377625
function log(msg, type) {
	switch (type) {
	case 'error':
		fancyLog(`${PLUGINNAME}: ${colors.red(`Error, ${msg}`)}`);
		break;

	case 'warn':
		fancyLog(`${PLUGINNAME}: ${colors.yellow(`Warning, ${msg}`)}`);
		break;

	case 'info':
		fancyLog(`${PLUGINNAME}: ${colors.green(`Info, ${msg}`)}`);
		break;

	default:
		fancyLog(`${PLUGINNAME}: ${colors.green(`Info, ${msg}`)}`);
		break;
	}

}
250689
function log(message, level) {
    var prefix = "[" + colors.cyan("gulp-tslint") + "]";
    if (level === "error") {
        fancyLog(prefix, colors.red("error"), message);
    }
    else {
        fancyLog(prefix, message);
    }
}
1254240
def on_raise(self, node):    # ('type', 'inst', 'tback')
        """"""
        if version_info[0] == 3:
            excnode = node.exc
            msgnode = node.cause
        else:
            excnode = node.type
            msgnode = node.inst
        out = self.run(excnode)
        msg = ' '.join(out.args)
        msg2 = self.run(msgnode)
        if msg2 not in (None, 'None'):
            msg = "%s: %s" % (msg, msg2)
        self.raise_exception(None, exc=out.__class__, msg=msg, expr='')
1327474
def log_warning(self, msg):
        
        if self.__logger:
            self.__logger.warning(msg)

        if self.__raise_exception_on_warning:
            raise RuntimeError(msg)