Fix runtime data races, memory leak, and shutdown safety

lib/api/Logger.cpp

@@ -127,7 +127,8 @@ namespace MAT_NS_BEGIN
 
     Logger::~Logger() noexcept
     {
-        LOG_TRACE("%p: Destroyed", this);
+        // Intentionally empty — logging here triggers a static-destruction-order
+        // crash on iOS simulator (recursive_mutex used after teardown).
     }
 
     ISemanticContext* Logger::GetSemanticContext() const

lib/http/HttpResponseDecoder.cpp

@@ -67,13 +67,11 @@ namespace MAT_NS_BEGIN {
             break;
 
         case HttpResult_Aborted:
-            ctx->httpResponse = nullptr;
             outcome = Abort;
             break;
 
         case HttpResult_LocalFailure:
         case HttpResult_NetworkFailure:
-            ctx->httpResponse = nullptr;
             outcome = RetryNetwork;
             break;
         }
@@ -129,7 +127,6 @@ namespace MAT_NS_BEGIN {
                 evt.param1 = 0; // response.GetStatusCode();
                 DispatchEvent(evt);
             }
-            ctx->httpResponse = nullptr;
             // eventsRejected(ctx); // FIXME: [MG] - investigate why ctx gets corrupt after eventsRejected
             requestAborted(ctx);
             break;
@@ -253,4 +250,3 @@ namespace MAT_NS_BEGIN {
     }
 
 } MAT_NS_END
-

lib/include/public/ITaskDispatcher.hpp

@@ -114,6 +114,23 @@ namespace MAT_NS_BEGIN
         /// <param name="task">Task to be executed on a worker thread</param>
         virtual void Queue(Task* task) = 0;
 
+        /// <summary>
+        /// Queue an asynchronous task and report whether the dispatcher accepted
+        /// it. Returns false if the task could not be queued (for example because
+        /// the dispatcher is shutting down) and was therefore destroyed by the
+        /// dispatcher; true otherwise. Callers that retain the task pointer for
+        /// later cancellation should treat a false result as "not scheduled" and
+        /// drop the pointer. The default delegates to Queue() and assumes success,
+        /// so existing dispatcher implementations keep their current behavior.
+        /// </summary>
+        /// <param name="task">Task to be executed on a worker thread</param>
+        /// <returns>True if the task was queued, false if it was dropped</returns>
+        virtual bool QueueWithResult(Task* task)
+        {
+            Queue(task);
+            return true;
+        }
+
         /// <summary>
         /// Cancel a previously queued tasks
         /// </summary>

lib/pal/TaskDispatcher.hpp

@@ -122,7 +122,14 @@ namespace PAL_NS_BEGIN {
     {
         auto bound = std::bind(std::mem_fn(func), obj, std::forward<TPassedArgs>(args)...);
         auto task = new detail::TaskCall<decltype(bound)>(bound, getMonotonicTimeMs() + (int64_t)delayMs);
-        taskDispatcher->Queue(task);
+        if (!taskDispatcher->QueueWithResult(task))
+        {
+            // The dispatcher could not queue the task (for example during
+            // shutdown) and has already destroyed it. Return a no-op handle so the
+            // caller never holds a pointer to a freed task and Cancel() is a safe
+            // no-op.
+            return DeferredCallbackHandle();
+        }
         return DeferredCallbackHandle(task, taskDispatcher);
     }
 

lib/pal/WorkerThread.cpp

@@ -6,6 +6,8 @@
 #include "pal/WorkerThread.hpp"
 #include "pal/PAL.hpp"
 
+#include <system_error>
+
 #if defined(MATSDK_PAL_CPP11) || defined(MATSDK_PAL_WIN32)
 
 /* Maximum scheduler interval for SDK is 1 hour required for clamping in case of monotonic clock drift */
@@ -35,7 +37,7 @@ namespace PAL_NS_BEGIN {
         std::list<MAT::Task*> m_timerQueue;
         Event                 m_event;
         MAT::Task*            m_itemInProgress;
-        int count = 0;
+        bool                  m_shuttingDown = false;
 
     public:
 
@@ -53,32 +55,70 @@ namespace PAL_NS_BEGIN {
 
         void Join() final
         {
-            auto item = new WorkerThreadShutdownItem();
-            Queue(item);
             std::thread::id this_id = std::this_thread::get_id();
+            bool joined = false;
+            {
+                LOCKGUARD(m_lock);
+                if (!m_shuttingDown) {
+                    m_shuttingDown = true;
+                    m_queue.push_back(new WorkerThreadShutdownItem());
+                    m_event.post();
+                }
+            }
             try {
-                if (m_hThread.joinable() && (m_hThread.get_id() != this_id))
+                if (!m_hThread.joinable()) {
+                    return;
+                }
+                if (m_hThread.get_id() != this_id) {
                     m_hThread.join();
-                else
+                    joined = true;
+                } else {
                     m_hThread.detach();
+                }
+            }
+            catch (const std::system_error& e) {
+                LOG_ERROR("Thread join/detach failed: [%d] %s", e.code().value(), e.what());
+            }
+            catch (const std::exception& e) {
+                LOG_ERROR("Thread join/detach failed: %s", e.what());
             }
-            catch (...) {};
 
-            // TODO: [MG] - investigate if we ever drop work items on shutdown.
-            if (!m_queue.empty())
-            {
-                LOG_WARN("m_queue is not empty!");
+            // Log pending work in both paths so operators can see if
+            // shutdown is dropping tasks.
+            LOCKGUARD(m_lock);
+            if (!m_queue.empty()) {
+                LOG_WARN("Shutdown with %zu queued task(s) pending", m_queue.size());
             }
-            if (!m_timerQueue.empty())
-            {
-                LOG_WARN("m_timerQueue is not empty!");
+            if (!m_timerQueue.empty()) {
+                LOG_WARN("Shutdown with %zu timer(s) pending", m_timerQueue.size());
+            }
+
+            // Clean up any tasks remaining in the queues after shutdown.
+            // Only safe after join() — the thread has fully exited.
+            // After detach(), the thread still needs the shutdown item
+            // and may still be accessing the queues.
+            if (joined) {
+                for (auto task : m_queue) { delete task; }
+                m_queue.clear();
+                for (auto task : m_timerQueue) { delete task; }
+                m_timerQueue.clear();
             }
         }
 
         void Queue(MAT::Task* item) final
         {
-            LOG_INFO("queue item=%p", &item);
+            QueueWithResult(item);
+        }
+
+        bool QueueWithResult(MAT::Task* item) override
+        {
+            LOG_INFO("queue item=%p", static_cast<void*>(item));
             LOCKGUARD(m_lock);
+            if (m_shuttingDown) {
+                LOG_WARN("Dropping queued task %p during shutdown", static_cast<void*>(item));
+                delete item;
+                return false;
+            }
             if (item->Type == MAT::Task::TimedCall) {
                 auto it = m_timerQueue.begin();
                 while (it != m_timerQueue.end() && (*it)->TargetTime < item->TargetTime) {
@@ -89,8 +129,8 @@ namespace PAL_NS_BEGIN {
             else {
                 m_queue.push_back(item);
             }
-            count++;
             m_event.post();
+            return true;
         }
 
         // Cancel a task or wait for task completion for up to waitTime ms:
@@ -261,4 +301,3 @@ namespace PAL_NS_BEGIN {
 } PAL_NS_END
 
 #endif
-