java.util.logging.ConsoleHandler Java Examples

@Test
public void testCdiInjection(TestContext context) {
  final ConsoleHandler consoleHandler = new ConsoleHandler();
  consoleHandler.setLevel(Level.FINEST);
  consoleHandler.setFormatter(new SimpleFormatter());

  final Logger app = Logger.getLogger("org.jboss.weld.vertx");
  app.setLevel(Level.FINEST);
  app.addHandler(consoleHandler);

  Async async = context.async();
    webClient.get("/test/injection")
    .as(BodyCodec.string())
    .rxSend()
    .subscribe(body -> {
        context.assertEquals(200, body.statusCode());
        async.complete();
    }, x -> { 
        x.printStackTrace();
        context.fail(x);
        async.complete();
    });
}
 

public static void main(String[] args) {
	Client client = new Client();
	// Set the logger to use our all-on-one-line formatter.
	Logger l = Logger.getLogger("");
	Handler[] hs = l.getHandlers();
	for (int i = 0; i < hs.length; i++) {
		Handler h = hs[0];
		if (h instanceof ConsoleHandler) {
			h.setFormatter(client.new OneLineSimpleLogger());
		}
	}
	try {
		client.execute(args);
	} catch (Exception e) {
		e.printStackTrace();
	}
}
 

public static void main(String[] args) {
	Client client = new Client();
	// Set the logger to use our all-on-one-line formatter.
	Logger l = Logger.getLogger("");
	Handler[] hs = l.getHandlers();
	for (int i = 0; i < hs.length; i++) {
		Handler h = hs[0];
		if (h instanceof ConsoleHandler) {
			h.setFormatter(client.new OneLineSimpleLogger());
		}
	}
	try {
		client.execute(args);
	} catch (Exception e) {
		e.printStackTrace();
	}
}
 

@Before
public void setupLogger() throws Exception {
    Level level = Level.SEVERE;
    Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

        @Override
        public void uncaughtException(Thread t, Throwable e) {
            System.err.println("uncaughtException from thread " + t.getName() + ": " + e);
            e.printStackTrace();
        }
    });
    java.util.logging.LogManager.getLogManager().reset();
    ConsoleHandler ch = new ConsoleHandler();
    ch.setLevel(level);
    SimpleFormatter f = new SimpleFormatter();
    ch.setFormatter(f);
    java.util.logging.Logger.getLogger("").setLevel(level);
    java.util.logging.Logger.getLogger("").addHandler(ch);
}
 

@Test
public void testHeadersArePropagated() throws Exception {
    Logger logger = 
        Logger.getLogger("org.eclipse.microprofile.rest.client.ext.DefaultClientHeadersFactoryImpl"); //NOPMD
    logger.setLevel(Level.ALL);
    ConsoleHandler h = new ConsoleHandler();
    h.setLevel(Level.ALL);
    logger.addHandler(new ConsoleHandler());
    final Response r = createWebClient("/jaxrs/propagate")
        .header("Header1", "Single")
        .header("MultiHeader", "value1", "value2", "value3")
        .get();
    assertEquals(Status.OK.getStatusCode(), r.getStatus());
    String propagatedHeaderContent = r.readEntity(String.class);
    System.out.println("propagatedHeaderContent: " + propagatedHeaderContent);
    assertTrue(propagatedHeaderContent.contains("Header1=Single"));
    assertTrue(propagatedHeaderContent.contains("MultiHeader=value1,value2,value3"));
}
 

@Override
public boolean enableConsoleOut(boolean check) {

    if (check == true) {
        if (this.consoleHandler == null) {
            this.consoleHandler = new ConsoleHandler();
            this.consoleHandler.setLevel(this.level);
            this.consoleHandler.setFormatter(new DefaultLogFormatter());
        }
        log.addHandler(this.consoleHandler);
        isEnableConsoleOutSus = true;
    }
    else {
        if (this.consoleHandler != null) {
            log.removeHandler(this.consoleHandler);
        }
        isEnableConsoleOutSus = false;
    }
		
    return isEnableConsoleOutSus;
}
 

private static void jul() {
    final Logger root = Logger.getLogger("");
    root.setLevel(Level.SEVERE);
    final Handler[] handlers = root.getHandlers();
    Stream.of(handlers).forEach(root::removeHandler);
    final ConsoleHandler handler = new ConsoleHandler() {

        {
            setFormatter(new UnifiedFormatter());
        }

        @Override
        protected synchronized void setOutputStream(final OutputStream out) throws SecurityException {
            super.setOutputStream(new StdErrStream());
        }
    };
    handler.setLevel(Level.SEVERE);
    root.addHandler(handler);
}
 

/**
 * Main entry point for the OpenOffice.org Remote Write Test.
 *
 * @param args arguments of the test
 *
 * @author Andreas Bröker
 * @date 17.08.2006
 */
public static void main(String[] args) {
  if(args.length < 2) {
    System.out.println("NOA Remote Write Test");
    System.out.println("-------------------");
    System.out.println("Usage:");
    System.out.println("RemoteWriteTest <host> <port>");
  }
  else { 
    LogManager.getLogManager().reset();
    ConsoleHandler consoleHandler = new ConsoleHandler();
    consoleHandler.setLevel(Level.FINEST);
    LOGGER.addHandler(consoleHandler);
    LOGGER.setLevel(Level.FINEST);
    
    try {
      FileHandler fileHandler = new FileHandler("log.xml");
      fileHandler.setLevel(Level.FINEST);
      LOGGER.addHandler(fileHandler);
    }
    catch (Throwable throwable) {
    }
    RemoteWriteTest remoteWriteTest = new RemoteWriteTest();
    remoteWriteTest.test(args[0], args[1]);
  }
}
 

/**
 * setup logs that display in a compact way on console
 */
public static void setUpLogsForConsoleDebugging() {
	
	ConsoleHandler consolehandler = new ConsoleHandler();
	consolehandler.setFormatter(new ConsoleFormatter());
	
	Logger anonymouslogger = Logger.getLogger("");
	for (int i = 0; i < anonymouslogger.getHandlers().length; i++) {
		anonymouslogger.removeHandler(anonymouslogger.getHandlers()[i]);
	}
	anonymouslogger.addHandler(consolehandler);
	anonymouslogger.setUseParentHandlers(false);
	anonymouslogger.setLevel(Level.ALL);


	// --------------------------------------------------------------
	Logger rootlogger = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);
	for (int i = 0; i < rootlogger.getHandlers().length; i++) {
		rootlogger.removeHandler(rootlogger.getHandlers()[i]);
	}
	rootlogger.addHandler(consolehandler);
	rootlogger.setUseParentHandlers(false);
	rootlogger.setLevel(Level.ALL);
}
 

/** Set up console handler */
public static Handler setUpConsoleHandler() {
	final ConsoleHandler handler = new ConsoleHandler() {
		@Override
		protected void setOutputStream(final OutputStream out) throws SecurityException {
			super.setOutputStream(System.out);
		}
	};
	handler.setLevel(Level.ALL);
	final Formatter formatter = new Formatter() {
		@Override
		public String format(final LogRecord record) {
			return record.getMessage();
		}
	};
	handler.setFormatter(formatter);
	return handler;
}
 

@Before
public void setupLogger() throws Exception {
    Level level = Level.SEVERE;
    Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

        @Override
        public void uncaughtException(Thread t, Throwable e) {
            System.err.println("uncaughtException from thread " + t.getName() + ": " + e);
            e.printStackTrace();
        }
    });
    java.util.logging.LogManager.getLogManager().reset();
    ConsoleHandler ch = new ConsoleHandler();
    ch.setLevel(level);
    SimpleFormatter f = new SimpleFormatter();
    ch.setFormatter(f);
    java.util.logging.Logger.getLogger("").setLevel(level);
    java.util.logging.Logger.getLogger("").addHandler(ch);
}
 

private static Logger instantiateLogger(final String name, final Level level) {
    final Logger logger = java.util.logging.Logger.getLogger(name);
    for (final Handler h : logger.getHandlers()) {
        logger.removeHandler(h);
    }

    logger.setLevel(level);
    logger.setUseParentHandlers(false);
    final Handler c = new ConsoleHandler();

    c.setFormatter(new Formatter() {
        @Override
        public String format(final LogRecord record) {
            final StringBuilder sb = new StringBuilder();

            sb.append('[')
               .append(record.getLoggerName())
               .append("] ")
               .append(record.getMessage())
               .append('\n');

            return sb.toString();
        }
    });
    logger.addHandler(c);
    c.setLevel(level);

    return logger;
}
 

public DriveSyncProvider(Context context, Supplier<DriveApi> driveSupplier) {
  applicationContext = context.getApplicationContext();
  accountMap = new HashMap<>();

  this.driveSupplier = driveSupplier;

  if (ENABLE_HTTP_TRANSPORT_LOGGING) {
    Logger logger = Logger.getLogger(HttpTransport.class.getName());
    logger.setLevel(Level.ALL);
    ConsoleHandler logHandler = new ConsoleHandler();
    logHandler.setLevel(Level.ALL);
    logger.addHandler(logHandler);
  }
}
 

private static void addDefaultConsoleHandler(Logger logger, String errorMessage, String logFilePath) {
  ConsoleHandler consoleHandler = new ConsoleHandler();
  consoleHandler.setFormatter(new GemFireFormatter());
  logger.addHandler(consoleHandler);

  System.err.println("ERROR: Could not log to file: " + logFilePath + ". Reason: " + errorMessage);
  System.err.println("Logs will be written on Console.");
  try {
    Thread.sleep(3000); //sleep for 3 secs for the message to appear
  } catch (InterruptedException ignore) {}
}
 

public static void initServer() throws Exception {
    String portstring = System.getProperty("port.number");
    port = portstring != null ? Integer.parseInt(portstring) : 0;
    portstring = System.getProperty("port.number1");
    proxyPort = portstring != null ? Integer.parseInt(portstring) : 0;

    Logger logger = Logger.getLogger("com.sun.net.httpserver");
    ConsoleHandler ch = new ConsoleHandler();
    logger.setLevel(Level.ALL);
    ch.setLevel(Level.ALL);
    logger.addHandler(ch);
    String root = System.getProperty ("test.src")+ "/docs";
    InetSocketAddress addr = new InetSocketAddress (port);
    s1 = HttpServer.create (addr, 0);
    if (s1 instanceof HttpsServer) {
        throw new RuntimeException ("should not be httpsserver");
    }
    HttpHandler h = new FileServerHandler (root);
    HttpContext c = s1.createContext ("/files", h);

    HttpHandler h1 = new RedirectHandler ("/redirect");
    HttpContext c1 = s1.createContext ("/redirect", h1);

    executor = Executors.newCachedThreadPool();
    s1.setExecutor (executor);
    s1.start();

    if (port == 0)
        port = s1.getAddress().getPort();
    else {
        if (s1.getAddress().getPort() != port)
            throw new RuntimeException("Error wrong port");
        System.out.println("Port was assigned by Driver");
    }
    System.out.println("HTTP server port = " + port);
    httproot = "http://127.0.0.1:" + port + "/files/";
    redirectroot = "http://127.0.0.1:" + port + "/redirect/";
    uri = new URI(httproot);
    fileuri = httproot + "foo.txt";
}
 

@Before
public final void setUp() {
    this.logger = PowerMock.createNiceMock(Logger.class);
    final ConsoleHandler handler = new ConsoleHandler();
    handler.setLevel(Level.FINEST);
    this.logger.addHandler(handler);
    this.os = new ByteArrayOutputStream();
    this.xmlUtil = XMLUtil.create();
    this.odsElements = PowerMock.createMock(OdsElements.class);
    this.builder = PowerMock.createMock(ZipUTF8WriterBuilderImpl.class);
    this.odsFactory = OdsFactory.create(this.logger, Locale.US);
}
 

SessionLog(File file, String appName) {
	this.file = file;
	logger = Logger.getLogger(appName);
	logger.addHandler(new ConsoleHandler());
	logger.addHandler(new MyFileHandler(file));
	LogManager.getLogManager().addLogger(logger);
}
 

private static Logger instantiateLogger(final String name, final Level level) {
    final Logger logger = java.util.logging.Logger.getLogger(name);
    AccessController.doPrivileged(new PrivilegedAction<Void>() {
        @Override
        public Void run() {
            for (final Handler h : logger.getHandlers()) {
                logger.removeHandler(h);
            }

            logger.setLevel(level);
            logger.setUseParentHandlers(false);
            final Handler c = new ConsoleHandler();

            c.setFormatter(new Formatter() {
                @Override
                public String format(final LogRecord record) {
                    final StringBuilder sb = new StringBuilder();

                    sb.append('[')
                    .append(record.getLoggerName())
                    .append("] ")
                    .append(record.getMessage())
                    .append('\n');

                    return sb.toString();
                }
            });
            logger.addHandler(c);
            c.setLevel(level);
            return null;
        }
    }, createLoggerControlAccCtxt());

    return logger;
}
 

private static Logger instantiateLogger(final String name, final Level level) {
    final Logger logger = java.util.logging.Logger.getLogger(name);
    for (final Handler h : logger.getHandlers()) {
        logger.removeHandler(h);
    }

    logger.setLevel(level);
    logger.setUseParentHandlers(false);
    final Handler c = new ConsoleHandler();

    c.setFormatter(new Formatter() {
        @Override
        public String format(final LogRecord record) {
            final StringBuilder sb = new StringBuilder();

            sb.append('[')
               .append(record.getLoggerName())
               .append("] ")
               .append(record.getMessage())
               .append('\n');

            return sb.toString();
        }
    });
    logger.addHandler(c);
    c.setLevel(level);

    return logger;
}
 

public StatusLogger() {
    super(StatusLogger.class.getName(), null);

    Handler h = new ConsoleHandler();
    h.setFormatter(new StatusOutputFormatter());
    addHandler(h);
    setUseParentHandlers(false);
    setLevel(Level.ALL);
}
 

public ExecutionLogger() {
    super(ExecutionLogger.class.getName(), null);

    Handler h = new ConsoleHandler();
    h.setFormatter(new StatusOutputFormatter());
    addHandler(h);
    setUseParentHandlers(false);
    setLevel(Level.INFO);
}
 

private static VerbatimLogger getVerbatimLogger() {
  if (singletonLogger == null) {
    singletonLogger = new VerbatimLogger();
    ConsoleHandler cs = new ConsoleHandler();
    singletonFormatter = singletonLogger.new VerbatimFormatter();
    cs.setFormatter(singletonFormatter);
    VerbatimLogger.underlyingLogger = Logger.getLogger("VerbatimLogger");
    VerbatimLogger.underlyingLogger.setUseParentHandlers(false);
    for (Handler handler : underlyingLogger.getHandlers()) {
      underlyingLogger.removeHandler(handler);
    }
    underlyingLogger.addHandler(cs);
  }
  return singletonLogger;
}
 

public static void enableLogging()
{
    // example code to turn on ALL logging
    //
    // To see logging:
    // [a] set the handler's level
    // [b] add the handler
    // [c] set the logger's level

    Logger l = EasyLinearEquation.getLogger();
    Handler lh = new ConsoleHandler();
    lh.setFormatter(oneLineFormatter());
    // don't forget to do this:
    lh.setLevel(Level.ALL);

    // alternative: write log to file:
    //lh = new FileHandler("log.txt");

    // need this too:
    l.addHandler(lh);
    // and this:
    l.setLevel(Level.ALL);
    if (EasyLinearEquation.getLogger().isLoggable(Level.FINE))
    {
        System.out.println("ok");
        EasyLinearEquation.getLogger().fine("Hi there");
    }
    else
    {
        System.out.println("failed");
    }
}
 

/**
 * 开启DEBUG级别日志（仅针对JDK14LOGGER，LOG4J请自行修改配置文件）
 * 
 * @param isEnabled
 */
public static void setJDKDebugEnabled(Boolean isEnabled) {
    //如果使用JDK14LOGGER，将业务日志级别设为DEBUG(FINE)
    if (blog instanceof Jdk14Logger) {
        Jdk14Logger logger = (Jdk14Logger) blog;
        if (isEnabled) {
            logger.getLogger().setLevel(Level.FINE);
            Handler consoleHandler = new ConsoleHandler();
            consoleHandler.setLevel(Level.FINE);
            logger.getLogger().addHandler(consoleHandler);
        } else {
            logger.getLogger().setLevel(Level.INFO);
        }
    }
}
 

public static void overrideSimpleFormatterWithTerseOneForConsoleHandler(
  Logger logger,
  boolean debugMode) {
  for (Handler handler : logger.getHandlers()) {
    if (handler instanceof ConsoleHandler) {
      final Formatter formatter;

      formatter = handler.getFormatter();
      if (formatter instanceof SimpleFormatter) {
        final StdOutHandler stdOutHandler;
        final Level originalLevel;

        /*
         * DGF - Nobody likes the SimpleFormatter; surely they wanted our terse formatter instead.
         */
        originalLevel = handler.getLevel();
        handler.setFormatter(new TerseFormatter());
        handler.setLevel(Level.WARNING);

        /*
         * Furthermore, we all want DEBUG/INFO on stdout and WARN/ERROR on stderr
         */
        stdOutHandler = new StdOutHandler();
        stdOutHandler.setFormatter(new TerseFormatter());
        stdOutHandler.setFilter(new MaxLevelFilter(Level.INFO));
        stdOutHandler.setLevel(originalLevel);
        logger.addHandler(stdOutHandler);
        if (debugMode) {
          if (originalLevel.intValue() > Level.FINE.intValue()) {
            stdOutHandler.setLevel(Level.FINE);
          }
        }
      }
    }
  }
}
 

/**
 * Initialize the logger.  Look at the current logger and its parents to see
 * if it already has a handler setup.  If not, it adds one.
 *
 * @param logger
 *            The logger to initialize
 */
private void initializeLogger(final Logger logger) {
    if (logger.getHandlers().length == 0) {
        if (logger.getParent() != null
                && logger.getUseParentHandlers()) {
            initializeLogger(LOG.getParent());
        } else {
            Handler newHandler = new ConsoleHandler();
            logger.addHandler(newHandler);
        }
    }
}
 

public LoggerFinderAPITest(boolean verbose) {
    this.warnDuplicateMappings = verbose;
    for (Handler h : Logger.getLogger("").getHandlers()) {
        if (h instanceof ConsoleHandler) {
            Logger.getLogger("").removeHandler(h);
        }
    }
    Logger.getLogger("").addHandler( new Handler() {
        @Override
        public void publish(LogRecord record) {
            StringBuilder builder = new StringBuilder();
            builder.append("GOT LogRecord: ")
                    .append(record.getLevel().getLocalizedName())
                    .append(": [").append(record.getLoggerName())
                    .append("] ").append(record.getSourceClassName())
                    .append('.')
                    .append(record.getSourceMethodName()).append(" -> ")
                    .append(record.getMessage())
                    .append(' ')
                    .append(record.getParameters() == null ? ""
                            : Arrays.toString(record.getParameters()))
                    ;
            System.out.println(builder);
            if (record.getThrown() != null) {
                record.getThrown().printStackTrace(System.out);
            }
        }
        @Override public void flush() {}
        @Override public void close() {}
    });
}
 

@Inject HttpClient(Loggers loggers, HttpClientConfiguration config, JsonUtils jsonUtils, Gson gson) {
    this.logger = loggers.get(getClass());
    this.config = checkNotNull(config, "config");
    this.jsonUtils = jsonUtils;
    this.gson = gson;
    ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("API HTTP Executor").build();
    if (config.getThreads() > 0) {
        this.executorService = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(config.getThreads()));
    } else {
        this.executorService = MoreExecutors.listeningDecorator(Executors.newCachedThreadPool(threadFactory));
    }

    this.requestFactory = this.createRequestFactory();

    // By default the google http client is very noisy on http errors,
    // spitting out a long stack trace every time one try of a request
    // fails. Disabling the parent handlers (removes default console
    // handling) and adding our own handler that will only show the short
    // message makes the error output much more manageable.
    // See HttpRequest#986 for the offending line and HttpTransport#81 for
    // the logger definition (it's package private so we can't access it
    // directly).
    final Logger httpLogger = Logger.getLogger(HttpTransport.class.getName());
    httpLogger.setUseParentHandlers(false);
    httpLogger.addHandler(new ConsoleHandler() {
        @Override
        public void publish(LogRecord record) {
            String message = record.getMessage();
            if (record.getThrown() != null) message += ": " + record.getThrown().toString();
            HttpClient.this.logger.log(record.getLevel(), message);
        }
    });
}
 

public static void configureLogging(final Handler handler, final Logger logger) {
    for (final Handler h : logger.getHandlers()) {
        logger.removeHandler(h);
    }
    logger.setUseParentHandlers(false);

    if (handler == null) {
        final ConsoleHandler consoleHandler = new ConsoleHandler();
        consoleHandler.setFormatter(new Formatter() {
            @Override
            public String format(final LogRecord record) {
                final StringBuffer sb = new StringBuffer();

                sb.append("[");
                sb.append(record.getLevel().getName());
                sb.append("]\t");

                sb.append(formatMessage(record));
                sb.append("\n");

                return sb.toString();
            }
        });
        logger.addHandler(consoleHandler);
    } else {
        logger.addHandler(handler);
    }

}
 

private static Logger instantiateLogger(final String name, final Level level) {
    final Logger logger = java.util.logging.Logger.getLogger(name);
    AccessController.doPrivileged(new PrivilegedAction<Void>() {
        @Override
        public Void run() {
            for (final Handler h : logger.getHandlers()) {
                logger.removeHandler(h);
            }

            logger.setLevel(level);
            logger.setUseParentHandlers(false);
            final Handler c = new ConsoleHandler();

            c.setFormatter(new Formatter() {
                @Override
                public String format(final LogRecord record) {
                    final StringBuilder sb = new StringBuilder();

                    sb.append('[')
                    .append(record.getLoggerName())
                    .append("] ")
                    .append(record.getMessage())
                    .append('\n');

                    return sb.toString();
                }
            });
            logger.addHandler(c);
            c.setLevel(level);
            return null;
        }
    }, createLoggerControlAccCtxt());

    return logger;
}