Fix

5 files changed, 333 insertions, 346 deletions

diff --git a/cpp/src/Ice/MetricsAdminI.cpp b/cpp/src/Ice/MetricsAdminI.cpp
index 341c8f852f7..8b6ae36586b 100644
--- a/cpp/src/Ice/MetricsAdminI.cpp
+++ b/cpp/src/Ice/MetricsAdminI.cpp
@@ -71,57 +71,6 @@ MetricsMapI::RegExp::match(const MetricsHelper& helper)
 #endif
 }
 
-MetricsMapI::Entry::Entry(MetricsMapI* map, const MetricsPtr& object, const list<Entry*>::iterator& pos) : 
-    _object(object), _map(map), _detachedPos(pos)
-{
-}
-
-void 
-MetricsMapI::Entry::destroy()
-{
-    Lock sync(*this);
-    _map = 0;
-}
-
-void 
-MetricsMapI::Entry::failed(const string& exceptionName)
-{
-    Lock sync(*this);
-    ++_object->failures;
-    ++_failures[exceptionName];
-}
-
-MetricsFailures
-MetricsMapI::Entry::getFailures() const
-{
-    MetricsFailures f;
-    
-    Lock sync(*this);
-    f.id = _object->id;
-    f.failures = _failures;
-    return f;
-}
-
-MetricsPtr
-MetricsMapI::Entry::clone() const
-{
-    Lock sync(*this);
-    return dynamic_cast<Metrics*>(_object->ice_clone().get());
-}
-
-const string& 
-MetricsMapI::Entry::id() const
-{
-    return _object->id;
-}
-
-MetricsMapI::Entry*
-MetricsMapI::Entry::getMatching(const string&, const MetricsHelper&)
-{
-    return 0;
-}
-
-
 MetricsMapI::MetricsMapI(const std::string& mapPrefix, const Ice::PropertiesPtr& properties) :
     _properties(properties->getPropertiesForPrefix(mapPrefix)),
     _retain(properties->getPropertyAsIntWithDefault(mapPrefix + "RetainDetached", 10)),
@@ -178,150 +127,6 @@ MetricsMapI::MetricsMapI(const MetricsMapI& map) :
     _reject(map._reject)
 {
 }
-
-MetricsMapI::~MetricsMapI()
-{
-    for(map<string, EntryPtr>::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
-    {
-        p->second->destroy();
-    }
-}
-
-MetricsMap
-MetricsMapI::getMetrics() const
-{
-    MetricsMap objects;
-
-    Lock sync(*this);
-    for(map<string, EntryPtr>::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
-    {
-        objects.push_back(p->second->clone());
-    }
-    return objects;
-}
-
-MetricsFailuresSeq
-MetricsMapI::getFailures()
-{
-    MetricsFailuresSeq failures;
-
-    Lock sync(*this);
-    for(map<string, EntryPtr>::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
-    {
-        MetricsFailures f = p->second->getFailures();
-        if(!f.failures.empty())
-        {
-            failures.push_back(f);
-        }
-    }
-    return failures;
-}
-
-MetricsFailures
-MetricsMapI::getFailures(const string& id)
-{
-    Lock sync(*this);
-    map<string, EntryPtr>::const_iterator p = _objects.begin();
-    if(p != _objects.end())
-    {
-        return p->second->getFailures();
-    }
-    return MetricsFailures();
-}
-
-MetricsMapI::EntryPtr
-MetricsMapI::getMatching(const MetricsHelper& helper)
-{
-    for(vector<RegExpPtr>::const_iterator p = _accept.begin(); p != _accept.end(); ++p)
-    {
-        if(!(*p)->match(helper))
-        {
-            return 0;
-        }
-    }
-    
-    for(vector<RegExpPtr>::const_iterator p = _reject.begin(); p != _reject.end(); ++p)
-    {
-        if((*p)->match(helper))
-        {
-            return 0;
-        }
-    }
-
-    string key;
-    if(_groupByAttributes.size() == 1)
-    {
-        key = helper(_groupByAttributes.front());
-    }
-    else
-    {
-        ostringstream os;
-        vector<string>::const_iterator q = _groupBySeparators.begin();
-        for(vector<string>::const_iterator p = _groupByAttributes.begin(); p != _groupByAttributes.end(); ++p)
-        {
-            os << helper(*p);
-            if(q != _groupBySeparators.end())
-            {
-                os << *q++;
-            }
-        }
-        key = os.str();
-    }
-
-    Lock sync(*this);
-    map<string, EntryPtr>::const_iterator p = _objects.find(key);
-    if(p == _objects.end())
-    {
-        p = _objects.insert(make_pair(key, newEntry(key))).first;
-    }
-    return p->second;
-}
-
-void
-MetricsMapI::detached(Entry* entry)
-{
-    if(_retain == 0)
-    {
-        return;
-    }
-
-    Lock sync(*this);
-    assert(static_cast<int>(_detachedQueue.size()) <= _retain);
-
-    if(entry->_detachedPos != _detachedQueue.end())
-    {
-        _detachedQueue.splice(_detachedQueue.end(), _detachedQueue, entry->_detachedPos);
-        entry->_detachedPos = --_detachedQueue.end();
-        return;
-    }
-
-    if(static_cast<int>(_detachedQueue.size()) == _retain)
-    {
-        // Remove entries which are no longer detached
-        list<Entry*>::iterator p = _detachedQueue.begin();
-        while(p != _detachedQueue.end())
-        {
-            if(!(*p)->isDetached())
-            {
-                p = _detachedQueue.erase(p);
-            }
-            else
-            {
-                ++p;
-            }
-        }
-    }
-
-    if(static_cast<int>(_detachedQueue.size()) == _retain)
-    {
-        // Remove oldest entry if there's still no room
-        _objects.erase(_detachedQueue.front()->id());
-        _detachedQueue.pop_front();
-    }
-
-    _detachedQueue.push_back(entry);
-    entry->_detachedPos = --_detachedQueue.end();
-}
     
 MetricsViewI::MetricsViewI(const string& name) : _name(name)
 {
diff --git a/cpp/src/Ice/MetricsAdminI.h b/cpp/src/Ice/MetricsAdminI.h
index 92c0277353c..c788a8e28b0 100644
--- a/cpp/src/Ice/MetricsAdminI.h
+++ b/cpp/src/Ice/MetricsAdminI.h
@@ -36,7 +36,7 @@ typedef IceUtil::Handle<Updater> UpdaterPtr;
 class MetricsHelper;
 template<typename T> class MetricsHelperT;
 
-class MetricsMapI : public IceUtil::Shared, private IceUtil::Mutex
+class MetricsMapI : public IceUtil::Shared
 {
 public:
 
@@ -59,109 +59,27 @@ public:
     };
     typedef IceUtil::Handle<RegExp> RegExpPtr;
 
-    class Entry : public Ice::LocalObject, protected IceUtil::Mutex
-    {
-    public:
-
-        Entry(MetricsMapI* map, const MetricsPtr& object, const std::list<Entry*>::iterator&);
-
-        void destroy();
-        void  failed(const std::string& exceptionName);
-        MetricsFailures getFailures() const;
-
-        virtual MetricsPtr clone() const;
-        const std::string& id() const;
-        virtual Entry* getMatching(const std::string&, const MetricsHelper&);
-
-        template<typename T> IceInternal::Handle<T>
-        attach(const MetricsHelperT<T>& helper)
-        {
-            Lock sync(*this);
-            ++_object->total;
-            ++_object->current;
-            IceInternal::Handle<T> obj = IceInternal::Handle<T>::dynamicCast(_object);
-            assert(obj);
-            helper.initMetrics(obj);
-            return obj;
-        }
-
-        void detach(Ice::Long lifetime)
-        {
-            MetricsMapI* map;
-            {
-                Lock sync(*this);
-                _object->totalLifetime += lifetime;
-                if(--_object->current > 0)
-                {
-                    return;
-                }
-                map = _map;
-            }
-            if(map)
-            {
-                map->detached(this);
-            }
-        }
-
-        bool isDetached() const
-        {
-            Lock sync(*this);
-            return _object->current == 0;
-        }
-
-        template<typename Function, typename MetricsType> void
-        execute(Function func, const MetricsType& obj)
-        {
-            Lock sync(*this);
-            func(obj);
-        }
-
-    protected:
-
-        friend class MetricsMapI;
-
-        MetricsPtr _object;
-        MetricsMapI* _map;
-        StringIntDict _failures;
-        std::list<Entry*>::iterator _detachedPos;
-    };
-    typedef IceUtil::Handle<Entry> EntryPtr;
-
     MetricsMapI(const std::string&, const Ice::PropertiesPtr&);
     MetricsMapI(const MetricsMapI&);
 
-    virtual ~MetricsMapI();
-    
-    MetricsFailuresSeq getFailures();
-    MetricsFailures getFailures(const std::string&);
-    MetricsMap getMetrics() const;
-    EntryPtr getMatching(const MetricsHelper&);
+    virtual MetricsFailuresSeq getFailures() = 0;
+    virtual MetricsFailures getFailures(const std::string&) = 0;
+    virtual MetricsMap getMetrics() const = 0;
+    virtual MetricsMapI* clone() const = 0;
 
     const Ice::PropertyDict& getMapProperties() const
     {
         return _properties;
     }
 
-    virtual MetricsMapI* clone() const = 0;
-
 protected:
 
-    virtual EntryPtr newEntry(const std::string&) = 0;
-    std::list<Entry*> _detachedQueue;
-
-private:
-
-    friend class Entry;
-    void detached(Entry*);
-    
     const Ice::PropertyDict _properties;
     std::vector<std::string> _groupByAttributes;
     std::vector<std::string> _groupBySeparators;
     const int _retain;
     const std::vector<RegExpPtr> _accept;
     const std::vector<RegExpPtr> _reject;
-
-    std::map<std::string, EntryPtr> _objects;
 };
 typedef IceUtil::Handle<MetricsMapI> MetricsMapIPtr;
 
@@ -173,7 +91,7 @@ public:
 };
 typedef IceUtil::Handle<MetricsMapFactory> MetricsMapFactoryPtr;
 
-template<class MetricsType> class MetricsMapT : public MetricsMapI
+template<class MetricsType> class MetricsMapT : public MetricsMapI, private IceUtil::Mutex
 {
 public:
 
@@ -182,17 +100,40 @@ public:
 
     typedef MetricsMap MetricsType::* SubMapMember;
 
-    class EntryT : public MetricsMapI::Entry
+    class EntryT : public Ice::LocalObject, protected IceUtil::Mutex
     {
     public:
 
-        EntryT(MetricsMapT* map, const TPtr& object, const std::list<Entry*>::iterator& p) : 
-            Entry(map, object, p), _map(map)
+        EntryT(MetricsMapT* map, const TPtr& object, const typename std::list<EntryT*>::iterator& p) : 
+            _map(map), _object(object), _detachedPos(p)
+        {
+        }
+
+        void destroy()
         {
+            Lock sync(*this);
+            _map = 0;
         }
 
-        virtual Entry*
-        getMatching(const std::string& mapName, const MetricsHelper& helper)
+        void  failed(const std::string& exceptionName)
+        {
+            Lock sync(*this);
+            ++_object->failures;
+            ++_failures[exceptionName];
+        }
+
+        MetricsFailures getFailures() const
+        {
+            MetricsFailures f;
+    
+            Lock sync(*this);
+            f.id = _object->id;
+            f.failures = _failures;
+            return f;
+        }
+
+        template<typename MemberMetricsType> typename MetricsMapT<MemberMetricsType>::EntryTPtr
+        getMatching(const std::string& mapName, const MetricsHelperT<MemberMetricsType>& helper)
         {
             typename std::map<std::string, std::pair<MetricsMapIPtr, SubMapMember> >::iterator p = 
                 _subMaps.find(mapName);
@@ -207,11 +148,55 @@ public:
             if(p == _subMaps.end())
             {
                 return 0;
-            }            
-            return p->second.first->getMatching(helper).get();
+            }
+
+            MetricsMapT<MemberMetricsType>* map = dynamic_cast<MetricsMapT<MemberMetricsType>*>(p->second.first.get());
+            assert(map);
+            return map->getMatching(helper);
+        }
+
+        TPtr
+        attach(const MetricsHelperT<T>& helper)
+        {
+            Lock sync(*this);
+            ++_object->total;
+            ++_object->current;
+            helper.initMetrics(_object);
+            return _object;
+        }
+
+        void detach(Ice::Long lifetime)
+        {
+            MetricsMapT* map;
+            {
+                Lock sync(*this);
+                _object->totalLifetime += lifetime;
+                if(--_object->current > 0)
+                {
+                    return;
+                }
+                map = _map;
+            }
+            if(map)
+            {
+                map->detached(this);
+            }
         }
 
-        virtual MetricsPtr
+        bool isDetached() const
+        {
+            Lock sync(*this);
+            return _object->current == 0;
+        }
+
+        template<typename Function> void
+        execute(Function func)
+        {
+            Lock sync(*this);
+            func(_object);
+        }
+
+        MetricsPtr
         clone() const
         {
             Lock sync(*this);
@@ -226,8 +211,12 @@ public:
 
     private:
 
+        friend class MetricsMapT;
         MetricsMapT* _map;
+        TPtr _object;
+        StringIntDict _failures;
         std::map<std::string, std::pair<MetricsMapIPtr, SubMapMember> > _subMaps;
+        typename std::list<EntryT*>::iterator _detachedPos;
     };
     typedef IceUtil::Handle<EntryT> EntryTPtr;
 
@@ -262,6 +251,57 @@ public:
     {
     }
 
+    ~MetricsMapT()
+    {
+        for(typename std::map<std::string, EntryTPtr>::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
+        {
+            p->second->destroy();
+        }
+    }
+
+    virtual MetricsMap
+    getMetrics() const
+    {
+        MetricsMap objects;
+        
+        Lock sync(*this);
+        for(typename std::map<std::string, EntryTPtr>::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
+        {
+            objects.push_back(p->second->clone());
+        }
+        return objects;
+    }
+    
+    virtual MetricsFailuresSeq
+    getFailures()
+    {
+        MetricsFailuresSeq failures;
+        
+        Lock sync(*this);
+        for(typename std::map<std::string, EntryTPtr>::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
+        {
+            MetricsFailures f = p->second->getFailures();
+            if(!f.failures.empty())
+            {
+                failures.push_back(f);
+            }
+        }
+        return failures;
+    }
+    
+    virtual MetricsFailures
+    getFailures(const std::string& id)
+    {
+        Lock sync(*this);
+        typename std::map<std::string, EntryTPtr>::const_iterator p = _objects.begin();
+        if(p != _objects.end())
+        {
+            return p->second->getFailures();
+        }
+        return MetricsFailures();
+    }
+
+
     std::pair<MetricsMapIPtr, SubMapMember>
     createSubMap(const std::string& subMapName)
     {
@@ -274,21 +314,63 @@ public:
         return std::make_pair(MetricsMapIPtr(), static_cast<SubMapMember>(0));
     }
 
-protected:
-
-    virtual EntryPtr newEntry(const std::string& id)
+    EntryTPtr 
+    getMatching(const MetricsHelperT<T>& helper)
     {
-        TPtr t = new T();
-        t->id = id;
-        t->failures = 0;
-        if(_subMaps.empty())
+        for(std::vector<RegExpPtr>::const_iterator p = _accept.begin(); p != _accept.end(); ++p)
+        {
+            if(!(*p)->match(helper))
+            {
+                return 0;
+            }
+        }
+        
+        for(std::vector<RegExpPtr>::const_iterator p = _reject.begin(); p != _reject.end(); ++p)
+        {
+            if((*p)->match(helper))
+            {
+                return 0;
+            }
+        }
+        
+        std::string key;
+        if(_groupByAttributes.size() == 1)
         {
-            return new Entry(this, t, _detachedQueue.end());
+            key = helper(_groupByAttributes.front());
         }
         else
         {
-            return new EntryT(this, t, _detachedQueue.end());
+            std::ostringstream os;
+            std::vector<std::string>::const_iterator q = _groupBySeparators.begin();
+            for(std::vector<std::string>::const_iterator p = _groupByAttributes.begin(); p != _groupByAttributes.end();
+                ++p)
+            {
+                os << helper(*p);
+                if(q != _groupBySeparators.end())
+                {
+                    os << *q++;
+                }
+            }
+            key = os.str();
         }
+        
+        Lock sync(*this);
+        typename std::map<std::string, EntryTPtr>::const_iterator p = _objects.find(key);
+        if(p == _objects.end())
+        {
+            p = _objects.insert(make_pair(key, newEntry(key))).first;
+        }
+        return p->second;
+    }
+    
+private:
+
+    virtual EntryTPtr newEntry(const std::string& id)
+    {
+        TPtr t = new T();
+        t->id = id;
+        t->failures = 0;
+        return new EntryT(this, t, _detachedQueue.end());
     }
 
     virtual MetricsMapI* clone() const
@@ -296,6 +378,55 @@ protected:
         return new MetricsMapT<MetricsType>(*this);
     }
 
+    void detached(EntryT* entry)
+    {
+        if(_retain == 0)
+        {
+            return;
+        }
+
+        Lock sync(*this);
+        assert(static_cast<int>(_detachedQueue.size()) <= _retain);
+
+        if(entry->_detachedPos != _detachedQueue.end())
+        {
+            _detachedQueue.splice(_detachedQueue.end(), _detachedQueue, entry->_detachedPos);
+            entry->_detachedPos = --_detachedQueue.end();
+            return;
+        }
+
+        if(static_cast<int>(_detachedQueue.size()) == _retain)
+        {
+            // Remove entries which are no longer detached
+            typename std::list<EntryT*>::iterator p = _detachedQueue.begin();
+            while(p != _detachedQueue.end())
+            {
+                if(!(*p)->isDetached())
+                {
+                    p = _detachedQueue.erase(p);
+                }
+                else
+                {
+                    ++p;
+                }
+            }
+        }
+
+        if(static_cast<int>(_detachedQueue.size()) == _retain)
+        {
+            // Remove oldest entry if there's still no room
+            _objects.erase(_detachedQueue.front()->_object->id);
+            _detachedQueue.pop_front();
+        }
+
+        _detachedQueue.push_back(entry);
+        entry->_detachedPos = --_detachedQueue.end();
+    }
+
+    friend class EntryT;
+    
+    std::map<std::string, EntryTPtr> _objects;
+    std::list<EntryT*> _detachedQueue;
     std::map<std::string, std::pair<SubMapMember, MetricsMapIPtr> > _subMaps;
 };
 
diff --git a/cpp/src/Ice/MetricsObserverI.h b/cpp/src/Ice/MetricsObserverI.h
index 0adfb9f4283..fee2ba2305b 100644
--- a/cpp/src/Ice/MetricsObserverI.h
+++ b/cpp/src/Ice/MetricsObserverI.h
@@ -261,13 +261,13 @@ private:
 
 class ObserverI;
 
-template<class MetricsType> class ObserverT : virtual public Ice::Instrumentation::Observer
+template<typename T> class ObserverT : virtual public Ice::Instrumentation::Observer
 {
 public:
 
-    typedef MetricsType Type;
-    typedef IceInternal::Handle<MetricsType> PtrType;
-    typedef std::vector<std::pair<PtrType, MetricsMapI::EntryPtr> > SeqType;
+    typedef T MetricsType;
+    typedef typename MetricsMapT<MetricsType>::EntryTPtr EntryPtrType;
+    typedef std::vector<EntryPtrType> EntrySeqType;
 
     ObserverT()
     {
@@ -283,54 +283,61 @@ public:
     detach()
     {
         Ice::Long lifetime = _watch.stop();
-        for(typename SeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
+        IceUtil::Mutex::Lock sync(*_mutex);
+        for(typename EntrySeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
         {
-            p->second->detach(lifetime);
+            (*p)->detach(lifetime);
         }
     }
 
     virtual void
     failed(const std::string& exceptionName)
     {
-        for(typename SeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
+        IceUtil::Mutex::Lock sync(*_mutex);
+        for(typename EntrySeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
         {
-            p->second->failed(exceptionName);
+            (*p)->failed(exceptionName);
         }
     }
 
     template<typename Function> void
     forEach(const Function& func)
     {
-        for(typename SeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
+        IceUtil::Mutex::Lock sync(*_mutex);
+        for(typename EntrySeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
         {
-            p->second->execute(func, p->first);
+            (*p)->execute(func);
         }
     }
     
     void
-    init(const MetricsHelperT<MetricsType>& helper, const std::vector<MetricsMapI::EntryPtr>& objects)
+    init(const MetricsHelperT<MetricsType>& helper, EntrySeqType& objects, IceUtil::Mutex* mutex)
     {
-        _objects.reserve(objects.size());
-        for(std::vector<MetricsMapI::EntryPtr>::const_iterator p = objects.begin(); p != objects.end(); ++p)
+        _mutex = mutex;
+        _objects.swap(objects);
+        std::sort(_objects.begin(), _objects.end());
+        for(typename EntrySeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
         {
-            _objects.push_back(std::make_pair((*p)->attach(helper), *p));
+            (*p)->attach(helper);
         }
     }
 
     void
-    update(const MetricsHelperT<MetricsType>& helper, const std::vector<MetricsMapI::EntryPtr>& objects)
+    update(const MetricsHelperT<MetricsType>& helper, EntrySeqType& objects)
     {
-        std::vector<MetricsMapI::EntryPtr>::const_iterator p = objects.begin();
-        typename SeqType::iterator q = _objects.begin();
+        std::sort(objects.begin(), objects.end());
+        typename EntrySeqType::const_iterator p = objects.begin();
+        typename EntrySeqType::iterator q = _objects.begin();
         while(p != objects.end())
         {
-            if(q == _objects.end() || *p < q->second) // New metrics object
+            if(q == _objects.end() || *p < *q) // New metrics object
             {
-                q = _objects.insert(q, std::make_pair((*p)->attach(helper), *p));
+                q = _objects.insert(q, *p);
+                (*p)->attach(helper);
                 ++p;
                 ++q;
             }
-            else if(*p == q->second) // Same metrics object
+            else if(*p == *q) // Same metrics object
             {
                 ++p;
                 ++q;
@@ -345,25 +352,32 @@ public:
     template<typename ObserverImpl, typename ObserverMetricsType> IceInternal::Handle<ObserverImpl>
     getObserver(const std::string& mapName, const MetricsHelperT<ObserverMetricsType>& helper)
     {
-        std::vector<MetricsMapI::EntryPtr> metricsObjects;
-        for(typename SeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
+        IceUtil::Mutex::Lock sync(*_mutex);
+        std::vector<typename MetricsMapT<ObserverMetricsType>::EntryTPtr> metricsObjects;
+        for(typename EntrySeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
         {
-            MetricsMapI::EntryPtr e = p->second->getMatching(mapName, helper);
+            typename MetricsMapT<ObserverMetricsType>::EntryTPtr e = (*p)->getMatching(mapName, helper);
             if(e)
             {
                 metricsObjects.push_back(e);
             }
         }
 
+        if(metricsObjects.empty())
+        {
+            return 0;
+        }
+
         IceInternal::Handle<ObserverImpl> obsv = new ObserverImpl();
-        obsv->init(helper, metricsObjects);
+        obsv->init(helper, metricsObjects, _mutex);
         return obsv;
     }
     
 private:
 
-    SeqType _objects;
+    EntrySeqType _objects;
     IceUtilInternal::StopWatch _watch;
+    IceUtil::Mutex* _mutex;
 };
 
 class ObserverI : virtual public Ice::Instrumentation::Observer, public ObserverT<Metrics>
@@ -388,22 +402,28 @@ class ObserverFactoryT : private IceUtil::Mutex
 public:
 
     typedef IceUtil::Handle<ObserverImplType> ObserverImplPtrType;
-    typedef typename ObserverImplType::Type MetricsType;
+    typedef typename ObserverImplType::MetricsType MetricsType;
+
+    typedef std::vector<IceUtil::Handle<MetricsMapT<MetricsType> > > MetricsMapSeqType;
 
     ObserverFactoryT(const MetricsAdminIPtr& metrics, const std::string& name) : _metrics(metrics), _name(name)
     {
         _metrics->registerMap<MetricsType>(name);
     }
 
+    ObserverFactoryT(const std::string& name) : _name(name)
+    {
+    }
+
     ObserverImplPtrType
     getObserver(const MetricsHelperT<MetricsType>& helper)
     {
         IceUtil::Mutex::Lock sync(*this);
 
-        std::vector<MetricsMapI::EntryPtr> metricsObjects;
-        for(std::vector<MetricsMapIPtr>::const_iterator p = _maps.begin(); p != _maps.end(); ++p)
+        typename ObserverImplType::EntrySeqType metricsObjects;
+        for(typename MetricsMapSeqType::const_iterator p = _maps.begin(); p != _maps.end(); ++p)
         {
-            MetricsMapI::EntryPtr entry = (*p)->getMatching(helper);
+            typename ObserverImplType::EntryPtrType entry = (*p)->getMatching(helper);
             if(entry)
             {
                 metricsObjects.push_back(entry);
@@ -415,8 +435,10 @@ public:
             return 0;
         }
 
+        std::sort(metricsObjects.begin(), metricsObjects.end());
+
         ObserverImplPtrType obsv = new ObserverImplType();
-        obsv->init(helper, metricsObjects);
+        obsv->init(helper, metricsObjects, this);
         return obsv;
     }
 
@@ -425,10 +447,10 @@ public:
     {
         IceUtil::Mutex::Lock sync(*this);
 
-        std::vector<MetricsMapI::EntryPtr> metricsObjects;
-        for(std::vector<MetricsMapIPtr>::const_iterator p = _maps.begin(); p != _maps.end(); ++p)
+        typename ObserverImplType::EntrySeqType metricsObjects;
+        for(typename MetricsMapSeqType::const_iterator p = _maps.begin(); p != _maps.end(); ++p)
         {
-            MetricsMapI::EntryPtr entry = (*p)->getMatching(helper);
+            typename ObserverImplType::EntryPtrType entry = (*p)->getMatching(helper);
             if(entry)
             {
                 metricsObjects.push_back(entry);
@@ -440,11 +462,13 @@ public:
             return 0;
         }
 
+        std::sort(metricsObjects.begin(), metricsObjects.end());
+
         ObserverImplPtrType obsv = ObserverImplPtrType::dynamicCast(observer);
         if(!obsv)
         {
             obsv = new ObserverImplType();
-            obsv->init(helper, metricsObjects);
+            obsv->init(helper, metricsObjects, this);
         }
         else
         {
@@ -467,7 +491,13 @@ public:
     void updateMaps()
     {
         IceUtil::Mutex::Lock sync(*this);
-        _maps = _metrics->getMaps(_name);
+        std::vector<MetricsMapIPtr> maps = _metrics->getMaps(_name);
+        _maps.clear();
+        for(std::vector<MetricsMapIPtr>::const_iterator p = maps.begin(); p != maps.end(); ++p)
+        {
+            _maps.push_back(IceUtil::Handle<MetricsMapT<MetricsType> >::dynamicCast(*p));
+            assert(_maps.back());
+        }
         _enabled = !_maps.empty();
     }
 
@@ -475,7 +505,7 @@ private:
 
     const MetricsAdminIPtr _metrics;
     const std::string _name;
-    std::vector<MetricsMapIPtr> _maps;
+    MetricsMapSeqType _maps;
     volatile bool _enabled;
 };
 
diff --git a/cpp/src/Ice/ObserverI.cpp b/cpp/src/Ice/ObserverI.cpp
index 5ec9296bbc3..715b6a180f0 100644
--- a/cpp/src/Ice/ObserverI.cpp
+++ b/cpp/src/Ice/ObserverI.cpp
@@ -696,13 +696,21 @@ CommunicatorObserverI::setObserverUpdater(const ObserverUpdaterPtr& updater)
 ObserverPtr
 CommunicatorObserverI::getConnectionEstablishmentObserver(const EndpointInfoPtr& endpt, const string& connector)
 {
-    return _connects.getObserver(EndpointHelper(endpt, connector));
+    if(_connects.isEnabled())
+    {
+        return _connects.getObserver(EndpointHelper(endpt, connector));
+    }
+    return 0;
 }
 
 ObserverPtr
 CommunicatorObserverI::getEndpointLookupObserver(const EndpointInfoPtr& endpt, const string& endpoint)
 {
-    return _endpointLookups.getObserver(EndpointHelper(endpt, endpoint));
+    if(_endpointLookups.isEnabled())
+    {
+        return _endpointLookups.getObserver(EndpointHelper(endpt, endpoint));
+    }
+    return 0;
 }
 
 ConnectionObserverPtr 
@@ -711,7 +719,11 @@ CommunicatorObserverI::getConnectionObserver(const ConnectionInfoPtr& con,
                                              ConnectionState state, 
                                              const ConnectionObserverPtr& observer)
 {
-    return _connections.getObserver(ConnectionHelper(con, endpt, state), observer);
+    if(_connections.isEnabled())
+    {
+        return _connections.getObserver(ConnectionHelper(con, endpt, state), observer);
+    }
+    return 0;
 }
 
 ThreadObserverPtr 
@@ -720,7 +732,11 @@ CommunicatorObserverI::getThreadObserver(const string& parent,
                                          ThreadState state,
                                          const ThreadObserverPtr& observer)
 {
-    return _threads.getObserver(ThreadHelper(parent, id, state), observer);
+    if(_threads.isEnabled())
+    {
+        return _threads.getObserver(ThreadHelper(parent, id, state), observer);
+    }
+    return 0;
 }
 
 InvocationObserverPtr 
@@ -736,13 +752,21 @@ CommunicatorObserverI::getInvocationObserver(const ObjectPrx& proxy, const strin
 InvocationObserverPtr 
 CommunicatorObserverI::getInvocationObserverWithContext(const ObjectPrx& proxy, const string& op, const Context& ctx)
 {
-    return _invocations.getObserver(InvocationHelper(proxy, op, ctx));
+    if(_invocations.isEnabled())
+    {
+        return _invocations.getObserver(InvocationHelper(proxy, op, ctx));
+    }
+    return 0;
 }
 
 ObserverPtr 
 CommunicatorObserverI::getDispatchObserver(const Current& current)
 {
-    return _dispatch.getObserver(DispatchHelper(current));
+    if(_dispatch.isEnabled())
+    {
+        return _dispatch.getObserver(DispatchHelper(current));
+    }
+    return 0;
 }
 
 void
diff --git a/cpp/src/Ice/ObserverI.h b/cpp/src/Ice/ObserverI.h
index 9ce1712bc55..c3954258ae8 100644
--- a/cpp/src/Ice/ObserverI.h
+++ b/cpp/src/Ice/ObserverI.h
@@ -40,9 +40,6 @@ public:
     virtual void retried();
 
     virtual Ice::Instrumentation::ObserverPtr getRemoteObserver(const Ice::ConnectionPtr&);
-
-private:
-
 };
 
 class CommunicatorObserverI : public Ice::Instrumentation::CommunicatorObserver, 
@@ -91,7 +88,7 @@ private:
     ObserverFactoryT<InvocationObserverI> _invocations;
     ObserverFactoryT<ThreadObserverI> _threads;
     ObserverFactoryT<ObserverI> _connects;
-    ObserverFactoryT<ObserverI>  _endpointLookups;
+    ObserverFactoryT<ObserverI> _endpointLookups;
 };
 typedef IceUtil::Handle<CommunicatorObserverI> CommunicatorObserverIPtr;