summaryrefslogtreecommitdiff
path: root/cpp/src/Ice/MetricsObserverI.cpp
blob: c3e51b170ba85bb226893af8407f9b21dda0e58d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
// **********************************************************************
//
// Copyright (c) 2003-2012 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/MetricsObserverI.h>
#include <Ice/MetricsAdminI.h>

using namespace std;
using namespace Ice;
using namespace IceMetrics;

namespace 
{

class ConnectionMetricsHelper : public MetricsHelper
{
public:
    
    ConnectionMetricsHelper(const ConnectionPtr& con) : _connection(con)
    {
    }

    virtual string operator()(const string& attribute) const
    {
        return ""; // TODO: return attribute value
    }
    
    virtual MetricsObjectPtr newMetricsObject() const
    {
        return new ConnectionMetricsObject();
    }
        
private:
    
    Ice::ConnectionPtr _connection;
};

}

void
ConnectionObserverI::attach()
{
    struct Attach 
    {
        void operator()(const ConnectionMetricsObjectPtr& v)
        {
            ++v->total;
            ++v->current;
            ++v->initializing;
        }
    };
    forEach(Attach());
}

void
ConnectionObserverI::detach()
{
    struct Detach 
    {
        void operator()(const ConnectionMetricsObjectPtr& v)
        {
            ++v->total;
            ++v->current;
            ++v->initializing;
        }
    };
    forEach(Detach());
}

void
ConnectionObserverI::stateChanged(ConnectionState oldState, ConnectionState newState)
{
    struct StateChanged 
    {
        StateChanged(ConnectionState oldState, ConnectionState newState) : 
            oldState(oldState), newState(newState)
        {
        }

        void operator()(const ConnectionMetricsObjectPtr& v)
        {
            --(v.get()->*getConnectionStateMetric(oldState));
            ++(v.get()->*getConnectionStateMetric(newState));
        }

        int ConnectionMetricsObject::*
        getConnectionStateMetric(ConnectionState s)
        {
            switch(s)
            {
            case ConnectionStateInitializing:
                return &ConnectionMetricsObject::initializing;
            case ConnectionStateActive:
                return &ConnectionMetricsObject::active;
            case ConnectionStateHolding:
                return &ConnectionMetricsObject::holding;
            case ConnectionStateClosing:
                return &ConnectionMetricsObject::closing;
            case ConnectionStateClosed:
                return &ConnectionMetricsObject::closed;
            }
        }    

        ConnectionState oldState;
        ConnectionState newState;
    }
    forEach(StateChanged(oldState, newState));
}

void 
ConnectionObserverI::sentBytes(Int num, Long duration)
{
    forEach(aggregate(applyOnMember(&ConnectionMetricsObject::sentBytes, Add<Int>(num)),
                      applyOnMember(&ConnectionMetricsObject::sentTime, Add<Long>(duration))));
}

void 
ConnectionObserverI::receivedBytes(Int num, Long duration)
{
    forEach(aggregate(applyOnMember(&ConnectionMetricsObject::receivedBytes, Add<Int>(num)),
                      applyOnMember(&ConnectionMetricsObject::receivedTime, Add<Long>(duration))));
}

ObserverResolverI::ObserverResolverI(const MetricsAdminIPtr& metrics) : _metrics(metrics)
{
}

void
ObserverResolverI::setObserverUpdater(const ObserverUpdaterPtr& updater)
{
    class Updater : public ObjectObserverUpdater
    {
    public:

        Updater(const ObserverUpdaterPtr& updater, void (ObserverUpdater::*fn)()) : 
            _updater(updater), _fn(fn)
        {
        }
        
        virtual void update()
        {
            (_updater.get()->*_fn)();
        }

    private: 

        const ObserverUpdaterPtr _updater;
        void (ObserverUpdater::*_fn)();
    };
    _metrics->addUpdater("Connection", new Updater(updater, &ObserverUpdater::updateConnectionObservers));
    _metrics->addUpdater("Thread", new Updater(updater, &ObserverUpdater::updateThreadObservers));
    _metrics->addUpdater("ThreadPoolThread", new Updater(updater, &ObserverUpdater::updateThreadPoolThreadObservers));
}

ConnectionObserverPtr 
ObserverResolverI::getConnectionObserver(const ConnectionObserverPtr& old, const ConnectionPtr& con)
{
    return _connections.getObserver(_metrics->getMatching("Connection", ConnectionMetricsHelper(con)), old.get());
}

ObjectObserverPtr 
ObserverResolverI::getThreadObserver(const ObjectObserverPtr&, const string&, const string&)
{
    return 0;
}

ThreadPoolThreadObserverPtr 
ObserverResolverI::getThreadPoolThreadObserver(const ThreadPoolThreadObserverPtr&, const string&, const string&)
{
    return 0;
}

RequestObserverPtr 
ObserverResolverI::getInvocationObserver(const RequestObserverPtr&, const ObjectPrx&, const string&)
{
    return 0;
}

RequestObserverPtr 
ObserverResolverI::getDispatchObserver(const RequestObserverPtr&, const ObjectPtr&, const Current&)
{
    return 0;
}