You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@logging.apache.org by rp...@apache.org on 2016/09/08 14:51:07 UTC

[38/50] [abbrv] logging-log4j2 git commit: Track stopped state during shutdown (WIP).

Track stopped state during shutdown (WIP).

Project: http://git-wip-us.apache.org/repos/asf/logging-log4j2/repo
Commit: http://git-wip-us.apache.org/repos/asf/logging-log4j2/commit/41ac242d
Tree: http://git-wip-us.apache.org/repos/asf/logging-log4j2/tree/41ac242d
Diff: http://git-wip-us.apache.org/repos/asf/logging-log4j2/diff/41ac242d

Branch: refs/heads/LOG4J2-1349-gcfree-threadcontext
Commit: 41ac242daad2cfcae45b209d420eaca8a21f9837
Parents: f6bb2c3
Author: ggregory <gg...@US-L-GG02.rocketsoftware.com>
Authored: Wed Sep 7 12:55:06 2016 -0400
Committer: ggregory <gg...@US-L-GG02.rocketsoftware.com>
Committed: Wed Sep 7 12:55:06 2016 -0400

----------------------------------------------------------------------
 .../appender/AbstractOutputStreamAppender.java  | 376 +++++++++----------
 1 file changed, 188 insertions(+), 188 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/41ac242d/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AbstractOutputStreamAppender.java
----------------------------------------------------------------------
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AbstractOutputStreamAppender.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AbstractOutputStreamAppender.java
index 1ff4cb9..d4ad3f7 100644
--- a/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AbstractOutputStreamAppender.java
+++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AbstractOutputStreamAppender.java
@@ -1,188 +1,188 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache license, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the license for the specific language governing permissions and
- * limitations under the license.
- */
-package org.apache.logging.log4j.core.appender;
-
-import java.io.Serializable;
-import java.util.concurrent.TimeUnit;
-
-import org.apache.logging.log4j.core.Filter;
-import org.apache.logging.log4j.core.Layout;
-import org.apache.logging.log4j.core.LogEvent;
-import org.apache.logging.log4j.core.config.plugins.PluginBuilderAttribute;
-import org.apache.logging.log4j.core.util.Constants;
-
-/**
- * Appends log events as bytes to a byte output stream. The stream encoding is defined in the layout.
- *
- * @param <M> The kind of {@link OutputStreamManager} under management
- */
-public abstract class AbstractOutputStreamAppender<M extends OutputStreamManager> extends AbstractAppender {
-
-    /**
-     * Subclasses can extend this abstract Builder. 
-     * 
-     * @param <B> This builder class.
-     */
-    public abstract static class Builder<B extends Builder<B>> extends AbstractAppender.Builder<B> {
-    
-        @PluginBuilderAttribute
-        private boolean bufferedIo = true;
-
-        @PluginBuilderAttribute
-        private int bufferSize = Constants.ENCODER_BYTE_BUFFER_SIZE;
-
-        @PluginBuilderAttribute
-        private boolean immediateFlush;
-
-        public int getBufferSize() {
-            return bufferSize;
-        }
-
-        public boolean isBufferedIo() {
-            return bufferedIo;
-        }
-
-        public boolean isImmediateFlush() {
-            return immediateFlush;
-        }
-        
-        public B withImmediateFlush(final boolean immediateFlush) {
-            this.immediateFlush = immediateFlush;
-            return asBuilder();
-        }
-        
-        public B withBufferedIo(final boolean bufferedIo) {
-            this.bufferedIo = bufferedIo;
-            return asBuilder();
-        }
-
-        public B withBufferSize(final int bufferSize) {
-            this.bufferSize = bufferSize;
-            return asBuilder();
-        }
-
-    }
-    
-    /**
-     * Immediate flush means that the underlying writer or output stream will be flushed at the end of each append
-     * operation. Immediate flush is slower but ensures that each append request is actually written. If
-     * <code>immediateFlush</code> is set to {@code false}, then there is a good chance that the last few logs events
-     * are not actually written to persistent media if and when the application crashes.
-     */
-    private final boolean immediateFlush;
-
-    private final M manager;
-
-    /**
-     * Instantiates a WriterAppender and set the output destination to a new {@link java.io.OutputStreamWriter}
-     * initialized with <code>os</code> as its {@link java.io.OutputStream}.
-     *
-     * @param name The name of the Appender.
-     * @param layout The layout to format the message.
-     * @param manager The OutputStreamManager.
-     */
-    protected AbstractOutputStreamAppender(final String name, final Layout<? extends Serializable> layout,
-            final Filter filter, final boolean ignoreExceptions, final boolean immediateFlush, final M manager) {
-        super(name, filter, layout, ignoreExceptions);
-        this.manager = manager;
-        this.immediateFlush = immediateFlush;
-    }
-
-    /**
-     * Gets the immediate flush setting.
-     *
-     * @return immediate flush.
-     */
-    public boolean getImmediateFlush() {
-        return immediateFlush;
-    }
-
-    /**
-     * Gets the manager.
-     *
-     * @return the manager.
-     */
-    public M getManager() {
-        return manager;
-    }
-
-    @Override
-    public void start() {
-        if (getLayout() == null) {
-            LOGGER.error("No layout set for the appender named [" + getName() + "].");
-        }
-        if (manager == null) {
-            LOGGER.error("No OutputStreamManager set for the appender named [" + getName() + "].");
-        }
-        super.start();
-    }
-
-    @Override
-    public boolean stop(final long timeout, final TimeUnit timeUnit) {
-        return stop(timeout, timeUnit, true);
-    }
-
-    @Override
-    protected boolean stop(final long timeout, final TimeUnit timeUnit, final boolean changeLifeCycleState) {
-        super.stop(timeout, timeUnit, changeLifeCycleState);
-        manager.stop(timeout, timeUnit);
-        if (changeLifeCycleState) {
-            setStopped();
-        }
-        return true;
-    }
-
-    /**
-     * Actual writing occurs here.
-     * <p>
-     * Most subclasses of <code>AbstractOutputStreamAppender</code> will need to override this method.
-     * </p>
-     *
-     * @param event The LogEvent.
-     */
-    @Override
-    public void append(final LogEvent event) {
-        try {
-            tryAppend(event);
-        } catch (final AppenderLoggingException ex) {
-            error("Unable to write to stream " + manager.getName() + " for appender " + getName() + ": " + ex);
-            throw ex;
-        }
-    }
-
-    private void tryAppend(final LogEvent event) {
-        if (Constants.ENABLE_DIRECT_ENCODERS) {
-            directEncodeEvent(event);
-        } else {
-            writeByteArrayToManager(event);
-        }
-    }
-
-    protected void directEncodeEvent(final LogEvent event) {
-        getLayout().encode(event, manager);
-        if (this.immediateFlush || event.isEndOfBatch()) {
-            manager.flush();
-        }
-    }
-
-    protected void writeByteArrayToManager(final LogEvent event) {
-        final byte[] bytes = getLayout().toByteArray(event);
-        if (bytes != null && bytes.length > 0) {
-            manager.write(bytes, this.immediateFlush || event.isEndOfBatch());
-        }
-    }
-}
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache license, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the license for the specific language governing permissions and
+ * limitations under the license.
+ */
+package org.apache.logging.log4j.core.appender;
+
+import java.io.Serializable;
+import java.util.concurrent.TimeUnit;
+
+import org.apache.logging.log4j.core.Filter;
+import org.apache.logging.log4j.core.Layout;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.config.plugins.PluginBuilderAttribute;
+import org.apache.logging.log4j.core.util.Constants;
+
+/**
+ * Appends log events as bytes to a byte output stream. The stream encoding is defined in the layout.
+ *
+ * @param <M> The kind of {@link OutputStreamManager} under management
+ */
+public abstract class AbstractOutputStreamAppender<M extends OutputStreamManager> extends AbstractAppender {
+
+    /**
+     * Subclasses can extend this abstract Builder. 
+     * 
+     * @param <B> This builder class.
+     */
+    public abstract static class Builder<B extends Builder<B>> extends AbstractAppender.Builder<B> {
+    
+        @PluginBuilderAttribute
+        private boolean bufferedIo = true;
+
+        @PluginBuilderAttribute
+        private int bufferSize = Constants.ENCODER_BYTE_BUFFER_SIZE;
+
+        @PluginBuilderAttribute
+        private boolean immediateFlush;
+
+        public int getBufferSize() {
+            return bufferSize;
+        }
+
+        public boolean isBufferedIo() {
+            return bufferedIo;
+        }
+
+        public boolean isImmediateFlush() {
+            return immediateFlush;
+        }
+        
+        public B withImmediateFlush(final boolean immediateFlush) {
+            this.immediateFlush = immediateFlush;
+            return asBuilder();
+        }
+        
+        public B withBufferedIo(final boolean bufferedIo) {
+            this.bufferedIo = bufferedIo;
+            return asBuilder();
+        }
+
+        public B withBufferSize(final int bufferSize) {
+            this.bufferSize = bufferSize;
+            return asBuilder();
+        }
+
+    }
+    
+    /**
+     * Immediate flush means that the underlying writer or output stream will be flushed at the end of each append
+     * operation. Immediate flush is slower but ensures that each append request is actually written. If
+     * <code>immediateFlush</code> is set to {@code false}, then there is a good chance that the last few logs events
+     * are not actually written to persistent media if and when the application crashes.
+     */
+    private final boolean immediateFlush;
+
+    private final M manager;
+
+    /**
+     * Instantiates a WriterAppender and set the output destination to a new {@link java.io.OutputStreamWriter}
+     * initialized with <code>os</code> as its {@link java.io.OutputStream}.
+     *
+     * @param name The name of the Appender.
+     * @param layout The layout to format the message.
+     * @param manager The OutputStreamManager.
+     */
+    protected AbstractOutputStreamAppender(final String name, final Layout<? extends Serializable> layout,
+            final Filter filter, final boolean ignoreExceptions, final boolean immediateFlush, final M manager) {
+        super(name, filter, layout, ignoreExceptions);
+        this.manager = manager;
+        this.immediateFlush = immediateFlush;
+    }
+
+    /**
+     * Gets the immediate flush setting.
+     *
+     * @return immediate flush.
+     */
+    public boolean getImmediateFlush() {
+        return immediateFlush;
+    }
+
+    /**
+     * Gets the manager.
+     *
+     * @return the manager.
+     */
+    public M getManager() {
+        return manager;
+    }
+
+    @Override
+    public void start() {
+        if (getLayout() == null) {
+            LOGGER.error("No layout set for the appender named [" + getName() + "].");
+        }
+        if (manager == null) {
+            LOGGER.error("No OutputStreamManager set for the appender named [" + getName() + "].");
+        }
+        super.start();
+    }
+
+    @Override
+    public boolean stop(final long timeout, final TimeUnit timeUnit) {
+        return stop(timeout, timeUnit, true);
+    }
+
+    @Override
+    protected boolean stop(final long timeout, final TimeUnit timeUnit, final boolean changeLifeCycleState) {
+        boolean stopped = super.stop(timeout, timeUnit, changeLifeCycleState);
+        manager.stop(timeout, timeUnit);
+        if (changeLifeCycleState) {
+            setStopped();
+        }
+        return stopped;
+    }
+
+    /**
+     * Actual writing occurs here.
+     * <p>
+     * Most subclasses of <code>AbstractOutputStreamAppender</code> will need to override this method.
+     * </p>
+     *
+     * @param event The LogEvent.
+     */
+    @Override
+    public void append(final LogEvent event) {
+        try {
+            tryAppend(event);
+        } catch (final AppenderLoggingException ex) {
+            error("Unable to write to stream " + manager.getName() + " for appender " + getName() + ": " + ex);
+            throw ex;
+        }
+    }
+
+    private void tryAppend(final LogEvent event) {
+        if (Constants.ENABLE_DIRECT_ENCODERS) {
+            directEncodeEvent(event);
+        } else {
+            writeByteArrayToManager(event);
+        }
+    }
+
+    protected void directEncodeEvent(final LogEvent event) {
+        getLayout().encode(event, manager);
+        if (this.immediateFlush || event.isEndOfBatch()) {
+            manager.flush();
+        }
+    }
+
+    protected void writeByteArrayToManager(final LogEvent event) {
+        final byte[] bytes = getLayout().toByteArray(event);
+        if (bytes != null && bytes.length > 0) {
+            manager.write(bytes, this.immediateFlush || event.isEndOfBatch());
+        }
+    }
+}