zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,17 +1,17 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/LoggerAdminI.h>
-#include <Ice/Initialize.h>
-#include <Ice/Communicator.h>
-#include <Ice/RemoteLogger.h>
-#include <Ice/Properties.h>
-#include <Ice/ObjectAdapter.h>
-#include <Ice/Connection.h>
-#include <Ice/LocalException.h>
-#include <Ice/LoggerUtil.h>
-
+// Copyright (c) ZeroC, Inc.
+
+#include "LoggerAdminI.h"
+#include "Ice/Communicator.h"
+#include "Ice/Initialize.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/ObjectAdapter.h"
+#include "Ice/Properties.h"
+#include "Ice/ProxyFunctions.h"
+#include "Ice/RemoteLogger.h"
+
+#include <atomic>
+#include <deque>
 #include <set>
 
 using namespace Ice;
@@ -19,938 +19,756 @@ using namespace std;
 
 namespace
 {
+    const char* traceCategory = "Admin.Logger";
 
-const char* traceCategory = "Admin.Logger";
-
-class LoggerAdminI : public Ice::LoggerAdmin
-#ifdef ICE_CPP11_MAPPING
-                   , public std::enable_shared_from_this<LoggerAdminI>
-#endif
-{
-public:
+    class LoggerAdminI : public Ice::LoggerAdmin, public std::enable_shared_from_this<LoggerAdminI>
+    {
+    public:
+        LoggerAdminI(const PropertiesPtr&);
 
-    LoggerAdminI(const PropertiesPtr&);
+        void
+        attachRemoteLogger(optional<RemoteLoggerPrx>, LogMessageTypeSeq, StringSeq, int32_t, const Current&) override;
 
-#ifdef ICE_CPP11_MAPPING
-    virtual void attachRemoteLogger(shared_ptr<RemoteLoggerPrx>, LogMessageTypeSeq,
-                                    StringSeq, Int, const Current&);
+        bool detachRemoteLogger(optional<RemoteLoggerPrx>, const Current&) override;
 
-    virtual bool detachRemoteLogger(shared_ptr<RemoteLoggerPrx>, const Current&);
+        LogMessageSeq getLog(LogMessageTypeSeq, StringSeq, int32_t, string&, const Current&) override;
 
-    virtual LogMessageSeq getLog(LogMessageTypeSeq, StringSeq, Int, string&, const Current&);
-#else
-    virtual void attachRemoteLogger(const RemoteLoggerPrx&, const LogMessageTypeSeq&,
-                                    const StringSeq&, Int, const Current&);
+        void destroy();
 
-    virtual bool detachRemoteLogger(const RemoteLoggerPrx&, const Current&);
+        vector<RemoteLoggerPrx> log(const LogMessage&);
 
-    virtual LogMessageSeq getLog(const LogMessageTypeSeq&, const StringSeq&, Int, string&, const Current&);
-#endif
+        void deadRemoteLogger(const RemoteLoggerPrx&, const LoggerPtr&, exception_ptr, std::string_view);
 
-    void destroy();
+        [[nodiscard]] int getTraceLevel() const { return _traceLevel; }
 
-    vector<RemoteLoggerPrxPtr> log(const LogMessage&);
+    private:
+        bool removeRemoteLogger(const RemoteLoggerPrx&);
 
-    void deadRemoteLogger(const RemoteLoggerPrxPtr&, const LoggerPtr&, const LocalException&, const string&);
+        std::mutex _mutex;
+        list<LogMessage> _queue;
+        int _logCount{0}; // non-trace messages
+        const int _maxLogCount;
+        int _traceCount{0};
+        const int _maxTraceCount;
+        const int _traceLevel;
 
-    int getTraceLevel() const
-    {
-        return _traceLevel;
-    }
+        list<LogMessage>::iterator _oldestTrace;
+        list<LogMessage>::iterator _oldestLog;
 
-private:
-
-    bool removeRemoteLogger(const RemoteLoggerPrxPtr&);
+        struct ObjectIdentityCompare
+        {
+            bool operator()(const RemoteLoggerPrx& lhs, const RemoteLoggerPrx& rhs) const
+            {
+                return lhs->ice_getIdentity() < rhs->ice_getIdentity();
+            }
+        };
 
-#ifndef ICE_CPP11_MAPPING // C++98 mapping begin_init callback
-    void initCompleted(const AsyncResultPtr&);
-#endif
+        struct Filters
+        {
+            Filters(const LogMessageTypeSeq& m, const StringSeq& c)
+                : messageTypes(m.begin(), m.end()),
+                  traceCategories(c.begin(), c.end())
+            {
+            }
 
-    IceUtil::Mutex _mutex;
-    list<LogMessage> _queue;
-    int _logCount; // non-trace messages
-    const int _maxLogCount;
-    int _traceCount;
-    const int _maxTraceCount;
-    const int _traceLevel;
+            const set<LogMessageType> messageTypes;
+            const set<string> traceCategories;
+        };
 
-    list<LogMessage>::iterator _oldestTrace;
-    list<LogMessage>::iterator _oldestLog;
+        using RemoteLoggerMap = map<RemoteLoggerPrx, Filters, ObjectIdentityCompare>;
 
-    struct ObjectIdentityCompare
-    {
-        bool operator()(const RemoteLoggerPrxPtr& lhs, const RemoteLoggerPrxPtr& rhs) const
+        struct GetRemoteLoggerMapKey
         {
-            //
-            // Caller should make sure that proxies are never null
-            //
-            assert(lhs != 0 && rhs != 0);
+            RemoteLoggerMap::key_type operator()(const RemoteLoggerMap::value_type& val) { return val.first; }
+        };
 
-            return lhs->ice_getIdentity() < rhs->ice_getIdentity();
-        }
+        RemoteLoggerMap _remoteLoggerMap;
+        CommunicatorPtr _sendLogCommunicator;
+        bool _destroyed{false};
     };
+    using LoggerAdminIPtr = std::shared_ptr<LoggerAdminI>;
 
-    struct Filters
+    class Job
     {
-        Filters(const LogMessageTypeSeq& m, const StringSeq& c) :
-            messageTypes(m.begin(), m.end()),
-            traceCategories(c.begin(), c.end())
-        {
-        }
+    public:
+        Job(const vector<RemoteLoggerPrx>& r, LogMessage l) : remoteLoggers(r), logMessage(std::move(l)) {}
 
-        const set<LogMessageType> messageTypes;
-        const set<string> traceCategories;
+        const vector<RemoteLoggerPrx> remoteLoggers;
+        const LogMessage logMessage;
     };
+    using JobPtr = std::shared_ptr<Job>;
 
-    typedef map<RemoteLoggerPrxPtr, Filters, ObjectIdentityCompare> RemoteLoggerMap;
-
-    struct GetRemoteLoggerMapKey
+    class LoggerAdminLoggerI final : public IceInternal::LoggerAdminLogger,
+                                     public std::enable_shared_from_this<LoggerAdminLoggerI>
     {
-        RemoteLoggerMap::key_type
-        operator()(const RemoteLoggerMap::value_type& val)
-        {
-            return val.first;
-        }
-    };
-
-    RemoteLoggerMap _remoteLoggerMap;
-    CommunicatorPtr _sendLogCommunicator;
-    bool _destroyed;
-};
-ICE_DEFINE_PTR(LoggerAdminIPtr, LoggerAdminI);
+    public:
+        LoggerAdminLoggerI(const PropertiesPtr&, const LoggerPtr&);
 
-class Job : public IceUtil::Shared
-{
-public:
+        void print(const std::string&) final;
+        void trace(const std::string&, const std::string&) final;
+        void warning(const std::string&) final;
+        void error(const std::string&) final;
+        std::string getPrefix() final;
+        LoggerPtr cloneWithPrefix(std::string) final;
 
-    Job(const vector<RemoteLoggerPrxPtr>& r, const LogMessage& l) :
-        remoteLoggers(r),
-        logMessage(l)
-    {
-    }
+        [[nodiscard]] ObjectPtr getFacet() const override;
+        void detach() final;
 
-    const vector<RemoteLoggerPrxPtr> remoteLoggers;
-    const LogMessage logMessage;
-};
-typedef IceUtil::Handle<Job> JobPtr;
+        [[nodiscard]] const LoggerPtr& getLocalLogger() const { return _localLogger; }
 
-class LoggerAdminLoggerI : public IceInternal::LoggerAdminLogger
-#ifdef ICE_CPP11_MAPPING
-                         , public std::enable_shared_from_this<LoggerAdminLoggerI>
-#endif
+        void run();
 
-{
-public:
+    private:
+        void log(const LogMessage&);
 
-    LoggerAdminLoggerI(const PropertiesPtr&, const LoggerPtr&);
+        const LoggerPtr _localLogger;
+        const LoggerAdminIPtr _loggerAdmin;
 
-    virtual void print(const std::string&);
-    virtual void trace(const std::string&, const std::string&);
-    virtual void warning(const std::string&);
-    virtual void error(const std::string&);
-    virtual std::string getPrefix();
-    virtual LoggerPtr cloneWithPrefix(const std::string&);
+        std::mutex _mutex;
+        std::condition_variable _conditionVariable;
 
-    virtual ObjectPtr getFacet() const;
+        std::atomic<bool> _detached{false};
+        std::thread _sendLogThread;
+        std::deque<JobPtr> _jobQueue;
+    };
+    using LoggerAdminLoggerIPtr = std::shared_ptr<LoggerAdminLoggerI>;
 
-    virtual void destroy();
+    //
+    // Helper functions
+    //
 
-    const LoggerPtr& getLocalLogger() const
+    LoggerPtr unwrapLocalLogger(const LoggerPtr& localLogger)
     {
-        return _localLogger;
-    }
-
-    void run();
-
-private:
-
-    void log(const LogMessage&);
-#ifndef ICE_CPP11_MAPPING // C++98 mapping begin_log callback
-    void logCompleted(const AsyncResultPtr&);
-#endif
-
-    LoggerPtr _localLogger;
-    const LoggerAdminIPtr _loggerAdmin;
-
-    IceUtil::Monitor<IceUtil::Mutex> _monitor;
-
-    bool _destroyed;
-    IceUtil::ThreadPtr _sendLogThread;
-    std::deque<JobPtr> _jobQueue;
-};
-ICE_DEFINE_PTR(LoggerAdminLoggerIPtr, LoggerAdminLoggerI);
-
-class SendLogThread : public IceUtil::Thread
-{
-public:
-
-    SendLogThread(const LoggerAdminLoggerIPtr&);
-
-    virtual void run();
-
-private:
-
-    LoggerAdminLoggerIPtr _logger;
-};
+        // There is currently no way to have a null local logger
+        assert(localLogger);
 
-//
-// Helper functions
-//
-
-//
-// Filter out messages from in/out logMessages list
-//
-void
-filterLogMessages(LogMessageSeq& logMessages, const set<LogMessageType>& messageTypes,
-                  const set<string>& traceCategories, Int messageMax)
-{
-    assert(!logMessages.empty() && messageMax != 0);
+        auto wrapper = dynamic_pointer_cast<LoggerAdminLoggerI>(localLogger);
+        if (wrapper)
+        {
+            // use the underlying local logger
+            return wrapper->getLocalLogger();
+        }
+        else
+        {
+            return localLogger;
+        }
+    }
 
     //
-    // Filter only if one of the 3 filters is set; messageMax < 0 means "give me all"
-    // that match the other filters, if any.
+    // Filter out messages from in/out logMessages list
     //
-    if(!messageTypes.empty() || !traceCategories.empty() || messageMax > 0)
+    void filterLogMessages(
+        LogMessageSeq& logMessages,
+        const set<LogMessageType>& messageTypes,
+        const set<string>& traceCategories,
+        int32_t messageMax)
     {
-        int count = 0;
-        LogMessageSeq::reverse_iterator p = logMessages.rbegin();
-        while(p != logMessages.rend())
+        assert(!logMessages.empty() && messageMax != 0);
+
+        //
+        // Filter only if one of the 3 filters is set; messageMax < 0 means "give me all"
+        // that match the other filters, if any.
+        //
+        if (!messageTypes.empty() || !traceCategories.empty() || messageMax > 0)
         {
-            bool keepIt = false;
-            if(messageTypes.empty() || messageTypes.count(p->type) != 0)
+            int count = 0;
+            auto p = logMessages.rbegin();
+            while (p != logMessages.rend())
             {
-                if(p->type != ICE_ENUM(LogMessageType, TraceMessage) || traceCategories.empty() ||
-                   traceCategories.count(p->traceCategory) != 0)
+                bool keepIt = false;
+                if (messageTypes.empty() || messageTypes.count(p->type) != 0)
                 {
-                    keepIt = true;
+                    if (p->type != LogMessageType::TraceMessage || traceCategories.empty() ||
+                        traceCategories.count(p->traceCategory) != 0)
+                    {
+                        keepIt = true;
+                    }
                 }
-            }
 
-            if(keepIt)
-            {
-                ++p;
-                ++count;
-                if(messageMax > 0 && count >= messageMax)
+                if (keepIt)
+                {
+                    ++p;
+                    ++count;
+                    if (messageMax > 0 && count >= messageMax)
+                    {
+                        //
+                        // p.base() points to p "+1"; note that this invalidates p.
+                        //
+                        logMessages.erase(logMessages.begin(), p.base());
+                        break; // while
+                    }
+                }
+                else
                 {
+                    ++p;
                     //
-                    // p.base() points to p "+1"; note that this invalidates p.
+                    // p.base() points to p "+1"; the erase invalidates p so we
+                    // need to rebuild it
                     //
-                    logMessages.erase(logMessages.begin(), p.base());
-                    break; // while
+                    p = LogMessageSeq::reverse_iterator(logMessages.erase(p.base()));
                 }
             }
-            else
-            {
-                ++p;
-                //
-                // p.base() points to p "+1"; the erase invalidates p so we
-                // need to rebuild it
-                //
-                p = LogMessageSeq::reverse_iterator(logMessages.erase(p.base()));
-            }
         }
+        // else, don't need any filtering
     }
-    // else, don't need any filtering
-}
 
-//
-// Change this proxy's communicator, while keeping its invocation timeout
-//
-RemoteLoggerPrxPtr
-changeCommunicator(const RemoteLoggerPrxPtr& prx, const CommunicatorPtr& communicator)
-{
-    if(prx == 0)
+    //
+    // Change this proxy's communicator, while keeping its invocation timeout
+    //
+    RemoteLoggerPrx changeCommunicator(const RemoteLoggerPrx& prx, const CommunicatorPtr& communicator)
     {
-        return 0;
+        RemoteLoggerPrx result{communicator, prx->ice_toString()};
+        return result->ice_invocationTimeout(prx->ice_getInvocationTimeout());
     }
 
-    RemoteLoggerPrxPtr result = ICE_UNCHECKED_CAST(RemoteLoggerPrx, communicator->stringToProxy(prx->ice_toString()));
-
-    return result->ice_invocationTimeout(prx->ice_getInvocationTimeout());
-}
-
-//
-// Copies a set of properties
-//
-void
-copyProperties(const string& prefix, const PropertiesPtr& from, const PropertiesPtr& to)
-{
-    PropertyDict dict = from->getPropertiesForPrefix(prefix);
-    for(PropertyDict::const_iterator p = dict.begin(); p != dict.end(); ++p)
+    //
+    // Copies a set of properties
+    //
+    void copyProperties(const string& prefix, const PropertiesPtr& from, const PropertiesPtr& to)
     {
-        to->setProperty(p->first, p->second);
+        PropertyDict dict = from->getPropertiesForPrefix(prefix);
+        for (const auto& p : dict)
+        {
+            to->setProperty(p.first, p.second);
+        }
     }
-}
 
-//
-// Create communicator used to send logs
-//
-CommunicatorPtr
-createSendLogCommunicator(const CommunicatorPtr& communicator, const LoggerPtr& logger)
-{
-    InitializationData initData;
-    initData.logger = logger;
-    initData.properties = createProperties();
+    //
+    // Create communicator used to send logs
+    //
+    CommunicatorPtr createSendLogCommunicator(const CommunicatorPtr& communicator, const LoggerPtr& logger)
+    {
+        InitializationData initData;
+        initData.logger = logger;
+        initData.properties = createProperties();
 
-    PropertiesPtr mainProps = communicator->getProperties();
+        PropertiesPtr mainProps = communicator->getProperties();
 
-    copyProperties("Ice.Default.Locator", mainProps, initData.properties);
-    copyProperties("Ice.Plugin.IceSSL", mainProps, initData.properties);
-    copyProperties("IceSSL.", mainProps, initData.properties);
+        copyProperties("Ice.Default.Locator", mainProps, initData.properties);
+        copyProperties("IceSSL.", mainProps, initData.properties);
 
-    StringSeq extraProps = mainProps->getPropertyAsList("Ice.Admin.Logger.Properties");
+        StringSeq extraProps = mainProps->getIcePropertyAsList("Ice.Admin.Logger.Properties");
 
-    if(!extraProps.empty())
-    {
-        for(vector<string>::iterator p = extraProps.begin(); p != extraProps.end(); ++p)
+        if (!extraProps.empty())
         {
-            if(p->find("--") != 0)
+            for (auto& extraProp : extraProps)
             {
-                *p = "--" + *p;
+                if (extraProp.find("--") != 0)
+                {
+                    extraProp = "--" + extraProp;
+                }
             }
+            initData.properties->parseCommandLineOptions("", extraProps);
         }
-        initData.properties->parseCommandLineOptions("", extraProps);
-    }
-
-    return initialize(initData);
-}
 
-//
-// LoggerAdminI
-//
-
-LoggerAdminI::LoggerAdminI(const PropertiesPtr& props) :
-    _logCount(0),
-    _maxLogCount(props->getPropertyAsIntWithDefault("Ice.Admin.Logger.KeepLogs", 100)),
-    _traceCount(0),
-    _maxTraceCount(props->getPropertyAsIntWithDefault("Ice.Admin.Logger.KeepTraces", 100)),
-    _traceLevel(props->getPropertyAsInt("Ice.Trace.Admin.Logger")),
-    _destroyed(false)
-{
-    _oldestLog = _queue.end();
-    _oldestTrace = _queue.end();
-}
-
-void
-#ifdef ICE_CPP11_MAPPING
-LoggerAdminI::attachRemoteLogger(shared_ptr<RemoteLoggerPrx> prx,
-                                 LogMessageTypeSeq messageTypes,
-                                 StringSeq categories,
-                                 Int messageMax,
-                                 const Current& current)
-#else
-LoggerAdminI::attachRemoteLogger(const RemoteLoggerPrx& prx,
-                                 const LogMessageTypeSeq& messageTypes,
-                                 const StringSeq& categories,
-                                 Int messageMax,
-                                 const Current& current)
-#endif
-{
-    if(!prx)
-    {
-        return; // can't send this null RemoteLogger anything!
+        return initialize(std::move(initData));
     }
 
     //
-    // In C++, LoggerAdminI does not keep a "logger" data member to avoid a hard-to-break circular
-    // reference, so we retrieve the logger from Current
+    // LoggerAdminI
     //
-    LoggerAdminLoggerIPtr logger = ICE_DYNAMIC_CAST(LoggerAdminLoggerI, current.adapter->getCommunicator()->getLogger());
-    assert(logger);
 
-    RemoteLoggerPrxPtr remoteLogger = prx->ice_twoway();
+    LoggerAdminI::LoggerAdminI(const PropertiesPtr& props)
+        : _maxLogCount(props->getIcePropertyAsInt("Ice.Admin.Logger.KeepLogs")),
+          _maxTraceCount(props->getIcePropertyAsInt("Ice.Admin.Logger.KeepTraces")),
+          _traceLevel(props->getIcePropertyAsInt("Ice.Trace.Admin.Logger"))
 
-    Filters filters(messageTypes, categories);
-    LogMessageSeq initLogMessages;
     {
-        IceUtil::Mutex::Lock lock(_mutex);
+        _oldestLog = _queue.end();
+        _oldestTrace = _queue.end();
+    }
 
-        if(!_sendLogCommunicator)
+    void LoggerAdminI::attachRemoteLogger(
+        optional<RemoteLoggerPrx> prx,
+        LogMessageTypeSeq messageTypes,
+        StringSeq categories,
+        int32_t messageMax,
+        const Current& current)
+    {
+        if (!prx)
         {
-            if(_destroyed)
-            {
-                throw Ice::ObjectNotExistException(__FILE__, __LINE__);
-            }
-
-            _sendLogCommunicator =
-                createSendLogCommunicator(current.adapter->getCommunicator(), logger->getLocalLogger());
+            return; // can't send this null RemoteLogger anything!
         }
 
-        if(!_remoteLoggerMap.insert(make_pair(changeCommunicator(remoteLogger, _sendLogCommunicator), filters)).second)
-        {
-            if(_traceLevel > 0)
-            {
-                Trace trace(logger, traceCategory);
-                trace << "rejecting `" << remoteLogger << "' with RemoteLoggerAlreadyAttachedException";
-            }
+        //
+        // In C++, LoggerAdminI does not keep a "logger" data member to avoid a hard-to-break circular
+        // reference, so we retrieve the logger from Current
+        //
+        LoggerAdminLoggerIPtr logger =
+            dynamic_pointer_cast<LoggerAdminLoggerI>(current.adapter->getCommunicator()->getLogger());
+        assert(logger);
 
-            throw RemoteLoggerAlreadyAttachedException();
-        }
+        RemoteLoggerPrx remoteLogger = prx->ice_twoway();
 
-        if(messageMax != 0)
+        Filters filters(messageTypes, categories);
+        LogMessageSeq initLogMessages;
         {
-            initLogMessages = _queue; // copy
-        }
-    }
+            lock_guard lock(_mutex);
 
-    if(_traceLevel > 0)
-    {
-        Trace trace(logger, traceCategory);
-        trace << "attached `" << remoteLogger << "'";
-    }
+            if (!_sendLogCommunicator)
+            {
+                if (_destroyed)
+                {
+                    throw Ice::ObjectNotExistException{__FILE__, __LINE__};
+                }
 
-    if(!initLogMessages.empty())
-    {
-        filterLogMessages(initLogMessages, filters.messageTypes, filters.traceCategories, messageMax);
-    }
+                _sendLogCommunicator =
+                    createSendLogCommunicator(current.adapter->getCommunicator(), logger->getLocalLogger());
+            }
 
-#ifdef ICE_CPP11_MAPPING
-    try
-    {
-        auto self = shared_from_this();
-        remoteLogger->initAsync(logger->getPrefix(), initLogMessages,
-            [self, logger, remoteLogger]()
+            if (!_remoteLoggerMap.insert(make_pair(changeCommunicator(remoteLogger, _sendLogCommunicator), filters))
+                     .second)
             {
-                if(self->_traceLevel > 1)
+                if (_traceLevel > 0)
                 {
                     Trace trace(logger, traceCategory);
-                    trace << "init on `" << remoteLogger << "' completed successfully";
+                    trace << "rejecting '" << remoteLogger << "' with RemoteLoggerAlreadyAttachedException";
                 }
-            },
-            [self, logger, remoteLogger](exception_ptr e)
+
+                throw RemoteLoggerAlreadyAttachedException();
+            }
+
+            if (messageMax != 0)
             {
-                try
-                {
-                    rethrow_exception(e);
-                }
-                catch(const Ice::LocalException& le)
-                {
-                    self->deadRemoteLogger(remoteLogger, logger, le, "init");
-                }
-            });
-    }
-    catch(const LocalException& ex)
-    {
-        deadRemoteLogger(remoteLogger, logger, ex, "init");
-        throw;
-    }
-#else
-    CallbackPtr initCompletedCb = newCallback(this, &LoggerAdminI::initCompleted);
-    try
-    {
-        remoteLogger->begin_init(logger->getPrefix(), initLogMessages, initCompletedCb, logger);
-    }
-    catch(const LocalException& ex)
-    {
-        deadRemoteLogger(remoteLogger, logger, ex, "init");
-        throw;
-    }
-#endif
-}
+                initLogMessages = _queue; // copy
+            }
+        }
 
-bool
-#ifdef ICE_CPP11_MAPPING
-LoggerAdminI::detachRemoteLogger(shared_ptr<RemoteLoggerPrx> remoteLogger, const Current& current)
-#else
-LoggerAdminI::detachRemoteLogger(const RemoteLoggerPrx& remoteLogger, const Current& current)
-#endif
-{
-    if(remoteLogger == 0)
-    {
-        return false;
-    }
+        if (_traceLevel > 0)
+        {
+            Trace trace(logger, traceCategory);
+            trace << "attached '" << remoteLogger << "'";
+        }
 
-    //
-    // No need to convert the proxy as we only use its identity
-    //
-    bool found = removeRemoteLogger(remoteLogger);
+        if (!initLogMessages.empty())
+        {
+            filterLogMessages(initLogMessages, filters.messageTypes, filters.traceCategories, messageMax);
+        }
 
-    if(_traceLevel > 0)
-    {
-        Trace trace(current.adapter->getCommunicator()->getLogger(), traceCategory);
-        if(found)
+        try
         {
-            trace << "detached `" << remoteLogger << "'";
+            auto self = shared_from_this();
+            remoteLogger->initAsync(
+                logger->getPrefix(),
+                initLogMessages,
+                [self, logger, remoteLogger]()
+                {
+                    if (self->_traceLevel > 1)
+                    {
+                        Trace trace(logger, traceCategory);
+                        trace << "init on '" << remoteLogger << "' completed successfully";
+                    }
+                },
+                [self, logger, remoteLogger](exception_ptr e)
+                { self->deadRemoteLogger(remoteLogger, logger, e, "init"); });
         }
-        else
+        catch (const LocalException&)
         {
-            trace << "cannot detach `" << remoteLogger << "': not found";
+            deadRemoteLogger(remoteLogger, logger, current_exception(), "init");
+            throw;
         }
     }
 
-    return found;
-}
-
-LogMessageSeq
-#ifdef ICE_CPP11_MAPPING
-LoggerAdminI::getLog(LogMessageTypeSeq messageTypes, StringSeq categories,
-                     Int messageMax, string& prefix, const Current& current)
-#else
-LoggerAdminI::getLog(const LogMessageTypeSeq& messageTypes, const StringSeq& categories,
-                     Int messageMax, string& prefix, const Current& current)
-#endif
-{
-    LogMessageSeq logMessages;
+    bool LoggerAdminI::detachRemoteLogger(std::optional<RemoteLoggerPrx> remoteLogger, const Current& current)
     {
-        IceUtil::Mutex::Lock lock(_mutex);
+        if (!remoteLogger)
+        {
+            return false;
+        }
 
-        if(messageMax != 0)
+        //
+        // No need to convert the proxy as we only use its identity
+        //
+        bool found = removeRemoteLogger(remoteLogger.value());
+
+        if (_traceLevel > 0)
         {
-            logMessages = _queue;
+            Trace trace(current.adapter->getCommunicator()->getLogger(), traceCategory);
+            if (found)
+            {
+                trace << "detached '" << remoteLogger.value() << "'";
+            }
+            else
+            {
+                trace << "cannot detach '" << remoteLogger.value() << "': not found";
+            }
         }
-    }
 
-    LoggerPtr logger = current.adapter->getCommunicator()->getLogger();
-    prefix = logger->getPrefix();
+        return found;
+    }
 
-    if(!logMessages.empty())
+    LogMessageSeq LoggerAdminI::getLog(
+        LogMessageTypeSeq messageTypes,
+        StringSeq categories,
+        int32_t messageMax,
+        string& prefix,
+        const Current& current)
     {
-        Filters filters(messageTypes, categories);
-        filterLogMessages(logMessages, filters.messageTypes, filters.traceCategories, messageMax);
-    }
+        LogMessageSeq logMessages;
+        {
+            lock_guard lock(_mutex);
 
-    return logMessages;
-}
+            if (messageMax != 0)
+            {
+                logMessages = _queue;
+            }
+        }
 
-void
-LoggerAdminI::destroy()
-{
-    CommunicatorPtr sendLogCommunicator;
-    {
-        IceUtil::Mutex::Lock lock(_mutex);
-        if(!_destroyed)
+        LoggerPtr logger = current.adapter->getCommunicator()->getLogger();
+        prefix = logger->getPrefix();
+
+        if (!logMessages.empty())
         {
-            _destroyed = true;
-            sendLogCommunicator = _sendLogCommunicator;
-            _sendLogCommunicator = 0;
+            Filters filters(messageTypes, categories);
+            filterLogMessages(logMessages, filters.messageTypes, filters.traceCategories, messageMax);
         }
-    }
 
-    //
-    // Destroy outside lock to avoid deadlock when there are outstanding two-way log calls sent to
-    // remote loggers
-    //
-    if(sendLogCommunicator)
-    {
-        sendLogCommunicator->destroy();
+        return logMessages;
     }
-}
 
-vector<RemoteLoggerPrxPtr>
-LoggerAdminI::log(const LogMessage& logMessage)
-{
-    vector<RemoteLoggerPrxPtr> remoteLoggers;
+    void LoggerAdminI::destroy()
+    {
+        CommunicatorPtr sendLogCommunicator;
+        {
+            lock_guard lock(_mutex);
+            if (!_destroyed)
+            {
+                _destroyed = true;
+                sendLogCommunicator = _sendLogCommunicator;
+                _sendLogCommunicator = nullptr;
+            }
+        }
 
-    IceUtil::Mutex::Lock lock(_mutex);
+        //
+        // Destroy outside lock to avoid deadlock when there are outstanding two-way log calls sent to
+        // remote loggers
+        //
+        if (sendLogCommunicator)
+        {
+            sendLogCommunicator->destroy();
+        }
+    }
 
-    //
-    // Put message in _queue
-    //
-    if((logMessage.type != ICE_ENUM(LogMessageType, TraceMessage) && _maxLogCount > 0) ||
-       (logMessage.type == ICE_ENUM(LogMessageType, TraceMessage) && _maxTraceCount > 0))
+    vector<RemoteLoggerPrx> LoggerAdminI::log(const LogMessage& logMessage)
     {
-        list<LogMessage>::iterator p = _queue.insert(_queue.end(), logMessage);
+        vector<RemoteLoggerPrx> remoteLoggers;
 
-        if(logMessage.type != ICE_ENUM(LogMessageType, TraceMessage))
+        lock_guard lock(_mutex);
+
+        //
+        // Put message in _queue
+        //
+        if ((logMessage.type != LogMessageType::TraceMessage && _maxLogCount > 0) ||
+            (logMessage.type == LogMessageType::TraceMessage && _maxTraceCount > 0))
         {
-            assert(_maxLogCount > 0);
-            if(_logCount == _maxLogCount)
+            auto p = _queue.insert(_queue.end(), logMessage);
+
+            if (logMessage.type != LogMessageType::TraceMessage)
             {
-                //
-                // Need to remove the oldest log from the queue
-                //
-                assert(_oldestLog != _queue.end());
-                _oldestLog = _queue.erase(_oldestLog);
-                while(_oldestLog != _queue.end() && _oldestLog->type == ICE_ENUM(LogMessageType, TraceMessage))
+                assert(_maxLogCount > 0);
+                if (_logCount == _maxLogCount)
+                {
+                    //
+                    // Need to remove the oldest log from the queue
+                    //
+                    assert(_oldestLog != _queue.end());
+                    _oldestLog = _queue.erase(_oldestLog);
+                    while (_oldestLog != _queue.end() && _oldestLog->type == LogMessageType::TraceMessage)
+                    {
+                        _oldestLog++;
+                    }
+                    assert(_oldestLog != _queue.end());
+                }
+                else
                 {
-                    _oldestLog++;
+                    assert(_logCount < _maxLogCount);
+                    _logCount++;
+                    if (_oldestLog == _queue.end())
+                    {
+                        _oldestLog = p;
+                    }
                 }
-                assert(_oldestLog != _queue.end());
             }
             else
             {
-                assert(_logCount < _maxLogCount);
-                _logCount++;
-                if(_oldestLog == _queue.end())
+                assert(_maxTraceCount > 0);
+                if (_traceCount == _maxTraceCount)
                 {
-                    _oldestLog = p;
+                    //
+                    // Need to remove the oldest trace from the queue
+                    //
+                    assert(_oldestTrace != _queue.end());
+                    _oldestTrace = _queue.erase(_oldestTrace);
+                    while (_oldestTrace != _queue.end() && _oldestTrace->type != LogMessageType::TraceMessage)
+                    {
+                        _oldestTrace++;
+                    }
+                    assert(_oldestTrace != _queue.end());
                 }
-            }
-        }
-        else
-        {
-            assert(_maxTraceCount > 0);
-            if(_traceCount == _maxTraceCount)
-            {
-                //
-                // Need to remove the oldest trace from the queue
-                //
-                assert(_oldestTrace != _queue.end());
-                _oldestTrace = _queue.erase(_oldestTrace);
-                while(_oldestTrace != _queue.end() && _oldestTrace->type != ICE_ENUM(LogMessageType, TraceMessage))
+                else
                 {
-                    _oldestTrace++;
+                    assert(_traceCount < _maxTraceCount);
+                    _traceCount++;
+                    if (_oldestTrace == _queue.end())
+                    {
+                        _oldestTrace = p;
+                    }
                 }
-                assert(_oldestTrace != _queue.end());
             }
-            else
+
+            //
+            // Queue updated, now find which remote loggers want this message
+            //
+            for (const auto& q : _remoteLoggerMap)
             {
-                assert(_traceCount < _maxTraceCount);
-                _traceCount++;
-                if(_oldestTrace == _queue.end())
+                const Filters& filters = q.second;
+
+                if (filters.messageTypes.empty() || filters.messageTypes.count(logMessage.type) != 0)
                 {
-                    _oldestTrace = p;
+                    if (logMessage.type != LogMessageType::TraceMessage || filters.traceCategories.empty() ||
+                        filters.traceCategories.count(logMessage.traceCategory) != 0)
+                    {
+                        remoteLoggers.push_back(q.first);
+                    }
                 }
             }
         }
+        return remoteLoggers;
+    }
 
+    void LoggerAdminI::deadRemoteLogger(
+        const RemoteLoggerPrx& remoteLogger,
+        const LoggerPtr& logger,
+        std::exception_ptr ex,
+        string_view operation)
+    {
         //
-        // Queue updated, now find which remote loggers want this message
+        // No need to convert remoteLogger as we only use its identity
         //
-        for(RemoteLoggerMap::const_iterator q = _remoteLoggerMap.begin(); q != _remoteLoggerMap.end(); ++q)
+        if (removeRemoteLogger(remoteLogger))
         {
-            const Filters& filters = q->second;
-
-            if(filters.messageTypes.empty() || filters.messageTypes.count(logMessage.type) != 0)
+            if (_traceLevel > 0)
             {
-                if(logMessage.type != ICE_ENUM(LogMessageType, TraceMessage) || filters.traceCategories.empty() ||
-                   filters.traceCategories.count(logMessage.traceCategory) != 0)
+                try
+                {
+                    rethrow_exception(ex);
+                }
+                catch (const std::exception& e)
                 {
-                    remoteLoggers.push_back(q->first);
+                    Trace trace(logger, traceCategory);
+                    trace << "detached '" << remoteLogger << "' because " << operation << " raised:\n" << e;
                 }
             }
         }
     }
-    return remoteLoggers;
-}
 
-void
-LoggerAdminI::deadRemoteLogger(const RemoteLoggerPrxPtr& remoteLogger,
-                               const LoggerPtr& logger,
-                               const LocalException& ex,
-                               const string& operation)
-{
-    //
-    // No need to convert remoteLogger as we only use its identity
-    //
-    if(removeRemoteLogger(remoteLogger))
+    bool LoggerAdminI::removeRemoteLogger(const RemoteLoggerPrx& remoteLogger)
     {
-        if(_traceLevel > 0)
-        {
-            Trace trace(logger, traceCategory);
-            trace << "detached `" << remoteLogger << "' because " << operation << " raised:\n" << ex;
-        }
+        lock_guard lock(_mutex);
+        return _remoteLoggerMap.erase(remoteLogger) > 0;
     }
-}
 
-bool
-LoggerAdminI::removeRemoteLogger(const RemoteLoggerPrxPtr& remoteLogger)
-{
-    IceUtil::Mutex::Lock lock(_mutex);
-    return _remoteLoggerMap.erase(remoteLogger) > 0;
-}
+    //
+    // LoggerAdminLoggerI
+    //
 
-#ifndef ICE_CPP11_MAPPING
-//
-// begin_init callback method for C++98 mapping
-//
-void
-LoggerAdminI::initCompleted(const AsyncResultPtr& r)
-{
-    RemoteLoggerPrxPtr remoteLogger = ICE_UNCHECKED_CAST(RemoteLoggerPrx, r->getProxy());
+    LoggerAdminLoggerI::LoggerAdminLoggerI(const PropertiesPtr& props, const LoggerPtr& localLogger)
+        : _localLogger(unwrapLocalLogger(localLogger)),
+          _loggerAdmin(new LoggerAdminI(props))
+    {
+    }
 
-    try
+    void LoggerAdminLoggerI::print(const string& message)
     {
-        remoteLogger->end_init(r);
+        _localLogger->print(message);
 
-        if(_traceLevel > 1)
+        if (!_detached.load())
         {
-            LoggerPtr logger = ICE_DYNAMIC_CAST(Logger, r->getCookie());
-            Trace trace(logger, traceCategory);
-            trace << r->getOperation() << " on `" << remoteLogger << "' completed successfully";
+            LogMessage logMessage = {
+                LogMessageType::PrintMessage,
+                chrono::duration_cast<chrono::microseconds>(chrono::system_clock::now().time_since_epoch()).count(),
+                "",
+                message};
+            log(logMessage);
         }
     }
-    catch(const LocalException& ex)
-    {
-        deadRemoteLogger(remoteLogger, ICE_DYNAMIC_CAST(Logger, r->getCookie()), ex, r->getOperation());
-    }
-}
-#endif
-
-//
-// LoggerAdminLoggerI
-//
 
-LoggerAdminLoggerI::LoggerAdminLoggerI(const PropertiesPtr& props,
-                                       const LoggerPtr& localLogger) :
-    _loggerAdmin(new LoggerAdminI(props)),
-    _destroyed(false)
-{
-    //
-    // There is currently no way to have a null local logger
-    //
-    assert(localLogger != 0);
-
-    LoggerAdminLoggerI* wrapper = dynamic_cast<LoggerAdminLoggerI*>(localLogger.get());
-    if(wrapper)
-    {
-        // use the underlying local logger
-       _localLogger = wrapper->getLocalLogger();
-    }
-    else
+    void LoggerAdminLoggerI::trace(const string& category, const string& message)
     {
-        _localLogger = localLogger;
-    }
-}
-
-void
-LoggerAdminLoggerI::print(const string& message)
-{
-   LogMessage logMessage = { ICE_ENUM(LogMessageType, PrintMessage), IceUtil::Time::now().toMicroSeconds(), "", message };
-
-    _localLogger->print(message);
-    log(logMessage);
-}
-
-void
-LoggerAdminLoggerI::trace(const string& category, const string& message)
-{
-    LogMessage logMessage = { ICE_ENUM(LogMessageType, TraceMessage), IceUtil::Time::now().toMicroSeconds(), category, message };
-
-    _localLogger->trace(category, message);
-    log(logMessage);
-}
-
-void
-LoggerAdminLoggerI::warning(const string& message)
-{
-    LogMessage logMessage = { ICE_ENUM(LogMessageType, WarningMessage), IceUtil::Time::now().toMicroSeconds(), "", message };
+        _localLogger->trace(category, message);
 
-    _localLogger->warning(message);
-    log(logMessage);
-}
-
-void
-LoggerAdminLoggerI::error(const string& message)
-{
-    LogMessage logMessage = { ICE_ENUM(LogMessageType, ErrorMessage), IceUtil::Time::now().toMicroSeconds(), "", message };
-
-    _localLogger->error(message);
-    log(logMessage);
-}
-
-string
-LoggerAdminLoggerI::getPrefix()
-{
-    return _localLogger->getPrefix();
-}
-
-LoggerPtr
-LoggerAdminLoggerI::cloneWithPrefix(const string& prefix)
-{
-    return _localLogger->cloneWithPrefix(prefix);
-}
-
-ObjectPtr
-LoggerAdminLoggerI::getFacet() const
-{
-    return _loggerAdmin;
-}
-
-void
-LoggerAdminLoggerI::log(const LogMessage& logMessage)
-{
-    const vector<RemoteLoggerPrxPtr> remoteLoggers = _loggerAdmin->log(logMessage);
+        if (!_detached.load())
+        {
+            LogMessage logMessage = {
+                LogMessageType::TraceMessage,
+                chrono::duration_cast<chrono::microseconds>(chrono::system_clock::now().time_since_epoch()).count(),
+                category,
+                message};
+            log(logMessage);
+        }
+    }
 
-    if(!remoteLoggers.empty())
+    void LoggerAdminLoggerI::warning(const string& message)
     {
-        IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+        _localLogger->warning(message);
 
-        if(!_sendLogThread)
+        if (!_detached.load())
         {
-            _sendLogThread = new SendLogThread(ICE_SHARED_FROM_THIS);
-            _sendLogThread->start();
+            LogMessage logMessage = {
+                LogMessageType::WarningMessage,
+                chrono::duration_cast<chrono::microseconds>(chrono::system_clock::now().time_since_epoch()).count(),
+                "",
+                message};
+            log(logMessage);
         }
-
-        _jobQueue.push_back(new Job(remoteLoggers, logMessage));
-        _monitor.notifyAll();
     }
-}
 
-void
-LoggerAdminLoggerI::destroy()
-{
-    IceUtil::ThreadControl sendLogThreadControl;
-    bool joinThread = false;
+    void LoggerAdminLoggerI::error(const string& message)
     {
-        IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+        _localLogger->error(message);
 
-        if(_sendLogThread)
+        if (!_detached.load())
         {
-            joinThread = true;
-            sendLogThreadControl = _sendLogThread->getThreadControl();
-            _sendLogThread = 0;
-            _destroyed = true;
-            _monitor.notifyAll();
+            LogMessage logMessage = {
+                LogMessageType::ErrorMessage,
+                chrono::duration_cast<chrono::microseconds>(chrono::system_clock::now().time_since_epoch()).count(),
+                "",
+                message};
+            log(logMessage);
         }
     }
 
-    if(joinThread)
+    string LoggerAdminLoggerI::getPrefix() { return _localLogger->getPrefix(); }
+
+    LoggerPtr LoggerAdminLoggerI::cloneWithPrefix(string prefix)
     {
-        sendLogThreadControl.join();
+        return _localLogger->cloneWithPrefix(std::move(prefix));
     }
 
-     // destroy sendLogCommunicator
-    _loggerAdmin->destroy();
-}
+    ObjectPtr LoggerAdminLoggerI::getFacet() const { return _loggerAdmin; }
 
-void
-LoggerAdminLoggerI::run()
-{
-    if(_loggerAdmin->getTraceLevel() > 1)
+    void LoggerAdminLoggerI::log(const LogMessage& logMessage)
     {
-        Trace trace(_localLogger, traceCategory);
-        trace << "send log thread started";
-    }
+        const vector<RemoteLoggerPrx> remoteLoggers = _loggerAdmin->log(logMessage);
+
+        if (!remoteLoggers.empty())
+        {
+            lock_guard lock(_mutex);
 
-#ifndef ICE_CPP11_MAPPING
-    CallbackPtr logCompletedCb = newCallback(this, &LoggerAdminLoggerI::logCompleted);
-#endif
+            if (!_sendLogThread.joinable())
+            {
+                _sendLogThread = std::thread(&LoggerAdminLoggerI::run, this);
+            }
+
+            _jobQueue.push_back(make_shared<Job>(remoteLoggers, logMessage));
+            _conditionVariable.notify_all();
+        }
+    }
 
-    for(;;)
+    void LoggerAdminLoggerI::detach()
     {
-        IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
-        while(!_destroyed && _jobQueue.empty())
+        std::thread sendLogThread;
         {
-            _monitor.wait();
+            lock_guard lock(_mutex);
+
+            if (_sendLogThread.joinable())
+            {
+                sendLogThread = std::move(_sendLogThread);
+                _detached.store(true);
+                _conditionVariable.notify_all();
+            }
         }
-        if(_destroyed)
+
+        if (sendLogThread.joinable())
         {
-            break; // for(;;)
+            sendLogThread.join();
         }
 
-        assert(!_jobQueue.empty());
-        JobPtr job = _jobQueue.front();
-        _jobQueue.pop_front();
-        lock.release();
+        // destroy sendLogCommunicator
+        _loggerAdmin->destroy();
+    }
+
+    void LoggerAdminLoggerI::run()
+    {
+        if (_loggerAdmin->getTraceLevel() > 1)
+        {
+            Trace trace(_localLogger, traceCategory);
+            trace << "send log thread started";
+        }
 
-        for(vector<RemoteLoggerPrxPtr>::const_iterator p = job->remoteLoggers.begin(); p != job->remoteLoggers.end(); ++p)
+        for (;;)
         {
-            if(_loggerAdmin->getTraceLevel() > 1)
+            unique_lock lock(_mutex);
+            _conditionVariable.wait(lock, [this] { return _detached.load() || !_jobQueue.empty(); });
+
+            if (_detached.load())
             {
-                Trace trace(_localLogger, traceCategory);
-                trace << "sending log message to `" << *p << "'";
+                break;
             }
 
-            try
+            assert(!_jobQueue.empty());
+            JobPtr job = _jobQueue.front();
+            _jobQueue.pop_front();
+            lock.unlock();
+
+            for (const auto& remoteLogger : job->remoteLoggers)
             {
-#ifdef ICE_CPP11_MAPPING
-                RemoteLoggerPrxPtr remoteLogger = *p;
-                auto self = shared_from_this();
-                remoteLogger->logAsync(job->logMessage,
-                    [self, remoteLogger]()
-                    {
-                        if(self->_loggerAdmin->getTraceLevel() > 1)
-                        {
-                            Trace trace(self->_localLogger, traceCategory);
-                            trace << "log on `" << remoteLogger << "' completed successfully";
-                        }
-                    },
-                    [self, remoteLogger](exception_ptr e)
-                    {
-                        try
-                        {
-                            rethrow_exception(e);
-                        }
-                        catch(const CommunicatorDestroyedException&)
+                if (_loggerAdmin->getTraceLevel() > 1)
+                {
+                    Trace trace(_localLogger, traceCategory);
+                    trace << "sending log message to '" << remoteLogger << "'";
+                }
+
+                try
+                {
+                    auto self = shared_from_this();
+                    remoteLogger->logAsync(
+                        job->logMessage,
+                        [self, proxy = remoteLogger]()
                         {
-                            // expected if there are outstanding calls during communicator destruction
-                        }
-                        catch(const LocalException& ex)
+                            if (self->_loggerAdmin->getTraceLevel() > 1)
+                            {
+                                Trace trace(self->_localLogger, traceCategory);
+                                trace << "log on '" << proxy << "' completed successfully";
+                            }
+                        },
+                        [self, proxy = remoteLogger](exception_ptr e)
                         {
-                            self->_loggerAdmin->deadRemoteLogger(remoteLogger, self->_localLogger, ex, "log");
-                        }
-                    });
-#else
-                //
-                // *p is a proxy associated with the _sendLogCommunicator
-                //
-                (*p)->begin_log(job->logMessage, logCompletedCb);
-#endif
-            }
-            catch(const LocalException& ex)
-            {
-                _loggerAdmin->deadRemoteLogger(*p, _localLogger, ex, "log");
+                            try
+                            {
+                                rethrow_exception(e);
+                            }
+                            catch (const CommunicatorDestroyedException&)
+                            {
+                                // expected if there are outstanding calls during communicator destruction
+                            }
+                            catch (const LocalException&)
+                            {
+                                self->_loggerAdmin->deadRemoteLogger(proxy, self->_localLogger, e, "log");
+                            }
+                        });
+                }
+                catch (const LocalException&)
+                {
+                    _loggerAdmin->deadRemoteLogger(remoteLogger, _localLogger, current_exception(), "log");
+                }
             }
         }
-    }
 
-    if(_loggerAdmin->getTraceLevel() > 1)
-    {
-        Trace trace(_localLogger, traceCategory);
-        trace << "send log thread completed";
-    }
-}
-
-#ifndef ICE_CPP11_MAPPING
-//
-// begin_log callback for C++98 mapping
-//
-void
-LoggerAdminLoggerI::logCompleted(const AsyncResultPtr& r)
-{
-    RemoteLoggerPrxPtr remoteLogger = ICE_UNCHECKED_CAST(RemoteLoggerPrx, r->getProxy());
-
-    try
-    {
-        remoteLogger->end_log(r);
-
-        if(_loggerAdmin->getTraceLevel() > 1)
+        if (_loggerAdmin->getTraceLevel() > 1)
         {
             Trace trace(_localLogger, traceCategory);
-            trace << r->getOperation() << " on `" << remoteLogger << "' completed successfully";
+            trace << "send log thread completed";
         }
     }
-    catch(const CommunicatorDestroyedException&)
-    {
-        // expected if there are outstanding calls during communicator destruction
-    }
-    catch(const LocalException& ex)
-    {
-        _loggerAdmin->deadRemoteLogger(remoteLogger, _localLogger, ex, r->getOperation());
-    }
-}
-#endif
-
-//
-// SendLogThread
-//
-
-SendLogThread::SendLogThread(const LoggerAdminLoggerIPtr& logger) :
-    IceUtil::Thread("Ice.SendLogThread"),
-    _logger(logger)
-{
 }
 
-void
-SendLogThread::run()
-{
-    _logger->run();
-}
-}
-
-//
-// createLoggerAdminLogger
-//
-
 namespace IceInternal
 {
+    LoggerAdminLogger::~LoggerAdminLogger() = default; // avoid weak vtable
 
-LoggerAdminLoggerPtr
-createLoggerAdminLogger(const PropertiesPtr& props,
-                        const LoggerPtr& localLogger)
-{
-    return ICE_MAKE_SHARED(LoggerAdminLoggerI, props, localLogger);
-}
-
+    LoggerAdminLoggerPtr createLoggerAdminLogger(const PropertiesPtr& props, const LoggerPtr& localLogger)
+    {
+        return make_shared<LoggerAdminLoggerI>(props, localLogger);
+    }
 }