The method prints the structure of all meta_signal-notifications as log-messages.
130
def observe_meta_signal_changes(self, changed_model, prop_name, info):
        "
        self.logger.info(NotificationOverview(info))
505149
def meta_changed(self, model, prop_name, info):
        
        if self.parent is not None:
            msg = info.arg
            # Add information about notification to the signal message
            notification = Notification(model, prop_name, info)
            msg = msg._replace(notification=notification)
            info.arg = msg
            self.parent.meta_changed(model, prop_name, info)
1340077
def log(self, msg):
        
        if self.master_class and self.instance_class:
            logger.info('{0} - {1} - {2} - {3} - lang: {4} msg: {5}'.format(
                self.ct_master.app_label, self.ct_master.model,
                self.instance_class, self.instance.language_code, self.instance.pk, msg)
            )
        elif self.instance_class:
            logger.info('{} - {}: {}'.format(self.instance_class, self.instance.pk, msg))
        else:
            logger.info('{}'.format(msg))
31676
def log(self, *msg, sep='', end='\n', flush=False):
        """"""
        if not self.quiet:
            print(*msg, sep=sep, end=end, flush=flush)
509543
def msg(message):
    
    to_stdout(" --- {message}".format(message=message))
    if _logger:
        _logger.info(message)
153180
def __db_print(self_,level,msg,*args,**kw):
        
        self_or_cls = self_.self_or_cls
        if get_logger(name=self_or_cls.name).isEnabledFor(level):

            if dbprint_prefix and callable(dbprint_prefix):
                msg = dbprint_prefix() + ": " + msg  # pylint: disable-msg=E1102

            get_logger(name=self_or_cls.name).log(level, msg, *args, **kw)
377973
def print_callback(msg):
    """"""
    json.dump(msg, stdout)
    stdout.write('\n')
    stdout.flush()
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>');
		}
}
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
814338
private void printLog() {
    Logger.Builder builder = new Logger.Builder();

    String tag = tagView.getText().toString();
    if (!TextUtils.isEmpty(tag)) {
      builder.tag(tag);
    }

    if (threadInfo.isChecked()) {
      builder.t();
    } else {
      builder.nt();
    }

    if (stackTraceInfo.isChecked()) {
      builder.st(STACK_TRACE_DEPTHS[stackTraceDepth.getSelectedItemPosition()]);
    } else {
      builder.nst();
    }

    if (border.isChecked()) {
      builder.b();
    } else {
      builder.nb();
    }

    // Print the log to view, logcat and file.
    if (hasPermission) {
      builder.printers(
          viewPrinter,
          new AndroidPrinter(),
          XLogSampleApplication.globalFilePrinter);
    } else {
      builder.printers(
          viewPrinter,
          new AndroidPrinter());
    }

    Logger logger = builder.build();

    int levelPosition = levelView.getSelectedItemPosition();
    int level = LEVELS[levelPosition];
    switch (level) {
      case LogLevel.VERBOSE:
        logger.v(MESSAGE);
        break;
      case LogLevel.DEBUG:
        logger.d(MESSAGE);
        break;
      case LogLevel.INFO:
        logger.i(MESSAGE);
        break;
      case LogLevel.WARN:
        logger.w(MESSAGE);
        break;
      case LogLevel.ERROR:
        logger.e(MESSAGE);
        break;
    }
  }
390763
def logGPMsg(self, printMsg=True):
        
        from arcpy import GetMessages

        msgs = GetMessages()
        try:
            self.logMsg(msgs, printMsg)
        except:
            self.logMsg('error getting arcpy message', printMsg)
469544
public function logNotification()
    {
        try {
            $this->logNotificationContents();
            $this->ipnLogFile->writeLine("=============================================================================");
            $this->ipnLogFile->closeFile();
        } catch (Exception $ex){
            error_log($ex->getMessage());
        } 
    }
576920
def do_notification_type_list(mc, args):
    ''''''

    try:
        notification_types = mc.notificationtypes.list()
    except (osc_exc.ClientException, k_exc.HttpError) as he:
        raise osc_exc.CommandError('%s\n%s' % (he.message, he.details))
    else:
        if args.json:
            print(utils.json_formatter(notification_types))
            return
        else:
            formatters = {'types': lambda x: x["type"]}
            # utils.print_list(notification_types['types'], ["types"], formatters=formatters)
            utils.print_list(notification_types, ["types"], formatters=formatters)
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)
328152
public static void printInfo(Object message)
	{
		
		if (message instanceof Throwable)
		{

			Throwable e = (Throwable) message;

			getLog(Debugger.class).info(stackTrace(e));
		}
		else

			getLog(Debugger.class).info(message);

	}
451701
function print() {
    getLoggers().forEach(function (logger) {
        consoleAppender.log(formatText('Logger %b: %b, parent:%b', logger.name, logger.level, logger.parent));
    });
}
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')