Java LogRecord.getMillis方法代码示例

import java.util.logging.LogRecord; //导入方法依赖的package包/类
private Integer getLogRecordValue(int sampleIndex) throws IOException {
    long timestamp = getTimestamp(sampleIndex);
    LogRecord rec = xmlLogs.getRecordFor(timestamp / 1000000);
    if (rec != null) {
        long startTime = cpuSnapshot.getStartTime();
        long endTime = getTimestamp(getSamplesCount() - 1);
        long recTime = rec.getMillis() * 1000000;
        if (recTime > startTime && recTime < endTime) {
            if (rec != lastRecord) {
                Integer index = new Integer(sampleIndex+1);
                lastRecord = rec;
                recordsMap.put(index, rec);
                return index;
            }
        }
    }
    return null;
}
 

import java.util.logging.LogRecord; //导入方法依赖的package包/类
/**
 * Take new record, update last timestamp of entity and emit it to all listeners.
 * @param record
 */
protected void addRecord(LogRecord record) {
    // handle records so I have consistent info.
    // All records are stored in the records
    //logRecords.add(record);

    // update log events according to info in record. In many cases nothing will happen.
    LogMessage logMessage = logEvents.updateLogMessages(record);
    if (logMessage != null) {
        emitNewLogMessage(logMessage);
    }

    LogEvent logEvent = logEvents.updateLogEvents(record);
    if (logEvent != null) {
        emitNewLogEvent(logEvent);
    }

    // update map events according to info in record. In many cases nothing will happen.
    mapEvents.update(record);

    long milis = record.getMillis();

    this.entity.setEndTime(milis);
}
 

import java.util.logging.LogRecord; //导入方法依赖的package包/类
/**
 * Format the log record as follows:
 *
 *     Date Level Message ExceptionTrace
 *
 * @param       logRecord       The log record
 * @return                      The formatted string
 */
@Override
public String format(LogRecord logRecord) {
    Object[] arguments = new Object[4];
    arguments[0] = new Date(logRecord.getMillis());
    arguments[1] = logRecord.getLevel().getName();
    arguments[2] = logRecord.getMessage();
    Throwable exc = logRecord.getThrown();
    if (exc != null) {
        Writer result = new StringWriter();
        exc.printStackTrace(new PrintWriter(result));
        arguments[3] = result.toString();
    } else {
        arguments[3] = "";
    }
    return messageFormat.get().format(arguments);
}
 

import java.util.logging.LogRecord; //导入方法依赖的package包/类
@Override
public String format(LogRecord record) {
  Date date = new Date(record.getMillis());
  String msg =
      String.format(
          "%s %s %s [%s] %s\n",
          DATE_FORMAT.format(date),
          record.getLevel().toString().substring(0, 1),
          record.getLoggerName(),
          record.getSourceMethodName(),
          record.getMessage());

  Throwable e = record.getThrown();
  if (e != null) {
    ByteArrayOutputStream stream = new ByteArrayOutputStream();
    e.printStackTrace(new PrintStream(stream));
    msg += new String(stream.toByteArray(), UTF_8);
  }
  return msg;
}
 

import java.util.logging.LogRecord; //导入方法依赖的package包/类
public String format( LogRecord rec) {
	int ii;
	StringBuffer outbuf = new StringBuffer(200);
	long tmval = rec.getMillis();
	if (timeType == DleseLogManager.LOG_UTCTIME) {
		// convert local time to UTC
		TimeZone tz = TimeZone.getDefault();
		tmval -= tz.getRawOffset();
	}
	outbuf.append( dateformat.format( new Date(tmval)));
	outbuf.append(" ");
	outbuf.append(rec.getLevel());
	outbuf.append(" ");
	String classname = rec.getSourceClassName();
	int ix = classname.lastIndexOf(".");
	if (ix >= 0 && ix < classname.length() - 1)
		classname = classname.substring( ix + 1);
	outbuf.append(classname);
	outbuf.append(".");
	outbuf.append(rec.getSourceMethodName());
	outbuf.append(" ");
	outbuf.append(rec.getMessage());
	outbuf.append("\n");
	Object[] parms = rec.getParameters();
	if (parms != null && parms.length > 0) {
		for (ii = 0; ii < parms.length; ii++) {
			outbuf.append("    parm ");
			outbuf.append(Integer.toString(ii));
			outbuf.append(": ");
			if (parms[ii] == null) outbuf.append("(null)");
			else outbuf.append( parms[ii].toString());
			outbuf.append("\n");
		}
	}
	return new String( outbuf);
}
 

import java.util.logging.LogRecord; //导入方法依赖的package包/类
private Object[] buildParameters(LogRecord record) {
    StackTraceElement frame = getCaller();

    Object[] arguments = new Object[otherPartsSize + 1];
    arguments[0] = new Long(record.getSequenceNumber());
    arguments[1] = new Date(record.getMillis());
    arguments[2] = record.getLoggerName();
    arguments[3] = record.getSourceClassName();
    arguments[4] = record.getSourceMethodName();
    if (frame != null) {
        arguments[5] = frame.getFileName();
        arguments[6] = frame.getLineNumber();
    } else {
        arguments[5] = "";
        arguments[6] = -1;
    }
    // LogRecord.getThreadID is not the actual thread ID.
    // arguments[7]=new Integer(record.getThreadID());
    arguments[7] = Thread.currentThread().getId();
    arguments[12] = Thread.currentThread().getName();

    // arguments[8]=record.getLevel().getLocalizedName();
    // this is faster, but not i18n
    arguments[8] = record.getLevel().getName();
    arguments[9] = new Integer(record.getLevel().intValue());
    arguments[11] = writeThrowable(arguments, record, 0);
    return arguments;
}
 

import java.util.logging.LogRecord; //导入方法依赖的package包/类
/**
 * Formats a given log record for logging.
 */
public String format(LogRecord record) {
	StringBuilder builder = new StringBuilder(1000);
	Date logTime = new Date(record.getMillis());
	builder.append(LOG_DATE_FORMAT.format(logTime));
	builder.append(" - ");
	builder.append("[").append(record.getSourceClassName());
	builder.append(".");
	builder.append(record.getSourceMethodName());
	Object[] params = record.getParameters();

	// we are in full control of this instance and we are passing
	// the line of the call from the source file as the first entry
	// in the parameter array
	if (params != null && params.length >= 1) {
		builder.append(":");
		builder.append(params[0]);
	}
	builder.append("] - ");
	builder.append("[").append(record.getLevel());
	builder.append("] - ");
	builder.append(formatMessage(record));
	if (record.getThrown() != null) {
		format(record.getThrown(), builder, 0);
	}
	builder.append("\n");
	return builder.toString();
}
 

import java.util.logging.LogRecord; //导入方法依赖的package包/类
private SerializableLogRecord asSerializableLogRecord(LogRecord record) {
    SerializableLogRecord serializableLogRecord = new SerializableLogRecord();
    serializableLogRecord.level = record.getLevel().toString();
    serializableLogRecord.millis = record.getMillis();
    serializableLogRecord.message = record.getMessage();
    serializableLogRecord.loggerName = record.getLoggerName();
    serializableLogRecord.permutationStrongName = GWT.getPermutationStrongName();
    serializableLogRecord.thrown = serializableThrowable(unwrap(record.getThrown()));
    return serializableLogRecord;
}
 

import java.util.logging.LogRecord; //导入方法依赖的package包/类
public String format(LogRecord record) {

            // Create a StringBuffer to contain the formatted record
            // start with the date.
            StringBuffer sb = new StringBuffer();

            sb.append("<font color=#ff0000>");

            // Get the date from the LogRecord and add it to the buffer
            Date date = new Date(record.getMillis());
            sb.append(date.toString());
            sb.append(" ");

            // get the name of the class
            sb.append(record.getSourceClassName());
            sb.append(" ");

            // get the name of the method
            sb.append(record.getSourceMethodName().replace("<", "[").replace(">", "]"));
            sb.append("\n");

            // Get the level name and add it to the buffer
            sb.append(record.getLevel().getName());
            sb.append(": ");

            // Get the formatted message (includes localization
            // and substitution of paramters) and add it to the buffer
            sb.append(formatMessage(record).replace("<", "[").replace(">", "]"));
            sb.append("\n");

            sb.append("</font>");

            return sb.toString();
        }
 

import java.util.logging.LogRecord; //导入方法依赖的package包/类
@Override
public String format(LogRecord record) {
    Date date = new Date(record.getMillis());
    return "[" + sdf.format(date) + " " + record.getLevel() + "] " + record.getMessage() + "\n";
}
 

import java.util.logging.LogRecord; //导入方法依赖的package包/类
@Override
public String format(LogRecord record) {
    Throwable t=record.getThrown();
    int level=record.getLevel().intValue();
    String name=record.getLoggerName();
    long time=record.getMillis();
    String message=formatMessage(record);


    if( name.indexOf('.') >= 0 )
        name = name.substring(name.lastIndexOf('.') + 1);

    // Use a string buffer for better performance
    StringBuilder buf = new StringBuilder();
    
    buf.append(time);
    
    // pad to 8 to make it more readable 
    for( int i=0; i<8-buf.length(); i++ ) { buf.append(" "); }
    
    //      Append a readable representation of the log level.
    switch(level) {
     case LOG_LEVEL_TRACE: buf.append(" T "); break;
     case LOG_LEVEL_DEBUG: buf.append(" D "); break;
     case LOG_LEVEL_INFO:  buf.append(" I ");  break;
     case LOG_LEVEL_WARN:  buf.append(" W ");  break;
     case LOG_LEVEL_ERROR: buf.append(" E "); break;
     //case : buf.append(" F "); break;
     default: buf.append("   ");
     }
     

    // Append the name of the log instance if so configured
    buf.append(name);
    buf.append(" ");

    // pad to 20 chars 
    for( int i=0; i<8-buf.length(); i++ ) { buf.append(" "); }
            
    // Append the message
    buf.append(message);
    
    // Append stack trace if not null
    if(t != null) {
        buf.append(LINE_SEP);
        
        java.io.StringWriter sw= new java.io.StringWriter(1024);
        java.io.PrintWriter pw= new java.io.PrintWriter(sw);
        t.printStackTrace(pw);
        pw.close();
        buf.append(sw.toString());
    }
    
    buf.append(LINE_SEP);
    // Print to the appropriate destination
    return buf.toString();
}
 

import java.util.logging.LogRecord; //导入方法依赖的package包/类
public String format(LogRecord record) {
    Throwable t=record.getThrown();
    int level=record.getLevel().intValue();
    String name=record.getLoggerName();
    long time=record.getMillis();
    String message=formatMessage(record);

    
    if( name.indexOf(".") >= 0 ) 
        name = name.substring(name.lastIndexOf(".") + 1);

    // Use a string buffer for better performance
    StringBuffer buf = new StringBuffer();
    
    buf.append(time);
    buf.append(" ");
    
    // pad to 8 to make it more readable 
    for( int i=0; i<8-buf.length(); i++ ) { buf.append(" "); }
    
    //      Append a readable representation of the log level.
    switch(level) {
     case LOG_LEVEL_TRACE: buf.append(" T "); break;
     case LOG_LEVEL_DEBUG: buf.append(" D "); break;
     case LOG_LEVEL_INFO:  buf.append(" I ");  break;
     case LOG_LEVEL_WARN:  buf.append(" W ");  break;
     case LOG_LEVEL_ERROR: buf.append(" E "); break;
     //case : buf.append(" F "); break;
     default: buf.append("   ");
     }
     

    // Append the name of the log instance if so configured
    buf.append(name);
    
    // pad to 20 chars 
    for( int i=0; i<8-buf.length(); i++ ) { buf.append(" "); }
            
    // Append the message
    buf.append(message);
    
    // Append stack trace if not null
    if(t != null) {
        buf.append(" \n");
        
        java.io.StringWriter sw= new java.io.StringWriter(1024);
        java.io.PrintWriter pw= new java.io.PrintWriter(sw);
        t.printStackTrace(pw);
        pw.close();
        buf.append(sw.toString());
    }
    
    buf.append("\n");
    // Print to the appropriate destination
    return buf.toString();
}
 

import java.util.logging.LogRecord; //导入方法依赖的package包/类
public static void test(Properties props) {
    Configuration conf = Configuration.apply(props);

    LogRecord record = new LogRecord(Level.INFO, "Test Name: {0}");
    record.setLoggerName("test");
    record.setParameters(new Object[] {conf.testName()});
    int nanos = record.getInstant().getNano() % NANOS_IN_MILLI;
    long millis = record.getMillis();
    // make sure we don't have leading zeros when printing below
    // the second precision
    if (millis % MILLIS_IN_SECOND < 100) millis = millis + 100;
    // make sure we some nanos - and make sure we don't have
    // trailing zeros
    if (nanos % 10 == 0) nanos = nanos + 7;

    record.setMillis(millis);
    setNanoAdjustment(record, nanos);
    final Instant instant = record.getInstant();
    if (nanos < 0) {
        throw new RuntimeException("Unexpected negative nano adjustment: "
                + getNanoAdjustment(record));
    }
    if (nanos >= NANOS_IN_MILLI) {
        throw new RuntimeException("Nano adjustment exceeds 1ms: "
                + getNanoAdjustment(record));
    }
    if (millis != record.getMillis()) {
        throw new RuntimeException("Unexpected millis: " + millis + " != "
                + record.getMillis());
    }
    if (millis != record.getInstant().toEpochMilli()) {
        throw new RuntimeException("Unexpected millis: "
                + record.getInstant().toEpochMilli());
    }
    long expectedNanos = (millis % MILLIS_IN_SECOND) * NANOS_IN_MILLI + nanos;
    assertEquals(expectedNanos, instant.getNano(), "Instant.getNano()");

    XMLFormatter formatter = new XMLFormatter();
    testMatching(formatter, record, instant, expectedNanos, conf.useInstant(formatter));

    XMLFormatter custom = new CustomXMLFormatter();
    testMatching(custom, record, instant, expectedNanos, conf.useInstant(custom));
}
 

import java.util.logging.LogRecord; //导入方法依赖的package包/类
/**
 * Serializes a log record, then deserializes it and check that both
 * records match.
 * @param record the log record to serialize & deserialize.
 * @param hasExceedingNanos whether the record has a nano adjustment whose
 *            value exceeds 1ms.
 * @throws IOException Unexpected.
 * @throws ClassNotFoundException  Unexpected.
 */
public static void test(LogRecord record, boolean hasExceedingNanos)
        throws IOException, ClassNotFoundException {

    // Format the given logRecord using the SimpleFormatter
    SimpleFormatter formatter = new SimpleFormatter();
    String str = formatter.format(record);

    // Serialize the given LogRecord
    final ByteArrayOutputStream baos = new ByteArrayOutputStream();
    final ObjectOutputStream oos = new ObjectOutputStream(baos);
    oos.writeObject(record);
    oos.flush();
    oos.close();

    // First checks that the log record can be deserialized
    final ByteArrayInputStream bais =
            new ByteArrayInputStream(baos.toByteArray());
    final ObjectInputStream ois = new ObjectInputStream(bais);
    final LogRecord record2 = (LogRecord)ois.readObject();

    assertEquals(record.getMillis(), record2.getMillis(), "getMillis()");
    assertEquals(record.getInstant().getEpochSecond(),
            record2.getInstant().getEpochSecond(),
            "getInstant().getEpochSecond()");
    assertEquals(record.getInstant().getNano(),
            record2.getInstant().getNano(),
            "getInstant().getNano()");
    assertEquals(record.getInstant().toEpochMilli(),
            record2.getInstant().toEpochMilli(),
            "getInstant().toEpochMilli()");
    long millis = record.getMillis();
    millis = hasExceedingNanos
            ? Instant.ofEpochSecond(millis/MILLIS_IN_SECOND,
                    (millis%MILLIS_IN_SECOND)*NANOS_IN_MILLI
                    + record.getInstant().getNano() % NANOS_IN_MILLI).toEpochMilli()
            : millis;
    assertEquals(millis, record.getInstant().toEpochMilli(),
            "getMillis()/getInstant().toEpochMilli()");
    millis = record2.getMillis();
    millis = hasExceedingNanos
            ? Instant.ofEpochSecond(millis/MILLIS_IN_SECOND,
                    (millis%MILLIS_IN_SECOND)*NANOS_IN_MILLI
                    + record2.getInstant().getNano() % NANOS_IN_MILLI).toEpochMilli()
            : millis;
    assertEquals(millis, record2.getInstant().toEpochMilli(),
            "getMillis()/getInstant().toEpochMilli()");
    long nanos = nanoInSecondFromEpochMilli(record.getMillis())
            + record.getInstant().getNano() % NANOS_IN_MILLI;
    assertEquals(nanos, record.getInstant().getNano(),
            "nanoInSecondFromEpochMilli(record.getMillis())"
            + " + record.getInstant().getNano() % NANOS_IN_MILLI /getInstant().getNano()");
    nanos = nanoInSecondFromEpochMilli(record2.getMillis())
            + record2.getInstant().getNano() % NANOS_IN_MILLI;
    assertEquals(nanos, record2.getInstant().getNano(),
            "nanoInSecondFromEpochMilli(record2.getMillis())"
            + " + record2.getInstant().getNano() % NANOS_IN_MILLI /getInstant().getNano()");

    // Format the deserialized LogRecord using the SimpleFormatter, and
    // check that the string representation obtained matches the string
    // representation of the original LogRecord
    String str2 = formatter.format(record2);
    if (!str.equals(str2))
        throw new RuntimeException("Unexpected values in deserialized object:"
            + "\n\tExpected:  " + str
            + "\n\tRetrieved: "+str);

}
 

import java.util.logging.LogRecord; //导入方法依赖的package包/类
@Override
public String format(LogRecord record) {
	Throwable t = record.getThrown();
	int level = record.getLevel().intValue();
	String name = record.getLoggerName();
	long time = record.getMillis();
	String message = formatMessage(record);

	if (name.indexOf('.') >= 0)
		name = name.substring(name.lastIndexOf('.') + 1);

	// Use a string buffer for better performance
	StringBuilder buf = new StringBuilder();

	buf.append(time);

	// pad to 8 to make it more readable
	for (int i = 0; i < 8 - buf.length(); i++) {
		buf.append(" ");
	}

	// Append a readable representation of the log level.
	switch (level) {
	case LOG_LEVEL_TRACE:
		buf.append(" T ");
		break;
	case LOG_LEVEL_DEBUG:
		buf.append(" D ");
		break;
	case LOG_LEVEL_INFO:
		buf.append(" I ");
		break;
	case LOG_LEVEL_WARN:
		buf.append(" W ");
		break;
	case LOG_LEVEL_ERROR:
		buf.append(" E ");
		break;
	// case : buf.append(" F "); break;
	default:
		buf.append("   ");
	}

	// Append the name of the log instance if so configured
	buf.append(name);
	buf.append(" ");

	// pad to 20 chars
	for (int i = 0; i < 8 - buf.length(); i++) {
		buf.append(" ");
	}

	// Append the message
	buf.append(message);

	// Append stack trace if not null
	if (t != null) {
		buf.append(LINE_SEP);

		java.io.StringWriter sw = new java.io.StringWriter(1024);
		java.io.PrintWriter pw = new java.io.PrintWriter(sw);
		t.printStackTrace(pw);
		pw.close();
		buf.append(sw.toString());
	}

	buf.append(LINE_SEP);
	// Print to the appropriate destination
	return buf.toString();
}