Merge remote-tracking branch 'gr3.7_log4cpp'

author: Tom Rondeau <trondeau@vt.edu> 2013-03-13 15:35:51 -0400
committer: Tom Rondeau <trondeau@vt.edu> 2013-03-13 15:35:51 -0400
commit: 890f2882d2210b1d4e64f0bbffc42ccc716cfd97 (patch)
tree: 3f85469b8ce65d0bc691e105257ccad32d603535
parent: 4e81a23e6c950e38fe920fbea0dffe551ec35a2f (diff)
parent: afae86a4354c2c82030def9c90b8fe74dcbf4f9d (diff)
13 files changed, 478 insertions, 367 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2c0a4e9096..edfd269a2e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -231,7 +231,10 @@ endif(ENABLE_VOLK)
 
 # Handle gr_log enable/disable
 GR_LOGGING()
+set(LOG4CPP_LIBRARIES ${LOG4CPP_LIBRARY})
+message("First Libs: ${LOG4CPP_LIBRARIES}")
 
+message("First Lib: ${LOG4CPP_LIBRARY}")
 ########################################################################
 # Distribute the README file
 ########################################################################
diff --git a/cmake/Modules/FindLog4cpp.cmake b/cmake/Modules/FindLog4cpp.cmake
new file mode 100644
index 0000000000..0b7208630f
--- /dev/null
+++ b/cmake/Modules/FindLog4cpp.cmake
@@ -0,0 +1,58 @@
+# - Find Log4cpp
+# Find the native LOG4CPP includes and library
+#
+#  LOG4CPP_INCLUDE_DIR - where to find LOG4CPP.h, etc.
+#  LOG4CPP_LIBRARIES   - List of libraries when using LOG4CPP.
+#  LOG4CPP_FOUND       - True if LOG4CPP found.
+
+
+if (LOG4CPP_INCLUDE_DIR)
+  # Already in cache, be silent
+  set(LOG4CPP_FIND_QUIETLY TRUE)
+endif ()
+
+find_path(LOG4CPP_INCLUDE_DIR log4cpp/Category.hh
+  /opt/local/include
+  /usr/local/include
+  /usr/include
+)
+
+set(LOG4CPP_NAMES log4cpp)
+find_library(LOG4CPP_LIBRARY
+  NAMES ${LOG4CPP_NAMES}
+  PATHS /usr/lib /usr/local/lib /opt/local/lib
+)
+
+message("#####################")
+message("LOG INCLEUDE :${LOG4CPP_INCLUDE_DIR}")
+message("LOG LIBRARY :${LOG4CPP_LIBRARY}")
+
+
+message("#####################")
+
+if (LOG4CPP_INCLUDE_DIR AND LOG4CPP_LIBRARY)
+  set(LOG4CPP_FOUND TRUE)
+  set(LOG4CPP_LIBRARIES ${LOG4CPP_LIBRARY} )
+else ()
+  set(LOG4CPP_FOUND FALSE)
+  set(LOG4CPP_LIBRARIES )
+endif ()
+
+if (LOG4CPP_FOUND)
+  if (NOT LOG4CPP_FIND_QUIETLY)
+    message(STATUS "Found LOG4CPP: ${LOG4CPP_LIBRARIES}")
+  endif ()
+else ()
+  if (LOG4CPP_FIND_REQUIRED)
+    message(STATUS "Looked for LOG4CPP libraries named ${LOG4CPPS_NAMES}.")
+    message(FATAL_ERROR "Could NOT find LOG4CPP library")
+  endif ()
+endif ()
+
+message("internal libs: ${LOG4CPP_LIBRARIES}")
+
+mark_as_advanced(
+  LOG4CPP_LIBRARY
+  LOG4CPP_LIBRARIES
+  LOG4CPP_INCLUDE_DIR
+  )
diff --git a/cmake/Modules/FindLog4cxx.cmake b/cmake/Modules/FindLog4cxx.cmake
deleted file mode 100644
index b1e4f6f1f7..0000000000
--- a/cmake/Modules/FindLog4cxx.cmake
+++ /dev/null
@@ -1,28 +0,0 @@
-#   CMake module to find LOG4CXX library
-
-INCLUDE(FindPkgConfig)
-PKG_CHECK_MODULES(PC_LOG4CXX liblog4cxx)
-
-FIND_PATH(
-    LOG4CXX_INCLUDE_DIRS
-    NAMES log4cxx/log4cxx.h
-    HINTS $ENV{LOG4CXX_DIR}/include
-        ${PC_LOG4CXX_INCLUDE_DIRS}
-    PATHS /usr/local/include
-          /usr/include
-)
-
-FIND_LIBRARY(
-    LOG4CXX_LIBRARIES
-    NAMES log4cxx
-    HINTS $ENV{LOG4CXX_DIR}/lib
-        ${PC_LOG4CXX_LIBRARIES}
-    PATHS /usr/local/lib
-          /usr/local/lib64
-          /usr/lib
-          /usr/lib64
-)
-
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(LOG4CXX DEFAULT_MSG LOG4CXX_LIBRARIES LOG4CXX_INCLUDE_DIRS)
-MARK_AS_ADVANCED(LOG4CXX_LIBRARIES LOG4CXX_INCLUDE_DIRS)
diff --git a/cmake/Modules/GrMiscUtils.cmake b/cmake/Modules/GrMiscUtils.cmake
index c7fe77bc88..65b0b5a8c8 100644
--- a/cmake/Modules/GrMiscUtils.cmake
+++ b/cmake/Modules/GrMiscUtils.cmake
@@ -218,36 +218,39 @@ endfunction(GR_GEN_TARGET_DEPS)
 # Can manually set with -DENABLE_GR_LOG=0|1
 ########################################################################
 function(GR_LOGGING)
-  find_package(Log4cxx)
+  find_package(Log4cpp)
+
+  message(STATUS "LOG4CPP_LIBRARIES First set to ${LOG4CPP_LIBRARIES}.")
 
   OPTION(ENABLE_GR_LOG "Use gr_logger" ON)
   if(ENABLE_GR_LOG)
     # If gr_logger is enabled, make it usable
     add_definitions( -DENABLE_GR_LOG )
 
-    # also test LOG4CXX; if we have it, use this version of the logger
+    # also test LOG4CPP; if we have it, use this version of the logger
     # otherwise, default to the stdout/stderr model.
-    if(LOG4CXX_FOUND)
-      SET(HAVE_LOG4CXX True CACHE INTERNAL "" FORCE)
-      add_definitions( -DHAVE_LOG4CXX )
-    else(LOG4CXX_FOUND)
-      SET(HAVE_LOG4CXX False CACHE INTERNAL "" FORCE)
-      SET(LOG4CXX_INCLUDE_DIRS "" CACHE INTERNAL "" FORCE)
-      SET(LOG4CXX_LIBRARY_DIRS "" CACHE INTERNAL "" FORCE)
-      SET(LOG4CXX_LIBRARIES "" CACHE INTERNAL "" FORCE)
-    endif(LOG4CXX_FOUND)
+    if(LOG4CPP_FOUND)
+      SET(HAVE_LOG4CPP True CACHE INTERNAL "" FORCE)
+      add_definitions( -DHAVE_LOG4CPP )
+    else(not LOG4CPP_FOUND)
+      SET(HAVE_LOG4CPP False CACHE INTERNAL "" FORCE)
+      SET(LOG4CPP_INCLUDE_DIRS "" CACHE INTERNAL "" FORCE)
+      SET(LOG4CPP_LIBRARY_DIRS "" CACHE INTERNAL "" FORCE)
+      SET(LOG4CPP_LIBRARIES "" CACHE INTERNAL "" FORCE)
+    endif(LOG4CPP_FOUND)
 
     SET(ENABLE_GR_LOG ${ENABLE_GR_LOG} CACHE INTERNAL "" FORCE)
 
   else(ENABLE_GR_LOG)
-    SET(HAVE_LOG4CXX False CACHE INTERNAL "" FORCE)
-    SET(LOG4CXX_INCLUDE_DIRS "" CACHE INTERNAL "" FORCE)
-    SET(LOG4CXX_LIBRARY_DIRS "" CACHE INTERNAL "" FORCE)
-    SET(LOG4CXX_LIBRARIES "" CACHE INTERNAL "" FORCE)
+    SET(HAVE_LOG4CPP False CACHE INTERNAL "" FORCE)
+    SET(LOG4CPP_INCLUDE_DIRS "" CACHE INTERNAL "" FORCE)
+    SET(LOG4CPP_LIBRARY_DIRS "" CACHE INTERNAL "" FORCE)
+    SET(LOG4CPP_LIBRARIES "" CACHE INTERNAL "" FORCE)
   endif(ENABLE_GR_LOG)
 
   message(STATUS "ENABLE_GR_LOG set to ${ENABLE_GR_LOG}.")
-  message(STATUS "HAVE_LOG4CXX set to ${HAVE_LOG4CXX}.")
+  message(STATUS "HAVE_LOG4CPP set to ${HAVE_LOG4CPP}.")
+  message(STATUS "LOG4CPP_LIBRARIES set to ${LOG4CPP_LIBRARIES}.")
 
 endfunction(GR_LOGGING)
 
diff --git a/config.h.in b/config.h.in
index 325cb838ef..a3187bb59e 100644
--- a/config.h.in
+++ b/config.h.in
@@ -25,6 +25,6 @@
 #cmakedefine TRY_SHM_VMCIRCBUF
 #cmakedefine GR_PERFORMANCE_COUNTERS
 #cmakedefine ENABLE_GR_LOG
-#cmakedefine HAVE_LOG4CXX
+#cmakedefine HAVE_LOG4CPP
 
 #endif /* GNURADIO_CONFIG_H */
diff --git a/gnuradio-core/CMakeLists.txt b/gnuradio-core/CMakeLists.txt
index 1138bcc453..97ca11e0a9 100644
--- a/gnuradio-core/CMakeLists.txt
+++ b/gnuradio-core/CMakeLists.txt
@@ -44,6 +44,7 @@ GR_REGISTER_COMPONENT("gnuradio-core" ENABLE_GR_CORE
 )
 
 include(GrMiscUtils)
+
 GR_SET_GLOBAL(GNURADIO_CORE_INCLUDE_DIRS
     ${CMAKE_CURRENT_SOURCE_DIR}/src/lib/runtime
     ${CMAKE_CURRENT_BINARY_DIR}/src/lib/general
@@ -61,6 +62,9 @@ GR_SET_GLOBAL(GNURADIO_CORE_INCLUDE_DIRS
     ${CMAKE_CURRENT_SOURCE_DIR}/src/lib/hier
 )
 
+list(APPEND GNURADIO_CORE_INCLUDE_DIRS ${CMAKE_BINARY_DIR})
+message("GNURADIO_CORE_INCLUDE_DIRS ARE: ${GNURADIO_CORE_INCLUDE_DIRS}")
+
 GR_SET_GLOBAL(GNURADIO_CORE_SWIG_INCLUDE_DIRS
     ${GNURADIO_CORE_INCLUDE_DIRS}
     ${CMAKE_CURRENT_SOURCE_DIR}/src/lib/swig
@@ -119,13 +123,13 @@ install(
     COMPONENT "core_runtime"
 )
 
-if(ENABLE_GR_LOG AND HAVE_LOG4CXX)
+if(ENABLE_GR_LOG AND HAVE_LOG4CPP)
 install(FILES
     ${CMAKE_CURRENT_SOURCE_DIR}/gr_log_default.xml
     DESTINATION ${GR_CONF_DIR}/gnuradio
     COMPONENT "core_runtime"
 )
-endif(ENABLE_GR_LOG AND HAVE_LOG4CXX)
+endif(ENABLE_GR_LOG AND HAVE_LOG4CPP)
 
 ########################################################################
 # Add subdirectories
diff --git a/gnuradio-core/src/lib/CMakeLists.txt b/gnuradio-core/src/lib/CMakeLists.txt
index fe3e530869..5b39cbc036 100644
--- a/gnuradio-core/src/lib/CMakeLists.txt
+++ b/gnuradio-core/src/lib/CMakeLists.txt
@@ -69,8 +69,8 @@ link_directories(
 	${FFTW3F_LIBRARY_DIRS}
 )
 
-include_directories(${LOG4CXX_INCLUDE_DIRS})
-link_directories(${LOG4CXX_LIBRARY_DIRS})
+include_directories(${LOG4CPP_INCLUDE_DIRS})
+link_directories(${LOG4CPP_LIBRARY_DIRS})
 
 ########################################################################
 # Setup library
@@ -82,12 +82,15 @@ link_directories(${LOG4CXX_LIBRARY_DIRS})
 #if(LOG4CXX_FOUND)
 #    add_definitions(-DENABLE_GR_LOG)
 #endif(LOG4CXX_FOUND)
+message("******************************************")
+message("LOG4CPP LIBRARIES are ${LOG4CPP_LIBRARIES}")
+message("******************************************")
 
 list(APPEND gnuradio_core_libs
     gruel
     ${Boost_LIBRARIES}
     ${FFTW3F_LIBRARIES}
-    ${LOG4CXX_LIBRARIES}
+    ${LOG4CPP_LIBRARIES}
 )
 
 if(FFTW3F_THREADS_LIBRARIES)
@@ -128,6 +131,6 @@ include_directories(${CPPUNIT_INCLUDE_DIRS})
 link_directories(${CPPUNIT_LIBRARY_DIRS})
 
 add_library(test-gnuradio-core SHARED ${test_gnuradio_core_sources})
-target_link_libraries(test-gnuradio-core gnuradio-core ${CPPUNIT_LIBRARIES} ${Boost_LIBRARIES} ${LOG4CXX_LIBRARIES})
+target_link_libraries(test-gnuradio-core gnuradio-core ${CPPUNIT_LIBRARIES} ${Boost_LIBRARIES} ${LOG4CPP_LIBRARIES})
 
 endif(ENABLE_TESTING)
diff --git a/gnuradio-core/src/lib/runtime/gr_block.cc b/gnuradio-core/src/lib/runtime/gr_block.cc
index 6c2ec4c539..a5029d13cc 100644
--- a/gnuradio-core/src/lib/runtime/gr_block.cc
+++ b/gnuradio-core/src/lib/runtime/gr_block.cc
@@ -52,7 +52,7 @@ gr_block::gr_block (const std::string &name,
     global_block_registry.register_primitive(alias(), this);
 
 #ifdef ENABLE_GR_LOG
-#ifdef HAVE_LOG4CXX
+#ifdef HAVE_LOG4CPP
     gr_prefs *p = gr_prefs::singleton();
     std::string config_file = p->get_string("LOG", "log_config", "");
     std::string log_level = p->get_string("LOG", "log_level", "off");
@@ -66,13 +66,13 @@ gr_block::gr_block (const std::string &name,
     GR_LOG_SET_LEVEL(LOG, log_level);
     if(log_file.size() > 0) {
       if(log_file == "stdout") {
-        GR_LOG_ADD_CONSOLE_APPENDER(LOG, "gr::log :%p: %c{1} - %m%n", "System.out");
+        GR_LOG_ADD_CONSOLE_APPENDER(LOG, "cout","gr::log :%p: %c{1} - %m%n");
       }
       else if(log_file == "stderr") {
-        GR_LOG_ADD_CONSOLE_APPENDER(LOG, "gr::log :%p: %c{1} - %m%n", "System.err");
+        GR_LOG_ADD_CONSOLE_APPENDER(LOG, "cerr","gr::log :%p: %c{1} - %m%n");
       }
       else {
-        GR_LOG_ADD_FILE_APPENDER(LOG, "%r :%p: %c{1} - %m%n", log_file, "");
+        GR_LOG_ADD_FILE_APPENDER(LOG, log_file , true,"%r :%p: %c{1} - %m%n");
       }
     }
     d_logger = LOG;
@@ -81,13 +81,13 @@ gr_block::gr_block (const std::string &name,
     GR_LOG_SET_LEVEL(DLOG, debug_level);
     if(debug_file.size() > 0) {
       if(debug_file == "stdout") {
-        GR_LOG_ADD_CONSOLE_APPENDER(DLOG, "gr::debug :%p: %c{1} - %m%n", "System.out");
+        GR_LOG_ADD_CONSOLE_APPENDER(DLOG, "cout","gr::debug :%p: %c{1} - %m%n");
       }
       else if(debug_file == "stderr") {
-        GR_LOG_ADD_CONSOLE_APPENDER(DLOG, "gr::debug :%p: %c{1} - %m%n", "System.err");
+        GR_LOG_ADD_CONSOLE_APPENDER(DLOG, "cerr", "gr::debug :%p: %c{1} - %m%n");
       }
       else {
-        GR_LOG_ADD_FILE_APPENDER(DLOG, "%r :%p: %c{1} - %m%n", debug_file, "");
+        GR_LOG_ADD_FILE_APPENDER(DLOG, debug_file, true, "%r :%p: %c{1} - %m%n");
       }
     }
     d_debug_logger = DLOG;
diff --git a/gnuradio-core/src/lib/runtime/gr_logger.cc b/gnuradio-core/src/lib/runtime/gr_logger.cc
index e337920a33..530c66f964 100644
--- a/gnuradio-core/src/lib/runtime/gr_logger.cc
+++ b/gnuradio-core/src/lib/runtime/gr_logger.cc
@@ -21,63 +21,70 @@
  */
 
 /*******************************************************************************
-* Copyright 2011 Johns Hopkins University Applied Physics Lab
 * Author: Mark Plett 
 * Description:
-*   The gr_log module wraps the log4cxx library for logging in gnuradio.
+*   The gr_log module wraps the log4cpp library for logging in gnuradio.
 *******************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include "config.h" 
-#endif
+//#ifdef HAVE_CONFIG_H
+//#include "config.h" 
+//#endif
 
 #include <gr_logger.h>
 #include <stdexcept>
 #include <algorithm>
 
 #ifdef ENABLE_GR_LOG
-#ifdef HAVE_LOG4CXX 
+#ifdef HAVE_LOG4CPP 
 
 bool gr_logger_configured(false);
 
 void
 logger_load_config(const std::string &config_filename)
 {
-  if(!gr_logger_configured) {
+  if(!gr_logger_configured){
     gr_logger_configured = true;
-    if(config_filename.size() > 0) {
-      if(config_filename.find(".xml") != std::string::npos) {
-        log4cxx::xml::DOMConfigurator::configure(config_filename);
-      }
-      else {
-        log4cxx::PropertyConfigurator::configure(config_filename);
-      }
-    }
-  }
+    if(config_filename.size() != 0) {
+       try
+       {
+         log4cpp::PropertyConfigurator::configure(config_filename);
+       }
+       catch( log4cpp::ConfigureFailure &e )
+       {
+         std::cout << "Logger config failed :" << e.what() << std::endl;
+       }
+    };
+  };
 }
 
 void
 logger_load_config_and_watch(const std::string &config_filename,
                              unsigned int watch_period)
 {
-  if(!gr_logger_configured) {
+// NOTE:: NEEDS CODE TO WATCH FILE HERE
+  if(!gr_logger_configured){
     gr_logger_configured = true;
-    if(config_filename.size() > 0) {
-      if(config_filename.find(".xml") != std::string::npos) {
-        log4cxx::xml::DOMConfigurator::configureAndWatch(config_filename, watch_period);
-      }
-      else {
-        log4cxx::PropertyConfigurator::configureAndWatch(config_filename, watch_period);
-      }
-    }
-  }
+    if(config_filename.size() != 0) {
+       try
+       {
+         log4cpp::PropertyConfigurator::configure(config_filename);
+       }
+       catch( log4cpp::ConfigureFailure &e )
+       {
+         std::cout << "Logger config failed :" << e.what() << std::endl;
+       }
+    };
+  };
 }
 
 void 
-logger_reset_config(void)
-{
-  log4cxx::LogManager::resetConfiguration();
-  gr_logger_configured=false;
+logger_reset_config(void){
+  std::vector<log4cpp::Category*> *loggers = log4cpp::Category::getCurrentCategories();
+  std::vector<log4cpp::Category*>::iterator logger = loggers->begin();
+// We can't destroy categories but we can neuter them by removing all appenders.
+  for (;logger!=loggers->end();logger++){
+    (*logger)->removeAllAppenders();
+  };
 }
 
 void
@@ -85,105 +92,113 @@ logger_set_level(gr_logger_ptr logger, const std::string &level)
 {
   std::string nocase = level;
   std::transform(level.begin(), level.end(), nocase.begin(), ::tolower);
-  
-  if(nocase == "off")
-    logger_set_level(logger, log4cxx::Level::getOff());
-  else if(nocase == "all")
-    logger_set_level(logger, log4cxx::Level::getAll());
-  else if(nocase == "trace")
-    logger_set_level(logger, log4cxx::Level::getTrace());
+
+  if(nocase == "off" || nocase == "notset")
+    logger_set_level(logger, log4cpp::Priority::NOTSET);
   else if(nocase == "debug")
-    logger_set_level(logger, log4cxx::Level::getDebug());
+    logger_set_level(logger, log4cpp::Priority::DEBUG);
   else if(nocase == "info")
-    logger_set_level(logger, log4cxx::Level::getInfo());
+    logger_set_level(logger, log4cpp::Priority::INFO);
+  else if(nocase == "notice")
+    logger_set_level(logger, log4cpp::Priority::NOTICE);
   else if(nocase == "warn")
-    logger_set_level(logger, log4cxx::Level::getWarn());
+    logger_set_level(logger, log4cpp::Priority::WARN);
   else if(nocase == "error")
-    logger_set_level(logger, log4cxx::Level::getError());
-  else if(nocase == "fatal")
-    logger_set_level(logger, log4cxx::Level::getFatal());
+    logger_set_level(logger, log4cpp::Priority::ERROR);
+  else if(nocase == "crit")
+    logger_set_level(logger, log4cpp::Priority::CRIT);
+  else if(nocase == "alert")
+    logger_set_level(logger, log4cpp::Priority::ALERT);
+ else if(nocase=="fatal")
+    logger_set_level(logger, log4cpp::Priority::FATAL);
+  else if(nocase == "all" || nocase == "emerg")
+    logger_set_level(logger, log4cpp::Priority::EMERG);
   else
     throw std::runtime_error("logger_set_level: Bad level type.\n");
 }
 
 void
-logger_set_level(gr_logger_ptr logger, log4cxx::LevelPtr level)
+logger_set_level(gr_logger_ptr logger, log4cpp::Priority::Value level)
 {
-  logger->setLevel(level);
+  logger->setPriority(level);
 }
 
 void 
 logger_get_level(gr_logger_ptr logger, std::string &level)
 {
-  log4cxx::LevelPtr levelPtr = logger->getLevel();
-  if(levelPtr == log4cxx::Level::getOff()) level = "off";
-  if(levelPtr == log4cxx::Level::getAll()) level = "all";
-  if(levelPtr == log4cxx::Level::getTrace()) level = "trace";
-  if(levelPtr == log4cxx::Level::getDebug()) level = "debug";
-  if(levelPtr == log4cxx::Level::getInfo()) level = "info";
-  if(levelPtr == log4cxx::Level::getWarn()) level = "warn";
-  if(levelPtr == log4cxx::Level::getError()) level = "error";
-  if(levelPtr == log4cxx::Level::getFatal()) level = "fatal";
+  log4cpp::Priority::Value levelPtr = logger->getPriority();
+  if(levelPtr == log4cpp::Priority::NOTSET) level = "noset";
+  if(levelPtr == log4cpp::Priority::DEBUG) level = "debug";
+  if(levelPtr == log4cpp::Priority::INFO) level = "info";
+  if(levelPtr == log4cpp::Priority::NOTICE) level = "notice";
+  if(levelPtr == log4cpp::Priority::WARN) level = "warn";
+  if(levelPtr == log4cpp::Priority::ERROR) level = "error";
+  if(levelPtr == log4cpp::Priority::CRIT) level = "crit";
+  if(levelPtr == log4cpp::Priority::ALERT) level = "alert";
+  if(levelPtr == log4cpp::Priority::FATAL) level = "fatal";
+  if(levelPtr == log4cpp::Priority::EMERG) level = "emerg";
 };
 
 void 
-logger_get_level(gr_logger_ptr logger, log4cxx::LevelPtr level)
+logger_get_level(gr_logger_ptr logger,log4cpp::Priority::Value level)
 {
-  level = logger->getLevel();
+  level = logger->getPriority();
 }
 
 void 
-logger_add_console_appender(gr_logger_ptr logger, std::string layout,
-                            std::string target)
+logger_add_console_appender(gr_logger_ptr logger,std::string target,std::string pattern)
 {
-  log4cxx::PatternLayout *playout =
-    new log4cxx::PatternLayout(layout);
-  log4cxx::ConsoleAppender *appender =
-    new log4cxx::ConsoleAppender(log4cxx::LayoutPtr(playout), target);
-  log4cxx::helpers::Pool p;
-  appender->activateOptions(p);
-  logger->addAppender(appender);
+
+  log4cpp::PatternLayout* layout = new log4cpp::PatternLayout();
+  log4cpp::Appender* app;
+  if(target=="cout")
+    app = new log4cpp::OstreamAppender("ConsoleAppender::",&std::cout);
+  else
+	  app = new log4cpp::OstreamAppender("ConsoleAppender::",&std::cerr);
+
+  layout->setConversionPattern(pattern);
+	app->setLayout(layout);
+  logger->setAppender(app);
+
 }
 
 void
-logger_add_file_appender(gr_logger_ptr logger, std::string layout,
-                         std::string filename, bool append)
+logger_add_file_appender(gr_logger_ptr logger,std::string filename,bool append,std::string pattern)
 {
-  log4cxx::PatternLayout *playout =
-    new log4cxx::PatternLayout(layout);
-  log4cxx::FileAppender *appender =
-    new log4cxx::FileAppender(log4cxx::LayoutPtr(playout), filename, append);
-  log4cxx::helpers::Pool p;
-  appender->activateOptions(p);
-  logger->addAppender(appender);
+
+  log4cpp::PatternLayout* layout = new log4cpp::PatternLayout();
+	log4cpp::Appender* app = new 
+              log4cpp::FileAppender("FileAppender::"+filename,
+              filename);
+  layout->setConversionPattern(pattern);
+	app->setLayout(layout);
+  logger->setAppender(app);
+
 }
 
 void 
-logger_add_rollingfile_appender(gr_logger_ptr logger, std::string layout,
-                                std::string filename, bool append,
-                                int bkup_index, std::string filesize)
+logger_add_rollingfile_appender(gr_logger_ptr logger,std::string filename,
+            size_t filesize,int bkup_index,bool append,mode_t mode,std::string pattern)
 {
-  log4cxx::PatternLayout *playout =
-    new log4cxx::PatternLayout(layout);
-  log4cxx::RollingFileAppender *appender = 
-    new log4cxx::RollingFileAppender(log4cxx::LayoutPtr(playout), filename, append);
-  appender->setMaxBackupIndex(bkup_index);
-  appender->setMaxFileSize(filesize);
-  log4cxx::helpers::Pool p; 
-  appender->activateOptions(p);
-  logger->addAppender(appender);
+  log4cpp::PatternLayout* layout = new log4cpp::PatternLayout();
+  log4cpp::Appender* app = new 
+              log4cpp::RollingFileAppender("RollFileAppender::"+filename,filename,filesize,bkup_index,append,mode);
+  layout->setConversionPattern(pattern);
+  app->setLayout(layout);
+  logger->setAppender(app);
 }
 
 void
-logger_get_logger_names(std::vector<std::string>& names)
-{
-  log4cxx::LoggerList list = log4cxx::LogManager::getCurrentLoggers();
-  log4cxx::LoggerList::iterator logger = list.begin();
+logger_get_logger_names(std::vector<std::string>& names){
+  std::vector<log4cpp::Category*> *loggers = log4cpp::Category::getCurrentCategories();
+  std::vector<log4cpp::Category*>::iterator logger = loggers->begin();
+
   names.clear();
-  for(; logger != list.end(); logger++) {
+  for (;logger!=loggers->end();logger++){
     names.push_back((*logger)->getName());
-  }
+  };
+  
 }
 
-#endif /* HAVE_LOG4CXX */
+#endif /* HAVE_LOG4CPP */
 #endif /* ENABLE_GR_LOGGER */
diff --git a/gnuradio-core/src/lib/runtime/gr_logger.h b/gnuradio-core/src/lib/runtime/gr_logger.h
index 40684ec9d0..d28907d045 100644
--- a/gnuradio-core/src/lib/runtime/gr_logger.h
+++ b/gnuradio-core/src/lib/runtime/gr_logger.h
@@ -21,7 +21,6 @@
  */
 
 /*******************************************************************************
-* Copyright 2011 Johns Hopkins University Applied Physics Lab
 * Author: Mark Plett
 * Description:
 *   The gr_logger module wraps the log4cxx library for logging in gnuradio
@@ -37,14 +36,26 @@
 *
 */
 
+#ifndef ENABLE_GR_LOG
+#include "config.h"
+//#define GR_LOG_CONFIG_H
+#endif
+
 #include <gr_core_api.h>
 #include <assert.h>
 #include <iostream>
 
+//#ifndef ENABLE_GR_LOG
+//#define ENABLE_GR_LOG 1
+//#endif
+//#ifndef HAVE_LOG4CPP
+//#define HAVE_LOG4CPP 2
+//#endif
+
 #ifdef ENABLE_GR_LOG
 
 // We have three configurations... first logging to stdout/stderr
-#ifndef HAVE_LOG4CXX
+#ifndef HAVE_LOG4CPP
 //#warning GR logging Enabled and using std::cout
 
 typedef std::string gr_logger_ptr;
@@ -52,53 +63,52 @@ typedef std::string gr_logger_ptr;
 #define GR_LOG_DECLARE_LOGPTR(logger)
 #define GR_LOG_ASSIGN_LOGPTR(logger,name)
 #define GR_CONFIG_LOGGER(config)
-#define GR_CONFIG_AND_WATCH_LOGGER(config)
+#define GR_CONFIG_AND_WATCH_LOGGER(config,period)
 #define GR_LOG_GETLOGGER(logger, name) 
 #define GR_SET_LEVEL(name, level)
 #define GR_LOG_SET_LEVEL(logger, level) 
 #define GR_GET_LEVEL(name, level)
 #define GR_LOG_GET_LEVEL(logger, level)
-#define GR_ADD_CONSOLE_APPENDER(logger,layout)
-#define GR_LOG_ADD_CONSOLE_APPENDER(logger,layout)
-#define GR_ADD_FILE_APPENDER(logger,layout,filename,append)
-#define GR_LOG_ADD_FILE_APPENDER(logger,layout,filename,append)
-#define GR_ADD_ROLLINGFILE_APPENDER(logger,layout,filename,append,bkup_index,filesize)
-#define GR_LOG_ADD_ROLLINGFILE_APPENDER(logger,layout,filename,append,bkup_index,filesize)
+#define GR_ADD_CONSOLE_APPENDER(logger,target,pattern)
+#define GR_LOG_ADD_CONSOLE_APPENDER(logger,,target,pattern)
+#define GR_ADD_FILE_APPENDER(name,filename,append,pattern)
+#define GR_LOG_ADD_FILE_APPENDER(logger,filename,append,pattern)
+#define GR_ADD_ROLLINGFILE_APPENDER(name,filename,filesize,bkup_index,append,mode,pattern)
+#define GR_LOG_ADD_ROLLINGFILE_APPENDER(logger,filename,filesize,bkup_index,append,mode,pattern)
 #define GR_GET_LOGGER_NAMES(names)
 #define GR_RESET_CONFIGURATION()
-#define GR_TRACE(name, msg) std::cout<<"TRACE:"<<msg<<std::endl
 #define GR_DEBUG(name, msg) std::cout<<"DEBUG:"<<msg<<std::endl
 #define GR_INFO(name, msg) std::cout<<"INFO:"<<msg<<std::endl
+#define GR_NOTICE(name, msg) std::cout<<"NOTICE:"<<msg<<std::endl
 #define GR_WARN(name, msg) std::cerr<<"WARN:"<<msg<<std::endl
 #define GR_ERROR(name, msg) std::cerr<<"ERROR:"<<msg<<std::endl
+#define GR_ALERT(name, msg) std::cerr<<"ERROR:"<<msg<<std::endl
+#define GR_CRIT(name, msg) std::cerr<<"ERROR:"<<msg<<std::endl
 #define GR_FATAL(name, msg) std::cerr<<"FATAL:"<<msg<<std::endl
+#define GR_EMERG(name, msg) std::cerr<<"EMERG:"<<msg<<std::endl
 #define GR_ERRORIF(name, cond, msg) if((cond)) std::cerr<<"ERROR:"<<msg<<std::endl
-#define GR_ASSERT(name, cond, msg) std::cerr<<"ERROR:"<<msg<<std::endl; assert(cond)
-#define GR_LOG_SET_LEVEL(logger, level)
-#define GR_LOG_GET_LEVEL(logger, level)
-#define GR_LOG_TRACE(logger, msg) std::cout<<"TRACE:"<<msg<<std::endl
+#define GR_ASSERT(name, cond, msg) if(!(cond)) std::cerr<<"ERROR:"<<msg<<std::endl; assert(cond)
 #define GR_LOG_DEBUG(logger, msg) std::cout<<"DEBUG:"<<msg<<std::endl
 #define GR_LOG_INFO(logger, msg) std::cout<<"INFO:"<<msg<<std::endl
+#define GR_LOG_NOTICE(logger, msg) std::cout<<"NOTICE:"<<msg<<std::endl
 #define GR_LOG_WARN(logger, msg) std::cerr<<"WARN:"<<msg<<std::endl
 #define GR_LOG_ERROR(logger, msg) std::cerr<<"ERROR:"<<msg<<std::endl
+#define GR_LOG_ALERT(logger, msg) std::cerr<<"ALERT:"<<msg<<std::endl
+#define GR_LOG_CRIT(logger, msg) std::cerr<<"CRIT:"<<msg<<std::endl
 #define GR_LOG_FATAL(logger, msg) std::cerr<<"FATAL:"<<msg<<std::endl
+#define GR_LOG_EMERG(logger, msg) std::cerr<<"EMERG:"<<msg<<std::endl
 #define GR_LOG_ERRORIF(logger, cond, msg) if((cond)) std::cerr<<"ERROR:"<<msg<<std::endl
 #define GR_LOG_ASSERT(logger, cond, msg) std::cerr<<"ERROR:"<<msg<<std::endl; assert(cond)
 
-#else /* HAVE_LOG4CXX */
+#else /* HAVE_LOG4CPP */
 // Second configuration...logging to log4cxx
-//#warning GR logging Enabled and using LOG4CXX
-
-#include <log4cxx/logger.h>
-#include <log4cxx/logmanager.h>
-#include <log4cxx/basicconfigurator.h>
-#include <log4cxx/xml/domconfigurator.h>
-#include <log4cxx/propertyconfigurator.h>
-#include <log4cxx/helpers/pool.h>
-#include <log4cxx/fileappender.h>
-#include <log4cxx/rollingfileappender.h>
-#include <log4cxx/consoleappender.h>
-#include <log4cxx/patternlayout.h>
+
+#include <log4cpp/Category.hh>
+#include <log4cpp/PropertyConfigurator.hh>
+#include <log4cpp/FileAppender.hh>
+#include <log4cpp/RollingFileAppender.hh>
+#include <log4cpp/OstreamAppender.hh>
+#include <log4cpp/PatternLayout.hh>
 
 /*!
  * \brief GR_LOG macros
@@ -106,15 +116,17 @@ typedef std::string gr_logger_ptr;
  *
  * These macros wrap the standard LOG4CXX_LEVEL macros.  The availablie macros
  * are:
- *  GR_LOG_TRACE
  *  GR_LOG_DEBUG
  *  GR_LOG_INFO
  *  GR_LOG_WARN
+ *  GR_LOG_TRACE
  *  GR_LOG_ERROR
+ *  GR_LOG_ALERT
+ *  GR_LOG_CRIT
  *  GR_LOG_FATAL
+ *  GR_LOG_EMERG
  */
-
-typedef log4cxx::LoggerPtr gr_logger_ptr;
+typedef log4cpp::Category* gr_logger_ptr;
 
 /* Macros for Programmatic Configuration */
 #define GR_LOG_DECLARE_LOGPTR(logger) \
@@ -130,42 +142,42 @@ typedef log4cxx::LoggerPtr gr_logger_ptr;
   logger_load_config_and_watch(config,period)
 
 #define GR_LOG_GETLOGGER(logger, name) \
-  log4cxx::LoggerPtr logger = gr_logger::getLogger(name);
+  gr_logger_ptr logger = gr_logger::getLogger(name);
 
 #define GR_SET_LEVEL(name, level){ \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
-  logger_set_level(logger, level);}
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  logger_set_level(logger,level);}
 
 #define GR_LOG_SET_LEVEL(logger, level) \
   logger_set_level(logger, level);
 
 #define GR_GET_LEVEL(name, level){ \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
   logger_get_level(logger,level);}
 
 #define GR_LOG_GET_LEVEL(logger, level) \
   logger_get_level(logger,level);
 
-#define GR_ADD_CONSOLE_APPENDER(name,layout,terget){d      \
-  gr_logger_ptr logger = log4cxx::Logger::getLogger(name); \
-  logger_add_console_appender(logger,layout, target);}
+#define GR_ADD_CONSOLE_APPENDER(name,target,pattern){\
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  logger_add_console_appender(logger,target,pattern);}
 
-#define GR_LOG_ADD_CONSOLE_APPENDER(logger,layout,target){      \
-  logger_add_console_appender(logger,layout,target);}
+#define GR_LOG_ADD_CONSOLE_APPENDER(logger,target,pattern){\
+  logger_add_console_appender(logger,target,pattern);}
 
-#define GR_ADD_FILE_APPENDER(name,layout,filename,append){\
-  gr_logger_ptr logger = log4cxx::Logger::getLogger(name); \
-  logger_add_file_appender(logger,layout,filename,append);}
+#define GR_ADD_FILE_APPENDER(name,filename,append,pattern){\
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  logger_add_file_appender(logger,filename,append,pattern);}
 
-#define GR_LOG_ADD_FILE_APPENDER(logger,layout,filename,append){\
-  logger_add_file_appender(logger,layout,filename,append);}
+#define GR_LOG_ADD_FILE_APPENDER(logger,filename,append,pattern){\
+  logger_add_file_appender(logger,filename,append,pattern);}
 
-#define GR_ADD_ROLLINGFILE_APPENDER(name,layout,filename,append,bkup_index,filesize){\
-  gr_logger_ptr logger = log4cxx::Logger::getLogger(name); \
-  logger_add_rollingfile_appender(logger,layout,filename,append,bkup_index,filesize);}
+#define GR_ADD_ROLLINGFILE_APPENDER(name,filename,filesize,bkup_index,append,mode,pattern){\
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  logger_add_rollingfile_appender(logger,filename,filesize,bkup_index,append,mode,pattern);}
 
-#define GR_LOG_ADD_ROLLINGFILE_APPENDER(logger,layout,filename,append,bkup_index,filesize){\
-  logger_add_rollingfile_appender(logger,layout,filename,append,bkup_index,filesize);}
+#define GR_LOG_ADD_ROLLINGFILE_APPENDER(logger,filename,filesize,bkup_index,append,mode,pattern){\
+  logger_add_rollingfile_appender(logger,filename,filesize,bkup_index,append,mode,pattern);}
 
 #define GR_GET_LOGGER_NAMES(names){ \
   logger_get_logger_names(names);}
@@ -174,64 +186,94 @@ typedef log4cxx::LoggerPtr gr_logger_ptr;
   logger_reset_config();}
 
 /* Logger name referenced macros */
-#define GR_TRACE(name, msg) { \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
-  LOG4CXX_TRACE(logger, msg);}
-
 #define GR_DEBUG(name, msg) { \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
-  LOG4CXX_DEBUG(logger, msg);}
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger<< log4cpp::Priority::DEBUG << msg << log4cpp::eol;}
 
 #define GR_INFO(name, msg) { \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
-  LOG4CXX_INFO(logger, msg);}
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger<< log4cpp::Priority::INFO << msg << log4cpp::eol;}
+
+#define GR_NOTICE(name, msg) { \
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger << log4cpp::Priority::NOTICE << msg;}
 
 #define GR_WARN(name, msg) { \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
-  LOG4CXX_WARN(logger, msg);}
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger<< log4cpp::Priority::WARN << msg << log4cpp::eol;}
 
 #define GR_ERROR(name, msg) { \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
-  LOG4CXX_ERROR(logger, msg);}
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger<< log4cpp::Priority::ERROR << msg << log4cpp::eol;}
+
+#define GR_CRIT(name, msg) { \
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger<< log4cpp::Priority::CRIT << msg << log4cpp::eol;}
+
+#define GR_ALERT(name, msg) { \
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger<< log4cpp::Priority::ALERT << msg << log4cpp::eol;}
 
 #define GR_FATAL(name, msg) { \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
-  LOG4CXX_FATAL(logger, msg);}
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger<< log4cpp::Priority::FATAL << msg << log4cpp::eol;}
+
+#define GR_EMERG(name, msg) { \
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger<< log4cpp::Priority::EMERG << msg << log4cpp::eol;}
 
 #define GR_ERRORIF(name, cond, msg) { \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
-  LOG4CXX_ASSERT(logger, !(cond), msg);}
+if((cond)){\
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger<< log4cpp::Priority::ERROR << msg << log4cpp::eol;};\
+};
 
 #define GR_ASSERT(name, cond, msg) { \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
-  LOG4CXX_ASSERT(logger, (cond), msg); \
-  assert((cond));}
+if((!cond)){\
+    gr_logger_ptr logger = gr_logger::getLogger(name);\
+    *logger<< log4cpp::Priority::EMERG << msg << log4cpp::eol;};\
+    assert(0);\
+};
 
 /* LoggerPtr Referenced Macros */
-#define GR_LOG_TRACE(logger, msg) { \
-  LOG4CXX_TRACE(logger, msg);}
-
 #define GR_LOG_DEBUG(logger, msg) { \
-  LOG4CXX_DEBUG(logger, msg);}
+  *logger << log4cpp::Priority::DEBUG << msg << log4cpp::eol;}
 
 #define GR_LOG_INFO(logger, msg) { \
-  LOG4CXX_INFO(logger, msg);}
+  *logger << log4cpp::Priority::INFO << msg << log4cpp::eol;}
+
+#define GR_LOG_NOTICE(logger, msg) { \
+  *logger << log4cpp::Priority::NOTICE << msg << log4cpp::eol;}
 
 #define GR_LOG_WARN(logger, msg) { \
-  LOG4CXX_WARN(logger, msg);}
+  *logger << log4cpp::Priority::WARN << msg << log4cpp::eol;}
 
 #define GR_LOG_ERROR(logger, msg) { \
-  LOG4CXX_ERROR(logger, msg);}
+  *logger << log4cpp::Priority::ERROR << msg << log4cpp::eol;}
+
+#define GR_LOG_CRIT(logger, msg) { \
+  *logger << log4cpp::Priority::CRIT << msg << log4cpp::eol;}
+
+#define GR_LOG_ALERT(logger, msg) { \
+  *logger << log4cpp::Priority::ALERT << msg << log4cpp::eol;}
 
 #define GR_LOG_FATAL(logger, msg) { \
-  LOG4CXX_FATAL(logger, msg);}
+  *logger << log4cpp::Priority::FATAL << msg << log4cpp::eol;}
+
+#define GR_LOG_EMERG(logger, msg) { \
+  *logger << log4cpp::Priority::EMERG << msg << log4cpp::eol;}
 
 #define GR_LOG_ERRORIF(logger,cond, msg) { \
-  LOG4CXX_ASSERT(logger, !(cond), msg);}
+if((!cond)){\
+    *logger<< log4cpp::Priority::ERROR << msg << log4cpp::eol;};\
+    assert(0);\
+};
 
 #define GR_LOG_ASSERT(logger, cond, msg) { \
-  LOG4CXX_ASSERT(logger, (cond), msg); \
-  assert((cond));}
+if((!cond)){\
+    *logger<< log4cpp::Priority::EMERG << msg << log4cpp::eol;};\
+    assert(0);\
+};
 
 /*!
  * \brief Load logger's configuration file.
@@ -256,14 +298,16 @@ GR_CORE_API void logger_reset_config(void);
  * Sets the level of the logger. This takes a string that is
  * translated to the standard levels and can be (case insensitive):
  *
- * \li off
- * \li all
- * \li trace
+ * \li off , notset
  * \li debug
  * \li info
+ * \li notice
  * \li warn
  * \li error
+ * \li crit
+ * \li alert
  * \li fatal
+ * \li emerg
  *
  * \param logger the logger to set the level of.
  * \param level  string to set the level to.
@@ -273,22 +317,24 @@ GR_CORE_API void logger_set_level(gr_logger_ptr logger, const std::string &level
 /*!
  * \brief Set the logger's output level.
  *
- * Sets the level of the logger. This takes the actual Log4cxx::Level
+ * Sets the level of the logger. This takes the actual Log4cpp::Priority
  * data type, which can be:
  *
- * \li log4cxx::Level::getOff()
- * \li log4cxx::Level::getAll()
- * \li log4cxx::Level::getTrace()
- * \li log4cxx::Level::getDebug()
- * \li log4cxx::Level::getInfo()
- * \li log4cxx::Level::getWarn()
- * \li log4cxx::Level::getError()
- * \li log4cxx::Level::getFatal()
+ * \li log4cpp::Priority::NOTSET
+ * \li log4cpp::Priority::DEBUG
+ * \li log4cpp::Priority::INFO
+ * \li log4cpp::Priority::NOTICE
+ * \li log4cpp::Priority::WARN
+ * \li log4cpp::Priority::ERROR
+ * \li log4cpp::Priority::CRIT
+ * \li log4cpp::Priority::ALERT
+ * \li log4cpp::Priority::FATAL
+ * \li log4cpp::Priority::EMERG
  *
  * \param logger the logger to set the level of.
- * \param level  new logger level of type Log4cxx::Level
+ * \param level  new logger level of type Log4cpp::Priority
  */
-GR_CORE_API void logger_set_level(gr_logger_ptr logger, log4cxx::LevelPtr level);
+void logger_set_level(gr_logger_ptr logger, log4cpp::Priority::Value level);
 
 
 /*!
@@ -297,14 +343,16 @@ GR_CORE_API void logger_set_level(gr_logger_ptr logger, log4cxx::LevelPtr level)
  * Gets the level of the logger. This returns a string that
  * corresponds to the standard levels and can be (case insensitive):
  *
- * \li off
- * \li all
- * \li trace
+ * \li notset
  * \li debug
  * \li info
+ * \li notice
  * \li warn
  * \li error
+ * \li crit
+ * \li alert
  * \li fatal
+ * \li emerg
  *
  * \param logger the logger to get the level of.
  * \param level  string to get the level into.
@@ -317,29 +365,28 @@ GR_CORE_API void logger_get_level(gr_logger_ptr logger, std::string &level);
  * Gets the level of the logger. This returns the actual Log4cxx::Level
  * data type, which can be:
  *
- * \li log4cxx::Level::getOff()
- * \li log4cxx::Level::getAll()
- * \li log4cxx::Level::getTrace()
- * \li log4cxx::Level::getDebug()
- * \li log4cxx::Level::getInfo()
- * \li log4cxx::Level::getWarn()
- * \li log4cxx::Level::getError()
- * \li log4cxx::Level::getFatal()
+ * \li log4cpp::Priority::NOTSET
+ * \li log4cpp::Priority::DEBUG
+ * \li log4cpp::Priority::INFO
+ * \li log4cpp::Priority::NOTICE
+ * \li log4cpp::Priority::WARN
+ * \li log4cpp::Priority::ERROR
+ * \li log4cpp::Priority::CRIT
+ * \li log4cpp::Priority::ALERT
+ * \li log4cpp::Priority::FATAL
+ * \li log4cpp::Priority::EMERG
  *
  * \param logger the logger to get the level of.
+ * \param level of the logger.
  */
-GR_CORE_API void logger_get_level(gr_logger_ptr logger, log4cxx::LevelPtr level);
-
+GR_CORE_API void logger_get_level(gr_logger_ptr logger, log4cpp::Priority::Value &level);
 
-GR_CORE_API void logger_add_console_appender(gr_logger_ptr logger, std::string layout,
-                                             std::string target);
+GR_CORE_API void logger_add_console_appender(gr_logger_ptr logger,std::string target,std::string pattern);
 
-GR_CORE_API void logger_add_file_appender(gr_logger_ptr logger, std::string layout,
-                                          std::string filename, bool append);
+GR_CORE_API void logger_add_file_appender(gr_logger_ptr logger,std::string filename,bool append,std::string pattern);
 
-GR_CORE_API void logger_add_rollingfile_appender(gr_logger_ptr logger, std::string layout,
-                                                 std::string filename, bool append,
-                                                 int bkup_index, std::string filesize);
+GR_CORE_API void logger_add_rollingfile_appender(gr_logger_ptr logger,std::string filename,
+                    size_t filesize,int bkup_index,bool append,mode_t mode,std::string pattern);
 
 GR_CORE_API void logger_get_logger_names(std::vector<std::string>& names);
 
@@ -366,25 +413,22 @@ class gr_logger
   gr_logger(std::string config_filename, int watchPeriodSec)
   {
     // Load configuration file
-    if(config_filename.find(".xml")!=std::string::npos) {
-      log4cxx::xml::DOMConfigurator::configureAndWatch(config_filename, watchPeriodSec);
-    }
-    else {
-      log4cxx::PropertyConfigurator::configureAndWatch(config_filename, watchPeriodSec);
-    }
+    logger_load_config_and_watch(config_filename,watchPeriodSec);
+
   };
 
-  static log4cxx::LoggerPtr getLogger(std::string name)
+  static gr_logger_ptr getLogger(std::string name)
   {
-    if(log4cxx::LogManager::exists(name)) {
-      log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name);
-      return logger;
-    }
-    else {
-      log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name);
-      logger->setLevel(log4cxx::Level::getOff());
-      return logger;
-    };
+      if(log4cpp::Category::exists(name)){
+        gr_logger_ptr logger = &log4cpp::Category::getInstance(name);
+        return logger;
+      }
+      else
+      {
+        gr_logger_ptr logger = &log4cpp::Category::getInstance(name);
+        logger->setPriority(log4cpp::Priority::NOTSET);
+        return logger;
+      };
   };
 
   // Wrappers for logging macros
@@ -394,24 +438,33 @@ class gr_logger
   /*! \brief inline function, wrapper to get the logger level */
   void get_level(std::string name,std::string &level){GR_GET_LEVEL(name,level);}
 
-  /*! \brief inline function, wrapper for LOG4CXX_TRACE for TRACE message */
-  void trace(std::string name,std::string msg){GR_TRACE(name,msg);};
-
-  /*! \brief inline function, wrapper for LOG4CXX_DEBUG for DEBUG message */
+  /*! \brief inline function, wrapper for DEBUG message */
   void debug(std::string name,std::string msg){GR_DEBUG(name,msg);};
 
-  /*! \brief inline function, wrapper for LOG4CXX_INFO for INFO message */
+  /*! \brief inline function, wrapper for INFO message */
   void info(std::string name,std::string msg){GR_INFO(name,msg);};
 
-  /*! \brief inline function, wrapper for LOG4CXX_WARN for WARN message */
+  /*! \brief inline function, wrapper for NOTICE message */
+  void notice(std::string name,std::string msg){GR_NOTICE(name,msg);};
+
+  /*! \brief inline function, wrapper for WARN message */
   void warn(std::string name,std::string msg){GR_WARN(name,msg);};
 
-  /*! \brief inline function, wrapper for LOG4CXX_ERROR for ERROR message */
+  /*! \brief inline function, wrapper for ERROR message */
   void error(std::string name,std::string msg){GR_ERROR(name,msg);};
 
-  /*! \brief inline function, wrapper for LOG4CXX_FATAL for FATAL message */
+  /*! \brief inline function, wrapper for CRIT message */
+  void crit(std::string name,std::string msg){GR_CRIT(name,msg);};
+
+  /*! \brief inline function, wrapper for ALERT message */
+  void alert(std::string name,std::string msg){GR_ALERT(name,msg);};
+
+  /*! \brief inline function, wrapper for FATAL message */
   void fatal(std::string name,std::string msg){GR_FATAL(name,msg);};
 
+  /*! \brief inline function, wrapper for EMERG message */
+  void emerg(std::string name,std::string msg){GR_EMERG(name,msg);};
+
   /*! \brief inline function, wrapper for LOG4CXX_ASSERT for conditional ERROR message */
   void errorIF(std::string name,bool cond,std::string msg){GR_ERRORIF(name,cond,msg);};
 
@@ -420,38 +473,47 @@ class gr_logger
 
   // Wrappers for Logger Pointer referenced functions
   /*! \brief inline function, wrapper to set the logger level */
-  void set_log_level(log4cxx::LoggerPtr logger,std::string level){GR_LOG_SET_LEVEL(logger,level);}
+  void set_log_level(gr_logger_ptr logger,std::string level){GR_LOG_SET_LEVEL(logger,level);}
 
   /*! \brief inline function, wrapper to get the logger level */
-  void get_log_level(log4cxx::LoggerPtr logger,std::string &level){GR_LOG_GET_LEVEL(logger,level);}
-
-  /*! \brief inline function, wrapper for LOG4CXX_TRACE for TRACE message */
-  void log_trace(log4cxx::LoggerPtr logger,std::string msg){GR_LOG_TRACE(logger,msg);};
+  void get_log_level(gr_logger_ptr logger,std::string &level){GR_LOG_GET_LEVEL(logger,level);}
 
   /*! \brief inline function, wrapper for LOG4CXX_DEBUG for DEBUG message */
-  void log_debug(log4cxx::LoggerPtr logger,std::string msg){GR_LOG_DEBUG(logger,msg);};
+  void log_debug(gr_logger_ptr logger,std::string msg){GR_LOG_DEBUG(logger,msg);};
 
   /*! \brief inline function, wrapper for LOG4CXX_INFO for INFO message */
-  void log_info(log4cxx::LoggerPtr logger,std::string msg){GR_LOG_INFO(logger,msg);};
+  void log_info(gr_logger_ptr logger,std::string msg){GR_LOG_INFO(logger,msg);};
+
+  /*! \brief inline function, wrapper for NOTICE message */
+  void log_notice(gr_logger_ptr logger,std::string msg){GR_LOG_NOTICE(logger,msg);};
 
   /*! \brief inline function, wrapper for LOG4CXX_WARN for WARN message */
-  void log_warn(log4cxx::LoggerPtr logger,std::string msg){GR_LOG_WARN(logger,msg);};
+  void log_warn(gr_logger_ptr logger,std::string msg){GR_LOG_WARN(logger,msg);};
 
   /*! \brief inline function, wrapper for LOG4CXX_ERROR for ERROR message */
-  void log_error(log4cxx::LoggerPtr logger,std::string msg){GR_LOG_ERROR(logger,msg);};
+  void log_error(gr_logger_ptr logger,std::string msg){GR_LOG_ERROR(logger,msg);};
 
-  /*! \brief inline function, wrapper for LOG4CXX_FATAL for FATAL message */
-  void log_fatal(log4cxx::LoggerPtr logger,std::string msg){GR_LOG_FATAL(logger,msg);};
+  /*! \brief inline function, wrapper for NOTICE message */
+  void log_crit(gr_logger_ptr logger,std::string msg){GR_LOG_CRIT(logger,msg);};
+
+  /*! \brief inline function, wrapper for ALERT message */
+  void log_alert(gr_logger_ptr logger,std::string msg){GR_LOG_ALERT(logger,msg);};
+
+  /*! \brief inline function, wrapper for FATAL message */
+  void log_fatal(gr_logger_ptr logger,std::string msg){GR_LOG_FATAL(logger,msg);};
+
+  /*! \brief inline function, wrapper for EMERG message */
+  void log_emerg(gr_logger_ptr logger,std::string msg){GR_LOG_EMERG(logger,msg);};
 
   /*! \brief inline function, wrapper for LOG4CXX_ASSERT for conditional ERROR message */
-  void log_errorIF(log4cxx::LoggerPtr logger,bool cond,std::string msg){GR_LOG_ERRORIF(logger,cond,msg);};
+  void log_errorIF(gr_logger_ptr logger,bool cond,std::string msg){GR_LOG_ERRORIF(logger,cond,msg);};
 
   /*! \brief inline function, wrapper for LOG4CXX_ASSERT for conditional ERROR message */
-  void log_assert(log4cxx::LoggerPtr logger,bool cond,std::string msg){GR_LOG_ASSERT(logger,cond,msg);};
+  void log_assert(gr_logger_ptr logger,bool cond,std::string msg){GR_LOG_ASSERT(logger,cond,msg);};
 };
 
 
-#endif /* HAVE_LOG4CXX */
+#endif /* HAVE_LOG4CPP */
 
 // If Logger disable do nothing
 #else /* ENABLE_GR_LOG */
@@ -461,36 +523,40 @@ typedef void* gr_logger_ptr;
 #define GR_LOG_DECLARE_LOGPTR(logger)
 #define GR_LOG_ASSIGN_LOGPTR(logger,name)
 #define GR_CONFIG_LOGGER(config)
-#define GR_CONFIG_AND_WATCH_LOGGER(config)
+#define GR_CONFIG_AND_WATCH_LOGGER(config,period)
 #define GR_LOG_GETLOGGER(logger, name) 
 #define GR_SET_LEVEL(name, level)
 #define GR_LOG_SET_LEVEL(logger, level) 
 #define GR_GET_LEVEL(name, level)
 #define GR_LOG_GET_LEVEL(logger, level)
-#define GR_ADD_CONSOLE_APPENDER(logger,layout)
-#define GR_LOG_ADD_CONSOLE_APPENDER(logger,layout)
-#define GR_ADD_FILE_APPENDER(logger,layout,filename,append)
-#define GR_LOG_ADD_FILE_APPENDER(logger,layout)
-#define GR_ADD_ROLLINGFILE_APPENDER(logger,layout,filename,append,bkup_index,filesize)
-#define GR_LOG_ADD_ROLLINGFILE_APPENDER(logger,layout)
+#define GR_ADD_CONSOLE_APPENDER(logger,target,pattern)
+#define GR_LOG_ADD_CONSOLE_APPENDER(logger,,target,pattern)
+#define GR_ADD_FILE_APPENDER(name,filename,append,pattern)
+#define GR_LOG_ADD_FILE_APPENDER(logger,filename,append,pattern)
+#define GR_ADD_ROLLINGFILE_APPENDER(name,filename,filesize,bkup_index,append,mode,pattern)
+#define GR_LOG_ADD_ROLLINGFILE_APPENDER(logger,filename,filesize,bkup_index,append,mode,pattern)
 #define GR_GET_LOGGER_NAMES(names)
 #define GR_RESET_CONFIGURATION()
-#define GR_TRACE(name, msg)
 #define GR_DEBUG(name, msg)
 #define GR_INFO(name, msg)
-#define GR_WARN(name, msg) 
-#define GR_ERROR(name, msg) 
-#define GR_FATAL(name, msg) 
+#define GR_NOTICE(name, msg)
+#define GR_WARN(name, msg)
+#define GR_ERROR(name, msg)
+#define GR_ALERT(name, msg)
+#define GR_CRIT(name, msg)
+#define GR_FATAL(name, msg)
+#define GR_EMERG(name, msg)
 #define GR_ERRORIF(name, cond, msg)
 #define GR_ASSERT(name, cond, msg)
-#define GR_LOG_SET_LEVEL(logger, level)
-#define GR_LOG_GET_LEVEL(logger, level)
-#define GR_LOG_TRACE(logger, msg)
 #define GR_LOG_DEBUG(logger, msg)
-#define GR_LOG_INFO(logger, msg) 
-#define GR_LOG_WARN(logger, msg) 
-#define GR_LOG_ERROR(logger, msg) 
-#define GR_LOG_FATAL(logger, msg) 
+#define GR_LOG_INFO(logger, msg)
+#define GR_LOG_NOTICE(logger, msg)
+#define GR_LOG_WARN(logger, msg)
+#define GR_LOG_ERROR(logger, msg)
+#define GR_LOG_ALERT(logger, msg)
+#define GR_LOG_CRIT(logger, msg)
+#define GR_LOG_FATAL(logger, msg)
+#define GR_LOG_EMERG(logger, msg)
 #define GR_LOG_ERRORIF(logger, cond, msg)
 #define GR_LOG_ASSERT(logger, cond, msg)
 
diff --git a/gnuradio-core/src/lib/runtime/gr_logger.i b/gnuradio-core/src/lib/runtime/gr_logger.i
index 1eedf3d60d..e0fe120205 100644
--- a/gnuradio-core/src/lib/runtime/gr_logger.i
+++ b/gnuradio-core/src/lib/runtime/gr_logger.i
@@ -40,13 +40,12 @@
 //-----------------------------------
 
 #ifdef ENABLE_GR_LOG
-#ifdef HAVE_LOG4CXX
+#ifdef HAVE_LOG4CPP
 
 %{
 // The .h files
 #include <gr_logger.h>
-#include <log4cxx/logger.h>
-#include <log4cxx/logmanager.h>
+#include <log4cpp/Category.hh>
 %}
 
 namespace log4cxx{
@@ -69,27 +68,41 @@ public:
   gr_logger(std::string config_filename,int watchPeriodSec);
   void set_level(std::string name,std::string level);
   void get_level(std::string name,std::string &level);
-  void trace(std::string name,std::string msg);
+  void add_console_appender(std::string name,std::string target,std::string pattern);
+  void add_file_appender(std::string name,std::string filename,bool append,std::string patter);
+  void add_rollingfile_appender(std::string name,std::string filename,size_t filesize,int bkup_indx,bool append,mode_t mode,std::string pattern);
+
+  void notice(std::string name,std::string msg);
   void debug(std::string name,std::string msg);
   void info(std::string name,std::string msg);
   void warn(std::string name,std::string msg);
   void error(std::string name,std::string msg);
-  void fatal(std::string name,std::string msg);
+  void emerg(std::string name,std::string msg);
+  void crit(std::string name,std::string msg);
   void errorIF(std::string name,bool cond,std::string msg);
   void gr_assert(std::string name,bool cond,std::string msg);
 
-  static log4cxx::LoggerPtr getLogger(std::string name);
-
-  void set_log_level(log4cxx::LoggerPtr logger,std::string level);
-  void get_log_level(log4cxx::LoggerPtr logger,std::string &level);
-  void log_trace(log4cxx::LoggerPtr logger,std::string msg);
-  void log_debug(log4cxx::LoggerPtr logger,std::string msg);
-  void log_info(log4cxx::LoggerPtr logger,std::string msg);
-  void log_warn(log4cxx::LoggerPtr logger,std::string msg);
-  void log_error(log4cxx::LoggerPtr logger,std::string msg);
-  void log_fatal(log4cxx::LoggerPtr logger,std::string msg);
-  void log_errorIF(log4cxx::LoggerPtr logger,bool cond,std::string msg);
-  void log_assert(log4cxx::LoggerPtr logger,bool cond,std::string msg);
+  static gr_logger_ptr getLogger(std::string name);
+
+  void log_set_level(gr_logger_ptr logger,std::string level);
+  void log_get_level(gr_logger_ptr logger,std::string &level);
+  void log_add_console_appender(gr_logger_ptr logger,std::string target,std::string pattern);
+  void log_add_file_appender(gr_logger_ptr logger,std::string filename,bool append,std::string pattern);
+  void log_add_rollingfile_appender(gr_logger_ptr logger,std::string filename,size_t filesize,int bkup_index,bool append,mode_t mode,std::string pattern);
+
+  void log_notice(gr_logger_ptr logger,std::string msg);
+  void log_debug(gr_logger_ptr logger,std::string msg);
+  void log_info(gr_logger_ptr logger,std::string msg);
+  void log_warn(gr_logger_ptr logger,std::string msg);
+  void log_error(gr_logger_ptr logger,std::string msg);
+  void log_crit(gr_logger_ptr logger,std::string msg);
+  void log_emerg(gr_logger_ptr logger,std::string msg);
+  void log_errorIF(gr_logger_ptr logger,bool cond,std::string msg);
+  void log_assert(gr_logger_ptr logger,bool cond,std::string msg);
+
+  void get_logger_names(std::vector<std::string>& names);
+  void reset_configuration();
+
 };
 
 #endif /* HAVE_LOG4CXX */
diff --git a/gnuradio-core/src/lib/runtime/qa_gr_logger.cc b/gnuradio-core/src/lib/runtime/qa_gr_logger.cc
index 3d21c1f305..e409c6aea7 100644
--- a/gnuradio-core/src/lib/runtime/qa_gr_logger.cc
+++ b/gnuradio-core/src/lib/runtime/qa_gr_logger.cc
@@ -38,8 +38,10 @@ qa_gr_logger::t1()
 #ifdef ENABLE_GR_LOG
   // This doesn't really test anything, more just
   // making sure nothing's gone horribly wrong.
-  GR_LOG_GETLOGGER(LOG,"errLoggerRoot");
-  GR_LOG_TRACE(LOG,"test from c++ 1");
+
+  GR_LOG_GETLOGGER(LOG,"main");
+  GR_ADD_CONSOLE_APPENDER("main","cout","%d{%H:%M:%S} : %m%n");
+  GR_LOG_NOTICE(LOG,"test from c++ 1");
   GR_LOG_DEBUG(LOG,"test from c++ 1");
   GR_LOG_INFO(LOG,"test from c++ 1");
   GR_LOG_WARN(LOG,"test from c++ 1");
diff --git a/gr-howto-write-a-block/cmake/Modules/FindLog4cxx.cmake b/gr-howto-write-a-block/cmake/Modules/FindLog4cxx.cmake
deleted file mode 100644
index b1e4f6f1f7..0000000000
--- a/gr-howto-write-a-block/cmake/Modules/FindLog4cxx.cmake
+++ /dev/null
@@ -1,28 +0,0 @@
-#   CMake module to find LOG4CXX library
-
-INCLUDE(FindPkgConfig)
-PKG_CHECK_MODULES(PC_LOG4CXX liblog4cxx)
-
-FIND_PATH(
-    LOG4CXX_INCLUDE_DIRS
-    NAMES log4cxx/log4cxx.h
-    HINTS $ENV{LOG4CXX_DIR}/include
-        ${PC_LOG4CXX_INCLUDE_DIRS}
-    PATHS /usr/local/include
-          /usr/include
-)
-
-FIND_LIBRARY(
-    LOG4CXX_LIBRARIES
-    NAMES log4cxx
-    HINTS $ENV{LOG4CXX_DIR}/lib
-        ${PC_LOG4CXX_LIBRARIES}
-    PATHS /usr/local/lib
-          /usr/local/lib64
-          /usr/lib
-          /usr/lib64
-)
-
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(LOG4CXX DEFAULT_MSG LOG4CXX_LIBRARIES LOG4CXX_INCLUDE_DIRS)
-MARK_AS_ADVANCED(LOG4CXX_LIBRARIES LOG4CXX_INCLUDE_DIRS)
author	Tom Rondeau <trondeau@vt.edu>	2013-03-13 15:35:51 -0400
committer	Tom Rondeau <trondeau@vt.edu>	2013-03-13 15:35:51 -0400
commit	890f2882d2210b1d4e64f0bbffc42ccc716cfd97 (patch)
tree	3f85469b8ce65d0bc691e105257ccad32d603535
parent	4e81a23e6c950e38fe920fbea0dffe551ec35a2f (diff)
parent	afae86a4354c2c82030def9c90b8fe74dcbf4f9d (diff)