More work

14 files changed, 718 insertions, 205 deletions

diff --git a/cpp/src/Ice/ConnectionFactory.cpp b/cpp/src/Ice/ConnectionFactory.cpp
index 21e642ce572..1508e3cc911 100755
--- a/cpp/src/Ice/ConnectionFactory.cpp
+++ b/cpp/src/Ice/ConnectionFactory.cpp
@@ -125,6 +125,14 @@ IceInternal::OutgoingConnectionFactory::destroy()
 }
 
 void
+IceInternal::OutgoingConnectionFactory::updateConnectionObservers()
+{
+    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+    for_each(_connections.begin(), _connections.end(),
+             Ice::secondVoidMemFun<const ConnectorPtr, ConnectionI>(&ConnectionI::updateObserver));
+}
+
+void
 IceInternal::OutgoingConnectionFactory::waitUntilFinished()
 {
     multimap<ConnectorPtr, ConnectionIPtr> connections;
@@ -1199,6 +1207,13 @@ IceInternal::IncomingConnectionFactory::destroy()
 }
 
 void
+IceInternal::IncomingConnectionFactory::updateConnectionObservers()
+{
+    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+    for_each(_connections.begin(), _connections.end(), Ice::voidMemFun(&ConnectionI::updateObserver));
+}
+
+void
 IceInternal::IncomingConnectionFactory::waitUntilHolding() const
 {
     set<ConnectionIPtr> connections;
diff --git a/cpp/src/Ice/ConnectionFactory.h b/cpp/src/Ice/ConnectionFactory.h
index 846248b8e40..ff5623f433e 100644
--- a/cpp/src/Ice/ConnectionFactory.h
+++ b/cpp/src/Ice/ConnectionFactory.h
@@ -54,6 +54,8 @@ public:
 
     void destroy();
 
+    void updateConnectionObservers();
+
     void waitUntilFinished();
 
     Ice::ConnectionIPtr create(const std::vector<EndpointIPtr>&, bool, Ice::EndpointSelectionType, bool&);
@@ -164,6 +166,8 @@ public:
     void hold();
     void destroy();
 
+    void updateConnectionObservers();
+
     void waitUntilHolding() const;
     void waitUntilFinished();
 
diff --git a/cpp/src/Ice/ConnectionI.cpp b/cpp/src/Ice/ConnectionI.cpp
index 7e619ba2e0f..46369c022d0 100644
--- a/cpp/src/Ice/ConnectionI.cpp
+++ b/cpp/src/Ice/ConnectionI.cpp
@@ -119,14 +119,14 @@ private:
     ConnectionIPtr _connection;
 };
 
-Ice::ConnectionState connectionStateMap[] = {
-    Ice::ConnectionStateInitializing, // StateNotInitialized
-    Ice::ConnectionStateInitializing, // StateNotValidated
-    Ice::ConnectionStateActive,       // StateActive
-    Ice::ConnectionStateHolding,      // StateHolding
-    Ice::ConnectionStateClosing,      // StateClosing
-    Ice::ConnectionStateClosed,       // StateClosed
-    Ice::ConnectionStateClosed,       // StateFinished
+Ice::ObserverConnectionState connectionStateMap[] = {
+    Ice::ObserverConnectionStateInitializing, // StateNotInitialized
+    Ice::ObserverConnectionStateInitializing, // StateNotValidated
+    Ice::ObserverConnectionStateActive,       // StateActive
+    Ice::ObserverConnectionStateHolding,      // StateHolding
+    Ice::ObserverConnectionStateClosing,      // StateClosing
+    Ice::ObserverConnectionStateClosed,       // StateClosed
+    Ice::ObserverConnectionStateClosed,       // StateFinished
 };
 
 }
@@ -448,6 +448,14 @@ Ice::ConnectionI::waitUntilFinished()
 }
 
 void
+Ice::ConnectionI::updateObserver()
+{
+    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+    assert(_instance->initializationData().observerResolver);
+    _observer = _instance->initializationData().observerResolver->getConnectionObserver(this, _observer);
+}
+
+void
 Ice::ConnectionI::monitor(const IceUtil::Time& now)
 {
     IceUtil::Monitor<IceUtil::Mutex>::TryLock sync(*this);
@@ -1908,7 +1916,7 @@ Ice::ConnectionI::ConnectionI(const CommunicatorPtr& communicator,
 
         if(_instance->initializationData().observerResolver)
         {
-            _observer = _instance->initializationData().observerResolver->getConnectionObserver(_observer, this);
+            _observer = _instance->initializationData().observerResolver->getConnectionObserver(this, _observer);
         }
     }
     catch(const IceUtil::Exception&)
@@ -2136,8 +2144,8 @@ Ice::ConnectionI::setState(State state)
 
     if(_observer)
     {
-        Ice::ConnectionState oldState = connectionStateMap[static_cast<int>(_state)];
-        Ice::ConnectionState newState = connectionStateMap[static_cast<int>(state)];
+        Ice::ObserverConnectionState oldState = connectionStateMap[static_cast<int>(_state)];
+        Ice::ObserverConnectionState newState = connectionStateMap[static_cast<int>(state)];
         if(oldState != newState)
         {
             _observer->stateChanged(oldState, newState);
diff --git a/cpp/src/Ice/ConnectionI.h b/cpp/src/Ice/ConnectionI.h
index 246cf72e9f2..94ff0432fdb 100644
--- a/cpp/src/Ice/ConnectionI.h
+++ b/cpp/src/Ice/ConnectionI.h
@@ -96,6 +96,8 @@ public:
     void waitUntilHolding() const;
     void waitUntilFinished(); // Not const, as this might close the connection upon timeout.
 
+    void updateObserver();
+
     void monitor(const IceUtil::Time&);
 
     bool sendRequest(IceInternal::Outgoing*, bool, bool);
diff --git a/cpp/src/Ice/Instance.cpp b/cpp/src/Ice/Instance.cpp
index 26099f3b815..394fbee017c 100644
--- a/cpp/src/Ice/Instance.cpp
+++ b/cpp/src/Ice/Instance.cpp
@@ -35,8 +35,10 @@
 #include <Ice/LoggerUtil.h>
 #include <IceUtil/StringUtil.h>
 #include <Ice/PropertiesI.h>
-#include <IceUtil/UUID.h>
 #include <Ice/Communicator.h>
+#include <Ice/Observer.h>
+
+#include <IceUtil/UUID.h>
 #include <IceUtil/Mutex.h>
 #include <IceUtil/MutexPtrLock.h>
 
@@ -102,6 +104,33 @@ public:
 
 Init init;
 
+class ObserverUpdaterI : public Ice::ObserverUpdater
+{
+public:
+
+    ObserverUpdaterI(InstancePtr instance) : _instance(instance)
+    {
+    }
+
+    void updateConnectionObservers()
+    {
+        _instance->outgoingConnectionFactory()->updateConnectionObservers();
+        _instance->objectAdapterFactory()->updateConnectionObservers();
+    }
+
+    void updateThreadObservers()
+    {
+    }
+
+    void updateThreadPoolThreadObservers()
+    {
+    }
+
+private:
+
+    InstancePtr _instance;
+};
+
 }
 
 IceUtil::Shared* IceInternal::upCast(Instance* p) { return p; }
@@ -1005,7 +1034,6 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi
         
         _retryQueue = new RetryQueue(this);
 
-
         if(_initData.wstringConverter == 0)
         {
             _initData.wstringConverter = new UnicodeWstringConverter();
@@ -1082,6 +1110,11 @@ IceInternal::Instance::~Instance()
 void
 IceInternal::Instance::finishSetup(int& argc, char* argv[])
 {
+    if(_initData.observerResolver)
+    {
+        _initData.observerResolver->setObserverUpdater(new ObserverUpdaterI(this));
+    }
+
     //
     // Load plug-ins.
     //
diff --git a/cpp/src/Ice/MetricsAdminI.cpp b/cpp/src/Ice/MetricsAdminI.cpp
index c30e298bafb..1198453c19f 100644
--- a/cpp/src/Ice/MetricsAdminI.cpp
+++ b/cpp/src/Ice/MetricsAdminI.cpp
@@ -11,8 +11,39 @@
 
 using namespace std;
 using namespace Ice;
-using namespace IceMetrics;
+using namespace IceMX;
 
+namespace 
+{
+
+struct MOCompare
+{
+    bool operator()(const pair<MetricsObjectPtr, IceUtil::Mutex*>& lhs, 
+                    const pair<MetricsObjectPtr, IceUtil::Mutex*>& rhs)
+    { 
+        return lhs.first.get() < rhs.first.get();
+    }
+};
+
+NameValueDict
+parseRule(const ::Ice::PropertiesPtr& properties, const string& name)
+{
+    NameValueDict dict;
+    PropertyDict rules = properties->getPropertiesForPrefix(name + '.');
+    for(PropertyDict::const_iterator p = rules.begin(); p != rules.end(); ++p)
+    {
+        dict.insert(make_pair(p->first.substr(name.size() + 1), p->second));
+    }
+    return dict;
+}
+
+bool
+match(const string& value, const string& expr)
+{
+    return true; // TODO
+}
+
+}
 
 MetricsMap::MetricsMap(const string& groupBy, const NameValueDict& accept, const NameValueDict& reject) : 
     _accept(accept), _reject(reject)
@@ -30,22 +61,22 @@ MetricsObjectSeq
 MetricsMap::getMetricsObjects() const
 {
     MetricsObjectSeq objects;
-    for(map<string, MetricsObjectPtr>::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
+    for(map<string, EntryPtr>::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
     {
-        // TODO: Fix ice_clone!
-        objects.push_back(dynamic_cast<MetricsObject*>(p->second->ice_clone().get()));
+        // TODO: Fix ice_clone to use a co-variant type.
+        objects.push_back(dynamic_cast<MetricsObject*>(p->second->object->ice_clone().get()));
     }
     return objects;
 }
 
-MetricsMap::Entry
-MetricsMap::getMatching(const MetricsHelper& helper)
+pair<MetricsObjectPtr, IceUtil::Mutex*>
+MetricsMap::getMatching(const ObjectHelper& helper)
 {
     for(map<string, string>::const_iterator p = _accept.begin(); p != _accept.end(); ++p)
     {
         if(!match(helper(p->first), p->second))
         {
-            return MetricsMap::Entry();
+            return make_pair(MetricsObjectPtr(), static_cast<IceUtil::Mutex*>(0));
         }
     }
     
@@ -53,7 +84,7 @@ MetricsMap::getMatching(const MetricsHelper& helper)
     {
         if(match(helper(p->first), p->second))
         {
-            return MetricsMap::Entry();
+            return make_pair(MetricsObjectPtr(), static_cast<IceUtil::Mutex*>(0));
         }
     }
     
@@ -65,22 +96,13 @@ MetricsMap::getMatching(const MetricsHelper& helper)
     }
 
     string key = os.str();
-    map<string, Entry>::const_iterator p = _objects.find(key);
+    map<string, EntryPtr>::const_iterator p = _objects.find(key);
     if(p == _objects.end())
     {
-        Entry e;
-        e.object = helper.newMetricsObject();
-        e.object->id = key;
-        e.map = this;
-        p = _objects.insert(make_pair(os.str(), e)).first;
+        p = _objects.insert(make_pair(os.str(), new Entry(helper.newMetricsObject()))).first;
+        p->second->object->id = key;
     }
-    return p->second;
-}
-
-bool
-MetricsMap::match(const string& value, const string& expr) const
-{
-    return true; // TODO
+    return make_pair(p->second->object, &p->second->mutex);
 }
     
 MetricsView::MetricsView()
@@ -103,48 +125,132 @@ MetricsObjectSeqDict
 MetricsView::getMetricsObjects() const
 {
     MetricsObjectSeqDict metrics;
-    for(map<string, MetricsMapPtr>::const_iterator p = _maps.begin(); p != _maps.end(); ++p)
+    if(_enabled)
     {
-        metrics.insert(make_pair(p->first, p->second->getMetricsObjects()));
+        for(map<string, MetricsMapPtr>::const_iterator p = _maps.begin(); p != _maps.end(); ++p)
+        {
+            metrics.insert(make_pair(p->first, p->second->getMetricsObjects()));
+        }
     }
     return metrics;
 }
 
-MetricsMap::Entry
-MetricsView::getMatching(const string& cl, const MetricsHelper& helper) const
+pair<MetricsObjectPtr, IceUtil::Mutex*>
+MetricsView::getMatching(const string& mapName, const ObjectHelper& helper) const
 {
-    map<string, MetricsMapPtr>::const_iterator p = _maps.find(cl);
-    if(p != _maps.end())
+    if(_enabled)
+    {
+        map<string, MetricsMapPtr>::const_iterator p = _maps.find(mapName);
+        if(p != _maps.end())
+        {
+            return p->second->getMatching(helper);
+        }
+    }
+    return make_pair(MetricsObjectPtr(), static_cast<IceUtil::Mutex*>(0));
+}
+
+vector<string>
+MetricsView::getMaps() const
+{
+    vector<string> maps;
+    for(map<string, MetricsMapPtr>::const_iterator p = _maps.begin(); p != _maps.end(); ++p)
+    {
+        maps.push_back(p->first);
+    }
+    return maps;
+}
+
+MetricsAdminI::MetricsAdminI(const PropertiesPtr& properties)
+{
+    const string viewsPrefix = "Ice.MetricsView.";
+    
+    vector<string> defaultMaps;
+    defaultMaps.push_back("Connection");
+    defaultMaps.push_back("Thread");
+    defaultMaps.push_back("ThreadPoolThread");
+    defaultMaps.push_back("Request");
+    
+    PropertyDict views = properties->getPropertiesForPrefix(viewsPrefix);
+    for(PropertyDict::const_iterator p = views.begin(); p != views.end(); ++p)
     {
-        return p->second->getMatching(helper);
+        string viewName = p->first.substr(viewsPrefix.size());
+        string::size_type dotPos = viewName.find('.');
+        if(dotPos != string::npos)
+        {
+            viewName = viewName.substr(0, dotPos);
+        }
+        
+        MetricsViewPtr view = new MetricsView();
+        _views.insert(make_pair(viewName, view));
+
+        view->setEnabled(properties->getPropertyAsIntWithDefault(viewsPrefix + viewName, 1) > 0);
+        
+        int mapsCount = 0;
+        const string mapsPrefix = viewsPrefix + viewName + '.';
+        PropertyDict maps = properties->getPropertiesForPrefix(mapsPrefix);
+        for(PropertyDict::const_iterator q = maps.begin(); q != maps.end(); ++q)
+        {
+            string mapName = q->first.substr(mapsPrefix.size());
+            dotPos = mapName.find('.');
+            if(dotPos != string::npos)
+            {
+                mapName = mapName.substr(0, dotPos);
+            }
+            
+            if(mapName == "GroupBy" || mapName == "Accept" || mapName == "Reject")
+            {
+                continue; // Those aren't maps.
+            }
+            
+            ++mapsCount;
+            
+            string groupBy = properties->getPropertyWithDefault(mapsPrefix + mapName + ".GroupBy", "parent");
+            NameValueDict accept = parseRule(properties, mapsPrefix + mapName + ".Accept");
+            NameValueDict reject = parseRule(properties, mapsPrefix + mapName + ".Reject");
+            addMapToView(viewName, mapName, groupBy, accept, reject);
+        }
+
+        //
+        // If no maps were defined explicitly, add default maps.
+        //
+        if(mapsCount == 0)
+        {
+            string groupBy = properties->getPropertyWithDefault(viewsPrefix + viewName + ".GroupBy", "parent");
+            NameValueDict accept = parseRule(properties, viewsPrefix + viewName + ".Accept");
+            NameValueDict reject = parseRule(properties, viewsPrefix + viewName + ".Reject");
+            for(vector<string>::const_iterator p = defaultMaps.begin(); p != defaultMaps.end(); ++p)
+            {
+                addMapToView(viewName, *p, groupBy, accept, reject);
+            }
+        }
     }
-    return MetricsMap::Entry()
 }
 
 void
-MetricsAdminI::addUpdater(const string& cl, const ObjectObserverUpdaterPtr& updater)
+MetricsAdminI::addUpdater(const string& mapName, const ObjectObserverUpdaterPtr& updater)
 {
-    _updaters.insert(make_pair(cl, updater));
+    _updaters.insert(make_pair(mapName, updater));
 }
 
-vector<MetricsMap::Entry>
-MetricsAdminI::getMatching(const string& cl, const MetricsHelper& helper) const
+vector<pair<MetricsObjectPtr, IceUtil::Mutex*> >
+MetricsAdminI::getMatching(const string& mapName, const ObjectHelper& helper) const
 {
     Lock sync(*this);
-    vector<MetricsMap::Entry> objects;
+    vector<pair<MetricsObjectPtr, IceUtil::Mutex*> > objects;
     for(map<string, MetricsViewPtr>::const_iterator p = _views.begin(); p != _views.end(); ++p)
     {
-        MetricsMap::Entry e = p->second->getMatching(cl, helper);
-        if(e.object)
+        pair<MetricsObjectPtr, IceUtil::Mutex*> e = p->second->getMatching(mapName, helper);
+        if(e.first)
         {
             objects.push_back(e);
         }
     }
+    sort(objects.begin(), objects.end(), MOCompare());
     return objects;
 }
 
 MetricsObjectSeqDict
-MetricsAdminI::getMetrics(const string& view, const Ice::Current&)
+MetricsAdminI::getMetricsMaps(const string& view, const ::Ice::Current&)
 {
     Lock sync(*this);
     std::map<string, MetricsViewPtr>::const_iterator p = _views.find(view);
@@ -156,24 +262,27 @@ MetricsAdminI::getMetrics(const string& view, const Ice::Current&)
 }
 
 MetricsObjectSeqDictDict 
-MetricsAdminI::getAllMetrics(const Ice::Current&)
+MetricsAdminI::getAllMetricsMaps(const ::Ice::Current&)
 {
     Lock sync(*this);
     MetricsObjectSeqDictDict metrics;
     for(map<string, MetricsViewPtr>::const_iterator p = _views.begin(); p != _views.end(); ++p)
     {
-        metrics.insert(make_pair(p->first, p->second->getMetricsObjects()));
+        if(p->second->isEnabled())
+        {
+            metrics.insert(make_pair(p->first, p->second->getMetricsObjects()));
+        }
     }
     return metrics;
 }
 
 void
-MetricsAdminI::addClassToView(const string& view, 
-                              const string& cl, 
-                              const string& groupBy, 
-                              const NameValueDict& accept, 
-                              const NameValueDict& reject,
-                              const Ice::Current&)
+MetricsAdminI::addMapToView(const string& view, 
+                            const string& mapName, 
+                            const string& groupBy, 
+                            const NameValueDict& accept, 
+                            const NameValueDict& reject,
+                            const ::Ice::Current&)
 {
     {
         Lock sync(*this);
@@ -182,17 +291,56 @@ MetricsAdminI::addClassToView(const string& view,
         {
             p = _views.insert(make_pair(view, new MetricsView())).first;
         }
-        p->second->add(cl, groupBy, accept, reject);
+        p->second->add(mapName, groupBy, accept, reject);
+    }
+    _updaters[mapName]->update();
+}
+
+void
+MetricsAdminI::removeMapFromView(const string& view, const string& mapName, const ::Ice::Current&)
+{
+    {
+        Lock sync(*this);
+        map<string, MetricsViewPtr>::const_iterator p = _views.find(view);
+        if(p == _views.end())
+        {
+            throw UnknownMetricsView();
+        }
+        p->second->remove(mapName);
     }
-    _updaters[cl]->update();
+    _updaters[mapName]->update();
+}
+
+void
+MetricsAdminI::enableView(const string& view, const ::Ice::Current&)
+{
+    setViewEnabled(view, true);
 }
 
 void
-MetricsAdminI::removeClassFromView(const string& view, const string& cl, const Ice::Current&)
+MetricsAdminI::disableView(const string& view, const ::Ice::Current&)
 {
+    setViewEnabled(view, false);
+}
+
+void
+MetricsAdminI::setViewEnabled(const string& view, bool enabled)
+{
+    vector<string> maps;
     {
         Lock sync(*this);
-        _views.erase(cl);
+        map<string, MetricsViewPtr>::const_iterator p = _views.find(view);
+        if(p == _views.end())
+        {
+            throw UnknownMetricsView();
+        }
+        p->second->setEnabled(enabled);
+        maps = p->second->getMaps();
+    }
+    for(vector<string>::const_iterator p = maps.begin(); p != maps.end(); ++p)
+    {
+        _updaters[*p]->update();
     }
-    _updaters[cl]->update();
 }
+
+
diff --git a/cpp/src/Ice/MetricsAdminI.h b/cpp/src/Ice/MetricsAdminI.h
index a021ae77845..c0b76bd2324 100644
--- a/cpp/src/Ice/MetricsAdminI.h
+++ b/cpp/src/Ice/MetricsAdminI.h
@@ -11,73 +11,76 @@
 #define ICE_METRICSADMIN_I_H
 
 #include <Ice/Metrics.h>
-#include <Ice/Stats.h>
+#include <Ice/Properties.h>
 
 #include <Ice/MetricsObserverI.h>
 
-namespace IceMetrics
+namespace IceMX
 {
 
-class MetricsHelper
+class MetricsMap : public IceUtil::Shared
 {
-public:
-
-    virtual std::string operator()(const std::string&) const = 0;
-
-    virtual MetricsObjectPtr newMetricsObject() const = 0;
-};
-
-class MetricsMap : public IceUtil::Shared, IceUtil::Mutex
-{
-public:
-
-    struct Entry
+    class Entry : public IceUtil::Shared
     {
-        MetricsObjectPtr object;
-        MetricsMapPtr map;
-
-        bool operator<(const Entry& e)
+    public:
+        Entry(const MetricsObjectPtr& object) : object(object)
         {
-            return object < e.object;
         }
+        
+        MetricsObjectPtr object;
+        IceUtil::Mutex mutex;
     };
-    
+    typedef IceUtil::Handle<Entry> EntryPtr;
+
+public:
+
     MetricsMap(const std::string&, const NameValueDict&, const NameValueDict&);
 
     void destroy();
 
     MetricsObjectSeq getMetricsObjects() const;
 
-    MetricsObjectPtr getMatching(const MetricsHelper&);
+    std::pair<MetricsObjectPtr, IceUtil::Mutex*> getMatching(const ObjectHelper&);
 
 private:
 
-    bool match(const std::string&, const std::string&) const;
-
     const std::vector<std::string> _groupByAttributes;
     const std::vector<std::string> _groupBySeparators;
     const NameValueDict _accept;
     const NameValueDict _reject;
-    std::map<std::string, MetricsObjectPtr> _objects;
+    std::map<std::string, EntryPtr> _objects;
 };
 typedef IceUtil::Handle<MetricsMap> MetricsMapPtr;
 
 class MetricsView : public IceUtil::Shared
 {
 public:
-
+    
     MetricsView();
 
+    void setEnabled(bool enabled)
+    {
+        _enabled = enabled;
+    }
+
+    bool isEnabled() const 
+    {
+        return _enabled;
+    }
+
     void add(const std::string&, const std::string&, const NameValueDict&, const NameValueDict&);
     void remove(const std::string&);
 
     MetricsObjectSeqDict getMetricsObjects() const;
 
-    MetricsObjectPtr getMatching(const std::string&, const MetricsHelper&) const;
+    std::pair<MetricsObjectPtr, IceUtil::Mutex*> getMatching(const std::string&, const ObjectHelper&) const;
+
+    std::vector<std::string> getMaps() const;
 
 private:
 
     std::map<std::string, MetricsMapPtr> _maps;
+    bool _enabled;
 };
 typedef IceUtil::Handle<MetricsView> MetricsViewPtr;
 
@@ -85,19 +88,27 @@ class MetricsAdminI : public MetricsAdmin, public IceUtil::Mutex
 {
 public:
 
-    MetricsObjectSeq getMatching(const std::string&, const MetricsHelper&) const;
+    MetricsAdminI(const ::Ice::PropertiesPtr&);
+
+    std::vector<std::pair<MetricsObjectPtr, IceUtil::Mutex*> > getMatching(const std::string&, 
+                                                                           const ObjectHelper&) const;
     void addUpdater(const std::string&, const ObjectObserverUpdaterPtr&);
 
-    virtual MetricsObjectSeqDict getMetrics(const std::string&, const Ice::Current&);
-    virtual MetricsObjectSeqDictDict getAllMetrics(const Ice::Current&);
+    virtual MetricsObjectSeqDict getMetricsMaps(const std::string&, const ::Ice::Current&);
+    virtual MetricsObjectSeqDictDict getAllMetricsMaps(const ::Ice::Current&);
+
+    virtual void addMapToView(const std::string&, const std::string&, const std::string&, const NameValueDict&, 
+                                const NameValueDict&, const ::Ice::Current& = ::Ice::Current());
 
-    virtual void addClassToView(const std::string&, const std::string&, const std::string&, const NameValueDict&, 
-                                const NameValueDict&, const Ice::Current&);
+    virtual void removeMapFromView(const std::string&, const std::string&, const ::Ice::Current&);
 
-    virtual void removeClassFromView(const std::string&, const std::string&, const Ice::Current&);
+    virtual void enableView(const std::string&, const ::Ice::Current&);
+    virtual void disableView(const std::string&, const ::Ice::Current&);
 
 private:
 
+    void setViewEnabled(const std::string&, bool);
+
     std::map<std::string, MetricsViewPtr> _views;
     std::map<std::string, ObjectObserverUpdaterPtr> _updaters;
 };
diff --git a/cpp/src/Ice/MetricsObserverI.cpp b/cpp/src/Ice/MetricsObserverI.cpp
index c3e51b170ba..2e031e89b8c 100644
--- a/cpp/src/Ice/MetricsObserverI.cpp
+++ b/cpp/src/Ice/MetricsObserverI.cpp
@@ -10,35 +10,86 @@
 #include <Ice/MetricsObserverI.h>
 #include <Ice/MetricsAdminI.h>
 
+#include <Ice/Connection.h>
+#include <Ice/Endpoint.h>
+
 using namespace std;
 using namespace Ice;
-using namespace IceMetrics;
+using namespace IceMX;
+using namespace IceMX::Ice;
 
 namespace 
 {
 
-class ConnectionMetricsHelper : public MetricsHelper
+
+class ConnectionHelper : public ObjectHelperT<ConnectionMetricsObject>
 {
 public:
     
-    ConnectionMetricsHelper(const ConnectionPtr& con) : _connection(con)
+    ConnectionHelper(const ConnectionPtr& con) : _connection(con)
     {
     }
 
-    virtual string operator()(const string& attribute) const
+    virtual string operator()(const string&) const;
+
+private:
+
+    friend class ConnectionAttributeResolver;
+
+    ::Ice::ConnectionInfo*
+    getConnectionInfo() const
     {
-        return ""; // TODO: return attribute value
+        return _connection->getInfo().get();
     }
-    
-    virtual MetricsObjectPtr newMetricsObject() const
+
+    ::Ice::EndpointInfo*
+    getEndpointInfo() const
     {
-        return new ConnectionMetricsObject();
+        return _connection->getEndpoint()->getInfo().get();
     }
-        
-private:
     
-    Ice::ConnectionPtr _connection;
+    ::Ice::ConnectionPtr _connection;
+};
+
+
+class ConnectionAttributeResolver : public ObjectAttributeResolverT<ConnectionHelper>
+{
+public:
+
+    ConnectionAttributeResolver()
+    {
+        //add("connectionId")
+
+        add("incoming", &ConnectionHelper::getConnectionInfo, &ConnectionInfo::incoming);
+        add("adapterName", &ConnectionHelper::getConnectionInfo, &ConnectionInfo::adapterName);
+
+        add("localHost", &ConnectionHelper::getConnectionInfo, &IPConnectionInfo::localAddress);
+        add("localPort", &ConnectionHelper::getConnectionInfo, &IPConnectionInfo::localPort);
+        add("remoteHost", &ConnectionHelper::getConnectionInfo, &IPConnectionInfo::remoteAddress);
+        add("remotePort", &ConnectionHelper::getConnectionInfo, &IPConnectionInfo::remotePort);
+
+        add("mcastHost", &ConnectionHelper::getConnectionInfo, &UDPConnectionInfo::mcastAddress);
+        add("mcastPort", &ConnectionHelper::getConnectionInfo, &UDPConnectionInfo::mcastPort);
+
+        add("endpointType", &ConnectionHelper::getEndpointInfo, &EndpointInfo::type);
+        add("endpointIsDatagram", &ConnectionHelper::getEndpointInfo, &EndpointInfo::datagram);
+        add("endpointIsSecure", &ConnectionHelper::getEndpointInfo, &EndpointInfo::secure);
+        add("endpointProtocolVersion", &ConnectionHelper::getEndpointInfo, &EndpointInfo::protocol);
+        add("endpointEncodingVersion", &ConnectionHelper::getEndpointInfo, &EndpointInfo::encoding);
+        add("endpointTimeout", &ConnectionHelper::getEndpointInfo, &EndpointInfo::timeout);
+        add("endpointCompress", &ConnectionHelper::getEndpointInfo, &EndpointInfo::compress);
+
+        add("endpointHost", &ConnectionHelper::getEndpointInfo, &IPEndpointInfo::host);
+        add("endpointPort", &ConnectionHelper::getEndpointInfo, &IPEndpointInfo::port);
+    }
 };
+ConnectionAttributeResolver connectionAttributes;
+
+string
+ConnectionHelper::operator()(const string& name) const
+{
+    return connectionAttributes(this, name);
+}
 
 }
 
@@ -64,50 +115,49 @@ ConnectionObserverI::detach()
     {
         void operator()(const ConnectionMetricsObjectPtr& v)
         {
-            ++v->total;
-            ++v->current;
-            ++v->initializing;
+            --v->current;
+            --v->closed;
         }
     };
     forEach(Detach());
 }
 
 void
-ConnectionObserverI::stateChanged(ConnectionState oldState, ConnectionState newState)
+ConnectionObserverI::stateChanged(ObserverConnectionState oldState, ObserverConnectionState newState)
 {
     struct StateChanged 
     {
-        StateChanged(ConnectionState oldState, ConnectionState newState) : 
+        StateChanged(ObserverConnectionState oldState, ObserverConnectionState newState) : 
             oldState(oldState), newState(newState)
         {
         }
 
         void operator()(const ConnectionMetricsObjectPtr& v)
         {
-            --(v.get()->*getConnectionStateMetric(oldState));
-            ++(v.get()->*getConnectionStateMetric(newState));
+            --(v.get()->*getObserverConnectionStateMetric(oldState));
+            ++(v.get()->*getObserverConnectionStateMetric(newState));
         }
 
         int ConnectionMetricsObject::*
-        getConnectionStateMetric(ConnectionState s)
+        getObserverConnectionStateMetric(ObserverConnectionState s)
         {
             switch(s)
             {
-            case ConnectionStateInitializing:
+            case ObserverConnectionStateInitializing:
                 return &ConnectionMetricsObject::initializing;
-            case ConnectionStateActive:
+            case ObserverConnectionStateActive:
                 return &ConnectionMetricsObject::active;
-            case ConnectionStateHolding:
+            case ObserverConnectionStateHolding:
                 return &ConnectionMetricsObject::holding;
-            case ConnectionStateClosing:
+            case ObserverConnectionStateClosing:
                 return &ConnectionMetricsObject::closing;
-            case ConnectionStateClosed:
+            case ObserverConnectionStateClosed:
                 return &ConnectionMetricsObject::closed;
             }
         }    
 
-        ConnectionState oldState;
-        ConnectionState newState;
+        ObserverConnectionState oldState;
+        ObserverConnectionState newState;
     }
     forEach(StateChanged(oldState, newState));
 }
@@ -115,15 +165,15 @@ ConnectionObserverI::stateChanged(ConnectionState oldState, ConnectionState newS
 void 
 ConnectionObserverI::sentBytes(Int num, Long duration)
 {
-    forEach(aggregate(applyOnMember(&ConnectionMetricsObject::sentBytes, Add<Int>(num)),
-                      applyOnMember(&ConnectionMetricsObject::sentTime, Add<Long>(duration))));
+    forEach(chain(add(&ConnectionMetricsObject::sentBytes, num), 
+                  add(&ConnectionMetricsObject::sentTime, duration)));
 }
 
 void 
 ConnectionObserverI::receivedBytes(Int num, Long duration)
 {
-    forEach(aggregate(applyOnMember(&ConnectionMetricsObject::receivedBytes, Add<Int>(num)),
-                      applyOnMember(&ConnectionMetricsObject::receivedTime, Add<Long>(duration))));
+    forEach(chain(add(&ConnectionMetricsObject::receivedBytes, num),
+                  add(&ConnectionMetricsObject::receivedTime, duration)));
 }
 
 ObserverResolverI::ObserverResolverI(const MetricsAdminIPtr& metrics) : _metrics(metrics)
@@ -133,56 +183,38 @@ ObserverResolverI::ObserverResolverI(const MetricsAdminIPtr& metrics) : _metrics
 void
 ObserverResolverI::setObserverUpdater(const ObserverUpdaterPtr& updater)
 {
-    class Updater : public ObjectObserverUpdater
-    {
-    public:
 
-        Updater(const ObserverUpdaterPtr& updater, void (ObserverUpdater::*fn)()) : 
-            _updater(updater), _fn(fn)
-        {
-        }
-        
-        virtual void update()
-        {
-            (_updater.get()->*_fn)();
-        }
-
-    private: 
-
-        const ObserverUpdaterPtr _updater;
-        void (ObserverUpdater::*_fn)();
-    };
-    _metrics->addUpdater("Connection", new Updater(updater, &ObserverUpdater::updateConnectionObservers));
-    _metrics->addUpdater("Thread", new Updater(updater, &ObserverUpdater::updateThreadObservers));
-    _metrics->addUpdater("ThreadPoolThread", new Updater(updater, &ObserverUpdater::updateThreadPoolThreadObservers));
+    _metrics->addUpdater("Connection", newUpdater(updater, &ObserverUpdater::updateConnectionObservers, _connections));
+    //_metrics->addUpdater("Thread", new Updater(updater, &ObserverUpdater::updateThreadObservers));
+    //_metrics->addUpdater("ThreadPoolThread", new Updater(updater, &ObserverUpdater::updateThreadPoolThreadObservers));
 }
 
 ConnectionObserverPtr 
-ObserverResolverI::getConnectionObserver(const ConnectionObserverPtr& old, const ConnectionPtr& con)
+ObserverResolverI::getConnectionObserver(const ConnectionPtr& con, const ConnectionObserverPtr& old)
 {
-    return _connections.getObserver(_metrics->getMatching("Connection", ConnectionMetricsHelper(con)), old.get());
+    return _connections.getObserver(_metrics->getMatching("Connection", ConnectionHelper(con)), old.get());
 }
 
 ObjectObserverPtr 
-ObserverResolverI::getThreadObserver(const ObjectObserverPtr&, const string&, const string&)
+ObserverResolverI::getThreadObserver(const string&, const string&, const ObjectObserverPtr&)
 {
     return 0;
 }
 
 ThreadPoolThreadObserverPtr 
-ObserverResolverI::getThreadPoolThreadObserver(const ThreadPoolThreadObserverPtr&, const string&, const string&)
+ObserverResolverI::getThreadPoolThreadObserver(const string&, const string&, const ThreadPoolThreadObserverPtr&)
 {
     return 0;
 }
 
 RequestObserverPtr 
-ObserverResolverI::getInvocationObserver(const RequestObserverPtr&, const ObjectPrx&, const string&)
+ObserverResolverI::getInvocationObserver(const ObjectPrx&, const string&)
 {
     return 0;
 }
 
 RequestObserverPtr 
-ObserverResolverI::getDispatchObserver(const RequestObserverPtr&, const ObjectPtr&, const Current&)
+ObserverResolverI::getDispatchObserver(const ObjectPtr&, const Current&)
 {
     return 0;
 }
diff --git a/cpp/src/Ice/MetricsObserverI.h b/cpp/src/Ice/MetricsObserverI.h
index 7b5b4abbf5a..839cc73e2ac 100644
--- a/cpp/src/Ice/MetricsObserverI.h
+++ b/cpp/src/Ice/MetricsObserverI.h
@@ -15,25 +15,45 @@
 
 #include <Ice/MetricsFunctional.h>
 
-namespace IceMetrics
+namespace IceMX
 {
 
 class MetricsAdminI;
 typedef IceUtil::Handle<MetricsAdminI> MetricsAdminIPtr;
 
-template<class T> class ObjectObserverI : virtual public Ice::ObjectObserver
+typedef std::vector<std::pair<IceMX::MetricsObjectPtr, IceUtil::Mutex*> > MetricsObjectAndLockSeq;
+
+class ObjectHelper
+{
+public:
+
+    virtual std::string operator()(const std::string&) const = 0;
+
+    virtual MetricsObjectPtr newMetricsObject() const = 0;
+};
+
+class ObjectObserverUpdater : public IceUtil::Shared
+{
+public:
+
+    virtual void update() = 0;
+};
+typedef IceUtil::Handle<ObjectObserverUpdater> ObjectObserverUpdaterPtr;
+
+template<class T> class ObjectObserverT : virtual public ::Ice::ObjectObserver
 {
 public:
 
     typedef T Type;
     typedef IceUtil::Handle<T> PtrType;
-    typedef std::vector<PtrType> SeqType;
+    typedef std::vector<std::pair<PtrType, IceUtil::Mutex*> > SeqType;
+
 
-    ObjectObserverI(const std::vector<MetricsObjectPtr>& objects)
+    ObjectObserverT(const MetricsObjectAndLockSeq& objects)
     {
-        for(std::vector<MetricsObjectPtr>::const_iterator p = objects.begin(); p != objects.end(); ++p)
+        for(MetricsObjectAndLockSeq::const_iterator p = objects.begin(); p != objects.end(); ++p)
         {
-            _objects.push_back(PtrType::dynamicCast(*p));
+            _objects.push_back(std::make_pair(PtrType::dynamicCast(p->first), p->second));
         }
     }
 
@@ -42,15 +62,16 @@ public:
     {
         for(typename SeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
         {
-            ++(*p)->total;
-            ++(*p)->current;
+            IceUtil::Mutex::Lock sync(*p->second);
+            ++p->first->total;
+            ++p->first->current;
         }
     }
 
     virtual void 
     detach()
     {
-        forEach(decMember(&MetricsObject::current));
+        forEach(dec(&MetricsObject::current));
     }
 
     template<typename Function> void
@@ -58,120 +79,331 @@ public:
     {
         for(typename SeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
         {
-            func(*p);
+            IceUtil::Mutex::Lock sync(*p->second);
+            func(p->first);
         }
     }
 
     void
-    update(ObjectObserverI* old)
+    update(ObjectObserverT* old)
     {
+        typename SeqType::const_iterator p = _objects.begin();
         typename SeqType::const_iterator q = old->_objects.begin();
-        for(typename SeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
+        while(p != _objects.end())
         {
-            if(*p != *q)
+            if(q == old->_objects.end() || p->first < q->first) // New metrics object
             {
-                ++(*p)->total;
-                ++(*p)->current;
+                IceUtil::Mutex::Lock sync(*p->second);
+                ++p->first->total;
+                ++p->first->current;
+                ++p;
             }
-            else
+            else if(p->first == q->first) // Same metrics object
+            {
+                ++p;
+                ++q;
+            }
+            else // Removed metrics object
             {
                 ++q;
             }
         }
     }
-
+    
 private:
 
     SeqType _objects;
 };
 
-class ConnectionObserverI : public Ice::ConnectionObserver, public ObjectObserverI<ConnectionMetricsObject>
+template<typename T> class ObjectHelperT : public ObjectHelper
 {
 public:
 
-    ConnectionObserverI(const std::vector<MetricsObjectPtr>& objects) : ObjectObserverI(objects)
+    virtual MetricsObjectPtr newMetricsObject() const
     {
+        return new T();
     }
+};
 
-    virtual void attach();
-    virtual void detach();
+template<typename Helper> class ObjectAttributeResolverT
+{
+    class Resolver
+    {
+    public:
+        virtual ~Resolver() { }
+        virtual std::string operator()(const Helper* h) const = 0;
+    };
+
+public:
+
+    ~ObjectAttributeResolverT()
+    {
+        for(typename std::map<std::string, Resolver*>::iterator p = _attributes.begin(); p != _attributes.end(); ++p)
+        {
+            delete p->second;
+        }
+    }
+
+    std::string operator()(const Helper* helper, const std::string& attribute) const
+    {
+        typename std::map<std::string, Resolver*>::const_iterator p = _attributes.find(attribute);
+        if(p == _attributes.end())
+        {
+            return "unknown";
+        }
+        return (*p->second)(helper);
+    }
+
+protected:
+
+    template<class T, typename O, typename Y> void
+    add(const std::string& name, O* (Helper::*getFn)() const, Y T::*member)
+    {
+        _attributes.insert(make_pair(name,  new MemberResolver<T, O, Y>(getFn, member)));
+    }
+
+    template<class T, typename O, typename Y> void
+    add(const std::string& name, O* (Helper::*getFn)() const, Y (T::*memberFn)() const)
+    {
+        _attributes.insert(make_pair(name,  new MemberFunctionResolver<T, O, Y>(getFn, memberFn)));
+    }
+
+private:
+
+    template<class T, typename O, typename Y> class MemberResolver : public Resolver
+    {
+    public:
+
+        MemberResolver(O* (Helper::*getFn)() const, Y T::*member) : _getFn(getFn), _member(member)
+        {
+        }
+
+        virtual std::string operator()(const Helper* r) const
+        {
+            O* o = (r->*_getFn)();
+            T* v = dynamic_cast<T*>(o);
+            if(v)
+            {
+                return toString(v->*_member);
+            }
+            else
+            {
+                return "unknown";
+            }
+        }
+        
+    private:
+        
+        O* (Helper::*_getFn)() const;
+        Y T::*_member;
+    };
+
+    template<class T, typename O, typename Y> class MemberFunctionResolver : public Resolver
+    {
+    public:
+
+        MemberFunctionResolver(O* (Helper::*getFn)() const, Y (T::*memberFn)() const) :
+            _getFn(getFn), _memberFn(memberFn)
+        {
+        }
+
+        virtual std::string operator()(const Helper* r) const
+        {
+            O* o = (r->*_getFn)();
+            T* v = dynamic_cast<T*>(o);
+            if(v)
+            {
+                return toString((v->*_memberFn)());
+            }
+            else
+            {
+                return "unknown";
+            }
+        }
+        
+    private:
+        
+        O* (Helper::*_getFn)() const;
+        Y (T::*_memberFn)() const;
+    };
+
+    template<typename T> static std::string
+    toString(const T& v)
+    {
+        std::ostringstream os;
+        os << v;
+        return os.str();
+    }
+
+    static std::string
+    toString(const std::string& s)
+    {
+        return s;
+    }
 
-    virtual void stateChanged(Ice::ConnectionState, Ice::ConnectionState);
-    virtual void sentBytes(Ice::Int, Ice::Long);
-    virtual void receivedBytes(Ice::Int, Ice::Long);
+    std::map<std::string, Resolver*> _attributes;
 };
 
-template<typename T> 
 class ObjectObserverResolver
 {
 public:
 
+    virtual void clear() = 0;
+};
+
+template<typename T> class ObjectObserverUpdaterT : public ObjectObserverUpdater
+{
+public:
+    
+    ObjectObserverUpdaterT(T* updater, void (T::*fn)(), ObjectObserverResolver& resolver) : 
+        _updater(updater), _fn(fn), _resolver(resolver)
+    {
+    }
+        
+    virtual void update()
+    {
+        _resolver.clear();
+        (_updater.get()->*_fn)();
+    }
+    
+private: 
+    
+    const IceUtil::Handle<T> _updater;
+    void (T::*_fn)();
+    ObjectObserverResolver& _resolver;
+};
+
+template<typename T> ObjectObserverUpdater*
+newUpdater(const IceUtil::Handle<T>& updater, void (T::*fn)(), ObjectObserverResolver& resolver)
+{
+    return new ObjectObserverUpdaterT<T>(updater.get(), fn, resolver);
+}
+
+template<typename T> ObjectObserverUpdater*
+newUpdater(const IceInternal::Handle<T>& updater, void (T::*fn)(), ObjectObserverResolver& resolver)
+{
+    return new ObjectObserverUpdaterT<T>(updater.get(), fn, resolver);
+}
+
+template<typename T> 
+class ObjectObserverResolverT : public ObjectObserverResolver, public IceUtil::Mutex
+{
+    struct Compare
+    {
+        //
+        // Only sort on the metrics object pointer value.
+        //
+        bool operator()(const MetricsObjectAndLockSeq& lhs, const MetricsObjectAndLockSeq& rhs)
+        { 
+            if(lhs.size() < rhs.size())
+            {
+                return true;
+            } 
+            else if(lhs.size() > rhs.size())
+            {
+                return false;
+            }
+
+            typename MetricsObjectAndLockSeq::const_iterator p = lhs.begin();
+            typename MetricsObjectAndLockSeq::const_iterator q = rhs.begin();
+            while(p != lhs.end())
+            {
+                if(p->first.get() < q->first.get())
+                {
+                    return true;
+                }
+                else if(p->first.get() > q->first.get())
+                {
+                    return false;
+                }
+            }
+            return false;
+        }
+    };
+
+public:
+
     typedef IceUtil::Handle<T> TPtr;
-    typedef std::map<std::vector<MetricsObjectPtr>, TPtr> ObserverMap;
+    typedef std::map<MetricsObjectAndLockSeq, TPtr, Compare> ObserverMap;
 
     template<typename S> T*
-    getObserver(const std::vector<MetricsMap::Entry>& objects, S* oldObserver)
+    getObserver(const MetricsObjectAndLockSeq& objects, S* oldObserver)
     {
         if(objects.empty())
         {
             return 0;
         }
 
-        typename ObserverMap::const_iterator p = _stats.find(objects);
-        if(p == _stats.end())
+        IceUtil::Mutex::Lock sync(*this);
+        typename ObserverMap::const_iterator p = _observers.find(objects);
+        if(p == _observers.end())
         {
-            p = _stats.insert(make_pair(objects, new T(objects))).first;
+            p = _observers.insert(make_pair(objects, new T(objects))).first;
         }
         
         T* newObserver = p->second.get();
-        if(oldObserver && static_cast<S*>(newObserver) != oldObserver)
+        if(oldObserver)
         {
             newObserver->update(dynamic_cast<T*>(oldObserver));
         }
         return newObserver;
     }
 
+
+    virtual void
+    clear()
+    {
+        IceUtil::Mutex::Lock sync(*this);
+        _observers.clear();
+    }
+
 private:
 
-    ObserverMap _stats;
+    ObserverMap _observers;
 };
 
-class ObjectObserverUpdater : public IceUtil::Shared
+class ConnectionObserverI : public ::Ice::ConnectionObserver, public ObjectObserverT<Ice::ConnectionMetricsObject>
 {
 public:
 
-    virtual void update() = 0;
+    ConnectionObserverI(const MetricsObjectAndLockSeq& objects) : ObjectObserverT(objects)
+    {
+    }
+
+    virtual void attach();
+    virtual void detach();
+
+    virtual void stateChanged(::Ice::ObserverConnectionState, ::Ice::ObserverConnectionState);
+    virtual void sentBytes(::Ice::Int, ::Ice::Long);
+    virtual void receivedBytes(::Ice::Int, ::Ice::Long);
 };
-typedef IceUtil::Handle<ObjectObserverUpdater> ObjectObserverUpdaterPtr;
 
-class ObserverResolverI : public Ice::ObserverResolver
+class ObserverResolverI : public ::Ice::ObserverResolver
 {
 public:
 
     ObserverResolverI(const MetricsAdminIPtr&);
 
-    virtual void setObserverUpdater(const Ice::ObserverUpdaterPtr&);
+    virtual void setObserverUpdater(const ::Ice::ObserverUpdaterPtr&);
 
-    virtual Ice::ConnectionObserverPtr 
-    getConnectionObserver(const Ice::ConnectionObserverPtr&, const Ice::ConnectionPtr&);
+    virtual ::Ice::ConnectionObserverPtr 
+    getConnectionObserver(const ::Ice::ConnectionPtr&, const ::Ice::ConnectionObserverPtr&);
 
-    virtual Ice::ObjectObserverPtr 
-    getThreadObserver(const Ice::ObjectObserverPtr&, const std::string&, const std::string&);
+    virtual ::Ice::ObjectObserverPtr 
+    getThreadObserver(const std::string&, const std::string&, const ::Ice::ObjectObserverPtr&);
 
-    virtual Ice::ThreadPoolThreadObserverPtr 
-    getThreadPoolThreadObserver(const Ice::ThreadPoolThreadObserverPtr&, const std::string&, const std::string&);
+    virtual ::Ice::ThreadPoolThreadObserverPtr 
+    getThreadPoolThreadObserver(const std::string&, const std::string&, const ::Ice::ThreadPoolThreadObserverPtr&);
 
-    virtual Ice::RequestObserverPtr 
-    getInvocationObserver(const Ice::RequestObserverPtr&, const Ice::ObjectPrx&, const std::string&);
+    virtual ::Ice::RequestObserverPtr getInvocationObserver(const ::Ice::ObjectPrx&, const std::string&);
 
-    virtual Ice::RequestObserverPtr 
-    getDispatchObserver(const Ice::RequestObserverPtr&, const Ice::ObjectPtr&, const Ice::Current&);
+    virtual ::Ice::RequestObserverPtr getDispatchObserver(const ::Ice::ObjectPtr&, const ::Ice::Current&);
 
 private:
 
     const MetricsAdminIPtr _metrics;
 
-    ObjectObserverResolver<ConnectionObserverI> _connections;
+    ObjectObserverResolverT<ConnectionObserverI> _connections;
 };
 
 }
diff --git a/cpp/src/Ice/ObjectAdapterFactory.cpp b/cpp/src/Ice/ObjectAdapterFactory.cpp
index 20aa10d95ec..5cc3cf3e054 100644
--- a/cpp/src/Ice/ObjectAdapterFactory.cpp
+++ b/cpp/src/Ice/ObjectAdapterFactory.cpp
@@ -110,6 +110,19 @@ IceInternal::ObjectAdapterFactory::destroy()
     }
 }
 
+void
+IceInternal::ObjectAdapterFactory::updateConnectionObservers()
+{
+    list<ObjectAdapterIPtr> adapters;
+
+    {
+        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        adapters = _adapters;
+    }
+
+    for_each(adapters.begin(), adapters.end(), IceUtil::voidMemFun(&ObjectAdapterI::updateConnectionObservers));
+}
+
 ObjectAdapterPtr
 IceInternal::ObjectAdapterFactory::createObjectAdapter(const string& name, const RouterPrx& router)
 {
diff --git a/cpp/src/Ice/ObjectAdapterFactory.h b/cpp/src/Ice/ObjectAdapterFactory.h
index 9523f65748f..4705bf07eb5 100644
--- a/cpp/src/Ice/ObjectAdapterFactory.h
+++ b/cpp/src/Ice/ObjectAdapterFactory.h
@@ -28,6 +28,8 @@ public:
     bool isShutdown() const;
     void destroy();
 
+    void updateConnectionObservers();
+
     ::Ice::ObjectAdapterPtr createObjectAdapter(const std::string&, const Ice::RouterPrx&);
     ::Ice::ObjectAdapterPtr findObjectAdapter(const ::Ice::ObjectPrx&);
     void removeObjectAdapter(const ::Ice::ObjectAdapterPtr&);
diff --git a/cpp/src/Ice/ObjectAdapterI.cpp b/cpp/src/Ice/ObjectAdapterI.cpp
index 30965746384..3f02609cc17 100644
--- a/cpp/src/Ice/ObjectAdapterI.cpp
+++ b/cpp/src/Ice/ObjectAdapterI.cpp
@@ -779,6 +779,17 @@ Ice::ObjectAdapterI::flushAsyncBatchRequests(const CommunicatorBatchOutgoingAsyn
 }
 
 void
+Ice::ObjectAdapterI::updateConnectionObservers()
+{
+    vector<IncomingConnectionFactoryPtr> f;
+    {
+        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        f = _incomingConnectionFactories;
+    }
+    for_each(f.begin(), f.end(), Ice::voidMemFun(&IncomingConnectionFactory::updateConnectionObservers));
+}
+
+void
 Ice::ObjectAdapterI::incDirectCount()
 {
     IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
diff --git a/cpp/src/Ice/ObjectAdapterI.h b/cpp/src/Ice/ObjectAdapterI.h
index d3eed147890..b5f6e7c417e 100644
--- a/cpp/src/Ice/ObjectAdapterI.h
+++ b/cpp/src/Ice/ObjectAdapterI.h
@@ -86,6 +86,8 @@ public:
 
     void flushAsyncBatchRequests(const IceInternal::CommunicatorBatchOutgoingAsyncPtr&);
 
+    void updateConnectionObservers();
+
     void incDirectCount();
     void decDirectCount();
 
diff --git a/cpp/src/slice2cpp/Gen.cpp b/cpp/src/slice2cpp/Gen.cpp
index fd34162a680..b43bc94f7b5 100644
--- a/cpp/src/slice2cpp/Gen.cpp
+++ b/cpp/src/slice2cpp/Gen.cpp
@@ -1003,14 +1003,14 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
             //
             C << sp << nl << "void" << nl << scoped.substr(2) << "::__write(const ::Ice::OutputStreamPtr&) const";
             C << sb;
-            C << nl << "Ice::MarshalException ex(__FILE__, __LINE__);";
+            C << nl << "::Ice::MarshalException ex(__FILE__, __LINE__);";
             C << nl << "ex.reason = \"exception " << scoped.substr(2) << " was not generated with stream support\";";
             C << nl << "throw ex;";
             C << eb;
 
             C << sp << nl << "void" << nl << scoped.substr(2) << "::__read(const ::Ice::InputStreamPtr&)";
             C << sb;
-            C << nl << "Ice::MarshalException ex(__FILE__, __LINE__);";
+            C << nl << "::Ice::MarshalException ex(__FILE__, __LINE__);";
             C << nl << "ex.reason = \"exception " << scoped .substr(2)<< " was not generated with stream support\";";
             C << nl << "throw ex;";
             C << eb;
@@ -3975,7 +3975,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
             //
             C << sp << nl << "void" << nl << scoped.substr(2) << "::__write(const ::Ice::OutputStreamPtr&) const";
             C << sb;
-            C << nl << "Ice::MarshalException ex(__FILE__, __LINE__);";
+            C << nl << "::Ice::MarshalException ex(__FILE__, __LINE__);";
             C << nl << "ex.reason = \"type " << scoped.substr(2) << " was not generated with stream support\";";
             C << nl << "throw ex;";
             C << eb;
@@ -3983,7 +3983,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
             C << sp;
             C << nl << "void" << nl << scoped.substr(2) << "::__read(const ::Ice::InputStreamPtr&)";
             C << sb;
-            C << nl << "Ice::MarshalException ex(__FILE__, __LINE__);";
+            C << nl << "::Ice::MarshalException ex(__FILE__, __LINE__);";
             C << nl << "ex.reason = \"type " << scoped.substr(2) << " was not generated with stream support\";";
             C << nl << "throw ex;";
             C << eb;