How to use

Logger

in

org.apache.log4j

  /** Listens for client connections **/
  public void run() {
    LOG.info("Thread started");
    try {
      while (true) {
        LOG.debug("Waiting for a connection");
        final Socket client = mSvrSock.accept();
        LOG.debug("Got a connection from " +
             client.getInetAddress().getHostName());
        final Thread t = new Thread(new Slurper(client));
        t.setDaemon(true);
        t.start();
      }
    } catch (IOException e) {
      LOG.error("Error in accepting connections, stopping.", e);
    }
  }
}

 static
 void roll() {
  try {
   Socket socket = new Socket(host, port);
   DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
   DataInputStream dis = new DataInputStream(socket.getInputStream());
   dos.writeUTF(ExternallyRolledFileAppender.ROLL_OVER);
   String rc = dis.readUTF();
   if(ExternallyRolledFileAppender.OK.equals(rc)) {
  cat.info("Roll over signal acknowledged by remote appender.");
   } else {
  cat.warn("Unexpected return code "+rc+" from remote entity.");
  System.exit(2);
   }
  } catch(IOException e) {
   cat.error("Could not send roll signal on host "+host+" port "+port+" .",
    e);
   System.exit(2);
  }
  System.exit(0);
 }
}

@Override
public boolean isDebugEnabled() {
  return logger.isDebugEnabled();
}

/**
 * Is this logger instance enabled for the TRACE level?
 *
 * @return True if this Logger is enabled for level TRACE, false otherwise.
 */
@Override
public boolean isTraceEnabled() {
  if (traceCapable) {
    return logger.isTraceEnabled();
  } else {
    return logger.isDebugEnabled();
  }
}

  private static void configLogger(String value) {
    Logger rootLogger = Logger.getRootLogger();
    if ("debug".equalsIgnoreCase(value)) {
      rootLogger.setLevel(Level.DEBUG);
    } else if ("info".equalsIgnoreCase(value)) {
      rootLogger.setLevel(Level.INFO);
    } else if ("warn".equalsIgnoreCase(value)) {
      rootLogger.setLevel(Level.WARN);
    } else if ("trace".equalsIgnoreCase(value)) {
      rootLogger.setLevel(Level.TRACE);
    } else if ("off".equalsIgnoreCase(value)) {
      rootLogger.setLevel(Level.OFF);
    } else if ("error".equalsIgnoreCase(value)) {
      rootLogger.setLevel(Level.ERROR);
    }
  }
}

public void onMessage(javax.jms.Message message) {
 LoggingEvent event;
 Logger remoteLogger;
 try {
  if(message instanceof  ObjectMessage) {
 ObjectMessage objectMessage = (ObjectMessage) message;
 event = (LoggingEvent) objectMessage.getObject();
 remoteLogger = Logger.getLogger(event.getLoggerName());
 remoteLogger.callAppenders(event);
  } else {
 logger.warn("Received message is of type "+message.getJMSType()
     +", was expecting ObjectMessage.");
  }      
 } catch(JMSException jmse) {
  logger.error("Exception thrown while processing incoming message.", 
     jmse);
 }
}

private void mutedClose(Connection connection, PreparedStatement statement, ResultSet resultSet) {
 try {
  resultSet.close();
  statement.close();
  connection.close();
 } catch (SQLException e) {
  LOGGER.info("Exception thrown " + e.getMessage());
 }
}

@Override
protected void statementLog(String message) {
  statementLogger.debug(message);
}

  @Override
  protected void statementLogError(String message, Throwable error) {
    statementLogger.error(message, error);
  }
}

  /**
   * Starts instance of HtmlAdapterServer.
   * @deprecated
   */
 public void start() {

  MBeanServer server = MBeanServerFactory.createMBeanServer();
  Object html = createServer();

  try {
   log.info("Registering HtmlAdaptorServer instance.");
   server.registerMBean(html, new ObjectName("Adaptor:name=html,port=8082"));
   log.info("Registering HierarchyDynamicMBean instance.");
   HierarchyDynamicMBean hdm = new HierarchyDynamicMBean();
   server.registerMBean(hdm, new ObjectName("log4j:hiearchy=default"));
  } catch(JMException e) {
   log.error("Problem while registering MBeans instances.", e);
   return;
  } catch(RuntimeException e) {
   log.error("Problem while registering MBeans instances.", e);
   return;
  }
  startServer(html);
 }
}

void registerAppenderMBean(Appender appender) {
 String name = getAppenderName(appender);
 cat.debug("Adding AppenderMBean for appender named "+name);
 ObjectName objectName = null;
 try {
  AppenderDynamicMBean appenderMBean = new AppenderDynamicMBean(appender);
  objectName = new ObjectName("log4j", "appender", name);
  if (!server.isRegistered(objectName)) {
   registerMBean(appenderMBean, objectName);
   dAttributes.add(new MBeanAttributeInfo("appender=" + name, "javax.management.ObjectName",
       "The " + name + " appender.", true, true, false));
  }
 } catch(JMException e) {
  cat.error("Could not add appenderMBean for ["+name+"].", e);
 } catch(java.beans.IntrospectionException e) {
  cat.error("Could not add appenderMBean for ["+name+"].", e);
 } catch(RuntimeException e) {
  cat.error("Could not add appenderMBean for ["+name+"].", e);
 }
}

  public MetricsCollectorConfig(String topoName, Map<String, Object> topoConfig) {
    this.topoConfig = topoConfig;
    String labelStr = (String) topoConfig.get("benchmark.label");
    this.name = topoName;
    if (labelStr == null) {
      LOG.warn("'benchmark.label' not found in config. Defaulting to topology name");
      labelStr = this.name;
    }
    this.label = labelStr;
  }
} // MetricsCollectorConfig

  public void process(WatchedEvent event) {
    // lets either become the leader or watch the new/updated node
    LOG.debug("Watcher fired on path: " + event.getPath() + " state: " +
           event.getState() + " type " + event.getType());
    try {
      lock();
    } catch (Exception e) {
      LOG.warn("Failed to acquire lock: " + e, e);
    }
  }
}

LoggerRepository configureHierarchy(InetAddress inetAddress) {
 cat.info("Locating configuration file for "+inetAddress);
 // We assume that the toSting method of InetAddress returns is in
 // the format hostname/d1.d2.d3.d4 e.g. torino/192.168.1.1
 String s = inetAddress.toString();
 int i = s.indexOf("/");
 if(i == -1) {
  cat.warn("Could not parse the inetAddress ["+inetAddress+
     "]. Using default hierarchy.");
  return genericHierarchy();
 } else {
  String key = s.substring(0, i);
  File configFile = new File(dir, key+CONFIG_FILE_EXT);
  if(configFile.exists()) {
 Hierarchy h = new Hierarchy(new RootLogger(Level.DEBUG));
 hierarchyMap.put(inetAddress, h);
 new PropertyConfigurator().doConfigure(configFile.getAbsolutePath(), h);
 return h;
  } else {
 cat.warn("Could not find config file ["+configFile+"].");
 return genericHierarchy();
  }
 }
}

@Override
public void setConnectionLoggerName(String connectionLoggerName) {
  this.connectionLoggerName = connectionLoggerName;
  connectionLogger = Logger.getLogger(connectionLoggerName);
}

void addAppender(String appenderClass, String appenderName) {
 cat.debug("addAppender called with "+appenderClass+", "+appenderName);
 Appender appender = (Appender)
   OptionConverter.instantiateByClassName(appenderClass,
            org.apache.log4j.Appender.class,
            null);
 appender.setName(appenderName);
 logger.addAppender(appender);
 //appenderMBeanRegistration();
}

public static void addTestAppender(Class target, Level level) {
  testAppender = new TestAppender();
  testAppender.setThreshold(level);
  org.apache.log4j.Logger lg = org.apache.log4j.Logger.getLogger(target);
  lg.setLevel(level);
  lg.addAppender(testAppender);
  //org.apache.log4j.Logger.getRootLogger().addAppender(testAppender);
}

 public static void main(String[] argv) throws Exception {
  // Silence the usual noise. This is probably fragile...
  Logger logger = Logger.getLogger("org.apache.hadoop.hbase");
  if (logger != null) {
   logger.setLevel(Level.WARN);
  }
  System.exit(ToolRunner.run(
   HBaseConfiguration.create(), new MapreduceDependencyClasspathTool(), argv));
 }
}

/**
 * Sets level for internal log4j implementation.
 *
 * @param level Log level to set.
 */
public void setLevel(Level level) {
  impl.setLevel(level);
}

 @Test
 public void testAppenderDefined() {
  HttpRequestLogAppender requestLogAppender = new HttpRequestLogAppender();
  requestLogAppender.setName("testrequestlog");
  Logger.getLogger("http.requests.test").addAppender(requestLogAppender);
  RequestLog requestLog = HttpRequestLog.getRequestLog("test");
  Logger.getLogger("http.requests.test").removeAppender(requestLogAppender);
  assertNotNull("RequestLog should not be null", requestLog);
  assertEquals("Class mismatch", NCSARequestLog.class, requestLog.getClass());
 }
}