Refine search
@Override public void publish(LogRecord logRecord) { // Map the log levels from java.util.logging to Ant int antLevel; Level level = logRecord.getLevel(); if (level == Level.FINEST) { antLevel = Project.MSG_DEBUG; // Shown when -debug is supplied to // Ant } else if (level == Level.FINE || level == Level.FINER || level == Level.CONFIG) { antLevel = Project.MSG_VERBOSE; // Shown when -verbose is supplied // to Ant } else if (level == Level.INFO) { antLevel = Project.MSG_INFO; // Always shown } else if (level == Level.WARNING) { antLevel = Project.MSG_WARN; // Always shown } else if (level == Level.SEVERE) { antLevel = Project.MSG_ERR; // Always shown } else { throw new IllegalStateException("Unknown logging level"); // shouldn't // get ALL // or NONE } project.log(FORMATTER.format(logRecord), antLevel); if (logRecord.getThrown() != null) { StringWriter stringWriter = new StringWriter(); PrintWriter printWriter = new PrintWriter(stringWriter, true); logRecord.getThrown().printStackTrace(printWriter); project.log(stringWriter.toString(), antLevel); } }
public synchronized void publish(final LogRecord record) { if (!isLoggable(record)) { return; } String msg; try { msg = getFormatter().format(record); } catch (Exception ex) { // We don't want to throw an exception here, but we // report the exception to any registered ErrorManager. reportError(null, ex, ErrorManager.FORMAT_FAILURE); return; } try { if (!doneHeader) { writer.write(getFormatter().getHead(this)); doneHeader = true; } writer.write(msg); } catch (Exception ex) { // We don't want to throw an exception here, but we // report the exception to any registered ErrorManager. reportError(null, ex, ErrorManager.WRITE_FAILURE); } }
StringBuilder sb = new StringBuilder(); sb.append(new Date(record.getMillis())) .append(" ") .append(record.getLevel().getLocalizedName()) .append(": ") .append(formatMessage(record)) .append(LINE_SEPARATOR); if (record.getThrown() != null) { try { StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw); record.getThrown().printStackTrace(pw); pw.close(); sb.append(sw.toString()); } catch (Exception ex) {
private synchronized void flushAndClose() throws SecurityException { if (writer != null) { try { if (!doneHeader) { writer.write(getFormatter().getHead(this)); doneHeader = true; } writer.write(getFormatter().getTail(this)); writer.flush(); writer.close(); } catch (Exception ex) { // We don't want to throw an exception here, but we // report the exception to any registered ErrorManager. reportError(null, ex, ErrorManager.CLOSE_FAILURE); } writer = null; } }
protected void closeWriter() { writerLock.writeLock().lock(); try { if (writer == null) return; writer.write(getFormatter().getTail(this)); writer.flush(); writer.close(); writer = null; date = ""; } catch (Exception e) { reportError(null, e, ErrorManager.CLOSE_FAILURE); } finally { writerLock.writeLock().unlock(); } }
@Override public void publish(LogRecord logRecord) { System.out.println(FORMATTER.format(logRecord)); if (logRecord.getThrown() != null) { // Use the same channel, to make sure that the stacktrace comes // after the message on the console (using printStackTrace // directly messes things up) StringWriter stringWriter = new StringWriter(); PrintWriter printWriter = new PrintWriter(stringWriter, true); logRecord.getThrown().printStackTrace(printWriter); System.out.println(stringWriter.toString()); } }
FileOutputStream fos = new FileOutputStream(pathname, true); OutputStream os = bufferSize>0?new BufferedOutputStream(fos,bufferSize):fos; writer = new PrintWriter( (encoding != null) ? new OutputStreamWriter(os, encoding) : new OutputStreamWriter(os), false); writer.write(getFormatter().getHead(this)); } catch (Exception e) { reportError(null, e, ErrorManager.OPEN_FAILURE);
@Override public void publish(LogRecord record) { if (getFormatter() == null) { setFormatter(new SimpleFormatter()); } try { String message = getFormatter().format(record); if (record.getLevel().intValue() >= Level.WARNING.intValue()) { System.err.write(message.getBytes()); } else { if (record.getLevel().intValue() >= Level.INFO.intValue()) { System.out.write(message.getBytes()); } else { if (verbosity == Verbosity.VERBOSE) { System.out.write(message.getBytes()); } } } } catch (Exception exception) { reportError(null, exception, ErrorManager.FORMAT_FAILURE); } } @Override
private LogEntry logEntryFor(LogRecord record) throws Exception { String payload = getFormatter().format(record); Level level = record.getLevel(); LogEntry.Builder builder = LogEntry.newBuilder(Payload.StringPayload.of(payload)) .setTimestamp(record.getMillis()) .setSeverity(severityFor(level)); if (!baseLevel.equals(level)) { builder .addLabel("levelName", level.getName()) .addLabel("levelValue", String.valueOf(level.intValue())); } for (LoggingEnhancer enhancer : enhancers) { enhancer.enhanceLogEntry(builder); } return builder.build(); }
@Override public void publish(LogRecord record) { int level = getAndroidLevel(record.getLevel()); // String tag = loggerNameToTag(record.getLoggerName()); String tag = record.getLoggerName(); try { String message = JME_FORMATTER.format(record); Log.println(level, tag, message); } catch (RuntimeException e) { Log.e("AndroidHandler", "Error logging message.", e); } }
/** * Formats message for the log record. This method removes any fully * qualified throwable class names from the message. * * @param record the log record. * @return the formatted message string. */ @Override public String formatMessage(final LogRecord record) { String msg = super.formatMessage(record); msg = replaceClassName(msg, record.getThrown()); msg = replaceClassName(msg, record.getParameters()); return msg; }
@Override public void publish(LogRecord record) { repository.getLogger(record.getLoggerName() == null ? "unknown" : record.getLoggerName()) .log(Log.convertJuliLevel(record.getLevel()), formatter.formatMessage(record), record.getThrown()); }
private String getMessage(final LogRecord record) { StringBuilder stringBuilder = new StringBuilder(); stringBuilder.append('(').append("tid=").append(record.getThreadID()) .append(" msgId=").append(record.getSequenceNumber()).append(") "); if (record.getMessage() != null) { stringBuilder.append(getFormatter().formatMessage(record)); } return stringBuilder.toString(); }
/** * {@inheritDoc} */ @Override public void publish(final LogRecord record) { if (this.isLoggable(record)) { final Level level = record.getLevel(); final String message = prefix + getFormatter().format(record); if (Level.SEVERE.equals(level)) { log.error(message); } else if (Level.WARNING.equals(level)) { log.warn(message); } else if (Level.INFO.equals(level)) { log.info(message); } else { log.debug(message); } } }
@Override public synchronized void publish(LogRecord record) { if (isLoggable(record)) { try { String suffix = ""; if (rotate) { suffix = new SimpleDateFormat("yyyyMMdd").format(new Date(record.getMillis())); if (writer != null && !suffix.equals(this.suffix)) { writer.close(); writer = null; if (!new File(name).renameTo(new File(name + "." + this.suffix))) { throw new RuntimeException("Log file renaming failed"); } } } if (writer == null) { this.suffix = suffix; writer = new BufferedWriter( new OutputStreamWriter(new FileOutputStream(name, true), StandardCharsets.UTF_8)); } writer.write(getFormatter().format(record)); writer.flush(); } catch (IOException e) { throw new RuntimeException(e); } } }
public static LogRecord formatMessage(Formatter formatter, LogRecord record) { record.setMessage(formatter.formatMessage(record)); record.setSourceClassName(record.getSourceClassName()); return record; }
@Override public synchronized void publish(LogRecord record) { super.publish(record); String message = f.formatMessage(record); Throwable x = record.getThrown(); messages.add(message == null && x != null ? x.toString() : message); } };