/*

  * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

  *

  * This code is free software; you can redistribute it and/or modify it

  * under the terms of the GNU General Public License version 2 only, as

  * published by the Free Software Foundation.  Oracle designates this

  * particular file as subject to the "Classpath" exception as provided

  * by Oracle in the LICENSE file that accompanied this code.

  *

  * This code is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

  * or visit www.oracle.com if you need additional information or have any

  * questions.

  */

 package java.util.logging;

 import java.util.*;

 import java.util.concurrent.atomic.AtomicInteger;

 import java.util.concurrent.atomic.AtomicLong;

 import java.io.*;

 import sun.misc.JavaLangAccess;

 import sun.misc.SharedSecrets;

 /**

  * LogRecord objects are used to pass logging requests between

  * the logging framework and individual log Handlers.

  * <p>

  * When a LogRecord is passed into the logging framework it

  * logically belongs to the framework and should no longer be

  * used or updated by the client application.

  * <p>

  * Note that if the client application has not specified an

  * explicit source method name and source class name, then the

  * LogRecord class will infer them automatically when they are

  * first accessed (due to a call on getSourceMethodName or

  * getSourceClassName) by analyzing the call stack.  Therefore,

  * if a logging Handler wants to pass off a LogRecord to another

  * thread, or to transmit it over RMI, and if it wishes to subsequently

  * obtain method name or class name information it should call

  * one of getSourceClassName or getSourceMethodName to force

  * the values to be filled in.

  * <p>

  * <b> Serialization notes:</b>

  * <ul>

  * <li>The LogRecord class is serializable.

  *

  * <li> Because objects in the parameters array may not be serializable,

  * during serialization all objects in the parameters array are

  * written as the corresponding Strings (using Object.toString).

  *

  * <li> The ResourceBundle is not transmitted as part of the serialized

  * form, but the resource bundle name is, and the recipient object's

  * readObject method will attempt to locate a suitable resource bundle.

  *

  * </ul>

  *

  * @since 1.4

  */

 public class LogRecord implements java.io.Serializable {

     private static final AtomicLong globalSequenceNumber

         = new AtomicLong(0);

     /**

      * The default value of threadID will be the current thread's

      * thread id, for ease of correlation, unless it is greater than

      * MIN_SEQUENTIAL_THREAD_ID, in which case we try harder to keep

      * our promise to keep threadIDs unique by avoiding collisions due

      * to 32-bit wraparound.  Unfortunately, LogRecord.getThreadID()

      * returns int, while Thread.getId() returns long.

      */

     private static final int MIN_SEQUENTIAL_THREAD_ID = Integer.MAX_VALUE / 2;

     private static final AtomicInteger nextThreadId

         = new AtomicInteger(MIN_SEQUENTIAL_THREAD_ID);

     private static final ThreadLocal<Integer> threadIds = new ThreadLocal<>();

     /**

      * @serial Logging message level

      */

     private Level level;

     /**

      * @serial Sequence number

      */

     private long sequenceNumber;

     /**

      * @serial Class that issued logging call

      */

     private String sourceClassName;

     /**

      * @serial Method that issued logging call

      */

     private String sourceMethodName;

     /**

      * @serial Non-localized raw message text

      */

     private String message;

     /**

      * @serial Thread ID for thread that issued logging call.

      */

     private int threadID;

     /**

      * @serial Event time in milliseconds since 1970

      */

     private long millis;

     /**

      * @serial The Throwable (if any) associated with log message

      */

     private Throwable thrown;

     /**

      * @serial Name of the source Logger.

      */

     private String loggerName;

     /**

      * @serial Resource bundle name to localized log message.

      */

     private String resourceBundleName;

     private transient boolean needToInferCaller;

     private transient Object parameters[];

     private transient ResourceBundle resourceBundle;

     /**

      * Returns the default value for a new LogRecord's threadID.

      */

     private int defaultThreadID() {

         long tid = Thread.currentThread().getId();

         if (tid < MIN_SEQUENTIAL_THREAD_ID) {

             return (int) tid;

         } else {

             Integer id = threadIds.get();

             if (id == null) {

                 id = nextThreadId.getAndIncrement();

                 threadIds.set(id);

             }

             return id;

         }

     }

     /**

      * Construct a LogRecord with the given level and message values.

      * <p>

      * The sequence property will be initialized with a new unique value.

      * These sequence values are allocated in increasing order within a VM.

      * <p>

      * The millis property will be initialized to the current time.

      * <p>

      * The thread ID property will be initialized with a unique ID for

      * the current thread.

      * <p>

      * All other properties will be initialized to "null".

      *

      * @param level  a logging level value

      * @param msg  the raw non-localized logging message (may be null)

      */

     public LogRecord(Level level, String msg) {

         // Make sure level isn't null, by calling random method.

         level.getClass();

         this.level = level;

         message = msg;

         // Assign a thread ID and a unique sequence number.

         sequenceNumber = globalSequenceNumber.getAndIncrement();

         threadID = defaultThreadID();

         millis = System.currentTimeMillis();

         needToInferCaller = true;

    }

     /**

      * Get the source Logger's name.

      *

      * @return source logger name (may be null)

      */

     public String getLoggerName() {

         return loggerName;

     }

     /**

      * Set the source Logger's name.

      *

      * @param name   the source logger name (may be null)

      */

     public void setLoggerName(String name) {

         loggerName = name;

     }

     /**

      * Get the localization resource bundle

      * <p>

      * This is the ResourceBundle that should be used to localize

      * the message string before formatting it.  The result may

      * be null if the message is not localizable, or if no suitable

      * ResourceBundle is available.

      */

     public ResourceBundle getResourceBundle() {

         return resourceBundle;

     }

     /**

      * Set the localization resource bundle.

      *

      * @param bundle  localization bundle (may be null)

      */

     public void setResourceBundle(ResourceBundle bundle) {

         resourceBundle = bundle;

     }

     /**

      * Get the localization resource bundle name

      * <p>

      * This is the name for the ResourceBundle that should be

      * used to localize the message string before formatting it.

      * The result may be null if the message is not localizable.

      */

     public String getResourceBundleName() {

         return resourceBundleName;

     }

     /**

      * Set the localization resource bundle name.

      *

      * @param name  localization bundle name (may be null)

      */

     public void setResourceBundleName(String name) {

         resourceBundleName = name;

     }

     /**

      * Get the logging message level, for example Level.SEVERE.

      * @return the logging message level

      */

     public Level getLevel() {

         return level;

     }

     /**

      * Set the logging message level, for example Level.SEVERE.

      * @param level the logging message level

      */

     public void setLevel(Level level) {

         if (level == null) {

             throw new NullPointerException();

         }

         this.level = level;

     }

     /**

      * Get the sequence number.

      * <p>

      * Sequence numbers are normally assigned in the LogRecord

      * constructor, which assigns unique sequence numbers to

      * each new LogRecord in increasing order.

      * @return the sequence number

      */

     public long getSequenceNumber() {

         return sequenceNumber;

     }

     /**

      * Set the sequence number.

      * <p>

      * Sequence numbers are normally assigned in the LogRecord constructor,

      * so it should not normally be necessary to use this method.

      */

     public void setSequenceNumber(long seq) {

         sequenceNumber = seq;

     }

     /**

      * Get the  name of the class that (allegedly) issued the logging request.

      * <p>

      * Note that this sourceClassName is not verified and may be spoofed.

      * This information may either have been provided as part of the

      * logging call, or it may have been inferred automatically by the

      * logging framework.  In the latter case, the information may only

      * be approximate and may in fact describe an earlier call on the

      * stack frame.

      * <p>

      * May be null if no information could be obtained.

      *

      * @return the source class name

      */

     public String getSourceClassName() {

         if (needToInferCaller) {

             inferCaller();

         }

         return sourceClassName;

     }

     /**

      * Set the name of the class that (allegedly) issued the logging request.

      *

      * @param sourceClassName the source class name (may be null)

      */

     public void setSourceClassName(String sourceClassName) {

         this.sourceClassName = sourceClassName;

         needToInferCaller = false;

     }

     /**

      * Get the  name of the method that (allegedly) issued the logging request.

      * <p>

      * Note that this sourceMethodName is not verified and may be spoofed.

      * This information may either have been provided as part of the

      * logging call, or it may have been inferred automatically by the

      * logging framework.  In the latter case, the information may only

      * be approximate and may in fact describe an earlier call on the

      * stack frame.

      * <p>

      * May be null if no information could be obtained.

      *

      * @return the source method name

      */

     public String getSourceMethodName() {

         if (needToInferCaller) {

             inferCaller();

         }

         return sourceMethodName;

     }

     /**

      * Set the name of the method that (allegedly) issued the logging request.

      *

      * @param sourceMethodName the source method name (may be null)

      */

     public void setSourceMethodName(String sourceMethodName) {

         this.sourceMethodName = sourceMethodName;

         needToInferCaller = false;

     }

     /**

      * Get the "raw" log message, before localization or formatting.

      * <p>

      * May be null, which is equivalent to the empty string "".

      * <p>

      * This message may be either the final text or a localization key.

      * <p>

      * During formatting, if the source logger has a localization

      * ResourceBundle and if that ResourceBundle has an entry for

      * this message string, then the message string is replaced

      * with the localized value.

      *

      * @return the raw message string

      */

     public String getMessage() {

         return message;

     }

     /**

      * Set the "raw" log message, before localization or formatting.

      *

      * @param message the raw message string (may be null)

      */

     public void setMessage(String message) {

         this.message = message;

     }

     /**

      * Get the parameters to the log message.

      *

      * @return the log message parameters.  May be null if

      *                  there are no parameters.

      */

     public Object[] getParameters() {

         return parameters;

     }

     /**

      * Set the parameters to the log message.

      *

      * @param parameters the log message parameters. (may be null)

      */

     public void setParameters(Object parameters[]) {

         this.parameters = parameters;

     }

     /**

      * Get an identifier for the thread where the message originated.

      * <p>

      * This is a thread identifier within the Java VM and may or

      * may not map to any operating system ID.

      *

      * @return thread ID

      */

     public int getThreadID() {

         return threadID;

     }

     /**

      * Set an identifier for the thread where the message originated.

      * @param threadID  the thread ID

      */

     public void setThreadID(int threadID) {

         this.threadID = threadID;

     }

     /**

      * Get event time in milliseconds since 1970.

      *

      * @return event time in millis since 1970

      */

     public long getMillis() {

         return millis;

     }

     /**

      * Set event time.

      *

      * @param millis event time in millis since 1970

      */

     public void setMillis(long millis) {

         this.millis = millis;

     }

     /**

      * Get any throwable associated with the log record.

      * <p>

      * If the event involved an exception, this will be the

      * exception object. Otherwise null.

      *

      * @return a throwable

      */

     public Throwable getThrown() {

         return thrown;

     }

     /**

      * Set a throwable associated with the log event.

      *

      * @param thrown  a throwable (may be null)

      */

     public void setThrown(Throwable thrown) {

         this.thrown = thrown;

     }

     private static final long serialVersionUID = 5372048053134512534L;

     /**

      * @serialData Default fields, followed by a two byte version number

      * (major byte, followed by minor byte), followed by information on

      * the log record parameter array.  If there is no parameter array,

      * then -1 is written.  If there is a parameter array (possible of zero

      * length) then the array length is written as an integer, followed

      * by String values for each parameter.  If a parameter is null, then

      * a null String is written.  Otherwise the output of Object.toString()

      * is written.

      */

     private void writeObject(ObjectOutputStream out) throws IOException {

         // We have to call defaultWriteObject first.

         out.defaultWriteObject();

         // Write our version number.

         out.writeByte(1);

         out.writeByte(0);

         if (parameters == null) {

             out.writeInt(-1);

             return;

         }

         out.writeInt(parameters.length);

         // Write string values for the parameters.

         for (int i = 0; i < parameters.length; i++) {

             if (parameters[i] == null) {

                 out.writeObject(null);

             } else {

                 out.writeObject(parameters[i].toString());

             }

         }

     }

     private void readObject(ObjectInputStream in)

                         throws IOException, ClassNotFoundException {

         // We have to call defaultReadObject first.

         in.defaultReadObject();

         // Read version number.

         byte major = in.readByte();

         byte minor = in.readByte();

         if (major != 1) {

             throw new IOException("LogRecord: bad version: " + major + "." + minor);

         }

         int len = in.readInt();

         if (len == -1) {

             parameters = null;

         } else {

             parameters = new Object[len];

             for (int i = 0; i < parameters.length; i++) {

                 parameters[i] = in.readObject();

             }

         }

         // If necessary, try to regenerate the resource bundle.

         if (resourceBundleName != null) {

             try {

                 resourceBundle = ResourceBundle.getBundle(resourceBundleName);

             } catch (MissingResourceException ex) {

                 // This is not a good place to throw an exception,

                 // so we simply leave the resourceBundle null.

                 resourceBundle = null;

             }

         }

         needToInferCaller = false;

     }

     // Private method to infer the caller's class and method names

     private void inferCaller() {

         needToInferCaller = false;

         JavaLangAccess access = SharedSecrets.getJavaLangAccess();

         Throwable throwable = new Throwable();

         int depth = access.getStackTraceDepth(throwable);

         boolean lookingForLogger = true;

         for (int ix = 0; ix < depth; ix++) {

             // Calling getStackTraceElement directly prevents the VM

             // from paying the cost of building the entire stack frame.

             StackTraceElement frame =

                 access.getStackTraceElement(throwable, ix);

             String cname = frame.getClassName();

             boolean isLoggerImpl = isLoggerImplFrame(cname);

             if (lookingForLogger) {

                 // Skip all frames until we have found the first logger frame.

                 if (isLoggerImpl) {

                     lookingForLogger = false;

                 }

             } else {

                 if (!isLoggerImpl) {

                     // skip reflection call

                     if (!cname.startsWith("java.lang.reflect.") && !cname.startsWith("sun.reflect.")) {

                        // We've found the relevant frame.

                        setSourceClassName(cname);

                        setSourceMethodName(frame.getMethodName());

                        return;

                     }

                 }

             }

         }

         // We haven't found a suitable frame, so just punt.  This is

         // OK as we are only committed to making a "best effort" here.

     }

     private boolean isLoggerImplFrame(String cname) {

         // the log record could be created for a platform logger

         return (cname.equals("java.util.logging.Logger") ||

                 cname.startsWith("java.util.logging.LoggingProxyImpl") ||

                 cname.startsWith("sun.util.logging."));

     }

 }