How to use

LogFactory

in

de.mhus.lib.core.logging

public static boolean isTrailLevelMapper() {
  IApi api = MApi.get();
  LevelMapper mapper = api.getLogFactory().getLevelMapper();
  return (mapper != null && mapper instanceof TrailLevelMapper);
}

/**
 * <p>Construct (if necessary) and return a <code>Log</code> instance,
 * using the factory's current set of configuration attributes.</p>
 *
 * <p><strong>NOTE</strong> - Depending upon the implementation of
 * the <code>LogFactory</code> you are using, the <code>Log</code>
 * instance you are returned may or may not be local to the current
 * application, and may or may not be returned again on a subsequent
 * call with the same name argument.</p>
 *
 * @param name Logical name of the <code>Log</code> instance to be
 *  returned (the meaning of this name is only known to the underlying
 *  logging implementation that is being wrapped)
 * @return  the log engine
 */
public synchronized LogEngine getInstance(String name) {
  LogEngine inst = buffer.get(name);
  if (inst == null) {
    inst = createInstance(name);
    inst.doInitialize(this);
    buffer.put(name,inst);
  }
  return inst;
}

public LogEngine getLog(Class<?> class1) {
  return getInstance(class1);
}

} break;
case "list": {
  System.out.println("Default Level  : " + api.getLogFactory().getDefaultLevel());
  System.out.println("Trace          : " + api.isFullTrace());
  System.out.println("LogFoctory     : " + api.getLogFactory().getClass().getSimpleName());
  System.out.println("DirtyTrace     : " + MApi.isDirtyTrace());
  LevelMapper lm = api.getLogFactory().getLevelMapper();
  if (lm != null) {
  System.out.println("LevelMapper    : " + lm.getClass().getSimpleName());
  if (api.getLogFactory().getParameterMapper() != null)
  System.out.println("ParameterMapper: " + api.getLogFactory().getParameterMapper().getClass().getSimpleName());
} break;
case "level": {
  api.getLogFactory().setDefaultLevel(Log.LEVEL.valueOf(parameters[0].toUpperCase()));
  MApi.updateLoggers();
  System.out.println("OK");
} break;
case "settrail": {
  LevelMapper mapper = api.getLogFactory().getLevelMapper();
  if (MLogUtil.isTrailLevelMapper()) {
    MLogUtil.setTrailConfig(parameters == null || parameters.length < 1 ? "" : parameters[0]);
  LevelMapper mapper = api.getLogFactory().getLevelMapper();
  if (MLogUtil.isTrailLevelMapper()) {
    System.out.println("LevelMapper: " + MLogUtil.getTrailConfig());
  LevelMapper mapper = api.getLogFactory().getLevelMapper();

public void update() {
  engine = MApi.get().getLogFactory().getInstance(getName());
  localTrace = MApi.isTrace(name);
  levelMapper = MApi.get().getLogFactory().getLevelMapper();
  parameterMapper = MApi.get().getLogFactory().getParameterMapper();
  maxMsgSize = MApi.get().getLogFactory().getMaxMessageSize();
}

  if (MString.isEmpty(name)) name = System.getProperty(MConstants.PROP_PREFIX + key);
  if (MString.isSet(name)) {
    logFactory.setLevelMapper( (LevelMapper) Class.forName(name.trim()).newInstance() );
  String size = system.getString(key);
  if (size != null) {
    logFactory.setMaxMessageSize(Integer.valueOf(size));
  if (MString.isEmpty(name)) name = System.getProperty(MConstants.PROP_PREFIX + key);
  if (MString.isSet(name)) {
    logFactory.setParameterMapper( (ParameterMapper) Class.forName(name.trim()).newInstance() );
if (logFactory.getParameterMapper() != null && logFactory.getParameterMapper() instanceof MutableParameterMapper) {
  try {
    Collection<IConfig> mappers = system.getNodes(MConstants.PROP_LOG_PARAMETER_MAPPER_CLASS);
    if (mappers.size() > 0) ((MutableParameterMapper)logFactory.getParameterMapper()).clear();
    for (IConfig mapper : mappers) {
      String name = mapper.getString("name");
      String clazz = mapper.getString("class");
      if (MString.isSet(name) && MString.isSet(clazz))
        ((MutableParameterMapper)logFactory.getParameterMapper()).put(name, (ParameterEntryMapper) Class.forName(clazz.trim()).newInstance() );
  if (MString.isEmpty(value)) value = System.getProperty(MConstants.PROP_PREFIX + key);
  if (MString.isSet(value)) {
    logFactory.setDefaultLevel(Log.LEVEL.valueOf(value.toUpperCase()));

public static void releaseTrailConfig() {
  IApi api = MApi.get();
  LevelMapper mapper = api.getLogFactory().getLevelMapper();
  if (mapper != null && mapper instanceof TrailLevelMapper) {
    TrailLevelMapper m = (TrailLevelMapper)mapper;
    m.doResetTrail();
  }
}

/**
 * Convenience method to derive a name from the specified class and
 * call <code>getInstance(String)</code> with it.
 *
 * @param clazz Class for which a suitable Log name will be derived
 * @return The current log engine
 *     */
public LogEngine getInstance(Class<?> clazz) {
  return getInstance(clazz.getCanonicalName());
}

  public static void setTrailConfig(String parameters) {
    IApi api = MApi.get();
    LevelMapper mapper = api.getLogFactory().getLevelMapper();
    if (mapper != null && mapper instanceof TrailLevelMapper) {
      TrailLevelMapper m = (TrailLevelMapper)mapper;
//            ThreadMapperConfig config = new ThreadMapperConfig();
//            if (parameters != null) {
//                config.doConfigure(parameters);
//            }
      m.doConfigureTrail(parameters);
    }
  }

public static String getTrailConfig() {
  IApi api = MApi.get();
  LevelMapper mapper = api.getLogFactory().getLevelMapper();
  if (mapper != null && mapper instanceof TrailLevelMapper) {
    TrailLevelMapper m = (TrailLevelMapper)mapper;
    return m.doSerializeTrail();
  }
  return null;
}

public static void doStartTrailLog() {
  LevelMapper mapper = get().getLogFactory().getLevelMapper();
  if (mapper != null && mapper instanceof TrailLevelMapper)
    ((TrailLevelMapper)mapper).doConfigureTrail("MAP");
}

public static void doStopTrailLog() {
  LevelMapper mapper = get().getLogFactory().getLevelMapper();
  if (mapper != null && mapper instanceof TrailLevelMapper)
    ((TrailLevelMapper)mapper).doResetTrail();
}

public static void resetAllTrailConfigs() {
  IApi api = MApi.get();
  LevelMapper mapper = api.getLogFactory().getLevelMapper();
  if (mapper != null && mapper instanceof TrailLevelMapper) {
    TrailLevelMapper m = (TrailLevelMapper)mapper;
    m.doResetAllTrails();
  }
}

public TimerTaskWrap(TimerImpl timer,String name, TimerTask task) {
  this.task = task;
  this.timer = timer;
  if (name == null) name = MSystem.getClassName(task);
  this.name = name;
  synchronized (timer) {
    timer.tasks.add(this);
  }
  LevelMapper lm = MApi.get().getLogFactory().getLevelMapper();
  if (lm != null && lm instanceof TrailLevelMapper)
    log = ((TrailLevelMapper)lm).doSerializeTrail();
}
@Override

    LevelMapper lm = MApi.get().getLogFactory().getLevelMapper();
    if (lm != null && lm instanceof TrailLevelMapper)
      ((TrailLevelMapper)lm).doConfigureTrail(log);
} finally {
  if (log != null) {
    LevelMapper lm = MApi.get().getLogFactory().getLevelMapper();
    if (lm != null && lm instanceof TrailLevelMapper)
      ((TrailLevelMapper)lm).doResetTrail();

LevelMapper levelMapper = MApi.get().getLogFactory().getLevelMapper();
if (levelMapper != null && levelMapper instanceof TrailLevelMapper)
  ((TrailLevelMapper)levelMapper).doResetTrail();