org.apache.log4j.Layout - java examples

Here are the examples of the java api org.apache.log4j.Layout taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

117 Examples 7

19 View Complete Implementation : MongoDbPatternLayoutDateAppender.java
Copyright Apache License 2.0
Author : RobertStewart
/**
 * this method returns the key of the date which is mentioned in layout pattern
 * @param layout
 * @return key of Date (%d)
 */
private String getDateKeyFromPatternLayout(Layout layout) {
    String dateKey = null;
    String conversionPattern = ((MongoDbPatternLayout) layout).getConversionPattern();
    String[] splitPattern = conversionPattern.split(",");
    for (String pattern : splitPattern) {
        if (pattern.contains("%d")) {
            dateKey = pattern.split(":")[0];
        }
    }
    // here we are removing double quotes '"' and opening curly braces '{' from the Key
    if (dateKey != null) {
        dateKey = dateKey.replaceAll("\"|\"$", "");
        dateKey = dateKey.replaceAll("\\{", "");
    }
    return dateKey;
}

19 View Complete Implementation : SystemLog.java
Copyright Apache License 2.0
Author : GerritCodeReview
private AsyncAppender createAsyncAppender(String name, Layout layout, boolean rotate) {
    return createAsyncAppender(name, layout, rotate, false);
}

19 View Complete Implementation : AppenderSkeleton.java
Copyright GNU General Public License v2.0
Author : anomalizer
/**
 *     Set the layout for this appender. Note that some appenders have
 *     their own (fixed) layouts or do not use one. For example, the
 *     {@link org.apache.log4j.net.SocketAppender} ignores the layout set
 *     here.
 */
public void setLayout(Layout layout) {
    this.layout = layout;
}

19 View Complete Implementation : InodeStoreBench.java
Copyright Apache License 2.0
Author : Alluxio
public static void main(String[] args) throws Exception {
    // Enable logging to stdout.
    Layout layout = new PatternLayout("%d [%t] %-5p %c %x - %m%n");
    Logger.getRootLogger().addAppender(new ConsoleAppender(layout));
    System.out.printf("Running benchmarks for rocks inode store%n");
    sStore = new RocksInodeStore(ServerConfiguration.get(PropertyKey.MASTER_METASTORE_DIR));
    runBenchmarks();
    System.out.printf("%nRunning benchmarks for heap inode store%n");
    sStore = new HeapInodeStore();
    runBenchmarks();
}

19 View Complete Implementation : Log4JRecordingAppender.java
Copyright Apache License 2.0
Author : goldmansachs
public void setLayout(Layout layout) {
    // todo: rezaem: implement not implemented method
    throw new RuntimeException("not implemented");
}

19 View Complete Implementation : MockAppender.java
Copyright Apache License 2.0
Author : mihaicostin
public void setLayout(Layout layout) {
    throw new UnsupportedOperationException();
}

19 View Complete Implementation : LoggerLayout.java
Copyright MIT License
Author : chedim
public clreplaced LoggerLayout extends Layout {

    private Layout parent;

    private CharSequence buffer;

    private Supplier<Integer> position;

    public LoggerLayout(Layout parent, CharSequence buffer, Supplier<Integer> position) {
        this.parent = parent;
        this.buffer = buffer;
        this.position = position;
    }

    public static CharSequence repeat(CharSequence s, int times) {
        if (times < 1) {
            return "";
        }
        return IntStream.of(times).boxed().map(i -> s).collect(Collectors.joining());
    }

    @Override
    public String format(LoggingEvent event) {
        int position = this.position.get();
        CharSequence bufVal = buffer;
        if (position < buffer.length()) {
            bufVal = buffer.subSequence(Math.max(0, position - 50), position);
        }
        bufVal = String.format("'%s'", ralign(sanitize(bufVal), 48));
        return String.format("%50.50s || %s :: %s\n", bufVal, ralign(event.getLoggerName(), 50), event.getMessage());
    }

    @Override
    public boolean ignoresThrowable() {
        return parent.ignoresThrowable();
    }

    @Override
    public void activateOptions() {
        parent.activateOptions();
    }

    public Layout parent() {
        return parent;
    }

    public static String sanitize(Object what) {
        return what == null ? "null" : sanitize(what.toString());
    }

    public static String sanitize(String what) {
        return what == null ? null : what.replaceAll("\n", "\\\\n").replaceAll("\t", "\\\\t");
    }

    public static CharSequence head(CharSequence what, int len) {
        if (what.length() < len) {
            return what;
        }
        return what.subSequence(0, len);
    }

    public static String ralign(CharSequence what, int len) {
        if (what.length() >= len) {
            what = what.subSequence(what.length() - len, what.length());
            return what.toString();
        }
        String format = String.format("%%%1$d.%1$ds%%2$s", len - what.length());
        return String.format(format, "", what);
    }
}

19 View Complete Implementation : XmlConfiguration.java
Copyright Apache License 2.0
Author : apache
/**
 * Used internally to parse a layout element.
 */
public Layout parseLayout(Element layoutElement) {
    String clreplacedName = subst(layoutElement.getAttribute(CLreplaced_ATTR));
    LOGGER.debug("Parsing layout of clreplaced: \"{}\"", clreplacedName);
    Layout layout = manager.parseLayout(clreplacedName, layoutElement, this);
    if (layout == null) {
        layout = buildLayout(clreplacedName, layoutElement);
    }
    return layout;
}

19 View Complete Implementation : SystemLog.java
Copyright Apache License 2.0
Author : GerritCodeReview
public AsyncAppender createAsyncAppender(String name, Layout layout) {
    return createAsyncAppender(name, layout, rotateLogs);
}

19 View Complete Implementation : Log4jPipedAppender.java
Copyright Apache License 2.0
Author : pentaho
public clreplaced Log4jPipedAppender implements Appender {

    private Layout layout;

    private Filter filter;

    private String name;

    private PipedOutputStream pipedOutputStream;

    public Log4jPipedAppender() {
        pipedOutputStream = new PipedOutputStream();
    }

    public void addFilter(Filter filter) {
        this.filter = filter;
    }

    public Filter getFilter() {
        return filter;
    }

    public void clearFilters() {
        filter = null;
    }

    public void close() {
        try {
            pipedOutputStream.close();
        } catch (IOException e) {
            System.out.println("Unable to close piped output stream: " + e.getMessage());
        }
    }

    public void doAppend(LoggingEvent event) {
        String line = layout.format(event) + Const.CR;
        try {
            pipedOutputStream.write(line.getBytes());
        } catch (IOException e) {
            System.out.println("Unable to write to piped output stream : " + e.getMessage());
        }
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setErrorHandler(ErrorHandler arg0) {
    }

    public ErrorHandler getErrorHandler() {
        return null;
    }

    public void setLayout(Layout layout) {
        this.layout = layout;
    }

    public Layout getLayout() {
        return layout;
    }

    public boolean requiresLayout() {
        return true;
    }

    public PipedOutputStream getPipedOutputStream() {
        return pipedOutputStream;
    }

    public void setPipedOutputStream(PipedOutputStream pipedOutputStream) {
        this.pipedOutputStream = pipedOutputStream;
    }

    public void setFilter(Filter filter) {
        this.filter = filter;
    }
}

19 View Complete Implementation : SyslogAppenderTest.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Test two parameter constructor with unexpected facility.
 */
public void testTwoParamConstructorBadFacility() {
    Layout layout = new PatternLayout();
    SyslogAppender appender = new SyslogAppender(layout, 25);
    replacedertEquals("user", appender.getFacility());
    replacedertEquals(false, appender.getFacilityPrinting());
    replacedertEquals(layout, appender.getLayout());
    replacedertNull(appender.getSyslogHost());
    replacedertTrue(appender.requiresLayout());
}

19 View Complete Implementation : LogCatAppender.java
Copyright GNU General Public License v3.0
Author : Hilaver
public void setTagLayout(Layout tagLayout) {
    this.tagLayout = tagLayout;
}

19 View Complete Implementation : SpyAppender.java
Copyright Apache License 2.0
Author : OpenPojo
public void setLayout(Layout layout) {
}

19 View Complete Implementation : DatagramStringAppender.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
public void setLayout(Layout layout) {
    this.layout = layout;
}

19 View Complete Implementation : LayoutAdapter.java
Copyright Apache License 2.0
Author : apache
/**
 * Clreplaced Description goes here.
 */
public clreplaced LayoutAdapter implements org.apache.logging.log4j.core.Layout<String> {

    private Layout layout;

    public LayoutAdapter(Layout layout) {
        this.layout = layout;
    }

    @Override
    public byte[] getFooter() {
        return layout.getFooter() == null ? null : layout.getFooter().getBytes();
    }

    @Override
    public byte[] getHeader() {
        return layout.getHeader() == null ? null : layout.getHeader().getBytes();
    }

    @Override
    public byte[] toByteArray(LogEvent event) {
        String result = layout.format(new LogEventAdapter(event));
        return result == null ? null : result.getBytes();
    }

    @Override
    public String toSerializable(LogEvent event) {
        return layout.format(new LogEventAdapter(event));
    }

    @Override
    public String getContentType() {
        return layout.getContentType();
    }

    @Override
    public Map<String, String> getContentFormat() {
        return new HashMap<>();
    }

    @Override
    public void encode(LogEvent event, ByteBufferDestination destination) {
        final byte[] data = toByteArray(event);
        destination.writeBytes(data, 0, data.length);
    }
}

19 View Complete Implementation : LoggerFactory.java
Copyright Apache License 2.0
Author : servicecatalog
/**
 * Returns the log message layout according to the product requirements.
 *
 * @return The message layout.
 */
private static Layout getLayout() {
    Layout layout = new PatternLayout("%d{MM/dd/yyyy_HH:mm:ss.SSS} FSP_INTS-BSS: %p: ThreadID %t: %c{1}: %m%n");
    return layout;
}

19 View Complete Implementation : SyslogAppenderTest.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Test two parameter constructor.
 */
public void testTwoParamConstructor() {
    Layout layout = new PatternLayout();
    SyslogAppender appender = new SyslogAppender(layout, 24);
    replacedertEquals("daemon", appender.getFacility());
    replacedertEquals(false, appender.getFacilityPrinting());
    replacedertEquals(layout, appender.getLayout());
    replacedertNull(appender.getSyslogHost());
    replacedertTrue(appender.requiresLayout());
}

19 View Complete Implementation : SyslogAppenderTest.java
Copyright GNU Lesser General Public License v2.1
Author : cacheonix
/**
 * Test three parameter constructor.
 */
public void testThreeParamConstructor() {
    Layout layout = new PatternLayout();
    SyslogAppender appender = new SyslogAppender(layout, "syslog.example.org", 24);
    replacedertEquals("daemon", appender.getFacility());
    replacedertEquals(false, appender.getFacilityPrinting());
    replacedertEquals(layout, appender.getLayout());
    replacedertEquals("syslog.example.org", appender.getSyslogHost());
    replacedertTrue(appender.requiresLayout());
}

19 View Complete Implementation : WrappedSyslogAppender.java
Copyright Apache License 2.0
Author : anuragphadke
public void setLayout(Layout layout) {
    syslog.setLayout(layout);
}

19 View Complete Implementation : LogCatAppender.java
Copyright GNU General Public License v3.0
Author : Hilaver
/**
 * 源自 android-logging-log4j-1.0.3.jar
 *
 * @author Administrator
 */
public clreplaced LogCatAppender extends AppenderSkeleton {

    protected Layout tagLayout;

    public LogCatAppender(Layout messageLayout, Layout tagLayout) {
        this.tagLayout = tagLayout;
        setLayout(messageLayout);
    }

    public LogCatAppender(Layout messageLayout) {
        // 这里定义的是Tag名称
        this(messageLayout, new PatternLayout("%c"));
    }

    public LogCatAppender() {
        this(new PatternLayout("%c"));
    }

    protected void append(LoggingEvent le) {
        switch(le.getLevel().toInt()) {
            case 5000:
                if (le.getThrowableInformation() != null) {
                    Log.v(getTagLayout().format(le), getLayout().format(le), le.getThrowableInformation().getThrowable());
                } else {
                    Log.v(getTagLayout().format(le), getLayout().format(le));
                }
                break;
            case 10000:
                if (le.getThrowableInformation() != null) {
                    Log.d(getTagLayout().format(le), getLayout().format(le), le.getThrowableInformation().getThrowable());
                } else {
                    Log.d(getTagLayout().format(le), getLayout().format(le));
                }
                break;
            case 20000:
                if (le.getThrowableInformation() != null) {
                    Log.i(getTagLayout().format(le), getLayout().format(le), le.getThrowableInformation().getThrowable());
                } else {
                    Log.i(getTagLayout().format(le), getLayout().format(le));
                }
                break;
            case 30000:
                if (le.getThrowableInformation() != null) {
                    Log.w(getTagLayout().format(le), getLayout().format(le), le.getThrowableInformation().getThrowable());
                } else {
                    Log.w(getTagLayout().format(le), getLayout().format(le));
                }
                break;
            case 40000:
                if (le.getThrowableInformation() != null) {
                    Log.e(getTagLayout().format(le), getLayout().format(le), le.getThrowableInformation().getThrowable());
                } else {
                    Log.e(getTagLayout().format(le), getLayout().format(le));
                }
                break;
            case 50000:
                if (le.getThrowableInformation() != null) {
                    Log.wtf(getTagLayout().format(le), getLayout().format(le), le.getThrowableInformation().getThrowable());
                } else
                    Log.wtf(getTagLayout().format(le), getLayout().format(le));
                break;
        }
    }

    public void close() {
    }

    public boolean requiresLayout() {
        return true;
    }

    public Layout getTagLayout() {
        return this.tagLayout;
    }

    public void setTagLayout(Layout tagLayout) {
        this.tagLayout = tagLayout;
    }
}

18 View Complete Implementation : JavaJobRunnerMain.java
Copyright Apache License 2.0
Author : azkaban
public clreplaced JavaJobRunnerMain {

    public static final String JOB_CLreplaced = "job.clreplaced";

    public static final String DEFAULT_RUN_METHOD = "run";

    public static final String DEFAULT_CANCEL_METHOD = "cancel";

    // This is the Job interface method to get the properties generated by the
    // job.
    public static final String GET_GENERATED_PROPERTIES_METHOD = "getJobGeneratedProperties";

    public static final String CANCEL_METHOD_PARAM = "method.cancel";

    public static final String RUN_METHOD_PARAM = "method.run";

    public static final String[] PROPS_CLreplacedES = new String[] { "azkaban.utils.Props", "azkaban.common.utils.Props" };

    private static final Layout DEFAULT_LAYOUT = new PatternLayout("%p %m\n");

    public final Logger _logger;

    public String _cancelMethod;

    public String _jobName;

    public Object _javaObject;

    private boolean _isFinished = false;

    public static void main(String[] args) throws Exception {
        @SuppressWarnings("unused")
        JavaJobRunnerMain wrapper = new JavaJobRunnerMain();
    }

    @SuppressWarnings("DefaultCharset")
    public JavaJobRunnerMain() throws Exception {
        Runtime.getRuntime().addShutdownHook(new Thread() {

            @Override
            public void run() {
                cancelJob();
            }
        });
        try {
            _jobName = System.getenv(ProcessJob.JOB_NAME_ENV);
            String propsFile = System.getenv(ProcessJob.JOB_PROP_ENV);
            _logger = Logger.getRootLogger();
            _logger.removeAllAppenders();
            ConsoleAppender appender = new ConsoleAppender(DEFAULT_LAYOUT);
            appender.activateOptions();
            _logger.addAppender(appender);
            Properties props = new Properties();
            props.load(new BufferedReader(new FileReader(propsFile)));
            _logger.info("Running job " + _jobName);
            String clreplacedName = props.getProperty(JOB_CLreplaced);
            if (clreplacedName == null) {
                throw new Exception("Clreplaced name is not set.");
            }
            _logger.info("Clreplaced name " + clreplacedName);
            HadoopConfigurationInjector.injectResources(new Props(null, props));
            // Create the object using proxy
            if (SecurityUtils.shouldProxy(props)) {
                _javaObject = getObjectAsProxyUser(props, _logger, _jobName, clreplacedName);
            } else {
                _javaObject = getObject(_jobName, clreplacedName, props, _logger);
            }
            if (_javaObject == null) {
                _logger.info("Could not create java object to run job: " + clreplacedName);
                throw new Exception("Could not create running object");
            }
            _cancelMethod = props.getProperty(CANCEL_METHOD_PARAM, DEFAULT_CANCEL_METHOD);
            final String runMethod = props.getProperty(RUN_METHOD_PARAM, DEFAULT_RUN_METHOD);
            if (SecurityUtils.shouldProxy(props)) {
                _logger.info("Proxying enabled.");
                runMethodAsProxyUser(props, _javaObject, runMethod);
            } else {
                _logger.info("Proxy check failed, not proxying run.");
                runMethod(_javaObject, runMethod);
            }
            _isFinished = true;
            // Get the generated properties and store them to disk, to be read
            // by ProcessJob.
            try {
                final Method generatedPropertiesMethod = _javaObject.getClreplaced().getMethod(GET_GENERATED_PROPERTIES_METHOD, new Clreplaced<?>[] {});
                Object outputGendProps = generatedPropertiesMethod.invoke(_javaObject, new Object[] {});
                if (outputGendProps != null) {
                    final Method toPropertiesMethod = outputGendProps.getClreplaced().getMethod("toProperties", new Clreplaced<?>[] {});
                    Properties properties = (Properties) toPropertiesMethod.invoke(outputGendProps, new Object[] {});
                    Props outputProps = new Props(null, properties);
                    outputGeneratedProperties(outputProps);
                } else {
                    outputGeneratedProperties(new Props());
                }
            } catch (NoSuchMethodException e) {
                _logger.info(String.format("Apparently there isn't a method[%s] on object[%s], " + "using empty Props object instead.", GET_GENERATED_PROPERTIES_METHOD, _javaObject));
                outputGeneratedProperties(new Props());
            }
        } catch (Exception e) {
            _isFinished = true;
            throw e;
        }
    }

    private void runMethodAsProxyUser(Properties props, final Object obj, final String runMethod) throws IOException, InterruptedException, UndeclaredThrowableException {
        UserGroupInformation ugi = SecurityUtils.getProxiedUser(props, _logger, new Configuration());
        _logger.info("user " + ugi + " authenticationMethod " + ugi.getAuthenticationMethod());
        _logger.info("user " + ugi + " hasKerberosCredentials " + ugi.hasKerberosCredentials());
        SecurityUtils.getProxiedUser(props, _logger, new Configuration()).doAs(new PrivilegedExceptionAction<Void>() {

            @Override
            public Void run() throws Exception {
                runMethod(obj, runMethod);
                return null;
            }
        });
    }

    private void runMethod(Object obj, String runMethod) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        final Method method = obj.getClreplaced().getMethod(runMethod, new Clreplaced<?>[] {});
        _logger.info("Beginning execution of external code: " + runMethod);
        method.invoke(obj);
        _logger.info("Completed execution of external code: " + runMethod);
    }

    @SuppressWarnings("DefaultCharset")
    private void outputGeneratedProperties(Props outputProperties) {
        if (outputProperties == null) {
            _logger.info("  no gend props");
            return;
        }
        for (String key : outputProperties.getKeySet()) {
            _logger.info("  gend prop " + key + " value:" + outputProperties.get(key));
        }
        String outputFileStr = System.getenv(ProcessJob.JOB_OUTPUT_PROP_FILE);
        if (outputFileStr == null) {
            return;
        }
        _logger.info("Outputting generated properties to " + outputFileStr);
        Map<String, String> properties = new LinkedHashMap<String, String>();
        for (String key : outputProperties.getKeySet()) {
            properties.put(key, outputProperties.get(key));
        }
        Writer writer = null;
        try {
            writer = new BufferedWriter(new FileWriter(outputFileStr));
            JSONUtils.writePropsNoJarDependency(properties, writer);
        } catch (Exception e) {
        } finally {
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                }
            }
        }
    }

    public void cancelJob() {
        if (_isFinished) {
            return;
        }
        _logger.info("Attempting to call cancel on this job");
        if (_javaObject == null) {
            return;
        }
        Method method = null;
        try {
            method = _javaObject.getClreplaced().getMethod(_cancelMethod);
        } catch (SecurityException e) {
        } catch (NoSuchMethodException e) {
        }
        if (method != null) {
            try {
                method.invoke(_javaObject);
            } catch (Exception e) {
                if (_logger != null) {
                    _logger.error("Cancel method failed! ", e);
                }
            }
        } else {
            throw new RuntimeException("Job " + _jobName + " does not have cancel method " + _cancelMethod);
        }
    }

    private static Object getObjectAsProxyUser(final Properties props, final Logger logger, final String jobName, final String clreplacedName) throws Exception {
        Object obj = SecurityUtils.getProxiedUser(props, logger, new Configuration()).doAs(new PrivilegedExceptionAction<Object>() {

            @Override
            public Object run() throws Exception {
                return getObject(jobName, clreplacedName, props, logger);
            }
        });
        return obj;
    }

    private static Object getObject(String jobName, String clreplacedName, Properties properties, Logger logger) throws Exception {
        Clreplaced<?> runningClreplaced = JavaJobRunnerMain.clreplaced.getClreplacedLoader().loadClreplaced(clreplacedName);
        if (runningClreplaced == null) {
            throw new Exception("Clreplaced " + clreplacedName + " was not found. Cannot run job.");
        }
        Clreplaced<?> propsClreplaced = null;
        for (String propClreplacedName : PROPS_CLreplacedES) {
            try {
                propsClreplaced = JavaJobRunnerMain.clreplaced.getClreplacedLoader().loadClreplaced(propClreplacedName);
            } catch (ClreplacedNotFoundException e) {
            }
            if (propsClreplaced != null && getConstructor(runningClreplaced, String.clreplaced, propsClreplaced) != null) {
                // is this the props clreplaced
                break;
            }
            propsClreplaced = null;
        }
        Object obj = null;
        if (propsClreplaced != null && getConstructor(runningClreplaced, String.clreplaced, propsClreplaced) != null) {
            // Create props clreplaced
            Constructor<?> propsCon = getConstructor(propsClreplaced, propsClreplaced, Properties[].clreplaced);
            Object props = propsCon.newInstance(null, new Properties[] { properties });
            Constructor<?> con = getConstructor(runningClreplaced, String.clreplaced, propsClreplaced);
            logger.info("Constructor found " + con.toGenericString());
            obj = con.newInstance(jobName, props);
        } else if (getConstructor(runningClreplaced, String.clreplaced, Properties.clreplaced) != null) {
            Constructor<?> con = getConstructor(runningClreplaced, String.clreplaced, Properties.clreplaced);
            logger.info("Constructor found " + con.toGenericString());
            obj = con.newInstance(jobName, properties);
        } else if (getConstructor(runningClreplaced, String.clreplaced, Map.clreplaced) != null) {
            Constructor<?> con = getConstructor(runningClreplaced, String.clreplaced, Map.clreplaced);
            logger.info("Constructor found " + con.toGenericString());
            HashMap<Object, Object> map = new HashMap<Object, Object>();
            for (Map.Entry<Object, Object> entry : properties.entrySet()) {
                map.put(entry.getKey(), entry.getValue());
            }
            obj = con.newInstance(jobName, map);
        } else if (getConstructor(runningClreplaced, String.clreplaced) != null) {
            Constructor<?> con = getConstructor(runningClreplaced, String.clreplaced);
            logger.info("Constructor found " + con.toGenericString());
            obj = con.newInstance(jobName);
        } else if (getConstructor(runningClreplaced) != null) {
            Constructor<?> con = getConstructor(runningClreplaced);
            logger.info("Constructor found " + con.toGenericString());
            obj = con.newInstance();
        } else {
            logger.error("Constructor not found. Listing available Constructors.");
            for (Constructor<?> c : runningClreplaced.getConstructors()) {
                logger.info(c.toGenericString());
            }
        }
        return obj;
    }

    private static Constructor<?> getConstructor(Clreplaced<?> c, Clreplaced<?>... args) {
        try {
            Constructor<?> cons = c.getConstructor(args);
            return cons;
        } catch (NoSuchMethodException e) {
            return null;
        }
    }
}

18 View Complete Implementation : JavaJobRunnerMain.java
Copyright Apache License 2.0
Author : azkaban
public clreplaced JavaJobRunnerMain {

    public static final String JOB_CLreplaced = "job.clreplaced";

    public static final String DEFAULT_RUN_METHOD = "run";

    public static final String DEFAULT_CANCEL_METHOD = "cancel";

    // This is the Job interface method to get the properties generated by the
    // job.
    public static final String GET_GENERATED_PROPERTIES_METHOD = "getJobGeneratedProperties";

    public static final String CANCEL_METHOD_PARAM = "method.cancel";

    public static final String RUN_METHOD_PARAM = "method.run";

    public static final String[] PROPS_CLreplacedES = new String[] { "azkaban.utils.Props", "azkaban.common.utils.Props" };

    private static final Layout DEFAULT_LAYOUT = new PatternLayout("%p %m\n");

    public final Logger _logger;

    public String _cancelMethod;

    public String _jobName;

    public Object _javaObject;

    private boolean _isFinished = false;

    public JavaJobRunnerMain() throws Exception {
        Runtime.getRuntime().addShutdownHook(new Thread() {

            @Override
            public void run() {
                cancelJob();
            }
        });
        try {
            this._jobName = System.getenv(ProcessJob.JOB_NAME_ENV);
            final String propsFile = System.getenv(ProcessJob.JOB_PROP_ENV);
            this._logger = Logger.getRootLogger();
            this._logger.removeAllAppenders();
            final ConsoleAppender appender = new ConsoleAppender(DEFAULT_LAYOUT);
            appender.activateOptions();
            this._logger.addAppender(appender);
            final Properties prop = new Properties();
            prop.load(Files.newBufferedReader(Paths.get(propsFile), StandardCharsets.UTF_8));
            this._logger.info("Running job " + this._jobName);
            final String clreplacedName = prop.getProperty(JOB_CLreplaced);
            if (clreplacedName == null) {
                throw new Exception("Clreplaced name is not set.");
            }
            this._logger.info("Clreplaced name " + clreplacedName);
            // Create the object using proxy
            this._javaObject = getObject(this._jobName, clreplacedName, prop, this._logger);
            if (this._javaObject == null) {
                this._logger.info("Could not create java object to run job: " + clreplacedName);
                throw new Exception("Could not create running object");
            }
            this._cancelMethod = prop.getProperty(CANCEL_METHOD_PARAM, DEFAULT_CANCEL_METHOD);
            final String runMethod = prop.getProperty(RUN_METHOD_PARAM, DEFAULT_RUN_METHOD);
            this._logger.info("Invoking method " + runMethod);
            this._logger.info("Proxy check failed, not proxying run.");
            runMethod(this._javaObject, runMethod);
            this._isFinished = true;
            // Get the generated properties and store them to disk, to be read
            // by ProcessJob.
            try {
                final Method generatedPropertiesMethod = this._javaObject.getClreplaced().getMethod(GET_GENERATED_PROPERTIES_METHOD, new Clreplaced<?>[] {});
                final Object outputGendProps = generatedPropertiesMethod.invoke(this._javaObject, new Object[] {});
                if (outputGendProps != null) {
                    final Method toPropertiesMethod = outputGendProps.getClreplaced().getMethod("toProperties", new Clreplaced<?>[] {});
                    final Properties properties = (Properties) toPropertiesMethod.invoke(outputGendProps, new Object[] {});
                    final Props outputProps = new Props(null, properties);
                    outputGeneratedProperties(outputProps);
                } else {
                    outputGeneratedProperties(new Props());
                }
            } catch (final NoSuchMethodException e) {
                this._logger.info(String.format("Apparently there isn't a method[%s] on object[%s], using empty Props object instead.", GET_GENERATED_PROPERTIES_METHOD, this._javaObject));
                outputGeneratedProperties(new Props());
            }
        } catch (final Exception e) {
            this._isFinished = true;
            throw e;
        }
    }

    public static void main(final String[] args) throws Exception {
        final JavaJobRunnerMain wrapper = new JavaJobRunnerMain();
    }

    private static Object getObject(final String jobName, final String clreplacedName, final Properties properties, final Logger logger) throws Exception {
        final Clreplaced<?> runningClreplaced = JavaJobRunnerMain.clreplaced.getClreplacedLoader().loadClreplaced(clreplacedName);
        if (runningClreplaced == null) {
            throw new Exception("Clreplaced " + clreplacedName + " was not found. Cannot run job.");
        }
        Clreplaced<?> propsClreplaced = null;
        for (final String propClreplacedName : PROPS_CLreplacedES) {
            try {
                propsClreplaced = JavaJobRunnerMain.clreplaced.getClreplacedLoader().loadClreplaced(propClreplacedName);
            } catch (final ClreplacedNotFoundException e) {
            }
            if (propsClreplaced != null && getConstructor(runningClreplaced, String.clreplaced, propsClreplaced) != null) {
                // is this the props clreplaced
                break;
            }
            propsClreplaced = null;
        }
        Object obj = null;
        if (propsClreplaced != null && getConstructor(runningClreplaced, String.clreplaced, propsClreplaced) != null) {
            // Create props clreplaced
            final Constructor<?> propsCon = getConstructor(propsClreplaced, propsClreplaced, Properties[].clreplaced);
            final Object props = propsCon.newInstance(null, new Properties[] { properties });
            final Constructor<?> con = getConstructor(runningClreplaced, String.clreplaced, propsClreplaced);
            logger.info("Constructor found " + con.toGenericString());
            obj = con.newInstance(jobName, props);
        } else if (getConstructor(runningClreplaced, String.clreplaced, Properties.clreplaced) != null) {
            final Constructor<?> con = getConstructor(runningClreplaced, String.clreplaced, Properties.clreplaced);
            logger.info("Constructor found " + con.toGenericString());
            obj = con.newInstance(jobName, properties);
        } else if (getConstructor(runningClreplaced, String.clreplaced, Map.clreplaced) != null) {
            final Constructor<?> con = getConstructor(runningClreplaced, String.clreplaced, Map.clreplaced);
            logger.info("Constructor found " + con.toGenericString());
            final HashMap<Object, Object> map = new HashMap<>();
            for (final Map.Entry<Object, Object> entry : properties.entrySet()) {
                map.put(entry.getKey(), entry.getValue());
            }
            obj = con.newInstance(jobName, map);
        } else if (getConstructor(runningClreplaced, String.clreplaced) != null) {
            final Constructor<?> con = getConstructor(runningClreplaced, String.clreplaced);
            logger.info("Constructor found " + con.toGenericString());
            obj = con.newInstance(jobName);
        } else if (getConstructor(runningClreplaced) != null) {
            final Constructor<?> con = getConstructor(runningClreplaced);
            logger.info("Constructor found " + con.toGenericString());
            obj = con.newInstance();
        } else {
            logger.error("Constructor not found. Listing available Constructors.");
            for (final Constructor<?> c : runningClreplaced.getConstructors()) {
                logger.info(c.toGenericString());
            }
        }
        return obj;
    }

    private static Constructor<?> getConstructor(final Clreplaced<?> c, final Clreplaced<?>... args) {
        try {
            final Constructor<?> cons = c.getConstructor(args);
            return cons;
        } catch (final NoSuchMethodException e) {
            return null;
        }
    }

    private void runMethod(final Object obj, final String runMethod) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        obj.getClreplaced().getMethod(runMethod, new Clreplaced<?>[] {}).invoke(obj);
    }

    private void outputGeneratedProperties(final Props outputProperties) {
        if (outputProperties == null) {
            this._logger.info("  no gend props");
            return;
        }
        for (final String key : outputProperties.getKeySet()) {
            this._logger.info("  gend prop " + key + " value:" + outputProperties.get(key));
        }
        final String outputFileStr = System.getenv(ProcessJob.JOB_OUTPUT_PROP_FILE);
        if (outputFileStr == null) {
            return;
        }
        this._logger.info("Outputting generated properties to " + outputFileStr);
        final Map<String, String> properties = new LinkedHashMap<>();
        for (final String key : outputProperties.getKeySet()) {
            properties.put(key, outputProperties.get(key));
        }
        OutputStream writer = null;
        try {
            writer = new BufferedOutputStream(new FileOutputStream(outputFileStr));
            // Manually serialize into JSON instead of adding org.json to
            // external clreplacedpath. Reduces one dependency for something that's
            // essentially easy.
            writer.write("{\n".getBytes(StandardCharsets.UTF_8));
            for (final Map.Entry<String, String> entry : properties.entrySet()) {
                writer.write(String.format("  \"%s\":\"%s\",\n", entry.getKey().replace("\"", "\\\\\""), entry.getValue().replace("\"", "\\\\\"")).getBytes(StandardCharsets.UTF_8));
            }
            writer.write("}".getBytes(StandardCharsets.UTF_8));
        } catch (final Exception e) {
            throw new RuntimeException("Unable to store output properties to: " + outputFileStr);
        } finally {
            try {
                if (writer != null) {
                    writer.close();
                }
            } catch (final IOException e) {
            }
        }
    }

    public void cancelJob() {
        if (this._isFinished) {
            return;
        }
        this._logger.info("Attempting to call cancel on this job");
        if (this._javaObject != null) {
            Method method = null;
            try {
                method = this._javaObject.getClreplaced().getMethod(this._cancelMethod);
            } catch (final SecurityException e) {
            } catch (final NoSuchMethodException e) {
            }
            if (method != null) {
                try {
                    method.invoke(this._javaObject);
                } catch (final Exception e) {
                    if (this._logger != null) {
                        this._logger.error("Cancel method failed! ", e);
                    }
                }
            } else {
                throw new RuntimeException("Job " + this._jobName + " does not have cancel method " + this._cancelMethod);
            }
        }
    }
}

18 View Complete Implementation : PluginLogFile.java
Copyright Apache License 2.0
Author : gerrit-review
public abstract clreplaced PluginLogFile implements LifecycleListener {

    private final SystemLog systemLog;

    private final ServerInformation serverInfo;

    private final String logName;

    private final Layout layout;

    public PluginLogFile(SystemLog systemLog, ServerInformation serverInfo, String logName, Layout layout) {
        this.systemLog = systemLog;
        this.serverInfo = serverInfo;
        this.logName = logName;
        this.layout = layout;
    }

    @Override
    public void start() {
        AsyncAppender asyncAppender = systemLog.createAsyncAppender(logName, layout);
        Logger logger = LogManager.getLogger(logName);
        logger.removeAppender(logName);
        logger.addAppender(asyncAppender);
        logger.setAdditivity(false);
    }

    @Override
    public void stop() {
        // stop is called when plugin is unloaded or when the server shutdown.
        // Only clean up when the server is shutting down to prevent issue when a
        // plugin is reloaded. The issue is that gerrit load the new plugin and then
        // unload the old one so because loggers are static, the unload of the old
        // plugin would remove the appenders just created by the new plugin.
        if (serverInfo.getState() == ServerInformation.State.SHUTDOWN) {
            LogManager.getLogger(logName).removeAllAppenders();
        }
    }
}

18 View Complete Implementation : Log4jConsoleAppender.java
Copyright Apache License 2.0
Author : pentaho
/**
 * @deprecated As of release 7.0, use log4j appender {@link org.apache.log4j.ConsoleAppender} instead
 */
@Deprecated
public clreplaced Log4jConsoleAppender implements Appender {

    private Layout layout;

    private Filter filter;

    private String name;

    public Log4jConsoleAppender() {
    }

    public void addFilter(Filter filter) {
        this.filter = filter;
    }

    public Filter getFilter() {
        return filter;
    }

    public void clearFilters() {
        filter = null;
    }

    public void close() {
    }

    public void doAppend(LoggingEvent event) {
        String line = layout.format(event);
        System.out.println(line);
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setErrorHandler(ErrorHandler arg0) {
    }

    public ErrorHandler getErrorHandler() {
        return null;
    }

    public void setLayout(Layout layout) {
        this.layout = layout;
    }

    public Layout getLayout() {
        return layout;
    }

    public boolean requiresLayout() {
        return true;
    }

    public void setFilter(Filter filter) {
        this.filter = filter;
    }
}

18 View Complete Implementation : Log4jFileAppender.java
Copyright Apache License 2.0
Author : pentaho
public clreplaced Log4jFileAppender implements Appender {

    private Layout layout;

    private Filter filter;

    private FileObject file;

    private String name;

    private OutputStream fileOutputStream;

    public Log4jFileAppender(FileObject file) throws IOException {
        this.file = file;
        fileOutputStream = KettleVFS.getOutputStream(file, false);
    }

    public Log4jFileAppender(FileObject file, boolean append) throws IOException {
        this.file = file;
        fileOutputStream = KettleVFS.getOutputStream(file, append);
    }

    public void addFilter(Filter filter) {
        this.filter = filter;
    }

    public Filter getFilter() {
        return filter;
    }

    public void clearFilters() {
        filter = null;
    }

    public void close() {
        try {
            fileOutputStream.close();
        } catch (IOException e) {
            System.out.println("Unable to close Logging file [" + file.getName() + "] : " + e.getMessage());
        }
    }

    public void doAppend(LoggingEvent event) {
        String line = layout.format(event) + Const.CR;
        try {
            fileOutputStream.write(line.getBytes(Const.XML_ENCODING));
        } catch (IOException e) {
            System.out.println("Unable to close Logging file [" + file.getName() + "] : " + e.getMessage());
        }
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setErrorHandler(ErrorHandler arg0) {
    }

    public ErrorHandler getErrorHandler() {
        return null;
    }

    public void setLayout(Layout layout) {
        this.layout = layout;
    }

    public Layout getLayout() {
        return layout;
    }

    public boolean requiresLayout() {
        return true;
    }

    public FileObject getFile() {
        return file;
    }

    public void setFilename(FileObject file) {
        this.file = file;
    }

    public OutputStream getFileOutputStream() {
        return fileOutputStream;
    }

    public void setFileOutputStream(OutputStream fileOutputStream) {
        this.fileOutputStream = fileOutputStream;
    }

    public void setFilter(Filter filter) {
        this.filter = filter;
    }
}

18 View Complete Implementation : MemoryAppender.java
Copyright Apache License 2.0
Author : QSFT
public clreplaced MemoryAppender extends AppenderSkeleton {

    private static Object m_sync = new Object();

    private static List<LoggingEvent> m_current = new ArrayList<LoggingEvent>(20000);

    private static List<LoggingEvent> m_backup = new ArrayList<LoggingEvent>(20000);

    private static Layout m_layout;

    private int m_capacity = 20000;

    public MemoryAppender() {
    }

    public void setCapacity(int capacity) {
        m_capacity = capacity;
        synchronized (m_sync) {
            m_current = new ArrayList<LoggingEvent>(m_capacity);
            m_backup = new ArrayList<LoggingEvent>(m_capacity);
        }
    }

    public int getCapacity() {
        return m_capacity;
    }

    @Override
    public void activateOptions() {
        m_layout = this.layout;
        super.activateOptions();
    }

    @Override
    public void close() {
        if (this.closed)
            return;
        this.closed = true;
    }

    @Override
    public boolean requiresLayout() {
        return true;
    }

    @Override
    protected void append(LoggingEvent event) {
        synchronized (m_sync) {
            if (m_current.size() > m_capacity) {
                List<LoggingEvent> temp = m_current;
                m_current = m_backup;
                m_backup = temp;
                m_current.clear();
            }
            m_current.add(event);
        }
    }

    public static String getLog(String level) {
        Level lvl = level == null ? Level.DEBUG : Level.toLevel(level);
        StringBuilder sb = new StringBuilder();
        synchronized (m_sync) {
            for (LoggingEvent event : m_backup) {
                if (event.getLevel().toInt() < lvl.toInt())
                    continue;
                String log = m_layout.format(event);
                sb.append(log);
            }
            sb.append("\n");
            for (LoggingEvent event : m_current) {
                if (event.getLevel().toInt() < lvl.toInt())
                    continue;
                String log = m_layout.format(event);
                sb.append(log);
            }
            return sb.toString();
        }
    }
}

18 View Complete Implementation : TestYARNRunner.java
Copyright Apache License 2.0
Author : aliyun-beta
@Test(timeout = 20000)
public void testWarnCommandOpts() throws Exception {
    Logger logger = Logger.getLogger(YARNRunner.clreplaced);
    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    Layout layout = new SimpleLayout();
    Appender appender = new WriterAppender(layout, bout);
    logger.addAppender(appender);
    JobConf jobConf = new JobConf();
    jobConf.set(MRJobConfig.MR_AM_ADMIN_COMMAND_OPTS, "-Djava.net.preferIPv4Stack=true -Djava.library.path=foo");
    jobConf.set(MRJobConfig.MR_AM_COMMAND_OPTS, "-Xmx1024m -Djava.library.path=bar");
    YARNRunner yarnRunner = new YARNRunner(jobConf);
    @SuppressWarnings("unused")
    ApplicationSubmissionContext submissionContext = buildSubmitContext(yarnRunner, jobConf);
    String logMsg = bout.toString();
    replacedertTrue(logMsg.contains("WARN - Usage of -Djava.library.path in " + "yarn.app.mapreduce.am.admin-command-opts can cause programs to no " + "longer function if hadoop native libraries are used. These values " + "should be set as part of the LD_LIBRARY_PATH in the app master JVM " + "env using yarn.app.mapreduce.am.admin.user.env config settings."));
    replacedertTrue(logMsg.contains("WARN - Usage of -Djava.library.path in " + "yarn.app.mapreduce.am.command-opts can cause programs to no longer " + "function if hadoop native libraries are used. These values should " + "be set as part of the LD_LIBRARY_PATH in the app master JVM env " + "using yarn.app.mapreduce.am.env config settings."));
}

18 View Complete Implementation : AppenderSkeleton.java
Copyright GNU General Public License v2.0
Author : anomalizer
/**
 * Abstract superclreplaced of the other appenders in the package.
 *
 *  This clreplaced provides the code for common functionality, such as
 *  support for threshold filtering and support for general filters.
 *
 * @since 0.8.1
 * @author Ceki Gülcü
 */
public abstract clreplaced AppenderSkeleton implements Appender, OptionHandler {

    /**
     * The layout variable does not need to be set if the appender
     *      implementation has its own layout.
     */
    protected Layout layout;

    /**
     * Appenders are named.
     */
    protected String name;

    /**
     *     There is no level threshold filtering by default.
     */
    protected Priority threshold;

    /**
     *      It is replacedumed and enforced that errorHandler is never null.
     */
    protected ErrorHandler errorHandler = new OnlyOnceErrorHandler();

    /**
     * The first filter in the filter chain. Set to <code>null</code>
     *      initially.
     */
    protected Filter headFilter;

    /**
     * The last filter in the filter chain.
     */
    protected Filter tailFilter;

    /**
     *     Is this appender closed?
     */
    protected boolean closed = false;

    /**
     * Create new instance.
     */
    public AppenderSkeleton() {
        super();
    }

    /**
     * Create new instance.
     * Provided for compatibility with log4j 1.3.
     *
     * @param isActive true if appender is ready for use upon construction.
     *                 Not used in log4j 1.2.x.
     * @since 1.2.15
     */
    protected AppenderSkeleton(final boolean isActive) {
        super();
    }

    /**
     *     Derived appenders should override this method if option structure
     *     requires it.
     */
    public void activateOptions() {
    }

    /**
     *     Add a filter to end of the filter list.
     *
     *     @since 0.9.0
     */
    public void addFilter(Filter newFilter) {
        if (headFilter == null) {
            headFilter = tailFilter = newFilter;
        } else {
            tailFilter.setNext(newFilter);
            tailFilter = newFilter;
        }
    }

    /**
     *     Subclreplacedes of <code>AppenderSkeleton</code> should implement this
     *     method to perform actual logging. See also {@link #doAppend
     *     AppenderSkeleton.doAppend} method.
     *
     *     @since 0.9.0
     */
    abstract protected void append(LoggingEvent event);

    /**
     *     Clear the filters chain.
     *
     *     @since 0.9.0
     */
    public void clearFilters() {
        headFilter = tailFilter = null;
    }

    /**
     *     Finalize this appender by calling the derived clreplaced'
     *     <code>close</code> method.
     *
     *     @since 0.8.4
     */
    public void finalize() {
        // An appender might be closed then garbage collected. There is no
        // point in closing twice.
        if (this.closed)
            return;
        LogLog.debug("Finalizing appender named [" + name + "].");
        close();
    }

    /**
     *      Return the currently set {@link ErrorHandler} for this
     *      Appender.
     *
     *      @since 0.9.0
     */
    public ErrorHandler getErrorHandler() {
        return this.errorHandler;
    }

    /**
     *     Returns the head Filter.
     *
     *     @since 1.1
     */
    public Filter getFilter() {
        return headFilter;
    }

    /**
     *      Return the first filter in the filter chain for this
     *      Appender. The return value may be <code>null</code> if no is
     *      filter is set.
     */
    public final Filter getFirstFilter() {
        return headFilter;
    }

    /**
     *     Returns the layout of this appender. The value may be null.
     */
    public Layout getLayout() {
        return layout;
    }

    /**
     *     Returns the name of this FileAppender.
     */
    public final String getName() {
        return this.name;
    }

    /**
     *     Returns this appenders threshold level. See the {@link
     *     #setThreshold} method for the meaning of this option.
     *
     *     @since 1.1
     */
    public Priority getThreshold() {
        return threshold;
    }

    /**
     *     Check whether the message level is below the appender's
     *     threshold. If there is no threshold set, then the return value is
     *     always <code>true</code>.
     */
    public boolean isreplacedevereAsThreshold(Priority priority) {
        return ((threshold == null) || priority.isGreaterOrEqual(threshold));
    }

    /**
     * This method performs threshold checks and invokes filters before
     * delegating actual logging to the subclreplacedes specific {@link
     * AppenderSkeleton#append} method.
     */
    public synchronized void doAppend(LoggingEvent event) {
        if (closed) {
            LogLog.error("Attempted to append to closed appender named [" + name + "].");
            return;
        }
        if (!isreplacedevereAsThreshold(event.getLevel())) {
            return;
        }
        Filter f = this.headFilter;
        FILTER_LOOP: while (f != null) {
            switch(f.decide(event)) {
                case Filter.DENY:
                    return;
                case Filter.ACCEPT:
                    break FILTER_LOOP;
                case Filter.NEUTRAL:
                    f = f.getNext();
            }
        }
        this.append(event);
    }

    /**
     *      Set the {@link ErrorHandler} for this Appender.
     *      @since 0.9.0
     */
    public synchronized void setErrorHandler(ErrorHandler eh) {
        if (eh == null) {
            // We do not throw exception here since the cause is probably a
            // bad config file.
            LogLog.warn("You have tried to set a null error-handler.");
        } else {
            this.errorHandler = eh;
        }
    }

    /**
     *     Set the layout for this appender. Note that some appenders have
     *     their own (fixed) layouts or do not use one. For example, the
     *     {@link org.apache.log4j.net.SocketAppender} ignores the layout set
     *     here.
     */
    public void setLayout(Layout layout) {
        this.layout = layout;
    }

    /**
     *     Set the name of this Appender.
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     *     Set the threshold level. All log events with lower level
     *     than the threshold level are ignored by the appender.
     *
     *     <p>In configuration files this option is specified by setting the
     *     value of the <b>Threshold</b> option to a level
     *     string, such as "DEBUG", "INFO" and so on.
     *
     *     @since 0.8.3
     */
    public void setThreshold(Priority threshold) {
        this.threshold = threshold;
    }
}

18 View Complete Implementation : DefaultTestAppender.java
Copyright Apache License 2.0
Author : apache
@Override
public void setLayout(Layout layout) {
}

18 View Complete Implementation : HadoopJavaJobRunnerMain.java
Copyright Apache License 2.0
Author : azkaban
public clreplaced HadoopJavaJobRunnerMain {

    public static final String JOB_CLreplaced = "job.clreplaced";

    public static final String DEFAULT_RUN_METHOD = "run";

    public static final String DEFAULT_CANCEL_METHOD = "cancel";

    // This is the Job interface method to get the properties generated by the
    // job.
    public static final String GET_GENERATED_PROPERTIES_METHOD = "getJobGeneratedProperties";

    public static final String CANCEL_METHOD_PARAM = "method.cancel";

    public static final String RUN_METHOD_PARAM = "method.run";

    public static final String[] PROPS_CLreplacedES = new String[] { "azkaban.utils.Props", "azkaban.common.utils.Props" };

    private static final Layout DEFAULT_LAYOUT = new PatternLayout("%p %m\n");

    public final Logger _logger;

    public String _cancelMethod;

    public String _jobName;

    public Object _javaObject;

    private boolean _isFinished = false;

    private static boolean securityEnabled;

    public static void main(String[] args) throws Exception {
        @SuppressWarnings("unused")
        HadoopJavaJobRunnerMain wrapper = new HadoopJavaJobRunnerMain();
    }

    public HadoopJavaJobRunnerMain() throws Exception {
        Runtime.getRuntime().addShutdownHook(new Thread() {

            @Override
            public void run() {
                cancelJob();
            }
        });
        try {
            _jobName = System.getenv(ProcessJob.JOB_NAME_ENV);
            String jobPropsFile = System.getenv(ProcessJob.JOB_PROP_ENV);
            String privatePropsFile = System.getenv(ProcessJob.JOBTYPE_PRIVATE_PROP_ENV);
            _logger = Logger.getRootLogger();
            _logger.removeAllAppenders();
            ConsoleAppender appender = new ConsoleAppender(DEFAULT_LAYOUT);
            appender.activateOptions();
            _logger.addAppender(appender);
            // Explicitly setting level to INFO
            _logger.setLevel(Level.INFO);
            Properties jobProps = new Properties(), privateProps = new Properties();
            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(jobPropsFile), StandardCharsets.UTF_8));
            jobProps.load(br);
            HadoopConfigurationInjector.injectResources(new Props(null, jobProps));
            if (privatePropsFile != null) {
                br = new BufferedReader(new InputStreamReader(new FileInputStream(privatePropsFile), StandardCharsets.UTF_8));
                privateProps.load(br);
            }
            final Configuration conf = new Configuration();
            UserGroupInformation.setConfiguration(conf);
            securityEnabled = UserGroupInformation.isSecurityEnabled();
            _logger.info("Running job " + _jobName);
            String clreplacedName = jobProps.getProperty(JOB_CLreplaced);
            if (clreplacedName == null) {
                throw new Exception("Clreplaced name is not set.");
            }
            _logger.info("Clreplaced name " + clreplacedName);
            UserGroupInformation loginUser = null;
            UserGroupInformation proxyUser = null;
            if (shouldProxy(jobProps)) {
                String userToProxy = jobProps.getProperty("user.to.proxy");
                if (securityEnabled) {
                    String filelocation = System.getenv(HADOOP_TOKEN_FILE_LOCATION);
                    _logger.info("Found token file " + filelocation);
                    _logger.info("Security enabled is " + UserGroupInformation.isSecurityEnabled());
                    _logger.info("Setting mapreduce.job.credentials.binary to " + filelocation);
                    System.setProperty("mapreduce.job.credentials.binary", filelocation);
                    _logger.info("Proxying enabled.");
                    loginUser = UserGroupInformation.getLoginUser();
                    _logger.info("Current logged in user is " + loginUser.getUserName());
                    proxyUser = UserGroupInformation.createProxyUser(userToProxy, loginUser);
                    for (Token<?> token : loginUser.getTokens()) {
                        proxyUser.addToken(token);
                    }
                    proxyUser.addCredentials(loginUser.getCredentials());
                } else {
                    proxyUser = UserGroupInformation.createRemoteUser(userToProxy);
                    if (jobProps.getProperty(Constants.JobProperties.ENABLE_OAUTH, "false").equals("true")) {
                        proxyUser.addCredentials(UserGroupInformation.getLoginUser().getCredentials());
                    }
                }
                _logger.info("Proxied as user " + userToProxy);
                // Create the object using proxy
                _javaObject = getObjectAsProxyUser(jobProps, privateProps, _logger, _jobName, clreplacedName, proxyUser);
            } else {
                // Create the object
                _javaObject = getObject(_jobName, clreplacedName, jobProps, privateProps, _logger);
            }
            if (_javaObject == null) {
                _logger.info("Could not create java object to run job: " + clreplacedName);
                throw new Exception("Could not create running object");
            }
            _logger.info("Got object " + _javaObject.toString());
            _cancelMethod = jobProps.getProperty(CANCEL_METHOD_PARAM, DEFAULT_CANCEL_METHOD);
            final String runMethod = jobProps.getProperty(RUN_METHOD_PARAM, DEFAULT_RUN_METHOD);
            if (shouldProxy(jobProps)) {
                _logger.info("Proxying enabled.");
                runMethodAsUser(_javaObject, runMethod, proxyUser);
            } else {
                _logger.info("Proxy check failed, not proxying run.");
                runMethod(_javaObject, runMethod);
            }
            _isFinished = true;
            // Get the generated properties and store them to disk, to be read
            // by ProcessJob.
            try {
                final Method generatedPropertiesMethod = _javaObject.getClreplaced().getMethod(GET_GENERATED_PROPERTIES_METHOD, new Clreplaced<?>[] {});
                Object outputGendProps = generatedPropertiesMethod.invoke(_javaObject, new Object[] {});
                if (outputGendProps != null) {
                    final Method toPropertiesMethod = outputGendProps.getClreplaced().getMethod("toProperties", new Clreplaced<?>[] {});
                    Properties properties = (Properties) toPropertiesMethod.invoke(outputGendProps, new Object[] {});
                    Props outputProps = new Props(null, properties);
                    outputGeneratedProperties(outputProps);
                } else {
                    _logger.info(GET_GENERATED_PROPERTIES_METHOD + " method returned null.  No properties to preplaced along");
                }
            } catch (NoSuchMethodException e) {
                _logger.info(String.format("Apparently there isn't a method[%s] on object[%s], using " + "empty Props object instead.", GET_GENERATED_PROPERTIES_METHOD, _javaObject));
                outputGeneratedProperties(new Props());
            }
        } catch (Exception e) {
            _isFinished = true;
            throw e;
        }
    }

    private void runMethodAsUser(final Object obj, final String runMethod, final UserGroupInformation ugi) throws IOException, InterruptedException, UndeclaredThrowableException {
        ugi.doAs((PrivilegedExceptionAction<Void>) () -> {
            Configuration conf = new Configuration();
            if (System.getenv(HADOOP_TOKEN_FILE_LOCATION) != null) {
                conf.set(MAPREDUCE_JOB_CREDENTIALS_BINARY, System.getenv(HADOOP_TOKEN_FILE_LOCATION));
            }
            runMethod(obj, runMethod);
            return null;
        });
    }

    private void runMethod(Object obj, String runMethod) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        final Method method = obj.getClreplaced().getMethod(runMethod, new Clreplaced<?>[] {});
        _logger.info("Beginning execution of external code: " + runMethod);
        method.invoke(obj);
        _logger.info("Completed execution of external code: " + runMethod);
    }

    private void outputGeneratedProperties(Props outputProperties) {
        _logger.info("Outputting generated properties to " + ProcessJob.JOB_OUTPUT_PROP_FILE);
        if (outputProperties == null) {
            _logger.info("  no gend props");
            return;
        }
        for (String key : outputProperties.getKeySet()) {
            _logger.info("  gend prop " + key + " value:" + outputProperties.get(key));
        }
        String outputFileStr = System.getenv(ProcessJob.JOB_OUTPUT_PROP_FILE);
        if (outputFileStr == null) {
            return;
        }
        Map<String, String> properties = new LinkedHashMap<String, String>();
        for (String key : outputProperties.getKeySet()) {
            properties.put(key, outputProperties.get(key));
        }
        Writer writer = null;
        try {
            // writer = new BufferedWriter(new FileWriter(outputFileStr));
            writer = Files.newBufferedWriter(Paths.get(outputFileStr), Charset.defaultCharset());
            JSONUtils.writePropsNoJarDependency(properties, writer);
        } catch (Exception e) {
        } finally {
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                }
            }
        }
    }

    public void cancelJob() {
        if (_isFinished) {
            return;
        }
        _logger.info("Attempting to call cancel on this job");
        if (_javaObject != null) {
            Method method = null;
            try {
                method = _javaObject.getClreplaced().getMethod(_cancelMethod);
            } catch (SecurityException e) {
            } catch (NoSuchMethodException e) {
            }
            if (method != null) {
                try {
                    method.invoke(_javaObject);
                } catch (Exception e) {
                    _logger.error("Cancel method failed! ", e);
                }
            } else {
                throw new RuntimeException("Job " + _jobName + " does not have cancel method " + _cancelMethod);
            }
        }
    }

    private static Object getObjectAsProxyUser(final Properties jobProp, final Properties privateProp, final Logger logger, final String jobName, final String clreplacedName, final UserGroupInformation ugi) throws Exception {
        return ugi.doAs((PrivilegedExceptionAction<Object>) () -> getObject(jobName, clreplacedName, jobProp, privateProp, logger));
    }

    private static Object getObject(final String jobName, final String clreplacedName, final Properties jobProperties, final Properties privateProperties, Logger logger) throws Exception {
        Clreplaced<?> runningClreplaced = HadoopJavaJobRunnerMain.clreplaced.getClreplacedLoader().loadClreplaced(clreplacedName);
        if (runningClreplaced == null) {
            throw new Exception("Clreplaced " + clreplacedName + " was not found. Cannot run job.");
        }
        Clreplaced<?> propsClreplaced = null;
        for (String propClreplacedName : PROPS_CLreplacedES) {
            try {
                propsClreplaced = HadoopJavaJobRunnerMain.clreplaced.getClreplacedLoader().loadClreplaced(propClreplacedName);
            } catch (ClreplacedNotFoundException e) {
            }
            if (propsClreplaced != null && ((getConstructor(runningClreplaced, String.clreplaced, propsClreplaced) != null) || (getConstructor(runningClreplaced, String.clreplaced, propsClreplaced, propsClreplaced) != null))) {
                // is this the props clreplaced
                break;
            }
            propsClreplaced = null;
        }
        Object obj = null;
        if (propsClreplaced != null) {
            // Create jobProps clreplaced
            Constructor<?> jobPropsCon = getConstructor(propsClreplaced, propsClreplaced, Properties[].clreplaced);
            Object jobProps = jobPropsCon.newInstance(null, new Properties[] { jobProperties });
            Constructor<?> con = getConstructor(runningClreplaced, String.clreplaced, propsClreplaced);
            if (con != null) {
                logger.info("Constructor found " + con.toGenericString());
                obj = con.newInstance(jobName, jobProps);
            } else {
                // Handle cases where jobtype has constructor of format
                // (java.lang.String,azkaban.utils.Props,azkaban.utils.Props)
                con = getConstructor(runningClreplaced, String.clreplaced, propsClreplaced, propsClreplaced);
                if (con != null) {
                    // Create privateProps clreplaced
                    Constructor<?> privatePropsCon = getConstructor(propsClreplaced, propsClreplaced, Properties[].clreplaced);
                    Object privateProps = privatePropsCon.newInstance(null, new Properties[] { privateProperties });
                    logger.info("Constructor found " + con.toGenericString());
                    obj = con.newInstance(jobName, privateProps, jobProps);
                }
            }
        } else if (getConstructor(runningClreplaced, String.clreplaced, Properties.clreplaced) != null) {
            Constructor<?> con = getConstructor(runningClreplaced, String.clreplaced, Properties.clreplaced);
            logger.info("Constructor found " + con.toGenericString());
            obj = con.newInstance(jobName, jobProperties);
        } else if (getConstructor(runningClreplaced, String.clreplaced, Map.clreplaced) != null) {
            Constructor<?> con = getConstructor(runningClreplaced, String.clreplaced, Map.clreplaced);
            logger.info("Constructor found " + con.toGenericString());
            HashMap<Object, Object> map = new HashMap<Object, Object>();
            for (Map.Entry<Object, Object> entry : jobProperties.entrySet()) {
                map.put(entry.getKey(), entry.getValue());
            }
            obj = con.newInstance(jobName, map);
        } else if (getConstructor(runningClreplaced, String.clreplaced) != null) {
            Constructor<?> con = getConstructor(runningClreplaced, String.clreplaced);
            logger.info("Constructor found " + con.toGenericString());
            obj = con.newInstance(jobName);
        } else if (getConstructor(runningClreplaced) != null) {
            Constructor<?> con = getConstructor(runningClreplaced);
            logger.info("Constructor found " + con.toGenericString());
            obj = con.newInstance();
        } else {
            logger.error("Constructor not found. Listing available Constructors.");
            for (Constructor<?> c : runningClreplaced.getConstructors()) {
                logger.info(c.toGenericString());
            }
        }
        return obj;
    }

    private static Constructor<?> getConstructor(Clreplaced<?> c, Clreplaced<?>... args) {
        try {
            return c.getConstructor(args);
        } catch (NoSuchMethodException e) {
            return null;
        }
    }

    public boolean shouldProxy(Properties props) {
        String shouldProxy = props.getProperty(HadoopSecurityManager.ENABLE_PROXYING);
        return shouldProxy != null && shouldProxy.equals("true");
    }
}

18 View Complete Implementation : PluginLogFile.java
Copyright Apache License 2.0
Author : GerritCodeReview
public abstract clreplaced PluginLogFile implements LifecycleListener {

    private final SystemLog systemLog;

    private final ServerInformation serverInfo;

    private final String logName;

    private final Layout layout;

    public PluginLogFile(SystemLog systemLog, ServerInformation serverInfo, String logName, Layout layout) {
        this.systemLog = systemLog;
        this.serverInfo = serverInfo;
        this.logName = logName;
        this.layout = layout;
    }

    @Override
    public void start() {
        AsyncAppender asyncAppender = systemLog.createAsyncAppender(logName, layout, true, true);
        Logger logger = LogManager.getLogger(logName);
        logger.removeAppender(logName);
        logger.addAppender(asyncAppender);
        logger.setAdditivity(false);
    }

    @Override
    public void stop() {
        // stop is called when plugin is unloaded or when the server shutdown.
        // Only clean up when the server is shutting down to prevent issue when a
        // plugin is reloaded. The issue is that gerrit load the new plugin and then
        // unload the old one so because loggers are static, the unload of the old
        // plugin would remove the appenders just created by the new plugin.
        if (serverInfo.getState() == ServerInformation.State.SHUTDOWN) {
            LogManager.getLogger(logName).removeAllAppenders();
        }
    }
}

18 View Complete Implementation : TestYARNRunner.java
Copyright Apache License 2.0
Author : apache
@Test(timeout = 20000)
public void testWarnCommandOpts() throws Exception {
    org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(YARNRunner.clreplaced);
    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    Layout layout = new SimpleLayout();
    Appender appender = new WriterAppender(layout, bout);
    logger.addAppender(appender);
    JobConf jobConf = new JobConf();
    jobConf.set(MRJobConfig.MR_AM_ADMIN_COMMAND_OPTS, "-Djava.net.preferIPv4Stack=true -Djava.library.path=foo");
    jobConf.set(MRJobConfig.MR_AM_COMMAND_OPTS, "-Xmx1024m -Djava.library.path=bar");
    YARNRunner yarnRunner = new YARNRunner(jobConf);
    @SuppressWarnings("unused")
    ApplicationSubmissionContext submissionContext = buildSubmitContext(yarnRunner, jobConf);
    String logMsg = bout.toString();
    replacedertTrue(logMsg.contains("WARN - Usage of -Djava.library.path in " + "yarn.app.mapreduce.am.admin-command-opts can cause programs to no " + "longer function if hadoop native libraries are used. These values " + "should be set as part of the LD_LIBRARY_PATH in the app master JVM " + "env using yarn.app.mapreduce.am.admin.user.env config settings."));
    replacedertTrue(logMsg.contains("WARN - Usage of -Djava.library.path in " + "yarn.app.mapreduce.am.command-opts can cause programs to no longer " + "function if hadoop native libraries are used. These values should " + "be set as part of the LD_LIBRARY_PATH in the app master JVM env " + "using yarn.app.mapreduce.am.env config settings."));
}

18 View Complete Implementation : AppenderWrapper.java
Copyright Apache License 2.0
Author : apache
@Override
public void setLayout(Layout layout) {
// Log4j 2 doesn't support this.
}

18 View Complete Implementation : ConsoleAppenderBuilder.java
Copyright Apache License 2.0
Author : apache
private <T extends Log4j1Configuration> Appender createAppender(String name, Layout layout, Filter filter, String level, String target, T configuration) {
    org.apache.logging.log4j.core.Layout<?> consoleLayout = null;
    if (layout instanceof LayoutWrapper) {
        consoleLayout = ((LayoutWrapper) layout).getLayout();
    } else if (layout != null) {
        consoleLayout = new LayoutAdapter(layout);
    }
    org.apache.logging.log4j.core.Filter consoleFilter = buildFilters(level, filter);
    ConsoleAppender.Target consoleTarget = SYSTEM_ERR.equals(target) ? ConsoleAppender.Target.SYSTEM_ERR : ConsoleAppender.Target.SYSTEM_OUT;
    return new AppenderWrapper(ConsoleAppender.newBuilder().setName(name).setTarget(consoleTarget).setLayout(consoleLayout).setFilter(consoleFilter).setConfiguration(configuration).build());
}

18 View Complete Implementation : PropertiesConfiguration.java
Copyright Apache License 2.0
Author : apache
private Layout buildLayout(String layoutPrefix, String clreplacedName, String appenderName, Properties props) {
    Layout layout = newInstanceOf(clreplacedName, "Layout");
    if (layout == null) {
        return null;
    }
    LOGGER.debug("Parsing layout options for \"{}\".", appenderName);
    PropertySetter.setProperties(layout, props, layoutPrefix + ".");
    LOGGER.debug("End of parsing for \"{}\".", appenderName);
    return layout;
}

18 View Complete Implementation : RingBufferAppender.java
Copyright GNU General Public License v3.0
Author : apavlo
public String[] getLogMessages() {
    LoggingEvent[] events = this.getLogEvents();
    String[] ret = new String[events.length];
    Layout layout = this.getLayout();
    for (int i = 0; i < events.length; i++) {
        ret[i] = layout.format(events[i]);
    }
    // FOR
    return (ret);
}

18 View Complete Implementation : StringAppender.java
Copyright GNU General Public License v3.0
Author : apavlo
/*
     * (non-Javadoc)
     * @see org.apache.log4j.Appender#setLayout(org.apache.log4j.Layout)
     */
@Override
public void setLayout(Layout arg0) {
// TODO Auto-generated method stub
}

18 View Complete Implementation : LogTransformerImpl.java
Copyright BSD 2-Clause "Simplified" License
Author : atlascommunity
@Component
public clreplaced LogTransformerImpl implements LogTransformer {

    private final Layout layout = new PatternLayout("%d %-5p [%t]: %m%n");

    @Override
    public String formatLog(List<LoggingEvent> events) {
        if (events == null || events.size() == 0) {
            return null;
        }
        return events.stream().map(layout::format).collect(Collectors.joining(""));
    }
}

18 View Complete Implementation : ReportAppender.java
Copyright Apache License 2.0
Author : Axway
/* (non-Javadoc)
     * @see org.apache.log4j.AppenderSkeleton#setLayout(org.apache.log4j.Layout)
     */
@Override
public void setLayout(Layout layout) {
    super.setLayout(layout);
}

17 View Complete Implementation : PropertiesConfiguration.java
Copyright Apache License 2.0
Author : apache
public Layout parseLayout(String layoutPrefix, String appenderName, Properties props) {
    String layoutClreplaced = OptionConverter.findAndSubst(layoutPrefix, props);
    if (layoutClreplaced == null) {
        return null;
    }
    Layout layout = manager.parseLayout(layoutClreplaced, layoutPrefix, props, this);
    if (layout == null) {
        layout = buildLayout(layoutPrefix, layoutClreplaced, appenderName, props);
    }
    return layout;
}

17 View Complete Implementation : AbstractDbAppender.java
Copyright Apache License 2.0
Author : Axway
/*
     * (non-Javadoc)
     * 
     * @see org.apache.log4j.AppenderSkeleton#setLayout(org.apache.log4j.Layout)
     */
@Override
public void setLayout(Layout layout) {
    super.setLayout(layout);
    // set the layout to the event processor as well
    if (eventProcessor != null) {
        eventProcessor.setLayout(layout);
    }
}

17 View Complete Implementation : SeleniumRemoteApplication.java
Copyright Apache License 2.0
Author : exactpro
@Override
protected void createLoggerDerived(String logName, String serverLogLevel, String serverLogPattern) throws Exception {
    System.out.println(String.format("createLoggerDerived(%s, %s, %s) is called", logName, serverLogLevel, serverLogPattern));
    Logger rootLogger = Logger.getRootLogger();
    Layout layout = new PatternLayout(serverLogPattern);
    Appender appender = new FileAppender(layout, logName);
    rootLogger.addAppender(appender);
    rootLogger.setLevel(Level.toLevel(serverLogLevel, Level.ALL));
}

17 View Complete Implementation : LogConfig.java
Copyright GNU General Public License v3.0
Author : Hilaver
private void configureLogCatAppender() {
    Logger root = Logger.getRootLogger();
    Layout logCatLayout = new PatternLayout(getLogCatPattern());
    LogCatAppender logCatAppender = new LogCatAppender(logCatLayout);
    root.addAppender(logCatAppender);
}

17 View Complete Implementation : SystemTestAppender.java
Copyright GNU Lesser General Public License v2.1
Author : JVoiceXML
public String getContents(final Layout layout) {
    final StringBuilder content = new StringBuilder();
    synchronized (events) {
        for (LoggingEvent event : events) {
            final String message = layout.format(event);
            content.append(message);
        // final String[] throwable = event.getThrowableStrRep();
        // final String lf = System.getProperty("line.separator");
        // if (throwable != null) {
        // for (String str : throwable) {
        // content.append(str);
        // content.append(lf);
        // }
        // }
        }
    }
    return content.toString();
}

17 View Complete Implementation : TaskAppender.java
Copyright GNU Lesser General Public License v2.1
Author : lucee
@Override
public void setLayout(Layout arg0) {
    appender.setLayout(arg0);
}

17 View Complete Implementation : Log4JAppenderWrapper.java
Copyright Apache License 2.0
Author : ngageoint
@Override
public void setLayout(Layout layout) {
    replacedert (wrappedAppender != null);
    wrappedAppender.setLayout(layout);
}

17 View Complete Implementation : MGLogWriter4j.java
Copyright GNU Lesser General Public License v3.0
Author : OurGrid
/**
 * This clreplaced is a consumer of log events. It's responsible to write the
 * information existent into the each log event in the specified file, with the
 * specified layout.
 */
public clreplaced MGLogWriter4j extends AppenderSkeleton {

    private Layout layout;

    private File logFile;

    private BufferedWriter bw;

    private ArrayList<LoggingEvent> logBuffer = new ArrayList<LoggingEvent>();

    public static final int TIMEOUT = 10000;

    private Dispatcher dispatcher;

    /**
     * HashMap containing writers that had been instantiated
     */
    private static Map<String, MGLogWriter4j> writers = CommonUtils.createSerializableMap();

    /**
     * MyAppender Constructor
     *
     * @param layout the layout to format log messages
     * @param fileName the file to write log
     */
    private MGLogWriter4j(Layout layout, String fileName, boolean newFile) {
        this.layout = layout;
        try {
            logFile = new File(fileName);
            if (newFile) {
                logFile.delete();
                logFile.createNewFile();
            }
        } catch (Exception e) {
            System.err.println("Cannot create log file: \"" + this.logFile.getAbsolutePath() + "\"");
        }
        dispatcher = new Dispatcher(this);
        dispatcher.start();
    }

    /**
     * Return an instance of MGLogWriter4j. We have one instance per file.
     *
     * @param layout the layout to format log messages.
     * @param fileName the file to write log.
     * @param newFile Determines if an existent file must be overwritten.
     * @return an instance of MGLogWriter.
     */
    public static MGLogWriter4j getInstance(Layout layout, String fileName, boolean newFile) {
        File myFile = new File(fileName);
        MGLogWriter4j mglw = writers.get(myFile.getAbsolutePath());
        if (mglw == null) {
            mglw = new MGLogWriter4j(layout, fileName, newFile);
            writers.put(myFile.getAbsolutePath(), mglw);
        }
        return mglw;
    }

    /**
     * Get all LoggingEvent buffered and write's it all on disk, in a log file.
     * Then the log buffer is reseted.
     */
    protected void writeBufferedLogs() {
        synchronized (logBuffer) {
            try {
                bw = new BufferedWriter(new FileWriter(logFile, true));
                while (!logBuffer.isEmpty()) {
                    bw.write(layout.format(logBuffer.get(0)));
                    logBuffer.remove(0);
                }
            } catch (IOException ioe) {
                System.out.println("Cannot write to log file: \"" + this.logFile.getAbsolutePath() + "\"");
            } finally {
                try {
                    bw.close();
                } catch (IOException e) {
                    System.out.println("Cannot close log file: \"" + this.logFile.getAbsolutePath() + "\"");
                }
            }
        }
    }

    /*
	 * (non-Javadoc)
	 * 
	 * @see org.apache.log4j.AppenderSkeleton#append(org.apache.log4j.spi.LoggingEvent)
	 */
    protected void append(LoggingEvent event) {
        // set the Local Information of an event
        event.getLocationInformation();
        synchronized (logBuffer) {
            logBuffer.add(event);
            logBuffer.notifyAll();
        }
    }

    /*
	 * (non-Javadoc)
	 * 
	 * @see org.apache.log4j.Appender#close()
	 */
    public void close() {
    // TODO Auto-generated method stub
    }

    /*
	 * (non-Javadoc)
	 * 
	 * @see org.apache.log4j.Appender#requiresLayout()
	 */
    public boolean requiresLayout() {
        return true;
    }

    /**
     * This clreplaced is a thread that make the MGLogWriter4j waits a sleep time to
     * write buffered logs.
     */
    private clreplaced Dispatcher extends Thread {

        private MGLogWriter4j appender;

        public Dispatcher(MGLogWriter4j appender) {
            this.appender = appender;
            this.setDaemon(true);
            this.setName("Log Writer");
        }

        public void run() {
            while (true) {
                try {
                    Thread.sleep(MGLogWriter4j.TIMEOUT);
                } catch (InterruptedException e) {
                // does nothing
                }
                appender.writeBufferedLogs();
            }
        }
    }
}

17 View Complete Implementation : XMLLogWriter4j.java
Copyright GNU Lesser General Public License v3.0
Author : OurGrid
/**
 * This clreplaced  is a consumer of log events. It's responsable to write the information existent into the each log event, in xml format, in a specified
 * file, with the specified layout.
 */
public clreplaced XMLLogWriter4j extends AppenderSkeleton {

    private Layout layout;

    private File logFile;

    private BufferedWriter bw;

    private ArrayList<LoggingEvent> logBuffer = new ArrayList<LoggingEvent>();

    public static final int TIMEOUT = 10000;

    private Dispatcher dispatcher;

    /**
     * HashMap containing writers that had been instantiated
     */
    private static Map<String, XMLLogWriter4j> writers = CommonUtils.createSerializableMap();

    /**
     * MyAppender Constructor
     * @param layout the layout
     * @param fileName the file to logging
     */
    private XMLLogWriter4j(Layout layout, String fileName, boolean newFile) {
        this.layout = layout;
        try {
            logFile = new File(fileName);
            if (newFile) {
                logFile.delete();
                logFile.createNewFile();
            }
        } catch (Exception e) {
            System.err.println("Cannot create XML log file: \"" + this.logFile.getAbsolutePath() + "\"");
        }
        dispatcher = new Dispatcher(this);
        dispatcher.start();
    }

    /**
     * Return an instance of XMLLogWriter4j. We have one instance per file.
     * @param layout the layout to format log messages.
     * @param fileName the file to write log.
     * @param newFile Determines if an existent file must be overwrited.
     * @return an instance of XMLLogWriter4j.
     */
    public static XMLLogWriter4j getInstance(Layout layout, String fileName, boolean newFile) {
        File myFile = new File(fileName);
        XMLLogWriter4j writer = writers.get(myFile.getAbsolutePath());
        if (writer == null) {
            writer = new XMLLogWriter4j(layout, fileName, newFile);
            writers.put(myFile.getAbsolutePath(), writer);
        }
        return writer;
    }

    /**
     * Get all LoggingEvent buffered and write's it all on disk, in a log file. Then the log buffer is reseted.
     */
    protected void writeBufferedLogs() {
        synchronized (logBuffer) {
            try {
                bw = new BufferedWriter(new FileWriter(logFile, true));
                while (!logBuffer.isEmpty()) {
                    bw.write(layout.format(logBuffer.get(0)));
                    logBuffer.remove(0);
                }
            } catch (IOException ioe) {
                System.out.println("Cannot write to XML log file: \"" + this.logFile.getAbsolutePath() + "\"");
            } finally {
                try {
                    bw.close();
                } catch (IOException e) {
                    System.out.println("Cannot close to XML log file: \"" + this.logFile.getAbsolutePath() + "\"");
                }
            }
        }
    }

    /* (non-Javadoc)
	 * @see org.apache.log4j.AppenderSkeleton#append(org.apache.log4j.spi.LoggingEvent)
	 */
    protected void append(LoggingEvent event) {
        // set the Local Information of an event
        event.getLocationInformation();
        synchronized (logBuffer) {
            logBuffer.add(event);
            logBuffer.notifyAll();
        }
    }

    /* (non-Javadoc)
	 * @see org.apache.log4j.Appender#close()
	 */
    public void close() {
    }

    /* (non-Javadoc)
	 * @see org.apache.log4j.Appender#requiresLayout()
	 */
    public boolean requiresLayout() {
        return true;
    }

    /**
     * @author augusto
     *
     * This clreplaced is a thread that make the MGLogWriter4j waits a sleep time to write buffered logs.
     */
    private clreplaced Dispatcher extends Thread {

        private XMLLogWriter4j appender;

        /**
         * @param appender
         * @param logBuffer
         */
        public Dispatcher(XMLLogWriter4j appender) {
            this.appender = appender;
            this.setDaemon(true);
            this.setName("Log Writer");
        }

        public void run() {
            while (true) {
                try {
                    Thread.sleep(XMLLogWriter4j.TIMEOUT);
                } catch (InterruptedException e) {
                // does nothing
                }
                appender.writeBufferedLogs();
            }
        }
    }
}

17 View Complete Implementation : Log4jStringAppender.java
Copyright Apache License 2.0
Author : pentaho
/**
 * @deprecated please use the centralized CentralLogStore to get your log lines from.
 * Preplaced the log channel id of the parent object that you want the log for.
 *
 * @author matt
 */
@Deprecated
public clreplaced Log4jStringAppender implements Appender {

    private Layout layout;

    private Filter filter;

    private String name;

    private StringBuffer buffer;

    private int nrLines;

    private int maxNrLines;

    private List<BufferChangedListener> bufferChangedListeners;

    public Log4jStringAppender() {
        buffer = new StringBuffer();
        nrLines = 0;
        maxNrLines = -1;
        bufferChangedListeners = new ArrayList<BufferChangedListener>();
    }

    public String toString() {
        return buffer.toString();
    }

    public void addFilter(Filter filter) {
        this.filter = filter;
    }

    public Filter getFilter() {
        return filter;
    }

    public void clearFilters() {
        filter = null;
    }

    public void close() {
    }

    public void doAppend(LoggingEvent event) {
        String line = layout.format(event) + Const.CR;
        buffer.append(line);
        // See if we don't have too many lines on board...
        nrLines++;
        if (maxNrLines > 0 && nrLines > maxNrLines) {
            buffer.delete(0, line.length());
            nrLines--;
        }
        for (BufferChangedListener listener : bufferChangedListeners) {
            listener.contentWasAdded(buffer, line, nrLines);
        }
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setErrorHandler(ErrorHandler arg0) {
    }

    public ErrorHandler getErrorHandler() {
        return null;
    }

    public void setLayout(Layout layout) {
        this.layout = layout;
    }

    public Layout getLayout() {
        return layout;
    }

    public boolean requiresLayout() {
        return true;
    }

    public void setFilter(Filter filter) {
        this.filter = filter;
    }

    public StringBuffer getBuffer() {
        return buffer;
    }

    public void setBuffer(StringBuffer buffer) {
        this.buffer = buffer;
    }

    /**
     * @return the maximum number of lines that this buffer contains, 0 or lower means: no limit
     */
    public int getMaxNrLines() {
        return maxNrLines;
    }

    /**
     * @param maxNrLines the maximum number of lines that this buffer should contain, 0 or lower means: no limit
     */
    public void setMaxNrLines(int maxNrLines) {
        this.maxNrLines = maxNrLines;
    }

    /**
     * @return the nrLines
     */
    public int getNrLines() {
        return nrLines;
    }

    public void addBufferChangedListener(BufferChangedListener bufferChangedListener) {
        bufferChangedListeners.add(bufferChangedListener);
    }

    public void removeBufferChangedListener(BufferChangedListener bufferChangedListener) {
        bufferChangedListeners.remove(bufferChangedListener);
    }

    /**
     * @param nrLines the nrLines to set
     */
    public void setNrLines(int nrLines) {
        this.nrLines = nrLines;
    }
}

17 View Complete Implementation : LogWriter.java
Copyright Apache License 2.0
Author : pentaho
/**
 * This clreplaced handles the logging.
 *
 * @author Matt
 * @since 25-04-2003
 *
 * @deprecated As of release 7.0, no longer needed. This clreplaced is used only in
 *             {@link org.pentaho.di.core.logging.CentralLogStore} which is never used in project
 */
@Deprecated
public clreplaced LogWriter {

    // private static Clreplaced<?> PKG = LogWriter.clreplaced; // for i18n purposes, needed by Translator2!!
    private static LogWriter logWriter;

    public static final String STRING_PENTAHO_DI_LOGGER_NAME = "org.pentaho.di";

    public static final String STRING_PENTAHO_DI_CONSOLE_APPENDER = "ConsoleAppender:" + STRING_PENTAHO_DI_LOGGER_NAME;

    // $NON-NLS-1$
    public static final String STRING_PENTAHO_BASERVER_FILE_APPENDER = "PENTAHOFILE";

    // $NON-NLS-1$
    public static final String STRING_PENTAHO_BASERVER_CONSOLE_APPENDER = "PENTAHOCONSOLE";

    // String...
    private int type;

    private String filter;

    // Log4j
    private Logger pentahoLogger;

    private Log4jFileAppender fileAppender;

    private File realFilename;

    private static Layout layout;

    // synchronizing logWriter singleton instance PDI-6840
    public static final synchronized LogWriter getInstance() {
        if (logWriter != null) {
            return logWriter;
        }
        logWriter = new LogWriter();
        return logWriter;
    }

    private LogWriter() {
        pentahoLogger = Logger.getLogger(STRING_PENTAHO_DI_LOGGER_NAME);
        pentahoLogger.setAdditivity(false);
        // ensure all messages get logged in this logger since we filtered it above
        // we do not set the level in the rootLogger so the rootLogger can decide by itself (e.g. in the platform)
        // 
        pentahoLogger.setLevel(Level.ALL);
        layout = new Log4jKettleLayout();
    /*
     * The console output is provided for by Kettle5 itself
    // Add a console logger to see something on the console as well...
    //
    boolean consoleAppenderFound = false;
    Enumeration<?> appenders = pentahoLogger.getAllAppenders();
    while (appenders.hasMoreElements()) {
      Appender appender = (Appender) appenders.nextElement();
      if (appender instanceof ConsoleAppender) {
        consoleAppenderFound = true;
        break;
      }
    }

    // Play it safe, if another console appender exists for org.pentaho, don't add another one...
    //
    if (!consoleAppenderFound) {
      Layout patternLayout = new PatternLayout("%-5p %d{dd-MM HH:mm:ss,SSS} - %m%n");
      ConsoleAppender consoleAppender = new ConsoleAppender(patternLayout);
      consoleAppender.setName(STRING_PENTAHO_DI_CONSOLE_APPENDER);
      pentahoLogger.addAppender(consoleAppender);
    }

    // BELOW : This is covered in log4j.xml
    // Doing it here is not really the right location.
    //

    // Get rid of the VFS info messages...
    //
    LogManager.getLogger("org.apache.commons.vfs").setLevel(Level.WARN);

    // Hide info messages from Jetty too...
    //
    // LogManager.getLogger("org.mortbay.log").setLevel(Level.WARN);
    // LogManager.getLogger("org.slf4j").setLevel(Level.WARN);
     */
    }

    /**
     * Get a new log instance for the specified file if it is not open yet!
     * @param filename The log file to open
     * @param exact is this an exact filename (false: prefix of name in temp directory)
     * @return the LogWriter object
     */
    // synchronizing logWriter singleton instance PDI-6840
    public static final synchronized LogWriter getInstance(String filename, boolean exact) throws KettleException {
        if (logWriter != null) {
            // OK, see if we have a file appender already for this
            // 
            if (logWriter.pentahoLogger.getAppender(LogWriter.createFileAppenderName(filename, exact)) == null) {
                logWriter.fileAppender = createFileAppender(filename, exact);
                logWriter.addAppender(logWriter.fileAppender);
            }
            return logWriter;
        }
        logWriter = new LogWriter(filename, exact);
        return logWriter;
    }

    /**
     * Closes the file appender opened by the getInstance(filename, exact, level) method
     */
    public static final void closeAndRemoveFileAppender() {
        if (logWriter.fileAppender != null) {
            logWriter.fileAppender.close();
            logWriter.pentahoLogger.removeAppender(logWriter.fileAppender);
        }
    }

    private LogWriter(String filename, boolean exact) {
        this();
        try {
            fileAppender = createFileAppender(filename, exact);
            addAppender(fileAppender);
        } catch (Exception e) {
            System.out.println("ERROR OPENING LOG FILE [" + filename + "] --> " + e.toString());
        }
    }

    /**
     * Create a file appender
     * @param filename The (VFS) filename (URL) to write to.
     * @param exact is this an exact filename of a filename to be stored in "java.io.tmp"
     * @return A new file appender
     * @throws KettleFileException In case there is a problem opening the file.
     */
    public static final Log4jFileAppender createFileAppender(String filename, boolean exact) throws KettleFileException {
        try {
            FileObject file;
            if (!exact) {
                file = KettleVFS.createTempFile(filename, ".log", System.getProperty("java.io.tmpdir"));
            } else {
                file = KettleVFS.getFileObject(filename);
            }
            Log4jFileAppender appender = new Log4jFileAppender(file);
            appender.setLayout(new Log4jKettleLayout(true));
            appender.setName(LogWriter.createFileAppenderName(filename, exact));
            return appender;
        } catch (IOException e) {
            throw new KettleFileException("Unable to add Kettle file appender to Log4J", e);
        }
    }

    /**
     * Create a file appender
     * @param filename The (VFS) filename (URL) to write to.
     * @param exact is this an exact filename of a filename to be stored in "java.io.tmp"
     * @param append
     * @return A new file appender
     * @throws KettleFileException In case there is a problem opening the file.
     */
    public static final Log4jFileAppender createFileAppender(String filename, boolean exact, boolean append) throws KettleFileException {
        try {
            FileObject file;
            if (!exact) {
                file = KettleVFS.createTempFile(filename, ".log", System.getProperty("java.io.tmpdir"));
            } else {
                file = KettleVFS.getFileObject(filename);
            }
            Log4jFileAppender appender = new Log4jFileAppender(file, append);
            appender.setLayout(new Log4jKettleLayout(true));
            appender.setName(LogWriter.createFileAppenderName(filename, exact));
            return appender;
        } catch (IOException e) {
            throw new KettleFileException("Unable to add Kettle file appender to Log4J", e);
        }
    }

    public static final String createFileAppenderName(String filename, boolean exact) {
        if (!exact) {
            return "<temp file> : " + filename;
        } else {
            return filename;
        }
    }

    /**
     * @return a new String appender object capable of capturing the log stream.
     * It starts to work the instant you add this appender to the Kettle logger.
     *
     * @deprecated Please use {@link CentralLogStore.getAppender()} instead.  This uses a central logging buffer in stead of a distributed one.
     * It also supports incremental buffer gets, and much more.
     */
    @Deprecated
    public static final Log4jStringAppender createStringAppender() {
        Log4jStringAppender appender = new Log4jStringAppender();
        appender.setLayout(new Log4jKettleLayout(true));
        return appender;
    }

    public static void setConsoleAppenderDebug() {
        Enumeration<?> appenders = Logger.getLogger(STRING_PENTAHO_DI_LOGGER_NAME).getAllAppenders();
        while (appenders.hasMoreElements()) {
            Object appender = appenders.nextElement();
            if (appender instanceof ConsoleAppender || appender instanceof Log4jConsoleAppender) {
                if (appender instanceof ConsoleAppender) {
                    ((ConsoleAppender) appender).setThreshold(Level.DEBUG);
                }
            }
        }
    }

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }

    public boolean close() {
        boolean isNotEmbedded = true;
        try {
            // Close all appenders only if we are not embedded (ie. running a report in BA Server
            // that has a PDI data source is considered embedded)
            Logger logger = Logger.getLogger(STRING_PENTAHO_DI_LOGGER_NAME);
            Enumeration<?> appenders = logger.getAllAppenders();
            while (appenders.hasMoreElements()) {
                final Appender appender = (Appender) appenders.nextElement();
                // Check to see if we have registered BA Server appenders
                if ((appender.getName().compareTo(STRING_PENTAHO_BASERVER_FILE_APPENDER) == 0) || (appender.getName().compareTo(STRING_PENTAHO_BASERVER_CONSOLE_APPENDER) == 0)) {
                    isNotEmbedded = false;
                    break;
                }
            }
            // If we are not embedded, we can safely close all appenders.
            if (isNotEmbedded == true) {
                pentahoLogger.removeAllAppenders();
                LogWriter.unsetLogWriter();
            }
        } catch (Exception e) {
            isNotEmbedded = false;
        }
        return isNotEmbedded;
    }

    // synchronizing logWriter singleton instance PDI-6840
    private static synchronized void unsetLogWriter() {
        logWriter = null;
    }

    /**
     * @param logMessage
     * @param channelLogLevel
     */
    public void println(LogMessageInterface logMessage, LogLevel channelLogLevel) {
        String subject = null;
        LogLevel logLevel = logMessage.getLevel();
        if (!logLevel.isVisible(channelLogLevel)) {
            // not for our eyes.
            return;
        }
        if (subject == null) {
            subject = "Kettle";
        }
        // Are the message filtered?
        // 
        if (!logLevel.isError() && !Utils.isEmpty(filter)) {
            if (subject.indexOf(filter) < 0 && logMessage.toString().indexOf(filter) < 0) {
                // "filter" not found in row: don't show!
                return;
            }
        }
        switch(logLevel) {
            case ERROR:
                pentahoLogger.error(logMessage);
                break;
            case ROWLEVEL:
            case DEBUG:
                pentahoLogger.debug(logMessage);
                break;
            default:
                pentahoLogger.info(logMessage);
                break;
        }
    }

    public void println(LogMessageInterface message, Throwable e, LogLevel channelLogLevel) {
        println(message, channelLogLevel);
        String stackTrace = Const.getStackTracker(e);
        LogMessage traceMessage = new LogMessage(stackTrace, message.getLogChannelId(), LogLevel.ERROR);
        println(traceMessage, channelLogLevel);
    }

    public void setFilter(String filter) {
        this.filter = filter;
    }

    public String getFilter() {
        return filter;
    }

    /**
     * This is not thread safe: please try to get the file appender yourself using the static constructor and work from there
     */
    public InputStream getFileInputStream() throws IOException {
        return KettleVFS.getInputStream(fileAppender.getFile());
    }

    /**
     * This is not thread safe: please try to get the file appender yourself using the static constructor and work from there
     */
    public FileObject getFileAppenderFile() throws IOException {
        return fileAppender.getFile();
    }

    /**
     * Get the file input stream for a certain appender.
     * The appender is looked up using the filename
     * @param filename The exact filename (with path: c:\temp\logfile.txt) or just a filename (spoon.log)
     * @param exact true if this is the exact filename or just the last part of the complete path.
     * @return The file input stream of the appender
     * @throws IOException in case the appender ocan't be found
     */
    public FileInputStream getFileInputStream(String filename, boolean exact) throws IOException {
        Appender appender = pentahoLogger.getAppender(createFileAppenderName(filename, exact));
        if (appender == null) {
            throw new IOException("Unable to find appender for file: " + filename + " (exact=" + exact + ")");
        }
        return new FileInputStream(((Log4jFileAppender) appender).getFile().getName().getPathDecoded());
    }

    /**
     * @return Returns the realFilename.
     */
    public File getRealFilename() {
        return realFilename;
    }

    /**
     * @param realFilename The realFilename to set.
     */
    public void setRealFilename(File realFilename) {
        this.realFilename = realFilename;
    }

    public void addAppender(Appender appender) {
        pentahoLogger.addAppender(appender);
    }

    public void removeAppender(Appender appender) {
        pentahoLogger.removeAppender(appender);
    }

    public static void setLayout(Layout layout) {
        // save for later creation of new files...
        LogWriter.layout = layout;
        Enumeration<?> appenders = logWriter.pentahoLogger.getAllAppenders();
        while (appenders.hasMoreElements()) {
            Appender appender = (Appender) appenders.nextElement();
            if (appender instanceof Log4jConsoleAppender || appender instanceof Log4jFileAppender) {
                appender.setLayout(layout);
            }
        }
    }

    public static Layout getLayout() {
        return layout;
    }

    public Logger getPentahoLogger() {
        return pentahoLogger;
    }
}