Java Code Examples for org.apache.logging.log4j.Logger

The following examples show how to use org.apache.logging.log4j.Logger. These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source Project: logging-log4j2   Source File: RollingFilePropertiesTest.java    License: Apache License 2.0 6 votes vote down vote up
@Test
public void testPropertiesConfiguration() {
    final Configuration config = context.getConfiguration();
    assertNotNull("No configuration created", config);
    assertEquals("Incorrect State: " + config.getState(), config.getState(), LifeCycle.State.STARTED);
    final Map<String, Appender> appenders = config.getAppenders();
    assertNotNull(appenders);
    assertTrue("Incorrect number of Appenders: " + appenders.size(), appenders.size() == 3);
    final Map<String, LoggerConfig> loggers = config.getLoggers();
    assertNotNull(loggers);
    assertTrue("Incorrect number of LoggerConfigs: " + loggers.size(), loggers.size() == 2);
    final Filter filter = config.getFilter();
    assertNotNull("No Filter", filter);
    assertTrue("Not a Threshold Filter", filter instanceof ThresholdFilter);
    final Logger logger = LogManager.getLogger(getClass());
    logger.info("Welcome to Log4j!");
}
 
Example 2
Source Project: besu   Source File: BesuCommand.java    License: Apache License 2.0 6 votes vote down vote up
@VisibleForTesting
protected BesuCommand(
    final Logger logger,
    final Supplier<RlpBlockImporter> rlpBlockImporter,
    final Function<BesuController, JsonBlockImporter> jsonBlockImporterFactory,
    final Function<Blockchain, RlpBlockExporter> rlpBlockExporterFactory,
    final RunnerBuilder runnerBuilder,
    final BesuController.Builder controllerBuilderFactory,
    final BesuPluginContextImpl besuPluginContext,
    final Map<String, String> environment,
    final StorageServiceImpl storageService,
    final SecurityModuleServiceImpl securityModuleService) {
  this.logger = logger;
  this.rlpBlockImporter = rlpBlockImporter;
  this.rlpBlockExporterFactory = rlpBlockExporterFactory;
  this.jsonBlockImporterFactory = jsonBlockImporterFactory;
  this.runnerBuilder = runnerBuilder;
  this.controllerBuilderFactory = controllerBuilderFactory;
  this.besuPluginContext = besuPluginContext;
  this.environment = environment;
  this.storageService = storageService;
  this.securityModuleService = securityModuleService;
}
 
Example 3
Source Project: gatk   Source File: PlottingUtils.java    License: BSD 3-Clause "New" or "Revised" License 6 votes vote down vote up
static Map<String, Integer> getContigLengthMap(final SAMSequenceDictionary sequenceDictionary,
                                               final int minContigLength,
                                               final Logger logger) {
    Utils.nonNull(sequenceDictionary);
    ParamUtils.isPositiveOrZero(minContigLength, "Minimum contig length must be non-negative.");
    Utils.nonNull(logger);
    Utils.validateArg(sequenceDictionary.getSequences().stream().map(SAMSequenceRecord::getSequenceName).noneMatch(n -> n.contains(CONTIG_DELIMITER)),
            String.format("Contig names cannot contain \"%s\".", CONTIG_DELIMITER));
    final Map<String, Integer> contigLengthMap = sequenceDictionary.getSequences().stream()
            .filter(s -> s.getSequenceLength() >= minContigLength)
            .collect(Collectors.toMap(SAMSequenceRecord::getSequenceName, SAMSequenceRecord::getSequenceLength,
                    (c, l) -> {
                        throw new IllegalArgumentException(String.format("Duplicate contig in sequence dictionary: %s", c));
                    },
                    LinkedHashMap::new));
    Utils.validateArg(contigLengthMap.size() > 0,
            "There must be at least one contig above the threshold length in the sequence dictionary.");
    logger.info("Contigs above length threshold: " + contigLengthMap.toString());
    return contigLengthMap;
}
 
Example 4
Source Project: gatk   Source File: PlottingUtils.java    License: BSD 3-Clause "New" or "Revised" License 6 votes vote down vote up
static <T extends Locatable> void validateContigs(final Map<String, Integer> contigLengthMap,
                                                  final AbstractSampleLocatableCollection<T> locatableCollection,
                                                  final File file,
                                                  final Logger logger) {
    Utils.nonNull(contigLengthMap);
    Utils.nonNull(logger);
    if (locatableCollection == null) {
        Utils.validateArg(file == null, "File can only be null if collection is also null.");
        return;
    }
    final Set<String> contigNames = contigLengthMap.keySet();
    final Set<String> fileContigNames = locatableCollection.getRecords().stream().map(T::getContig).collect(Collectors.toSet());
    if (!contigNames.containsAll(fileContigNames)) {
        logger.warn(String.format("Contigs present in the file %s are missing from the sequence dictionary and will not be plotted.", file));
    }
    final Map<String, Integer> fileContigMaxPositionMap = locatableCollection.getIntervals().stream().filter(i -> contigNames.contains(i.getContig()))
            .collect(Collectors.toMap(SimpleInterval::getContig, SimpleInterval::getEnd, Integer::max));
    fileContigMaxPositionMap.forEach((c, integer) -> Utils.validateArg(integer <= contigLengthMap.get(c),
            String.format("Position present in the file %s exceeds contig length in the sequence dictionary.", file)));
}
 
Example 5
/**
 * First parse the input alignments, then classify the assembly contigs based on their alignment signatures,
 * and return the contigs that are classified together for downstream inference.
 */
public static AssemblyContigsClassifiedByAlignmentSignatures preprocess(final SvDiscoveryInputMetaData svDiscoveryInputMetaData,
                                                                        final JavaRDD<GATKRead> assemblyRawAlignments) {

    final Broadcast<SAMFileHeader> headerBroadcast = svDiscoveryInputMetaData.getSampleSpecificData().getHeaderBroadcast();
    final Broadcast<Set<String>> canonicalChromosomesBroadcast = svDiscoveryInputMetaData.getReferenceData().getCanonicalChromosomesBroadcast();
    final Logger toolLogger = svDiscoveryInputMetaData.getToolLogger();

    final JavaRDD<AssemblyContigWithFineTunedAlignments> contigsWithChimericAlignmentsReconstructed =
            AssemblyContigAlignmentsConfigPicker
                    .createOptimalCoverageAlignmentSetsForContigs(assemblyRawAlignments, headerBroadcast.getValue(),
                            canonicalChromosomesBroadcast.getValue(), 0.0, toolLogger)
                    .cache();
    toolLogger.info( contigsWithChimericAlignmentsReconstructed.count() +
            " contigs with chimeric alignments potentially giving SV signals.");

    return new AssemblyContigsClassifiedByAlignmentSignatures(contigsWithChimericAlignmentsReconstructed);
}
 
Example 6
private static ClickEvent parseClickEvent(JSONObject json, Logger logger) {
	String key = json.optString("action", null);
	if (key == null) {
		logger.warn("Received invalid click event with no action, ignoring it: " + json.toString());
		return null;
	}
	String value = json.optString("value", null);
	if (value == null) {
		logger.warn("Received invalid click event with no value, ignoring it: " + json.toString());
		return null;
	}
	switch (key.toLowerCase()) {
	case "open_url":
		return new ClickEvent(ClickEvent.Action.OPEN_URL, value);
	case "run_command":
		return new ClickEvent(ClickEvent.Action.RUN_COMMAND, value);
	case "suggest_command":
		return new ClickEvent(ClickEvent.Action.SUGGEST_COMMAND, value);
	case "change_page":
		return new ClickEvent(ClickEvent.Action.CHANGE_PAGE, value);
	default:
		logger.warn("Unknown key " + key + " for click event, ignoring it: " + json.toString());
		return null;
	}
}
 
Example 7
public static ReadMetadata buildMetadata( final FindBreakpointEvidenceSparkArgumentCollection params,
                                          final SAMFileHeader header,
                                          final JavaRDD<GATKRead> unfilteredReads,
                                          final SVReadFilter filter,
                                          final Logger logger ) {
    Utils.validate(header.getSortOrder() == SAMFileHeader.SortOrder.coordinate,
            "The reads must be coordinate sorted.");

    final Set<Integer> crossContigsToIgnoreSet;
    if ( params.crossContigsToIgnoreFile == null ) crossContigsToIgnoreSet = Collections.emptySet();
    else crossContigsToIgnoreSet = readCrossContigsToIgnoreFile(params.crossContigsToIgnoreFile,
            header.getSequenceDictionary());
    final ReadMetadata readMetadata =
            new ReadMetadata(crossContigsToIgnoreSet, header, params.maxTrackedFragmentLength, unfilteredReads, filter, logger);
    if ( params.metadataFile != null ) {
        ReadMetadata.writeMetadata(readMetadata, params.metadataFile);
    }
    return readMetadata;
}
 
Example 8
Source Project: crate   Source File: MemoryCircuitBreaker.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Create a circuit breaker that will break if the number of estimated
 * bytes grows above the limit. All estimations will be multiplied by
 * the given overheadConstant. Uses the given oldBreaker to initialize
 * the starting offset.
 * @param limit circuit breaker limit
 * @param overheadConstant constant multiplier for byte estimations
 * @param oldBreaker the previous circuit breaker to inherit the used value from (starting offset)
 */
public MemoryCircuitBreaker(ByteSizeValue limit, double overheadConstant, MemoryCircuitBreaker oldBreaker, Logger logger) {
    this.memoryBytesLimit = limit.getBytes();
    this.overheadConstant = overheadConstant;
    if (oldBreaker == null) {
        this.used = new AtomicLong(0);
        this.trippedCount = new AtomicLong(0);
    } else {
        this.used = oldBreaker.used;
        this.trippedCount = oldBreaker.trippedCount;
    }
    this.logger = logger;
    if (logger.isTraceEnabled()) {
        logger.trace("Creating MemoryCircuitBreaker with a limit of {} bytes ({}) and a overhead constant of {}",
                this.memoryBytesLimit, limit, this.overheadConstant);
    }
}
 
Example 9
Source Project: logging-log4j2   Source File: ThrowableProxyTest.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Attempts to instantiate a class that cannot initialize and then logs the stack trace of the Error. The logger
 * must not fail when using {@link ThrowableProxy} to inspect the frames of the stack trace.
 */
@Test
public void testLogStackTraceWithClassThatCannotInitialize() {
    try {
        // Try to create the object, which will always fail during class initialization
        final AlwaysThrowsError error = new AlwaysThrowsError();

        // If the error was not triggered then fail
        fail("Test did not throw expected error: " + error);
    } catch (final Throwable e) {
        // Print the stack trace to System.out for informational purposes
        // System.err.println("### Here's the stack trace that we'll log with log4j ###");
        // e.printStackTrace();
        // System.err.println("### End stack trace ###");

        final Logger logger = LogManager.getLogger(getClass());

        // This is the critical portion of the test. The log message must be printed without
        // throwing a java.lang.Error when introspecting the AlwaysThrowError class in the
        // stack trace.
        logger.error(e.getMessage(), e);
        logger.error(e);
    }
}
 
Example 10
Source Project: chronus   Source File: LogFactory.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * 获取Logger
 *
 * @param logger
 * @param clazz
 * @return
 */
public Logger createLogger(Logger logger, Class clazz) {
    String clKey = String.join("#", logger.getName(), clazz.getName());
    Logger rl = loggerMap.get(clKey);
    if (rl != null) {
        return rl;
    }
    lock.lock();
    try {
        if (!LogManager.exists(clKey)) {
            start(logger, clKey);
            loggerMap.put(clKey, LogManager.getLogger(clKey));
        }
    } finally {
        lock.unlock();
    }
    return loggerMap.get(clKey);
}
 
Example 11
Source Project: logging-log4j2   Source File: AbstractScriptFilterTest.java    License: Apache License 2.0 6 votes vote down vote up
@Test
public void testJavascriptFilter() throws Exception {
    final Logger logger = LogManager.getLogger("TestJavaScriptFilter");
    logger.traceEntry();
    logger.info("This should not be logged");
    ThreadContext.put("UserId", "JohnDoe");
    logger.info("This should be logged");
    ThreadContext.clearMap();
    final ListAppender app = getContext().getListAppender("List");
    final List<String> messages = app.getMessages();
    try {
        assertNotNull("No Messages", messages);
        assertTrue("Incorrect number of messages. Expected 2, Actual " + messages.size(), messages.size() == 2);
    } finally {
        app.clear();
    }
}
 
Example 12
/**
 * Calculate the number of eigensamples given the user preferences and the
 * result of the log-normals SVD.
 *
 * @param requestedNumberOfEigensamples the user requested eigenvalues (empty means the user didn't specify any in particular).
 * @param numberOfCountColumns number of count columns in the original input.
 * @param logNormalizedSVD SVD results on the log-normalized counts.
 * @return always greater than 0.
 */
@VisibleForTesting
static int determineNumberOfEigensamples(final OptionalInt requestedNumberOfEigensamples, final int numberOfCountColumns, final SVD logNormalizedSVD, final Logger logger) {
    final int numberOfEigensamples;
    if (requestedNumberOfEigensamples.isPresent()) {
        if (requestedNumberOfEigensamples.getAsInt() > numberOfCountColumns) {
            logger.warn(String.format("The number of requested eigensamples (%d) is larger than the available number of read count columns after filtering (%d), thus we will have to use the latter.", requestedNumberOfEigensamples.getAsInt(), numberOfCountColumns));
        }
        numberOfEigensamples = Math.min(requestedNumberOfEigensamples.getAsInt(), numberOfCountColumns);
    } else {
        final double[] singularValues = logNormalizedSVD.getSingularValues();
        final double mean = MathUtils.mean(singularValues, 0, singularValues.length);
        final double eigenvalueCutoff = mean * JOLLIFES_RULE_MEAN_FACTOR; // Jollife's less strict version of Kaiser' Rule.
        numberOfEigensamples = (int) DoubleStream.of(singularValues).filter(v -> v > eigenvalueCutoff).count();
        logger.info(String.format("Jollife's rule produced %d eigensamples out of %d possibles for the reduced PoN", numberOfEigensamples, numberOfCountColumns));
    }
    return numberOfEigensamples;
}
 
Example 13
Source Project: iaf   Source File: HttpSender.java    License: Apache License 2.0 6 votes vote down vote up
public static void streamResponseBody(InputStream is, String contentType,
		String contentDisposition, HttpServletResponse response,
		Logger log, String logPrefix, String redirectLocation) throws IOException {
	if (StringUtils.isNotEmpty(contentType)) {
		response.setHeader("Content-Type", contentType); 
	}
	if (StringUtils.isNotEmpty(contentDisposition)) {
		response.setHeader("Content-Disposition", contentDisposition); 
	}
	if (StringUtils.isNotEmpty(redirectLocation)) {
		response.sendRedirect(redirectLocation);
	}
	if (is != null) {
		try (OutputStream outputStream = response.getOutputStream()) {
			Misc.streamToStream(is, outputStream);
			log.debug(logPrefix + "copied response body input stream [" + is + "] to output stream [" + outputStream + "]");
		}
	}
}
 
Example 14
Source Project: ambari-logsearch   Source File: LogFeederUtil.java    License: Apache License 2.0 6 votes vote down vote up
public static boolean logErrorMessageByInterval(String key, String message, Throwable e, Logger callerLogger, Level level) {
  LogHistory log = logHistoryList.get(key);
  if (log == null) {
    log = new LogHistory();
    logHistoryList.put(key, log);
  }

  if ((System.currentTimeMillis() - log.lastLogTime) > 30 * 1000) {
    log.lastLogTime = System.currentTimeMillis();
    if (log.counter > 0) {
      message += ". Messages suppressed before: " + log.counter;
    }
    log.counter = 0;
    callerLogger.log(level, message, e);

    return true;
  } else {
    log.counter++;
    return false;
  }
}
 
Example 15
@Test
public void testAsyncLogWritesToLog() throws Exception {
    final File file = new File("target", "AsyncLoggerTest.log");
    // System.out.println(f.getAbsolutePath());
    file.delete();
    
    ThreadContext.push("stackvalue");
    ThreadContext.put("KEY", "mapvalue");
    
    final Logger log = LogManager.getLogger("com.foo.Bar");
    final String msg = "Async logger msg";
    log.info(msg, new InternalError("this is not a real error"));
    CoreLoggerContexts.stopLoggerContext(false, file); // stop async thread

    final BufferedReader reader = new BufferedReader(new FileReader(file));
    final String line1 = reader.readLine();
    reader.close();
    file.delete();
    assertNotNull("line1", line1);
    assertTrue("line1 correct", line1.contains(msg));

    assertTrue("ThreadContext.map", line1.contains("mapvalue"));
    assertTrue("ThreadContext.stack", line1.contains("stackvalue"));
}
 
Example 16
Source Project: meghanada-server   Source File: Scope.java    License: GNU General Public License v3.0 6 votes vote down vote up
public void dumpFieldAccess(final Logger logger) {
  for (final FieldAccess fa : this.fieldAccesses) {
    if (fa.returnType == null) {
      logger.warn("missing returnType {}", fa);
    } else {
      logger.trace("# {}", fa);
    }
  }
  for (final MethodCall mc : this.methodCalls) {
    if (mc.returnType == null) {
      logger.warn("missing returnType {}", mc);
    } else {
      logger.trace("# {}", mc);
    }
  }
}
 
Example 17
Source Project: crate   Source File: AwsEc2ServiceImpl.java    License: Apache License 2.0 5 votes vote down vote up
static ClientConfiguration buildConfiguration(Logger logger, Ec2ClientSettings clientSettings) {
    final ClientConfiguration clientConfiguration = new ClientConfiguration();
    // the response metadata cache is only there for diagnostics purposes,
    // but can force objects from every response to the old generation.
    clientConfiguration.setResponseMetadataCacheSize(0);
    clientConfiguration.setProtocol(clientSettings.protocol);
    if (Strings.hasText(clientSettings.proxyHost)) {
        // TODO: remove this leniency, these settings should exist together and be validated
        clientConfiguration.setProxyHost(clientSettings.proxyHost);
        clientConfiguration.setProxyPort(clientSettings.proxyPort);
        clientConfiguration.setProxyUsername(clientSettings.proxyUsername);
        clientConfiguration.setProxyPassword(clientSettings.proxyPassword);
    }
    // Increase the number of retries in case of 5xx API responses
    final Random rand = Randomness.get();
    final RetryPolicy retryPolicy = new RetryPolicy(
        RetryPolicy.RetryCondition.NO_RETRY_CONDITION,
        (originalRequest, exception, retriesAttempted) -> {
            // with 10 retries the max delay time is 320s/320000ms (10 * 2^5 * 1 * 1000)
            logger.warn("EC2 API request failed, retry again. Reason was:", exception);
            return 1000L * (long) (10d * Math.pow(2, retriesAttempted / 2.0d) * (1.0d + rand.nextDouble()));
        },
        10,
        false);
    clientConfiguration.setRetryPolicy(retryPolicy);
    clientConfiguration.setSocketTimeout(clientSettings.readTimeoutMillis);
    return clientConfiguration;
}
 
Example 18
Source Project: crate   Source File: Loggers.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * Set the level of the logger. If the new level is null, the logger will inherit it's level from its nearest ancestor with a non-null
 * level.
 */
public static void setLevel(Logger logger, String level) {
    final Level l;
    if (level == null) {
        l = null;
    } else {
        l = Level.valueOf(level);
    }
    setLevel(logger, l);
}
 
Example 19
Source Project: logging-log4j2   Source File: OutputStreamManagerTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void narrow() throws Exception {
    final Logger logger = LogManager.getLogger(OutputStreamManagerTest.class);
    logger.info("test");
    final List<StatusData> statusData = StatusLogger.getLogger().getStatusData();
    StatusData data = statusData.get(0);
    if (data.getMessage().getFormattedMessage().contains("WindowsAnsiOutputStream")) {
        data = statusData.get(1);
    }
    assertEquals(Level.ERROR, data.getLevel());
    assertEquals("Could not create plugin of type class org.apache.logging.log4j.core.appender.RollingRandomAccessFileAppender for element RollingRandomAccessFile",
            data.getMessage().getFormattedMessage());
    assertEquals("org.apache.logging.log4j.core.config.ConfigurationException: Configuration has multiple incompatible Appenders pointing to the same resource 'target/multiIncompatibleAppender.log'",
            data.getThrowable().toString());
}
 
Example 20
Source Project: logging-log4j2   Source File: InitTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void initTest() {
    Timer timer = new Timer("Log4j Initialization");
    timer.start();
    Logger logger = LogManager.getLogger();
    timer.stop();
    long elapsed = timer.getElapsedNanoTime();
    System.out.println(timer.toString());
    assertTrue("Initialization time exceeded threshold; elapsed " + elapsed, elapsed < 1000000000);
}
 
Example 21
Source Project: crate   Source File: Analysis.java    License: Apache License 2.0 5 votes vote down vote up
public static Version parseAnalysisVersion(Settings indexSettings, Settings settings, Logger logger) {
    // check for explicit version on the specific analyzer component
    String sVersion = settings.get("version");
    if (sVersion != null) {
        return Lucene.parseVersion(sVersion, Version.LATEST, logger);
    }
    // check for explicit version on the index itself as default for all analysis components
    sVersion = indexSettings.get("index.analysis.version");
    if (sVersion != null) {
        return Lucene.parseVersion(sVersion, Version.LATEST, logger);
    }
    // resolve the analysis version based on the version the index was created with
    return org.elasticsearch.Version.indexCreated(indexSettings).luceneVersion;
}
 
Example 22
Source Project: logging-log4j2   Source File: PluginManagerPackagesTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void test() throws Exception {

    // To ensure our custom plugin is NOT included in the log4j plugin metadata file,
    // we make sure the class does not exist until after the build is finished.
    // So we don't create the custom plugin class until this test is run.
    final File orig = new File("target/test-classes/customplugin/FixedStringLayout.java.source");
    final File f = new File(orig.getParentFile(), "FixedStringLayout.java");
    assertTrue("renamed source file failed", orig.renameTo(f));
    compile(f);
    assertTrue("reverted source file failed", f.renameTo(orig));

    // load the compiled class
    Class.forName("customplugin.FixedStringLayout");

    // now that the custom plugin class exists, we load the config
    // with the packages element pointing to our custom plugin
    ctx = Configurator.initialize("Test1", "customplugin/log4j2-741.xml");
    config = ctx.getConfiguration();
    listAppender = config.getAppender("List");

    final Logger logger = LogManager.getLogger(PluginManagerPackagesTest.class);
    logger.info("this message is ignored");

    final List<String> messages = listAppender.getMessages();
    assertEquals(messages.toString(), 1, messages.size());
    assertEquals("abc123XYZ", messages.get(0));
}
 
Example 23
Source Project: logging-log4j2   Source File: LoggerAdapterTest.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * Testing synchronization in the getLoggersInContext() method
 */
@Test
public synchronized void testGetLoggersInContextSynch() throws Exception {
    final TestLoggerAdapter adapter = new TestLoggerAdapter();

    final int num = 500;

    final CountDownLatch startSignal = new CountDownLatch(1);
    final CountDownLatch doneSignal = new CountDownLatch(num);

    final RunnableThreadTest[] instances = new RunnableThreadTest[num];
    LoggerContext lastUsedContext = null;
    for (int i = 0; i < num; i++) {
        if (i % 2 == 0) {
            //every other time create a new context
            lastUsedContext = new SimpleLoggerContext();
        }
        final RunnableThreadTest runnable = new RunnableThreadTest(i, adapter, lastUsedContext, startSignal, doneSignal);
        final Thread thread = new Thread(runnable);
        thread.start();
        instances[i] = runnable;
    }

    startSignal.countDown();
    doneSignal.await();

    for (int i = 0; i < num; i = i + 2) {
        //maps for the same context should be the same instance
        final Map<String, Logger> resultMap1 = instances[i].getResultMap();
        final Map<String, Logger> resultMap2 = instances[i + 1].getResultMap();
        assertSame("not the same map for instances" + i + " and " + (i + 1) + ":", resultMap1, resultMap2);
        assertEquals(2, resultMap1.size());
    }
}
 
Example 24
Source Project: logging-log4j2   Source File: MongoDb4CappedTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void test() {
    final Logger logger = LogManager.getLogger();
    logger.info("Hello log");
    try (final MongoClient mongoClient = mongoDbTestRule.getMongoClient()) {
        final MongoDatabase database = mongoClient.getDatabase("testDb");
        Assert.assertNotNull(database);
        final MongoCollection<Document> collection = database.getCollection("testCollection");
        Assert.assertNotNull(collection);
        final Document first = collection.find().first();
        Assert.assertNotNull(first);
        Assert.assertEquals(first.toJson(), "Hello log", first.getString("message"));
    }
}
 
Example 25
Source Project: logging-log4j2   Source File: XmlFileAppenderTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void testFlushAtEndOfBatch() throws Exception {
    final File file = new File("target", "XmlFileAppenderTest.log");
    // System.out.println(f.getAbsolutePath());
    file.delete();
    final Logger log = LogManager.getLogger("com.foo.Bar");
    final String logMsg = "Message flushed with immediate flush=false";
    log.info(logMsg);
    CoreLoggerContexts.stopLoggerContext(false, file); // stop async thread

    List<String> lines = Files.readAllLines(file.toPath(), Charset.forName("UTF8"));
    file.delete();

    String[] expect = {
            "", // ? unsure why initial empty line...
        "<Event ", //
        "<Instant epochSecond=", //
        logMsg, //
        "</Event>", //
    };

    for (int i = 0; i < expect.length; i++) {
        assertTrue("Expected line " + i + " to contain " + expect[i] + " but got: " + lines.get(i),
                lines.get(i).contains(expect[i]));
    }

    final String location = "testFlushAtEndOfBatch";
    assertTrue("no location", !lines.get(0).contains(location));
}
 
Example 26
Source Project: pinpoint   Source File: Log4j2ForAsyncLoggerIT.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void test() {
    Logger logger = LogManager.getLogger();
    logger.error("for log4j2 plugin async logger test");

    Assert.assertNotNull(ThreadContext.get("PtxId"));
    Assert.assertNotNull(ThreadContext.get("PspanId"));
}
 
Example 27
Source Project: micrometer   Source File: Log4j2MetricsTest.java    License: Apache License 2.0 5 votes vote down vote up
@Issue("#1466")
@Test
void filterWhenRootLoggerAdditivityIsFalseShouldWork() throws IOException {
    ConfigurationSource source = new ConfigurationSource(getClass().getResourceAsStream("/binder/logging/log4j2-root-logger-additivity-false.xml"));
    Configurator.initialize(null, source);

    Logger logger = LogManager.getLogger(Log4j2MetricsTest.class);

    new Log4j2Metrics().bindTo(registry);

    assertThat(registry.get("log4j2.events").tags("level", "info").counter().count()).isEqualTo(0);

    logger.info("Hello, world!");
    assertThat(registry.get("log4j2.events").tags("level", "info").counter().count()).isEqualTo(1);
}
 
Example 28
Source Project: modernmt   Source File: PythonProcess.java    License: Apache License 2.0 5 votes vote down vote up
public static String getNativeLogLevel() {
    Logger logger = LogManager.getLogger(PythonProcess.class);
    Level level = logger.getLevel();

    for (Map.Entry<String, Level> entry : LOG_LEVELS.entrySet()) {
        if (level.equals(entry.getValue()))
            return entry.getKey().toLowerCase();
    }

    return null;
}
 
Example 29
private static void evaluateIntervalsAgainstTruth(final List<SVInterval> assembledIntervals,
                                                  final SVIntervalTree<String> trueBreakpoints,
                                                  final Logger localLogger) {
    final SVIntervalTree<Integer> intervals = new SVIntervalTree<>();
    final int nIntervals = assembledIntervals.size();
    for ( int idx = 0; idx != nIntervals; ++idx ) {
        intervals.put(assembledIntervals.get(idx), idx);
    }
    final float falsePos = 1.f - intervals.overlapFraction(trueBreakpoints);
    localLogger.info("Interval false positive rate = " + falsePos + " (" + Math.round(falsePos*nIntervals) + "/" + nIntervals + ")");
    final float falseNeg = 1.f - trueBreakpoints.overlapFraction(intervals);
    final int nTrue = trueBreakpoints.size();
    localLogger.info("Interval false negative rate = " + falseNeg + " (" + Math.round(falseNeg*nTrue) + "/" + nTrue + ")");
}
 
Example 30
Source Project: crate   Source File: ExceptionsHelper.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * Unwrap the specified throwable looking for any suppressed errors or errors as a root cause of the specified throwable.
 *
 * @param cause the root throwable
 * @return an optional error if one is found suppressed or a root cause in the tree rooted at the specified throwable
 */
public static Optional<Error> maybeError(final Throwable cause, final Logger logger) {
    // early terminate if the cause is already an error
    if (cause instanceof Error) {
        return Optional.of((Error) cause);
    }

    final Queue<Throwable> queue = new LinkedList<>();
    queue.add(cause);
    int iterations = 0;
    while (queue.isEmpty() == false) {
        iterations++;
        // this is a guard against deeply nested or circular chains of exceptions
        if (iterations > MAX_ITERATIONS) {
            logger.warn("giving up looking for fatal errors", cause);
            break;
        }
        final Throwable current = queue.remove();
        if (current instanceof Error) {
            return Optional.of((Error) current);
        }
        Collections.addAll(queue, current.getSuppressed());
        if (current.getCause() != null) {
            queue.add(current.getCause());
        }
    }
    return Optional.empty();
}