Fixed ICE-5196: allow setting an observer with IceMX enabled

11 files changed, 278 insertions, 66 deletions

diff --git a/cpp/src/Ice/CommunicatorI.cpp b/cpp/src/Ice/CommunicatorI.cpp
index f3e17c4dd2d..4646479d978 100644
--- a/cpp/src/Ice/CommunicatorI.cpp
+++ b/cpp/src/Ice/CommunicatorI.cpp
@@ -261,7 +261,7 @@ Ice::CommunicatorI::getStats() const
 Ice::Instrumentation::CommunicatorObserverPtr
 Ice::CommunicatorI::getObserver() const
 {
-    return _instance->initializationData().observer;
+    return _instance->getObserver();
 }
 
 RouterPrx
diff --git a/cpp/src/Ice/ConnectionFactory.cpp b/cpp/src/Ice/ConnectionFactory.cpp
index 60534489cd9..822e26b84ec 100644
--- a/cpp/src/Ice/ConnectionFactory.cpp
+++ b/cpp/src/Ice/ConnectionFactory.cpp
@@ -225,7 +225,7 @@ IceInternal::OutgoingConnectionFactory::create(const vector<EndpointIPtr>& endpt
     // Try to establish the connection to the connectors.
     //
     DefaultsAndOverridesPtr defaultsAndOverrides = _instance->defaultsAndOverrides();
-    const CommunicatorObserverPtr& obsv = _instance->initializationData().observer;
+    const CommunicatorObserverPtr& obsv = _instance->getObserver();
     vector<ConnectorInfo>::const_iterator q;
     for(q = connectors.begin(); q != connectors.end(); ++q)
     {
@@ -1122,7 +1122,7 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::nextConnector()
     try
     {
 
-        const CommunicatorObserverPtr& obsv = _factory->_instance->initializationData().observer;
+        const CommunicatorObserverPtr& obsv = _factory->_instance->getObserver();
         if(obsv)
         {
             _observer = obsv->getConnectionEstablishmentObserver(_iter->endpoint, _iter->connector->toString());
diff --git a/cpp/src/Ice/ConnectionI.cpp b/cpp/src/Ice/ConnectionI.cpp
index 8091d2f2233..fbf9b2ea5f6 100644
--- a/cpp/src/Ice/ConnectionI.cpp
+++ b/cpp/src/Ice/ConnectionI.cpp
@@ -525,11 +525,11 @@ Ice::ConnectionI::updateObserver()
         return;
     }
 
-    assert(_instance->initializationData().observer);
-    _observer.attach(_instance->initializationData().observer->getConnectionObserver(initConnectionInfo(),
-                                                                                     _endpoint, 
-                                                                                     toConnectionState(_state),
-                                                                                     _observer.get()));
+    assert(_instance->getObserver());
+    _observer.attach(_instance->getObserver()->getConnectionObserver(initConnectionInfo(),
+                                                                     _endpoint, 
+                                                                     toConnectionState(_state),
+                                                                     _observer.get()));
 }
 
 void
@@ -2188,16 +2188,16 @@ Ice::ConnectionI::setState(State state)
         }
     }
 
-    if(_instance->initializationData().observer)
+    if(_instance->getObserver())
     {
         ConnectionState oldState = toConnectionState(_state);
         ConnectionState newState = toConnectionState(state);
         if(oldState != newState)
         {
-            _observer.attach(_instance->initializationData().observer->getConnectionObserver(initConnectionInfo(),
-                                                                                             _endpoint, 
-                                                                                             newState,
-                                                                                             _observer.get()));
+            _observer.attach(_instance->getObserver()->getConnectionObserver(initConnectionInfo(),
+                                                                             _endpoint, 
+                                                                             newState,
+                                                                             _observer.get()));
         }
         if(_observer && state == StateClosed && _exception.get())
         {
diff --git a/cpp/src/Ice/EndpointI.cpp b/cpp/src/Ice/EndpointI.cpp
index a27c4082faf..7d70754021b 100644
--- a/cpp/src/Ice/EndpointI.cpp
+++ b/cpp/src/Ice/EndpointI.cpp
@@ -139,7 +139,7 @@ IceInternal::EndpointHostResolver::resolve(const string& host, int port, Ice::En
     }
 
     ObserverHelperT<> observer;
-    const CommunicatorObserverPtr& obsv = _instance->initializationData().observer;
+    const CommunicatorObserverPtr& obsv = _instance->getObserver();
     if(obsv)
     {
         observer.attach(obsv->getEndpointLookupObserver(endpoint));
@@ -201,7 +201,7 @@ IceInternal::EndpointHostResolver::resolve(const string& host, int port, Ice::En
     entry.endpoint = endpoint;
     entry.callback = callback;
 
-    const CommunicatorObserverPtr& obsv = _instance->initializationData().observer;
+    const CommunicatorObserverPtr& obsv = _instance->getObserver();
     if(obsv)
     {
         entry.observer = obsv->getEndpointLookupObserver(endpoint);
@@ -310,7 +310,7 @@ void
 IceInternal::EndpointHostResolver::updateObserver()
 {
     Lock sync(*this);
-    const CommunicatorObserverPtr& obsv = _instance->initializationData().observer;
+    const CommunicatorObserverPtr& obsv = _instance->getObserver();
     if(obsv)
     {
         _observer.attach(obsv->getThreadObserver("Communicator", name(), ThreadStateIdle, _observer.get()));
diff --git a/cpp/src/Ice/Incoming.cpp b/cpp/src/Ice/Incoming.cpp
index 928c3c50088..e516940c84f 100644
--- a/cpp/src/Ice/Incoming.cpp
+++ b/cpp/src/Ice/Incoming.cpp
@@ -592,7 +592,7 @@ IceInternal::Incoming::invoke(const ServantManagerPtr& servantManager, BasicStre
         _current.ctx.insert(_current.ctx.end(), pr);
     }
 
-    const CommunicatorObserverPtr& obsv = _is->instance()->initializationData().observer;
+    const CommunicatorObserverPtr& obsv = _is->instance()->getObserver();
     if(obsv)
     { 
         // Read the parameter encapsulation size.
diff --git a/cpp/src/Ice/Instance.cpp b/cpp/src/Ice/Instance.cpp
index f5a61cb9995..19fa9701352 100644
--- a/cpp/src/Ice/Instance.cpp
+++ b/cpp/src/Ice/Instance.cpp
@@ -1148,18 +1148,20 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi
         // Setup the communicator observer only if the user didn't already set an
         // Ice observer resolver and if the admininistrative endpoints are set.
         //
-        if(!_initData.observer && 
-           (_adminFacetFilter.empty() || _adminFacetFilter.find("Metrics") != _adminFacetFilter.end()) &&
+        if((_adminFacetFilter.empty() || _adminFacetFilter.find("Metrics") != _adminFacetFilter.end()) &&
            _initData.properties->getProperty("Ice.Admin.Endpoints") != "")
         {
-            CommunicatorObserverIPtr observer = new CommunicatorObserverI(_metricsAdmin);
-            _initData.observer = observer;
+            _observer = new CommunicatorObserverI(_metricsAdmin, _initData.observer);
 
             //
             // Make sure the admin plugin receives property updates.
             //
             props->addUpdateCallback(_metricsAdmin);
         }
+        else
+        {
+            _observer = _initData.observer;
+        }
 
         __setNoDelete(false);
     }
@@ -1229,10 +1231,10 @@ IceInternal::Instance::finishSetup(int& argc, char* argv[])
     //
     // Set observer updater
     //
-    if(_initData.observer)
+    if(_observer)
     {
-        theCollector->updateObserver(_initData.observer);
-        _initData.observer->setObserverUpdater(new ObserverUpdaterI(this));
+        theCollector->updateObserver(_observer);
+        _observer->setObserverUpdater(new ObserverUpdaterI(this));
     }
 
     //
@@ -1398,18 +1400,20 @@ IceInternal::Instance::destroy()
         _retryQueue->destroy();
     }
 
-    if(_initData.observer && theCollector)
+    if(_observer && theCollector)
     {
-        theCollector->clearObserver(_initData.observer);
+        theCollector->clearObserver(_observer);
     }
 
     if(_metricsAdmin)
     {
         _metricsAdmin->destroy();
         _metricsAdmin = 0;
-        if(CommunicatorObserverIPtr::dynamicCast(_initData.observer))
+
+        // Break cyclic reference counts. Don't clear _observer, it's immutable.
+        if(_observer)
         {
-            _initData.observer = 0; // Clear cyclic reference counts.
+            CommunicatorObserverIPtr::dynamicCast(_observer)->destroy(); 
         }
     }
 
@@ -1567,7 +1571,7 @@ IceInternal::Instance::updateThreadObservers()
             _endpointHostResolver->updateObserver();
         }
         assert(theCollector);
-        theCollector->updateObserver(_initData.observer);
+        theCollector->updateObserver(_observer);
     }
     catch(const Ice::CommunicatorDestroyedException&)
     {
diff --git a/cpp/src/Ice/Instance.h b/cpp/src/Ice/Instance.h
index 16aa25648b0..34261196016 100644
--- a/cpp/src/Ice/Instance.h
+++ b/cpp/src/Ice/Instance.h
@@ -93,6 +93,11 @@ public:
     void addAdminFacet(const Ice::ObjectPtr&, const std::string&);
     Ice::ObjectPtr removeAdminFacet(const std::string&);
     Ice::ObjectPtr findAdminFacet(const std::string&);
+
+    const Ice::Instrumentation::CommunicatorObserverPtr& getObserver() const
+    {
+        return _observer;
+    }
     
     const Ice::ImplicitContextIPtr& getImplicitContext() const
     {
@@ -157,6 +162,7 @@ private:
     Ice::Identity _adminIdentity;
     std::set<std::string> _adminFacetFilter;
     IceInternal::MetricsAdminIPtr _metricsAdmin;
+    Ice::Instrumentation::CommunicatorObserverPtr _observer;
 };
 
 class ProcessI : public Ice::Process
diff --git a/cpp/src/Ice/InstrumentationI.cpp b/cpp/src/Ice/InstrumentationI.cpp
index 82598bbf1dc..fcfae4200a7 100644
--- a/cpp/src/Ice/InstrumentationI.cpp
+++ b/cpp/src/Ice/InstrumentationI.cpp
@@ -694,48 +694,81 @@ void
 ConnectionObserverI::sentBytes(Int num)
 {
     forEach(add(&ConnectionMetrics::sentBytes, num));
+    if(_delegate)
+    {
+        _delegate->sentBytes(num);
+    }
 }
 
 void 
 ConnectionObserverI::receivedBytes(Int num)
 {
     forEach(add(&ConnectionMetrics::receivedBytes, num));
+    if(_delegate)
+    {
+        _delegate->receivedBytes(num);
+    }
 }
 
 void
 ThreadObserverI::stateChanged(ThreadState oldState, ThreadState newState)
 {
     forEach(ThreadStateChanged(oldState, newState));
+    if(_delegate)
+    {
+        _delegate->stateChanged(oldState, newState);
+    }
+
 }
 
 void
 DispatchObserverI::userException()
 {
     forEach(inc(&DispatchMetrics::userException));
+    if(_delegate)
+    {
+        _delegate->userException();
+    }
 }
 
 void
 DispatchObserverI::reply(Int size)
 {
     forEach(add(&DispatchMetrics::replySize, size));
+    if(_delegate)
+    {
+        _delegate->reply(size);
+    }
 }
 
 void
 RemoteObserverI::reply(Int size)
 {
     forEach(add(&RemoteMetrics::replySize, size));
+    if(_delegate)
+    {
+        _delegate->reply(size);
+    }
 }
 
 void
 InvocationObserverI::retried()
 {
     forEach(inc(&InvocationMetrics::retry));
+    if(_delegate)
+    {
+        _delegate->retried();
+    }
 }
 
 void
 InvocationObserverI::userException()
 {
     forEach(inc(&InvocationMetrics::userException));
+    if(_delegate)
+    {
+        _delegate->userException();
+    }
 }
 
 RemoteObserverPtr
@@ -746,7 +779,14 @@ InvocationObserverI::getRemoteObserver(const ConnectionInfoPtr& connection,
 {
     try
     {
-        return getObserver<RemoteObserverI>("Remote", RemoteInvocationHelper(connection, endpoint, requestId, size));
+        RemoteObserverPtr delegate;
+        if(_delegate)
+        {
+            delegate = _delegate->getRemoteObserver(connection, endpoint, requestId, size);
+        }
+        return getObserver<RemoteObserverI>("Remote", 
+                                            RemoteInvocationHelper(connection, endpoint, requestId, size),
+                                            delegate);
     }
     catch(const exception&)
     {
@@ -754,8 +794,11 @@ InvocationObserverI::getRemoteObserver(const ConnectionInfoPtr& connection,
     return 0;
 }
 
-CommunicatorObserverI::CommunicatorObserverI(const IceInternal::MetricsAdminIPtr& metrics) : 
+CommunicatorObserverI::CommunicatorObserverI(const IceInternal::MetricsAdminIPtr& metrics,
+                                             const Ice::Instrumentation::CommunicatorObserverPtr& delegate) : 
     _metrics(metrics),
+    _logger(metrics->getLogger()),
+    _delegate(delegate),
     _connections(metrics, "Connection"),
     _dispatch(metrics, "Dispatch"),
     _invocations(metrics, "Invocation"),
@@ -771,6 +814,10 @@ CommunicatorObserverI::setObserverUpdater(const ObserverUpdaterPtr& updater)
 {
     _connections.setUpdater(newUpdater(updater, &ObserverUpdater::updateConnectionObservers));
     _threads.setUpdater(newUpdater(updater, &ObserverUpdater::updateThreadObservers));
+    if(_delegate)
+    {
+        _delegate->setObserverUpdater(updater);
+    }
 }
 
 ObserverPtr
@@ -780,11 +827,16 @@ CommunicatorObserverI::getConnectionEstablishmentObserver(const EndpointPtr& end
     {
         try
         {
-            return _connects.getObserver(EndpointHelper(endpt, connector));
+            ObserverPtr delegate;
+            if(_delegate)
+            {
+                delegate = _delegate->getConnectionEstablishmentObserver(endpt, connector);
+            }
+            return _connects.getObserver(EndpointHelper(endpt, connector), delegate);
         }
         catch(const exception& ex)
         {
-            Error error(_metrics->getLogger());
+            Error error(_logger);
             error << "unexpected exception trying to obtain observer:\n" << ex;
         }
     }
@@ -798,11 +850,16 @@ CommunicatorObserverI::getEndpointLookupObserver(const EndpointPtr& endpt)
     {
         try
         {
-            return _endpointLookups.getObserver(EndpointHelper(endpt));
+            ObserverPtr delegate;
+            if(_delegate)
+            {
+                delegate = _delegate->getEndpointLookupObserver(endpt);
+            }
+            return _endpointLookups.getObserver(EndpointHelper(endpt), delegate);
         }
         catch(const exception& ex)
         {
-            Error error(_metrics->getLogger());
+            Error error(_logger);
             error << "unexpected exception trying to obtain observer:\n" << ex;
         }
     }
@@ -819,11 +876,17 @@ CommunicatorObserverI::getConnectionObserver(const ConnectionInfoPtr& con,
     {
         try
         {
-            return _connections.getObserver(ConnectionHelper(con, endpt, state), observer);
+            ConnectionObserverPtr delegate;
+            ConnectionObserverI* o = dynamic_cast<ConnectionObserverI*>(observer.get());
+            if(_delegate)
+            {
+                delegate = _delegate->getConnectionObserver(con, endpt, state, o ? o->getDelegate() : observer);
+            }
+            return _connections.getObserver(ConnectionHelper(con, endpt, state), delegate, observer);
         }
         catch(const exception& ex)
         {
-            Error error(_metrics->getLogger());
+            Error error(_logger);
             error << "unexpected exception trying to obtain observer:\n" << ex;
         }
     }
@@ -840,11 +903,17 @@ CommunicatorObserverI::getThreadObserver(const string& parent,
     {
         try
         {
-            return _threads.getObserver(ThreadHelper(parent, id, state), observer);
+            ThreadObserverPtr delegate;
+            ThreadObserverI* o = dynamic_cast<ThreadObserverI*>(observer.get());
+            if(_delegate)
+            {
+                delegate = _delegate->getThreadObserver(parent, id, state, o ? o->getDelegate() : observer);
+            }
+            return _threads.getObserver(ThreadHelper(parent, id, state), delegate, observer);
         }
         catch(const exception& ex)
         {
-            Error error(_metrics->getLogger());
+            Error error(_logger);
             error << "unexpected exception trying to obtain observer:\n" << ex;
         }
     }
@@ -858,11 +927,16 @@ CommunicatorObserverI::getInvocationObserver(const ObjectPrx& proxy, const strin
     {
         try
         {
-            return _invocations.getObserver(InvocationHelper(proxy, op, ctx));
+            InvocationObserverPtr delegate;
+            if(_delegate)
+            {
+                delegate = _delegate->getInvocationObserver(proxy, op, ctx);
+            }
+            return _invocations.getObserver(InvocationHelper(proxy, op, ctx), delegate);
         }
         catch(const exception& ex)
         {
-            Error error(_metrics->getLogger());
+            Error error(_logger);
             error << "unexpected exception trying to obtain observer:\n" << ex;
         }
     }
@@ -876,11 +950,16 @@ CommunicatorObserverI::getDispatchObserver(const Current& current, int size)
     {
         try
         {
-            return _dispatch.getObserver(DispatchHelper(current, size));
+            DispatchObserverPtr delegate;
+            if(_delegate)
+            {
+                delegate = _delegate->getDispatchObserver(current, size);
+            }
+            return _dispatch.getObserver(DispatchHelper(current, size), delegate);
         }
         catch(const exception& ex)
         {
-            Error error(_metrics->getLogger());
+            Error error(_logger);
             error << "unexpected exception trying to obtain observer:\n" << ex;
         }
     }
@@ -890,5 +969,18 @@ CommunicatorObserverI::getDispatchObserver(const Current& current, int size)
 const IceInternal::MetricsAdminIPtr& 
 CommunicatorObserverI::getMetricsAdmin() const
 {
+    assert(_metrics);
     return _metrics;
 }
+
+void
+CommunicatorObserverI::destroy()
+{
+    _metrics = 0;
+    _connections.destroy();
+    _dispatch.destroy();
+    _invocations.destroy();
+    _threads.destroy();
+    _connects.destroy();
+    _endpointLookups.destroy();
+}
diff --git a/cpp/src/Ice/InstrumentationI.h b/cpp/src/Ice/InstrumentationI.h
index 9f6b61327b9..1db093feae2 100644
--- a/cpp/src/Ice/InstrumentationI.h
+++ b/cpp/src/Ice/InstrumentationI.h
@@ -16,6 +16,109 @@
 namespace IceInternal
 {
 
+template<typename T, typename O> class ObserverWithDelegateT : public IceMX::ObserverT<T>, virtual public O
+{
+public:
+
+    typedef O ObserverType;
+    typedef typename IceInternal::Handle<O> ObserverPtrType;
+
+    virtual void 
+    attach()
+    {
+        IceMX::ObserverT<T>::attach();
+        if(_delegate)
+        {
+            _delegate->attach();
+        }
+    }
+
+    virtual void 
+    detach()
+    {
+        IceMX::ObserverT<T>::detach();
+        if(_delegate)
+        {
+            _delegate->detach();
+        }
+    }
+
+    virtual void
+    failed(const std::string& exceptionName)
+    {
+        IceMX::ObserverT<T>::failed(exceptionName);
+        if(_delegate)
+        {
+            _delegate->failed(exceptionName);
+        }
+    }
+
+    ObserverPtrType
+    getDelegate() const
+    {
+        return _delegate;
+    }
+
+    void
+    setDelegate(ObserverPtrType delegate)
+    {
+        _delegate = delegate;
+    }
+
+    template<typename ObserverImpl, typename ObserverMetricsType, typename ObserverPtrType> ObserverPtrType 
+    getObserver(const std::string& mapName, const IceMX::MetricsHelperT<ObserverMetricsType>& helper, 
+                const ObserverPtrType& del)
+    {
+        IceInternal::Handle<ObserverImpl> obsv = IceMX::ObserverT<T>::template getObserver<ObserverImpl>(mapName, 
+                                                                                                         helper);
+        if(obsv)
+        {
+            obsv->setDelegate(del);
+            return obsv;
+        }
+        return del;
+    }
+
+protected:
+
+    ObserverPtrType _delegate;
+};
+
+template<typename T> class ObserverFactoryWithDelegateT : public IceMX::ObserverFactoryT<T>
+{
+public:
+
+    ObserverFactoryWithDelegateT(const IceInternal::MetricsAdminIPtr& metrics, const std::string& name) : 
+        IceMX::ObserverFactoryT<T>(metrics, name)
+    {
+    }
+
+    template<typename ObserverMetricsType, typename ObserverPtrType> ObserverPtrType 
+    getObserver(const IceMX::MetricsHelperT<ObserverMetricsType>& helper, const ObserverPtrType& del)
+    {
+        IceInternal::Handle<T> obsv = IceMX::ObserverFactoryT<T>::getObserver(helper);
+        if(obsv)
+        {
+            obsv->setDelegate(del);
+            return obsv;
+        }
+        return del;
+    }
+
+    template<typename ObserverMetricsType, typename ObserverPtrType> ObserverPtrType 
+    getObserver(const IceMX::MetricsHelperT<ObserverMetricsType>& helper, const ObserverPtrType& del, 
+                const ObserverPtrType& old)
+    {
+        IceInternal::Handle<T> obsv = IceMX::ObserverFactoryT<T>::getObserver(helper, old);
+        if(obsv)
+        {
+            obsv->setDelegate(del);
+            return obsv;
+        }
+        return del;
+    }
+};
+
 template<typename Helper>
 void addEndpointAttributes(typename Helper::Attributes& attrs)
 {
@@ -49,8 +152,8 @@ void addConnectionAttributes(typename Helper::Attributes& attrs)
     addEndpointAttributes<Helper>(attrs);
 }
 
-class ConnectionObserverI : public Ice::Instrumentation::ConnectionObserver, 
-                            public IceMX::ObserverT<IceMX::ConnectionMetrics>
+class ConnectionObserverI : public ObserverWithDelegateT<IceMX::ConnectionMetrics, 
+                                                         Ice::Instrumentation::ConnectionObserver>
 {
 public:
 
@@ -58,16 +161,14 @@ public:
     virtual void receivedBytes(Ice::Int);
 };
 
-class ThreadObserverI : public Ice::Instrumentation::ThreadObserver, 
-                        public IceMX::ObserverT<IceMX::ThreadMetrics>
+class ThreadObserverI : public ObserverWithDelegateT<IceMX::ThreadMetrics, Ice::Instrumentation::ThreadObserver>
 {
 public:
 
     virtual void stateChanged(Ice::Instrumentation::ThreadState, Ice::Instrumentation::ThreadState);
 };
 
-class DispatchObserverI : public Ice::Instrumentation::DispatchObserver, 
-                          public IceMX::ObserverT<IceMX::DispatchMetrics>
+class DispatchObserverI : public ObserverWithDelegateT<IceMX::DispatchMetrics, Ice::Instrumentation::DispatchObserver>
 {
 public:
 
@@ -76,14 +177,15 @@ public:
     virtual void reply(Ice::Int);
 };
 
-class RemoteObserverI : public Ice::Instrumentation::RemoteObserver, 
-                        public IceMX::ObserverT<IceMX::RemoteMetrics>
+class RemoteObserverI : public ObserverWithDelegateT<IceMX::RemoteMetrics, Ice::Instrumentation::RemoteObserver>
 {
+public:
+
     virtual void reply(Ice::Int);
 };
 
-class InvocationObserverI : public Ice::Instrumentation::InvocationObserver, 
-                            public IceMX::ObserverT<IceMX::InvocationMetrics>
+class InvocationObserverI : public ObserverWithDelegateT<IceMX::InvocationMetrics, 
+                                                         Ice::Instrumentation::InvocationObserver>
 {
 public:
 
@@ -95,11 +197,15 @@ public:
                                                                       const Ice::EndpointPtr&, Ice::Int, Ice::Int);
 };
 
+typedef ObserverWithDelegateT<IceMX::Metrics, Ice::Instrumentation::Observer> ObserverI;
+
 class ICE_API CommunicatorObserverI : public Ice::Instrumentation::CommunicatorObserver
 {
 public:
 
-    CommunicatorObserverI(const IceInternal::MetricsAdminIPtr&);
+    CommunicatorObserverI(const IceInternal::MetricsAdminIPtr&,
+                          const Ice::Instrumentation::CommunicatorObserverPtr& = 
+                          Ice::Instrumentation::CommunicatorObserverPtr());
 
     virtual void setObserverUpdater(const Ice::Instrumentation::ObserverUpdaterPtr&);
  
@@ -126,16 +232,20 @@ public:
 
     const IceInternal::MetricsAdminIPtr& getMetricsAdmin() const;
 
+    void destroy();
+
 private:
 
-    const IceInternal::MetricsAdminIPtr _metrics;
+    IceInternal::MetricsAdminIPtr _metrics;
+    Ice::LoggerPtr _logger;
+    const Ice::Instrumentation::CommunicatorObserverPtr _delegate;
 
-    IceMX::ObserverFactoryT<ConnectionObserverI> _connections;
-    IceMX::ObserverFactoryT<DispatchObserverI> _dispatch;
-    IceMX::ObserverFactoryT<InvocationObserverI> _invocations;
-    IceMX::ObserverFactoryT<ThreadObserverI> _threads;
-    IceMX::ObserverFactoryT<IceMX::ObserverI> _connects;
-    IceMX::ObserverFactoryT<IceMX::ObserverI> _endpointLookups;
+    ObserverFactoryWithDelegateT<ConnectionObserverI> _connections;
+    ObserverFactoryWithDelegateT<DispatchObserverI> _dispatch;
+    ObserverFactoryWithDelegateT<InvocationObserverI> _invocations;
+    ObserverFactoryWithDelegateT<ThreadObserverI> _threads;
+    ObserverFactoryWithDelegateT<ObserverI> _connects;
+    ObserverFactoryWithDelegateT<ObserverI> _endpointLookups;
 };
 typedef IceUtil::Handle<CommunicatorObserverI> CommunicatorObserverIPtr;
 
diff --git a/cpp/src/Ice/ObserverHelper.cpp b/cpp/src/Ice/ObserverHelper.cpp
index ca148bff6da..4215d77eabd 100644
--- a/cpp/src/Ice/ObserverHelper.cpp
+++ b/cpp/src/Ice/ObserverHelper.cpp
@@ -25,7 +25,7 @@ Ice::Context emptyCtx;
 
 IceInternal::InvocationObserver::InvocationObserver(IceProxy::Ice::Object* proxy, const string& op, const Context* ctx)
 {
-    const CommunicatorObserverPtr& obsv = proxy->__reference()->getInstance()->initializationData().observer;
+    const CommunicatorObserverPtr& obsv = proxy->__reference()->getInstance()->getObserver();
     if(!obsv)
     {
         return;
@@ -43,7 +43,7 @@ IceInternal::InvocationObserver::InvocationObserver(IceProxy::Ice::Object* proxy
 
 IceInternal::InvocationObserver::InvocationObserver(IceInternal::Instance* instance, const string& op)
 {
-    const CommunicatorObserverPtr& obsv = instance->initializationData().observer;
+    const CommunicatorObserverPtr& obsv = instance->getObserver();
     if(!obsv)
     {
         return;
@@ -55,7 +55,7 @@ IceInternal::InvocationObserver::InvocationObserver(IceInternal::Instance* insta
 void
 IceInternal::InvocationObserver::attach(IceProxy::Ice::Object* proxy, const string& op, const Context* ctx)
 {
-    const CommunicatorObserverPtr& obsv = proxy->__reference()->getInstance()->initializationData().observer;
+    const CommunicatorObserverPtr& obsv = proxy->__reference()->getInstance()->getObserver();
     if(!obsv)
     {
         return;
@@ -74,7 +74,7 @@ IceInternal::InvocationObserver::attach(IceProxy::Ice::Object* proxy, const stri
 void
 IceInternal::InvocationObserver::attach(IceInternal::Instance* instance, const string& op)
 {
-    const CommunicatorObserverPtr& obsv = instance->initializationData().observer;
+    const CommunicatorObserverPtr& obsv = instance->getObserver();
     if(!obsv)
     {
         return;
diff --git a/cpp/src/Ice/ThreadPool.cpp b/cpp/src/Ice/ThreadPool.cpp
index 62652c786d2..2234e8c7ceb 100644
--- a/cpp/src/Ice/ThreadPool.cpp
+++ b/cpp/src/Ice/ThreadPool.cpp
@@ -1128,7 +1128,7 @@ void
 IceInternal::ThreadPool::EventHandlerThread::updateObserver()
 {
     // Must be called with the thread pool mutex locked
-    const CommunicatorObserverPtr& obsv = _pool->_instance->initializationData().observer;
+    const CommunicatorObserverPtr& obsv = _pool->_instance->getObserver();
     if(obsv)
     {
         _observer.attach(obsv->getThreadObserver(_pool->_prefix, name(), _state, _observer.get()));