summaryrefslogtreecommitdiff
path: root/cpp/src
diff options
context:
space:
mode:
Diffstat (limited to 'cpp/src')
-rw-r--r--cpp/src/Ice/MetricsAdminI.cpp195
-rw-r--r--cpp/src/Ice/MetricsAdminI.h341
-rw-r--r--cpp/src/Ice/MetricsObserverI.h102
-rw-r--r--cpp/src/Ice/ObserverI.cpp36
-rw-r--r--cpp/src/Ice/ObserverI.h5
5 files changed, 333 insertions, 346 deletions
diff --git a/cpp/src/Ice/MetricsAdminI.cpp b/cpp/src/Ice/MetricsAdminI.cpp
index 341c8f852f7..8b6ae36586b 100644
--- a/cpp/src/Ice/MetricsAdminI.cpp
+++ b/cpp/src/Ice/MetricsAdminI.cpp
@@ -71,57 +71,6 @@ MetricsMapI::RegExp::match(const MetricsHelper& helper)
#endif
}
-MetricsMapI::Entry::Entry(MetricsMapI* map, const MetricsPtr& object, const list<Entry*>::iterator& pos) :
- _object(object), _map(map), _detachedPos(pos)
-{
-}
-
-void
-MetricsMapI::Entry::destroy()
-{
- Lock sync(*this);
- _map = 0;
-}
-
-void
-MetricsMapI::Entry::failed(const string& exceptionName)
-{
- Lock sync(*this);
- ++_object->failures;
- ++_failures[exceptionName];
-}
-
-MetricsFailures
-MetricsMapI::Entry::getFailures() const
-{
- MetricsFailures f;
-
- Lock sync(*this);
- f.id = _object->id;
- f.failures = _failures;
- return f;
-}
-
-MetricsPtr
-MetricsMapI::Entry::clone() const
-{
- Lock sync(*this);
- return dynamic_cast<Metrics*>(_object->ice_clone().get());
-}
-
-const string&
-MetricsMapI::Entry::id() const
-{
- return _object->id;
-}
-
-MetricsMapI::Entry*
-MetricsMapI::Entry::getMatching(const string&, const MetricsHelper&)
-{
- return 0;
-}
-
-
MetricsMapI::MetricsMapI(const std::string& mapPrefix, const Ice::PropertiesPtr& properties) :
_properties(properties->getPropertiesForPrefix(mapPrefix)),
_retain(properties->getPropertyAsIntWithDefault(mapPrefix + "RetainDetached", 10)),
@@ -178,150 +127,6 @@ MetricsMapI::MetricsMapI(const MetricsMapI& map) :
_reject(map._reject)
{
}
-
-MetricsMapI::~MetricsMapI()
-{
- for(map<string, EntryPtr>::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
- {
- p->second->destroy();
- }
-}
-
-MetricsMap
-MetricsMapI::getMetrics() const
-{
- MetricsMap objects;
-
- Lock sync(*this);
- for(map<string, EntryPtr>::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
- {
- objects.push_back(p->second->clone());
- }
- return objects;
-}
-
-MetricsFailuresSeq
-MetricsMapI::getFailures()
-{
- MetricsFailuresSeq failures;
-
- Lock sync(*this);
- for(map<string, EntryPtr>::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
- {
- MetricsFailures f = p->second->getFailures();
- if(!f.failures.empty())
- {
- failures.push_back(f);
- }
- }
- return failures;
-}
-
-MetricsFailures
-MetricsMapI::getFailures(const string& id)
-{
- Lock sync(*this);
- map<string, EntryPtr>::const_iterator p = _objects.begin();
- if(p != _objects.end())
- {
- return p->second->getFailures();
- }
- return MetricsFailures();
-}
-
-MetricsMapI::EntryPtr
-MetricsMapI::getMatching(const MetricsHelper& helper)
-{
- for(vector<RegExpPtr>::const_iterator p = _accept.begin(); p != _accept.end(); ++p)
- {
- if(!(*p)->match(helper))
- {
- return 0;
- }
- }
-
- for(vector<RegExpPtr>::const_iterator p = _reject.begin(); p != _reject.end(); ++p)
- {
- if((*p)->match(helper))
- {
- return 0;
- }
- }
-
- string key;
- if(_groupByAttributes.size() == 1)
- {
- key = helper(_groupByAttributes.front());
- }
- else
- {
- ostringstream os;
- vector<string>::const_iterator q = _groupBySeparators.begin();
- for(vector<string>::const_iterator p = _groupByAttributes.begin(); p != _groupByAttributes.end(); ++p)
- {
- os << helper(*p);
- if(q != _groupBySeparators.end())
- {
- os << *q++;
- }
- }
- key = os.str();
- }
-
- Lock sync(*this);
- map<string, EntryPtr>::const_iterator p = _objects.find(key);
- if(p == _objects.end())
- {
- p = _objects.insert(make_pair(key, newEntry(key))).first;
- }
- return p->second;
-}
-
-void
-MetricsMapI::detached(Entry* entry)
-{
- if(_retain == 0)
- {
- return;
- }
-
- Lock sync(*this);
- assert(static_cast<int>(_detachedQueue.size()) <= _retain);
-
- if(entry->_detachedPos != _detachedQueue.end())
- {
- _detachedQueue.splice(_detachedQueue.end(), _detachedQueue, entry->_detachedPos);
- entry->_detachedPos = --_detachedQueue.end();
- return;
- }
-
- if(static_cast<int>(_detachedQueue.size()) == _retain)
- {
- // Remove entries which are no longer detached
- list<Entry*>::iterator p = _detachedQueue.begin();
- while(p != _detachedQueue.end())
- {
- if(!(*p)->isDetached())
- {
- p = _detachedQueue.erase(p);
- }
- else
- {
- ++p;
- }
- }
- }
-
- if(static_cast<int>(_detachedQueue.size()) == _retain)
- {
- // Remove oldest entry if there's still no room
- _objects.erase(_detachedQueue.front()->id());
- _detachedQueue.pop_front();
- }
-
- _detachedQueue.push_back(entry);
- entry->_detachedPos = --_detachedQueue.end();
-}
MetricsViewI::MetricsViewI(const string& name) : _name(name)
{
diff --git a/cpp/src/Ice/MetricsAdminI.h b/cpp/src/Ice/MetricsAdminI.h
index 92c0277353c..c788a8e28b0 100644
--- a/cpp/src/Ice/MetricsAdminI.h
+++ b/cpp/src/Ice/MetricsAdminI.h
@@ -36,7 +36,7 @@ typedef IceUtil::Handle<Updater> UpdaterPtr;
class MetricsHelper;
template<typename T> class MetricsHelperT;
-class MetricsMapI : public IceUtil::Shared, private IceUtil::Mutex
+class MetricsMapI : public IceUtil::Shared
{
public:
@@ -59,109 +59,27 @@ public:
};
typedef IceUtil::Handle<RegExp> RegExpPtr;
- class Entry : public Ice::LocalObject, protected IceUtil::Mutex
- {
- public:
-
- Entry(MetricsMapI* map, const MetricsPtr& object, const std::list<Entry*>::iterator&);
-
- void destroy();
- void failed(const std::string& exceptionName);
- MetricsFailures getFailures() const;
-
- virtual MetricsPtr clone() const;
- const std::string& id() const;
- virtual Entry* getMatching(const std::string&, const MetricsHelper&);
-
- template<typename T> IceInternal::Handle<T>
- attach(const MetricsHelperT<T>& helper)
- {
- Lock sync(*this);
- ++_object->total;
- ++_object->current;
- IceInternal::Handle<T> obj = IceInternal::Handle<T>::dynamicCast(_object);
- assert(obj);
- helper.initMetrics(obj);
- return obj;
- }
-
- void detach(Ice::Long lifetime)
- {
- MetricsMapI* map;
- {
- Lock sync(*this);
- _object->totalLifetime += lifetime;
- if(--_object->current > 0)
- {
- return;
- }
- map = _map;
- }
- if(map)
- {
- map->detached(this);
- }
- }
-
- bool isDetached() const
- {
- Lock sync(*this);
- return _object->current == 0;
- }
-
- template<typename Function, typename MetricsType> void
- execute(Function func, const MetricsType& obj)
- {
- Lock sync(*this);
- func(obj);
- }
-
- protected:
-
- friend class MetricsMapI;
-
- MetricsPtr _object;
- MetricsMapI* _map;
- StringIntDict _failures;
- std::list<Entry*>::iterator _detachedPos;
- };
- typedef IceUtil::Handle<Entry> EntryPtr;
-
MetricsMapI(const std::string&, const Ice::PropertiesPtr&);
MetricsMapI(const MetricsMapI&);
- virtual ~MetricsMapI();
-
- MetricsFailuresSeq getFailures();
- MetricsFailures getFailures(const std::string&);
- MetricsMap getMetrics() const;
- EntryPtr getMatching(const MetricsHelper&);
+ virtual MetricsFailuresSeq getFailures() = 0;
+ virtual MetricsFailures getFailures(const std::string&) = 0;
+ virtual MetricsMap getMetrics() const = 0;
+ virtual MetricsMapI* clone() const = 0;
const Ice::PropertyDict& getMapProperties() const
{
return _properties;
}
- virtual MetricsMapI* clone() const = 0;
-
protected:
- virtual EntryPtr newEntry(const std::string&) = 0;
- std::list<Entry*> _detachedQueue;
-
-private:
-
- friend class Entry;
- void detached(Entry*);
-
const Ice::PropertyDict _properties;
std::vector<std::string> _groupByAttributes;
std::vector<std::string> _groupBySeparators;
const int _retain;
const std::vector<RegExpPtr> _accept;
const std::vector<RegExpPtr> _reject;
-
- std::map<std::string, EntryPtr> _objects;
};
typedef IceUtil::Handle<MetricsMapI> MetricsMapIPtr;
@@ -173,7 +91,7 @@ public:
};
typedef IceUtil::Handle<MetricsMapFactory> MetricsMapFactoryPtr;
-template<class MetricsType> class MetricsMapT : public MetricsMapI
+template<class MetricsType> class MetricsMapT : public MetricsMapI, private IceUtil::Mutex
{
public:
@@ -182,17 +100,40 @@ public:
typedef MetricsMap MetricsType::* SubMapMember;
- class EntryT : public MetricsMapI::Entry
+ class EntryT : public Ice::LocalObject, protected IceUtil::Mutex
{
public:
- EntryT(MetricsMapT* map, const TPtr& object, const std::list<Entry*>::iterator& p) :
- Entry(map, object, p), _map(map)
+ EntryT(MetricsMapT* map, const TPtr& object, const typename std::list<EntryT*>::iterator& p) :
+ _map(map), _object(object), _detachedPos(p)
+ {
+ }
+
+ void destroy()
{
+ Lock sync(*this);
+ _map = 0;
}
- virtual Entry*
- getMatching(const std::string& mapName, const MetricsHelper& helper)
+ void failed(const std::string& exceptionName)
+ {
+ Lock sync(*this);
+ ++_object->failures;
+ ++_failures[exceptionName];
+ }
+
+ MetricsFailures getFailures() const
+ {
+ MetricsFailures f;
+
+ Lock sync(*this);
+ f.id = _object->id;
+ f.failures = _failures;
+ return f;
+ }
+
+ template<typename MemberMetricsType> typename MetricsMapT<MemberMetricsType>::EntryTPtr
+ getMatching(const std::string& mapName, const MetricsHelperT<MemberMetricsType>& helper)
{
typename std::map<std::string, std::pair<MetricsMapIPtr, SubMapMember> >::iterator p =
_subMaps.find(mapName);
@@ -207,11 +148,55 @@ public:
if(p == _subMaps.end())
{
return 0;
- }
- return p->second.first->getMatching(helper).get();
+ }
+
+ MetricsMapT<MemberMetricsType>* map = dynamic_cast<MetricsMapT<MemberMetricsType>*>(p->second.first.get());
+ assert(map);
+ return map->getMatching(helper);
+ }
+
+ TPtr
+ attach(const MetricsHelperT<T>& helper)
+ {
+ Lock sync(*this);
+ ++_object->total;
+ ++_object->current;
+ helper.initMetrics(_object);
+ return _object;
+ }
+
+ void detach(Ice::Long lifetime)
+ {
+ MetricsMapT* map;
+ {
+ Lock sync(*this);
+ _object->totalLifetime += lifetime;
+ if(--_object->current > 0)
+ {
+ return;
+ }
+ map = _map;
+ }
+ if(map)
+ {
+ map->detached(this);
+ }
}
- virtual MetricsPtr
+ bool isDetached() const
+ {
+ Lock sync(*this);
+ return _object->current == 0;
+ }
+
+ template<typename Function> void
+ execute(Function func)
+ {
+ Lock sync(*this);
+ func(_object);
+ }
+
+ MetricsPtr
clone() const
{
Lock sync(*this);
@@ -226,8 +211,12 @@ public:
private:
+ friend class MetricsMapT;
MetricsMapT* _map;
+ TPtr _object;
+ StringIntDict _failures;
std::map<std::string, std::pair<MetricsMapIPtr, SubMapMember> > _subMaps;
+ typename std::list<EntryT*>::iterator _detachedPos;
};
typedef IceUtil::Handle<EntryT> EntryTPtr;
@@ -262,6 +251,57 @@ public:
{
}
+ ~MetricsMapT()
+ {
+ for(typename std::map<std::string, EntryTPtr>::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
+ {
+ p->second->destroy();
+ }
+ }
+
+ virtual MetricsMap
+ getMetrics() const
+ {
+ MetricsMap objects;
+
+ Lock sync(*this);
+ for(typename std::map<std::string, EntryTPtr>::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
+ {
+ objects.push_back(p->second->clone());
+ }
+ return objects;
+ }
+
+ virtual MetricsFailuresSeq
+ getFailures()
+ {
+ MetricsFailuresSeq failures;
+
+ Lock sync(*this);
+ for(typename std::map<std::string, EntryTPtr>::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
+ {
+ MetricsFailures f = p->second->getFailures();
+ if(!f.failures.empty())
+ {
+ failures.push_back(f);
+ }
+ }
+ return failures;
+ }
+
+ virtual MetricsFailures
+ getFailures(const std::string& id)
+ {
+ Lock sync(*this);
+ typename std::map<std::string, EntryTPtr>::const_iterator p = _objects.begin();
+ if(p != _objects.end())
+ {
+ return p->second->getFailures();
+ }
+ return MetricsFailures();
+ }
+
+
std::pair<MetricsMapIPtr, SubMapMember>
createSubMap(const std::string& subMapName)
{
@@ -274,21 +314,63 @@ public:
return std::make_pair(MetricsMapIPtr(), static_cast<SubMapMember>(0));
}
-protected:
-
- virtual EntryPtr newEntry(const std::string& id)
+ EntryTPtr
+ getMatching(const MetricsHelperT<T>& helper)
{
- TPtr t = new T();
- t->id = id;
- t->failures = 0;
- if(_subMaps.empty())
+ for(std::vector<RegExpPtr>::const_iterator p = _accept.begin(); p != _accept.end(); ++p)
+ {
+ if(!(*p)->match(helper))
+ {
+ return 0;
+ }
+ }
+
+ for(std::vector<RegExpPtr>::const_iterator p = _reject.begin(); p != _reject.end(); ++p)
+ {
+ if((*p)->match(helper))
+ {
+ return 0;
+ }
+ }
+
+ std::string key;
+ if(_groupByAttributes.size() == 1)
{
- return new Entry(this, t, _detachedQueue.end());
+ key = helper(_groupByAttributes.front());
}
else
{
- return new EntryT(this, t, _detachedQueue.end());
+ std::ostringstream os;
+ std::vector<std::string>::const_iterator q = _groupBySeparators.begin();
+ for(std::vector<std::string>::const_iterator p = _groupByAttributes.begin(); p != _groupByAttributes.end();
+ ++p)
+ {
+ os << helper(*p);
+ if(q != _groupBySeparators.end())
+ {
+ os << *q++;
+ }
+ }
+ key = os.str();
}
+
+ Lock sync(*this);
+ typename std::map<std::string, EntryTPtr>::const_iterator p = _objects.find(key);
+ if(p == _objects.end())
+ {
+ p = _objects.insert(make_pair(key, newEntry(key))).first;
+ }
+ return p->second;
+ }
+
+private:
+
+ virtual EntryTPtr newEntry(const std::string& id)
+ {
+ TPtr t = new T();
+ t->id = id;
+ t->failures = 0;
+ return new EntryT(this, t, _detachedQueue.end());
}
virtual MetricsMapI* clone() const
@@ -296,6 +378,55 @@ protected:
return new MetricsMapT<MetricsType>(*this);
}
+ void detached(EntryT* entry)
+ {
+ if(_retain == 0)
+ {
+ return;
+ }
+
+ Lock sync(*this);
+ assert(static_cast<int>(_detachedQueue.size()) <= _retain);
+
+ if(entry->_detachedPos != _detachedQueue.end())
+ {
+ _detachedQueue.splice(_detachedQueue.end(), _detachedQueue, entry->_detachedPos);
+ entry->_detachedPos = --_detachedQueue.end();
+ return;
+ }
+
+ if(static_cast<int>(_detachedQueue.size()) == _retain)
+ {
+ // Remove entries which are no longer detached
+ typename std::list<EntryT*>::iterator p = _detachedQueue.begin();
+ while(p != _detachedQueue.end())
+ {
+ if(!(*p)->isDetached())
+ {
+ p = _detachedQueue.erase(p);
+ }
+ else
+ {
+ ++p;
+ }
+ }
+ }
+
+ if(static_cast<int>(_detachedQueue.size()) == _retain)
+ {
+ // Remove oldest entry if there's still no room
+ _objects.erase(_detachedQueue.front()->_object->id);
+ _detachedQueue.pop_front();
+ }
+
+ _detachedQueue.push_back(entry);
+ entry->_detachedPos = --_detachedQueue.end();
+ }
+
+ friend class EntryT;
+
+ std::map<std::string, EntryTPtr> _objects;
+ std::list<EntryT*> _detachedQueue;
std::map<std::string, std::pair<SubMapMember, MetricsMapIPtr> > _subMaps;
};
diff --git a/cpp/src/Ice/MetricsObserverI.h b/cpp/src/Ice/MetricsObserverI.h
index 0adfb9f4283..fee2ba2305b 100644
--- a/cpp/src/Ice/MetricsObserverI.h
+++ b/cpp/src/Ice/MetricsObserverI.h
@@ -261,13 +261,13 @@ private:
class ObserverI;
-template<class MetricsType> class ObserverT : virtual public Ice::Instrumentation::Observer
+template<typename T> class ObserverT : virtual public Ice::Instrumentation::Observer
{
public:
- typedef MetricsType Type;
- typedef IceInternal::Handle<MetricsType> PtrType;
- typedef std::vector<std::pair<PtrType, MetricsMapI::EntryPtr> > SeqType;
+ typedef T MetricsType;
+ typedef typename MetricsMapT<MetricsType>::EntryTPtr EntryPtrType;
+ typedef std::vector<EntryPtrType> EntrySeqType;
ObserverT()
{
@@ -283,54 +283,61 @@ public:
detach()
{
Ice::Long lifetime = _watch.stop();
- for(typename SeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
+ IceUtil::Mutex::Lock sync(*_mutex);
+ for(typename EntrySeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
{
- p->second->detach(lifetime);
+ (*p)->detach(lifetime);
}
}
virtual void
failed(const std::string& exceptionName)
{
- for(typename SeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
+ IceUtil::Mutex::Lock sync(*_mutex);
+ for(typename EntrySeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
{
- p->second->failed(exceptionName);
+ (*p)->failed(exceptionName);
}
}
template<typename Function> void
forEach(const Function& func)
{
- for(typename SeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
+ IceUtil::Mutex::Lock sync(*_mutex);
+ for(typename EntrySeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
{
- p->second->execute(func, p->first);
+ (*p)->execute(func);
}
}
void
- init(const MetricsHelperT<MetricsType>& helper, const std::vector<MetricsMapI::EntryPtr>& objects)
+ init(const MetricsHelperT<MetricsType>& helper, EntrySeqType& objects, IceUtil::Mutex* mutex)
{
- _objects.reserve(objects.size());
- for(std::vector<MetricsMapI::EntryPtr>::const_iterator p = objects.begin(); p != objects.end(); ++p)
+ _mutex = mutex;
+ _objects.swap(objects);
+ std::sort(_objects.begin(), _objects.end());
+ for(typename EntrySeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
{
- _objects.push_back(std::make_pair((*p)->attach(helper), *p));
+ (*p)->attach(helper);
}
}
void
- update(const MetricsHelperT<MetricsType>& helper, const std::vector<MetricsMapI::EntryPtr>& objects)
+ update(const MetricsHelperT<MetricsType>& helper, EntrySeqType& objects)
{
- std::vector<MetricsMapI::EntryPtr>::const_iterator p = objects.begin();
- typename SeqType::iterator q = _objects.begin();
+ std::sort(objects.begin(), objects.end());
+ typename EntrySeqType::const_iterator p = objects.begin();
+ typename EntrySeqType::iterator q = _objects.begin();
while(p != objects.end())
{
- if(q == _objects.end() || *p < q->second) // New metrics object
+ if(q == _objects.end() || *p < *q) // New metrics object
{
- q = _objects.insert(q, std::make_pair((*p)->attach(helper), *p));
+ q = _objects.insert(q, *p);
+ (*p)->attach(helper);
++p;
++q;
}
- else if(*p == q->second) // Same metrics object
+ else if(*p == *q) // Same metrics object
{
++p;
++q;
@@ -345,25 +352,32 @@ public:
template<typename ObserverImpl, typename ObserverMetricsType> IceInternal::Handle<ObserverImpl>
getObserver(const std::string& mapName, const MetricsHelperT<ObserverMetricsType>& helper)
{
- std::vector<MetricsMapI::EntryPtr> metricsObjects;
- for(typename SeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
+ IceUtil::Mutex::Lock sync(*_mutex);
+ std::vector<typename MetricsMapT<ObserverMetricsType>::EntryTPtr> metricsObjects;
+ for(typename EntrySeqType::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
{
- MetricsMapI::EntryPtr e = p->second->getMatching(mapName, helper);
+ typename MetricsMapT<ObserverMetricsType>::EntryTPtr e = (*p)->getMatching(mapName, helper);
if(e)
{
metricsObjects.push_back(e);
}
}
+ if(metricsObjects.empty())
+ {
+ return 0;
+ }
+
IceInternal::Handle<ObserverImpl> obsv = new ObserverImpl();
- obsv->init(helper, metricsObjects);
+ obsv->init(helper, metricsObjects, _mutex);
return obsv;
}
private:
- SeqType _objects;
+ EntrySeqType _objects;
IceUtilInternal::StopWatch _watch;
+ IceUtil::Mutex* _mutex;
};
class ObserverI : virtual public Ice::Instrumentation::Observer, public ObserverT<Metrics>
@@ -388,22 +402,28 @@ class ObserverFactoryT : private IceUtil::Mutex
public:
typedef IceUtil::Handle<ObserverImplType> ObserverImplPtrType;
- typedef typename ObserverImplType::Type MetricsType;
+ typedef typename ObserverImplType::MetricsType MetricsType;
+
+ typedef std::vector<IceUtil::Handle<MetricsMapT<MetricsType> > > MetricsMapSeqType;
ObserverFactoryT(const MetricsAdminIPtr& metrics, const std::string& name) : _metrics(metrics), _name(name)
{
_metrics->registerMap<MetricsType>(name);
}
+ ObserverFactoryT(const std::string& name) : _name(name)
+ {
+ }
+
ObserverImplPtrType
getObserver(const MetricsHelperT<MetricsType>& helper)
{
IceUtil::Mutex::Lock sync(*this);
- std::vector<MetricsMapI::EntryPtr> metricsObjects;
- for(std::vector<MetricsMapIPtr>::const_iterator p = _maps.begin(); p != _maps.end(); ++p)
+ typename ObserverImplType::EntrySeqType metricsObjects;
+ for(typename MetricsMapSeqType::const_iterator p = _maps.begin(); p != _maps.end(); ++p)
{
- MetricsMapI::EntryPtr entry = (*p)->getMatching(helper);
+ typename ObserverImplType::EntryPtrType entry = (*p)->getMatching(helper);
if(entry)
{
metricsObjects.push_back(entry);
@@ -415,8 +435,10 @@ public:
return 0;
}
+ std::sort(metricsObjects.begin(), metricsObjects.end());
+
ObserverImplPtrType obsv = new ObserverImplType();
- obsv->init(helper, metricsObjects);
+ obsv->init(helper, metricsObjects, this);
return obsv;
}
@@ -425,10 +447,10 @@ public:
{
IceUtil::Mutex::Lock sync(*this);
- std::vector<MetricsMapI::EntryPtr> metricsObjects;
- for(std::vector<MetricsMapIPtr>::const_iterator p = _maps.begin(); p != _maps.end(); ++p)
+ typename ObserverImplType::EntrySeqType metricsObjects;
+ for(typename MetricsMapSeqType::const_iterator p = _maps.begin(); p != _maps.end(); ++p)
{
- MetricsMapI::EntryPtr entry = (*p)->getMatching(helper);
+ typename ObserverImplType::EntryPtrType entry = (*p)->getMatching(helper);
if(entry)
{
metricsObjects.push_back(entry);
@@ -440,11 +462,13 @@ public:
return 0;
}
+ std::sort(metricsObjects.begin(), metricsObjects.end());
+
ObserverImplPtrType obsv = ObserverImplPtrType::dynamicCast(observer);
if(!obsv)
{
obsv = new ObserverImplType();
- obsv->init(helper, metricsObjects);
+ obsv->init(helper, metricsObjects, this);
}
else
{
@@ -467,7 +491,13 @@ public:
void updateMaps()
{
IceUtil::Mutex::Lock sync(*this);
- _maps = _metrics->getMaps(_name);
+ std::vector<MetricsMapIPtr> maps = _metrics->getMaps(_name);
+ _maps.clear();
+ for(std::vector<MetricsMapIPtr>::const_iterator p = maps.begin(); p != maps.end(); ++p)
+ {
+ _maps.push_back(IceUtil::Handle<MetricsMapT<MetricsType> >::dynamicCast(*p));
+ assert(_maps.back());
+ }
_enabled = !_maps.empty();
}
@@ -475,7 +505,7 @@ private:
const MetricsAdminIPtr _metrics;
const std::string _name;
- std::vector<MetricsMapIPtr> _maps;
+ MetricsMapSeqType _maps;
volatile bool _enabled;
};
diff --git a/cpp/src/Ice/ObserverI.cpp b/cpp/src/Ice/ObserverI.cpp
index 5ec9296bbc3..715b6a180f0 100644
--- a/cpp/src/Ice/ObserverI.cpp
+++ b/cpp/src/Ice/ObserverI.cpp
@@ -696,13 +696,21 @@ CommunicatorObserverI::setObserverUpdater(const ObserverUpdaterPtr& updater)
ObserverPtr
CommunicatorObserverI::getConnectionEstablishmentObserver(const EndpointInfoPtr& endpt, const string& connector)
{
- return _connects.getObserver(EndpointHelper(endpt, connector));
+ if(_connects.isEnabled())
+ {
+ return _connects.getObserver(EndpointHelper(endpt, connector));
+ }
+ return 0;
}
ObserverPtr
CommunicatorObserverI::getEndpointLookupObserver(const EndpointInfoPtr& endpt, const string& endpoint)
{
- return _endpointLookups.getObserver(EndpointHelper(endpt, endpoint));
+ if(_endpointLookups.isEnabled())
+ {
+ return _endpointLookups.getObserver(EndpointHelper(endpt, endpoint));
+ }
+ return 0;
}
ConnectionObserverPtr
@@ -711,7 +719,11 @@ CommunicatorObserverI::getConnectionObserver(const ConnectionInfoPtr& con,
ConnectionState state,
const ConnectionObserverPtr& observer)
{
- return _connections.getObserver(ConnectionHelper(con, endpt, state), observer);
+ if(_connections.isEnabled())
+ {
+ return _connections.getObserver(ConnectionHelper(con, endpt, state), observer);
+ }
+ return 0;
}
ThreadObserverPtr
@@ -720,7 +732,11 @@ CommunicatorObserverI::getThreadObserver(const string& parent,
ThreadState state,
const ThreadObserverPtr& observer)
{
- return _threads.getObserver(ThreadHelper(parent, id, state), observer);
+ if(_threads.isEnabled())
+ {
+ return _threads.getObserver(ThreadHelper(parent, id, state), observer);
+ }
+ return 0;
}
InvocationObserverPtr
@@ -736,13 +752,21 @@ CommunicatorObserverI::getInvocationObserver(const ObjectPrx& proxy, const strin
InvocationObserverPtr
CommunicatorObserverI::getInvocationObserverWithContext(const ObjectPrx& proxy, const string& op, const Context& ctx)
{
- return _invocations.getObserver(InvocationHelper(proxy, op, ctx));
+ if(_invocations.isEnabled())
+ {
+ return _invocations.getObserver(InvocationHelper(proxy, op, ctx));
+ }
+ return 0;
}
ObserverPtr
CommunicatorObserverI::getDispatchObserver(const Current& current)
{
- return _dispatch.getObserver(DispatchHelper(current));
+ if(_dispatch.isEnabled())
+ {
+ return _dispatch.getObserver(DispatchHelper(current));
+ }
+ return 0;
}
void
diff --git a/cpp/src/Ice/ObserverI.h b/cpp/src/Ice/ObserverI.h
index 9ce1712bc55..c3954258ae8 100644
--- a/cpp/src/Ice/ObserverI.h
+++ b/cpp/src/Ice/ObserverI.h
@@ -40,9 +40,6 @@ public:
virtual void retried();
virtual Ice::Instrumentation::ObserverPtr getRemoteObserver(const Ice::ConnectionPtr&);
-
-private:
-
};
class CommunicatorObserverI : public Ice::Instrumentation::CommunicatorObserver,
@@ -91,7 +88,7 @@ private:
ObserverFactoryT<InvocationObserverI> _invocations;
ObserverFactoryT<ThreadObserverI> _threads;
ObserverFactoryT<ObserverI> _connects;
- ObserverFactoryT<ObserverI> _endpointLookups;
+ ObserverFactoryT<ObserverI> _endpointLookups;
};
typedef IceUtil::Handle<CommunicatorObserverI> CommunicatorObserverIPtr;
generated by cgit v1.2.3 (git 2.46.0) at 2025-08-03 22:45:34 +0000