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
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
|
// **********************************************************************
//
// 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.
//
// **********************************************************************
#ifndef ICE_METRICSADMIN_I_H
#define ICE_METRICSADMIN_I_H
#include <Ice/Metrics.h>
#include <Ice/Properties.h>
#include <Ice/Initialize.h>
namespace IceMX
{
class Updater;
typedef IceUtil::Handle<Updater> UpdaterPtr;
class MetricsHelper;
typedef std::map<std::string, std::string> NameValueDict;
class MetricsMapI : public IceUtil::Shared, public IceUtil::Mutex
{
public:
class Entry : public Ice::LocalObject, public IceUtil::Mutex
{
public:
Entry(MetricsMapI* map, const MetricsPtr& object) : _map(map), _object(object)
{
}
template<typename MetricsHelper, typename MetricsPtrType> MetricsPtrType
attach(const MetricsHelper& helper)
{
IceUtil::Mutex::Lock sync(*this);
++_object->total;
++_object->current;
MetricsPtrType obj = MetricsPtrType::dynamicCast(_object);
helper.initMetrics(obj);
return obj;
}
void detach(long lifetime)
{
bool detached = false;
{
IceUtil::Mutex::Lock sync(*this);
detached = --_object->current == 0;
_object->totalLifetime += lifetime;
}
if(detached)
{
_map->detached(this);
}
}
void failed(const std::string& exceptionName)
{
IceUtil::Mutex::Lock sync(*this);
++_failures[exceptionName];
}
MetricsPtr
clone() const
{
IceUtil::Mutex::Lock sync(*this);
// TODO: Fix ice_clone to use a co-variant type.
return dynamic_cast<Metrics*>(_object->ice_clone().get());
}
MetricsFailures
getFailures() const
{
MetricsFailures f;
IceUtil::Mutex::Lock sync(*this);
f.id = _object->id;
f.failures = _failures;
return f;
}
template<typename Function, typename MetricsType> void
execute(Function func, const MetricsType& obj)
{
IceUtil::Mutex::Lock sync(*this);
func(obj);
}
const std::string& id() const
{
return _object->id;
}
bool isDetached() const
{
IceUtil::Mutex::Lock sync(*this);
return _object->current == 0;
}
private:
MetricsMapI* _map;
MetricsPtr _object;
StringIntDict _failures;
};
typedef IceUtil::Handle<Entry> EntryPtr;
MetricsMapI(const std::string&, int, const NameValueDict&, const NameValueDict&);
MetricsMap getMetrics();
MetricsFailuresSeq getFailures();
EntryPtr getMatching(const MetricsHelper&);
private:
friend class Entry;
void detached(Entry*);
std::vector<std::string> _groupByAttributes;
std::vector<std::string> _groupBySeparators;
int _retain;
const NameValueDict _accept;
const NameValueDict _reject;
std::map<std::string, EntryPtr> _objects;
std::deque<Entry*> _detachedQueue;
};
typedef IceUtil::Handle<MetricsMapI> MetricsMapIPtr;
class MetricsViewI : public IceUtil::Shared
{
public:
MetricsViewI();
void setEnabled(bool enabled)
{
_enabled = enabled;
}
bool isEnabled() const
{
return _enabled;
}
void add(const std::string&, const std::string&, int, const NameValueDict&, const NameValueDict&);
void remove(const std::string&);
MetricsView getMetrics();
MetricsFailuresSeq getFailures(const std::string&);
MetricsMapI::EntryPtr getMatching(const std::string&, const MetricsHelper&) const;
std::vector<std::string> getMaps() const;
private:
std::map<std::string, MetricsMapIPtr> _maps;
bool _enabled;
};
typedef IceUtil::Handle<MetricsViewI> MetricsViewIPtr;
class MetricsAdminI : public MetricsAdmin, public IceUtil::Mutex
{
public:
MetricsAdminI(::Ice::InitializationData&);
std::vector<MetricsMapI::EntryPtr> getMatching(const std::string&, const MetricsHelper&) const;
void addUpdater(const std::string&, const UpdaterPtr&);
virtual Ice::StringSeq getMetricsViewNames(const ::Ice::Current&);
virtual MetricsView getMetricsView(const std::string&, const ::Ice::Current&);
virtual MetricsFailuresSeq getMetricsFailures(const std::string&, const std::string&, const ::Ice::Current&);
private:
virtual void addMapToView(const std::string&, const std::string&, const std::string&, int, const NameValueDict&,
const NameValueDict&, const ::Ice::Current& = ::Ice::Current());
virtual void removeMapFromView(const std::string&, const std::string&, const ::Ice::Current&);
void setViewEnabled(const std::string&, bool);
std::map<std::string, MetricsViewIPtr> _views;
std::map<std::string, UpdaterPtr> _updaters;
};
typedef IceUtil::Handle<MetricsAdminI> MetricsAdminIPtr;
};
#endif
|
