foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/logging/JavaLog.java - eclipselink - Git at Google

 /*
  * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0,
  * or the Eclipse Distribution License v. 1.0 which is available at
  * http://www.eclipse.org/org/documents/edl-v10.php.
  *
  * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
  */

 // Contributors:
 //     Oracle - initial API and implementation from Oracle TopLink
 package org.eclipse.persistence.logging;


 import java.io.OutputStream;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import java.util.logging.StreamHandler;

 import org.eclipse.persistence.sessions.Session;

 /**
  * PUBLIC:
  * <p>
  * This is a wrapper class for java.util.logging.  It is used when messages need to
  * be logged through java.util.logging.
  * </p>
  *  @see SessionLog
  *  @see AbstractSessionLog
  *  @see SessionLogEntry
  *  @see Session
  */
 public class JavaLog extends AbstractSessionLog {

     /**
      * Stores the default session name in case there is the session name is missing.
      */
     public static final String TOPLINK_NAMESPACE = "org.eclipse.persistence";
     protected static final String LOGGING_LOCALIZATION_STRING = "org.eclipse.persistence.internal.localization.i18n.LoggingLocalizationResource";
     protected static final String TRACE_LOCALIZATION_STRING = "org.eclipse.persistence.internal.localization.i18n.TraceLocalizationResource";
     public static final String DEFAULT_TOPLINK_NAMESPACE = TOPLINK_NAMESPACE + ".default";
     public static final String SESSION_TOPLINK_NAMESPACE = TOPLINK_NAMESPACE + ".session";

     /**
      * Stores all the java.util.logging.Levels.  The indexes are TopLink logging levels.
      */
     private static final Level[] levels = new Level[] { Level.ALL, Level.FINEST, Level.FINER, Level.FINE, Level.CONFIG, Level.INFO, Level.WARNING, Level.SEVERE, Level.OFF };

     /**
      * Represents the HashMap that stores all the name space strings.
      * The keys are category names.  The values are namespace strings.
      */
     private Map nameSpaceMap  = new HashMap();

     /**
      * Stores the namespace for session, i.e."{@code org.eclipse.persistence.session.<sessionname>}".
      */
     private String sessionNameSpace;

     /**
      * Stores the Logger for session namespace, i.e. "{@code org.eclipse.persistence.session.<sessionname>}".
      */
     private Logger sessionLogger;

     private Map categoryloggers = new HashMap<String, Logger>();

     /**
      * INTERNAL:
      */

     public JavaLog(){
         super();
         addLogger(DEFAULT_TOPLINK_NAMESPACE, DEFAULT_TOPLINK_NAMESPACE);
     }

     /**
      * INTERNAL:
      * Add Logger to the categoryloggers.
      */
     protected void addLogger(String loggerCategory, String loggerNameSpace) {
         categoryloggers.put(loggerCategory, Logger.getLogger(loggerNameSpace));
     }

     /**
      * INTERNAL:
      * Return catagoryloggers
      */
      public Map getCategoryLoggers() {
          return categoryloggers;
      }

     /**
      * PUBLIC:
      * <p>
      * Return the effective log level for the name space extracted from session and category.
      * If a Logger's level is set to be null then the Logger will use an effective Level that will
      * be obtained by walking up the parent tree and using the first non-null Level.
      * </p>
      *
      * @return the effective log level.
      */
     @Override
     public int getLevel(String category) {
         Logger logger = getLogger(category);
         while ((logger != null) && (logger.getLevel() == null)) {
             logger = logger.getParent();
         }

         if (logger == null) {
             return OFF;
         }

         //For a given java.util.logging.Level, return the index (ie, TopLink logging level)
         int logLevel = logger.getLevel().intValue();
         for (int i = 0; i < levels.length ; i++) {
             if (logLevel == levels[i].intValue()) {
                 return i;
             }
         }
         return OFF;
     }

     /**
      * PUBLIC:
      * <p>
      * Set the log level to a logger with name space extracted from the given category.
      * </p>
      */
     @Override
     public void setLevel(final int level, String category) {
         final Logger logger = getLogger(category);
         if (logger == null) {
             return;
         }

         AccessController.doPrivileged(new PrivilegedAction() {
             @Override
             public Object run() {
                 logger.setLevel(getJavaLevel(level));
                 return null; // nothing to return
             }
         });
     }

     /**
      * PUBLIC:
      * <p>
      * Set the output stream  that will receive the formatted log entries.
      * </p>
      *
      * @param fileOutputStream the file output stream will receive the formatted log entries.
      */
     @Override
     public void setWriter(OutputStream fileOutputStream){
         StreamHandler sh = new StreamHandler(fileOutputStream,new LogFormatter());
         ((Logger)categoryloggers.get(DEFAULT_TOPLINK_NAMESPACE)).addHandler(sh);
         if(sessionLogger!=null){
             sessionLogger.addHandler(sh);
         }
     }

     /**
      * INTERNAL:
      * Return the name space for the given category from the map.
      */
     protected String getNameSpaceString(String category) {
         if (session == null) {
             return DEFAULT_TOPLINK_NAMESPACE;
         } else if ((category == null) || (category.length() == 0)) {
             return sessionNameSpace;
         } else {
             return  (String)nameSpaceMap.get(category);
         }
     }

     /**
      * INTERNAL:
      * Return the Logger for the given category
      */
     protected Logger getLogger(String category) {
         if (session == null) {
             return (Logger)categoryloggers.get(DEFAULT_TOPLINK_NAMESPACE);
         } else if ((category == null) || (category.length() == 0) || !this.categoryloggers.containsKey(category)) {
             return (Logger) categoryloggers.get(sessionNameSpace);
         } else {
             Logger logger = (Logger) categoryloggers.get(category);
             // If session != null, categoryloggers should have an entry for this category
             assert logger != null;
             return logger;
         }
     }

     /**
      * PUBLIC:
      * <p>
      * Set the session and session namespace.
      * </p>
      *
      * @param session  a Session
      */
     @Override
     public void setSession(Session session) {
         super.setSession(session);
         if (session != null) {
             String sessionName = session.getName();
             if ((sessionName != null) && (sessionName.length() != 0)) {
                 sessionNameSpace = SESSION_TOPLINK_NAMESPACE + "." + sessionName;
             } else {
                 sessionNameSpace = DEFAULT_TOPLINK_NAMESPACE;
             }

             //Initialize loggers eagerly
             addLogger(sessionNameSpace, sessionNameSpace);
              for (int i = 0; i < loggerCatagories.length; i++) {
                 String loggerCategory =  loggerCatagories[i];
                 String loggerNameSpace = sessionNameSpace + "." + loggerCategory;
                 nameSpaceMap.put(loggerCategory, loggerNameSpace);
                 addLogger(loggerCategory, loggerNameSpace);
             }
         }
     }

     /**
      * INTERNAL:
      * Return the corresponding java.util.logging.Level for a given TopLink level.
      */
     protected Level getJavaLevel(int level) {
         return levels[level];
     }

     /**
      * PUBLIC:
      * <p>
      * Check if a message of the given level would actually be logged by the logger
      * with name space built from the given session and category.
      * Return the shouldLog for the given category from
      * </p>
      * @return true if the given message level will be logged
      */
     @Override
     public boolean shouldLog(int level, String category) {
         Logger logger = getLogger(category);
         return logger.isLoggable(getJavaLevel(level));
     }

     /**
      * PUBLIC:
      * <p>
      * Log a SessionLogEntry
      * </p>
      * @param entry SessionLogEntry that holds all the information for a TopLink logging event
      */
     @Override
     public void log(SessionLogEntry entry) {
         if (!shouldLog(entry.getLevel(), entry.getNameSpace())) {
             return;
         }

         Logger logger = getLogger(entry.getNameSpace());
         Level javaLevel = getJavaLevel(entry.getLevel());

         internalLog(entry, javaLevel, logger);
     }

     /**
      * INTERNAL:
      * <p>
      * Build a LogRecord
      * </p>
      * @param entry SessionLogEntry that holds all the information for a TopLink logging event
      * @param javaLevel the message level
      */
     protected void internalLog(SessionLogEntry entry, Level javaLevel, Logger logger) {
         // Format message so that we do not depend on the bundle
         EclipseLinkLogRecord lr = new EclipseLinkLogRecord(javaLevel, formatMessage(entry));

         lr.setSourceClassName(entry.getSourceClassName());
         lr.setSourceMethodName(entry.getSourceMethodName());
         lr.setLoggerName(getNameSpaceString(entry.getNameSpace()));
         if (shouldPrintSession()) {
             lr.setSessionString(getSessionString(entry.getSession()));
         }
         if (shouldPrintConnection()) {
             lr.setConnection(entry.getConnection());
         }
         lr.setThrown(entry.getException());
         lr.setShouldLogExceptionStackTrace(shouldLogExceptionStackTrace());
         lr.setShouldPrintDate(shouldPrintDate());
         lr.setShouldPrintThread(shouldPrintThread());
         logger.log(lr);
     }

     /**
      * PUBLIC:
      * <p>
      * Log a throwable.
      * </p>
      * @param throwable a throwable
      */
     @Override
     public void throwing(Throwable throwable) {
         getLogger(null).throwing(null, null, throwable);
     }

     /**
      * INTERNAL:
      * Each session owns its own session log because session is stored in the session log
      */
     @Override
     public Object clone() {
         // There is no special treatment required for cloning here
         // The state of this object is described  by member variables sessionLogger and categoryLoggers.
         // This state depends on session.
         // If session for the clone is going to be the same as session for this there is no
         // need to do "deep" cloning.
         // If not, the session being cloned should call setSession() on its JavaLog object to initialize it correctly.
         JavaLog cloneLog = (JavaLog)super.clone();
         return cloneLog;
     }
 }
	/*
	* Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
	*
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Public License v. 2.0 which is available at
	* http://www.eclipse.org/legal/epl-2.0,
	* or the Eclipse Distribution License v. 1.0 which is available at
	* http://www.eclipse.org/org/documents/edl-v10.php.
	*
	* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
	*/

	// Contributors:
	// Oracle - initial API and implementation from Oracle TopLink
	package org.eclipse.persistence.logging;


	import java.io.OutputStream;
	import java.security.AccessController;
	import java.security.PrivilegedAction;
	import java.util.HashMap;
	import java.util.Map;
	import java.util.logging.Level;
	import java.util.logging.Logger;
	import java.util.logging.StreamHandler;

	import org.eclipse.persistence.sessions.Session;

	/**
	* PUBLIC:
	* <p>
	* This is a wrapper class for java.util.logging. It is used when messages need to
	* be logged through java.util.logging.
	* </p>
	* @see SessionLog
	* @see AbstractSessionLog
	* @see SessionLogEntry
	* @see Session
	*/
	public class JavaLog extends AbstractSessionLog {

	/**
	* Stores the default session name in case there is the session name is missing.
	*/
	public static final String TOPLINK_NAMESPACE = "org.eclipse.persistence";
	protected static final String LOGGING_LOCALIZATION_STRING = "org.eclipse.persistence.internal.localization.i18n.LoggingLocalizationResource";
	protected static final String TRACE_LOCALIZATION_STRING = "org.eclipse.persistence.internal.localization.i18n.TraceLocalizationResource";
	public static final String DEFAULT_TOPLINK_NAMESPACE = TOPLINK_NAMESPACE + ".default";
	public static final String SESSION_TOPLINK_NAMESPACE = TOPLINK_NAMESPACE + ".session";

	/**
	* Stores all the java.util.logging.Levels. The indexes are TopLink logging levels.
	*/
	private static final Level[] levels = new Level[] { Level.ALL, Level.FINEST, Level.FINER, Level.FINE, Level.CONFIG, Level.INFO, Level.WARNING, Level.SEVERE, Level.OFF };

	/**
	* Represents the HashMap that stores all the name space strings.
	* The keys are category names. The values are namespace strings.
	*/
	private Map nameSpaceMap = new HashMap();

	/**
	* Stores the namespace for session, i.e."{@code org.eclipse.persistence.session.<sessionname>}".
	*/
	private String sessionNameSpace;

	/**
	* Stores the Logger for session namespace, i.e. "{@code org.eclipse.persistence.session.<sessionname>}".
	*/
	private Logger sessionLogger;

	private Map categoryloggers = new HashMap<String, Logger>();

	/**
	* INTERNAL:
	*/

	public JavaLog(){
	super();
	addLogger(DEFAULT_TOPLINK_NAMESPACE, DEFAULT_TOPLINK_NAMESPACE);
	}

	/**
	* INTERNAL:
	* Add Logger to the categoryloggers.
	*/
	protected void addLogger(String loggerCategory, String loggerNameSpace) {
	categoryloggers.put(loggerCategory, Logger.getLogger(loggerNameSpace));
	}

	/**
	* INTERNAL:
	* Return catagoryloggers
	*/
	public Map getCategoryLoggers() {
	return categoryloggers;
	}

	/**
	* PUBLIC:
	* <p>
	* Return the effective log level for the name space extracted from session and category.
	* If a Logger's level is set to be null then the Logger will use an effective Level that will
	* be obtained by walking up the parent tree and using the first non-null Level.
	* </p>
	*
	* @return the effective log level.
	*/
	@Override
	public int getLevel(String category) {
	Logger logger = getLogger(category);
	while ((logger != null) && (logger.getLevel() == null)) {
	logger = logger.getParent();
	}

	if (logger == null) {
	return OFF;
	}

	//For a given java.util.logging.Level, return the index (ie, TopLink logging level)
	int logLevel = logger.getLevel().intValue();
	for (int i = 0; i < levels.length ; i++) {
	if (logLevel == levels[i].intValue()) {
	return i;
	}
	}
	return OFF;
	}

	/**
	* PUBLIC:
	* <p>
	* Set the log level to a logger with name space extracted from the given category.
	* </p>
	*/
	@Override
	public void setLevel(final int level, String category) {
	final Logger logger = getLogger(category);
	if (logger == null) {
	return;
	}

	AccessController.doPrivileged(new PrivilegedAction() {
	@Override
	public Object run() {
	logger.setLevel(getJavaLevel(level));
	return null; // nothing to return
	}
	});
	}

	/**
	* PUBLIC:
	* <p>
	* Set the output stream that will receive the formatted log entries.
	* </p>
	*
	* @param fileOutputStream the file output stream will receive the formatted log entries.
	*/
	@Override
	public void setWriter(OutputStream fileOutputStream){
	StreamHandler sh = new StreamHandler(fileOutputStream,new LogFormatter());
	((Logger)categoryloggers.get(DEFAULT_TOPLINK_NAMESPACE)).addHandler(sh);
	if(sessionLogger!=null){
	sessionLogger.addHandler(sh);
	}
	}

	/**
	* INTERNAL:
	* Return the name space for the given category from the map.
	*/
	protected String getNameSpaceString(String category) {
	if (session == null) {
	return DEFAULT_TOPLINK_NAMESPACE;
	} else if ((category == null) \|\| (category.length() == 0)) {
	return sessionNameSpace;
	} else {
	return (String)nameSpaceMap.get(category);
	}
	}

	/**
	* INTERNAL:
	* Return the Logger for the given category
	*/
	protected Logger getLogger(String category) {
	if (session == null) {
	return (Logger)categoryloggers.get(DEFAULT_TOPLINK_NAMESPACE);
	} else if ((category == null) \|\| (category.length() == 0) \|\| !this.categoryloggers.containsKey(category)) {
	return (Logger) categoryloggers.get(sessionNameSpace);
	} else {
	Logger logger = (Logger) categoryloggers.get(category);
	// If session != null, categoryloggers should have an entry for this category
	assert logger != null;
	return logger;
	}
	}

	/**
	* PUBLIC:
	* <p>
	* Set the session and session namespace.
	* </p>
	*
	* @param session a Session
	*/
	@Override
	public void setSession(Session session) {
	super.setSession(session);
	if (session != null) {
	String sessionName = session.getName();
	if ((sessionName != null) && (sessionName.length() != 0)) {
	sessionNameSpace = SESSION_TOPLINK_NAMESPACE + "." + sessionName;
	} else {
	sessionNameSpace = DEFAULT_TOPLINK_NAMESPACE;
	}

	//Initialize loggers eagerly
	addLogger(sessionNameSpace, sessionNameSpace);
	for (int i = 0; i < loggerCatagories.length; i++) {
	String loggerCategory = loggerCatagories[i];
	String loggerNameSpace = sessionNameSpace + "." + loggerCategory;
	nameSpaceMap.put(loggerCategory, loggerNameSpace);
	addLogger(loggerCategory, loggerNameSpace);
	}
	}
	}

	/**
	* INTERNAL:
	* Return the corresponding java.util.logging.Level for a given TopLink level.
	*/
	protected Level getJavaLevel(int level) {
	return levels[level];
	}

	/**
	* PUBLIC:
	* <p>
	* Check if a message of the given level would actually be logged by the logger
	* with name space built from the given session and category.
	* Return the shouldLog for the given category from
	* </p>
	* @return true if the given message level will be logged
	*/
	@Override
	public boolean shouldLog(int level, String category) {
	Logger logger = getLogger(category);
	return logger.isLoggable(getJavaLevel(level));
	}

	/**
	* PUBLIC:
	* <p>
	* Log a SessionLogEntry
	* </p>
	* @param entry SessionLogEntry that holds all the information for a TopLink logging event
	*/
	@Override
	public void log(SessionLogEntry entry) {
	if (!shouldLog(entry.getLevel(), entry.getNameSpace())) {
	return;
	}

	Logger logger = getLogger(entry.getNameSpace());
	Level javaLevel = getJavaLevel(entry.getLevel());

	internalLog(entry, javaLevel, logger);
	}

	/**
	* INTERNAL:
	* <p>
	* Build a LogRecord
	* </p>
	* @param entry SessionLogEntry that holds all the information for a TopLink logging event
	* @param javaLevel the message level
	*/
	protected void internalLog(SessionLogEntry entry, Level javaLevel, Logger logger) {
	// Format message so that we do not depend on the bundle
	EclipseLinkLogRecord lr = new EclipseLinkLogRecord(javaLevel, formatMessage(entry));

	lr.setSourceClassName(entry.getSourceClassName());
	lr.setSourceMethodName(entry.getSourceMethodName());
	lr.setLoggerName(getNameSpaceString(entry.getNameSpace()));
	if (shouldPrintSession()) {
	lr.setSessionString(getSessionString(entry.getSession()));
	}
	if (shouldPrintConnection()) {
	lr.setConnection(entry.getConnection());
	}
	lr.setThrown(entry.getException());
	lr.setShouldLogExceptionStackTrace(shouldLogExceptionStackTrace());
	lr.setShouldPrintDate(shouldPrintDate());
	lr.setShouldPrintThread(shouldPrintThread());
	logger.log(lr);
	}

	/**
	* PUBLIC:
	* <p>
	* Log a throwable.
	* </p>
	* @param throwable a throwable
	*/
	@Override
	public void throwing(Throwable throwable) {
	getLogger(null).throwing(null, null, throwable);
	}

	/**
	* INTERNAL:
	* Each session owns its own session log because session is stored in the session log
	*/
	@Override
	public Object clone() {
	// There is no special treatment required for cloning here
	// The state of this object is described by member variables sessionLogger and categoryLoggers.
	// This state depends on session.
	// If session for the clone is going to be the same as session for this there is no
	// need to do "deep" cloning.
	// If not, the session being cloned should call setSession() on its JavaLog object to initialize it correctly.
	JavaLog cloneLog = (JavaLog)super.clone();
	return cloneLog;
	}
	}