zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/MetricsAdminI.cpp

@@ -1,17 +1,14 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/MetricsAdminI.h>
+#include "MetricsAdminI.h"
+#include "Ice/Logger.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/Properties.h"
+#include "Ice/StringUtil.h"
+#include "MetricsObserverI.h"
 
-#include <Ice/InstrumentationI.h>
-#include <Ice/Properties.h>
-#include <Ice/Logger.h>
-#include <Ice/Communicator.h>
-#include <Ice/Instance.h>
-#include <Ice/LoggerUtil.h>
-
-#include <IceUtil/StringUtil.h>
+#include <chrono>
+#include <stdexcept>
 
 using namespace std;
 using namespace Ice;
@@ -20,173 +17,125 @@ using namespace IceMX;
 
 namespace
 {
-
-const string suffixes[] =
-{
-    "Disabled",
-    "GroupBy",
-    "Accept.*",
-    "Reject.*",
-    "RetainDetached",
-    "Map.*",
-};
-
-void
-validateProperties(const string& prefix, const PropertiesPtr& properties)
-{
-    vector<string> unknownProps;
-    PropertyDict props = properties->getPropertiesForPrefix(prefix);
-    for(PropertyDict::const_iterator p = props.begin(); p != props.end(); ++p)
-    {
-        bool valid = false;
-        for(size_t i = 0; i < sizeof(suffixes) / sizeof(*suffixes); ++i)
+    // NOLINTBEGIN(cert-err58-cpp)
+    const string suffixes[] = {
+        "Disabled",
+        "GroupBy",
+        "Accept.*",
+        "Reject.*",
+        "RetainDetached",
+        "Map.*",
+    };
+    // NOLINTEND(cert-err58-cpp)
+
+    void validateProperties(const string& prefix, const PropertiesPtr& properties)
+    {
+        vector<string> unknownProps;
+        PropertyDict props = properties->getPropertiesForPrefix(prefix);
+        for (const auto& p : props)
         {
-            string prop = prefix + suffixes[i];
-            if(IceUtilInternal::match(p->first, prop))
+            bool valid = false;
+            for (const auto& suffix : suffixes)
             {
-                valid = true;
-                break;
+                string prop = prefix + suffix;
+                if (IceInternal::match(p.first, prop))
+                {
+                    valid = true;
+                    break;
+                }
+            }
+            if (!valid)
+            {
+                unknownProps.push_back(p.first);
             }
         }
-        if(!valid)
-        {
-            unknownProps.push_back(p->first);
-        }
-    }
 
-    if(!unknownProps.empty() && properties->getPropertyAsIntWithDefault("Ice.Warn.UnknownProperties", 1) > 0)
-    {
-        Warning out(getProcessLogger());
-        out << "found unknown IceMX properties for '" << prefix.substr(0, prefix.size() - 1) << "':";
-        for(vector<string>::const_iterator p = unknownProps.begin(); p != unknownProps.end(); ++p)
+        if (!unknownProps.empty())
         {
-            out << "\n    " << *p;
-            properties->setProperty(*p, ""); // Clear the known property to prevent further warnings.
+            ostringstream os;
+            os << "found unknown properties for " << "IceMX" << ": '" << prefix << "'";
+            for (const auto& prop : unknownProps)
+            {
+                os << "\n    " << prop;
+            }
+            throw PropertyException{__FILE__, __LINE__, os.str()};
         }
     }
-}
 
-vector<MetricsMapI::RegExpPtr>
-parseRule(const PropertiesPtr& properties, const string& name)
-{
-    vector<MetricsMapI::RegExpPtr> regexps;
-    PropertyDict rules = properties->getPropertiesForPrefix(name + '.');
-    for(PropertyDict::const_iterator p = rules.begin(); p != rules.end(); ++p)
+    vector<MetricsMapI::RegExpPtr> parseRule(const PropertiesPtr& properties, const string& name)
     {
-        try
-        {
-            regexps.push_back(ICE_MAKE_SHARED(MetricsMapI::RegExp, p->first.substr(name.length() + 1), p->second));
-        }
-        catch(const std::exception&)
+        vector<MetricsMapI::RegExpPtr> regexps;
+        PropertyDict rules = properties->getPropertiesForPrefix(name + '.');
+        for (const auto& rule : rules)
         {
-            throw invalid_argument("invalid regular expression `" + p->second + "' for `" + p->first + "'");
+            try
+            {
+                regexps.push_back(make_shared<MetricsMapI::RegExp>(rule.first.substr(name.length() + 1), rule.second));
+            }
+            catch (const std::exception&)
+            {
+                throw invalid_argument("invalid regular expression '" + rule.second + "' for '" + rule.first + "'");
+            }
         }
+        return regexps;
     }
-    return regexps;
-}
-
 }
 
-MetricsMapI::RegExp::RegExp(const string& attribute, const string& regexp) : _attribute(attribute)
+MetricsMapI::RegExp::RegExp(string attribute, const string& regexp) : _attribute(std::move(attribute))
 {
-#ifdef __MINGW32__
-    //
-    // No regexp support with MinGW, when MinGW C++11 mode is not experimental
-    // we can use std::regex.
-    //
-#elif !defined(ICE_CPP11_COMPILER_REGEXP)
-    if(regcomp(&_preg, regexp.c_str(), REG_EXTENDED | REG_NOSUB) != 0)
-    {
-        throw SyscallException(__FILE__, __LINE__);
-    }
-#else
-#   if _MSC_VER < 1600
-    _regex = std::tr1::regex(regexp, std::tr1::regex_constants::extended | std::tr1::regex_constants::nosubs);
-#   else
     _regex = regex(regexp, std::regex_constants::extended | std::regex_constants::nosubs);
-#   endif
-#endif
-}
-
-MetricsMapI::RegExp::~RegExp()
-{
-#ifdef __MINGW32__
-    //
-    // No regexp support with MinGW, when MinGW C++11 mode is not experimental
-    // we can use std::regex.
-    //
-#elif !defined(ICE_CPP11_COMPILER_REGEXP)
-    regfree(&_preg);
-#endif
 }
 
 bool
 MetricsMapI::RegExp::match(const string& value)
 {
-#ifdef __MINGW32__
-    //
-    // No regexp support with MinGW, when MinGW C++11 mode is not experimental
-    // we can use std::regex.
-    //
-    return false;
-#elif !defined(ICE_CPP11_COMPILER_REGEXP)
-    return regexec(&_preg, value.c_str(), 0, 0, 0) == 0;
-#else
-#   if _MSC_VER < 1600
-    return std::tr1::regex_match(value, _regex);
-#   else
     return regex_match(value, _regex);
-#   endif
-#endif
 }
 
-MetricsMapI::~MetricsMapI()
-{
-    // Out of line to avoid weak vtable
-}
+MetricsMapI::~MetricsMapI() = default; // Out of line to avoid weak vtable
 
-MetricsMapI::MetricsMapI(const std::string& mapPrefix, const PropertiesPtr& properties) :
-    _properties(properties->getPropertiesForPrefix(mapPrefix)),
-    _retain(properties->getPropertyAsIntWithDefault(mapPrefix + "RetainDetached", 10)),
-    _accept(parseRule(properties, mapPrefix + "Accept")),
-    _reject(parseRule(properties, mapPrefix + "Reject"))
+MetricsMapI::MetricsMapI(const std::string& mapPrefix, const PropertiesPtr& properties)
+    : _properties(properties->getPropertiesForPrefix(mapPrefix)),
+      _retain(properties->getIcePropertyAsInt(mapPrefix + "RetainDetached")),
+      _accept(parseRule(properties, mapPrefix + "Accept")),
+      _reject(parseRule(properties, mapPrefix + "Reject"))
 {
     validateProperties(mapPrefix, properties);
 
     string groupBy = properties->getPropertyWithDefault(mapPrefix + "GroupBy", "id");
-    vector<string>& groupByAttributes = const_cast<vector<string>&>(_groupByAttributes);
-    vector<string>& groupBySeparators = const_cast<vector<string>&>(_groupBySeparators);
-    if(!groupBy.empty())
+    auto& groupByAttributes = const_cast<vector<string>&>(_groupByAttributes);
+    auto& groupBySeparators = const_cast<vector<string>&>(_groupBySeparators);
+    if (!groupBy.empty())
     {
         string v;
-        bool attribute = IceUtilInternal::isAlpha(groupBy[0]) || IceUtilInternal::isDigit(groupBy[0]);
-        if(!attribute)
+        bool attribute = IceInternal::isAlpha(groupBy[0]) || IceInternal::isDigit(groupBy[0]);
+        if (!attribute)
         {
-            groupByAttributes.push_back("");
+            groupByAttributes.emplace_back("");
         }
 
-        for(string::const_iterator p = groupBy.begin(); p != groupBy.end(); ++p)
+        for (char p : groupBy)
         {
-            bool isAlphaNum = IceUtilInternal::isAlpha(*p) || IceUtilInternal::isDigit(*p) || *p == '.';
-            if(attribute && !isAlphaNum)
+            bool isAlphaNum = IceInternal::isAlpha(p) || IceInternal::isDigit(p) || p == '.';
+            if (attribute && !isAlphaNum)
             {
                 groupByAttributes.push_back(v);
-                v = *p;
+                v = p;
                 attribute = false;
             }
-            else if(!attribute && isAlphaNum)
+            else if (!attribute && isAlphaNum)
             {
                 groupBySeparators.push_back(v);
-                v = *p;
+                v = p;
                 attribute = true;
             }
             else
             {
-                v += *p;
+                v += p;
             }
         }
 
-        if(attribute)
+        if (attribute)
         {
             groupByAttributes.push_back(v);
         }
@@ -197,35 +146,26 @@ MetricsMapI::MetricsMapI(const std::string& mapPrefix, const PropertiesPtr& prop
     }
 }
 
-MetricsMapI::MetricsMapI(const MetricsMapI& map) :
-#if defined(ICE_CPP11_MAPPING)
-    std::enable_shared_from_this<MetricsMapI>(),
-#elif defined(__GNUC__)
-    IceUtil::Shared(),
-#endif
-    _properties(map._properties),
-    _groupByAttributes(map._groupByAttributes),
-    _groupBySeparators(map._groupBySeparators),
-    _retain(map._retain),
-    _accept(map._accept),
-    _reject(map._reject)
+MetricsMapI::MetricsMapI(const MetricsMapI& map)
+    : std::enable_shared_from_this<MetricsMapI>(),
+      _properties(map._properties),
+      _groupByAttributes(map._groupByAttributes),
+      _groupBySeparators(map._groupBySeparators),
+      _retain(map._retain),
+      _accept(map._accept),
+      _reject(map._reject)
 {
 }
 
-const ::Ice::PropertyDict&
+const Ice::PropertyDict&
 MetricsMapI::getProperties() const
 {
     return _properties;
 }
 
-MetricsMapFactory::~MetricsMapFactory()
-{
-    // Out of line to avoid weak vtable
-}
+MetricsMapFactory::~MetricsMapFactory() = default; // Out of line to avoid weak vtable
 
-MetricsMapFactory::MetricsMapFactory(Updater* updater) : _updater(updater)
-{
-}
+MetricsMapFactory::MetricsMapFactory(Updater* updater) : _updater(updater) {}
 
 void
 MetricsMapFactory::update()
@@ -234,22 +174,23 @@ MetricsMapFactory::update()
     _updater->update();
 }
 
-MetricsViewI::MetricsViewI(const string& name) : _name(name)
-{
-}
+MetricsViewI::MetricsViewI(string name) : _name(std::move(name)) {}
 
 void
 MetricsViewI::destroy()
 {
-    for(map<string, MetricsMapIPtr>::const_iterator p = _maps.begin(); p != _maps.end(); ++p)
+    for (const auto& map : _maps)
     {
-        p->second->destroy();
+        map.second->destroy();
     }
 }
 
 bool
-MetricsViewI::addOrUpdateMap(const PropertiesPtr& properties, const string& mapName,
-                             const MetricsMapFactoryPtr& factory, const ::Ice::LoggerPtr& logger)
+MetricsViewI::addOrUpdateMap(
+    const PropertiesPtr& properties,
+    const string& mapName,
+    const MetricsMapFactoryPtr& factory,
+    const Ice::LoggerPtr& logger)
 {
     const string viewPrefix = "IceMX.Metrics." + _name + ".";
     const string mapsPrefix = viewPrefix + "Map.";
@@ -257,15 +198,15 @@ MetricsViewI::addOrUpdateMap(const PropertiesPtr& properties, const string& mapN
 
     string mapPrefix;
     PropertyDict mapProps;
-    if(!mapsProps.empty())
+    if (!mapsProps.empty())
     {
         mapPrefix = mapsPrefix + mapName + ".";
         mapProps = properties->getPropertiesForPrefix(mapPrefix);
-        if(mapProps.empty())
+        if (mapProps.empty())
         {
             // This map isn't configured for this view.
-            map<string, MetricsMapIPtr>::iterator q = _maps.find(mapName);
-            if(q != _maps.end())
+            auto q = _maps.find(mapName);
+            if (q != _maps.end())
             {
                 q->second->destroy();
                 _maps.erase(q);
@@ -280,11 +221,11 @@ MetricsViewI::addOrUpdateMap(const PropertiesPtr& properties, const string& mapN
         mapProps = properties->getPropertiesForPrefix(mapPrefix);
     }
 
-    if(properties->getPropertyAsInt(mapPrefix + "Disabled") > 0)
+    if (properties->getPropertyAsInt(mapPrefix + "Disabled") > 0)
     {
         // This map is disabled for this view.
-        map<string, MetricsMapIPtr>::iterator q = _maps.find(mapName);
-        if(q != _maps.end())
+        auto q = _maps.find(mapName);
+        if (q != _maps.end())
         {
             q->second->destroy();
             _maps.erase(q);
@@ -293,13 +234,13 @@ MetricsViewI::addOrUpdateMap(const PropertiesPtr& properties, const string& mapN
         return false;
     }
 
-    map<string, MetricsMapIPtr>::iterator q = _maps.find(mapName);
-    if(q != _maps.end() && q->second->getProperties() == mapProps)
+    auto q = _maps.find(mapName);
+    if (q != _maps.end() && q->second->getProperties() == mapProps)
     {
         return false; // The map configuration didn't change, no need to re-create.
     }
 
-    if(q != _maps.end())
+    if (q != _maps.end())
     {
         // Destroy the previous map
         q->second->destroy();
@@ -310,9 +251,9 @@ MetricsViewI::addOrUpdateMap(const PropertiesPtr& properties, const string& mapN
     {
         _maps.insert(make_pair(mapName, factory->create(mapPrefix, properties)));
     }
-    catch(const std::exception& ex)
+    catch (const std::exception& ex)
     {
-        ::Ice::Warning warn(logger);
+        Ice::Warning warn(logger);
         warn << "unexpected exception while creating metrics map:\n" << ex;
     }
     return true;
@@ -321,8 +262,8 @@ MetricsViewI::addOrUpdateMap(const PropertiesPtr& properties, const string& mapN
 bool
 MetricsViewI::removeMap(const string& mapName)
 {
-    map<string, MetricsMapIPtr>::iterator q = _maps.find(mapName);
-    if(q != _maps.end())
+    auto q = _maps.find(mapName);
+    if (q != _maps.end())
     {
         q->second->destroy();
         _maps.erase(q);
@@ -335,9 +276,9 @@ MetricsView
 MetricsViewI::getMetrics()
 {
     MetricsView metrics;
-    for(map<string, MetricsMapIPtr>::const_iterator p = _maps.begin(); p != _maps.end(); ++p)
+    for (const auto& map : _maps)
     {
-        metrics.insert(make_pair(p->first, p->second->getMetrics()));
+        metrics.insert(make_pair(map.first, map.second->getMetrics()));
     }
     return metrics;
 }
@@ -345,32 +286,33 @@ MetricsViewI::getMetrics()
 MetricsFailuresSeq
 MetricsViewI::getFailures(const string& mapName)
 {
-    map<string, MetricsMapIPtr>::const_iterator p = _maps.find(mapName);
-    if(p != _maps.end())
+    auto p = _maps.find(mapName);
+    if (p != _maps.end())
     {
         return p->second->getFailures();
     }
-    return MetricsFailuresSeq();
+    return {};
 }
 
 MetricsFailures
 MetricsViewI::getFailures(const string& mapName, const string& id)
 {
-    map<string, MetricsMapIPtr>::const_iterator p = _maps.find(mapName);
-    if(p != _maps.end())
+    auto p = _maps.find(mapName);
+    if (p != _maps.end())
     {
         return p->second->getFailures(id);
     }
-    return MetricsFailures();
+    return {};
 }
 
 vector<string>
 MetricsViewI::getMaps() const
 {
     vector<string> maps;
-    for(map<string, MetricsMapIPtr>::const_iterator p = _maps.begin(); p != _maps.end(); ++p)
+    maps.reserve(_maps.size());
+    for (const auto& map : _maps)
     {
-        maps.push_back(p->first);
+        maps.push_back(map.first);
     }
     return maps;
 }
@@ -378,31 +320,30 @@ MetricsViewI::getMaps() const
 MetricsMapIPtr
 MetricsViewI::getMap(const string& mapName) const
 {
-    map<string, MetricsMapIPtr>::const_iterator p = _maps.find(mapName);
-    if(p != _maps.end())
+    auto p = _maps.find(mapName);
+    if (p != _maps.end())
     {
         return p->second;
     }
-    return ICE_NULLPTR;
+    return nullptr;
 }
 
-MetricsAdminI::MetricsAdminI(const PropertiesPtr& properties, const LoggerPtr& logger) :
-    _logger(logger), _properties(properties)
+MetricsAdminI::MetricsAdminI(PropertiesPtr properties, LoggerPtr logger)
+    : _logger(std::move(logger)),
+      _properties(std::move(properties))
 {
     updateViews();
 }
 
-MetricsAdminI::~MetricsAdminI()
-{
-}
+MetricsAdminI::~MetricsAdminI() = default;
 
 void
 MetricsAdminI::destroy()
 {
-    Lock sync(*this);
-    for(map<string, MetricsViewIPtr>::const_iterator p = _views.begin(); p != _views.end(); ++p)
+    lock_guard lock(_mutex);
+    for (const auto& view : _views)
     {
-        p->second->destroy();
+        view.second->destroy();
     }
 }
 
@@ -411,28 +352,28 @@ MetricsAdminI::updateViews()
 {
     set<MetricsMapFactoryPtr> updatedMaps;
     {
-        Lock sync(*this);
+        lock_guard lock(_mutex);
         const string viewsPrefix = "IceMX.Metrics.";
         PropertyDict viewsProps = _properties->getPropertiesForPrefix(viewsPrefix);
         map<string, MetricsViewIPtr> views;
         _disabledViews.clear();
-        for(PropertyDict::const_iterator p = viewsProps.begin(); p != viewsProps.end(); ++p)
+        for (const auto& viewsProp : viewsProps)
         {
-            string viewName = p->first.substr(viewsPrefix.size());
+            string viewName = viewsProp.first.substr(viewsPrefix.size());
             string::size_type dotPos = viewName.find('.');
-            if(dotPos != string::npos)
+            if (dotPos != string::npos)
             {
                 viewName = viewName.substr(0, dotPos);
             }
 
-            if(views.find(viewName) != views.end() || _disabledViews.find(viewName) != _disabledViews.end())
+            if (views.find(viewName) != views.end() || _disabledViews.find(viewName) != _disabledViews.end())
             {
                 continue; // View already configured.
             }
 
             validateProperties(viewsPrefix + viewName + ".", _properties);
 
-            if(_properties->getPropertyAsIntWithDefault(viewsPrefix + viewName + ".Disabled", 0) > 0)
+            if (_properties->getPropertyAsIntWithDefault(viewsPrefix + viewName + ".Disabled", 0) > 0)
             {
                 _disabledViews.insert(viewName);
                 continue; // The view is disabled
@@ -441,21 +382,23 @@ MetricsAdminI::updateViews()
             //
             // Create the view or update it.
             //
-            map<string, MetricsViewIPtr>::const_iterator q = _views.find(viewName);
-            if(q == _views.end())
+            auto q = _views.find(viewName);
+            if (q == _views.end())
             {
-                q = views.insert(map<string, MetricsViewIPtr>::value_type(viewName, ICE_MAKE_SHARED(MetricsViewI, viewName))).first;
+                q = views
+                        .insert(map<string, MetricsViewIPtr>::value_type(viewName, make_shared<MetricsViewI>(viewName)))
+                        .first;
             }
             else
             {
                 q = views.insert(make_pair(viewName, q->second)).first;
             }
 
-            for(map<string, MetricsMapFactoryPtr>::const_iterator r = _factories.begin(); r != _factories.end(); ++r)
+            for (const auto& fact : _factories)
             {
-                if(q->second->addOrUpdateMap(_properties, r->first, r->second, _logger))
+                if (q->second->addOrUpdateMap(_properties, fact.first, fact.second, _logger))
                 {
-                    updatedMaps.insert(r->second);
+                    updatedMaps.insert(fact.second);
                 }
             }
         }
@@ -464,16 +407,16 @@ MetricsAdminI::updateViews()
         //
         // Go through removed views to collect maps to update.
         //
-        for(map<string, MetricsViewIPtr>::const_iterator p = views.begin(); p != views.end(); ++p)
+        for (const auto& view : views)
         {
-            if(_views.find(p->first) == _views.end())
+            if (_views.find(view.first) == _views.end())
             {
-                vector<string> maps = p->second->getMaps();
-                for(vector<string>::const_iterator q = maps.begin(); q != maps.end(); ++q)
+                vector<string> maps = view.second->getMaps();
+                for (const auto& map : maps)
                 {
-                    updatedMaps.insert(_factories[*q]);
+                    updatedMaps.insert(_factories[map]);
                 }
-                p->second->destroy();
+                view.second->destroy();
             }
         }
     }
@@ -481,9 +424,9 @@ MetricsAdminI::updateViews()
     //
     // Call the updaters to update the maps.
     //
-    for(set<MetricsMapFactoryPtr>::const_iterator p = updatedMaps.begin(); p != updatedMaps.end(); ++p)
+    for (const auto& updatedMap : updatedMaps)
     {
-        (*p)->update();
+        updatedMap->update();
     }
 }
 
@@ -493,9 +436,9 @@ MetricsAdminI::unregisterMap(const std::string& mapName)
     bool updated;
     MetricsMapFactoryPtr factory;
     {
-        Lock sync(*this);
-        map<string, MetricsMapFactoryPtr>::iterator p = _factories.find(mapName);
-        if(p == _factories.end())
+        lock_guard lock(_mutex);
+        auto p = _factories.find(mapName);
+        if (p == _factories.end())
         {
             return;
         }
@@ -503,7 +446,7 @@ MetricsAdminI::unregisterMap(const std::string& mapName)
         _factories.erase(p);
         updated = removeMap(mapName);
     }
-    if(updated)
+    if (updated)
     {
         factory->update();
     }
@@ -514,113 +457,84 @@ MetricsAdminI::getMetricsViewNames(Ice::StringSeq& disabledViews, const Current&
 {
     Ice::StringSeq enabledViews;
 
-    Lock sync(*this);
-    for(map<string, MetricsViewIPtr>::const_iterator p = _views.begin(); p != _views.end(); ++p)
-    {
-        enabledViews.push_back(p->first);
-    }
-
-#if defined(__SUNPRO_CC) && defined(_RWSTD_NO_MEMBER_TEMPLATES)
-    for(set<string>::const_iterator p = _disabledViews.begin(); p != _disabledViews.end(); ++p)
+    lock_guard lock(_mutex);
+    for (const auto& view : _views)
     {
-        disabledViews.push_back(*p);
+        enabledViews.push_back(view.first);
     }
-
-#else
     disabledViews.insert(disabledViews.end(), _disabledViews.begin(), _disabledViews.end());
-#endif
-
     return enabledViews;
 }
 
 void
-#ifdef ICE_CPP11_MAPPING
 MetricsAdminI::enableMetricsView(string viewName, const Current&)
-#else
-MetricsAdminI::enableMetricsView(const string& viewName, const Current&)
-#endif
 {
     {
-        Lock sync(*this);
-        getMetricsView(viewName); // Throws if unkonwn metrics view.
+        lock_guard lock(_mutex);
+        getMetricsView(viewName); // Throws if unknown metrics view.
         _properties->setProperty("IceMX.Metrics." + viewName + ".Disabled", "0");
     }
     updateViews();
 }
 
 void
-#ifdef ICE_CPP11_MAPPING
 MetricsAdminI::disableMetricsView(string viewName, const Current&)
-#else
-MetricsAdminI::disableMetricsView(const string& viewName, const Current&)
-#endif
 {
     {
-        Lock sync(*this);
-        getMetricsView(viewName); // Throws if unkonwn metrics view.
+        lock_guard lock(_mutex);
+        getMetricsView(viewName); // Throws if unknown metrics view.
         _properties->setProperty("IceMX.Metrics." + viewName + ".Disabled", "1");
     }
     updateViews();
 }
 
 MetricsView
-#ifdef ICE_CPP11_MAPPING
-MetricsAdminI::getMetricsView(string viewName, ::Ice::Long& timestamp, const Current&)
-#else
-MetricsAdminI::getMetricsView(const string& viewName, ::Ice::Long& timestamp, const Current&)
-#endif
+MetricsAdminI::getMetricsView(string viewName, int64_t& timestamp, const Current&)
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
     MetricsViewIPtr view = getMetricsView(viewName);
-    timestamp = IceUtil::Time::now().toMilliSeconds();
-    if(view)
+    timestamp =
+        chrono::duration_cast<chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
+    if (view)
     {
         return view->getMetrics();
     }
-    return MetricsView();
+    return {};
 }
 
 MetricsFailuresSeq
-#ifdef ICE_CPP11_MAPPING
 MetricsAdminI::getMapMetricsFailures(string viewName, string map, const Current&)
-#else
-MetricsAdminI::getMapMetricsFailures(const string& viewName, const string& map, const Current&)
-#endif
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
     MetricsViewIPtr view = getMetricsView(viewName);
-    if(view)
+    if (view)
     {
         return view->getFailures(map);
     }
-    return MetricsFailuresSeq();
+    return {};
 }
 
 MetricsFailures
-#ifdef ICE_CPP11_MAPPING
 MetricsAdminI::getMetricsFailures(string viewName, string map, string id, const Current&)
-#else
-MetricsAdminI::getMetricsFailures(const string& viewName, const string& map, const string& id, const Current&)
-#endif
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
     MetricsViewIPtr view = getMetricsView(viewName);
-    if(view)
+    if (view)
     {
         return view->getFailures(map, id);
     }
-    return MetricsFailures();
+    return {};
 }
 
 vector<MetricsMapIPtr>
 MetricsAdminI::getMaps(const string& mapName) const
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
     vector<MetricsMapIPtr> maps;
-    for(std::map<string, MetricsViewIPtr>::const_iterator p = _views.begin(); p != _views.end(); ++p)
+    for (const auto& view : _views)
     {
-        MetricsMapIPtr map = p->second->getMap(mapName);
-        if(map)
+        MetricsMapIPtr map = view.second->getMap(mapName);
+        if (map)
         {
             maps.push_back(map);
         }
@@ -637,14 +551,14 @@ MetricsAdminI::getLogger() const
 MetricsViewIPtr
 MetricsAdminI::getMetricsView(const std::string& name)
 {
-    std::map<string, MetricsViewIPtr>::const_iterator p = _views.find(name);
-    if(p == _views.end())
+    auto p = _views.find(name);
+    if (p == _views.end())
     {
-        if(_disabledViews.find(name) == _disabledViews.end())
+        if (_disabledViews.find(name) == _disabledViews.end())
         {
             throw UnknownMetricsView();
         }
-        return ICE_NULLPTR;
+        return nullptr;
     }
     return p->second;
 }
@@ -652,18 +566,18 @@ MetricsAdminI::getMetricsView(const std::string& name)
 void
 MetricsAdminI::updated(const PropertyDict& props)
 {
-    for(PropertyDict::const_iterator p = props.begin(); p != props.end(); ++p)
+    for (const auto& prop : props)
     {
-        if(p->first.find("IceMX.") == 0)
+        if (prop.first.find("IceMX.") == 0)
         {
             // Update the metrics views using the new configuration.
             try
             {
                 updateViews();
             }
-            catch(const std::exception& ex)
+            catch (const std::exception& ex)
             {
-                ::Ice::Warning warn(_logger);
+                Ice::Warning warn(_logger);
                 warn << "unexpected exception while updating metrics view configuration:\n" << ex.what();
             }
             return;
@@ -675,9 +589,9 @@ bool
 MetricsAdminI::addOrUpdateMap(const std::string& mapName, const MetricsMapFactoryPtr& factory)
 {
     bool updated = false;
-    for(std::map<string, MetricsViewIPtr>::const_iterator p = _views.begin(); p != _views.end(); ++p)
+    for (const auto& view : _views)
     {
-        updated |= p->second->addOrUpdateMap(_properties, mapName, factory, _logger);
+        updated |= view.second->addOrUpdateMap(_properties, mapName, factory, _logger);
     }
     return updated;
 }
@@ -686,9 +600,9 @@ bool
 MetricsAdminI::removeMap(const std::string& mapName)
 {
     bool updated = false;
-    for(std::map<string, MetricsViewIPtr>::const_iterator p = _views.begin(); p != _views.end(); ++p)
+    for (const auto& view : _views)
     {
-        updated |= p->second->removeMap(mapName);
+        updated |= view.second->removeMap(mapName);
     }
     return updated;
 }