zeroc-ice 3.6b1

data/ext/ice/cpp/src/Ice/Instance.h

@@ -0,0 +1,198 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_INSTANCE_H
+#define ICE_INSTANCE_H
+
+#include <IceUtil/Config.h>
+#include <IceUtil/Shared.h>
+#include <IceUtil/Mutex.h>
+#include <IceUtil/RecMutex.h>
+#include <IceUtil/Timer.h>
+#include <IceUtil/StringConverter.h>
+#include <Ice/InstanceF.h>
+#include <Ice/CommunicatorF.h>
+#include <Ice/InstrumentationF.h>
+#include <Ice/TraceLevelsF.h>
+#include <Ice/DefaultsAndOverridesF.h>
+#include <Ice/RouterInfoF.h>
+#include <Ice/LocatorInfoF.h>
+#include <Ice/ReferenceFactoryF.h>
+#include <Ice/ProxyFactoryF.h>
+#include <Ice/ThreadPoolF.h>
+#include <Ice/ConnectionFactoryF.h>
+#include <Ice/ACM.h>
+#include <Ice/ObjectFactoryManagerF.h>
+#include <Ice/ObjectAdapterFactoryF.h>
+#include <Ice/EndpointFactoryManagerF.h>
+#include <Ice/IPEndpointIF.h>
+#include <Ice/RetryQueueF.h>
+#include <Ice/DynamicLibraryF.h>
+#include <Ice/PluginF.h>
+#include <Ice/NetworkF.h>
+#include <Ice/NetworkProxyF.h>
+#include <Ice/Initialize.h>
+#include <Ice/ImplicitContextI.h>
+#include <Ice/FacetMap.h>
+#include <Ice/Process.h>
+#include <list>
+#include <IceUtil/UniquePtr.h>
+
+namespace Ice
+{
+
+class CommunicatorI;
+
+}
+
+namespace IceInternal
+{
+
+class Timer;
+typedef IceUtil::Handle<Timer> TimerPtr;
+
+class MetricsAdminI;
+typedef IceUtil::Handle<MetricsAdminI> MetricsAdminIPtr;
+
+class RequestHandlerFactory;
+typedef IceUtil::Handle<RequestHandlerFactory> RequestHandlerFactoryPtr;
+
+class Instance : public IceUtil::Shared, public IceUtil::Monitor<IceUtil::RecMutex>
+{
+public:
+
+    bool destroyed() const;
+    const Ice::InitializationData& initializationData() const { return _initData; }
+    TraceLevelsPtr traceLevels() const;
+    DefaultsAndOverridesPtr defaultsAndOverrides() const;
+    RouterManagerPtr routerManager() const;
+    LocatorManagerPtr locatorManager() const;
+    ReferenceFactoryPtr referenceFactory() const;
+    RequestHandlerFactoryPtr requestHandlerFactory() const;
+    ProxyFactoryPtr proxyFactory() const;
+    OutgoingConnectionFactoryPtr outgoingConnectionFactory() const;
+    ObjectFactoryManagerPtr servantFactoryManager() const;
+    ObjectAdapterFactoryPtr objectAdapterFactory() const;
+    ProtocolSupport protocolSupport() const;
+    bool preferIPv6() const;
+    NetworkProxyPtr networkProxy() const;
+    ThreadPoolPtr clientThreadPool();
+    ThreadPoolPtr serverThreadPool();
+    EndpointHostResolverPtr endpointHostResolver();
+    RetryQueuePtr retryQueue();
+    IceUtil::TimerPtr timer();
+    EndpointFactoryManagerPtr endpointFactoryManager() const;
+    DynamicLibraryListPtr dynamicLibraryList() const;
+    Ice::PluginManagerPtr pluginManager() const;
+    size_t messageSizeMax() const { return _messageSizeMax; }
+    size_t batchAutoFlushSize() const { return _batchAutoFlushSize; }
+    bool collectObjects() const { return _collectObjects; }
+    const ACMConfig& clientACM() const;
+    const ACMConfig& serverACM() const;
+    Ice::Identity stringToIdentity(const std::string&) const;
+    std::string identityToString(const Ice::Identity&) const;
+
+    Ice::ObjectPrx createAdmin(const Ice::ObjectAdapterPtr&, const Ice::Identity&);
+    Ice::ObjectPrx getAdmin();
+    void addAdminFacet(const Ice::ObjectPtr&, const std::string&);
+    Ice::ObjectPtr removeAdminFacet(const std::string&);
+    Ice::ObjectPtr findAdminFacet(const std::string&);
+    Ice::FacetMap findAllAdminFacets();
+
+    const Ice::ImplicitContextIPtr& getImplicitContext() const
+    {
+        return _implicitContext;
+    }
+
+    void setDefaultLocator(const Ice::LocatorPrx&);
+    void setDefaultRouter(const Ice::RouterPrx&);
+
+    void setLogger(const Ice::LoggerPtr&);
+    void setThreadHook(const Ice::ThreadNotificationPtr&);
+
+    IceUtil::StringConverterPtr getStringConverter() const { return _stringConverter; }
+    IceUtil::WstringConverterPtr getWstringConverter() const { return _wstringConverter; }
+   
+private:
+
+    Instance(const Ice::CommunicatorPtr&, const Ice::InitializationData&);
+    virtual ~Instance();
+    void finishSetup(int&, char*[], const Ice::CommunicatorPtr&);
+    void destroy();
+    friend class Ice::CommunicatorI;
+
+    void updateConnectionObservers();
+    void updateThreadObservers();
+    friend class ObserverUpdaterI;
+
+    void addAllAdminFacets();
+    void setServerProcessProxy(const Ice::ObjectAdapterPtr&, const Ice::Identity&);
+
+    enum State
+    {
+        StateActive,
+        StateDestroyInProgress,
+        StateDestroyed
+    };
+    State _state;
+    Ice::InitializationData _initData;
+    const TraceLevelsPtr _traceLevels; // Immutable, not reset by destroy().
+    const DefaultsAndOverridesPtr _defaultsAndOverrides; // Immutable, not reset by destroy().
+    const size_t _messageSizeMax; // Immutable, not reset by destroy().
+    const size_t _batchAutoFlushSize; // Immutable, not reset by destroy().
+    const bool _collectObjects; // Immutable, not reset by destroy().
+    ACMConfig _clientACM;
+    ACMConfig _serverACM;
+    RouterManagerPtr _routerManager;
+    LocatorManagerPtr _locatorManager;
+    ReferenceFactoryPtr _referenceFactory;
+    RequestHandlerFactoryPtr _requestHandlerFactory;
+    ProxyFactoryPtr _proxyFactory;
+    OutgoingConnectionFactoryPtr _outgoingConnectionFactory;
+    ObjectFactoryManagerPtr _servantFactoryManager;
+    ObjectAdapterFactoryPtr _objectAdapterFactory;
+    ProtocolSupport _protocolSupport;
+    bool _preferIPv6;
+    NetworkProxyPtr _networkProxy;
+    ThreadPoolPtr _clientThreadPool;
+    ThreadPoolPtr _serverThreadPool;
+    EndpointHostResolverPtr _endpointHostResolver;
+    RetryQueuePtr _retryQueue;
+    TimerPtr _timer;
+    EndpointFactoryManagerPtr _endpointFactoryManager;
+    DynamicLibraryListPtr _dynamicLibraryList;
+    Ice::PluginManagerPtr _pluginManager;
+    const Ice::ImplicitContextIPtr _implicitContext;
+    IceUtil::StringConverterPtr _stringConverter;
+    IceUtil::WstringConverterPtr _wstringConverter;
+    bool _adminEnabled;
+    Ice::ObjectAdapterPtr _adminAdapter;
+    Ice::FacetMap _adminFacets;
+    Ice::Identity _adminIdentity;
+    std::set<std::string> _adminFacetFilter;
+    IceInternal::MetricsAdminIPtr _metricsAdmin;
+};
+
+class ProcessI : public Ice::Process
+{
+public:
+
+    ProcessI(const Ice::CommunicatorPtr&);
+
+    virtual void shutdown(const Ice::Current&);
+    virtual void writeMessage(const std::string&, Ice::Int, const Ice::Current&);
+
+private:
+
+    const Ice::CommunicatorPtr _communicator;
+};
+
+}
+
+#endif

data/ext/ice/cpp/src/Ice/Instrumentation.cpp

@@ -0,0 +1,68 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+//
+// Ice version 3.6b
+//
+// <auto-generated>
+//
+// Generated from file `Instrumentation.ice'
+//
+// Warning: do not edit this file.
+//
+// </auto-generated>
+//
+
+#ifndef ICE_API_EXPORTS
+#   define ICE_API_EXPORTS
+#endif
+#include <Ice/Instrumentation.h>
+#include <IceUtil/PushDisableWarnings.h>
+#include <Ice/BasicStream.h>
+#include <IceUtil/Iterator.h>
+#include <IceUtil/PopDisableWarnings.h>
+
+#ifndef ICE_IGNORE_VERSION
+#   if ICE_INT_VERSION  != 30651
+#       error Ice version mismatch: an exact match is required for beta generated code
+#   endif
+#endif
+
+namespace
+{
+
+namespace
+{
+
+}
+
+}
+
+namespace Ice
+{
+}
+
+ICE_DECLSPEC_EXPORT ::Ice::LocalObject* Ice::Instrumentation::upCast(::Ice::Instrumentation::Observer* p) { return p; }
+
+ICE_DECLSPEC_EXPORT ::Ice::LocalObject* Ice::Instrumentation::upCast(::Ice::Instrumentation::ThreadObserver* p) { return p; }
+
+ICE_DECLSPEC_EXPORT ::Ice::LocalObject* Ice::Instrumentation::upCast(::Ice::Instrumentation::ConnectionObserver* p) { return p; }
+
+ICE_DECLSPEC_EXPORT ::Ice::LocalObject* Ice::Instrumentation::upCast(::Ice::Instrumentation::DispatchObserver* p) { return p; }
+
+ICE_DECLSPEC_EXPORT ::Ice::LocalObject* Ice::Instrumentation::upCast(::Ice::Instrumentation::ChildInvocationObserver* p) { return p; }
+
+ICE_DECLSPEC_EXPORT ::Ice::LocalObject* Ice::Instrumentation::upCast(::Ice::Instrumentation::RemoteObserver* p) { return p; }
+
+ICE_DECLSPEC_EXPORT ::Ice::LocalObject* Ice::Instrumentation::upCast(::Ice::Instrumentation::CollocatedObserver* p) { return p; }
+
+ICE_DECLSPEC_EXPORT ::Ice::LocalObject* Ice::Instrumentation::upCast(::Ice::Instrumentation::InvocationObserver* p) { return p; }
+
+ICE_DECLSPEC_EXPORT ::Ice::LocalObject* Ice::Instrumentation::upCast(::Ice::Instrumentation::ObserverUpdater* p) { return p; }
+
+ICE_DECLSPEC_EXPORT ::Ice::LocalObject* Ice::Instrumentation::upCast(::Ice::Instrumentation::CommunicatorObserver* p) { return p; }

data/ext/ice/cpp/src/Ice/InstrumentationF.cpp

@@ -0,0 +1,43 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+//
+// Ice version 3.6b
+//
+// <auto-generated>
+//
+// Generated from file `InstrumentationF.ice'
+//
+// Warning: do not edit this file.
+//
+// </auto-generated>
+//
+
+#ifndef ICE_API_EXPORTS
+#   define ICE_API_EXPORTS
+#endif
+#include <Ice/InstrumentationF.h>
+#include <IceUtil/PushDisableWarnings.h>
+#include <IceUtil/Iterator.h>
+#include <IceUtil/PopDisableWarnings.h>
+
+#ifndef ICE_IGNORE_VERSION
+#   if ICE_INT_VERSION  != 30651
+#       error Ice version mismatch: an exact match is required for beta generated code
+#   endif
+#endif
+
+namespace
+{
+
+namespace
+{
+
+}
+
+}

data/ext/ice/cpp/src/Ice/InstrumentationI.cpp

@@ -0,0 +1,1083 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#include <Ice/InstrumentationI.h>
+
+#include <Ice/Connection.h>
+#include <Ice/Endpoint.h>
+#include <Ice/ObjectAdapter.h>
+#include <Ice/LocalException.h>
+#include <Ice/Communicator.h>
+#include <Ice/LoggerUtil.h>
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+using namespace Ice::Instrumentation;
+using namespace IceMX;
+
+namespace 
+{
+
+Context emptyCtx;
+
+int ThreadMetrics::*
+getThreadStateMetric(ThreadState s)
+{
+    switch(s)
+    {
+    case ThreadStateIdle:
+        return 0;
+    case ThreadStateInUseForIO:
+        return &ThreadMetrics::inUseForIO;
+    case ThreadStateInUseForUser:
+        return &ThreadMetrics::inUseForUser;
+    case ThreadStateInUseForOther:
+        return &ThreadMetrics::inUseForOther;
+    default:
+        assert(false);
+        return 0;
+    }
+}    
+
+struct ThreadStateChanged 
+{
+    ThreadStateChanged(ThreadState oldState, ThreadState newState) : oldState(oldState), newState(newState)
+    {
+    }
+    
+    void operator()(const ThreadMetricsPtr& v)
+    {
+        if(oldState != ThreadStateIdle)
+        {
+            --(v.get()->*getThreadStateMetric(oldState));
+        }
+        if(newState != ThreadStateIdle)
+        {
+            ++(v.get()->*getThreadStateMetric(newState));
+        }
+    }
+
+    ThreadState oldState;
+    ThreadState newState;
+};
+
+class ConnectionHelper : public MetricsHelperT<ConnectionMetrics>
+{
+public:
+
+    class Attributes : public AttributeResolverT<ConnectionHelper>
+    {
+    public:
+        
+        Attributes()
+        {
+            add("parent", &ConnectionHelper::getParent);
+            add("id", &ConnectionHelper::getId);
+            add("state", &ConnectionHelper::getState);
+            addConnectionAttributes<ConnectionHelper>(*this);
+        }
+    };
+    static Attributes attributes;
+    
+    ConnectionHelper(const ConnectionInfoPtr& con, const EndpointPtr& endpt, ConnectionState state) : 
+        _connectionInfo(con), _endpoint(endpt), _state(state)
+    {
+    }
+
+    virtual string operator()(const string& attribute) const
+    {
+        return attributes(this, attribute);
+    }
+
+    const string&
+    getId() const
+    {
+        if(_id.empty())
+        {
+            ostringstream os;
+            IPConnectionInfoPtr info = IPConnectionInfoPtr::dynamicCast(_connectionInfo);
+            if(info)
+            {
+                os << info->localAddress << ':' << info->localPort;
+                os << " -> ";
+                os << info->remoteAddress << ':' << info->remotePort;
+            }
+            else
+            {
+                os << "connection-" << _connectionInfo.get();
+            }
+            if(!_connectionInfo->connectionId.empty())
+            {
+                os << " [" << _connectionInfo->connectionId << "]";
+            }
+            _id = os.str();
+        }
+        return _id;
+    }
+
+    string
+    getState() const
+    {
+        switch(_state)
+        {
+        case ConnectionStateValidating:
+            return "validating";
+        case ConnectionStateHolding:
+            return "holding";
+        case ConnectionStateActive:
+            return "active";
+        case ConnectionStateClosing:
+            return "closing";
+        case ConnectionStateClosed:
+            return "closed";
+        default:
+            assert(false);
+            return "";
+        }
+    }
+    
+    string 
+    getParent() const
+    {
+        if(!_connectionInfo->adapterName.empty())
+        {
+            return _connectionInfo->adapterName;
+        }
+        else
+        {
+            return "Communicator";
+        }
+    }
+    
+    const ConnectionInfoPtr&
+    getConnectionInfo() const
+    {
+        return _connectionInfo;
+    }
+
+    const EndpointPtr&
+    getEndpoint() const
+    {
+        return _endpoint;
+    }
+
+    const EndpointInfoPtr&
+    getEndpointInfo() const
+    {
+        if(!_endpointInfo)
+        {
+            _endpointInfo = _endpoint->getInfo();
+        }
+        return _endpointInfo;
+    }
+    
+private:
+
+    const ConnectionInfoPtr& _connectionInfo;
+    const EndpointPtr& _endpoint;
+    const ConnectionState _state;
+    mutable string _id;
+    mutable EndpointInfoPtr _endpointInfo;
+};
+
+ConnectionHelper::Attributes ConnectionHelper::attributes;
+
+class DispatchHelper : public MetricsHelperT<DispatchMetrics>
+{
+public:
+
+    class Attributes : public AttributeResolverT<DispatchHelper>
+    {
+    public:
+        
+        Attributes()
+        {
+            add("parent", &DispatchHelper::getParent);
+            add("id", &DispatchHelper::getId);
+            add("connection", &DispatchHelper::getConnection);
+
+            addConnectionAttributes<DispatchHelper>(*this);
+
+            add("operation", &DispatchHelper::getCurrent, &Current::operation);
+            add("identity", &DispatchHelper::getIdentity);
+            add("facet", &DispatchHelper::getCurrent, &Current::facet);
+            add("mode", &DispatchHelper::getMode);
+            add("requestId", &DispatchHelper::getCurrent, &Current::requestId);
+
+            setDefault(&DispatchHelper::resolve);
+        }
+    };
+    static Attributes attributes;
+    
+    DispatchHelper(const Current& current, int size) : _current(current), _size(size)
+    {
+    }
+
+    virtual string operator()(const string& attribute) const
+    {
+        return attributes(this, attribute);
+    }
+
+    virtual void initMetrics(const DispatchMetricsPtr& v) const
+    {
+        v->size += _size;
+    }
+
+    string resolve(const string& attribute) const
+    {
+        if(attribute.compare(0, 8, "context.") == 0)
+        {
+            Context::const_iterator p = _current.ctx.find(attribute.substr(8));
+            if(p != _current.ctx.end())
+            {
+                return p->second;
+            }
+        }
+        throw invalid_argument(attribute);
+    }
+
+    string
+    getMode() const
+    {
+        return _current.requestId == 0 ? "oneway" : "twoway";
+    }
+
+    const string&
+    getId() const
+    {
+        if(_id.empty())
+        {
+            ostringstream os;
+            if(!_current.id.category.empty())
+            {
+                os << _current.id.category << '/';
+            }
+            os << _current.id.name << " [" << _current.operation << ']';
+            _id = os.str();
+        }
+        return _id;
+    }
+
+    string 
+    getParent() const
+    {
+        return _current.adapter->getName();
+    }
+
+    ConnectionInfoPtr
+    getConnectionInfo() const
+    {
+        if(_current.con)
+        {
+            return _current.con->getInfo();
+        }
+        return 0;
+    }
+
+    EndpointPtr
+    getEndpoint() const
+    {
+        if(_current.con)
+        {
+            return _current.con->getEndpoint();
+        }
+        return 0;
+    }
+
+    const ConnectionPtr&
+    getConnection() const
+    {
+        return _current.con;
+    }
+
+    const EndpointInfoPtr&
+    getEndpointInfo() const
+    {
+        if(_current.con && !_endpointInfo)
+        {
+            _endpointInfo = _current.con->getEndpoint()->getInfo();
+        }
+        return _endpointInfo;
+    }
+
+    const Current&
+    getCurrent() const
+    {
+        return _current;
+    }
+
+    string
+    getIdentity() const
+    {
+        return _current.adapter->getCommunicator()->identityToString(_current.id);
+    }
+
+private:
+
+    const Current& _current;
+    const int _size;
+    mutable string _id;
+    mutable EndpointInfoPtr _endpointInfo;
+};
+
+DispatchHelper::Attributes DispatchHelper::attributes;
+
+class InvocationHelper : public MetricsHelperT<InvocationMetrics>
+{
+public:
+
+    class Attributes : public AttributeResolverT<InvocationHelper>
+    {
+    public:
+        
+        Attributes()
+        {
+            add("parent", &InvocationHelper::getParent);
+            add("id", &InvocationHelper::getId);
+
+            add("operation", &InvocationHelper::getOperation);
+            add("identity", &InvocationHelper::getIdentity);
+            add("facet", &InvocationHelper::getProxy, &IceProxy::Ice::Object::ice_getFacet);
+            add("encoding", &InvocationHelper::getProxy, &IceProxy::Ice::Object::ice_getEncodingVersion);
+            add("mode", &InvocationHelper::getMode);
+            add("proxy", &InvocationHelper::getProxy);
+
+            setDefault(&InvocationHelper::resolve);
+        }
+    };
+    static Attributes attributes;
+    
+    InvocationHelper(const ObjectPrx& proxy, const string& op, const Context& ctx = emptyCtx) :
+        _proxy(proxy), _operation(op), _context(ctx)
+    {
+    }
+
+    string resolve(const string& attribute) const
+    {
+        if(attribute.compare(0, 8, "context.") == 0)
+        {
+            Context::const_iterator p = _context.find(attribute.substr(8));
+            if(p != _context.end())
+            {
+                return p->second;
+            }
+        }
+        throw invalid_argument(attribute);
+    }
+
+    virtual string operator()(const string& attribute) const
+    {
+        return attributes(this, attribute);
+    }
+
+    string
+    getMode() const
+    {
+        if(!_proxy)
+        {
+            throw invalid_argument("mode");
+        }
+
+        if(_proxy->ice_isTwoway())
+        {
+            return "twoway";
+        } 
+        else if(_proxy->ice_isOneway())
+        {
+            return "oneway";
+        } 
+        else if(_proxy->ice_isBatchOneway())
+        {
+            return "batch-oneway";
+        } 
+        else if(_proxy->ice_isDatagram())
+        {
+            return "datagram";
+        } 
+        else if(_proxy->ice_isBatchDatagram())
+        {
+            return "batch-datagram";
+        } 
+        else
+        {
+            throw invalid_argument("mode");
+        }
+    }
+
+    const string&
+    getId() const
+    {
+        if(_id.empty())
+        {
+            ostringstream os;
+            if(_proxy)
+            {
+                try
+                {
+                    os << _proxy->ice_endpoints(Ice::EndpointSeq()) << " [" << _operation << ']';
+                }
+                catch(const Exception&)
+                {
+                    // Either a fixed proxy or the communicator is destroyed.
+                    os << _proxy->ice_getCommunicator()->identityToString(_proxy->ice_getIdentity());
+                    os << " [" << _operation << ']';
+                }
+            }
+            else
+            {
+                os << _operation;
+            }
+            _id = os.str();
+        }
+        return _id;
+    }
+
+    string 
+    getParent() const
+    {
+        return "Communicator";
+    }
+
+    const ObjectPrx&
+    getProxy() const
+    {
+        return _proxy;
+    }
+
+
+    string
+    getIdentity() const
+    {
+        if(_proxy)
+        {
+            return _proxy->ice_getCommunicator()->identityToString(_proxy->ice_getIdentity());
+        }
+        else
+        {
+            return "";
+        }
+    }
+
+    const string&
+    getOperation() const
+    {
+        return _operation;
+    }
+
+private:
+
+    const ObjectPrx& _proxy;
+    const string& _operation;
+    const Context& _context;
+    mutable string _id;
+};
+
+InvocationHelper::Attributes InvocationHelper::attributes;
+
+class RemoteInvocationHelper : public MetricsHelperT<RemoteMetrics>
+{
+public:
+
+    class Attributes : public AttributeResolverT<RemoteInvocationHelper>
+    {
+    public:
+        
+        Attributes()
+        {
+            add("parent", &RemoteInvocationHelper::getParent);
+            add("id", &RemoteInvocationHelper::getId);
+            add("requestId", &RemoteInvocationHelper::_requestId);
+            addConnectionAttributes<RemoteInvocationHelper>(*this);
+        }
+    };
+    static Attributes attributes;
+    
+    RemoteInvocationHelper(const ConnectionInfoPtr& con, const EndpointPtr& endpt, int requestId, int size) : 
+        _connectionInfo(con), _endpoint(endpt), _requestId(requestId), _size(size)
+    {
+    }
+
+    virtual string operator()(const string& attribute) const
+    {
+        return attributes(this, attribute);
+    }
+
+    virtual void initMetrics(const RemoteMetricsPtr& v) const
+    {
+        v->size += _size;
+    }
+
+    const string&
+    getId() const
+    {
+        if(_id.empty())
+        {
+            _id = _endpoint->toString();
+            if(!_connectionInfo->connectionId.empty())
+            {
+                _id += " [" + _connectionInfo->connectionId + "]";
+            }
+        }
+        return _id;
+    }
+    
+    string 
+    getParent() const
+    {
+        if(!_connectionInfo->adapterName.empty())
+        {
+            return _connectionInfo->adapterName;
+        }
+        else
+        {
+            return "Communicator";
+        }
+    }
+    
+    const ConnectionInfoPtr&
+    getConnectionInfo() const
+    {
+        return _connectionInfo;
+    }
+
+    const EndpointPtr&
+    getEndpoint() const
+    {
+        return _endpoint;
+    }
+
+    const EndpointInfoPtr&
+    getEndpointInfo() const
+    {
+        if(!_endpointInfo)
+        {
+            _endpointInfo = _endpoint->getInfo();
+        }
+        return _endpointInfo;
+    }
+    
+private:
+
+    const ConnectionInfoPtr& _connectionInfo;
+    const EndpointPtr& _endpoint;
+
+protected:
+    //
+    // COMPILERFIX: Clang 4.2 reports unused-private-field for the _requestId
+    // field that is only used in the nested Attributes class.
+    //
+    const int _requestId;
+
+private:
+    const int _size;
+    mutable string _id;
+    mutable EndpointInfoPtr _endpointInfo;
+};
+
+RemoteInvocationHelper::Attributes RemoteInvocationHelper::attributes;
+
+class CollocatedInvocationHelper : public MetricsHelperT<CollocatedMetrics>
+{
+public:
+
+    class Attributes : public AttributeResolverT<CollocatedInvocationHelper>
+    {
+    public:
+        
+        Attributes()
+        {
+            add("parent", &CollocatedInvocationHelper::getParent);
+            add("id", &CollocatedInvocationHelper::getId);
+            add("requestId", &CollocatedInvocationHelper::_requestId);
+        }
+    };
+    static Attributes attributes;
+    
+    CollocatedInvocationHelper(const Ice::ObjectAdapterPtr& adapter, int requestId, int size) : 
+        _requestId(requestId), _size(size), _id(adapter->getName())
+    {
+    }
+
+    virtual string operator()(const string& attribute) const
+    {
+        return attributes(this, attribute);
+    }
+
+    virtual void initMetrics(const CollocatedMetricsPtr& v) const
+    {
+        v->size += _size;
+    }
+
+    const string&
+    getId() const
+    {
+        return _id;
+    }
+    
+    string 
+    getParent() const
+    {
+        return "Communicator";
+    }
+
+protected:
+    //
+    // COMPILERFIX: Clang 4.2 reports unused-private-field for the _requestId
+    // field that is only used in the nested Attributes class.
+    //
+    const int _requestId;
+
+private:
+
+    const int _size;
+    mutable string _id;
+};
+
+CollocatedInvocationHelper::Attributes CollocatedInvocationHelper::attributes;
+
+class ThreadHelper : public MetricsHelperT<ThreadMetrics>
+{
+public:
+
+    class Attributes : public AttributeResolverT<ThreadHelper>
+    {
+    public:
+        
+        Attributes()
+        {
+            add("parent", &ThreadHelper::_parent);
+            add("id", &ThreadHelper::_id);
+        }
+    };
+    static Attributes attributes;
+    
+    ThreadHelper(const string& parent, const string& id, ThreadState state) : _parent(parent), _id(id), _state(state)
+    {
+    }
+
+    virtual string operator()(const string& attribute) const
+    {
+        return attributes(this, attribute);
+    }
+
+    virtual void initMetrics(const ThreadMetricsPtr& v) const
+    {
+        if(_state != ThreadStateIdle)
+        {
+            ++(v.get()->*getThreadStateMetric(_state));
+        }
+    }
+
+private:
+    
+    const string _parent;
+    const string _id;
+    const ThreadState _state;
+};
+
+ThreadHelper::Attributes ThreadHelper::attributes;
+
+class EndpointHelper : public MetricsHelperT<Metrics>
+{
+public:
+
+    class Attributes : public AttributeResolverT<EndpointHelper>
+    {
+    public:
+        
+        Attributes()
+        {
+            add("parent", &EndpointHelper::getParent);
+            add("id", &EndpointHelper::getId);
+            addEndpointAttributes<EndpointHelper>(*this);
+        }
+    };
+    static Attributes attributes;
+    
+    EndpointHelper(const EndpointPtr& endpt, const string& id) : _endpoint(endpt), _id(id)
+    {
+    }
+
+    EndpointHelper(const EndpointPtr& endpt) : _endpoint(endpt)
+    {
+    }
+
+    virtual string operator()(const string& attribute) const
+    {
+        return attributes(this, attribute);
+    }
+
+    const EndpointInfoPtr&
+    getEndpointInfo() const
+    {
+        if(!_endpointInfo)
+        {
+            _endpointInfo = _endpoint->getInfo();
+        }
+        return _endpointInfo;
+    }
+
+    string
+    getParent() const
+    {
+        return "Communicator";
+    }
+
+    const string&
+    getId() const
+    {
+        if(_id.empty())
+        {
+            _id = _endpoint->toString();
+        }
+        return _id;
+    }
+
+    string
+    getEndpoint() const
+    {
+        return _endpoint->toString();
+    }
+
+private:
+    
+    const EndpointPtr _endpoint;
+    mutable string _id;
+    mutable EndpointInfoPtr _endpointInfo;
+};
+
+EndpointHelper::Attributes EndpointHelper::attributes;
+
+}
+
+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
+CollocatedObserverI::reply(Int size)
+{
+    forEach(add(&CollocatedMetrics::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
+InvocationObserverI::getRemoteObserver(const ConnectionInfoPtr& connection, 
+                                       const EndpointPtr& endpoint, 
+                                       int requestId,
+                                       int size)
+{
+    try
+    {
+        RemoteObserverPtr delegate;
+        if(_delegate)
+        {
+            delegate = _delegate->getRemoteObserver(connection, endpoint, requestId, size);
+        }
+        return getObserverWithDelegate<RemoteObserverI>("Remote", 
+                                                        RemoteInvocationHelper(connection, endpoint, requestId, size),
+                                                        delegate);
+    }
+    catch(const exception&)
+    {
+    }
+    return 0;
+}
+
+CollocatedObserverPtr
+InvocationObserverI::getCollocatedObserver(const Ice::ObjectAdapterPtr& adapter, int requestId, int size)
+{
+    try
+    {
+        CollocatedObserverPtr delegate;
+        if(_delegate)
+        {
+            delegate = _delegate->getCollocatedObserver(adapter, requestId, size);
+        }
+        return getObserverWithDelegate<CollocatedObserverI>("Collocated",
+                                                            CollocatedInvocationHelper(adapter, requestId, size),
+                                                            delegate);
+    }
+    catch(const exception&)
+    {
+    }
+    return 0;
+}
+
+CommunicatorObserverI::CommunicatorObserverI(const InitializationData& initData) : 
+    _metrics(new MetricsAdminI(initData.properties, initData.logger)),
+    _delegate(initData.observer),
+    _connections(_metrics, "Connection"),
+    _dispatch(_metrics, "Dispatch"),
+    _invocations(_metrics, "Invocation"),
+    _threads(_metrics, "Thread"),
+    _connects(_metrics, "ConnectionEstablishment"),
+    _endpointLookups(_metrics, "EndpointLookup")
+{
+    _invocations.registerSubMap<RemoteMetrics>("Remote", &InvocationMetrics::remotes);
+    _invocations.registerSubMap<CollocatedMetrics>("Collocated", &InvocationMetrics::collocated);
+}
+
+void
+CommunicatorObserverI::setObserverUpdater(const ObserverUpdaterPtr& updater)
+{
+    _connections.setUpdater(newUpdater(updater, &ObserverUpdater::updateConnectionObservers));
+    _threads.setUpdater(newUpdater(updater, &ObserverUpdater::updateThreadObservers));
+    if(_delegate)
+    {
+        _delegate->setObserverUpdater(updater);
+    }
+}
+
+ObserverPtr
+CommunicatorObserverI::getConnectionEstablishmentObserver(const EndpointPtr& endpt, const string& connector)
+{
+    if(_connects.isEnabled())
+    {
+        try
+        {
+            ObserverPtr delegate;
+            if(_delegate)
+            {
+                delegate = _delegate->getConnectionEstablishmentObserver(endpt, connector);
+            }
+            return _connects.getObserverWithDelegate(EndpointHelper(endpt, connector), delegate);
+        }
+        catch(const exception& ex)
+        {
+            Error error(_metrics->getLogger());
+            error << "unexpected exception trying to obtain observer:\n" << ex;
+        }
+    }
+    return 0;
+}
+
+ObserverPtr
+CommunicatorObserverI::getEndpointLookupObserver(const EndpointPtr& endpt)
+{
+    if(_endpointLookups.isEnabled())
+    {
+        try
+        {
+            ObserverPtr delegate;
+            if(_delegate)
+            {
+                delegate = _delegate->getEndpointLookupObserver(endpt);
+            }
+            return _endpointLookups.getObserverWithDelegate(EndpointHelper(endpt), delegate);
+        }
+        catch(const exception& ex)
+        {
+            Error error(_metrics->getLogger());
+            error << "unexpected exception trying to obtain observer:\n" << ex;
+        }
+    }
+    return 0;
+}
+
+ConnectionObserverPtr 
+CommunicatorObserverI::getConnectionObserver(const ConnectionInfoPtr& con, 
+                                             const EndpointPtr& endpt,
+                                             ConnectionState state, 
+                                             const ConnectionObserverPtr& observer)
+{
+    if(_connections.isEnabled())
+    {
+        try
+        {
+            ConnectionObserverPtr delegate;
+            ConnectionObserverI* o = dynamic_cast<ConnectionObserverI*>(observer.get());
+            if(_delegate)
+            {
+                delegate = _delegate->getConnectionObserver(con, endpt, state, o ? o->getDelegate() : observer);
+            }
+            return _connections.getObserverWithDelegate(ConnectionHelper(con, endpt, state), delegate, observer);
+        }
+        catch(const exception& ex)
+        {
+            Error error(_metrics->getLogger());
+            error << "unexpected exception trying to obtain observer:\n" << ex;
+        }
+    }
+    return 0;
+}
+
+ThreadObserverPtr 
+CommunicatorObserverI::getThreadObserver(const string& parent, 
+                                         const string& id,
+                                         ThreadState state,
+                                         const ThreadObserverPtr& observer)
+{
+    if(_threads.isEnabled())
+    {
+        try
+        {
+            ThreadObserverPtr delegate;
+            ThreadObserverI* o = dynamic_cast<ThreadObserverI*>(observer.get());
+            if(_delegate)
+            {
+                delegate = _delegate->getThreadObserver(parent, id, state, o ? o->getDelegate() : observer);
+            }
+            return _threads.getObserverWithDelegate(ThreadHelper(parent, id, state), delegate, observer);
+        }
+        catch(const exception& ex)
+        {
+            Error error(_metrics->getLogger());
+            error << "unexpected exception trying to obtain observer:\n" << ex;
+        }
+    }
+    return 0;
+}
+
+InvocationObserverPtr 
+CommunicatorObserverI::getInvocationObserver(const ObjectPrx& proxy, const string& op, const Context& ctx)
+{
+    if(_invocations.isEnabled())
+    {
+        try
+        {
+            InvocationObserverPtr delegate;
+            if(_delegate)
+            {
+                delegate = _delegate->getInvocationObserver(proxy, op, ctx);
+            }
+            return _invocations.getObserverWithDelegate(InvocationHelper(proxy, op, ctx), delegate);
+        }
+        catch(const exception& ex)
+        {
+            Error error(_metrics->getLogger());
+            error << "unexpected exception trying to obtain observer:\n" << ex;
+        }
+    }
+    return 0;
+}
+
+DispatchObserverPtr 
+CommunicatorObserverI::getDispatchObserver(const Current& current, int size)
+{
+    if(_dispatch.isEnabled())
+    {
+        try
+        {
+            DispatchObserverPtr delegate;
+            if(_delegate)
+            {
+                delegate = _delegate->getDispatchObserver(current, size);
+            }
+            return _dispatch.getObserverWithDelegate(DispatchHelper(current, size), delegate);
+        }
+        catch(const exception& ex)
+        {
+            Error error(_metrics->getLogger());
+            error << "unexpected exception trying to obtain observer:\n" << ex;
+        }
+    }
+    return 0;
+}
+
+const IceInternal::MetricsAdminIPtr& 
+CommunicatorObserverI::getFacet() const
+{
+    assert(_metrics);
+    return _metrics;
+}
+
+void
+CommunicatorObserverI::destroy()
+{
+    _connections.destroy();
+    _dispatch.destroy();
+    _invocations.destroy();
+    _threads.destroy();
+    _connects.destroy();
+    _endpointLookups.destroy();
+
+    _metrics->destroy();
+}