Examples with Logger org.apache.logging.log4j.Logger used on opensource projects

Example 91 with Logger

use of org.apache.logging.log4j.Logger in project incubator-pulsar by apache.

the class ConfigurationAssemblerTest method validate.

private void validate(final Configuration config) {
    assertNotNull(config);
    assertNotNull(config.getName());
    assertFalse(config.getName().isEmpty());
    assertNotNull(config, "No configuration created");
    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() == 2);
    final PulsarAppender pulsarAppender = (PulsarAppender) appenders.get("Pulsar");
    final GelfLayout gelfLayout = (GelfLayout) pulsarAppender.getLayout();
    final Map<String, LoggerConfig> loggers = config.getLoggers();
    assertNotNull(loggers);
    assertTrue("Incorrect number of LoggerConfigs: " + loggers.size(), loggers.size() == 2);
    final LoggerConfig rootLoggerConfig = loggers.get("");
    assertEquals(Level.ERROR, rootLoggerConfig.getLevel());
    assertFalse(rootLoggerConfig.isIncludeLocation());
    final LoggerConfig loggerConfig = loggers.get("org.apache.logging.log4j");
    assertEquals(Level.DEBUG, loggerConfig.getLevel());
    assertTrue(loggerConfig.isIncludeLocation());
    final Filter filter = config.getFilter();
    assertNotNull(filter, "No Filter");
    assertTrue("Not a Threshold Filter", filter instanceof ThresholdFilter);
    final List<CustomLevelConfig> customLevels = config.getCustomLevels();
    assertNotNull(filter, "No CustomLevels");
    assertEquals(1, customLevels.size());
    final CustomLevelConfig customLevel = customLevels.get(0);
    assertEquals("Panic", customLevel.getLevelName());
    assertEquals(17, customLevel.getIntLevel());
    final Logger logger = LogManager.getLogger(getClass());
    logger.info("Welcome to Log4j!");
}

Example 92 with Logger

use of org.apache.logging.log4j.Logger in project vertigo by KleeGroup.

the class LoggerAnalyticsConnectorPlugin method add.

/**
 * {@inheritDoc}
 */
@Override
public void add(final AProcess process) {
    final Logger logger = LogManager.getLogger(process.getCategory());
    if (logger.isInfoEnabled()) {
        final String json = GSON.toJson(Collections.singletonList(process));
        logger.info(json);
    }
}

Example 93 with Logger

use of org.apache.logging.log4j.Logger in project vertigo by KleeGroup.

the class SocketLoggerAnalyticsConnectorPlugin method createLogger.

private static Logger createLogger(final String loggerName, final String hostName, final int port) {
    // If it doesn't exist we create it with the right appender
    final Logger logger = LogManager.getLogger(loggerName);
    // we create appender
    final SocketAppender appender = SocketAppender.newBuilder().withName("socketAnalytics").withLayout(SerializedLayout.createLayout()).withHost(hostName).withPort(port).withReconnectDelayMillis(// we make only one try
    0).build();
    appender.start();
    // on ne close pas : car ca stop le context
    final LoggerContext context = LoggerContext.getContext(false);
    final Configuration config = context.getConfiguration();
    config.getLoggerConfig(loggerName).addAppender(appender, null, null);
    Configurator.setLevel(loggerName, Level.INFO);
    return logger;
}

Example 94 with Logger

use of org.apache.logging.log4j.Logger in project FoamFix by asiekierka.

the class Deduplicator method deduplicateObject.

public Object deduplicateObject(Object o, int recursion) {
    if (o == null || recursion > maxRecursion)
        return o;
    Class c = o.getClass();
    if (!shouldCheckClass(c))
        return o;
    if (!deduplicatedObjects.add(o))
        return o;
    boolean canTrim = o instanceof Predicate || TRIM_ARRAYS_CLASSES.contains(c);
    if (canTrim) {
        if (c == SimpleBakedModel.class) {
            for (EnumFacing facing : EnumFacing.VALUES) {
                List l = ((SimpleBakedModel) o).getQuads(null, facing, 0);
                trimArray(l);
            }
        }
    }
    if (o instanceof IBakedModel) {
        if (o instanceof PerspectiveMapWrapper) {
            try {
                Object to = IPAM_MW_TRANSFORMS_GETTER.invoke(o);
                Object toD = deduplicate0(to);
                if (toD != null && to != toD) {
                    IPAM_MW_TRANSFORMS_SETTER.invoke(o, toD);
                }
            } catch (Throwable t) {
                t.printStackTrace();
            }
        } else if ("net.minecraftforge.client.model.BakedItemModel".equals(c.getName())) {
            try {
                Object to = BIM_TRANSFORMS_GETTER.invoke(o);
                Object toD = deduplicate0(to);
                if (toD != null && to != toD) {
                    BIM_TRANSFORMS_SETTER.invoke(o, toD);
                }
            } catch (Throwable t) {
                t.printStackTrace();
            }
        }
    }
    if (c == BlockPartFace.class) {
        ((BlockPartFace) o).blockFaceUV.uvs = (float[]) deduplicate0(((BlockPartFace) o).blockFaceUV.uvs);
        return o;
    }
    if (o instanceof BakedQuad) {
        if (c == BakedQuad.class) {
            if (FoamFixShared.config.expUnpackBakedQuads) {
                BakedQuad quad = (BakedQuad) o;
                UnpackedBakedQuad.Builder builder = new UnpackedBakedQuad.Builder(quad.getFormat());
                quad.pipe(builder);
                o = builder.build();
                c = UnpackedBakedQuad.class;
            }
        }
        if (c == UnpackedBakedQuad.class) {
            try {
                float[][][] array = (float[][][]) FIELD_UNPACKED_DATA_GETTER.invokeExact((UnpackedBakedQuad) o);
                // float[][][]s are not currently deduplicated
                deduplicate0(array);
            } catch (Throwable t) {
                t.printStackTrace();
            }
        }
    } else if (o instanceof ResourceLocation || c == TRSRTransformation.class || c == Style.class) {
        return deduplicate0(o);
    } else if (c == ItemCameraTransforms.class || c == Vec3d.class || c == Vec3i.class || c == BlockPos.class) {
        return deduplicate0(o);
    /* if (d != o)
                return d;
            TODO: Add ItemTransformVec3f dedup, maybe
            return o; */
    } else if (o instanceof Item || o instanceof Block || o instanceof World || o instanceof Entity || o instanceof Logger || o instanceof IRegistry) {
        BLACKLIST_CLASS.add(c);
        return o;
    } else if (o instanceof ItemOverrideList && o != ItemOverrideList.NONE) {
        try {
            List list = (List) IOL_OVERRIDES_GETTER.invokeExact((ItemOverrideList) o);
            if (list.isEmpty()) {
                if (c == ItemOverrideList.class) {
                    successfuls++;
                    return ItemOverrideList.NONE;
                } else if (c == AnimationItemOverrideList.class) {
                    IOL_OVERRIDES_SETTER.invokeExact((ItemOverrideList) o, (List) ImmutableList.of());
                    successfuls++;
                }
            }
        } catch (Throwable t) {
        }
    } else if (o instanceof java.util.Optional) {
        java.util.Optional opt = (java.util.Optional) o;
        if (opt.isPresent()) {
            Object b = deduplicateObject(opt.get(), recursion + 1);
            if (b != null) {
                if (JAVA_OPTIONALS.containsKey(b)) {
                    successfuls++;
                    return JAVA_OPTIONALS.get(b);
                }
                if (b != opt.get()) {
                    java.util.Optional opt2 = java.util.Optional.of(b);
                    JAVA_OPTIONALS.put(b, opt2);
                    return opt2;
                } else {
                    JAVA_OPTIONALS.put(opt.get(), opt);
                    return opt;
                }
            }
        } else {
            return opt;
        }
    } else if (o instanceof com.google.common.base.Optional) {
        Optional opt = (Optional) o;
        if (opt.isPresent()) {
            Object b = deduplicateObject(opt.get(), recursion + 1);
            if (b != null) {
                if (GUAVA_OPTIONALS.containsKey(b)) {
                    successfuls++;
                    return GUAVA_OPTIONALS.get(b);
                }
                if (b != opt.get()) {
                    com.google.common.base.Optional opt2 = com.google.common.base.Optional.of(b);
                    GUAVA_OPTIONALS.put(b, opt2);
                    return opt2;
                } else {
                    GUAVA_OPTIONALS.put(opt.get(), opt);
                    return opt;
                }
            }
        } else {
            return opt;
        }
    } else if (o instanceof Multimap) {
        if (o instanceof ImmutableMultimap || o instanceof SortedSetMultimap) {
            for (Object value : ((Multimap) o).values()) {
                deduplicateObject(value, recursion + 1);
            }
        } else {
            for (Object key : ((Multimap) o).keySet()) {
                List l = Lists.newArrayList(((Multimap) o).values());
                for (int i = 0; i < l.size(); i++) {
                    l.set(i, deduplicateObject(l.get(i), recursion + 1));
                }
                ((Multimap) o).replaceValues(key, l);
            }
        }
    } else if (o instanceof Map) {
        for (Object v : ((Map) o).keySet()) {
            deduplicateObject(v, recursion + 1);
        }
        if (o instanceof SortedMap || IMMUTABLE_CLASS.contains(c)) {
            for (Object v : ((Map) o).values()) {
                deduplicateObject(v, recursion + 1);
            }
        } else if (o instanceof ImmutableMap) {
            ImmutableMap im = (ImmutableMap) o;
            ImmutableMap.Builder newMap = (o instanceof ImmutableBiMap) ? ImmutableBiMap.builder() : ImmutableMap.builder();
            boolean deduplicated = false;
            for (Object key : im.keySet()) {
                Object a = im.get(key);
                Object b = deduplicateObject(a, recursion + 1);
                newMap.put(key, b != null ? b : a);
                if (b != null && b != a)
                    deduplicated = true;
            }
            return deduplicated ? newMap.build() : o;
        } else {
            try {
                for (Object key : ((Map) o).keySet()) {
                    Object value = ((Map) o).get(key);
                    Object valueD = deduplicateObject(value, recursion + 1);
                    if (valueD != null && value != valueD)
                        ((Map) o).put(key, valueD);
                }
            } catch (UnsupportedOperationException e) {
                IMMUTABLE_CLASS.add(c);
                for (Object v : ((Map) o).values()) {
                    deduplicateObject(v, recursion + 1);
                }
            }
        }
    } else if (o instanceof List) {
        if (IMMUTABLE_CLASS.contains(c)) {
            List l = (List) o;
            for (int i = 0; i < l.size(); i++) {
                deduplicateObject(l.get(i), recursion + 1);
            }
        } else if (o instanceof ImmutableList) {
            ImmutableList il = (ImmutableList) o;
            ImmutableList.Builder builder = ImmutableList.builder();
            boolean deduplicated = false;
            for (int i = 0; i < il.size(); i++) {
                Object a = il.get(i);
                Object b = deduplicateObject(a, recursion + 1);
                builder.add(b != null ? b : a);
                if (b != null && b != a)
                    deduplicated = true;
            }
            if (deduplicated) {
                return builder.build();
            }
        } else {
            List l = (List) o;
            try {
                for (int i = 0; i < l.size(); i++) {
                    l.set(i, deduplicateObject(l.get(i), recursion + 1));
                }
            } catch (UnsupportedOperationException e) {
                IMMUTABLE_CLASS.add(c);
                for (int i = 0; i < l.size(); i++) {
                    deduplicateObject(l.get(i), recursion + 1);
                }
            }
        }
    } else if (o instanceof ImmutableSet) {
        if (!(o instanceof ImmutableSortedSet)) {
            ImmutableSet.Builder builder = new ImmutableSet.Builder();
            for (Object o1 : ((Set) o)) {
                builder.add(deduplicateObject(o1, recursion + 1));
            }
            o = builder.build();
        } else {
            for (Object o1 : ((Set) o)) {
                deduplicateObject(o1, recursion + 1);
            }
        }
    } else if (o instanceof Collection) {
        if (!(o instanceof SortedSet)) {
            if (!COLLECTION_CONSTRUCTORS.containsKey(c)) {
                try {
                    COLLECTION_CONSTRUCTORS.put(c, MethodHandles.publicLookup().findConstructor(c, MethodType.methodType(void.class)));
                } catch (Exception e) {
                    COLLECTION_CONSTRUCTORS.put(c, null);
                }
            }
            MethodHandle constructor = COLLECTION_CONSTRUCTORS.get(c);
            if (constructor != null) {
                try {
                    Collection nc = (Collection) constructor.invoke();
                    if (nc != null) {
                        for (Object o1 : ((Collection) o)) {
                            nc.add(deduplicateObject(o1, recursion + 1));
                        }
                        return nc;
                    }
                } catch (Throwable t) {
                    COLLECTION_CONSTRUCTORS.put(c, null);
                }
            }
        }
        // fallback
        for (Object o1 : ((Collection) o)) {
            deduplicateObject(o1, recursion + 1);
        }
    } else if (c.isArray()) {
        for (int i = 0; i < Array.getLength(o); i++) {
            Object entry = Array.get(o, i);
            Object entryD = deduplicateObject(entry, recursion + 1);
            if (entryD != null && entry != entryD)
                Array.set(o, i, entryD);
        }
    } else {
        if (!CLASS_FIELDS.containsKey(c)) {
            ImmutableSet.Builder<MethodHandle[]> fsBuilder = ImmutableSet.builder();
            Class cc = c;
            do {
                for (Field f : cc.getDeclaredFields()) {
                    if ((f.getModifiers() & Modifier.STATIC) != 0)
                        continue;
                    if (shouldCheckClass(f.getType())) {
                        try {
                            f.setAccessible(true);
                            fsBuilder.add(new MethodHandle[] { MethodHandles.lookup().unreflectGetter(f), MethodHandles.lookup().unreflectSetter(f) });
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        }
                    }
                }
            } while ((cc = cc.getSuperclass()) != Object.class);
            CLASS_FIELDS.put(c, fsBuilder.build());
        }
        for (MethodHandle[] mh : CLASS_FIELDS.get(c)) {
            try {
                // System.out.println("-" + Strings.repeat("-", recursion) + "* " + f.getName());
                Object value = mh[0].invoke(o);
                Object valueD = deduplicateObject(value, recursion + 1);
                if (canTrim)
                    trimArray(valueD);
                if (valueD != null && value != valueD)
                    mh[1].invoke(o, valueD);
            } catch (IllegalAccessException e) {
            } catch (Throwable t) {
                t.printStackTrace();
            }
        }
    }
    return o;
}

Example 95 with Logger

use of org.apache.logging.log4j.Logger in project logging-log4j2 by apache.

the class RollingDirectTimeNewDirectoryTest method streamClosedError.

@Test
public void streamClosedError() throws Exception {
    final Logger logger = loggerContextRule.getLogger(RollingDirectTimeNewDirectoryTest.class.getName());
    for (int i = 0; i < 1000; i++) {
        logger.info("nHq6p9kgfvWfjzDRYbZp");
    }
    Thread.sleep(1500);
    for (int i = 0; i < 1000; i++) {
        logger.info("nHq6p9kgfvWfjzDRYbZp");
    }
    File logDir = new File(DIR);
    File[] logFolders = logDir.listFiles();
    assertNotNull(logFolders);
    Arrays.sort(logFolders);
    try {
        final int minExpectedLogFolderCount = 2;
        assertTrue("was expecting at least " + minExpectedLogFolderCount + " folders, " + "found " + logFolders.length, logFolders.length >= minExpectedLogFolderCount);
        for (File logFolder : logFolders) {
            File[] logFiles = logFolder.listFiles();
            if (logFiles != null) {
                Arrays.sort(logFiles);
            }
            assertTrue("empty folder: " + logFolder, logFiles != null && logFiles.length > 0);
        }
    } catch (AssertionError error) {
        System.out.format("log directory (%s) contents:%n", DIR);
        final Iterator<File> fileIterator = FileUtils.iterateFilesAndDirs(logDir, TrueFileFilter.TRUE, TrueFileFilter.TRUE);
        int totalFileCount = 0;
        while (fileIterator.hasNext()) {
            totalFileCount++;
            final File file = fileIterator.next();
            System.out.format("-> %s (%d)%n", file, file.length());
        }
        System.out.format("total file count: %d%n", totalFileCount);
        throw new AssertionError("check failure", error);
    }
}