Send log message to the listener.
424846
def emit(self, record):
        """"""
        future = asyncio.ensure_future(send_manager_command(
            ExecutorProtocol.LOG,
            extra_fields={
                ExecutorProtocol.LOG_MESSAGE: self.format(record),
            },
            expect_reply=False
        ))
        self.emit_list.append(future)
630154
protected void notifyListeners()
   {
      synchronized (listeners)
      {
         Thread notifier = new NotifyThread(listeners.toArray(new BackupJobListener[listeners.size()]), this);
         notifier.start();
      }
   }
1158284
public static void log(String message, Importance importance) {
		if(listener != null) {
			listener.log(message, importance);
		}
	}
1166541
def _notify(self, func, *args, **kw):
        
        for x in self.listeners:
            try:
                getattr(x, func)(*args, **kw)
            except Exception:
                log.err()
563411
def _emit_message(cls, message):
        """"""
        sys.stdout.write(message)
        sys.stdout.flush()
270903
def dlog(msg, log_path=DEFAULT_LOG_PATH):
  """"""
  with open(log_path, 'a') as f:
    f.write('\n{}@{}: {}'.format(os.getpid(), threading.current_thread().name, msg))
1050097
def listen(self, listener):
        ''''''
        for message in listener.listen():
            try:
                data = json.loads(message['data'])
                if data['event'] in ('canceled', 'lock_lost', 'put'):
                    self.kill(data['jid'])
            except:
                logger.exception('Pubsub error')
684345
def log(_self, _level, _message, *args, **kwargs):
        """
        logger = _self.opt(
            exception=_self._exception,
            record=_self._record,
            lazy=_self._lazy,
            ansi=_self._ansi,
            raw=_self._raw,
            depth=_self._depth + 1,
        )
        logger._make_log_function(_level)(logger, _message, *args, **kwargs)
1310757
function logMessage (message) {
  if (!process.send) {
    console.log(message)
  } else {
    process.send(message)
  }
}
278135
def _log(self):
        """"""
        self._log_platform()
        self._log_app_data()
        self._log_python_version()
        self._log_tcex_version()
        self._log_tc_proxy()
1320346
public static void registerLogListener(@NonNull final Context context, @NonNull final DfuLogListener listener) {
		if (mLogBroadcastReceiver == null) {
			mLogBroadcastReceiver = new LogBroadcastReceiver();

			final IntentFilter filter = new IntentFilter();
			filter.addAction(DfuBaseService.BROADCAST_LOG);
			LocalBroadcastManager.getInstance(context).registerReceiver(mLogBroadcastReceiver, filter);
		}
		mLogBroadcastReceiver.setLogListener(listener);
	}
874621
public static void invokeOnRequestLog(RequestLogListener listener, RequestLog log) {
        try (SafeCloseable ignored = log.context().push()) {
            listener.onRequestLog(log);
        } catch (Throwable e) {
            logger.warn("onRequestLog() failed with an exception:", e);
        }
    }
56749
def sendintr(self):
        ''' '''

        n, byte = self.ptyproc.sendintr()
        self._log_control(byte)
1087110
def log(self, msg, lvl = 0):
        ''''''
        if self.log_level >= lvl:
            self.log_fn(msg)
25954
def log(cls, message):
        
        if cls.verbose > 0:
            msg = '[INFO] %s' % message
            cls.echo(msg)
460550
def emit(self, record):
        """"""
        self.records.append(Record(levelno=record.levelno, levelname=record.levelname,
                                   message=self.format(record)))
        return super(SetupLogChecker, self).emit(record)
751522
protected void logMessage(String logMessage, String message, boolean incoming) {
        if (messageListener != null) {
            log.debug(logMessage);

            if (incoming) {
                messageListener.onInboundMessage(new RawMessage(message), null);
            } else {
                messageListener.onOutboundMessage(new RawMessage(message), null);
            }
        } else {
            if (log.isDebugEnabled()) {
                log.debug(logMessage + ":" + System.getProperty("line.separator") + message);
            }
        }
    }