Publish `message` with the `level` the redis `channel`.

    :param level: the level of the message
    :param message: the message you want to log
487304
def log(level, message):
    
    if redis_instance is None:
        __connect()

    if level not in __error_levels:
        raise InvalidErrorLevel('You have used an invalid error level. \
                Please choose in: ' + ', '.join(__error_levels))
    if channel is None:
        raise NoChannelError('Please set a channel.')
    c = '{channel}.{level}'.format(channel=channel, level=level)
    redis_instance.publish(c, message)
756035
def publish(self, message, channel=None):
        
        if not self.master:
            return
        channel = channel or ''
        data = json.dumps(message)
        self.publisher.send_string("%s %s" % (channel, data))
407576
public static function log($level, $message, array $context = [], string $channel = self::DEFAULT_CHANNEL): void
    {
        self::getLoggerForChannel($channel)->log($level, $message, $context);
    }
912334
def publish(self, channel, message, pipeline=False):
        
        if pipeline:
            self._pipeline.publish(channel, message)
        else:
            self._db.publish(channel, message)
699168
def log(self, msg, level=INFO):
        
        logger.log(level, '<{}> - '.format(self._name) + msg)
404934
def add_status_message(self, message, level="info"):
        
        return self.context.plone_utils.addPortalMessage(message, level)
1129711
def print_input message, level=:debug
      return if LEVELS.index(level) > LEVELS.index(@@log_level)
      puts format_lhs("", "", "<") + message, :default
    end
694764
public void log(Level level, String loggerFqcn, Object message, Throwable t) {
        doLog(level, loggerFqcn, message, null, t);
    }
1236928
public static void log(final Level level, final String message) {
		System.err.println("LOGGER " + level + ": " + message);
	}
256880
def show_logging(level=logging.INFO):
    
    logger = logging.getLogger()

    h = logging.StreamHandler(stream=sys.stderr)
    h.setFormatter(logging.Formatter(fmt="[%(levelname)-8s] %(name)s: %(message)s"))

    logger.addHandler(h)
    logger.setLevel(level)
624381
def log(self, level, message):
        
        if level <= self._debug_level:
            self._write_log("debug", Settings.LogTime, message)
31892
async def publish(self, message):
        
        try:
            self.write_message(dict(data=message))
        except WebSocketClosedError:
            self._close()
1367485
public static void log(Level level, String message) {
        Logger.getLogger("LEX4J").log(level, message);
    }
976021
public function log($level, $message, array $context = array())
    {
        if (!$this->canLog($level)) {
            return;
        }
        $levelCode = $this->levelCode[$level];
        $data = $this->message->process($levelCode, $level, $message, $context);
        foreach ($this->channels as $channel) {
            $channel->deliver($level, $data);
        }
    }
1281260
private static function log(string $message, int $level) {
        \Logger::configure(self::getConfiguration());
        $logger = \Logger::getRootLogger();
        $logger->setLevel(self::getLoggerLevel());

        switch ($level) {
            case Logger::DEBUG:
                $logger->debug($message);
                break;
            case Logger::INFO:
                $logger->info($message);
                break;
            case Logger::WARN:
                $logger->warn($message);
                break;
            case Logger::ERROR:
                $logger->error($message);
                break;
            case Logger::FATAL:
                $logger->fatal($message);
                break;
            case Logger::TRACE:
                $logger->trace($message);
                break;
            default:
        }
    }
751643
def send(self, message, level=Level.NOTICE):
    ""
    data = "<%d>%s" % (level + self.facility*8, message)
    if self.protocol == 'UDP':
        self.socket.sendto(data.encode('utf-8'), (self.host, self.port))
    else:
        self.socket.send(data.encode('utf-8'))
1130013
public static void log(Logger logger,
                           Level level,
                           String message,
                           Object parameter) {
        log(logger, level, message, new Object[] { parameter });
    }