1   /*
2    * Copyright 2000-2001,2004 The Apache Software Foundation.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    * 
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  
17  package org.apache.wsrp4j.log;
18  
19  import java.io.InputStream;
20  import java.util.Properties;
21  
22  /**
23   Logger factory return an appropriate implementation of a Logger
24   */
25  public class LogManager {
26  
27      private static final String LOG_PROPERTIES_FILE = "wsrp-logger.properties";
28  
29      private static final String PROPERTY_PREFIX = "wsrp4j.logger.";
30  
31      private static final String GLOBAL_LOG_LEVEL_PROPERTY = "wsrp4j.logger";
32  
33      private static int globalLogLevel = Logger.ERROR;
34  
35      private static Properties wsrp4jLevels = new Properties();
36  
37      private static LogManager logManager = new LogManager();
38  
39      /**
40       private constructor prohibits sub-classing
41       */
42      private LogManager() {
43          try {
44              InputStream propertiesInputStream;
45              propertiesInputStream = this.getClass().getClassLoader()
46                      .getResourceAsStream(LOG_PROPERTIES_FILE);
47              wsrp4jLevels.load(propertiesInputStream);
48          }
49          catch (Exception e) {
50              System.err
51                      .println("LogManager: Error while initializing log properties. StackTrace follows.");
52              e.printStackTrace(System.err);
53          }
54          try {
55              //load log4j configuration from properties
56              org.apache.log4j.PropertyConfigurator.configure(wsrp4jLevels);
57  
58              //log used properties file
59              org.apache.log4j.Logger.getLogger(this.getClass()).info(
60                      "Logger.properties file: " + LOG_PROPERTIES_FILE);
61  
62              //initialize wsrp4j-logger levels from properties
63              int userDefinedGlobalLevel = getLevelFromString(wsrp4jLevels
64                      .getProperty(GLOBAL_LOG_LEVEL_PROPERTY));
65              if (userDefinedGlobalLevel != 0) {
66                  globalLogLevel = userDefinedGlobalLevel;
67              }
68  
69              //log global wsrp4jlog level
70              org.apache.log4j.Logger.getLogger(this.getClass()).info(
71                      "Global log level: "
72                              + this.getLevelAsString(globalLogLevel));
73  
74          }
75          catch (Exception e) {
76              System.err.println("LogManager: Error while initializing Logger.");
77              // StackTrace follows.");
78              //e.printStackTrace(System.err);
79          }
80      }
81  
82      /**
83       Returns the LogManager instance
84       
85       @return LogManager instance
86       */
87      public static LogManager getLogManager() {
88          return logManager;
89      }
90  
91      /**
92       Returns a Logger instance for the calling class
93       
94       @param aClass The class that requests the logger instance.
95       @return instance of <CODE>Logger</CODE>.
96       */
97      public Logger getLogger(Class aClass) {
98          //create a Logger
99          org.apache.log4j.Logger logger = org.apache.log4j.Logger
100                 .getLogger(aClass);
101 
102         //determine log level for aClass
103         String propertyName = PROPERTY_PREFIX + aClass.getName();
104         int level = globalLogLevel;
105         int userDefinedLevel = getLevelFromString(wsrp4jLevels
106                 .getProperty(propertyName));
107         if (userDefinedLevel != 0) {
108             level = userDefinedLevel;
109         }
110         return new LoggerImpl(logger, level);
111     }
112 
113     /*
114      Returns an int LogLevel defined by a String {ERROR, WARN, INFO, TRACE_HIGH, TRACE_MEDIUM, TRACE_LOW}.
115      Use this method to convert levels defined in a properties file
116      If the string does not represent a correct level this method returns 0
117      */
118     private int getLevelFromString(String s) {
119         if (s != null) {
120             if (s.equalsIgnoreCase("ERROR")) {
121                 return Logger.ERROR;
122             }
123             else if (s.equalsIgnoreCase("WARN")) {
124                 return Logger.WARN;
125             }
126             else if (s.equalsIgnoreCase("INFO")) {
127                 return Logger.INFO;
128             }
129             else if (s.equalsIgnoreCase("TRACE_LOW")) {
130                 return Logger.TRACE_LOW;
131             }
132             else if (s.equalsIgnoreCase("TRACE_MEDIUM")) {
133                 return Logger.TRACE_MEDIUM;
134             }
135             else if (s.equalsIgnoreCase("TRACE_HIGH")) {
136                 return Logger.TRACE_HIGH;
137             }
138             else {
139                 return 0;
140             }
141         }
142         else {
143             return 0;
144         }
145     }
146 
147     /*
148      Translates a int logLevel to a String
149      */
150     private String getLevelAsString(int level) {
151         String sLevel;
152         if (level < Logger.WARN) {
153             sLevel = "ERROR";
154         }
155         else if (level < Logger.INFO) {
156             sLevel = "WARN";
157         }
158         else if (level < Logger.TRACE_LOW) {
159             sLevel = "INFO";
160         }
161         else if (level < Logger.TRACE_MEDIUM) {
162             sLevel = "TRACE_LOW";
163         }
164         else if (level < Logger.TRACE_HIGH) {
165             sLevel = "TRACE_MEDIUM";
166         }
167         else {
168             sLevel = "TRACE_HIGH";
169         }
170         return sLevel;
171     }
172 }