Builds a KieRuntimeLogger.

@param runtimeEventManager runtimeEventManager
@return a KieRuntimeLogger
324096
public KieRuntimeLogger build(KieRuntimeEventManager runtimeEventManager) {
        KieRuntimeLogger logger = null;
        if (_loggerType != null && runtimeEventManager != null) {
            KieLoggers loggers = KieServices.Factory.get().getLoggers();
            switch (_loggerType) {
            case CONSOLE:
                logger = loggers.newConsoleLogger(runtimeEventManager);
                break;
            case FILE:
                logger = loggers.newFileLogger(runtimeEventManager, _log);
                break;
            case THREADED_FILE:
                logger = loggers.newThreadedFileLogger(runtimeEventManager, _log, _interval);
                break;
            }
        }
        return logger;
    }
497672
public function getEventManager()
    {
        if (!$this->eventManager instanceof EventManagerInterface) {
            $this->setEventManager(new EventManager(array(__CLASS__, get_called_class())));
        }
        return $this->eventManager;
    }
1291247
public TimerTask getTimerTask()
	{
            if (logger.isLoggable(Level.FINEST)) {
                   logger.entering(CLASS_NAME, "getTimerTask")    ;
                   logger.exiting(CLASS_NAME, "getTimerTask")    ;
            }
            if (task==null)
            	task = new EntryTimer();
		return task;
	}
1130800
public static Logger getLogger(Class<?> clazz) {
    if (hasToLog != null && hasToLog) {
      return new Slf4JLogger(org.slf4j.LoggerFactory.getLogger(clazz));
    } else {
      return NO_LOGGER;
    }
  }
1342791
public static List<ILoggingEvent> capture(Logger logger) {
        CaptureAppender capture = new CaptureAppender();
        ((ch.qos.logback.classic.Logger) logger).addAppender(capture);
        capture.start();
        return capture.captured;
    }
887789
public InternalRunner createStrict(Class<?> klass) throws InvocationTargetException {
        return create(klass, new Supplier<MockitoTestListener>() {
            public MockitoTestListener get() {
                return new MismatchReportingTestListener(Plugins.getMockitoLogger());
            }
        });
    }
593736
private org.apache.log4j.Logger getLogger()
	{
        /*
        Logger interface extends Serializable, thus Log field is
        declared 'transient' and we have to null-check
		*/
		if (logger == null)
		{
			logger = org.apache.log4j.Logger.getLogger(name);
		}
		return logger;
	}
1349934
@Override
  public DailyTimeIntervalTrigger build ()
  {
    final DailyTimeIntervalTrigger st = new DailyTimeIntervalTrigger ();
    st.setRepeatInterval (m_nInterval);
    st.setRepeatIntervalUnit (m_eIntervalUnit);
    st.setMisfireInstruction (m_nMisfireInstruction);
    st.setRepeatCount (m_nRepeatCount);

    if (m_aDaysOfWeek != null)
      st.setDaysOfWeek (m_aDaysOfWeek);
    else
      st.setDaysOfWeek (ALL_DAYS_OF_THE_WEEK);

    if (m_aStartTimeOfDay != null)
      st.setStartTimeOfDay (m_aStartTimeOfDay);
    else
      st.setStartTimeOfDay (TimeOfDay.hourAndMinuteOfDay (0, 0));

    if (m_aEndTimeOfDay != null)
      st.setEndTimeOfDay (m_aEndTimeOfDay);
    else
      st.setEndTimeOfDay (TimeOfDay.hourMinuteAndSecondOfDay (23, 59, 59));

    return st;
  }
402971
private Logger createLogger() {
    String loggerName = String.format("%s.%s.Script", project.getGroupId(), project.getArtifactId());
    return LoggerFactory.getLogger(loggerName);
  }
1330133
@Override
    protected LogHandler createLogHandler(ServletConfig pServletConfig, boolean pDebug) {
        // If there is a bundle context available, set up a tracker for tracking the logging
        // service
        BundleContext ctx = getBundleContext(pServletConfig);
        if (ctx != null) {
            // Track logging service
            logTracker = new ServiceTracker(ctx, LogService.class.getName(), null);
            logTracker.open();
            return new ActivatorLogHandler(logTracker,pDebug);
        } else {
            // Use default log handler
            return super.createLogHandler(pServletConfig, pDebug);
        }
    }
239315
public Logger getGlobalLogger() {
      return new Logger(java.util.logging.Logger
                           .getLogger(java.util.logging.Logger.GLOBAL_LOGGER_NAME));
   }
499302
protected static ManagedMessagingService buildMessagingService(ClusterConfig config) {
    return new NettyMessagingService(
        config.getClusterId(),
        config.getNodeConfig().getAddress(),
        config.getMessagingConfig());
  }
460782
public Long createEventLog(String pEventName, String pEventCategory, String pEventSubCat, String pEventSource,
        String pEventOwner, Long pEventOwnerId, String user, String modUser, String comments)
    throws DataAccessException, EventException {
        TransactionWrapper transaction = null;
        EngineDataAccessDB edao = new EngineDataAccessDB();
        try {
            transaction = edao.startTransaction();
            Long id = edao.recordEventLog(pEventName, pEventCategory, pEventSubCat,
                    pEventSource, pEventOwner, pEventOwnerId, user, modUser, comments);
            return id;
        } catch (SQLException e) {
            edao.rollbackTransaction(transaction);
            throw new EventException("Failed to create event log", e);
        } finally {
            edao.stopTransaction(transaction);
        }
    }
1079398
public static <C> LogTemplate<C> everyNSeconds(LogTemplate<C> delegateLogger, long period) {
		return everyNMilliseconds(delegateLogger, period * SimonClock.MILLIS_IN_SECOND);
	}
450070
public static Logger getLogger(Class<?> cls,
                                   String resourcename,
                                   String loggerName) {
        return createLogger(cls, resourcename, loggerName);
    }
530914
protected Logger wrap(String name, org.slf4j.Logger implementation) {
		return new Slf4jLogger(name, implementation);
	}
973154
public static JRLogger getLogger(final Class<?> clazz) {

        JRLogger logger = loggerMap.get(clazz.getName());
        if (logger == null) {
            JRLogger newInstance = null;

            // Get the logger instance according to slf4j configuration
            final org.slf4j.Logger innerLogger = LoggerFactory.getLogger(clazz);

            if ("ch.qos.logback.classic.Logger".equals(innerLogger.getClass().getName())) {
                newInstance = new LogbackAdapter((ch.qos.logback.classic.Logger) innerLogger);
            } else {

                newInstance = new Slf4jAdapter(innerLogger);
            }

            final JRLogger oldInstance = loggerMap.putIfAbsent(clazz.getName(), newInstance);
            logger = oldInstance == null ? newInstance : oldInstance;
        }
        return logger;
    }