Writes given message to logger handlers.

        :param message: Message.
        :type message: unicode
        :return: Method success.
        :rtype: bool
548861
def write(self, message):
        

        for handler in self.__logger.__dict__["handlers"]:
            handler.stream.write(message)
        return True
145160
def on_message(self, handler, msg):
        
        if self.remote_debugging:
            #: Forward to other clients
            for h in self.handlers:
                if h != handler:
                    h.write_message(msg, True)
        else:
            print(msg)
680370
void logError(final String message) {
      if(logger != null) {
         try {
            StringBuilder buf = new StringBuilder(name);
            buf.append(":");
            buf.append(message);
            logger.error(buf.toString());            
         } catch(Throwable t) {
            //Ignore - logging should not kill anything
         }
      }
   }
509543
def msg(message):
    
    to_stdout(" --- {message}".format(message=message))
    if _logger:
        _logger.info(message)
901965
def log_to_file(self, message):
        """"""

        with self.build_fs.open(self.log_file, 'a+') as f:
            f.write(unicode(message + '\n'))
938638
def _log(self, message):
        
        self._logger.debug("{}: {}".format(self.name, message))
864287
def error(self, message):
        
        if Settings.ErrorLogs:
            self._write_log("error", Settings.LogTime, message)
1097796
def log(self, message, level=None):
        
        if level is None:
            level = logging.INFO

        current_app.logger.log(msg=message, level=level)
776168
async def _process_message(self, message):
        
        self._pending_ack.add(message.msg_id)
        handler = self._handlers.get(message.obj.CONSTRUCTOR_ID,
                                     self._handle_update)
        await handler(message)
109229
def notify(self, message):
        
        for regex, handler in self.dispatch.items():
            match = re.search(regex, message)
            if match:
                handler = getattr(self, handler)
                return handler(match)
825443
def write_to_console(self, message: str):
        
        if not self._step:
            raise ValueError(
                'Cannot write to the console stdout on an uninitialized step'
            )
        interceptor = self._step.report.stdout_interceptor
        interceptor.write_source('{}'.format(message))
668184
def error(self, message, *args, **kwargs):
        
        self._log(logging.ERROR, message, *args, **kwargs)
198584
def print_message(self, message="heya!"):
        
        if self.log == None: print(message)
        else:                self.log.append_text(message)
243956
def ping(self, message=None):
        '''
        '''
        return self.write(self.parser.ping(message), encode=False)
431
def write(self, msg):
        
        ser = msg.SerializeToString()
        header = struct.pack(">HL", mapping.get_type(msg), len(ser))
        self._write(b"##" + header + ser, msg)
435379
def write(self, msg, level=logging.INFO):
        
        if msg is not None and len(msg.strip()) > 0:
            self.logger.log(level, msg)
932780
def indent(self, message):
        
        indent = self.indent_char * self.indent_size
        return indent + message