Get a configurator instance with a specified class name
@param className
@param loggerWrapper
@param configuration
@return
501528
public static LoggerWrapperConfigurator getInstance (String className, LoggerWrapper loggerWrapper, Node configuration) {
		boolean goOn = true;
		
		Class<? extends LoggerWrapperConfigurator> configuratorClass = null;
		if (goOn) {
			try {
				configuratorClass = (Class<LoggerWrapperConfigurator>) Class.forName (className);
			} catch (ClassNotFoundException ex) {
				LogHelperDebug.printError ("Class not found: " + className, ex, false);
				goOn = false;
			} catch (ClassCastException ex) {
				LogHelperDebug.printError ("Class " + className + " is found, but probably is not a subclass of ru.dmerkushov.loghelper.configure.loggerwrapper.LoggerWrapperConfigurator", ex, false);
				goOn = false;
			}
		}

		Constructor<? extends LoggerWrapperConfigurator> configuratorConstructor = null;
		if (goOn) {
			try {
				configuratorConstructor = configuratorClass.getConstructor (LoggerWrapper.class, Node.class);
			} catch (NoSuchMethodException ex) {
				LogHelperDebug.printError ("Could not find the needed constructor (LoggerWrapper, Node) in " + className, ex, false);
				goOn = false;
			} catch (SecurityException ex) {
				LogHelperDebug.printError (ex.getMessage (), ex, false);
				goOn = false;
			}
		}

		LoggerWrapperConfigurator configurator = null;
		if (goOn) {
			try {
				configurator = configuratorConstructor.newInstance (loggerWrapper, configuration);
			} catch (InstantiationException ex) {
				LogHelperDebug.printError (ex.getMessage (), ex, false);
			} catch (IllegalAccessException ex) {
				LogHelperDebug.printError (ex.getMessage (), ex, false);
			} catch (IllegalArgumentException ex) {
				LogHelperDebug.printError (ex.getMessage (), ex, false);
			} catch (InvocationTargetException ex) {
				LogHelperDebug.printError (ex.getMessage (), ex, false);
			}
		}

		return configurator;
	}
1152132
@RequestMapping(value = "configurations/{name}", method = RequestMethod.GET)
    public JIRAConfiguration getConfiguration(@PathVariable String name) {
        return jiraConfigurationService.getConfiguration(name);
    }
413725
public static StopWatchFactory getInstance(String loggerName) throws ConfigurationException
    {
        StopWatchFactory swf = getFactories().get(loggerName);

        if( swf == null ) throw new ConfigurationException("No logger by the name "+loggerName+" found.");

        return swf;
    }
1144343
@Singleton
    @Primary
    @Requires(classes = JaegerTracer.Builder.class)
    JaegerTracer.Builder jaegerTracerBuilder(Configuration configuration) {
        JaegerTracer.Builder tracerBuilder = resolveBuilder(configuration);
        if (this.configuration.isExpandExceptionLogs()) {
            tracerBuilder.withExpandExceptionLogs();
        }
        if (this.configuration.isZipkinSharedRpcSpan()) {
            tracerBuilder.withZipkinSharedRpcSpan();
        }
        if (reporter != null) {
            tracerBuilder.withReporter(reporter);
        }
        if (sampler != null) {
            tracerBuilder.withSampler(sampler);
        }
        return tracerBuilder;
    }
824458
public static Logger getLogger(final Class<?> clazz) {
        if (!clazz.getPackage().getName().startsWith(LOGGER.getName())) {
            throw new IllegalArgumentException(String.format("Class %s is not a child of the package %s",
                    clazz.getName(), LOGGER.getName()));
        }
        LOGGER.fine(() -> String.format("Locating logger for class %s", clazz));
        return Logger.getLogger(clazz.getName());
    }
663580
@Override
  public Logger getLogger(String name) {
    String tag = createTag(name);
    Logger logger = loggerMap.get(tag);
    if (logger == null) {
      Logger newInstance = new TimberLoggerAdapter(tag);
      Logger oldInstance = loggerMap.putIfAbsent(tag, newInstance);
      logger = oldInstance == null ? newInstance : oldInstance;
    }
    return logger;
  }
421188
@Override
  public Configuration getConfiguration() {
    return Tang.Factory.getTang().newConfigurationBuilder()
        .bindNamedParameter(TcpPortRangeBegin.class, String.valueOf(portRangeBegin))
        .bindNamedParameter(TcpPortRangeCount.class, String.valueOf(portRangeCount))
        .bindNamedParameter(TcpPortRangeTryCount.class, String.valueOf(portRangeTryCount))
        .bindSetEntry(EvaluatorConfigurationProviders.class, TcpPortConfigurationProvider.class)
        .build();
  }
918471
public static Logger getLogger(String name){
		if (name == null) {
			throw new IllegalArgumentException(
			        "The Logger name must not be null.");
		}

		return loggerRepository.getLogger(name);
	}
616068
public static Logger getL7dLogger(Class<?> cls,
                                      String resourcename,
                                      String loggerName) {
        return createLogger(cls, resourcename, loggerName);
    }
1290620
private static LoggingProvider loadLoggingProvider() {
		ServiceLoader<LoggingProvider> loader = new ServiceLoader<LoggingProvider>(LoggingProvider.class);
		String name = Configuration.get(PROVIDER_PROPERTY);

		if (name == null) {
			Collection<LoggingProvider> providers = loader.createAll();
			switch (providers.size()) {
				case 0:
					InternalLogger.log(Level.WARN, "No logging framework implementation found in classpath."
						+ " Add tinylog-impl.jar for outputting log entries.");
					return new NopLoggingProvider();
				case 1:
					return providers.iterator().next();
				default:
					return new BundleLoggingProvider(providers);
			}
		} else if (NOP_PROVIDER_NAME.equalsIgnoreCase(name)) {
			return new NopLoggingProvider();
		} else {
			LoggingProvider provider = loader.create(name);
			if (provider == null) {
				InternalLogger.log(Level.ERROR, "Requested logging provider is not available. Logging will be disabled.");
				return new NopLoggingProvider();
			} else {
				return provider;
			}
		}
	}
1264639
private static Class<?> getClassWithCaching(String className,
      Configuration conf) {
    Class<?> classs = cachedClassObjects.get(className);
    if (classs == null) {
      try {
        classs = conf.getClassByName(className);
        if (cachedClassObjects.size() < CACHE_MAX_SIZE) {
          cachedClassObjects.put(className, classs);
        }
      } catch (ClassNotFoundException e) {
        throw new RuntimeException("readObject can't find class " + className,
            e);
      }
    }
    // for sanity check if the class is not null
    if (classs == null) {
      throw new RuntimeException("readObject can't find class " + className);
    }
    return classs;
  }
84892
private static ClusterConfig config(String[] resources, ClassLoader classLoader) {
    return new ConfigMapper(classLoader).loadResources(ClusterConfig.class, resources);
  }
501141
public Log getInstance(String name) throws LogConfigurationException
    {
        String match="";
        for (int i=prefixes.size();name!=null && i-->0;)
        {
            String prefix=(String)prefixes.get(i);
            if (name.startsWith(prefix) && prefix.length()>match.length())
                match=prefix;
        }
        if (match.length()>0)
            name=match+".*";
        
        // Get value
        Object o = attributes.get(name);
        
        // Dereference string attributes
        while(o!=null && o instanceof String)
            o=attributes.get(o);
        
        // return actual log.
        if (o instanceof Log)
            return (Log)o;
        return log;
    }
274630
@RequestMapping(value = "configurations/{name:.*}", method = RequestMethod.GET)
    public SVNConfiguration getConfiguration(@PathVariable String name) {
        return svnConfigurationService.getConfiguration(name);
    }
320345
public static Logger getLogger(String className) {
		if (logType == null) {
			logType = findLogType();
		}
		return new Logger(logType.createLog(className));
	}
894441
public IServletWrapper getServletWrapper(String servletName, boolean addMapping) throws Exception // PK61140
    {
        IServletWrapper targetWrapper = null;

        IServletConfig sconfig = config.getServletInfo(servletName);
        if (sconfig != null) {
            IServletWrapper existingServletWrapper = sconfig.getServletWrapper();
            if (existingServletWrapper != null)
                return existingServletWrapper;
        }

        // Retrieve the list of mappings associated with 'servletName'
        List<String> mappings = config.getServletMappings(servletName);

        if (mappings != null) {
            for (String mapping : mappings) {
                if (mapping.length() > 0 && mapping.charAt(0) != '/' && mapping.charAt(0) != '*')
                    mapping = '/' + mapping;
                RequestProcessor p = requestMapper.map(mapping);
                if (p != null) {
                    if (p instanceof IServletWrapper) {
                        if (((IServletWrapper) p).getServletName().equals(servletName)) {
                            targetWrapper = (IServletWrapper) p;
                            break;
                        }
                    }
                }
            }
        }

        if (targetWrapper != null)
            return targetWrapper;

        // Begin 650884
        // PK61140 - Starts
        // String path = BY_NAME_ONLY + servletName;
        // RequestProcessor p = requestMapper.map(path);
        // // RequestProcessor p = requestMapper.map(BY_NAME_ONLY + servletName);
        //
        // // PK61140 - Ends
        //       
        //
        // if (p != null)
        // if (p instanceof ServletWrapper) {
        // if (((ServletWrapper) p).getServletName().equals(servletName))
        // targetWrapper = (ServletWrapper) p;
        // }
        //
        // if (targetWrapper != null)
        // return targetWrapper;
        // End 650884

        if (sconfig == null) {
            int internalIndex;
            if ((internalIndex = getInternalServletIndex(servletName)) >= 0) {
                sconfig = loadInternalConfig(servletName, internalIndex);
            } else {
                // Not found in DD, and not an Internal Servlet, stray??
                //
                return null;
            }

        }

        // return webExtensionProcessor.createServletWrapper(sconfig); //
        // PK61140
        // PK61140 - Starts
        IServletWrapper sw = webExtensionProcessor.createServletWrapper(sconfig);

        // Begin 650884
        // if ((sw != null)) {
        // if (addMapping) {
        // synchronized (sconfig) {
        // if (!requestMapper.exists(path)) {
        // requestMapper.addMapping(path, sw);
        // }
        // }
        // }
        // }
        // End 650884
        return sw;
        // PK61140 - Ends
    }
1142840
public static Class loadClass(String className) throws ClassException {
	Set<Throwable> exceptions = new HashSet<Throwable>();
	// OSGI env
	Class clazz = _loadClass(new OSGiBasedClassLoading(), className, null, exceptions);
	if (clazz != null) {
	    return clazz;
	}

	// core classloader
	clazz = _loadClass(new ClassLoaderBasedClassLoading(SystemUtil.getCoreClassLoader()), className, null, exceptions);
	if (clazz != null) {
	    return clazz;
	}

	// loader classloader
	clazz = _loadClass(new ClassLoaderBasedClassLoading(SystemUtil.getLoaderClassLoader()), className, null, exceptions);
	if (clazz != null) {
	    return clazz;
	}

	String msg = "cannot load class through its string name, because no definition for the class with the specified name [" + className + "] could be found";
	if (exceptions.size() > 0) {
	    StringBuilder detail = new StringBuilder();
	    Iterator<Throwable> it = exceptions.iterator();
	    Throwable t;
	    while (it.hasNext()) {
		t = it.next();
		detail.append(t.getClass().getName()).append(':').append(t.getMessage()).append(';');
	    }
	    throw new ClassException(msg + " caused by (" + detail.toString() + ")");
	}
	throw new ClassException(msg);
    }