InstrumentationI.h

Go to the documentation of this file.

// **********************************************************************
//
// Copyright (c) 2003-2017 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_INSTRUMENTATION_I_H
#define ICE_INSTRUMENTATION_I_H
 
#include <Ice/Connection.h>
#include <Ice/MetricsObserverI.h>
 
namespace IceInternal
{
 
    template <typename T, typename O>
    class ObserverWithDelegateT : public IceMX::ObserverT<T>, public virtual O
    {
    public:
        typedef O ObserverType;
        typedef typename ICE_INTERNAL_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
        getObserverWithDelegate(const std::string& mapName,
                                const IceMX::MetricsHelperT<ObserverMetricsType>& helper,
                                const ObserverPtrType& del)
        {
            ICE_INTERNAL_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
        getObserverWithDelegate(const IceMX::MetricsHelperT<ObserverMetricsType>& helper,
                                const ObserverPtrType& del)
        {
            ICE_INTERNAL_HANDLE<T> obsv = IceMX::ObserverFactoryT<T>::getObserver(helper);
            if (obsv)
            {
                obsv->setDelegate(del);
                return obsv;
            }
            return del;
        }
 
        template <typename ObserverMetricsType, typename ObserverPtrType>
        ObserverPtrType
        getObserverWithDelegate(const IceMX::MetricsHelperT<ObserverMetricsType>& helper,
                                const ObserverPtrType& del,
                                const ObserverPtrType& old)
        {
            ICE_INTERNAL_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)
    {
        attrs.add("endpoint", &Helper::getEndpoint);
 
        attrs.add("endpointType", &Helper::getEndpointInfo, &Ice::EndpointInfo::type);
        attrs.add("endpointIsDatagram", &Helper::getEndpointInfo, &Ice::EndpointInfo::datagram);
        attrs.add("endpointIsSecure", &Helper::getEndpointInfo, &Ice::EndpointInfo::secure);
        attrs.add("endpointTimeout", &Helper::getEndpointInfo, &Ice::EndpointInfo::timeout);
        attrs.add("endpointCompress", &Helper::getEndpointInfo, &Ice::EndpointInfo::compress);
 
        attrs.add("endpointHost", &Helper::getEndpointInfo, &Ice::IPEndpointInfo::host);
        attrs.add("endpointPort", &Helper::getEndpointInfo, &Ice::IPEndpointInfo::port);
    }
 
    template <typename Helper>
    void
    addConnectionAttributes(typename Helper::Attributes& attrs)
    {
        attrs.add("incoming", &Helper::getConnectionInfo, &Ice::ConnectionInfo::incoming);
        attrs.add("adapterName", &Helper::getConnectionInfo, &Ice::ConnectionInfo::adapterName);
        attrs.add("connectionId", &Helper::getConnectionInfo, &Ice::ConnectionInfo::connectionId);
 
        attrs.add("localHost", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::localAddress);
        attrs.add("localPort", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::localPort);
        attrs.add("remoteHost", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::remoteAddress);
        attrs.add("remotePort", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::remotePort);
 
        attrs.add("mcastHost", &Helper::getConnectionInfo, &Ice::UDPConnectionInfo::mcastAddress);
        attrs.add("mcastPort", &Helper::getConnectionInfo, &Ice::UDPConnectionInfo::mcastPort);
 
        addEndpointAttributes<Helper>(attrs);
    }
 
    class ConnectionObserverI :
        public ObserverWithDelegateT<IceMX::ConnectionMetrics,
                                     Ice::Instrumentation::ConnectionObserver>
    {
    public:
        virtual void sentBytes(Ice::Int);
        virtual void receivedBytes(Ice::Int);
    };
 
    class ThreadObserverI :
        public ObserverWithDelegateT<IceMX::ThreadMetrics, Ice::Instrumentation::ThreadObserver>
    {
    public:
        virtual void stateChanged(Ice::Instrumentation::ThreadState,
                                  Ice::Instrumentation::ThreadState);
    };
 
    class DispatchObserverI :
        public ObserverWithDelegateT<IceMX::DispatchMetrics, Ice::Instrumentation::DispatchObserver>
    {
    public:
        virtual void userException();
 
        virtual void reply(Ice::Int);
    };
 
    class RemoteObserverI :
        public ObserverWithDelegateT<IceMX::RemoteMetrics, Ice::Instrumentation::RemoteObserver>
    {
    public:
        virtual void reply(Ice::Int);
    };
 
    class CollocatedObserverI :
        public ObserverWithDelegateT<IceMX::CollocatedMetrics,
                                     Ice::Instrumentation::CollocatedObserver>
    {
    public:
        virtual void reply(Ice::Int);
    };
 
    class InvocationObserverI :
        public ObserverWithDelegateT<IceMX::InvocationMetrics,
                                     Ice::Instrumentation::InvocationObserver>
    {
    public:
        virtual void retried();
 
        virtual void userException();
 
        virtual Ice::Instrumentation::RemoteObserverPtr
        getRemoteObserver(const Ice::ConnectionInfoPtr&,
                          const Ice::EndpointPtr&,
                          Ice::Int,
                          Ice::Int);
 
        virtual Ice::Instrumentation::CollocatedObserverPtr
        getCollocatedObserver(const Ice::ObjectAdapterPtr&, Ice::Int, Ice::Int);
    };
 
    typedef ObserverWithDelegateT<IceMX::Metrics, Ice::Instrumentation::Observer> ObserverI;
 
    class ICE_API CommunicatorObserverI : public Ice::Instrumentation::CommunicatorObserver
    {
    public:
        CommunicatorObserverI(const Ice::InitializationData&);
 
        virtual void setObserverUpdater(const Ice::Instrumentation::ObserverUpdaterPtr&);
 
        virtual Ice::Instrumentation::ObserverPtr
        getConnectionEstablishmentObserver(const Ice::EndpointPtr&, const std::string&);
 
        virtual Ice::Instrumentation::ObserverPtr
        getEndpointLookupObserver(const Ice::EndpointPtr&);
 
        virtual Ice::Instrumentation::ConnectionObserverPtr
        getConnectionObserver(const Ice::ConnectionInfoPtr&,
                              const Ice::EndpointPtr&,
                              Ice::Instrumentation::ConnectionState,
                              const Ice::Instrumentation::ConnectionObserverPtr&);
 
        virtual Ice::Instrumentation::ThreadObserverPtr
        getThreadObserver(const std::string&,
                          const std::string&,
                          Ice::Instrumentation::ThreadState,
                          const Ice::Instrumentation::ThreadObserverPtr&);
 
        virtual Ice::Instrumentation::InvocationObserverPtr
        getInvocationObserver(const Ice::ObjectPrxPtr&, const std::string&, const Ice::Context&);
 
        virtual Ice::Instrumentation::DispatchObserverPtr getDispatchObserver(const Ice::Current&,
                                                                              Ice::Int);
 
        const IceInternal::MetricsAdminIPtr& getFacet() const;
 
        void destroy();
 
    private:
        IceInternal::MetricsAdminIPtr _metrics;
        const Ice::Instrumentation::CommunicatorObserverPtr _delegate;
 
        ObserverFactoryWithDelegateT<ConnectionObserverI> _connections;
        ObserverFactoryWithDelegateT<DispatchObserverI> _dispatch;
        ObserverFactoryWithDelegateT<InvocationObserverI> _invocations;
        ObserverFactoryWithDelegateT<ThreadObserverI> _threads;
        ObserverFactoryWithDelegateT<ObserverI> _connects;
        ObserverFactoryWithDelegateT<ObserverI> _endpointLookups;
    };
 
    ICE_DEFINE_PTR(CommunicatorObserverIPtr, CommunicatorObserverI);
 
} // namespace IceInternal
 
#endif