Prints out the given log message with the color due to its type

 @param [String] message
 @param [Symbol] type
557438
def log(message, type = nil)
      unless Alchemy::Shell.silenced?
        case type
        when :skip
          puts "#{color(:yellow)}== Skipping! #{message}#{color(:clear)}"
        when :error
          puts "#{color(:red)}!! ERROR: #{message}#{color(:clear)}"
        when :message
          puts "#{color(:clear)}#{message}"
        else
          puts "#{color(:green)}== #{message}#{color(:clear)}"
        end
      end
    end
717179
def __PrintMessageDocstringLines(self, message_type):
        """"""
        description = message_type.description or '%s message type.' % (
            message_type.name)
        short_description = (
            _EmptyMessage(message_type) and
            len(description) < (self.__printer.CalculateWidth() - 6))
        with self.__printer.CommentContext():
            if short_description:
                # Note that we use explicit string interpolation here since
                # we're in comment context.
                self.__printer('r"""%s"""' % description)
                return
            for line in textwrap.wrap('r"""%s' % description,
                                      self.__printer.CalculateWidth()):
                self.__printer(line)

            PrintIndentedDescriptions(self.__printer, message_type.enum_types,
                                      'Enums')
            PrintIndentedDescriptions(
                self.__printer, message_type.message_types, 'Messages')
            PrintIndentedDescriptions(
                self.__printer, message_type.fields, 'Fields')
            self.__printer('"""')
            self.__printer()
267101
function Logger_log(message, data, type) {

            if (!this.config.enabled) {
                return;
            }

            if (this.config.types.indexOf(type) === -1) {
                type = 'ALL';
            }

            this.logs.push({
                type: type,
                message: message,
                trace: this.trace(),
                data: this.inspect(data),
                created: new Date().toISOString()
            });

            process.nextTick(this.write.bind(this));
        }
887633
def print_log_for(logs, message, method)
      logs.each do |log|
        public_send(
          method,
          message,
          sticky: false,
          file: log.file,
          line: log.line
        )
      end
    end
246844
def format(message, colour = nil, style = nil)
      c = @map[:colour][colour.to_sym] unless colour.nil?

      if style.nil?
        t = 0
      else
        t = @map[:style][style.to_sym]
      end

      "\e[#{t};#{c}m#{message}\e[0m"
    end
569753
def warning(message):
	'''  '''

	import lltk.config as config
	if config['warnings']:

		try:
			from termcolor import colored
		except ImportError:
			def colored(message, color):
				return message

		print colored('@LLTK-WARNING: ' + message, 'red')
437010
function log(type, args, color){
  pad();
  var msg = format.apply(format, args);
  if (color) msg = chalk[color](msg);
  var pre = prefix();
  console[type](pre, msg);
}
951779
async def message(self, msg, msg_type=None):
        
        elem_type = msg_type if msg_type is not None else msg.__class__

        if hasattr(elem_type, 'blob_serialize'):
            msg = elem_type() if msg is None else msg
            return await msg.blob_serialize(self)

        fields = elem_type.f_specs()
        for field in fields:
            await self.message_field(msg=msg, field=field)

        return msg
538740
function log(type, label, data) {
	var typeLabel = type.charAt(0).toUpperCase() + type.slice(1);
	var color;

	if (typeLabel === 'Error') {
		typeLabel = chalk.red(typeLabel);
		color = 'red';
	} else if (typeLabel === 'Warn') {
		typeLabel = chalk.yellow(typeLabel);
		color = 'yellow';
	} else if (typeLabel === 'Info') {
		typeLabel = chalk.green(typeLabel);
		color = 'green';
	} else if (typeLabel === 'Log') {
		typeLabel = chalk.gray(typeLabel);
		color = 'gray';
	}

	// used to avoid logging "undefined" in the console
	if (useTypeLabels) {
		label = typeLabel + ': ' + chalk.cyan(label);
	} else {
		label = chalk[color](label);
	}
	if (data) {
		console[type](label, data);
	} else {
		console[type](label);
	}
}
808569
function _log(type, message){
		var _debugger = $('div.lcars-debug pre');
		if( type == 'log' ){
			var message = '<span style="background:transparent;color:black">'+message+'</span>';
			_debugger.append(message+'<br>');
		}
		else if( type == 'warning' ){
			var message = '<span style="background:orange;color:black;">'+message+'</span>';
			_debugger.append(message+'<br>');
		}
		else if( type == 'error' ){
			var message = '<span style="background:#f00;color:white;font-weight:bold;">'+message+'</span>';
			_debugger.append(message+'<br>');
		}
		else if( type == 'info' ){
			var message = '<span style="background:#99f;color:white;">'+message+'</span>';
			_debugger.append(message+'<br>');
		}
		else{
			_debugger.append('<span style="background:#f00;color:white;font-weight:bold;">Unknown!</span><br>');
		}
}
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
421612
def print_with_header(header, message, color, indent=0):
    
    print()
    padding = ' ' * indent
    print(padding + color + BOLD + header + ENDC + color + message + ENDC)
1321405
def format(self, record):
        # type: (logging.LogRecord) -> str
        
        if record.levelno >= logging.ERROR:
            color = colorama.Fore.RED
        elif record.levelno >= logging.WARNING:
            color = colorama.Fore.YELLOW
        elif record.levelno >= logging.INFO:
            color = colorama.Fore.RESET
        else:
            color = colorama.Fore.CYAN
        format_template = (
            '{}{}%(levelname)s{} [%(asctime)s][%(name)s]{} %(message)s')
        if sys.stdout.isatty():
            self._fmt = format_template.format(
                colorama.Style.BRIGHT,
                color,
                colorama.Fore.RESET,
                colorama.Style.RESET_ALL
            )
        else:
            self._fmt = format_template.format(*[''] * 4)
        if six.PY3:
            self._style._fmt = self._fmt  # pylint: disable=protected-access
        return super(_LogColorFormatter, self).format(record)
839744
function format (type, msg, typeColor, msgColor) {
  type = type || '';
  msg = msg || '';
  typeColor = typeColor || 'blue';
  msgColor = msgColor || 'grey';
  type = pad(type, 12);
  return type[typeColor] + ' · ' + msg[msgColor];
}
1225531
def nni_log(log_type, log_message):
    ''''''
    dt = datetime.now()
    print('[{0}] {1} {2}'.format(dt, log_type.value, log_message))
195851
def msg_debug(message):
    
    if _log_lvl == logging.DEBUG:
        to_stdout(" (*) {message}".format(message=message), colorf=cyan)
        if _logger:
            _logger.debug(message)
170493
function log (type) {
  return (...message) => {
    if (!message.length) {
      return
    }

    const { colorFn, icon } = getColorFnAndIconByType(type)
    const output = ['']

    message.forEach((item, index) => {
      if (index === 0) {
        output.push(`  ${icon} ${item}`)
        return
      }

      output.push(`    ${item}`)
    })

    output.push('')

    console.log(colorFn(output.join('\n')))
  }
}