Initial merge for ICE-2400:

- added new Logger admin facet (C++ only)
- this Logger facet allows remote application to retrieve the Ice log file, including recently logged events, with optional filters
- this logger facet also allows remote applications to attach RemoteLogger objects to get new logs as they are generated
- added new "show log" feature to icegridadmin, to retrieve Ice log file of Ice server (not yet implemented for IceGrid registry and node)

34 files changed, 2001 insertions, 307 deletions

diff --git a/cpp/demo/Ice/MFC/server/LogI.cpp b/cpp/demo/Ice/MFC/server/LogI.cpp
index 54cc5ae556f..bcef1cc1ff7 100644
--- a/cpp/demo/Ice/MFC/server/LogI.cpp
+++ b/cpp/demo/Ice/MFC/server/LogI.cpp
@@ -60,6 +60,12 @@ LogI::error(const string& msg)
     message("error: " + msg);
 }
 
+string
+LogI::getPrefix()
+{
+    return "";
+}
+
 Ice::LoggerPtr
 LogI::cloneWithPrefix(const string&)
 {
diff --git a/cpp/demo/Ice/MFC/server/LogI.h b/cpp/demo/Ice/MFC/server/LogI.h
index 796eac3c093..8c6f76ea1a3 100644
--- a/cpp/demo/Ice/MFC/server/LogI.h
+++ b/cpp/demo/Ice/MFC/server/LogI.h
@@ -20,6 +20,7 @@ public:
     virtual void trace(const std::string&, const std::string&);
     virtual void warning(const std::string&);
     virtual void error(const std::string&);
+    virtual std::string getPrefix();
     virtual Ice::LoggerPtr cloneWithPrefix(const std::string&);
 
     void message(const std::string&);
diff --git a/cpp/demo/Ice/plugin/LoggerPluginI.cpp b/cpp/demo/Ice/plugin/LoggerPluginI.cpp
index 5324b6f380d..5dc2d8c9798 100644
--- a/cpp/demo/Ice/plugin/LoggerPluginI.cpp
+++ b/cpp/demo/Ice/plugin/LoggerPluginI.cpp
@@ -42,14 +42,20 @@ public:
         cout << "ERROR: " << message << endl;
     }
 
+    virtual string
+    getPrefix()
+    {
+        return "";
+    }
+
     virtual Ice::LoggerPtr
     cloneWithPrefix(const std::string&)
     {
-        return new LoggerI();   
+        return new LoggerI;   
     }
 };
 
-};
+}
 
 extern "C"
 {
diff --git a/cpp/include/Ice/Ice.h b/cpp/include/Ice/Ice.h
index 627425777c6..ec15a2258e7 100644
--- a/cpp/include/Ice/Ice.h
+++ b/cpp/include/Ice/Ice.h
@@ -18,6 +18,7 @@
 #include <Ice/Properties.h>
 #include <Ice/Logger.h>
 #include <Ice/LoggerUtil.h>
+#include <Ice/RemoteLogger.h>
 #include <Ice/Communicator.h>
 #include <Ice/CommunicatorAsync.h>
 #include <Ice/ObjectFactory.h>
diff --git a/cpp/src/Ice/.depend.mak b/cpp/src/Ice/.depend.mak
index d9e05938186..088e886c25a 100644
--- a/cpp/src/Ice/.depend.mak
+++ b/cpp/src/Ice/.depend.mak
@@ -148,3 +148,12 @@ $(HDIR)\ServantLocatorF.h ServantLocatorF.cpp: "$(slicedir)/Ice/ServantLocatorF.
 $(HDIR)\ServantLocator.h ServantLocator.cpp: "$(slicedir)/Ice/ServantLocator.ice" "$(slicedir)/Ice/ObjectAdapterF.ice" "$(slicedir)/Ice/Current.ice" "$(slicedir)/Ice/ConnectionF.ice" "$(slicedir)/Ice/Identity.ice" "$(slicedir)/Ice/Version.ice" "$(SLICE2CPP)" "$(SLICEPARSERLIB)"
 $(HDIR)\SliceChecksumDict.h SliceChecksumDict.cpp: "$(slicedir)/Ice/SliceChecksumDict.ice" "$(SLICE2CPP)" "$(SLICEPARSERLIB)"
 $(HDIR)\Version.h Version.cpp: "$(slicedir)/Ice/Version.ice" "$(SLICE2CPP)" "$(SLICEPARSERLIB)"
+
+RemoteLogger$(OBJEXT): RemoteLogger.cpp "$(includedir)/Ice/RemoteLogger.h" 
+$(HDIR)\RemoteLogger.h RemoteLogger.cpp: "$(slicedir)/Ice/RemoteLogger.ice" "$(SLICE2CPP)" "$(SLICEPARSERLIB)"
+
+
+
+
+
+
diff --git a/cpp/src/Ice/CommunicatorI.cpp b/cpp/src/Ice/CommunicatorI.cpp
index 820d5fee400..7f225c425e0 100644
--- a/cpp/src/Ice/CommunicatorI.cpp
+++ b/cpp/src/Ice/CommunicatorI.cpp
@@ -361,7 +361,7 @@ Ice::CommunicatorI::finishSetup(int& argc, char* argv[])
 {
     try
     {
-        _instance->finishSetup(argc, argv);
+        _instance->finishSetup(argc, argv, this);
     }
     catch(...)
     {
diff --git a/cpp/src/Ice/Instance.cpp b/cpp/src/Ice/Instance.cpp
index 8bf1162ce8d..52c29e7d3b9 100644
--- a/cpp/src/Ice/Instance.cpp
+++ b/cpp/src/Ice/Instance.cpp
@@ -39,7 +39,7 @@
 #include <Ice/MetricsAdminI.h>
 #include <Ice/InstrumentationI.h>
 #include <Ice/ProtocolInstance.h>
-
+#include <Ice/LoggerAdminI.h>
 #include <IceUtil/UUID.h>
 #include <IceUtil/Mutex.h>
 #include <IceUtil/MutexPtrLock.h>
@@ -1207,44 +1207,6 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi
             _wstringConverter = new IceUtil::UnicodeWstringConverter();
         }
 
-        //
-        // Add Process and Properties facets
-        //
-
-        StringSeq facetSeq = _initData.properties->getPropertyAsList("Ice.Admin.Facets");
-
-        if(!facetSeq.empty())
-        {
-            _adminFacetFilter.insert(facetSeq.begin(), facetSeq.end());
-        }
-
-        _adminFacets.insert(FacetMap::value_type("Process", new ProcessI(communicator)));
-
-        PropertiesAdminIPtr props = new PropertiesAdminI("Properties", _initData.properties, _initData.logger);
-        _adminFacets.insert(FacetMap::value_type("Properties",props));
-
-        _metricsAdmin = new MetricsAdminI(_initData.properties, _initData.logger);
-        _adminFacets.insert(FacetMap::value_type("Metrics", _metricsAdmin));
-
-        //
-        // Setup the communicator observer only if the user didn't already set an
-        // Ice observer resolver and if the admininistrative endpoints are set.
-        //
-        if((_adminFacetFilter.empty() || _adminFacetFilter.find("Metrics") != _adminFacetFilter.end()) &&
-           _initData.properties->getProperty("Ice.Admin.Endpoints") != "")
-        {
-            _observer = new CommunicatorObserverI(_metricsAdmin, _initData.observer);
-
-            //
-            // Make sure the admin plugin receives property updates.
-            //
-            props->addUpdateCallback(_metricsAdmin);
-        }
-        else
-        {
-            _observer = _initData.observer;
-        }
-
         __setNoDelete(false);
     }
     catch(...)
@@ -1303,7 +1265,7 @@ IceInternal::Instance::~Instance()
 }
 
 void
-IceInternal::Instance::finishSetup(int& argc, char* argv[])
+IceInternal::Instance::finishSetup(int& argc, char* argv[], const Ice::CommunicatorPtr& communicator)
 {
     //
     // Load plug-ins.
@@ -1314,6 +1276,70 @@ IceInternal::Instance::finishSetup(int& argc, char* argv[])
     pluginManagerImpl->loadPlugins(argc, argv);
 
     //
+    // Add admin facets
+    // Note that any logger-dependent admin facet must be created after we load all plugins,
+    // since one of these plugins can be a Logger plugin that sets a new logger during loading
+    //
+
+    StringSeq facetSeq = _initData.properties->getPropertyAsList("Ice.Admin.Facets");
+    
+    if(!facetSeq.empty())
+    {
+        _adminFacetFilter.insert(facetSeq.begin(), facetSeq.end());
+    }
+    _adminFacets.insert(FacetMap::value_type("Process", new ProcessI(communicator)));
+        
+    string loggerFacetName = _initData.properties->getPropertyWithDefault("Ice.Admin.Logger", "Logger");
+    
+    bool insertLoggerFacet = 
+        (_adminFacetFilter.empty() || _adminFacetFilter.find(loggerFacetName) != _adminFacetFilter.end()) &&
+        _initData.properties->getProperty("Ice.Admin.Endpoints") != "";
+    
+    if(loggerFacetName != "Logger" || insertLoggerFacet)
+    {
+        //
+        // Set up a new Logger
+        // 
+        Ice::LoggerAdminLoggerPtr logger = createLoggerAdminLogger(loggerFacetName,
+                                                                   _initData.properties, 
+                                                                   _initData.logger);
+        setLogger(logger);
+                                                                  
+        if(insertLoggerFacet)
+        {
+            logger->addAdminFacet(communicator);
+        }
+        //
+        // Else, this new logger & facet is useful for "slave" communicators like IceBox services.
+        //
+    }
+    
+    PropertiesAdminIPtr props = new PropertiesAdminI("Properties", _initData.properties, _initData.logger);
+    _adminFacets.insert(FacetMap::value_type("Properties", props));
+    
+    _metricsAdmin = new MetricsAdminI(_initData.properties, _initData.logger);
+    _adminFacets.insert(FacetMap::value_type("Metrics", _metricsAdmin));
+    
+    //
+    // Setup the communicator observer only if the user didn't already set an
+    // Ice observer resolver and if the admininistrative endpoints are set.
+    //
+    if((_adminFacetFilter.empty() || _adminFacetFilter.find("Metrics") != _adminFacetFilter.end()) &&
+       _initData.properties->getProperty("Ice.Admin.Endpoints") != "")
+    {
+        _observer = new CommunicatorObserverI(_metricsAdmin, _initData.observer);
+        
+        //
+        // Make sure the admin plugin receives property updates.
+        //
+        props->addUpdateCallback(_metricsAdmin);
+    }
+    else
+    {
+        _observer = _initData.observer;
+    }
+
+    //
     // Set observer updater
     //
     if(_observer)
@@ -1491,6 +1517,15 @@ IceInternal::Instance::destroy()
             _observer->setObserverUpdater(0); // Break cyclic reference count.
         }
     }
+    
+    Ice::LoggerAdminLoggerPtr logger = Ice::LoggerAdminLoggerPtr::dynamicCast(_initData.logger);
+    if(logger)
+    {
+        //
+        // This only disables the remote logging; we don't set or reset _initData.logger
+        //
+        logger->destroy();
+    }
 
     ThreadPoolPtr serverThreadPool;
     ThreadPoolPtr clientThreadPool;
diff --git a/cpp/src/Ice/Instance.h b/cpp/src/Ice/Instance.h
index 9373b960fda..e9806b307a6 100644
--- a/cpp/src/Ice/Instance.h
+++ b/cpp/src/Ice/Instance.h
@@ -120,7 +120,7 @@ private:
 
     Instance(const Ice::CommunicatorPtr&, const Ice::InitializationData&);
     virtual ~Instance();
-    void finishSetup(int&, char*[]);
+    void finishSetup(int&, char*[], const Ice::CommunicatorPtr&);
     void destroy();
     friend class Ice::CommunicatorI;
 
diff --git a/cpp/src/Ice/LoggerAdminI.cpp b/cpp/src/Ice/LoggerAdminI.cpp
new file mode 100644
index 00000000000..299f3718087
--- /dev/null
+++ b/cpp/src/Ice/LoggerAdminI.cpp
@@ -0,0 +1,873 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#include <Ice/LoggerAdminI.h>
+#include <Ice/RemoteLogger.h>
+#include <Ice/Properties.h>
+#include <Ice/ObjectAdapter.h>
+#include <Ice/Communicator.h>
+#include <Ice/Connection.h>
+#include <Ice/LocalException.h>
+#include <Ice/LoggerUtil.h>
+
+#include <set>
+
+using namespace std;
+
+namespace
+{
+
+class LoggerAdminI : public Ice::LoggerAdmin
+{
+public:
+
+    LoggerAdminI(const string&, const Ice::PropertiesPtr&);
+    
+    virtual void attachRemoteLogger(const Ice::RemoteLoggerPrx&, const Ice::LogMessageTypeSeq&, 
+                                    const Ice::StringSeq&, Ice::Int, const Ice::Current&);
+    
+    virtual void detachRemoteLogger(const Ice::RemoteLoggerPrx&, const Ice::Current&);
+    
+    virtual Ice::LogMessageSeq getLog(const Ice::LogMessageTypeSeq&, 
+                                      const Ice::StringSeq&, Ice::Int, string&,
+                                      const Ice::Current&);
+    
+    vector<Ice::RemoteLoggerPrx> log(const Ice::LogMessage&);
+    
+    void deadRemoteLogger(const Ice::RemoteLoggerPrx&,
+                          const Ice::LoggerPtr&, 
+                          const Ice::LocalException&, const string&);
+
+    void run(const Ice::LoggerPtr&);
+    void destroy();
+
+    const string& getFacetName() const
+    {
+        return _facetName;
+    }
+
+    const int getTraceLevel() const
+    {
+        return _traceLevel;
+    }
+
+private:
+   
+    bool removeRemoteLogger(const Ice::RemoteLoggerPrx&);
+    
+    void remoteCallCompleted(const Ice::AsyncResultPtr&);
+
+    const string _facetName;
+
+    IceUtil::Monitor<IceUtil::Mutex> _monitor;
+    list<Ice::LogMessage> _queue;
+    int _logCount; // non-trace messages
+    const int _maxLogCount;
+    int _traceCount;
+    const int _maxTraceCount;
+    const int _traceLevel;
+    IceUtil::Time _pingPeriod;
+    
+    list<Ice::LogMessage>::iterator _oldestTrace;
+    list<Ice::LogMessage>::iterator _oldestLog;
+
+    struct ObjectIdentityCompare
+    {
+        bool operator()(const Ice::RemoteLoggerPrx& lhs, const Ice::RemoteLoggerPrx& rhs)
+        {
+            //
+            // Caller should make sure that proxies are never null
+            //
+            assert(lhs != 0 && rhs != 0);
+            
+            return lhs->ice_getIdentity() < rhs->ice_getIdentity();
+        }
+    };
+
+    struct Filters
+    {
+        Filters(const Ice::LogMessageTypeSeq& m, const Ice::StringSeq& c) :
+            messageTypes(m.begin(), m.end()),
+            traceCategories(c.begin(), c.end())
+        {
+        }
+        
+        const set<Ice::LogMessageType> messageTypes;
+        const set<string> traceCategories;
+    };
+
+    typedef map<Ice::RemoteLoggerPrx, Filters, ObjectIdentityCompare> RemoteLoggerMap; 
+
+    struct GetRemoteLoggerMapKey
+    {
+        RemoteLoggerMap::key_type 
+        operator()(const RemoteLoggerMap::value_type& val)
+        {
+            return val.first;
+        }
+    };
+    
+    RemoteLoggerMap _remoteLoggerMap;
+
+    const Ice::CallbackPtr _remoteCallCompleted;
+
+    bool _destroyed;
+    bool _pingThreadStarted;
+    IceUtil::ThreadControl _pingThreadControl;
+};
+typedef IceUtil::Handle<LoggerAdminI> LoggerAdminIPtr;
+
+
+class PingThread : public IceUtil::Thread
+{
+public:
+    PingThread(const LoggerAdminIPtr&, const Ice::LoggerPtr&);
+
+    virtual void run();
+
+private:
+
+    LoggerAdminIPtr _loggerAdmin;
+    Ice::LoggerPtr _logger;
+};
+
+
+class Job : public IceUtil::Shared
+{
+public:
+    
+    Job(const vector<Ice::RemoteLoggerPrx>& r, const Ice::LogMessage& l) :
+        remoteLoggers(r),
+        logMessage(l)
+    {
+    }
+    
+    const vector<Ice::RemoteLoggerPrx> remoteLoggers;
+    const Ice::LogMessage logMessage;   
+};
+typedef IceUtil::Handle<Job> JobPtr;
+
+
+class LoggerAdminLoggerI : public Ice::LoggerAdminLogger
+{
+public:
+    
+    LoggerAdminLoggerI(const std::string&, const Ice::PropertiesPtr&, const Ice::LoggerPtr&);
+
+    virtual void print(const std::string&);
+    virtual void trace(const std::string&, const std::string&);
+    virtual void warning(const std::string&);
+    virtual void error(const std::string&);
+    virtual std::string getPrefix();
+    virtual Ice::LoggerPtr cloneWithPrefix(const std::string&);
+
+    virtual void addAdminFacet(const Ice::CommunicatorPtr&);
+    virtual void destroy();
+    
+    void run();
+    
+private:
+
+    void log(const Ice::LogMessage&);
+    
+    const Ice::LoggerPtr _localLogger;
+    const LoggerAdminIPtr _loggerAdmin;
+     
+    IceUtil::Monitor<IceUtil::Mutex> _monitor;
+
+    bool _destroyed;
+    bool _sendLogThreadStarted;
+    IceUtil::ThreadControl _sendLogThreadControl;
+    std::deque<JobPtr> _jobQueue;   
+};
+typedef IceUtil::Handle<LoggerAdminLoggerI> LoggerAdminLoggerIPtr;
+
+
+class SendLogThread : public IceUtil::Thread
+{
+public:
+
+    SendLogThread(const LoggerAdminLoggerIPtr&);
+    
+    virtual void run();
+  
+private:
+
+    LoggerAdminLoggerIPtr _logger;
+};
+
+
+//
+// Filter out messages from in/out logMessages list
+//
+void 
+filterLogMessages(Ice::LogMessageSeq& logMessages, const set<Ice::LogMessageType>& messageTypes,
+                  const set<string>& traceCategories, Ice::Int messageMax)
+{
+    if(messageMax == 0)
+    {
+        logMessages.clear();
+    }
+
+    //
+    // Filter only if one of the 3 filters is set; messageMax < 0 means "give me all"
+    // that match the other filters, if any.
+    //
+    else if(!messageTypes.empty() || !traceCategories.empty() || messageMax > 0)
+    {
+        int count = 0;
+        Ice::LogMessageSeq::reverse_iterator p = logMessages.rbegin();
+        while(p != logMessages.rend())
+        {
+            bool keepIt = false;
+            if(messageTypes.empty() || messageTypes.count(p->type) != 0)
+            {
+                if(p->type != Ice::TraceMessage || traceCategories.empty() || 
+                   traceCategories.count(p->traceCategory) != 0)
+                {
+                    keepIt = true;
+                }
+            }
+
+            if(keepIt)
+            {
+                ++p;
+                ++count;
+                if(messageMax > 0 && count >= messageMax)
+                {
+                    //
+                    // p.base() points to p "+1"; note that this invalidates p.
+                    //
+                    logMessages.erase(logMessages.begin(), p.base());
+                    break; // while
+                }
+            }
+            else
+            {
+                ++p;
+                //
+                // p.base() points to p "+1"; the erase invalidates p so we
+                // need to rebuild it
+                //
+                p = Ice::LogMessageSeq::reverse_iterator(logMessages.erase(p.base()));
+            }
+        }
+    }
+    // else, don't need any filtering
+}
+
+
+
+//
+// LoggerAdminI
+//
+
+LoggerAdminI::LoggerAdminI(const string& name, const Ice::PropertiesPtr& props) :
+    _facetName(name),
+    _logCount(0),
+    _maxLogCount(props->getPropertyAsIntWithDefault("Ice.Admin.Logger.KeepLogs", 100)),
+    _traceCount(0),
+    _maxTraceCount(props->getPropertyAsIntWithDefault("Ice.Admin.Logger.KeepTraces", 100)),
+    _traceLevel(props->getPropertyAsInt("Ice.Trace.Admin.Logger")),
+    _remoteCallCompleted(Ice::newCallback(this, &LoggerAdminI::remoteCallCompleted)),
+    _destroyed(false),
+    _pingThreadStarted(false)
+{
+    int pingPeriod = props->getPropertyAsIntWithDefault("Ice.Admin.Logger.PingPeriod", 60);
+    if(pingPeriod < 10)
+    {
+        pingPeriod = 10;
+    }
+    _pingPeriod = IceUtil::Time::seconds(pingPeriod);
+
+    _oldestLog = _queue.end();
+    _oldestTrace = _queue.end();
+}
+
+void
+LoggerAdminI::attachRemoteLogger(const Ice::RemoteLoggerPrx& prx, 
+                                 const Ice::LogMessageTypeSeq& messageTypes, 
+                                 const Ice::StringSeq& categories,
+                                 Ice::Int messageMax, 
+                                 const Ice::Current& current)
+{
+    if(prx == 0)
+    {
+        return; // can't send this null RemoteLogger anything!
+    }
+
+    Ice::RemoteLoggerPrx remoteLogger = prx->ice_oneway();
+    Filters filters(messageTypes, categories);
+
+    Ice::LogMessageSeq initLogMessages;
+    Ice::LoggerPtr logger = current.adapter->getCommunicator()->getLogger();
+
+    {
+        IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+ 
+        if(_remoteLoggerMap.insert(make_pair(remoteLogger, filters)).second == false)
+        {
+            if(_traceLevel > 0)
+            {
+                Ice::Trace trace(current.adapter->getCommunicator()->getLogger(), _facetName);
+                trace << "rejecting '" << remoteLogger << "' with RemoteLoggerAlreadyAttachedException";
+            }
+
+            throw Ice::RemoteLoggerAlreadyAttachedException();
+        }
+
+        if(_pingThreadStarted == false)
+        {
+            IceUtil::ThreadPtr t = new PingThread(this, logger);
+            _pingThreadControl = t->start();
+            _pingThreadStarted = true;
+        }
+
+        if(messageMax != 0)
+        {
+            initLogMessages = _queue; // copy
+        }
+    }
+    
+    if(_traceLevel > 0)
+    {
+        Ice::Trace trace(logger, _facetName);
+        trace << "sending init to '" << remoteLogger->ice_twoway() << "'";
+    }
+
+    filterLogMessages(initLogMessages, filters.messageTypes, filters.traceCategories, messageMax);
+
+    try
+    {
+        remoteLogger->ice_twoway()->begin_init(logger->getPrefix(), initLogMessages, _remoteCallCompleted, logger);
+    }
+    catch(const Ice::LocalException& ex)
+    {
+        deadRemoteLogger(remoteLogger, logger, ex, "init");
+        throw;
+    }
+}
+    
+void
+LoggerAdminI::detachRemoteLogger(const Ice::RemoteLoggerPrx& remoteLogger, 
+                                 const Ice::Current& current)
+{
+    if(remoteLogger == 0)
+    {
+        throw Ice::RemoteLoggerNotAttachedException();
+    }
+
+    bool found = removeRemoteLogger(remoteLogger);
+
+    if(!found)
+    {
+        throw Ice::RemoteLoggerNotAttachedException();
+    }
+
+    if(_traceLevel > 0)
+    {
+        Ice::Trace trace(current.adapter->getCommunicator()->getLogger(), _facetName);
+        trace << "detached '" << remoteLogger << "'";
+    }
+}
+
+Ice::LogMessageSeq 
+LoggerAdminI::getLog(const Ice::LogMessageTypeSeq& messageTypes, 
+                     const Ice::StringSeq& categories, 
+                     Ice::Int messageMax, string& prefix, const Ice::Current& current)
+{
+    Ice::LogMessageSeq logMessages;
+    {
+        IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+        
+        if(messageMax != 0)
+        {
+            logMessages = _queue;
+        }
+    }
+   
+    Ice::LoggerPtr logger = current.adapter->getCommunicator()->getLogger();
+    prefix = logger->getPrefix();
+    
+    Filters filters(messageTypes, categories);
+    filterLogMessages(logMessages, filters.messageTypes, filters.traceCategories, messageMax);
+    return logMessages;
+}
+
+vector<Ice::RemoteLoggerPrx>
+LoggerAdminI::log(const Ice::LogMessage& logMessage)
+{
+    vector<Ice::RemoteLoggerPrx> remoteLoggers;
+
+    IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+
+    //
+    // Put message in _queue
+    //
+    if((logMessage.type != Ice::TraceMessage && _maxLogCount > 0) || 
+       (logMessage.type == Ice::TraceMessage && _maxTraceCount > 0)) 
+    {
+        list<Ice::LogMessage>::iterator p = _queue.insert(_queue.end(), logMessage);
+        
+        if(logMessage.type != Ice::TraceMessage)
+        {
+            assert(_maxLogCount > 0);
+            if(_logCount == _maxLogCount)
+            {
+                //
+                // Need to remove the oldest log from the queue
+                //
+                assert(_oldestLog != _queue.end());
+                _oldestLog = _queue.erase(_oldestLog);
+                while(_oldestLog != _queue.end() && _oldestLog->type == Ice::TraceMessage)
+                {
+                    _oldestLog++;
+                }
+                assert(_oldestLog != _queue.end());
+            }
+            else
+            {
+                assert(_logCount < _maxLogCount);
+                _logCount++;
+                if(_oldestLog == _queue.end())
+                {
+                    _oldestLog = p;
+                }
+            }
+        }
+        else
+        {
+            assert(_maxTraceCount > 0);
+            if(_traceCount == _maxTraceCount)
+            {
+                //
+                // Need to remove the oldest trace from the queue
+                //
+                assert(_oldestTrace != _queue.end());
+                _oldestTrace = _queue.erase(_oldestTrace);
+                while(_oldestTrace != _queue.end() && _oldestTrace->type != Ice::TraceMessage)
+                {
+                    _oldestTrace++;
+                }
+                assert(_oldestTrace != _queue.end());
+            }
+            else
+            {
+                assert(_traceCount < _maxTraceCount);
+                _traceCount++;
+                if(_oldestTrace == _queue.end())
+                {
+                    _oldestTrace = p;
+                }
+            }
+        }
+        
+        //
+        // Queue updated, now find which remote loggers want this message
+        //        
+        for(RemoteLoggerMap::const_iterator p = _remoteLoggerMap.begin(); p != _remoteLoggerMap.end(); ++p)
+        {
+            const Filters& filters = p->second;
+            
+            if(filters.messageTypes.empty() || filters.messageTypes.count(logMessage.type) != 0)
+            {
+                if(logMessage.type != Ice::TraceMessage || filters.traceCategories.empty() ||
+                   filters.traceCategories.count(logMessage.traceCategory) != 0) 
+                {
+                    remoteLoggers.push_back(p->first);
+                }
+            }
+        }
+    }
+    return remoteLoggers;
+}
+
+void
+LoggerAdminI::deadRemoteLogger(const Ice::RemoteLoggerPrx& remoteLogger,
+                               const Ice::LoggerPtr& logger,
+                               const Ice::LocalException& ex,
+                               const string& operation)
+{
+    if(removeRemoteLogger(remoteLogger))
+    {
+        if(_traceLevel > 0)
+        {
+            Ice::Trace trace(logger, _facetName);
+            trace << operation << " on '" << remoteLogger << "' raised '" 
+                  << ex << "'; remote logger removed automatically";
+        }
+    }
+}
+
+void
+LoggerAdminI::destroy()
+{
+    IceUtil::ThreadControl pingThreadControl;
+    bool joinThread = false;
+    {
+        IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+        
+        if(_pingThreadStarted)
+        {
+            joinThread = true;
+            pingThreadControl = _pingThreadControl;
+            _pingThreadStarted = false;
+            _destroyed = true;
+            _monitor.notifyAll();
+        }
+    }
+
+    if(joinThread)
+    {
+        pingThreadControl.join();
+    }
+}
+
+void
+LoggerAdminI::run(const Ice::LoggerPtr& logger)
+{
+    if(_traceLevel > 1)
+    {
+        Ice::Trace trace(logger, _facetName);
+        trace << "Ping thread started";
+    }
+
+    for(;;)
+    {
+        vector<Ice::RemoteLoggerPrx> remoteLoggers;
+        {
+            IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+            if(_destroyed)
+            {
+                break; // for(;;)
+            }
+
+            if(_monitor.timedWait(_pingPeriod) == false && !_destroyed)
+            {
+                transform(_remoteLoggerMap.begin(), _remoteLoggerMap.end(), back_inserter(remoteLoggers), 
+                          GetRemoteLoggerMapKey());
+            }
+        }
+        
+        for(vector<Ice::RemoteLoggerPrx>::const_iterator p = remoteLoggers.begin(); p != remoteLoggers.end(); ++p)
+        {
+            Ice::RemoteLoggerPrx remoteLogger = (*p)->ice_twoway();
+
+            if(_traceLevel > 1)
+            {
+                Ice::Trace trace(logger, _facetName);
+                trace << "sending ice_ping to '" << remoteLogger << "'";
+            }
+            
+            try
+            {
+                remoteLogger->begin_ice_ping(_remoteCallCompleted, logger);
+            }
+            catch(const Ice::LocalException& ex)
+            {
+                deadRemoteLogger(remoteLogger, logger, ex, "ice_ping");
+            }
+        }
+    }        
+    
+    if(_traceLevel > 1)
+    {
+        Ice::Trace trace(logger, _facetName);
+        trace << "Ping thread completed";
+    }
+}
+
+bool
+LoggerAdminI::removeRemoteLogger(const Ice::RemoteLoggerPrx& remoteLogger)
+{
+    IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+    return _remoteLoggerMap.erase(remoteLogger) > 0;
+}
+
+void
+LoggerAdminI::remoteCallCompleted(const Ice::AsyncResultPtr& r)
+{
+    try 
+    {
+        r->throwLocalException();
+
+        if(_traceLevel > 1)
+        {
+            Ice::LoggerPtr logger = Ice::LoggerPtr::dynamicCast(r->getCookie());
+            Ice::Trace trace(logger, _facetName);
+            trace << r->getOperation() << " on '" << r->getProxy() << "' completed successfully";
+        }
+    }
+    catch(const Ice::LocalException& ex)
+    {
+        deadRemoteLogger(Ice::RemoteLoggerPrx::uncheckedCast(r->getProxy()),
+                        Ice::LoggerPtr::dynamicCast(r->getCookie()),
+                        ex, r->getOperation());
+    }
+}
+
+//
+// PingThread
+//
+PingThread::PingThread(
+    const LoggerAdminIPtr& loggerAdmin, const Ice::LoggerPtr& logger) :
+    IceUtil::Thread("Ice.RemoteLoggerPingThread"),
+    _loggerAdmin(loggerAdmin),
+    _logger(logger)
+{
+}
+
+void
+PingThread::run()
+{
+    _loggerAdmin->run(_logger);
+}
+
+
+//
+// LoggerAdminLoggerI
+//
+
+LoggerAdminLoggerI::LoggerAdminLoggerI(const string& facetName, 
+                                       const Ice::PropertiesPtr& props, 
+                                       const Ice::LoggerPtr& localLogger) :
+    _localLogger(localLogger),
+    _loggerAdmin(new LoggerAdminI(facetName, props)),
+    _destroyed(false),
+    _sendLogThreadStarted(false)
+{
+    //
+    // There is currently no way to have a null local logger
+    //
+    assert(_localLogger != 0);
+}
+
+void
+LoggerAdminLoggerI::print(const string& message)
+{
+   Ice::LogMessage logMessage = {Ice::PrintMessage, 
+                                 IceUtil::Time::now().toMicroSeconds(),
+                                 "",
+                                 message};
+   
+    _localLogger->print(message);
+    log(logMessage);
+}
+
+void
+LoggerAdminLoggerI::trace(const string& category, const string& message)
+{
+    Ice::LogMessage logMessage = {Ice::TraceMessage, 
+                                  IceUtil::Time::now().toMicroSeconds(),
+                                  category,
+                                  message};
+    
+    _localLogger->trace(category, message);
+    log(logMessage);
+}
+
+void
+LoggerAdminLoggerI::warning(const string& message)
+{
+    Ice::LogMessage logMessage = {Ice::WarningMessage, 
+                                  IceUtil::Time::now().toMicroSeconds(),
+                                  "",
+                                  message};
+
+    
+    _localLogger->warning(message);
+    log(logMessage);
+}
+
+void
+LoggerAdminLoggerI::error(const string& message)
+{
+    Ice::LogMessage logMessage = {Ice::ErrorMessage, 
+                                   IceUtil::Time::now().toMicroSeconds(),
+                                  "",
+                                  message};
+    
+    
+    _localLogger->error(message);
+    log(logMessage);
+}
+
+string
+LoggerAdminLoggerI::getPrefix()
+{
+    return _localLogger->getPrefix();
+}
+
+Ice::LoggerPtr
+LoggerAdminLoggerI::cloneWithPrefix(const string& prefix)
+{
+    return _localLogger->cloneWithPrefix(prefix);
+}
+
+void
+LoggerAdminLoggerI::addAdminFacet(const Ice::CommunicatorPtr& communicator)
+{
+    communicator->addAdminFacet(_loggerAdmin, _loggerAdmin->getFacetName());
+}
+
+void 
+LoggerAdminLoggerI::log(const Ice::LogMessage& logMessage)
+{
+
+    //
+    // We don't want to proceed if the SendLog thread is calling log.
+    //
+    bool proceed = false;
+    {
+        IceUtil::ThreadControl currentThread;
+
+        IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+        proceed = !_destroyed &&
+            (!_sendLogThreadStarted || (_sendLogThreadStarted && (currentThread != _sendLogThreadControl)));
+    }
+
+    if(proceed)
+    {
+        const vector<Ice::RemoteLoggerPrx> remoteLoggers = _loggerAdmin->log(logMessage); 
+    
+        if(!remoteLoggers.empty())
+        {
+            IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+            
+            if(!_sendLogThreadStarted)
+            {
+                IceUtil::ThreadPtr t = new SendLogThread(this);
+                _sendLogThreadControl = t->start();
+                _sendLogThreadStarted = true;
+            }
+            _jobQueue.push_back(new Job(remoteLoggers, logMessage));
+            _monitor.notifyAll();
+        }
+    }
+}
+
+void
+LoggerAdminLoggerI::destroy()
+{
+    _loggerAdmin->destroy();
+
+    IceUtil::ThreadControl sendLogThreadControl;
+    bool joinThread = false;
+    {
+        IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+        
+        if(_sendLogThreadStarted)
+        {
+            joinThread = true;
+            sendLogThreadControl = _sendLogThreadControl;
+            _sendLogThreadStarted = false;
+            _destroyed = true;
+            _monitor.notifyAll();
+        }
+    }
+
+    if(joinThread)
+    {
+        sendLogThreadControl.join();
+    }
+}
+
+void
+LoggerAdminLoggerI::run()
+{
+    if(_loggerAdmin->getTraceLevel() > 1)
+    {
+        Ice::Trace trace(_localLogger, _loggerAdmin->getFacetName());
+        trace << "Send log thread started";
+    }
+
+    for(;;)
+    {
+        IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+        while(!_destroyed && _jobQueue.empty())
+        {
+            _monitor.wait();
+        }
+        if(_destroyed)
+        {
+            break; // for(;;)
+        }
+        if(!_jobQueue.empty())
+        {
+            JobPtr job = _jobQueue.front();
+            _jobQueue.pop_front();
+            lock.release();
+            
+            for(vector<Ice::RemoteLoggerPrx>::const_iterator p = job->remoteLoggers.begin();
+                p != job->remoteLoggers.end(); ++p)
+            {
+                if(_loggerAdmin->getTraceLevel() > 1)
+                {
+                    Ice::Trace trace(_localLogger, _loggerAdmin->getFacetName());
+                    trace << "sending log message to '" << *p << "'";
+                }
+
+                try
+                {
+                    // We use a synchronous oneway call here
+                    // using twoway could generate additional log when receiving the response
+                    // from the client thread-pool thread; likewise, AMI could generate
+                    // extra logs from the client thread pool thread
+                    
+                    (*p)->log(job->logMessage);
+                }
+                catch(const Ice::LocalException& ex)
+                {
+                    _loggerAdmin->deadRemoteLogger(*p, _localLogger, ex, "log");
+                }
+            }  
+        }
+    }
+
+    if(_loggerAdmin->getTraceLevel() > 1)
+    {
+        Ice::Trace trace(_localLogger, _loggerAdmin->getFacetName());
+        trace << "Send log thread completed";
+    }
+}
+
+
+//
+// SendLogThread
+//
+
+SendLogThread::SendLogThread(const LoggerAdminLoggerIPtr& logger) :
+    IceUtil::Thread("Ice.SendLogThread"),
+    _logger(logger)
+{
+}
+    
+void 
+SendLogThread::run()
+{
+    _logger->run();
+}
+}
+
+//
+// createLoggerAdminLogger
+//
+
+namespace IceInternal
+{
+
+Ice::LoggerAdminLoggerPtr 
+createLoggerAdminLogger(const std::string& facetName, 
+                        const Ice::PropertiesPtr& props, 
+                        const Ice::LoggerPtr& localLogger)
+{
+    return new LoggerAdminLoggerI(facetName, props, localLogger);
+}
+
+}
diff --git a/cpp/src/Ice/LoggerAdminI.h b/cpp/src/Ice/LoggerAdminI.h
new file mode 100644
index 00000000000..1a175d1b8ff
--- /dev/null
+++ b/cpp/src/Ice/LoggerAdminI.h
@@ -0,0 +1,53 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_LOGGER_ADMIN_I_H
+#define ICE_LOGGER_ADMIN_I_H
+
+#include <Ice/Config.h>
+#include <Ice/Logger.h>
+#include <Ice/PropertiesF.h>
+#include <Ice/CommunicatorF.h>
+
+namespace Ice
+{
+
+//
+// A logger that works in tandem with a "Logger" admin facet.
+//
+class ICE_API LoggerAdminLogger : public Ice::Logger
+{
+public:
+
+    //
+    // Add the associated LoggerAdmin facet to this communicator
+    //
+    virtual void addAdminFacet(const CommunicatorPtr&) = 0;
+
+
+    //
+    // Destroy this logger, in particular join any thread
+    // that this logger may have started
+    //
+    virtual void destroy() = 0;
+    
+};
+typedef IceInternal::Handle<LoggerAdminLogger> LoggerAdminLoggerPtr;
+
+}
+
+namespace IceInternal
+{
+
+Ice::LoggerAdminLoggerPtr 
+createLoggerAdminLogger(const std::string&, const Ice::PropertiesPtr&, const Ice::LoggerPtr&);
+
+}
+
+#endif
diff --git a/cpp/src/Ice/LoggerI.cpp b/cpp/src/Ice/LoggerI.cpp
index 430d9fd49f6..e3298062478 100644
--- a/cpp/src/Ice/LoggerI.cpp
+++ b/cpp/src/Ice/LoggerI.cpp
@@ -50,6 +50,7 @@ Init init;
 
 Ice::LoggerI::LoggerI(const string& prefix, const string& file, 
                       bool convert, const IceUtil::StringConverterPtr& converter) :
+    _prefix(prefix),
     _convert(convert),
     _converter(converter)
 #if defined(_WIN32) && !defined(ICE_OS_WINRT)
@@ -59,7 +60,7 @@ Ice::LoggerI::LoggerI(const string& prefix, const string& file,
 {
     if(!prefix.empty())
     {
-        _prefix = prefix + ": ";
+        _formattedPrefix = prefix + ": ";
     }
 
     if(!file.empty())
@@ -90,7 +91,7 @@ Ice::LoggerI::print(const string& message)
 void
 Ice::LoggerI::trace(const string& category, const string& message)
 {
-    string s = "-- " + IceUtil::Time::now().toDateTime() + " " + _prefix;
+    string s = "-- " + IceUtil::Time::now().toDateTime() + " " + _formattedPrefix;
     if(!category.empty())
     {
         s += category + ": ";
@@ -103,13 +104,19 @@ Ice::LoggerI::trace(const string& category, const string& message)
 void
 Ice::LoggerI::warning(const string& message)
 {
-    write("-! " + IceUtil::Time::now().toDateTime() + " " + _prefix + "warning: " + message, true);
+    write("-! " + IceUtil::Time::now().toDateTime() + " " + _formattedPrefix + "warning: " + message, true);
 }
 
 void
 Ice::LoggerI::error(const string& message)
 {
-    write("!! " + IceUtil::Time::now().toDateTime() + " " + _prefix + "error: " + message, true);
+    write("!! " + IceUtil::Time::now().toDateTime() + " " + _formattedPrefix + "error: " + message, true);
+}
+
+string
+Ice::LoggerI::getPrefix()
+{
+    return _prefix;
 }
 
 LoggerPtr
diff --git a/cpp/src/Ice/LoggerI.h b/cpp/src/Ice/LoggerI.h
index 1ae72c9445b..f8fbb813252 100644
--- a/cpp/src/Ice/LoggerI.h
+++ b/cpp/src/Ice/LoggerI.h
@@ -29,13 +29,15 @@ public:
     virtual void trace(const std::string&, const std::string&);
     virtual void warning(const std::string&);
     virtual void error(const std::string&);
+    virtual std::string getPrefix();
     virtual LoggerPtr cloneWithPrefix(const std::string&);
 
 private:
 
     void write(const std::string&, bool);
 
-    std::string _prefix;
+    const std::string _prefix;
+    std::string _formattedPrefix;
     const bool _convert;
     const IceUtil::StringConverterPtr _converter;
     IceUtilInternal::ofstream _out;
diff --git a/cpp/src/Ice/Makefile b/cpp/src/Ice/Makefile
index 7fa44656c04..7c5803c1a96 100644
--- a/cpp/src/Ice/Makefile
+++ b/cpp/src/Ice/Makefile
@@ -58,8 +58,9 @@ OBJS		= Acceptor.o \
 		  LocalObject.o \
 		  LocatorInfo.o \
 		  Locator.o \
-		  LoggerI.o \
 		  Logger.o \
+                  LoggerAdminI.o \
+                  LoggerI.o \
 		  LoggerUtil.o \
 		  Metrics.o \
 		  MetricsAdminI.o \
@@ -92,6 +93,7 @@ OBJS		= Acceptor.o \
 		  Proxy.o \
 		  ReferenceFactory.o \
 		  Reference.o \
+                  RemoteLogger.o \
 		  ResponseHandler.o \
 		  RetryQueue.o \
 		  RequestHandler.o \
diff --git a/cpp/src/Ice/Makefile.mak b/cpp/src/Ice/Makefile.mak
index 85c8a06a7ab..2d847dce230 100644
--- a/cpp/src/Ice/Makefile.mak
+++ b/cpp/src/Ice/Makefile.mak
@@ -59,6 +59,7 @@ OBJS		= Acceptor.obj \
 		  LocalObject.obj \
 		  LocatorInfo.obj \
 		  Locator.obj \
+                  LoggerAdminI.obj \
 		  LoggerI.obj \
 		  Logger.obj \
 		  LoggerUtil.obj \
@@ -93,6 +94,7 @@ OBJS		= Acceptor.obj \
 		  Proxy.obj \
 		  ReferenceFactory.obj \
 		  Reference.obj \
+                  RemoteLogger.obj \
 		  RetryQueue.obj \
 		  RequestHandler.obj \
 		  ResponseHandler.obj \
@@ -195,6 +197,7 @@ clean::
 	-del /q PropertiesF.cpp $(HDIR)\PropertiesF.h
 	-del /q PropertiesAdmin.cpp $(HDIR)\PropertiesAdmin.h
 	-del /q Properties.cpp $(HDIR)\Properties.h
+        -del /q RemoteLogger.cpp $(HDIR)\RemoteLogger.h
 	-del /q RouterF.cpp $(HDIR)\RouterF.h
 	-del /q Router.cpp $(HDIR)\Router.h
 	-del /q ServantLocatorF.cpp $(HDIR)\ServantLocatorF.h
diff --git a/cpp/src/Ice/PropertyNames.cpp b/cpp/src/Ice/PropertyNames.cpp
index 7c11a5db27b..92ecdaddc56 100644
--- a/cpp/src/Ice/PropertyNames.cpp
+++ b/cpp/src/Ice/PropertyNames.cpp
@@ -6,7 +6,7 @@
 // ICE_LICENSE file included in this distribution.
 //
 // **********************************************************************
-// Generated by makeprops.py from file ./config/PropertyNames.xml, Wed Aug 13 15:11:58 2014
+// Generated by makeprops.py from file ../config/PropertyNames.xml, Thu Aug 14 14:50:07 2014
 
 // IMPORTANT: Do not edit this file -- any edits made here will be lost!
 
@@ -67,6 +67,9 @@ const IceInternal::Property IcePropsData[] =
     IceInternal::Property("Ice.Admin.DelayCreation", false, 0),
     IceInternal::Property("Ice.Admin.Facets", false, 0),
     IceInternal::Property("Ice.Admin.InstanceName", false, 0),
+    IceInternal::Property("Ice.Admin.Logger.KeepLogs", false, 0),
+    IceInternal::Property("Ice.Admin.Logger.KeepTraces", false, 0),
+    IceInternal::Property("Ice.Admin.Logger.PingPeriod", false, 0),
     IceInternal::Property("Ice.Admin.ServerId", false, 0),
     IceInternal::Property("Ice.BackgroundLocatorCacheUpdates", false, 0),
     IceInternal::Property("Ice.BatchAutoFlush", false, 0),
@@ -156,6 +159,7 @@ const IceInternal::Property IcePropsData[] =
     IceInternal::Property("Ice.ThreadPool.Server.ThreadPriority", false, 0),
     IceInternal::Property("Ice.ThreadPriority", false, 0),
     IceInternal::Property("Ice.Trace.Admin.Properties", false, 0),
+    IceInternal::Property("Ice.Trace.Admin.Logger", false, 0),
     IceInternal::Property("Ice.Trace.Locator", false, 0),
     IceInternal::Property("Ice.Trace.Network", false, 0),
     IceInternal::Property("Ice.Trace.Protocol", false, 0),
diff --git a/cpp/src/Ice/PropertyNames.h b/cpp/src/Ice/PropertyNames.h
index d5b33df89b8..6a38fafc5e3 100644
--- a/cpp/src/Ice/PropertyNames.h
+++ b/cpp/src/Ice/PropertyNames.h
@@ -6,7 +6,7 @@
 // ICE_LICENSE file included in this distribution.
 //
 // **********************************************************************
-// Generated by makeprops.py from file ./config/PropertyNames.xml, Wed Aug 13 15:11:58 2014
+// Generated by makeprops.py from file ../config/PropertyNames.xml, Thu Aug 14 14:50:07 2014
 
 // IMPORTANT: Do not edit this file -- any edits made here will be lost!
 
diff --git a/cpp/src/Ice/ProtocolInstance.cpp b/cpp/src/Ice/ProtocolInstance.cpp
index 363de0cb1b0..2c27bb2c0c2 100644
--- a/cpp/src/Ice/ProtocolInstance.cpp
+++ b/cpp/src/Ice/ProtocolInstance.cpp
@@ -24,7 +24,6 @@ IceInternal::ProtocolInstance::ProtocolInstance(const CommunicatorPtr& com, Shor
     _instance(getInstance(com)),
     _traceLevel(_instance->traceLevels()->network),
     _traceCategory(_instance->traceLevels()->networkCat),
-    _logger(_instance->initializationData().logger),
     _properties(_instance->initializationData().properties),
     _protocol(protocol),
     _type(type)
@@ -35,7 +34,6 @@ IceInternal::ProtocolInstance::ProtocolInstance(const InstancePtr& instance, Sho
     _instance(instance),
     _traceLevel(_instance->traceLevels()->network),
     _traceCategory(_instance->traceLevels()->networkCat),
-    _logger(_instance->initializationData().logger),
     _properties(_instance->initializationData().properties),
     _protocol(protocol),
     _type(type)
diff --git a/cpp/src/Ice/ProtocolInstance.h b/cpp/src/Ice/ProtocolInstance.h
index 9a0ebec59b9..60ce51426f2 100644
--- a/cpp/src/Ice/ProtocolInstance.h
+++ b/cpp/src/Ice/ProtocolInstance.h
@@ -18,6 +18,7 @@
 #include <Ice/ConnectorF.h>
 #include <Ice/IPEndpointIF.h>
 #include <Ice/NetworkF.h>
+#include <Ice/Instance.h>
 
 namespace IceInternal
 {
@@ -40,7 +41,7 @@ public:
 
     const Ice::LoggerPtr& logger() const
     {
-        return _logger;
+        return _instance->initializationData().logger;
     }
 
     const std::string& protocol() const
@@ -81,7 +82,6 @@ protected:
 
     const int _traceLevel;
     const std::string _traceCategory;
-    const Ice::LoggerPtr _logger;
     const Ice::PropertiesPtr _properties;
     const std::string _protocol;
     const Ice::Short _type;
diff --git a/cpp/src/Ice/Service.cpp b/cpp/src/Ice/Service.cpp
index 4fca9da3e36..f3271be7cb8 100644
--- a/cpp/src/Ice/Service.cpp
+++ b/cpp/src/Ice/Service.cpp
@@ -187,6 +187,12 @@ public:
         _logger->error(_prefix, message);
     }
     
+    virtual string
+    getPrefix()
+    {
+        return _prefix;
+    }
+
     virtual Ice::LoggerPtr
     cloneWithPrefix(const string& prefix)
     {
@@ -196,10 +202,10 @@ public:
 private:
     
     SMEventLoggerPtr _logger;
-    string _prefix;
+    const string _prefix;
 };
 
-class SMEventLoggerI : public Ice::Logger, public SMEventLogger
+class SMEventLoggerI : public SMEventLogger
 {
 public:
 
@@ -317,14 +323,14 @@ public:
         print(s);
     }
     
-    virtual void
+    void
     print(const string& message)
     {
         //
         // Don't need to use a wide string converter as the wide string is passed
         // to Windows API.
         //
-		wstring msg = IceUtil::stringToWstring(message, _stringConverter);
+        wstring msg = IceUtil::stringToWstring(message, _stringConverter);
         const wchar_t* messages[1];
         messages[0] = msg.c_str();
         //
@@ -347,7 +353,7 @@ public:
         trace(prefix, s);
     }
     
-    virtual void
+    void
     trace(const string& category, const string& message)
     {
         string s;
@@ -362,7 +368,7 @@ public:
         // Don't need to use a wide string converter as the wide string is passed
         // to Windows API.
         //
-		wstring msg = IceUtil::stringToWstring(s, _stringConverter);
+        wstring msg = IceUtil::stringToWstring(s, _stringConverter);
         const wchar_t* messages[1];
         messages[0] = msg.c_str();
         //
@@ -385,14 +391,14 @@ public:
         warning(s);
     }
     
-    virtual void
+    void
     warning(const string& message)
     {
         //
         // Don't need to use a wide string converter as the wide string is passed
         // to Windows API.
         //
-		wstring msg = IceUtil::stringToWstring(message, _stringConverter);
+        wstring msg = IceUtil::stringToWstring(message, _stringConverter);
         const wchar_t* messages[1];
         messages[0] = msg.c_str();
         //
@@ -415,14 +421,14 @@ public:
         error(s);
     }
 
-    virtual void
+    void
     error(const string& message)
     {
         //
         // Don't need to use a wide string converter as the wide string is passed
         // to Windows API.
         //
-		wstring msg = IceUtil::stringToWstring(message, _stringConverter);
+        wstring msg = IceUtil::stringToWstring(message, _stringConverter);
         const wchar_t* messages[1];
         messages[0] = msg.c_str();
         //
@@ -432,12 +438,6 @@ public:
         ReportEventW(_source, EVENTLOG_ERROR_TYPE, 0, EVENT_LOGGER_MSG, 0, 1, 0, messages, 0);
     }
     
-    virtual Ice::LoggerPtr
-    cloneWithPrefix(const string& prefix)
-    {
-        return new SMEventLoggerIWrapper(this, prefix);
-    }
-
     static void
     setModuleHandle(HMODULE module)
     {
diff --git a/cpp/src/Ice/SysLoggerI.cpp b/cpp/src/Ice/SysLoggerI.cpp
index 65a35ddecc5..197e88ae375 100644
--- a/cpp/src/Ice/SysLoggerI.cpp
+++ b/cpp/src/Ice/SysLoggerI.cpp
@@ -15,7 +15,9 @@ using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-Ice::SysLoggerI::SysLoggerI(const string& prefix, const string& facilityString)
+Ice::SysLoggerI::SysLoggerI(const string& prefix, const string& facilityString) :
+    _facility(0),
+    _prefix(prefix)
 {
     if(facilityString == "LOG_KERN")
     {
@@ -111,7 +113,8 @@ Ice::SysLoggerI::SysLoggerI(const string& prefix, const string& facilityString)
 }
 
 Ice::SysLoggerI::SysLoggerI(const string& prefix, int facility) :
-    _facility(facility)
+    _facility(facility),
+    _prefix(prefix)
 {
     int logopt = LOG_PID | LOG_CONS;
     openlog(prefix.c_str(), logopt, facility);
@@ -151,6 +154,12 @@ Ice::SysLoggerI::error(const string& message)
     syslog(LOG_ERR, "%s", message.c_str());
 }
 
+string
+Ice::SysLoggerI::getPrefix()
+{
+    return _prefix;
+}
+
 Ice::LoggerPtr
 Ice::SysLoggerI::cloneWithPrefix(const string& prefix)
 {
diff --git a/cpp/src/Ice/SysLoggerI.h b/cpp/src/Ice/SysLoggerI.h
index c493f5179d9..e141c7b2bc0 100644
--- a/cpp/src/Ice/SysLoggerI.h
+++ b/cpp/src/Ice/SysLoggerI.h
@@ -27,6 +27,7 @@ public:
     virtual void trace(const std::string&, const std::string&);
     virtual void warning(const std::string&);
     virtual void error(const std::string&);
+    virtual std::string getPrefix();
     virtual LoggerPtr cloneWithPrefix(const std::string&);
 
 private:
@@ -34,6 +35,7 @@ private:
     SysLoggerI(const std::string&, int);
 
     int _facility;
+    const std::string _prefix;
 };
 
 }
diff --git a/cpp/src/IceBox/ServiceManagerI.cpp b/cpp/src/IceBox/ServiceManagerI.cpp
index d1883c77537..433985d971a 100644
--- a/cpp/src/IceBox/ServiceManagerI.cpp
+++ b/cpp/src/IceBox/ServiceManagerI.cpp
@@ -17,6 +17,7 @@
 #include <Ice/PropertiesAdminI.h>
 #include <Ice/MetricsAdminI.h>
 #include <Ice/InstrumentationI.h>
+#include <Ice/LoggerAdminI.h>
 #include <IceBox/ServiceManagerI.h>
 
 using namespace Ice;
@@ -597,6 +598,10 @@ IceBox::ServiceManagerI::start(const string& service, const string& entryPoint,
 #endif
                )
             {
+                //
+                // When _logger is a LoggerAdminLogger, cloneWithPrefix returns a clone of the 
+                // underlying local logger, not of the LoggerAdminLogger itself
+                //
                 initData.logger = _logger->cloneWithPrefix(initData.properties->getProperty("Ice.ProgramName"));
             }
 
@@ -611,12 +616,38 @@ IceBox::ServiceManagerI::start(const string& service, const string& entryPoint,
             }
 
             //
+            // If the Logger is enabled on the IceBox communicator, we tell the service 
+            // to create a LoggerAdmin's Logger, by setting the property Ice.Admin.Logger
+            // 
+            if(_communicator->findAdminFacet("Logger") != 0)
+            {
+                if(initData.properties->getPropertyWithDefault("Ice.Admin.Logger", "Logger") == "Logger")
+                {
+                    initData.properties->setProperty("Ice.Admin.Logger", string("IceBox.Service.") + service + ".Logger");
+                }
+            }
+
+            //
             // Remaining command line options are passed to the communicator. This is
             // necessary for Ice plug-in properties (e.g.: IceSSL).
             //
             info.communicator = initialize(info.args, initData);
             communicator = info.communicator;
 
+            if(_communicator->findAdminFacet("Logger") != 0)
+            {
+                Ice::LoggerAdminLoggerPtr logger = Ice::LoggerAdminLoggerPtr::dynamicCast(communicator->getLogger());
+                assert(logger != 0); // a plugin reset Ice.Admin.Logger to its default??
+                if(logger != 0)
+                {
+                    //
+                    // We add this admin facet to the IceBox main communicator, even though the associated logger
+                    // "works" for the service's communicator
+                    //
+                    logger->addAdminFacet(_communicator);
+                }
+            }
+
             //
             // Ensure the metrics admin plugin uses the same property set as the
             // communicator. This is necessary to correctly deal with runtime 
diff --git a/cpp/src/IceGrid/Grammar.cpp b/cpp/src/IceGrid/Grammar.cpp
index 129718be7b9..df811692aa3 100644
--- a/cpp/src/IceGrid/Grammar.cpp
+++ b/cpp/src/IceGrid/Grammar.cpp
@@ -1,10 +1,9 @@
-
-/* A Bison parser, made by GNU Bison 2.4.1.  */
+/* A Bison parser, made by GNU Bison 2.4.2.  */
 
 /* Skeleton implementation for Bison's Yacc-like parsers in C
    
-      Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
-   Free Software Foundation, Inc.
+      Copyright (C) 1984, 1989-1990, 2000-2006, 2009-2010 Free Software
+   Foundation, Inc.
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -46,7 +45,7 @@
 #define YYBISON 1
 
 /* Bison version.  */
-#define YYBISON_VERSION "2.4.1"
+#define YYBISON_VERSION "2.4.2"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
@@ -104,7 +103,7 @@ yyerror(const char* s)
 
 
 /* Line 189 of yacc.c  */
-#line 108 "Grammar.tab.c"
+#line 107 "Grammar.tab.c"
 
 /* Enabling traces.  */
 #ifndef YYDEBUG
@@ -188,7 +187,7 @@ typedef int YYSTYPE;
 
 
 /* Line 264 of yacc.c  */
-#line 192 "Grammar.tab.c"
+#line 191 "Grammar.tab.c"
 
 #ifdef short
 # undef short
@@ -238,7 +237,7 @@ typedef short int yytype_int16;
 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 
 #ifndef YY_
-# if YYENABLE_NLS
+# if defined YYENABLE_NLS && YYENABLE_NLS
 #  if ENABLE_NLS
 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
@@ -1355,9 +1354,18 @@ static const yytype_uint8 yystos[] =
 
 /* Like YYERROR except do call yyerror.  This remains here temporarily
    to ease the transition to the new meaning of YYERROR, for GCC.
-   Once GCC version 2 has supplanted version 1, this can go.  */
+   Once GCC version 2 has supplanted version 1, this can go.  However,
+   YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
+   in Bison 2.4.2's NEWS entry, where a plan to phase it out is
+   discussed.  */
 
 #define YYFAIL		goto yyerrlab
+#if defined YYFAIL
+  /* This is here to suppress warnings from the GCC cpp's
+     -Wunused-macros.  Normally we don't worry about that warning, but
+     some users do, and we want to make it easy for users to remove
+     YYFAIL uses, which will produce warnings from Bison 2.5.  */
+#endif
 
 #define YYRECOVERING()  (!!yyerrstatus)
 
@@ -1414,7 +1422,7 @@ while (YYID (0))
    we won't break user code: when these are the locations we know.  */
 
 #ifndef YY_LOCATION_PRINT
-# if YYLTYPE_IS_TRIVIAL
+# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
 #  define YY_LOCATION_PRINT(File, Loc)			\
      fprintf (File, "%d.%d-%d.%d",			\
 	      (Loc).first_line, (Loc).first_column,	\
@@ -2152,7 +2160,7 @@ yyreduce:
     {
         case 2:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 89 "Grammar.y"
     {
 ;}
@@ -2160,7 +2168,7 @@ yyreduce:
 
   case 3:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 92 "Grammar.y"
     {
 ;}
@@ -2168,7 +2176,7 @@ yyreduce:
 
   case 4:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 100 "Grammar.y"
     {
 ;}
@@ -2176,7 +2184,7 @@ yyreduce:
 
   case 5:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 103 "Grammar.y"
     {
 ;}
@@ -2184,7 +2192,7 @@ yyreduce:
 
   case 6:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 109 "Grammar.y"
     {
     parser->checkInterrupted();
@@ -2193,7 +2201,7 @@ yyreduce:
 
   case 7:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 118 "Grammar.y"
     {
     parser->usage();
@@ -2202,7 +2210,7 @@ yyreduce:
 
   case 8:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 122 "Grammar.y"
     {
     return 0;
@@ -2211,7 +2219,7 @@ yyreduce:
 
   case 9:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 126 "Grammar.y"
     {
     parser->addApplication((yyvsp[(3) - (4)]));
@@ -2220,7 +2228,7 @@ yyreduce:
 
   case 10:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 130 "Grammar.y"
     {
     parser->usage("application", "add");
@@ -2229,7 +2237,7 @@ yyreduce:
 
   case 11:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 134 "Grammar.y"
     {
     parser->removeApplication((yyvsp[(3) - (4)]));
@@ -2238,7 +2246,7 @@ yyreduce:
 
   case 12:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 138 "Grammar.y"
     {
     parser->usage("application", "remove");
@@ -2247,7 +2255,7 @@ yyreduce:
 
   case 13:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 142 "Grammar.y"
     {
     parser->diffApplication((yyvsp[(3) - (4)]));
@@ -2256,7 +2264,7 @@ yyreduce:
 
   case 14:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 146 "Grammar.y"
     {
     parser->usage("application", "diff");
@@ -2265,7 +2273,7 @@ yyreduce:
 
   case 15:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 150 "Grammar.y"
     {
     parser->updateApplication((yyvsp[(3) - (4)]));
@@ -2274,7 +2282,7 @@ yyreduce:
 
   case 16:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 154 "Grammar.y"
     {
     parser->usage("application", "update");
@@ -2283,7 +2291,7 @@ yyreduce:
 
   case 17:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 158 "Grammar.y"
     {
     parser->describeApplication((yyvsp[(3) - (4)]));
@@ -2292,7 +2300,7 @@ yyreduce:
 
   case 18:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 162 "Grammar.y"
     {
     parser->usage("application", "describe");
@@ -2301,7 +2309,7 @@ yyreduce:
 
   case 19:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 166 "Grammar.y"
     {
     parser->patchApplication((yyvsp[(3) - (4)]));
@@ -2310,7 +2318,7 @@ yyreduce:
 
   case 20:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 170 "Grammar.y"
     {
     parser->usage("application", "patch");
@@ -2319,7 +2327,7 @@ yyreduce:
 
   case 21:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 174 "Grammar.y"
     {
     parser->listAllApplications((yyvsp[(3) - (4)]));
@@ -2328,7 +2336,7 @@ yyreduce:
 
   case 22:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 178 "Grammar.y"
     {
     parser->usage("application", "list");
@@ -2337,7 +2345,7 @@ yyreduce:
 
   case 23:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 182 "Grammar.y"
     {
     parser->describeServerTemplate((yyvsp[(4) - (5)]));
@@ -2346,7 +2354,7 @@ yyreduce:
 
   case 24:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 186 "Grammar.y"
     {
     parser->usage("server template", "describe");
@@ -2355,7 +2363,7 @@ yyreduce:
 
   case 25:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 190 "Grammar.y"
     {
     parser->instantiateServerTemplate((yyvsp[(4) - (5)]));
@@ -2364,7 +2372,7 @@ yyreduce:
 
   case 26:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 194 "Grammar.y"
     {
     parser->usage("server template", "instantiate");
@@ -2373,7 +2381,7 @@ yyreduce:
 
   case 27:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 198 "Grammar.y"
     {
     parser->usage("server template");
@@ -2382,7 +2390,7 @@ yyreduce:
 
   case 28:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 202 "Grammar.y"
     {
     parser->describeServiceTemplate((yyvsp[(4) - (5)]));
@@ -2391,7 +2399,7 @@ yyreduce:
 
   case 29:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 206 "Grammar.y"
     {
     parser->usage("service template", "describe");
@@ -2400,7 +2408,7 @@ yyreduce:
 
   case 30:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 210 "Grammar.y"
     {
     parser->usage("service template");
@@ -2409,7 +2417,7 @@ yyreduce:
 
   case 31:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 214 "Grammar.y"
     {
     parser->describeNode((yyvsp[(3) - (4)]));
@@ -2418,7 +2426,7 @@ yyreduce:
 
   case 32:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 218 "Grammar.y"
     {
     parser->usage("node", "describe");
@@ -2427,7 +2435,7 @@ yyreduce:
 
   case 33:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 222 "Grammar.y"
     {
     parser->pingNode((yyvsp[(3) - (4)]));
@@ -2436,7 +2444,7 @@ yyreduce:
 
   case 34:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 226 "Grammar.y"
     {
     parser->usage("node", "ping");
@@ -2445,7 +2453,7 @@ yyreduce:
 
   case 35:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 230 "Grammar.y"
     {
     parser->printLoadNode((yyvsp[(3) - (4)]));
@@ -2454,7 +2462,7 @@ yyreduce:
 
   case 36:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 234 "Grammar.y"
     {
     parser->usage("node", "load");
@@ -2463,7 +2471,7 @@ yyreduce:
 
   case 37:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 238 "Grammar.y"
     {
     parser->printNodeProcessorSockets((yyvsp[(3) - (4)]));
@@ -2472,7 +2480,7 @@ yyreduce:
 
   case 38:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 242 "Grammar.y"
     {
     parser->usage("node", "sockets");
@@ -2481,7 +2489,7 @@ yyreduce:
 
   case 39:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 246 "Grammar.y"
     {
     parser->shutdownNode((yyvsp[(3) - (4)]));
@@ -2490,7 +2498,7 @@ yyreduce:
 
   case 40:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 250 "Grammar.y"
     {
     parser->usage("node", "shutdown");
@@ -2499,7 +2507,7 @@ yyreduce:
 
   case 41:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 254 "Grammar.y"
     {
     parser->listAllNodes((yyvsp[(3) - (4)]));
@@ -2508,7 +2516,7 @@ yyreduce:
 
   case 42:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 258 "Grammar.y"
     {
     parser->usage("node", "list");
@@ -2517,16 +2525,16 @@ yyreduce:
 
   case 43:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 262 "Grammar.y"
     {
-    parser->showFile("node", (yyvsp[(3) - (4)]));
+    parser->show("node", (yyvsp[(3) - (4)]));
 ;}
     break;
 
   case 44:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 266 "Grammar.y"
     {
     parser->usage("node", "show");
@@ -2535,7 +2543,7 @@ yyreduce:
 
   case 45:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 270 "Grammar.y"
     {
     parser->describeRegistry((yyvsp[(3) - (4)]));
@@ -2544,7 +2552,7 @@ yyreduce:
 
   case 46:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 274 "Grammar.y"
     {
     parser->usage("registry", "describe");
@@ -2553,7 +2561,7 @@ yyreduce:
 
   case 47:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 278 "Grammar.y"
     {
     parser->pingRegistry((yyvsp[(3) - (4)]));
@@ -2562,7 +2570,7 @@ yyreduce:
 
   case 48:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 282 "Grammar.y"
     {
     parser->usage("registry", "ping");
@@ -2571,7 +2579,7 @@ yyreduce:
 
   case 49:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 286 "Grammar.y"
     {
     parser->shutdownRegistry((yyvsp[(3) - (4)]));
@@ -2580,7 +2588,7 @@ yyreduce:
 
   case 50:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 290 "Grammar.y"
     {
     parser->usage("registry", "shutdown");
@@ -2589,7 +2597,7 @@ yyreduce:
 
   case 51:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 294 "Grammar.y"
     {
     parser->listAllRegistries((yyvsp[(3) - (4)]));
@@ -2598,7 +2606,7 @@ yyreduce:
 
   case 52:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 298 "Grammar.y"
     {
     parser->usage("registry", "list");
@@ -2607,16 +2615,16 @@ yyreduce:
 
   case 53:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 302 "Grammar.y"
     {
-    parser->showFile("registry", (yyvsp[(3) - (4)]));
+    parser->show("registry", (yyvsp[(3) - (4)]));
 ;}
     break;
 
   case 54:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 306 "Grammar.y"
     {
     parser->usage("registry", "show");
@@ -2625,7 +2633,7 @@ yyreduce:
 
   case 55:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 310 "Grammar.y"
     {
     parser->removeServer((yyvsp[(3) - (4)]));
@@ -2634,7 +2642,7 @@ yyreduce:
 
   case 56:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 314 "Grammar.y"
     {
     parser->usage("server", "remove");
@@ -2643,7 +2651,7 @@ yyreduce:
 
   case 57:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 318 "Grammar.y"
     {
     parser->describeServer((yyvsp[(3) - (4)]));
@@ -2652,7 +2660,7 @@ yyreduce:
 
   case 58:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 322 "Grammar.y"
     {
     parser->usage("server", "describe");
@@ -2661,7 +2669,7 @@ yyreduce:
 
   case 59:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 326 "Grammar.y"
     {
     parser->startServer((yyvsp[(3) - (4)]));
@@ -2670,7 +2678,7 @@ yyreduce:
 
   case 60:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 330 "Grammar.y"
     {
     parser->usage("server", "start");
@@ -2679,7 +2687,7 @@ yyreduce:
 
   case 61:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 334 "Grammar.y"
     {
     parser->stopServer((yyvsp[(3) - (4)]));
@@ -2688,7 +2696,7 @@ yyreduce:
 
   case 62:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 338 "Grammar.y"
     {
     parser->usage("server", "stop");
@@ -2697,7 +2705,7 @@ yyreduce:
 
   case 63:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 342 "Grammar.y"
     {
     parser->patchServer((yyvsp[(3) - (4)]));
@@ -2706,7 +2714,7 @@ yyreduce:
 
   case 64:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 346 "Grammar.y"
     {
     parser->usage("server", "patch");
@@ -2715,7 +2723,7 @@ yyreduce:
 
   case 65:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 350 "Grammar.y"
     {
     parser->signalServer((yyvsp[(3) - (4)]));
@@ -2724,7 +2732,7 @@ yyreduce:
 
   case 66:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 354 "Grammar.y"
     {
     parser->usage("server", "signal");
@@ -2733,7 +2741,7 @@ yyreduce:
 
   case 67:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 358 "Grammar.y"
     {
     parser->writeMessage((yyvsp[(3) - (4)]), 1);
@@ -2742,7 +2750,7 @@ yyreduce:
 
   case 68:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 362 "Grammar.y"
     {
     parser->usage("server", "stdout");
@@ -2751,7 +2759,7 @@ yyreduce:
 
   case 69:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 366 "Grammar.y"
     {
     parser->writeMessage((yyvsp[(3) - (4)]), 2);
@@ -2760,7 +2768,7 @@ yyreduce:
 
   case 70:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 370 "Grammar.y"
     {
     parser->usage("server", "stderr");
@@ -2769,7 +2777,7 @@ yyreduce:
 
   case 71:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 374 "Grammar.y"
     {
     parser->stateServer((yyvsp[(3) - (4)]));
@@ -2778,7 +2786,7 @@ yyreduce:
 
   case 72:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 378 "Grammar.y"
     {
     parser->usage("server", "start");
@@ -2787,7 +2795,7 @@ yyreduce:
 
   case 73:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 382 "Grammar.y"
     {
     parser->pidServer((yyvsp[(3) - (4)]));
@@ -2796,7 +2804,7 @@ yyreduce:
 
   case 74:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 386 "Grammar.y"
     {
     parser->usage("server", "pid");
@@ -2805,7 +2813,7 @@ yyreduce:
 
   case 75:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 390 "Grammar.y"
     {
     parser->propertiesServer((yyvsp[(3) - (4)]), false);
@@ -2814,7 +2822,7 @@ yyreduce:
 
   case 76:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 394 "Grammar.y"
     {
     parser->usage("server", "properties");
@@ -2823,7 +2831,7 @@ yyreduce:
 
   case 77:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 398 "Grammar.y"
     {
     parser->propertiesServer((yyvsp[(3) - (4)]), true);
@@ -2832,7 +2840,7 @@ yyreduce:
 
   case 78:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 402 "Grammar.y"
     {
     parser->usage("server", "property");
@@ -2841,7 +2849,7 @@ yyreduce:
 
   case 79:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 406 "Grammar.y"
     {
     parser->enableServer((yyvsp[(3) - (4)]), true);
@@ -2850,7 +2858,7 @@ yyreduce:
 
   case 80:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 410 "Grammar.y"
     {
     parser->usage("server", "enable");
@@ -2859,7 +2867,7 @@ yyreduce:
 
   case 81:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 414 "Grammar.y"
     {
     parser->enableServer((yyvsp[(3) - (4)]), false);
@@ -2868,7 +2876,7 @@ yyreduce:
 
   case 82:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 418 "Grammar.y"
     {
     parser->usage("server", "disable");
@@ -2877,7 +2885,7 @@ yyreduce:
 
   case 83:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 422 "Grammar.y"
     {
     parser->listAllServers((yyvsp[(3) - (4)]));
@@ -2886,7 +2894,7 @@ yyreduce:
 
   case 84:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 426 "Grammar.y"
     {
     parser->usage("server", "list");
@@ -2895,16 +2903,16 @@ yyreduce:
 
   case 85:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 430 "Grammar.y"
     {
-    parser->showFile("server", (yyvsp[(3) - (4)]));
+    parser->show("server", (yyvsp[(3) - (4)]));
 ;}
     break;
 
   case 86:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 434 "Grammar.y"
     {
     parser->usage("server", "show");
@@ -2913,7 +2921,7 @@ yyreduce:
 
   case 87:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 438 "Grammar.y"
     {
     parser->startService((yyvsp[(3) - (4)]));
@@ -2922,7 +2930,7 @@ yyreduce:
 
   case 88:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 442 "Grammar.y"
     {
     parser->usage("service", "start");
@@ -2931,7 +2939,7 @@ yyreduce:
 
   case 89:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 446 "Grammar.y"
     {
     parser->stopService((yyvsp[(3) - (4)]));
@@ -2940,7 +2948,7 @@ yyreduce:
 
   case 90:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 450 "Grammar.y"
     {
     parser->usage("service", "stop");
@@ -2949,7 +2957,7 @@ yyreduce:
 
   case 91:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 454 "Grammar.y"
     {
     parser->describeService((yyvsp[(3) - (4)]));
@@ -2958,7 +2966,7 @@ yyreduce:
 
   case 92:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 458 "Grammar.y"
     {
     parser->usage("service", "describe");
@@ -2967,7 +2975,7 @@ yyreduce:
 
   case 93:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 462 "Grammar.y"
     {
     parser->propertiesService((yyvsp[(3) - (4)]), false);
@@ -2976,7 +2984,7 @@ yyreduce:
 
   case 94:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 466 "Grammar.y"
     {
     parser->usage("service", "properties");
@@ -2985,7 +2993,7 @@ yyreduce:
 
   case 95:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 470 "Grammar.y"
     {
     parser->propertiesService((yyvsp[(3) - (4)]), true);
@@ -2994,7 +3002,7 @@ yyreduce:
 
   case 96:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 474 "Grammar.y"
     {
     parser->usage("service", "property");
@@ -3003,7 +3011,7 @@ yyreduce:
 
   case 97:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 478 "Grammar.y"
     {
     parser->listServices((yyvsp[(3) - (4)]));
@@ -3012,7 +3020,7 @@ yyreduce:
 
   case 98:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 482 "Grammar.y"
     {
     parser->usage("service", "list");
@@ -3021,7 +3029,7 @@ yyreduce:
 
   case 99:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 486 "Grammar.y"
     {
     parser->endpointsAdapter((yyvsp[(3) - (4)]));
@@ -3030,7 +3038,7 @@ yyreduce:
 
   case 100:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 490 "Grammar.y"
     {
     parser->usage("adapter", "endpoints");
@@ -3039,7 +3047,7 @@ yyreduce:
 
   case 101:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 494 "Grammar.y"
     {
     parser->removeAdapter((yyvsp[(3) - (4)]));
@@ -3048,7 +3056,7 @@ yyreduce:
 
   case 102:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 498 "Grammar.y"
     {
     parser->usage("adapter", "remove");
@@ -3057,7 +3065,7 @@ yyreduce:
 
   case 103:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 502 "Grammar.y"
     {
     parser->listAllAdapters((yyvsp[(3) - (4)]));
@@ -3066,7 +3074,7 @@ yyreduce:
 
   case 104:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 506 "Grammar.y"
     {
     parser->usage("adapter", "list");
@@ -3075,7 +3083,7 @@ yyreduce:
 
   case 105:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 510 "Grammar.y"
     {
     parser->addObject((yyvsp[(3) - (4)]));
@@ -3084,7 +3092,7 @@ yyreduce:
 
   case 106:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 514 "Grammar.y"
     {
     parser->usage("object", "add");
@@ -3093,7 +3101,7 @@ yyreduce:
 
   case 107:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 518 "Grammar.y"
     {
     parser->removeObject((yyvsp[(3) - (4)]));
@@ -3102,7 +3110,7 @@ yyreduce:
 
   case 108:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 522 "Grammar.y"
     {
     parser->usage("object", "remove");
@@ -3111,7 +3119,7 @@ yyreduce:
 
   case 109:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 526 "Grammar.y"
     {
     parser->findObject((yyvsp[(3) - (4)]));
@@ -3120,7 +3128,7 @@ yyreduce:
 
   case 110:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 530 "Grammar.y"
     {
     parser->usage("object", "find");
@@ -3129,7 +3137,7 @@ yyreduce:
 
   case 111:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 534 "Grammar.y"
     {
     parser->listObject((yyvsp[(3) - (4)]));
@@ -3138,7 +3146,7 @@ yyreduce:
 
   case 112:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 538 "Grammar.y"
     {
     parser->usage("object", "list");
@@ -3147,7 +3155,7 @@ yyreduce:
 
   case 113:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 542 "Grammar.y"
     {
     parser->describeObject((yyvsp[(3) - (4)]));
@@ -3156,7 +3164,7 @@ yyreduce:
 
   case 114:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 546 "Grammar.y"
     {
     parser->usage("object", "describe");
@@ -3165,7 +3173,7 @@ yyreduce:
 
   case 115:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 550 "Grammar.y"
     {
     parser->showCopying();
@@ -3174,7 +3182,7 @@ yyreduce:
 
   case 116:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 554 "Grammar.y"
     {
     parser->showWarranty();
@@ -3183,7 +3191,7 @@ yyreduce:
 
   case 117:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 558 "Grammar.y"
     {
     parser->usage((yyvsp[(2) - (3)]).front());
@@ -3192,7 +3200,7 @@ yyreduce:
 
   case 118:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 562 "Grammar.y"
     {
     if(((yyvsp[(2) - (4)]).front() == "server" || (yyvsp[(2) - (4)]).front() == "service") && (yyvsp[(3) - (4)]).front() == "template")
@@ -3208,7 +3216,7 @@ yyreduce:
 
   case 119:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 573 "Grammar.y"
     {
     parser->usage((yyvsp[(2) - (5)]).front(), (yyvsp[(3) - (5)]).front());
@@ -3217,7 +3225,7 @@ yyreduce:
 
   case 120:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 577 "Grammar.y"
     {
     if(((yyvsp[(2) - (5)]).front() == "server" || (yyvsp[(2) - (5)]).front() == "service") && (yyvsp[(3) - (5)]).front() == "template")
@@ -3233,7 +3241,7 @@ yyreduce:
 
   case 121:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 588 "Grammar.y"
     {
     if(((yyvsp[(2) - (6)]).front() == "server" || (yyvsp[(2) - (6)]).front() == "service") && (yyvsp[(3) - (6)]).front() == "template")
@@ -3249,7 +3257,7 @@ yyreduce:
 
   case 122:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 599 "Grammar.y"
     {
     parser->usage((yyvsp[(2) - (4)]).front());
@@ -3258,7 +3266,7 @@ yyreduce:
 
   case 123:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 603 "Grammar.y"
     {
     parser->usage();
@@ -3267,7 +3275,7 @@ yyreduce:
 
   case 124:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 607 "Grammar.y"
     {
     parser->usage((yyvsp[(1) - (3)]).front());
@@ -3276,7 +3284,7 @@ yyreduce:
 
   case 125:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 611 "Grammar.y"
     {
     (yyvsp[(1) - (4)]).push_back((yyvsp[(2) - (4)]).front());
@@ -3287,7 +3295,7 @@ yyreduce:
 
   case 126:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 617 "Grammar.y"
     {
     parser->invalidCommand((yyvsp[(1) - (3)]));
@@ -3297,7 +3305,7 @@ yyreduce:
 
   case 127:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 622 "Grammar.y"
     {
     parser->invalidCommand((yyvsp[(1) - (3)]));
@@ -3307,7 +3315,7 @@ yyreduce:
 
   case 128:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 627 "Grammar.y"
     {
     yyerrok;
@@ -3316,7 +3324,7 @@ yyreduce:
 
   case 129:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 631 "Grammar.y"
     {
 ;}
@@ -3324,7 +3332,7 @@ yyreduce:
 
   case 130:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 640 "Grammar.y"
     {
     (yyval) = (yyvsp[(2) - (2)]);
@@ -3334,7 +3342,7 @@ yyreduce:
 
   case 131:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 645 "Grammar.y"
     {
     (yyval) = (yyvsp[(2) - (2)]);
@@ -3344,7 +3352,7 @@ yyreduce:
 
   case 132:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 650 "Grammar.y"
     {
     (yyval) = (yyvsp[(2) - (3)]);
@@ -3355,7 +3363,7 @@ yyreduce:
 
   case 133:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 656 "Grammar.y"
     {
     (yyval) = (yyvsp[(2) - (3)]);
@@ -3366,7 +3374,7 @@ yyreduce:
 
   case 134:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 662 "Grammar.y"
     {
     (yyval) = YYSTYPE();
@@ -3375,7 +3383,7 @@ yyreduce:
 
   case 135:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 671 "Grammar.y"
     {
 ;}
@@ -3383,7 +3391,7 @@ yyreduce:
 
   case 136:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 674 "Grammar.y"
     {
 ;}
@@ -3391,7 +3399,7 @@ yyreduce:
 
   case 137:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 677 "Grammar.y"
     {
 ;}
@@ -3399,7 +3407,7 @@ yyreduce:
 
   case 138:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 680 "Grammar.y"
     {
 ;}
@@ -3407,7 +3415,7 @@ yyreduce:
 
   case 139:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 683 "Grammar.y"
     {
 ;}
@@ -3415,7 +3423,7 @@ yyreduce:
 
   case 140:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 686 "Grammar.y"
     {
 ;}
@@ -3423,7 +3431,7 @@ yyreduce:
 
   case 141:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 689 "Grammar.y"
     {
 ;}
@@ -3431,7 +3439,7 @@ yyreduce:
 
   case 142:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 692 "Grammar.y"
     {
 ;}
@@ -3439,7 +3447,7 @@ yyreduce:
 
   case 143:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 695 "Grammar.y"
     {
 ;}
@@ -3447,7 +3455,7 @@ yyreduce:
 
   case 144:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 698 "Grammar.y"
     {
 ;}
@@ -3455,7 +3463,7 @@ yyreduce:
 
   case 145:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 701 "Grammar.y"
     {
 ;}
@@ -3463,7 +3471,7 @@ yyreduce:
 
   case 146:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 704 "Grammar.y"
     {
 ;}
@@ -3471,7 +3479,7 @@ yyreduce:
 
   case 147:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 707 "Grammar.y"
     {
 ;}
@@ -3479,7 +3487,7 @@ yyreduce:
 
   case 148:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 710 "Grammar.y"
     {
 ;}
@@ -3487,7 +3495,7 @@ yyreduce:
 
   case 149:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 713 "Grammar.y"
     {
 ;}
@@ -3495,7 +3503,7 @@ yyreduce:
 
   case 150:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 716 "Grammar.y"
     {
 ;}
@@ -3503,7 +3511,7 @@ yyreduce:
 
   case 151:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 719 "Grammar.y"
     {
 ;}
@@ -3511,7 +3519,7 @@ yyreduce:
 
   case 152:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 722 "Grammar.y"
     {
 ;}
@@ -3519,7 +3527,7 @@ yyreduce:
 
   case 153:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 725 "Grammar.y"
     {
 ;}
@@ -3527,7 +3535,7 @@ yyreduce:
 
   case 154:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 728 "Grammar.y"
     {
 ;}
@@ -3535,7 +3543,7 @@ yyreduce:
 
   case 155:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 731 "Grammar.y"
     {
 ;}
@@ -3543,7 +3551,7 @@ yyreduce:
 
   case 156:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 734 "Grammar.y"
     {
 ;}
@@ -3551,7 +3559,7 @@ yyreduce:
 
   case 157:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 737 "Grammar.y"
     {
 ;}
@@ -3559,7 +3567,7 @@ yyreduce:
 
   case 158:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 740 "Grammar.y"
     {
 ;}
@@ -3567,7 +3575,7 @@ yyreduce:
 
   case 159:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 743 "Grammar.y"
     {
 ;}
@@ -3575,7 +3583,7 @@ yyreduce:
 
   case 160:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 746 "Grammar.y"
     {
 ;}
@@ -3583,7 +3591,7 @@ yyreduce:
 
   case 161:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 749 "Grammar.y"
     {
 ;}
@@ -3591,7 +3599,7 @@ yyreduce:
 
   case 162:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 752 "Grammar.y"
     {
 ;}
@@ -3599,7 +3607,7 @@ yyreduce:
 
   case 163:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 755 "Grammar.y"
     {
 ;}
@@ -3607,7 +3615,7 @@ yyreduce:
 
   case 164:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 758 "Grammar.y"
     {
 ;}
@@ -3615,7 +3623,7 @@ yyreduce:
 
   case 165:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 761 "Grammar.y"
     {
 ;}
@@ -3623,7 +3631,7 @@ yyreduce:
 
   case 166:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 764 "Grammar.y"
     {
 ;}
@@ -3631,7 +3639,7 @@ yyreduce:
 
   case 167:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 767 "Grammar.y"
     {
 ;}
@@ -3639,7 +3647,7 @@ yyreduce:
 
   case 168:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 770 "Grammar.y"
     {
 ;}
@@ -3647,7 +3655,7 @@ yyreduce:
 
   case 169:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 773 "Grammar.y"
     {
 ;}
@@ -3655,7 +3663,7 @@ yyreduce:
 
   case 170:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 776 "Grammar.y"
     {
 ;}
@@ -3663,7 +3671,7 @@ yyreduce:
 
   case 171:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 779 "Grammar.y"
     {
 ;}
@@ -3671,7 +3679,7 @@ yyreduce:
 
   case 172:
 
-/* Line 1455 of yacc.c  */
+/* Line 1464 of yacc.c  */
 #line 782 "Grammar.y"
     {
 ;}
@@ -3679,8 +3687,8 @@ yyreduce:
 
 
 
-/* Line 1455 of yacc.c  */
-#line 3684 "Grammar.tab.c"
+/* Line 1464 of yacc.c  */
+#line 3692 "Grammar.tab.c"
       default: break;
     }
   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
diff --git a/cpp/src/IceGrid/Grammar.h b/cpp/src/IceGrid/Grammar.h
index e39828c6ae7..5ed019cc349 100644
--- a/cpp/src/IceGrid/Grammar.h
+++ b/cpp/src/IceGrid/Grammar.h
@@ -1,10 +1,9 @@
-
-/* A Bison parser, made by GNU Bison 2.4.1.  */
+/* A Bison parser, made by GNU Bison 2.4.2.  */
 
 /* Skeleton interface for Bison's Yacc-like parsers in C
    
-      Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
-   Free Software Foundation, Inc.
+      Copyright (C) 1984, 1989-1990, 2000-2006, 2009-2010 Free Software
+   Foundation, Inc.
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/cpp/src/IceGrid/Grammar.y b/cpp/src/IceGrid/Grammar.y
index 98e69366156..6e96279c1d0 100644
--- a/cpp/src/IceGrid/Grammar.y
+++ b/cpp/src/IceGrid/Grammar.y
@@ -260,7 +260,7 @@ command
 }
 | ICE_GRID_NODE ICE_GRID_SHOW strings ';'
 {
-    parser->showFile("node", $3);
+    parser->show("node", $3);
 }
 | ICE_GRID_NODE ICE_GRID_SHOW ICE_GRID_HELP ';'
 {
@@ -300,7 +300,7 @@ command
 }
 | ICE_GRID_REGISTRY ICE_GRID_SHOW strings ';'
 {
-    parser->showFile("registry", $3);
+    parser->show("registry", $3);
 }
 | ICE_GRID_REGISTRY ICE_GRID_SHOW ICE_GRID_HELP ';'
 {
@@ -428,7 +428,7 @@ command
 }
 | ICE_GRID_SERVER ICE_GRID_SHOW strings ';'
 {
-    parser->showFile("server", $3);
+    parser->show("server", $3);
 }
 | ICE_GRID_SERVER ICE_GRID_SHOW ICE_GRID_HELP ';'
 {
diff --git a/cpp/src/IceGrid/Parser.cpp b/cpp/src/IceGrid/Parser.cpp
index 4af84b21243..951ef773f97 100644
--- a/cpp/src/IceGrid/Parser.cpp
+++ b/cpp/src/IceGrid/Parser.cpp
@@ -8,7 +8,7 @@
 // **********************************************************************
 
 #include <IceUtil/DisableWarnings.h>
-#include <IceUtil/OutputUtil.h>
+#include <IceUtil/IceUtil.h>
 #include <IceUtil/Options.h>
 #include <Ice/Ice.h>
 #include <IceXML/Parser.h>
@@ -101,12 +101,12 @@ const char* _commandsHelp[][3] = {
 "                          node NAME or all the nodes if NAME is omitted.\n" 
 },
 { "node", "show",
-"node show [OPTIONS] NAME [stderr | stdout]\n"
-"                          Show node NAME stderr or stdout.\n"
+"node show [OPTIONS] NAME [log | stderr | stdout]\n"
+"                          Show node NAME Ice log, stderr or stdout.\n"
 "                          Options:\n"
 "                           -f | --follow: Wait for new data to be available\n"
-"                           -t N | --tail N: Print the last N lines\n"
-"                           -h N | --head N: Print the first N lines\n"
+"                           -t N | --tail N: Print the last N log messages or lines\n"
+"                           -h N | --head N: Print the first N lines (stderr and stdout only)\n"
 },
 { "node", "shutdown",
 "node shutdown NAME        Shutdown node NAME.\n" 
@@ -121,12 +121,12 @@ const char* _commandsHelp[][3] = {
 "registry ping NAME        Ping registry NAME.\n" 
 },
 { "registry", "show",
-"registry show [OPTIONS] NAME [stderr | stdout]\n" 
-"                          Show registry NAME stderr or stdout.\n" 
+"registry show [OPTIONS] NAME [log | stderr | stdout ]\n" 
+"                          Show registry NAME Ice log, stderr or stdout.\n" 
 "                          Options:\n"
-"                           -f | --follow: Wait for new data to be available\n"
-"                           -t N | --tail N: Print the last N lines\n"
-"                           -h N | --head N: Print the first N lines\n"
+"                           -f | --follow: Wait for new log or data to be available\n"
+"                           -t N | --tail N: Print the last N log messages or lines\n"
+"                           -h N | --head N: Print the first N lines (stderr and stdout only)\n"
 },
 { "registry", "shutdown",
 "registry shutdown NAME    Shutdown registry NAME.\n" 
@@ -171,12 +171,12 @@ const char* _commandsHelp[][3] = {
 "server stderr ID MESSAGE  Write MESSAGE on server ID's stderr.\n" 
 },
 { "server", "show",
-"server show [OPTIONS] ID [stderr | stdout | LOGFILE ]\n"
-"                          Show server ID stderr, stdout or log file LOGFILE.\n"
+"server show [OPTIONS] ID [log | stderr | stdout | LOGFILE ]\n"
+"                          Show server ID Ice log, stderr, stdout or log file LOGFILE.\n"
 "                          Options:\n"
 "                           -f | --follow: Wait for new data to be available\n"
-"                           -t N | --tail N: Print the last N lines\n"
-"                           -h N | --head N: Print the first N lines\n"
+"                           -t N | --tail N: Print the last N log messages or lines\n"
+"                           -h N | --head N: Print the first N lines (not available for Ice log)\n"
 },
 { "server", "enable",
 "server enable ID          Enable server ID.\n" 
@@ -243,6 +243,141 @@ const char* _commandsHelp[][3] = {
 { 0, 0, 0 }
 };
 
+
+void writeMessage(const string& message, bool indent)
+{
+    string s = message;
+
+    if(indent)
+    {
+        string::size_type idx = 0;
+        while((idx = s.find("\n", idx)) != string::npos)
+        {
+            s.insert(idx + 1, "   ");
+            ++idx;
+        }
+    }
+    
+    // TODO: Console handling on Windows
+
+    cout << s << endl;
+}
+
+void printLogMessage(const string& p, const Ice::LogMessage& logMessage)
+{
+    string prefix = p;
+
+    if(!prefix.empty())
+    {
+        prefix += ": ";
+    }
+
+    string timestamp = IceUtil::Time::microSeconds(logMessage.timestamp).toDateTime();
+            
+    switch(logMessage.type)
+    {
+        case Ice::PrintMessage:
+        {
+            writeMessage(timestamp + " " + logMessage.message, false);
+            break;
+        }
+        case Ice::TraceMessage:
+        {
+            string s = "-- " + timestamp + " " + prefix;
+            if(!logMessage.traceCategory.empty())
+            {
+                s += logMessage.traceCategory + ": ";
+            }
+            s += logMessage.message;
+            writeMessage(s, true);
+            break;
+        }
+        case Ice::WarningMessage:
+        {
+            writeMessage("!- " + timestamp + " " + prefix + "warning: " + logMessage.message, true);
+            break;
+        }
+        case Ice::ErrorMessage:
+        {
+            writeMessage("!! " + timestamp + " " + prefix + "error: " + logMessage.message, true);
+            break;
+        }
+        default:
+        {
+            assert(0);
+        }
+    }
+}
+
+
+
+class RemoteLoggerI : public Ice::RemoteLogger
+{                                               
+public:
+
+    RemoteLoggerI();
+
+    virtual void init(const string&, const Ice::LogMessageSeq&, const Ice::Current&);
+    virtual void log(const Ice::LogMessage&, const Ice::Current&);
+    
+    void destroy();
+
+private:
+
+    IceUtil::Monitor<IceUtil::Mutex> _monitor;
+    bool _initDone;
+    bool _destroyed;
+    string _prefix;
+};
+
+typedef IceUtil::Handle<RemoteLoggerI> RemoteLoggerIPtr;
+
+RemoteLoggerI::RemoteLoggerI() :
+    _initDone(false),
+    _destroyed(false)
+{
+}
+
+void
+RemoteLoggerI::init(const string& prefix, const Ice::LogMessageSeq& logMessages, const Ice::Current&)
+{    
+    IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+    if(!_destroyed)
+    {
+        _prefix = prefix;
+        
+        for(Ice::LogMessageSeq::const_iterator p = logMessages.begin(); p != logMessages.end(); ++p)
+        {
+            printLogMessage(_prefix, *p);
+        }
+        
+        _initDone = true;
+        _monitor.notifyAll();
+    }
+}
+
+void 
+RemoteLoggerI::log(const Ice::LogMessage& logMessage, const Ice::Current&)
+{
+    IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+    while(!_initDone && !_destroyed)
+    {
+        _monitor.wait();
+    }
+    if(!_destroyed)
+    {
+        printLogMessage(_prefix, logMessage);
+    }
+}
+
+void
+RemoteLoggerI::destroy()
+{
+    IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+    _destroyed = true;
+    _monitor.notifyAll();
+}
+
 }
 
 namespace IceGrid
@@ -1975,7 +2110,7 @@ Parser::listObject(const list<string>& args)
 }
 
 void
-Parser::showFile(const string& reader, const list<string>& origArgs)
+Parser::show(const string& reader, const list<string>& origArgs)
 {
     list<string> copyArgs = origArgs;
     copyArgs.push_front("icegridadmin");
@@ -2022,8 +2157,13 @@ Parser::showFile(const string& reader, const list<string>& origArgs)
             invalidCommand("can't specify both -h | --head and -t | --tail options");
             return;
         }
+        if(head && reader == "log")
+        {
+            invalidCommand("can't specify -h | --head option with log");
+            return;
+        }
+
         int lineCount = 20;
-        int maxBytes = _communicator->getProperties()->getPropertyAsIntWithDefault("Ice.MessageSizeMax", 1024) * 1024;
         if(head || tail)
         {
             if(head)
@@ -2042,8 +2182,41 @@ Parser::showFile(const string& reader, const list<string>& origArgs)
                 return;
             }
         }
+        
+        bool follow = opts.isSet("follow");
+     
+        if(head && follow)
+        {
+            invalidCommand("can't use -f | --follow option with -h | --head option");
+            return;
+        }
 
-        FileIteratorPrx it;
+        if(filename == "log")
+        {
+            showLog(id, reader, tail, follow, lineCount);
+        }
+        else
+        {
+            showFile(id, reader, filename, head, tail, follow, lineCount);
+        }
+    }
+    catch(const Ice::Exception& ex)
+    {
+        exception(ex);
+    }
+}
+
+void
+Parser::showFile(const string& id, const string& reader, const string& filename, 
+                 bool head, bool tail, bool follow, int lineCount)
+{
+    
+    int maxBytes = _communicator->getProperties()->getPropertyAsIntWithDefault("Ice.MessageSizeMax", 1024) * 1024;
+    
+    FileIteratorPrx it;
+
+    try
+    {
         if(reader == "node")
         {
             if(filename == "stderr")
@@ -2091,17 +2264,13 @@ Parser::showFile(const string& reader, const list<string>& origArgs)
                 it = _session->openServerLog(id, filename, tail ? lineCount : -1);
             }
         }
-
-        bool follow = opts.isSet("follow");
+        
         resetInterrupt();
+        Ice::StringSeq lines;
         if(head)
         {
-            if(follow)
-            {
-                invalidCommand("can't use -f | --follow option with -h | --head option");
-                return;
-            }
-
+            assert(!follow);
+            
             int i = 0;
             bool eof = false;
             while(!interrupted() && !eof && i < lineCount)
@@ -2125,7 +2294,7 @@ Parser::showFile(const string& reader, const list<string>& origArgs)
                 }
             }
         }
-
+        
         if(follow)
         {
             while(!interrupted())
@@ -2143,7 +2312,7 @@ Parser::showFile(const string& reader, const list<string>& origArgs)
                         cout << flush;
                     }
                 }
-
+                
                 if(eof)
                 {
                     Lock sync(*this);
@@ -2155,17 +2324,136 @@ Parser::showFile(const string& reader, const list<string>& origArgs)
                 }
             }
         }
-
+        
         if(lines.empty() || !lines.back().empty())
         {
             cout << endl;
         }
-
+        
         it->destroy();
     }
-    catch(const Ice::Exception& ex)
+    catch(...)
     {
-        exception(ex);
+        if(it != 0)
+        {
+            try
+            {
+                it->destroy();
+            }
+            catch(...)
+            {
+            }
+        }
+        throw;
+    }
+}
+
+void
+Parser::showLog(const string& id, const string& reader, bool tail, bool follow, int lineCount)
+{
+    cout << endl;
+
+    if(reader == "server")
+    {
+        Ice::ObjectPrx serverAdmin = _admin->getServerAdmin(id);
+
+        Ice::LoggerAdminPrx loggerAdmin;
+        try
+        {
+             loggerAdmin = Ice::LoggerAdminPrx::checkedCast(serverAdmin, "Logger");
+        }
+        catch(const Ice::Exception&)
+        {
+            loggerAdmin = 0;
+        }
+        
+        if(loggerAdmin == 0)
+        {
+            error("cannot retrieve Logger facet for server '" + id + "'");
+            return;
+        }
+        
+        if(follow)
+        {
+            Ice::ObjectPrx adminCallbackTemplate = _session->getAdminCallbackTemplate();
+            
+            if(adminCallbackTemplate == 0)
+            {
+                error("cannot retriever Callback template from IceGrid registry");
+                return;
+            }
+            
+            const Ice::EndpointSeq endpoints = adminCallbackTemplate->ice_getEndpoints(); 
+            string publishedEndpoints;
+            
+            for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p)
+            {
+                if(publishedEndpoints.empty())
+                {
+                    publishedEndpoints = (*p)->toString();
+                }
+                else
+                {
+                    publishedEndpoints += ":" + (*p)->toString();
+                }
+            }
+
+            _communicator->getProperties()->setProperty("RemoteLoggerAdapter.PublishedEndpoints", publishedEndpoints);
+            
+            Ice::ObjectAdapterPtr adapter = 
+                _communicator->createObjectAdapter("RemoteLoggerAdapter");
+            
+            _session->ice_getConnection()->setAdapter(adapter);
+
+            Ice::Identity id;
+            id.name = "RemoteLogger-" + IceUtil::generateUUID();
+            id.category = adminCallbackTemplate->ice_getIdentity().category;
+
+            RemoteLoggerIPtr servant = new RemoteLoggerI;
+            Ice::RemoteLoggerPrx prx = 
+                Ice::RemoteLoggerPrx::uncheckedCast(adapter->add(servant, id));
+            adapter->activate();
+            
+            loggerAdmin->attachRemoteLogger(prx, Ice::LogMessageTypeSeq(), Ice::StringSeq(),
+                                            tail ? lineCount : -1);
+            
+            resetInterrupt();
+            {
+                Lock lock(*this);
+                while(!_interrupted)
+                {
+                    wait();
+                }
+            }
+
+            servant->destroy();
+            adapter->destroy();
+            
+            try
+            {
+                loggerAdmin->detachRemoteLogger(prx);
+            }
+            catch(const Ice::ObjectNotExistException&)
+            {
+                // ignored
+            }
+            catch(const Ice::RemoteLoggerNotAttachedException&)
+            {
+                // ignored
+            }
+        }
+        else
+        {
+            string prefix;
+            const Ice::LogMessageSeq logMessages = 
+                loggerAdmin->getLog(Ice::LogMessageTypeSeq(), Ice::StringSeq(), 
+                                    tail ? lineCount : -1, prefix);
+            
+            for(Ice::LogMessageSeq::const_iterator p = logMessages.begin(); p != logMessages.end(); ++p)
+            {
+                printLogMessage(prefix, *p);
+            }
+        }
     }
 }
 
diff --git a/cpp/src/IceGrid/Parser.h b/cpp/src/IceGrid/Parser.h
index af22bd5aade..bfd08d10438 100644
--- a/cpp/src/IceGrid/Parser.h
+++ b/cpp/src/IceGrid/Parser.h
@@ -120,8 +120,8 @@ public:
     void describeObject(const std::list<std::string>&);
     void listObject(const std::list<std::string>&);
 
-    void showFile(const std::string&, const std::list<std::string>&);
-
+    void show(const std::string&, const std::list<std::string>&);
+    
     void showBanner();
     void showCopying();
     void showWarranty();
@@ -151,6 +151,10 @@ private:
     Parser(const Ice::CommunicatorPtr&, const AdminSessionPrx&, const AdminPrx&, bool);
     void exception(const Ice::Exception&);
 
+    void showFile(const std::string&, const std::string&, const std::string&, bool, bool, bool, int);
+    void showLog(const std::string&, const std::string&, bool, bool, int);
+    
+
     std::string _commands;
     Ice::CommunicatorPtr _communicator;
     AdminSessionPrx _session;
diff --git a/cpp/src/IceGrid/Scanner.cpp b/cpp/src/IceGrid/Scanner.cpp
index 442e3a6697c..45fded5ae27 100644
--- a/cpp/src/IceGrid/Scanner.cpp
+++ b/cpp/src/IceGrid/Scanner.cpp
@@ -1,4 +1,4 @@
-#include <IceUtil/ScannerConfig.h>
+#include "IceUtil/ScannerConfig.h" 
 
 #line 3 "lex.yy.c"
 
@@ -612,7 +612,7 @@ static int input (void );
 /* This used to be an fputs(), but since the string might contain NUL's,
  * we now use fwrite().
  */
-#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
+#define ECHO fwrite( yytext, yyleng, 1, yyout )
 #endif
 
 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
@@ -623,7 +623,7 @@ static int input (void );
 	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
 		{ \
 		int c = '*'; \
-		unsigned n; \
+		int n; \
 		for ( n = 0; n < max_size && \
 			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 			buf[n] = (char) c; \
diff --git a/cpp/test/Ice/acm/AllTests.cpp b/cpp/test/Ice/acm/AllTests.cpp
index e95c43bf607..14fb0ea57fb 100644
--- a/cpp/test/Ice/acm/AllTests.cpp
+++ b/cpp/test/Ice/acm/AllTests.cpp
@@ -85,6 +85,12 @@ public:
         }
     }
 
+    virtual string
+    getPrefix()
+    {
+        return "";
+    }
+
     virtual Ice::LoggerPtr
     cloneWithPrefix(const std::string&)
     {
diff --git a/cpp/test/Ice/admin/AllTests.cpp b/cpp/test/Ice/admin/AllTests.cpp
index 6d9d0e7c469..5eef4f47b05 100644
--- a/cpp/test/Ice/admin/AllTests.cpp
+++ b/cpp/test/Ice/admin/AllTests.cpp
@@ -15,11 +15,23 @@ using namespace std;
 using namespace Test;
 
 static void
-testFacets(const Ice::CommunicatorPtr& com)
+testFacets(const Ice::CommunicatorPtr& com, bool optionalBuiltInFacets = true)
 {
+    //
+    // Properties and Process are always created,
+    // and findAdminFacet also returns "filtered out" facets
+    //
     test(com->findAdminFacet("Properties"));
     test(com->findAdminFacet("Process"));
 
+    if(optionalBuiltInFacets)
+    {
+        //
+        // Optional built-in facets like Logger
+        // 
+        test(com->findAdminFacet("Logger"));
+    }
+    
     TestFacetPtr f1 = new TestFacetI;
     TestFacetPtr f2 = new TestFacetI;
     TestFacetPtr f3 = new TestFacetI;
@@ -68,6 +80,91 @@ testFacets(const Ice::CommunicatorPtr& com)
     }
 }
 
+class RemoteLoggerI : public Ice::RemoteLogger
+{
+public:
+    
+    RemoteLoggerI();
+
+    virtual void init(const string&, const Ice::LogMessageSeq&, const Ice::Current&);
+    virtual void log(const Ice::LogMessage&, const Ice::Current&);
+
+    void checkNextInit(const string&, const Ice::LogMessageSeq&);
+    void checkNextLog(Ice::LogMessageType, const string&, const string& = "");
+
+    void wait(int);
+
+private:
+
+    IceUtil::Monitor<IceUtil::Mutex> _monitor;
+
+    int _receivedCalls;
+
+    string _expectedPrefix;
+    Ice::LogMessageSeq _expectedInitMessages;
+    
+    Ice::LogMessageSeq _expectedLogMessages;
+};
+
+typedef IceUtil::Handle<RemoteLoggerI> RemoteLoggerIPtr;
+
+RemoteLoggerI::RemoteLoggerI() : _receivedCalls(0)
+{
+}
+
+void
+RemoteLoggerI::init(const string& prefix, const Ice::LogMessageSeq& logMessages, const Ice::Current&)
+{
+    IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+    test(prefix == _expectedPrefix);
+    test(logMessages == _expectedInitMessages);
+    _receivedCalls++;
+    _monitor.notifyAll();
+}
+
+void
+RemoteLoggerI::log(const Ice::LogMessage& logMessage, const Ice::Current&)
+{
+    IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+    Ice::LogMessage front = _expectedLogMessages.front();
+    
+    test(front.type == logMessage.type && front.message == logMessage.message &&
+         front.traceCategory == logMessage.traceCategory);
+
+    _expectedLogMessages.pop_front();
+    _receivedCalls++;
+    _monitor.notifyAll();
+}
+
+void
+RemoteLoggerI::checkNextInit(const string& prefix, const Ice::LogMessageSeq& logMessages)
+{
+    IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+    _expectedPrefix = prefix;
+    _expectedInitMessages = logMessages;
+}
+
+void
+RemoteLoggerI::checkNextLog(Ice::LogMessageType messageType, const string& message, 
+                            const string& category)
+{
+    Ice::LogMessage logMessage = { messageType, 0, category, message };
+
+    IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+    _expectedLogMessages.push_back(logMessage);
+}
+
+void
+RemoteLoggerI::wait(int calls)
+{
+    IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+    _receivedCalls -= calls;
+    while(_receivedCalls < 0)
+    {
+        _monitor.wait();
+    }
+}
+
 void
 allTests(const Ice::CommunicatorPtr& communicator)
 {
@@ -94,7 +191,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
         init.properties->setProperty("Ice.Admin.InstanceName", "Test");
         init.properties->setProperty("Ice.Admin.Facets", "Properties");
         Ice::CommunicatorPtr com = Ice::initialize(init);
-        testFacets(com);
+        testFacets(com, false);
         com->destroy();
     }
     {
@@ -102,7 +199,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
         // Test: Verify that the operations work correctly with the Admin object disabled.
         //
         Ice::CommunicatorPtr com = Ice::initialize();
-        testFacets(com);
+        testFacets(com, false);
         com->destroy();
     }
     {
@@ -204,6 +301,176 @@ allTests(const Ice::CommunicatorPtr& communicator)
     }
     cout << "ok" << endl;
 
+    cout << "testing logger facet... " << flush;
+    {
+        Ice::PropertyDict props;
+        props["Ice.Admin.Endpoints"] = "tcp -h 127.0.0.1";
+        props["Ice.Admin.InstanceName"] = "Test";
+        props["NullLogger"] = "1";
+        RemoteCommunicatorPrx com = factory->createCommunicator(props);
+
+        com->trace("testCat", "trace");
+        com->warning("warning");
+        com->error("error");
+        com->print("print");
+       
+        Ice::ObjectPrx obj = com->getAdmin();
+        Ice::LoggerAdminPrx logger = Ice::LoggerAdminPrx::checkedCast(obj, "Logger");
+        test(logger);
+
+        string prefix;   
+
+        //
+        // Get all
+        //
+        Ice::LogMessageSeq logMessages = 
+            logger->getLog(Ice::LogMessageTypeSeq(), Ice::StringSeq(), -1, prefix);
+        
+        test(logMessages.size() == 4);
+        test(prefix == "NullLogger");
+        Ice::LogMessageSeq::const_iterator p = logMessages.begin();
+        test(p->traceCategory == "testCat" && p++->message == "trace"); 
+        test(p++->message == "warning");
+        test(p++->message == "error");
+        test(p++->message == "print");
+       
+        //
+        // Get only errors and warnings
+        //
+        com->error("error2");
+        com->print("print2");
+        com->trace("testCat", "trace2");
+        com->warning("warning2");
+        
+        Ice::LogMessageTypeSeq messageTypes;
+        messageTypes.push_back(Ice::ErrorMessage);
+        messageTypes.push_back(Ice::WarningMessage);
+
+        logMessages = 
+            logger->getLog(messageTypes, Ice::StringSeq(), -1, prefix);
+        test(logMessages.size() == 4);
+        test(prefix == "NullLogger");
+
+        p = logMessages.begin();
+        while(p != logMessages.end())
+        {
+            test(p->type == Ice::ErrorMessage || p->type == Ice::WarningMessage);
+            ++p;
+        }
+        
+        //
+        // Get only errors and traces with Cat = "testCat"
+        //
+        com->trace("testCat2", "A");
+        com->trace("testCat", "trace3");
+        com->trace("testCat2", "B");
+        
+        messageTypes.clear();
+        messageTypes.push_back(Ice::ErrorMessage);
+        messageTypes.push_back(Ice::TraceMessage);
+        
+        Ice::StringSeq categories;
+        categories.push_back("testCat");
+
+        logMessages = 
+            logger->getLog(messageTypes, categories, -1, prefix);
+        test(logMessages.size() == 5);
+        test(prefix == "NullLogger");
+
+        p = logMessages.begin();
+        while(p != logMessages.end())
+        {
+            test(p->type == Ice::ErrorMessage || 
+                 (p->type == Ice::TraceMessage && p->traceCategory == "testCat"));
+            ++p;
+        }
+
+        //
+        // Same, but limited to last 2 messages (trace3 + error3)
+        //
+        com->error("error3");
+        
+        logMessages = 
+            logger->getLog(messageTypes, categories, 2, prefix);
+        test(logMessages.size() == 2);
+        test(prefix == "NullLogger");
+
+        p = logMessages.begin();
+        test(p++->message == "trace3");
+        test(p->message == "error3");
+
+        //
+        // Now, test RemoteLogger
+        //
+
+        Ice::ObjectAdapterPtr adapter = 
+            communicator->createObjectAdapterWithEndpoints("RemoteLoggerAdapter", "tcp -h localhost");
+   
+        RemoteLoggerIPtr remoteLogger = new RemoteLoggerI;
+        
+        Ice::RemoteLoggerPrx myProxy = 
+            Ice::RemoteLoggerPrx::uncheckedCast(adapter->addWithUUID(remoteLogger));
+        
+        adapter->activate();
+         
+        //
+        // No filtering
+        //
+        logMessages = logger->getLog(Ice::LogMessageTypeSeq(), Ice::StringSeq(), -1, prefix);
+        remoteLogger->checkNextInit(prefix, logMessages);
+       
+        logger->attachRemoteLogger(myProxy, Ice::LogMessageTypeSeq(), Ice::StringSeq(), -1);
+        remoteLogger->wait(1);
+
+        remoteLogger->checkNextLog(Ice::TraceMessage, "rtrace", "testCat");
+        remoteLogger->checkNextLog(Ice::WarningMessage, "rwarning");
+        remoteLogger->checkNextLog(Ice::ErrorMessage, "rerror");
+        remoteLogger->checkNextLog(Ice::PrintMessage, "rprint");
+
+        com->trace("testCat", "rtrace");
+        com->warning("rwarning");
+        com->error("rerror");
+        com->print("rprint");
+        remoteLogger->wait(4);
+
+        logger->detachRemoteLogger(myProxy);
+
+        //
+        // Use Error + Trace with "traceCat" filter with 4 limit
+        //
+        logMessages = logger->getLog(messageTypes, categories, 4, prefix);
+        test(logMessages.size() == 4);
+        remoteLogger->checkNextInit(prefix, logMessages);
+        logger->attachRemoteLogger(myProxy, messageTypes, categories, 4);
+        remoteLogger->wait(1);
+
+        remoteLogger->checkNextLog(Ice::TraceMessage, "rtrace2", "testCat");
+        remoteLogger->checkNextLog(Ice::ErrorMessage, "rerror2");
+     
+        com->warning("rwarning2");
+        com->trace("testCat", "rtrace2");
+        com->warning("rwarning3");
+        com->error("rerror2");
+        com->print("rprint2");
+        remoteLogger->wait(2);
+
+        //
+        // Attempt reconnection with slightly different proxy
+        //
+        try
+        {
+            logger->attachRemoteLogger(myProxy->ice_oneway(), messageTypes, categories, 4);
+            test(false);
+        }
+        catch(const Ice::RemoteLoggerAlreadyAttachedException&)
+        {
+            // expected
+        }
+
+        com->destroy();
+    }
+    cout << "ok" << endl;
+
     cout << "testing custom facet... " << flush;
     {
         //
diff --git a/cpp/test/Ice/admin/Test.ice b/cpp/test/Ice/admin/Test.ice
index 786ec48fe81..97df7090b7a 100644
--- a/cpp/test/Ice/admin/Test.ice
+++ b/cpp/test/Ice/admin/Test.ice
@@ -21,6 +21,14 @@ interface RemoteCommunicator
 
     Ice::PropertyDict getChanges();
 
+    //
+    // Logger operations
+    //
+    void print(string message);
+    void trace(string category, string message);
+    void warning(string message);
+    void error(string message);
+
     void shutdown();
 
     void waitForShutdown();
diff --git a/cpp/test/Ice/admin/TestI.cpp b/cpp/test/Ice/admin/TestI.cpp
index 43ff704d695..56e32e99d36 100644
--- a/cpp/test/Ice/admin/TestI.cpp
+++ b/cpp/test/Ice/admin/TestI.cpp
@@ -12,6 +12,44 @@
 
 using namespace std;
 
+namespace
+{
+
+//
+// A no-op Logger, used when testing the Logger Admin
+//
+
+class NullLogger : public Ice::Logger
+{
+public:
+
+    virtual void print(const string&)
+    {}
+
+    virtual void trace(const string&, const string&)
+    {}
+
+    virtual void warning(const string&)
+    {}
+
+    virtual void error(const string&)
+    {}
+
+    virtual string getPrefix()
+    {
+        return "NullLogger";
+    }
+    
+    virtual Ice::LoggerPtr cloneWithPrefix(const string&)
+    {
+        return new NullLogger;
+    }
+};
+
+}
+
+
+
 RemoteCommunicatorI::RemoteCommunicatorI(const Ice::CommunicatorPtr& communicator) :
     _communicator(communicator), _called(false)
 {
@@ -46,6 +84,28 @@ RemoteCommunicatorI::getChanges(const Ice::Current&)
 }
 
 void
+RemoteCommunicatorI::print(const std::string& message, const Ice::Current&)
+{
+    _communicator->getLogger()->print(message);
+}
+void
+RemoteCommunicatorI::trace(const std::string& category,
+                           const std::string& message, const Ice::Current&)
+{
+    _communicator->getLogger()->trace(category, message);
+}
+void
+RemoteCommunicatorI::warning(const std::string& message, const Ice::Current&)
+{
+    _communicator->getLogger()->warning(message);
+}
+void
+RemoteCommunicatorI::error(const std::string& message, const Ice::Current&)
+{
+    _communicator->getLogger()->error(message);
+}
+
+void
 RemoteCommunicatorI::shutdown(const Ice::Current&)
 {
     _communicator->shutdown();
@@ -90,6 +150,11 @@ RemoteCommunicatorFactoryI::createCommunicator(const Ice::PropertyDict& props, c
         init.properties->setProperty(p->first, p->second);
     }
 
+    if(init.properties->getPropertyAsInt("NullLogger") != 0)
+    {
+        init.logger = new NullLogger;
+    }
+
     //
     // Initialize a new communicator.
     //
diff --git a/cpp/test/Ice/admin/TestI.h b/cpp/test/Ice/admin/TestI.h
index 7c1a2284de9..41deeee308d 100644
--- a/cpp/test/Ice/admin/TestI.h
+++ b/cpp/test/Ice/admin/TestI.h
@@ -23,6 +23,12 @@ public:
 
     virtual Ice::ObjectPrx getAdmin(const Ice::Current&);
     virtual Ice::PropertyDict getChanges(const Ice::Current&);
+
+    virtual void print(const std::string&, const Ice::Current&);
+    virtual void trace(const std::string&, const std::string&, const Ice::Current&);
+    virtual void warning(const std::string&, const Ice::Current&);
+    virtual void error(const std::string&, const Ice::Current&);
+
     virtual void shutdown(const Ice::Current&);
     virtual void waitForShutdown(const Ice::Current&);
     virtual void destroy(const Ice::Current&);
diff --git a/cpp/test/IceBox/admin/AllTests.cpp b/cpp/test/IceBox/admin/AllTests.cpp
index 891a9d10abf..e0828dd8f7b 100644
--- a/cpp/test/IceBox/admin/AllTests.cpp
+++ b/cpp/test/IceBox/admin/AllTests.cpp
@@ -47,12 +47,13 @@ allTests(const Ice::CommunicatorPtr& communicator)
         // Test: PropertiesAdmin::getProperties()
         //
         Ice::PropertyDict pd = pa->getPropertiesForPrefix("");
-        test(pd.size() == 5);
+        test(pd.size() == 6);
         test(pd["Prop1"] == "1");
         test(pd["Prop2"] == "2");
         test(pd["Prop3"] == "3");
         test(pd["Ice.Config"] == "config.service");
         test(pd["Ice.ProgramName"] == "IceBox-TestService");
+        test(pd["Ice.Admin.Logger"] == "IceBox.Service.TestService.Logger");
 
         Ice::PropertyDict changes;