[WIP] Modern lifecycle + Ownership

lib/api/LogManagerImpl.cpp

@@ -629,7 +629,7 @@ namespace MAT_NS_BEGIN
         return m_logConfiguration;
     }
 
-    ILogger* LogManagerImpl::GetLogger(const std::string& tenantToken, const std::string& source, const std::string& scope)
+    std::shared_ptr<ILogger> LogManagerImpl::GetLogger(const std::string& tenantToken, const std::string& source, const std::string& scope)
     {
         {
             LOCKGUARD(m_lock);
@@ -653,7 +653,7 @@ namespace MAT_NS_BEGIN
         auto it = m_loggers.find(hash);
         if (it == std::end(m_loggers))
         {
-            m_loggers[hash] = std::make_unique<Logger>(
+            m_loggers[hash] = std::make_shared<Logger>(
                 normalizedTenantToken, normalizedSource, scope,
                 *this, m_context, *m_config);
         }
@@ -662,7 +662,7 @@ namespace MAT_NS_BEGIN
         {
             m_loggers[hash]->SetLevel(level);
         }
-        return m_loggers[hash].get();
+        return std::static_pointer_cast<ILogger>(m_loggers[hash]);
     }
 
     /// <summary>

lib/api/LogManagerImpl.hpp

@@ -129,15 +129,15 @@ namespace MAT_NS_BEGIN
 
     class Logger;
 
-    using LoggerMap = std::map<std::string, std::unique_ptr<Logger>>;
+    using LoggerMap = std::map<std::string, std::shared_ptr<Logger>>;
 
     class DeadLoggers
     {
        public:
         void AddMap(LoggerMap&& source);
         size_t GetDeadLoggerCount() const noexcept;
 
-        std::vector<std::unique_ptr<Logger>> m_deadLoggers;
+        std::vector<std::shared_ptr<Logger>> m_deadLoggers;
         mutable std::mutex m_deadLoggersMutex;
     };
 
@@ -227,7 +227,7 @@ namespace MAT_NS_BEGIN
 
         virtual ILogConfiguration& GetLogConfiguration() override;
 
-        virtual ILogger* GetLogger(std::string const& tenantToken, std::string const& source = std::string(), std::string const& scopeId = std::string()) override;
+        virtual std::shared_ptr<ILogger> GetLogger(std::string const& tenantToken, std::string const& source = std::string(), std::string const& scopeId = std::string()) override;
 
         LogSessionData* GetLogSessionData() override;
         void ResetLogSessionData() override;

lib/api/LogManagerProvider.cpp

@@ -8,21 +8,21 @@
 
 namespace MAT_NS_BEGIN {
 
-    ILogManager * LogManagerProvider::Get(
+    std::unique_ptr<ILogManager> LogManagerProvider::Get(
         ILogConfiguration & config,
-        status_t &status
+        status_t &/*status*/
     )
     {
-        return LogManagerFactory::Get(config, status);
+        return std::unique_ptr<ILogManager>(LogManagerFactory::Create(config));
     }
 
     // TODO: consider utilizing a default reference
-    ILogManager* LogManagerProvider::Get(
+    std::unique_ptr<ILogManager> LogManagerProvider::Get(
         const char * moduleName,
         status_t& status
     )
     {
-        return LogManagerFactory::Get(moduleName, status);
+        return std::unique_ptr<ILogManager>(LogManagerFactory::Get(moduleName, status));
     }
 
     /// <summary>

lib/api/capi.cpp

@@ -8,6 +8,7 @@
 #if !defined (ANDROID) || defined(ENABLE_CAPI_HTTP_CLIENT)
 #include "http/HttpClient_CAPI.hpp"
 #endif
+#include "LogManagerFactory.hpp"
 #include "LogManagerProvider.hpp"
 #include "mat.h"
 #include "pal/TaskDispatcher_CAPI.hpp"
@@ -163,7 +164,7 @@ evt_status_t mat_open_core(
     }
 
     status_t status = static_cast<status_t>(EFAULT);
-    clients[code].logmanager = LogManagerProvider::CreateLogManager(clients[code].config, status);
+    clients[code].logmanager = LogManagerFactory::Get(clients[code].config, status);
 
     // Verify that the instance pointer is valid
     if (clients[code].logmanager == nullptr)
@@ -271,7 +272,7 @@ evt_status_t mat_log(evt_context_t *ctx)
     const auto & it = m.find(COMMONFIELDS_EVENT_SOURCE);
     std::string source = ((it != m.cend()) && (it->second.type == EventProperty::TYPE_STRING)) ? it->second.as_string : "";
 
-    ILogger *logger = client->logmanager->GetLogger(token, source, scope);
+    auto logger = client->logmanager->GetLogger(token, source, scope);
     if (logger == nullptr)
     {
         ctx->result = EFAULT; /* invalid address */

lib/include/public/ILogManager.hpp

@@ -285,7 +285,7 @@ namespace MAT_NS_BEGIN
         /// <param name="scope">A string that contains the logger scope/project set (reserved for future use).</param>
         ///
         /// <returns>A pointer to the ILogger instance.</returns>
-        virtual ILogger* GetLogger(std::string const& tenantToken, std::string const& source = std::string(), std::string const& scope = std::string()) = 0;
+        virtual std::shared_ptr<ILogger> GetLogger(std::string const& tenantToken, std::string const& source = std::string(), std::string const& scope = std::string()) = 0;
 
         /// <summary>Retrieves the current LogManager instance configuration</summary>
         virtual ILogConfiguration& GetLogConfiguration() = 0;

lib/include/public/LogManager.hpp

@@ -12,7 +12,4 @@ namespace MAT_NS_BEGIN {
     class LogManager : public LogManagerBase<ModuleLogConfiguration> {};
 } MAT_NS_END
 
-#define LOGMANAGER_INSTANCE namespace MAT_NS_BEGIN { DEFINE_LOGMANAGER(LogManager, ModuleLogConfiguration); } MAT_NS_END
-
 #endif
-

lib/include/public/LogManagerBase.hpp

@@ -170,7 +170,7 @@ namespace MAT_NS_BEGIN
         /// <summary>
         /// Concrete instance for servicing all singleton calls
         /// </summary>
-        static ILogManager* instance;
+        static std::unique_ptr<ILogManager> instance;
 
         /// <summary>
         /// Debug event source associated with this singleton
@@ -201,7 +201,7 @@ namespace MAT_NS_BEGIN
         /// Initializes the telemetry logging system with default configuration and HTTPClient.
         /// </summary>
         /// <returns>A logger instance instantiated with the default tenantToken.</returns>
-        static ILogger* Initialize()
+        static std::shared_ptr<ILogger> Initialize()
         {
             return Initialize(std::string{});
         }
@@ -211,7 +211,7 @@ namespace MAT_NS_BEGIN
         /// </summary>
         /// <param name="tenantToken">Token of the tenant with which the application is associated for collecting telemetry</param>
         /// <returns>A logger instance instantiated with the tenantToken.</returns>
-        inline static ILogger* Initialize(const std::string& tenantToken)
+        inline static std::shared_ptr<ILogger> Initialize(const std::string& tenantToken)
         {
             return Initialize(tenantToken, GetLogConfiguration());
         }
@@ -222,7 +222,7 @@ namespace MAT_NS_BEGIN
         /// <param name="tenantToken">Token of the tenant with which the application is associated for collecting telemetry</param>
         /// <param name="configuration">ILogConfiguration to be used.</param>
         /// <returns>A logger instance instantiated with the tenantToken.</returns>
-        static ILogger* Initialize(
+        static std::shared_ptr<ILogger> Initialize(
             const std::string& tenantToken,
             ILogConfiguration& configuration)
         {
@@ -559,15 +559,15 @@ namespace MAT_NS_BEGIN
         /// Retrieves the ILogger interface of a Logger instance through which to log telemetry event.
         /// </summary>
         /// <returns>Pointer to the Ilogger interface of an logger instance</returns>
-        static ILogger* GetLogger()
+        static std::shared_ptr<ILogger> GetLogger()
             LM_SAFE_CALL_PTR(GetLogger, GetPrimaryToken());
 
         /// <summary>
         /// Retrieves the ILogger interface of a Logger instance through which to log telemetry event.
         /// </summary>
         /// <param name="source">Source name of events sent by this logger instance</param>
         /// <returns>Pointer to the Ilogger interface of the logger instance</returns>
-        static ILogger* GetLogger(const std::string& source)
+        static std::shared_ptr<ILogger> GetLogger(const std::string& source)
             LM_SAFE_CALL_PTR(GetLogger, GetPrimaryToken(), source);
 
         /// <summary>
@@ -576,7 +576,7 @@ namespace MAT_NS_BEGIN
         /// <param name="tenantToken">Token of the tenant with which the application is associated for collecting telemetry</param>
         /// <param name="source">Source name of events sent by this logger instance</param>
         /// <returns>Pointer to the Ilogger interface of the logger instance</returns>
-        static ILogger* GetLogger(const std::string& tenantToken, const std::string& source)
+        static std::shared_ptr<ILogger> GetLogger(const std::string& tenantToken, const std::string& source)
             LM_SAFE_CALL_PTR(GetLogger, tenantToken, source);
 
         /// <summary>
@@ -731,7 +731,7 @@ namespace MAT_NS_BEGIN
         static ILogManager* GetInstance() noexcept
         {
             LM_LOCKGUARD(stateLock());
-            return instance;
+            return instance.get();
         }
     };
 
@@ -743,7 +743,7 @@ namespace MAT_NS_BEGIN
 // https://developercommunity.visualstudio.com/content/problem/134886/initialization-of-template-static-variable-wrong.html
 //
 #define DEFINE_LOGMANAGER(LogManagerClass, LogConfigurationClass) \
-    ILogManager* LogManagerClass::instance = nullptr;
+    std::unique_ptr<ILogManager> LogManagerClass::instance = nullptr;
 #elif defined(__APPLE__) && defined(MAT_USE_WEAK_LOGMANAGER)
 #define DEFINE_LOGMANAGER(LogManagerClass, LogConfigurationClass) \
     template <>                                                   \

lib/include/public/LogManagerProvider.hpp

@@ -39,7 +39,7 @@ namespace MAT_NS_BEGIN
         /// <param name="status">Status.</param>
         /// <param name="wantController">WantController.</param>
         /// </summary>
-        static ILogManager* MATSDK_SPEC CreateLogManager(
+        static std::unique_ptr<ILogManager> MATSDK_SPEC CreateLogManager(
             char const* id,
             bool wantController,
             ILogConfiguration& cfg,
@@ -93,7 +93,7 @@ namespace MAT_NS_BEGIN
         /// <param name="id">Instance Id.</param>
         /// <param name="status">Status.</param>
         /// </summary>
-        static ILogManager* MATSDK_SPEC CreateLogManager(char const* id,
+        static std::unique_ptr<ILogManager> MATSDK_SPEC CreateLogManager(char const* id,
             status_t& status,
             uint64_t targetVersion = MAT::Version)
         {
@@ -105,13 +105,19 @@ namespace MAT_NS_BEGIN
             );
         }
 
-        static ILogManager* MATSDK_SPEC CreateLogManager(
+        static std::unique_ptr<ILogManager> MATSDK_SPEC CreateLogManager(
             ILogConfiguration& cfg,
             status_t& status)
         {
             return Get(cfg, status);
         }
 
+        static std::unique_ptr<ILogManager> MATSDK_SPEC CreateLogManager(ILogConfiguration& cfg)
+        {
+            status_t status;
+            return Get(cfg, status);
+        }
+
         /// <summary>
         /// Releases a guest or host LogManager by its instance id.
         /// <param name="id">Instance Id.</param>
@@ -139,12 +145,12 @@ namespace MAT_NS_BEGIN
         // methods deprecated.
         //
 
-        static ILogManager * MATSDK_SPEC Get(
+        static std::unique_ptr<ILogManager> MATSDK_SPEC Get(
             ILogConfiguration & cfg,
             status_t &status
         );
 
-        static ILogManager* MATSDK_SPEC Get(
+        static std::unique_ptr<ILogManager> MATSDK_SPEC Get(
             const char * id,
             status_t& status
         );

lib/include/public/NullObjects.hpp

@@ -305,10 +305,10 @@ namespace MAT_NS_BEGIN
             return STATUS_ENOSYS;
         }
 
-        virtual ILogger * GetLogger(std::string const & /*tenantToken*/, std::string const & /*source*/ = std::string(), std::string const & /*experimentationProject*/ = std::string()) override
+        virtual std::shared_ptr<ILogger> GetLogger(std::string const & /*tenantToken*/, std::string const & /*source*/ = std::string(), std::string const & /*experimentationProject*/ = std::string()) override
         {
-            static NullLogger nullLogger;
-            return &nullLogger;
+            static std::shared_ptr<ILogger> nullLogger(new NullLogger);
+            return nullLogger;
         }
 
         virtual void AddEventListener(DebugEventType /*type*/, DebugEventListener & /*listener*/) override {};

tests/functests/AISendTests.cpp

@@ -97,6 +97,8 @@ class AISendTests : public ::testing::Test,
     std::string serverAddress;
     HttpServer server;
 
+    ILogConfiguration configuration;
+    std::unique_ptr<ILogManager> logManager;
     ILogger* logger;
 
     std::atomic<bool> isSetup;
@@ -147,7 +149,8 @@ class AISendTests : public ::testing::Test,
     virtual void Initialize(DebugEventListener& debugListener, std::string const& path, bool compression)
     {
         receivedRequests.clear();
-        auto configuration = LogManager::GetLogConfiguration();
+        configuration = ILogConfiguration{};
+        configuration[CFG_STR_PRIMARY_TOKEN] = std::string{TEST_TOKEN};
         configuration[CFG_INT_SDK_MODE] = SdkModeTypes_AI;
         configuration[CFG_STR_COLLECTOR_URL] = (serverAddress + path).c_str();
         configuration[CFG_MAP_HTTP][CFG_BOOL_HTTP_COMPRESSION] = compression;
@@ -167,32 +170,31 @@ class AISendTests : public ::testing::Test,
         configuration["version"] = "1.0.0";
         configuration["config"] = {{"host", __FILE__}};  // Host instance
 
-        LogManager::Initialize(TEST_TOKEN, configuration);
-        LogManager::SetLevelFilter(DIAG_LEVEL_DEFAULT, {DIAG_LEVEL_DEFAULT_MIN, DIAG_LEVEL_DEFAULT_MAX});
-        LogManager::ResumeTransmission();
+        logManager = LogManagerProvider::CreateLogManager(configuration);
+        logManager->SetLevelFilter(DIAG_LEVEL_DEFAULT, {DIAG_LEVEL_DEFAULT_MIN, DIAG_LEVEL_DEFAULT_MAX});
+        logManager->ResumeTransmission();
 
-        LogManager::AddEventListener(DebugEventType::EVT_HTTP_OK, debugListener);
-        LogManager::AddEventListener(DebugEventType::EVT_HTTP_ERROR, debugListener);
-        LogManager::AddEventListener(DebugEventType::EVT_HTTP_FAILURE, debugListener);
-        LogManager::AddEventListener(DebugEventType::EVT_HTTP_STATE, debugListener);
-        LogManager::AddEventListener(DebugEventType::EVT_ADDED, debugListener);
+        logManager->AddEventListener(DebugEventType::EVT_HTTP_OK, debugListener);
+        logManager->AddEventListener(DebugEventType::EVT_HTTP_ERROR, debugListener);
+        logManager->AddEventListener(DebugEventType::EVT_HTTP_FAILURE, debugListener);
+        logManager->AddEventListener(DebugEventType::EVT_HTTP_STATE, debugListener);
+        logManager->AddEventListener(DebugEventType::EVT_ADDED, debugListener);
 
-        logger = LogManager::GetLogger(TEST_TOKEN);
+        logger = logManager->GetLogger(TEST_TOKEN);
     }
 
     virtual void FlushAndTeardown(DebugEventListener& debugListener)
     {
-        LogManager::Flush();
+        logManager->Flush();
 
-        LogManager::RemoveEventListener(DebugEventType::EVT_HTTP_OK, debugListener);
-        LogManager::RemoveEventListener(DebugEventType::EVT_HTTP_ERROR, debugListener);
-        LogManager::RemoveEventListener(DebugEventType::EVT_HTTP_FAILURE, debugListener);
-        LogManager::RemoveEventListener(DebugEventType::EVT_HTTP_STATE, debugListener);
-        LogManager::RemoveEventListener(DebugEventType::EVT_ADDED, debugListener);
+        logManager->RemoveEventListener(DebugEventType::EVT_HTTP_OK, debugListener);
+        logManager->RemoveEventListener(DebugEventType::EVT_HTTP_ERROR, debugListener);
+        logManager->RemoveEventListener(DebugEventType::EVT_HTTP_FAILURE, debugListener);
+        logManager->RemoveEventListener(DebugEventType::EVT_HTTP_STATE, debugListener);
+        logManager->RemoveEventListener(DebugEventType::EVT_ADDED, debugListener);
 
-        LogManager::FlushAndTeardown();
+        logManager->FlushAndTeardown();
 
-        auto &configuration = LogManager::GetLogConfiguration();
         configuration[CFG_INT_SDK_MODE] = SdkModeTypes_CS;
     }