Log a regular message

    :param message: the message to be logged
509543
def msg(message):
    
    to_stdout(" --- {message}".format(message=message))
    if _logger:
        _logger.info(message)
682703
def _log_message(self, level, process_name, timeperiod, msg):
        
        self.timetable.add_log_entry(process_name, timeperiod, msg)
        self.logger.log(level, msg)
325094
def log(self, msg):
        '''
        '''
        if self.logfile:
            fd = self.logfile.fileno()
        else:
            fd = sys.stdout.fileno()

        os.write(fd, ('%.3f %s\n' % (time.time(), msg)).encode('UTF-8'))
835274
def log(message)
      if verbose
        puts "*** #{message}"
      elsif very_verbose
        time = Time.now.strftime('%H:%M:%S %Y-%m-%d')
        puts "** [#{time}] #$$: #{message}"
      end
    end
932780
def indent(self, message):
        
        indent = self.indent_char * self.indent_size
        return indent + message
1201935
void logDebug(final String message) {
      if(logger != null) {
         try {
            StringBuilder buf = new StringBuilder(name);
            buf.append(": ");
            buf.append(message);
            logger.debug(buf.toString());
         } catch(Throwable t) {
            //Ignore - logging should not kill anything
         }
      }
   }
1326150
public void log(final String _message,
                    final int _level)
    {
        switch (_level)  {
            case 4:
                if (IvyOverSLF4JLogger.LOG.isDebugEnabled())  {
                    IvyOverSLF4JLogger.LOG.debug(_message);
                }
                break;
            case 3:
                if (IvyOverSLF4JLogger.LOG.isWarnEnabled())  {
                    IvyOverSLF4JLogger.LOG.warn(_message);
                }
                break;
            case 2:
                if (IvyOverSLF4JLogger.LOG.isInfoEnabled())  {
                    IvyOverSLF4JLogger.LOG.info(_message);
                }
                break;
            case 1:
                if (IvyOverSLF4JLogger.LOG.isErrorEnabled())  {
                    IvyOverSLF4JLogger.LOG.error(_message);
                }
                break;
            default:
                IvyOverSLF4JLogger.LOG.error("unknown log level " + _level);
                IvyOverSLF4JLogger.LOG.error(_message);
        }
    }
437094
def log(self, msg):
        ""
        if not isinstance(msg, unicode):
            msg = unicode(msg, 'utf8', 'ignore')
        if not self.Log:
            self.Log = StringIO()
        self.Log.write(msg)
        self.Log.write('\n\r')
        if DEBUG:
            warnings.warn(msg)
816150
public void log(final String message) {
		if (!SwingUtilities.isEventDispatchThread()) {
			SwingUtilities.invokeLater(new Runnable() {
				@Override
				public void run() {
					log(message);
				}
			});
		} else {
			log.append(message);
		}
	}
333506
def showMessage(self, level, message):
        
        self.uiFeedbackLBL.setText(message)
        self.uiLoggerEDIT.log(level, message)
1189439
def logv(msg, *args, **kwargs):
    
    if settings.VERBOSE:
        log(msg, *args, **kwargs)
870750
def _log(message):
        
        #  @todo Replace with log package.
        print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()) + ' ' + str(message), flush=True)
724058
def log_message(level, message)
      if logger.respond_to?(:tagged)
        logger.tagged(TAG_NAME) { |l| l.public_send(level, message) }
      else
        logger.public_send(level, message)
      end
    end
129212
def _log_msg(self, msg, ok):
        ''''''
        if self._config['color']:
            CGREEN, CRED, CEND = '\033[92m', '\033[91m', '\033[0m'
        else:
            CGREEN = CRED = CEND = ''

        LOG_LEVELS = {False: logging.ERROR, True: logging.INFO}

        # pylint: disable=logging-not-lazy
        L.log(LOG_LEVELS[ok],
              '%35s %s' + CEND, msg, CGREEN + 'PASS' if ok else CRED + 'FAIL')
306211
public static synchronized void log(RTMessage message)
	{
		if (enabled)
		{
			eventCount++;

			for (IRTLogger logger : loggers)
			{
				logger.log(message);
			}
		}
	}
728867
public function log($message)
	{
		if($this->logLevel == self::LOG_NORMAL) {
			fwrite(STDOUT, "*** " . $message . "\n");
		}
		else if($this->logLevel == self::LOG_VERBOSE) {
			fwrite(STDOUT, "** [" . strftime('%T %Y-%m-%d') . "] " . $message . "\n");
		}
	}
1190451
async def dump_message(self, msg, msg_type=None):
        
        mtype = msg.__class__ if msg_type is None else msg_type
        fields = mtype.f_specs()
        for field in fields:
            await self.message_field(msg=msg, field=field)