From 87e52c1998cb51df4fc98dc30c32f79b467de00c Mon Sep 17 00:00:00 2001
From: Marco Bubke <marco.bubke@qt.io>
Date: Sun, 1 Jun 2025 21:45:01 +0200
Subject: [PATCH] Nanotracer: Simplify templates

Change-Id: Iec6e80ec7622b9fc9162c6852d3736e505c8feff
Reviewed-by: Thomas Hartmann <thomas.hartmann@qt.io>
---
 src/libs/nanotrace/nanotracehr.cpp            |    6 -
 src/libs/nanotrace/nanotracehr.h              | 1229 +++++++++--------
 src/libs/sqlite/sqlitebasestatement.h         |    8 +-
 .../libs/designercore/imagecache/taskqueue.h  |    4 +-
 .../include/imagecacheauxiliarydata.h         |   12 +-
 .../libs/designercore/model/internalnode_p.h  |    2 +-
 .../projectstorage/projectstorageupdater.cpp  |    2 +-
 .../projectstorage/projectstorageupdater.h    |    2 +-
 .../projectstorage/qmldocumentparser.cpp      |    2 +-
 .../projectstorage/qmltypesparser.cpp         |    2 +-
 .../tracing/qmldesignertracing.cpp            |   20 +-
 .../designercore/tracing/qmldesignertracing.h |    6 +-
 .../unittests/imagecache/taskqueue-test.cpp   |    4 +-
 13 files changed, 663 insertions(+), 636 deletions(-)

diff --git a/src/libs/nanotrace/nanotracehr.cpp b/src/libs/nanotrace/nanotracehr.cpp
index f50f5ef44f5..64682a2ef8c 100644
--- a/src/libs/nanotrace/nanotracehr.cpp
+++ b/src/libs/nanotrace/nanotracehr.cpp
@@ -50,12 +50,6 @@ constexpr bool isArgumentValid(const ArgumentsString &string)
     return string.isValid() && string.size();
 }
 
-template<typename String>
-constexpr bool isArgumentValid(const String &string)
-{
-    return string.size();
-}
-
 template<typename TraceEvent>
 void printEvent(std::ostream &out, const TraceEvent &event, qint64 processId, std::thread::id threadId)
 {
diff --git a/src/libs/nanotrace/nanotracehr.h b/src/libs/nanotrace/nanotracehr.h
index 49ed2563577..56861542605 100644
--- a/src/libs/nanotrace/nanotracehr.h
+++ b/src/libs/nanotrace/nanotracehr.h
@@ -346,8 +346,8 @@ void setArguments(String &eventArguments, TracerLiteral arguments)
     eventArguments = arguments;
 }
 
-template<typename String, typename... Arguments>
-[[maybe_unused]] void setArguments(String &eventArguments, Arguments &&...arguments)
+template<typename String>
+[[maybe_unused]] void setArguments(String &eventArguments, KeyValue auto &&...arguments)
 {
     static_assert(
         !std::is_same_v<String, std::string_view>,
@@ -357,7 +357,7 @@ template<typename String, typename... Arguments>
         eventArguments = {};
     else
         eventArguments.clear();
-    Internal::toArguments(eventArguments, std::forward<Arguments>(arguments)...);
+    Internal::toArguments(eventArguments, std::forward<decltype(arguments)>(arguments)...);
 }
 
 } // namespace Internal
@@ -616,7 +616,7 @@ class BasicDisabledToken
 public:
     using IsActive = std::false_type;
 
-    BasicDisabledToken() {}
+    BasicDisabledToken() = default;
 
     BasicDisabledToken(const BasicDisabledToken &) = default;
     BasicDisabledToken &operator=(const BasicDisabledToken &) = default;
@@ -635,30 +635,357 @@ class BasicEnabledToken
 public:
     using IsActive = std::true_type;
 
-    BasicEnabledToken() {}
+    BasicEnabledToken() = default;
 
     BasicEnabledToken(const BasicEnabledToken &) = default;
     BasicEnabledToken &operator=(const BasicEnabledToken &) = default;
     BasicEnabledToken(BasicEnabledToken &&other) noexcept = default;
     BasicEnabledToken &operator=(BasicEnabledToken &&other) noexcept = default;
 
-    ~BasicEnabledToken() {}
+    ~BasicEnabledToken() = default;
 
     constexpr explicit operator bool() const { return false; }
 
     static constexpr bool isActive() { return false; }
 };
 
-template<typename Category, typename IsActive>
+template<typename Category>
+class AsynchronousToken;
+
+template<typename Category>
+class FlowToken;
+
+template<typename Category>
+class Tracer;
+
+template<typename Category>
+class Token;
+
+class DisabledCategory;
+class EnabledCategory;
+
+using EnabledTracer = Tracer<EnabledCategory>;
+using DisabledTracer = Tracer<DisabledCategory>;
+
+using EnabledToken = Token<EnabledCategory>;
+using DisabledToken = Token<DisabledCategory>;
+
+using EnabledAsynchronousToken = AsynchronousToken<EnabledCategory>;
+using DisabledAsynchronousToken = AsynchronousToken<DisabledCategory>;
+
+using EnabledFlowToken = FlowToken<EnabledCategory>;
+using DisabledFlowToken = FlowToken<DisabledCategory>;
+
+class DisabledCategory
+{
+public:
+    class SourceLocation
+    {
+    public:
+        template<typename String>
+        friend void convertToString(String &, SourceLocation)
+        {}
+    };
+
+    using CategoryFunctionPointer = DisabledCategory &(*) ();
+
+    DisabledCategory() = default;
+
+    DisabledCategory(TracerLiteral,
+                     EventQueueWithArguments<Tracing::IsDisabled> &,
+                     EventQueueWithoutArguments<Tracing::IsDisabled> &,
+                     CategoryFunctionPointer)
+    {}
+
+    DisabledCategory(TracerLiteral,
+                     EventQueueWithArguments<Tracing::IsEnabled> &,
+                     EventQueueWithoutArguments<Tracing::IsEnabled> &,
+                     CategoryFunctionPointer)
+    {}
+
+    [[nodiscard]] DisabledAsynchronousToken beginAsynchronous(TracerLiteral, KeyValue auto &&...);
+
+    [[nodiscard]] std::pair<DisabledAsynchronousToken, DisabledFlowToken> beginAsynchronousWithFlow(
+        TracerLiteral, KeyValue auto &&...);
+
+    [[nodiscard]] DisabledTracer beginDuration(TracerLiteral, KeyValue auto &&...);
+
+    [[nodiscard]] std::pair<DisabledTracer, DisabledFlowToken> beginDurationWithFlow(
+        TracerLiteral, KeyValue auto &&...);
+
+    void threadEvent(TracerLiteral, KeyValue auto &&...) {}
+
+    static constexpr bool isActive() { return false; }
+};
+
+class EnabledCategory
+{
+    class PrivateTag
+    {};
+
+public:
+    class SourceLocation : public Sqlite::source_location
+    {
+    public:
+        consteval SourceLocation(const char *fileName = __builtin_FILE(),
+                                 const char *functionName = __builtin_FUNCTION(),
+                                 const uint_least32_t line = __builtin_LINE())
+            : Sqlite::source_location(Sqlite::source_location::current(fileName, functionName, line))
+        {}
+
+        template<typename String>
+        friend void convertToString(String &string, SourceLocation sourceLocation)
+        {
+            using NanotraceHR::dictonary;
+            using NanotraceHR::keyValue;
+            auto dict = dictonary(keyValue("file", sourceLocation.file_name()),
+                                  keyValue("function", sourceLocation.function_name()),
+                                  keyValue("line", sourceLocation.line()));
+            convertToString(string, dict);
+
+            string.append(',');
+            convertToString(string, "id");
+            string.append(':');
+            string.append('\"');
+            string.append(sourceLocation.file_name());
+            string.append(':');
+            string.append(sourceLocation.line());
+            string.append('\"');
+        }
+    };
+
+    using CategoryFunctionPointer = EnabledCategory &(*) ();
+
+    friend EnabledAsynchronousToken;
+    friend EnabledToken;
+    friend EnabledFlowToken;
+    friend EnabledTracer;
+
+    template<typename EventQueue>
+    EnabledCategory(TracerLiteral name,
+                    EventQueue &queue,
+                    EnabledEventQueueWithoutArguments &eventQueueWithoutArguments,
+                    CategoryFunctionPointer self)
+        : m_name{std::move(name)}
+        , m_eventQueue{queue}
+        , m_eventQueueWithoutArguments{eventQueueWithoutArguments}
+        , m_self{self}
+    {
+        static_assert(std::is_same_v<typename EventQueue::IsActive, std::true_type>,
+                      "A active category is not possible with an inactive event queue!");
+        m_idCounter = m_globalIdCounter += 1ULL << 32;
+        m_bindIdCounter = m_globalBindIdCounter += 1ULL << 32;
+    }
+
+    EnabledCategory(const EnabledCategory &) = delete;
+    EnabledCategory &operator=(const EnabledCategory &) = delete;
+
+    [[nodiscard]] EnabledAsynchronousToken beginAsynchronous(TracerLiteral traceName,
+                                                             KeyValue auto &&...arguments);
+
+    [[nodiscard]] std::pair<EnabledAsynchronousToken, EnabledFlowToken> beginAsynchronousWithFlow(
+        TracerLiteral traceName, KeyValue auto &&...arguments);
+
+    [[nodiscard]] EnabledTracer beginDuration(TracerLiteral traceName, KeyValue auto &&...arguments);
+
+    [[nodiscard]] std::pair<EnabledTracer, EnabledFlowToken> beginDurationWithFlow(
+        TracerLiteral traceName, KeyValue auto &&...arguments);
+
+    void threadEvent(TracerLiteral traceName, KeyValue auto &&...arguments)
+    {
+        if (isEnabled == IsEnabled::No)
+            return;
+
+        auto &traceEvent = getTraceEvent(eventQueue(std::forward<decltype(arguments)>(arguments)...));
+
+        traceEvent.time = Clock::now();
+        traceEvent.name = std::move(traceName);
+        traceEvent.category = traceName;
+        traceEvent.type = 'i';
+        traceEvent.id = 0;
+        traceEvent.bindId = 0;
+        traceEvent.flow = IsFlow::No;
+        if constexpr (sizeof...(arguments))
+            Internal::setArguments(traceEvent.arguments,
+                                   std::forward<decltype(arguments)>(arguments)...);
+    }
+
+    EnabledEventQueueWithoutArguments &eventQueue() const { return m_eventQueueWithoutArguments; }
+
+    EnabledEventQueueWithArguments &eventQueue(const KeyValue auto &...) const
+    {
+        return m_eventQueue;
+    }
+
+    std::string_view name() const { return m_name; }
+
+    static constexpr bool isActive() { return true; }
+
+    std::size_t createBindId() { return ++m_bindIdCounter; }
+
+    std::size_t createId() { return ++m_idCounter; }
+
+public:
+    IsEnabled isEnabled = IsEnabled::Yes;
+
+private:
+    void begin(char type,
+               std::size_t id,
+               std::string_view traceName,
+               std::size_t bindId,
+               IsFlow flow,
+               KeyValue auto &&...arguments)
+    {
+        if (isEnabled == IsEnabled::No)
+            return;
+
+        auto &traceEvent = getTraceEvent(eventQueue(std::forward<decltype(arguments)>(arguments)...));
+
+        traceEvent.name = std::move(traceName);
+        traceEvent.category = m_name;
+        traceEvent.type = type;
+        traceEvent.id = id;
+        traceEvent.bindId = bindId;
+        traceEvent.flow = flow;
+        if constexpr (sizeof...(arguments))
+            Internal::setArguments(traceEvent.arguments,
+                                   std::forward<decltype(arguments)>(arguments)...);
+        traceEvent.time = Clock::now();
+    }
+
+    void tick(char type,
+              std::size_t id,
+              std::string_view traceName,
+              std::size_t bindId,
+              IsFlow flow,
+              KeyValue auto &&...arguments)
+    {
+        if (isEnabled == IsEnabled::No)
+            return;
+
+        auto time = Clock::now();
+
+        auto &traceEvent = getTraceEvent(eventQueue(std::forward<decltype(arguments)>(arguments)...));
+
+        traceEvent.name = std::move(traceName);
+        traceEvent.category = m_name;
+        traceEvent.time = time;
+        traceEvent.type = type;
+        traceEvent.id = id;
+        traceEvent.bindId = bindId;
+        traceEvent.flow = flow;
+        if constexpr (sizeof...(arguments))
+            Internal::setArguments(traceEvent.arguments,
+                                   std::forward<decltype(arguments)>(arguments)...);
+    }
+
+    void end(char type, std::size_t id, std::string_view traceName, KeyValue auto &&...arguments)
+    {
+        if (isEnabled == IsEnabled::No)
+            return;
+
+        auto time = Clock::now();
+
+        auto &traceEvent = getTraceEvent(eventQueue(std::forward<decltype(arguments)>(arguments)...));
+
+        traceEvent.name = std::move(traceName);
+        traceEvent.category = m_name;
+        traceEvent.time = time;
+        traceEvent.type = type;
+        traceEvent.id = id;
+        traceEvent.bindId = 0;
+        traceEvent.flow = IsFlow::No;
+        if constexpr (sizeof...(arguments))
+            Internal::setArguments(traceEvent.arguments,
+                                   std::forward<decltype(arguments)>(arguments)...);
+    }
+
+    CategoryFunctionPointer self() { return m_self; }
+
+private:
+    std::string_view m_name;
+    EnabledEventQueueWithArguments &m_eventQueue;
+    EnabledEventQueueWithoutArguments &m_eventQueueWithoutArguments;
+    inline static std::atomic<std::size_t> m_globalIdCounter;
+    std::size_t m_idCounter;
+    inline static std::atomic<std::size_t> m_globalBindIdCounter;
+    std::size_t m_bindIdCounter;
+    CategoryFunctionPointer m_self;
+};
+
+template<typename Category>
+class Token : public BasicDisabledToken
+{
+public:
+    Token() = default;
+
+    ~Token() = default;
+
+    [[nodiscard]] DisabledAsynchronousToken beginAsynchronous(TracerLiteral, KeyValue auto &&...);
+
+    [[nodiscard]] std::pair<DisabledAsynchronousToken, DisabledFlowToken> beginAsynchronousWithFlow(
+        TracerLiteral, KeyValue auto &&...);
+
+    [[nodiscard]] DisabledTracer beginDuration(TracerLiteral, KeyValue auto &&...);
+
+    [[nodiscard]] std::pair<DisabledTracer, DisabledFlowToken> beginDurationWithFlow(
+        TracerLiteral, KeyValue auto &&...);
+
+    void tick(TracerLiteral, KeyValue auto &&...) {}
+};
+
+template<>
+class Token<EnabledCategory> : public BasicEnabledToken
+
+{
+    using CategoryFunctionPointer = typename EnabledCategory::CategoryFunctionPointer;
+
+    Token(std::size_t id, CategoryFunctionPointer category)
+        : m_id{id}
+        , m_category{category}
+    {}
+
+    using PrivateTag = typename EnabledCategory::PrivateTag;
+
+public:
+    Token(PrivateTag, std::size_t id, CategoryFunctionPointer category)
+        : Token{id, category}
+    {}
+
+    friend EnabledTracer;
+    friend EnabledAsynchronousToken;
+
+    ~Token() {}
+
+    [[nodiscard]] EnabledAsynchronousToken beginAsynchronous(TracerLiteral name,
+                                                             KeyValue auto &&...arguments);
+
+    [[nodiscard]] std::pair<EnabledAsynchronousToken, EnabledFlowToken> beginAsynchronousWithFlow(
+        TracerLiteral name, KeyValue auto &&...arguments);
+
+    [[nodiscard]] EnabledTracer beginDuration(TracerLiteral traceName, KeyValue auto &&...arguments);
+
+    [[nodiscard]] std::pair<EnabledTracer, EnabledFlowToken> beginDurationWithFlow(
+        TracerLiteral traceName, KeyValue auto &&...arguments);
+
+    void tick(TracerLiteral name, KeyValue auto &&...arguments)
+    {
+        m_category().begin('i', 0, name, 0, IsFlow::No, std::forward<decltype(arguments)>(arguments)...);
+    }
+
+private:
+    std::size_t m_id = 0;
+    CategoryFunctionPointer m_category = nullptr;
+};
+
+template<typename Category>
 class Tracer
 {
 public:
     Tracer() = default;
-    using TokenType = typename Category::TokenType;
-    using FlowTokenType = typename Category::FlowTokenType;
 
-    friend TokenType;
-    friend FlowTokenType;
+    friend DisabledToken;
+    friend DisabledFlowToken;
     friend Category;
 
     [[nodiscard]] Tracer(TracerLiteral, const Category &, KeyValue auto &&...) {}
@@ -668,7 +995,7 @@ public:
     Tracer(Tracer &&other) noexcept = default;
     Tracer &operator=(Tracer &&other) noexcept = delete;
 
-    TokenType createToken() { return {}; }
+    DisabledToken createToken() { return {}; }
 
     Tracer beginDuration(TracerLiteral, KeyValue auto &&...) { return {}; }
 
@@ -679,56 +1006,52 @@ public:
     ~Tracer() {}
 };
 
-template<typename Category>
-class Tracer<Category, std::true_type>
+template<>
+class Tracer<EnabledCategory>
 {
-    using TokenType = typename Category::TokenType;
-    using FlowTokenType = typename Category::FlowTokenType;
-    using PrivateTag = typename Category::PrivateTag;
-    using CategoryFunctionPointer = typename Category::CategoryFunctionPointer;
+    using PrivateTag = typename EnabledCategory::PrivateTag;
+    using CategoryFunctionPointer = typename EnabledCategory::CategoryFunctionPointer;
 
-    friend FlowTokenType;
-    friend TokenType;
-    friend Category;
+    friend EnabledFlowToken;
+    friend EnabledToken;
+    friend EnabledCategory;
 
-    template<KeyValue... Arguments>
     [[nodiscard]] Tracer(std::size_t bindId,
                          IsFlow flow,
                          TracerLiteral name,
                          CategoryFunctionPointer category,
-                         Arguments &&...arguments)
+                         KeyValue auto &&...arguments)
         : m_name{name}
         , m_bindId{bindId}
         , flow{flow}
         , m_category{category}
     {
         if (category().isEnabled == IsEnabled::Yes)
-            sendBeginTrace(std::forward<Arguments>(arguments)...);
+            sendBeginTrace(std::forward<decltype(arguments)>(arguments)...);
     }
 
 public:
-    template<KeyValue... Arguments>
     [[nodiscard]] Tracer(PrivateTag,
                          std::size_t bindId,
                          IsFlow flow,
                          TracerLiteral name,
                          CategoryFunctionPointer category,
-                         Arguments &&...arguments)
-        : Tracer{bindId, flow, std::move(name), category, std::forward<Arguments>(arguments)...}
+                         KeyValue auto &&...arguments)
+        : Tracer{bindId, flow, std::move(name), category, std::forward<decltype(arguments)>(arguments)...}
     {}
 
-    template<KeyValue... Arguments>
-    [[nodiscard]] Tracer(TracerLiteral name, CategoryFunctionPointer category, Arguments &&...arguments)
+    [[nodiscard]] Tracer(TracerLiteral name,
+                         CategoryFunctionPointer category,
+                         KeyValue auto &&...arguments)
         : m_name{name}
         , m_category{category}
     {
         if (category().isEnabled == IsEnabled::Yes)
-            sendBeginTrace(std::forward<Arguments>(arguments)...);
+            sendBeginTrace(std::forward<decltype(arguments)>(arguments)...);
     }
 
-    template<KeyValue... Arguments>
-    [[nodiscard]] Tracer(TracerLiteral name, Category &category, Arguments &&...arguments)
-        : Tracer(std::move(name), category.self(), std::forward<Arguments>(arguments)...)
+    [[nodiscard]] Tracer(TracerLiteral name, EnabledCategory &category, KeyValue auto &&...arguments)
+        : Tracer(std::move(name), category.self(), std::forward<decltype(arguments)>(arguments)...)
     {}
 
     Tracer(const Tracer &) = delete;
@@ -736,36 +1059,33 @@ public:
     Tracer(Tracer &&other) noexcept = delete;
     Tracer &operator=(Tracer &&other) noexcept = delete;
 
-    TokenType createToken() { return {0, m_category}; }
+    EnabledToken createToken() { return {0, m_category}; }
 
     ~Tracer() { sendEndTrace(); }
 
-    template<KeyValue... Arguments>
-    Tracer beginDuration(TracerLiteral name, Arguments &&...arguments)
+    Tracer beginDuration(TracerLiteral name, KeyValue auto &&...arguments)
     {
-        return {std::move(name), m_category, std::forward<Arguments>(arguments)...};
+        return {std::move(name), m_category, std::forward<decltype(arguments)>(arguments)...};
     }
 
-    template<KeyValue... Arguments>
-    void tick(TracerLiteral name, Arguments &&...arguments)
+    void tick(TracerLiteral name, KeyValue auto &&...arguments)
     {
-        m_category().begin('i', 0, name, 0, IsFlow::No, std::forward<Arguments>(arguments)...);
+        m_category().begin('i', 0, name, 0, IsFlow::No, std::forward<decltype(arguments)>(arguments)...);
     }
 
-    template<KeyValue... Arguments>
-    void end(Arguments &&...arguments)
+    void end(KeyValue auto &&...arguments)
     {
-        sendEndTrace(std::forward<Arguments>(arguments)...);
+        sendEndTrace(std::forward<decltype(arguments)>(arguments)...);
         m_name = {};
     }
 
 private:
-    template<KeyValue... Arguments>
-    void sendBeginTrace(Arguments &&...arguments)
+    void sendBeginTrace(KeyValue auto &&...arguments)
     {
         auto &category = m_category();
         if (category.isEnabled == IsEnabled::Yes) {
-            auto &traceEvent = getTraceEvent(category.eventQueue(arguments...));
+            auto &traceEvent = getTraceEvent(
+                category.eventQueue(std::forward<decltype(arguments)>(arguments)...));
             traceEvent.name = m_name;
             traceEvent.category = category.name();
             traceEvent.bindId = m_bindId;
@@ -773,20 +1093,20 @@ private:
             traceEvent.type = 'B';
             if constexpr (sizeof...(arguments)) {
                 Internal::setArguments<ArgumentsString>(traceEvent.arguments,
-                                                        std::forward<Arguments>(arguments)...);
+                                                        std::forward<decltype(arguments)>(arguments)...);
             }
             traceEvent.time = Clock::now();
         }
     }
 
-    template<KeyValue... Arguments>
-    void sendEndTrace(Arguments &&...arguments)
+    void sendEndTrace(KeyValue auto &&...arguments)
     {
         if (m_name.size()) {
             auto &category = m_category();
             if (category.isEnabled == IsEnabled::Yes) {
                 auto end = Clock::now();
-                auto &traceEvent = getTraceEvent(category.eventQueue(arguments...));
+                auto &traceEvent = getTraceEvent(
+                    category.eventQueue(std::forward<decltype(arguments)>(arguments)...));
                 traceEvent.name = std::move(m_name);
                 traceEvent.category = category.name();
                 traceEvent.time = end;
@@ -795,7 +1115,8 @@ private:
                 traceEvent.type = 'E';
                 if constexpr (sizeof...(arguments)) {
                     Internal::setArguments<ArgumentsString>(traceEvent.arguments,
-                                                            std::forward<Arguments>(arguments)...);
+                                                            std::forward<decltype(arguments)>(
+                                                                arguments)...);
                 }
             }
         }
@@ -809,146 +1130,18 @@ private:
 };
 
 template<typename Category, KeyValue... Arguments>
-Tracer(TracerLiteral name, Category &category, Arguments &&...)
-    -> Tracer<Category, typename Category::IsActive>;
+Tracer(TracerLiteral name, Category &category, Arguments &&...) -> Tracer<Category>;
 
 template<typename Category, KeyValue... Arguments>
-Tracer(TracerLiteral name, const Category &category, Arguments &&...)
-    -> Tracer<Category, typename Category::IsActive>;
-
-template<typename Category, Tracing isEnabled>
-class Token : public BasicDisabledToken
-{
-public:
-    using FlowTokenType = typename Category::FlowTokenType;
-    using AsynchronousTokenType = typename Category::AsynchronousTokenType;
-    using TracerType = typename Category::TracerType;
-
-    Token() {}
-
-    ~Token() {}
-
-    [[nodiscard]] AsynchronousTokenType beginAsynchronous(TracerLiteral, KeyValue auto &&...)
-    {
-        return {};
-    }
-
-    [[nodiscard]] std::pair<AsynchronousTokenType, FlowTokenType> beginAsynchronousWithFlow(
-        TracerLiteral, KeyValue auto &&...)
-    {
-        return {};
-    }
-
-    [[nodiscard]] TracerType beginDuration(TracerLiteral, KeyValue auto &&...) { return {}; }
-
-    [[nodiscard]] std::pair<TracerType, FlowTokenType> beginDurationWithFlow(TracerLiteral,
-                                                                             KeyValue auto &&...)
-    {
-        return {};
-    }
-
-    void tick(TracerLiteral, KeyValue auto &&...) {}
-};
+Tracer(TracerLiteral name, const Category &category, Arguments &&...) -> Tracer<Category>;
 
 template<typename Category>
-class Token<Category, Tracing::IsEnabled> : public BasicEnabledToken
-
-{
-    using CategoryFunctionPointer = typename Category::CategoryFunctionPointer;
-
-    Token(std::size_t id, CategoryFunctionPointer category)
-        : m_id{id}
-        , m_category{category}
-    {}
-
-    using PrivateTag = typename Category::PrivateTag;
-
-public:
-    using FlowTokenType = typename Category::FlowTokenType;
-    using AsynchronousTokenType = typename Category::AsynchronousTokenType;
-    using TracerType = typename Category::TracerType;
-
-    Token(PrivateTag, std::size_t id, CategoryFunctionPointer category)
-        : Token{id, category}
-    {}
-
-    friend TracerType;
-    friend AsynchronousTokenType;
-
-    ~Token() {}
-
-    template<KeyValue... Arguments>
-    [[nodiscard]] AsynchronousTokenType beginAsynchronous(TracerLiteral name, Arguments &&...arguments)
-    {
-        if (m_id)
-            m_category().begin('b', m_id, name, 0, IsFlow::No, std::forward<Arguments>(arguments)...);
-
-        return {std::move(name), m_id, m_category};
-    }
-
-    template<KeyValue... Arguments>
-    [[nodiscard]] std::pair<AsynchronousTokenType, FlowTokenType> beginAsynchronousWithFlow(
-        TracerLiteral name, Arguments &&...arguments)
-    {
-        std::size_t bindId = 0;
-
-        if (m_id) {
-            auto &category = m_category();
-            bindId = category.createBindId();
-            category.begin('b', m_id, name, bindId, IsFlow::Out, std::forward<Arguments>(arguments)...);
-        }
-
-        return {std::piecewise_construct,
-                std::forward_as_tuple(std::move(name), m_id, m_category),
-                std::forward_as_tuple(std::move(name), bindId, m_category)};
-    }
-
-    template<KeyValue... Arguments>
-    [[nodiscard]] TracerType beginDuration(TracerLiteral traceName, Arguments &&...arguments)
-    {
-        return {traceName, m_category, std::forward<Arguments>(arguments)...};
-    }
-
-    template<KeyValue... Arguments>
-    [[nodiscard]] std::pair<TracerType, FlowTokenType> beginDurationWithFlow(TracerLiteral traceName,
-                                                                             Arguments &&...arguments)
-    {
-        std::size_t bindId = m_category().createBindId();
-
-        return {std::piecewise_construct,
-                std::forward_as_tuple(PrivateTag{},
-                                      bindId,
-                                      IsFlow::Out,
-                                      traceName,
-                                      m_category,
-                                      std::forward<Arguments>(arguments)...),
-                std::forward_as_tuple(PrivateTag{}, traceName, bindId, m_category)};
-    }
-
-    template<KeyValue... Arguments>
-    void tick(TracerLiteral name, Arguments &&...arguments)
-    {
-        m_category().begin('i', 0, name, 0, IsFlow::No, std::forward<Arguments>(arguments)...);
-    }
-
-private:
-    std::size_t m_id = 0;
-    CategoryFunctionPointer m_category = nullptr;
-};
-template<typename TraceEvent, Tracing isEnabled>
-class Category;
-
-template<typename Category>
-using DisabledToken = Token<Category, Tracing::IsDisabled>;
-
-template<typename Category, Tracing isEnabled>
 class AsynchronousToken : public BasicDisabledToken
 {
 public:
-    using FlowTokenType = typename Category::FlowTokenType;
-    using TokenType = typename Category::TokenType;
+    using TokenType = Token<DisabledCategory>;
 
-    AsynchronousToken() {}
+    AsynchronousToken() = default;
 
     AsynchronousToken(const AsynchronousToken &) = delete;
     AsynchronousToken &operator=(const AsynchronousToken &) = delete;
@@ -961,35 +1154,32 @@ public:
 
     [[nodiscard]] AsynchronousToken begin(TracerLiteral, KeyValue auto &&...) { return {}; }
 
-    [[nodiscard]] AsynchronousToken begin(const FlowTokenType &, TracerLiteral, KeyValue auto &&...)
+    [[nodiscard]] AsynchronousToken begin(const DisabledFlowToken &, TracerLiteral, KeyValue auto &&...)
     {
         return {};
     }
 
-    [[nodiscard]] std::pair<AsynchronousToken, FlowTokenType> beginWithFlow(TracerLiteral,
-                                                                            KeyValue auto &&...)
+    [[nodiscard]] std::pair<AsynchronousToken, DisabledFlowToken> beginWithFlow(TracerLiteral,
+                                                                                KeyValue auto &&...)
     {
         return {};
     }
 
     void tick(TracerLiteral, KeyValue auto &&...) {}
 
-    void tick(const FlowTokenType &, TracerLiteral, KeyValue auto &&...) {}
+    void tick(const DisabledFlowToken &, TracerLiteral, KeyValue auto &&...) {}
 
-    FlowTokenType tickWithFlow(TracerLiteral, KeyValue auto &&...) { return {}; }
+    DisabledFlowToken tickWithFlow(TracerLiteral, KeyValue auto &&...);
 
     void end(KeyValue auto &&...) {}
 
     static constexpr bool categoryIsActive() { return Category::isActive(); }
 };
 
-template<typename Category, Tracing isEnabled>
-class FlowToken;
-
-template<typename Category>
-class AsynchronousToken<Category, Tracing::IsEnabled> : public BasicEnabledToken
+template<>
+class AsynchronousToken<EnabledCategory> : public BasicEnabledToken
 {
-    using CategoryFunctionPointer = typename Category::CategoryFunctionPointer;
+    using CategoryFunctionPointer = typename EnabledCategory::CategoryFunctionPointer;
 
     AsynchronousToken(std::string_view name, std::size_t id, CategoryFunctionPointer category)
         : m_name{name}
@@ -997,22 +1187,17 @@ class AsynchronousToken<Category, Tracing::IsEnabled> : public BasicEnabledToken
         , m_category{category}
     {}
 
-    using PrivateTag = typename Category::PrivateTag;
+    using PrivateTag = typename EnabledCategory::PrivateTag;
 
 public:
-    using FlowTokenType = typename Category::FlowTokenType;
-    using TokenType = typename Category::TokenType;
-
-    friend Category;
-    friend FlowTokenType;
-    friend TokenType;
+    friend EnabledCategory;
+    friend EnabledFlowToken;
+    friend EnabledToken;
 
     AsynchronousToken(PrivateTag, std::string_view name, std::size_t id, CategoryFunctionPointer category)
         : AsynchronousToken{name, id, category}
     {}
 
-    AsynchronousToken() {}
-
     AsynchronousToken(const AsynchronousToken &) = delete;
     AsynchronousToken &operator=(const AsynchronousToken &) = delete;
 
@@ -1035,96 +1220,52 @@ public:
 
     ~AsynchronousToken() { end(); }
 
-    [[nodiscard]] TokenType createToken() { return {m_id, m_category}; }
+    [[nodiscard]] EnabledToken createToken();
 
-    template<KeyValue... Arguments>
-    [[nodiscard]] AsynchronousToken begin(TracerLiteral name, Arguments &&...arguments)
+    [[nodiscard]] AsynchronousToken begin(TracerLiteral name, KeyValue auto &&...arguments)
     {
         if (m_id)
-            m_category().begin('b', m_id, name, 0, IsFlow::No, std::forward<Arguments>(arguments)...);
+            m_category().begin(
+                'b', m_id, name, 0, IsFlow::No, std::forward<decltype(arguments)>(arguments)...);
 
         return AsynchronousToken{std::move(name), m_id, m_category};
     }
 
-    template<KeyValue... Arguments>
-    [[nodiscard]] AsynchronousToken begin(const FlowTokenType &flowToken,
+    [[nodiscard]] AsynchronousToken begin(const EnabledFlowToken &flowToken,
                                           TracerLiteral name,
-                                          Arguments &&...arguments)
-    {
-        if (m_id)
-            m_category().begin('b',
-                               m_id,
-                               name,
-                               flowToken.bindId(),
-                               IsFlow::In,
-                               std::forward<Arguments>(arguments)...);
+                                          KeyValue auto &&...arguments);
 
-        return AsynchronousToken{std::move(name), m_id, m_category};
-    }
+    [[nodiscard]] std::pair<AsynchronousToken, EnabledFlowToken> beginWithFlow(
+        TracerLiteral name, KeyValue auto &&...arguments);
 
-    template<KeyValue... Arguments>
-    [[nodiscard]] std::pair<AsynchronousToken, FlowTokenType> beginWithFlow(TracerLiteral name,
-                                                                            Arguments &&...arguments)
-    {
-        std::size_t bindId = 0;
-
-        if (m_id) {
-            auto &category = m_category();
-            bindId = category.createBindId();
-            category.begin('b', m_id, name, bindId, IsFlow::Out, std::forward<Arguments>(arguments)...);
-        }
-
-        return {std::piecewise_construct,
-                std::forward_as_tuple(PrivateTag{}, std::move(name), m_id, m_category),
-                std::forward_as_tuple(PrivateTag{}, std::move(name), bindId, m_category)};
-    }
-
-    template<KeyValue... Arguments>
-    void tick(TracerLiteral name, Arguments &&...arguments)
-    {
-        if (m_id) {
-            m_category().tick(
-                'n', m_id, std::move(name), 0, IsFlow::No, std::forward<Arguments>(arguments)...);
-        }
-    }
-
-    template<KeyValue... Arguments>
-    void tick(const FlowTokenType &flowToken, TracerLiteral name, Arguments &&...arguments)
+    void tick(TracerLiteral name, KeyValue auto &&...arguments)
     {
         if (m_id) {
             m_category().tick('n',
                               m_id,
                               std::move(name),
-                              flowToken.bindId(),
-                              IsFlow::In,
-                              std::forward<Arguments>(arguments)...);
+                              0,
+                              IsFlow::No,
+                              std::forward<decltype(arguments)>(arguments)...);
         }
     }
 
-    template<KeyValue... Arguments>
-    FlowTokenType tickWithFlow(TracerLiteral name, Arguments &&...arguments)
-    {
-        std::size_t bindId = 0;
+    void tick(const EnabledFlowToken &flowToken, TracerLiteral name, KeyValue auto &&...arguments);
 
-        if (m_id) {
-            auto &category = m_category();
-            bindId = category.createBindId();
-            category.tick('n', m_id, name, bindId, IsFlow::Out, std::forward<Arguments>(arguments)...);
-        }
+    EnabledFlowToken tickWithFlow(TracerLiteral name, KeyValue auto &&...arguments);
 
-        return {PrivateTag{}, std::move(name), bindId, m_category};
-    }
-
-    template<KeyValue... Arguments>
-    void end(Arguments &&...arguments)
+    void end(KeyValue auto &&...arguments)
     {
         if (m_id && m_name.size())
-            m_category().end('e', m_id, std::move(m_name), std::forward<Arguments>(arguments)...);
+            m_category().end('e',
+                             m_id,
+                             std::move(m_name),
+                             std::forward<decltype(arguments)>(arguments)...);
 
         m_id = 0;
     }
 
-    static constexpr bool categoryIsActive() { return Category::isActive(); }
+    static constexpr bool categoryIsActive() { return EnabledCategory::isActive(); }
 
 private:
     std::string_view m_name;
@@ -1132,19 +1273,11 @@ private:
     CategoryFunctionPointer m_category = nullptr;
 };
 
-template<typename Category, Tracing isEnabled>
+template<typename Category>
 class FlowToken : public BasicDisabledToken
 {
 public:
     FlowToken() = default;
-    using AsynchronousTokenType = typename Category::AsynchronousTokenType;
-    using TracerType = typename Category::TracerType;
-    using TokenType = typename Category::TokenType;
-
-    friend TracerType;
-    friend AsynchronousTokenType;
-    friend TokenType;
-    friend Category;
 
     FlowToken(const FlowToken &) = default;
     FlowToken &operator=(const FlowToken &) = default;
@@ -1153,53 +1286,47 @@ public:
 
     ~FlowToken() {}
 
-    [[nodiscard]] AsynchronousTokenType beginAsynchronous(TracerLiteral, KeyValue auto &&...)
+    [[nodiscard]] DisabledAsynchronousToken beginAsynchronous(TracerLiteral, KeyValue auto &&...)
     {
         return {};
     }
 
-    [[nodiscard]] std::pair<AsynchronousTokenType, FlowToken> beginAsynchronousWithFlow(
+    [[nodiscard]] std::pair<DisabledAsynchronousToken, FlowToken> beginAsynchronousWithFlow(
         TracerLiteral, KeyValue auto &&...)
     {
         return {};
     }
 
-    void connectTo(const AsynchronousTokenType &, KeyValue auto &&...) {}
+    void connectTo(const DisabledAsynchronousToken &, KeyValue auto &&...) {}
 
-    [[nodiscard]] TracerType beginDuration(TracerLiteral, KeyValue auto &&...) { return {}; }
+    [[nodiscard]] DisabledTracer beginDuration(TracerLiteral, KeyValue auto &&...) { return {}; }
 
-    [[nodiscard]] std::pair<TracerType, FlowToken> beginDurationWithFlow(TracerLiteral,
-                                                                         KeyValue auto &&...)
+    [[nodiscard]] std::pair<DisabledTracer, FlowToken> beginDurationWithFlow(TracerLiteral,
+                                                                             KeyValue auto &&...)
     {
-        return std::pair<TracerType, FlowToken>();
+        return std::pair<DisabledTracer, FlowToken>();
     }
 
     void tick(TracerLiteral, KeyValue auto &&...) {}
 };
 
-template<typename Category>
-class FlowToken<Category, Tracing::IsEnabled> : public BasicDisabledToken
+template<>
+class FlowToken<EnabledCategory> : public BasicDisabledToken
 {
-    using PrivateTag = typename Category::PrivateTag;
-    using CategoryFunctionPointer = typename Category::CategoryFunctionPointer;
+    using PrivateTag = typename EnabledCategory::PrivateTag;
+    using CategoryFunctionPointer = typename EnabledCategory::CategoryFunctionPointer;
 
 public:
-    FlowToken() = default;
-
     FlowToken(PrivateTag, std::string_view name, std::size_t bindId, CategoryFunctionPointer category)
         : m_name{name}
         , m_bindId{bindId}
         , m_category{category}
     {}
 
-    using AsynchronousTokenType = typename Category::AsynchronousTokenType;
-    using TracerType = typename Category::TracerType;
-    using TokenType = typename Category::TokenType;
-
-    friend AsynchronousTokenType;
-    friend TokenType;
-    friend TracerType;
-    friend Category;
+    friend EnabledAsynchronousToken;
+    friend EnabledToken;
+    friend EnabledTracer;
+    friend EnabledCategory;
 
     FlowToken(const FlowToken &) = default;
     FlowToken &operator=(const FlowToken &) = default;
@@ -1209,22 +1336,27 @@ public:
     ~FlowToken() {}
 
     template<KeyValue... Arguments>
-    [[nodiscard]] AsynchronousTokenType beginAsynchronous(TracerLiteral name, Arguments &&...arguments)
+    [[nodiscard]] EnabledAsynchronousToken beginAsynchronous(TracerLiteral name,
+                                                             KeyValue auto &&...arguments)
     {
         std::size_t id = 0;
 
         if (m_bindId) {
             auto &category = m_category();
             id = category.createId();
-            category.begin('b', id, name, m_bindId, IsFlow::In, std::forward<Arguments>(arguments)...);
+            category.begin('b',
+                           id,
+                           name,
+                           m_bindId,
+                           IsFlow::In,
+                           std::forward<decltype(arguments)>(arguments)...);
         }
 
         return {std::move(name), id, m_category};
     }
 
-    template<KeyValue... Arguments>
-    [[nodiscard]] std::pair<AsynchronousTokenType, FlowToken> beginAsynchronousWithFlow(
-        TracerLiteral name, Arguments &&...arguments)
+    [[nodiscard]] std::pair<EnabledAsynchronousToken, FlowToken> beginAsynchronousWithFlow(
+        TracerLiteral name, KeyValue auto &&...arguments)
     {
         std::size_t id = 0;
         std::size_t bindId = 0;
@@ -1233,7 +1365,12 @@ public:
             auto &category = m_category();
             id = category.createId();
             bindId = category.createBindId();
-            category.begin('b', id, name, bindId, IsFlow::InOut, std::forward<Arguments>(arguments)...);
+            category.begin('b',
+                           id,
+                           name,
+                           bindId,
+                           IsFlow::InOut,
+                           std::forward<decltype(arguments)>(arguments)...);
         }
 
         return {std::piecewise_construct,
@@ -1241,8 +1378,7 @@ public:
                 std::forward_as_tuple(PrivateTag{}, std::move(name), bindId, m_category)};
     }
 
-    template<KeyValue... Arguments>
-    void connectTo(const AsynchronousTokenType &token, Arguments &&...arguments)
+    void connectTo(const EnabledAsynchronousToken &token, KeyValue auto &&...arguments)
     {
         if (m_bindId && token.m_id) {
             m_category().begin('b',
@@ -1250,19 +1386,21 @@ public:
                                token.m_name,
                                m_bindId,
                                IsFlow::In,
-                               std::forward<Arguments>(arguments)...);
+                               std::forward<decltype(arguments)>(arguments)...);
         }
     }
 
-    template<KeyValue... Arguments>
-    [[nodiscard]] TracerType beginDuration(TracerLiteral traceName, Arguments &&...arguments)
+    [[nodiscard]] EnabledTracer beginDuration(TracerLiteral traceName, KeyValue auto &&...arguments)
     {
-        return {m_bindId, IsFlow::In, traceName, m_category, std::forward<Arguments>(arguments)...};
+        return {m_bindId,
+                IsFlow::In,
+                traceName,
+                m_category,
+                std::forward<decltype(arguments)>(arguments)...};
     }
 
-    template<KeyValue... Arguments>
-    [[nodiscard]] std::pair<TracerType, FlowToken> beginDurationWithFlow(TracerLiteral traceName,
-                                                                         Arguments &&...arguments)
+    [[nodiscard]] std::pair<EnabledTracer, FlowToken> beginDurationWithFlow(TracerLiteral traceName,
+                                                                            KeyValue auto &&...arguments)
     {
         return {std::piecewise_construct,
                 std::forward_as_tuple(PrivateTag{},
@@ -1270,14 +1408,14 @@ public:
                                       IsFlow::InOut,
                                       traceName,
                                       m_category,
-                                      std::forward<Arguments>(arguments)...),
+                                      std::forward<decltype(arguments)>(arguments)...),
                 std::forward_as_tuple(PrivateTag{}, traceName, m_bindId, m_category)};
     }
 
-    template<KeyValue... Arguments>
-    void tick(TracerLiteral name, Arguments &&...arguments)
+    void tick(TracerLiteral name, KeyValue auto &&...arguments)
     {
-        m_category().tick('i', 0, name, m_bindId, IsFlow::In, std::forward<Arguments>(arguments)...);
+        m_category().tick(
+            'i', 0, name, m_bindId, IsFlow::In, std::forward<decltype(arguments)>(arguments)...);
     }
 
     std::size_t bindId() const { return m_bindId; }
@@ -1288,308 +1426,203 @@ private:
     CategoryFunctionPointer m_category = nullptr;
 };
 
-class DisabledCategory
+inline DisabledAsynchronousToken DisabledCategory::beginAsynchronous(TracerLiteral, KeyValue auto &&...)
 {
-public:
-    class SourceLocation
-    {
-    public:
-        template<typename String>
-        friend void convertToString(String &, SourceLocation)
-        {}
-    };
+    return {};
+}
 
-    using IsActive = std::false_type;
-    using AsynchronousTokenType = AsynchronousToken<DisabledCategory, Tracing::IsDisabled>;
-    using FlowTokenType = FlowToken<DisabledCategory, Tracing::IsDisabled>;
-    using TracerType = Tracer<DisabledCategory, std::false_type>;
-    using TokenType = Token<DisabledCategory, Tracing::IsDisabled>;
-    using CategoryFunctionPointer = DisabledCategory &(*) ();
-
-    DisabledCategory() = default;
-
-    DisabledCategory(TracerLiteral,
-                     EventQueueWithArguments<Tracing::IsDisabled> &,
-                     EventQueueWithoutArguments<Tracing::IsDisabled> &,
-                     CategoryFunctionPointer)
-    {}
-
-    DisabledCategory(TracerLiteral,
-                     EventQueueWithArguments<Tracing::IsEnabled> &,
-                     EventQueueWithoutArguments<Tracing::IsEnabled> &,
-                     CategoryFunctionPointer)
-    {}
-
-    template<typename... Arguments>
-    [[nodiscard]] AsynchronousTokenType beginAsynchronous(TracerLiteral, Arguments &&...)
-    {
-        return {};
-    }
-
-    template<typename... Arguments>
-    [[nodiscard]] std::pair<AsynchronousTokenType, FlowTokenType> beginAsynchronousWithFlow(
-        TracerLiteral, Arguments &&...)
-    {
-        return {};
-    }
-
-    template<typename... Arguments>
-    [[nodiscard]] TracerType beginDuration(TracerLiteral, Arguments &&...)
-    {
-        return {};
-    }
-
-    template<typename... Arguments>
-    [[nodiscard]] std::pair<TracerType, FlowTokenType> beginDurationWithFlow(TracerLiteral,
-                                                                             Arguments &&...)
-    {
-        return std::pair<TracerType, FlowTokenType>();
-    }
-
-    template<typename... Arguments>
-    void threadEvent(TracerLiteral, Arguments &&...)
-    {}
-
-    static constexpr bool isActive() { return false; }
-};
-
-class EnabledCategory
+inline std::pair<DisabledAsynchronousToken, DisabledFlowToken> DisabledCategory::beginAsynchronousWithFlow(
+    TracerLiteral, KeyValue auto &&...)
 {
-    class PrivateTag
-    {};
+    return {};
+}
 
-public:
-    class SourceLocation : public Sqlite::source_location
-    {
-    public:
-        consteval SourceLocation(
-            const char *fileName = __builtin_FILE(),
-            const char *functionName = __builtin_FUNCTION(),
-            const uint_least32_t line = __builtin_LINE())
-            : Sqlite::source_location(Sqlite::source_location::current(fileName, functionName, line))
-        {}
+inline DisabledTracer DisabledCategory::beginDuration(TracerLiteral, KeyValue auto &&...)
+{
+    return {};
+}
 
-        template<typename String>
-        friend void convertToString(String &string, SourceLocation sourceLocation)
-        {
-            using NanotraceHR::dictonary;
-            using NanotraceHR::keyValue;
-            auto dict = dictonary(
-                keyValue("file", sourceLocation.file_name()),
-                keyValue("function", sourceLocation.function_name()),
-                keyValue("line", sourceLocation.line()));
-            convertToString(string, dict);
+inline std::pair<DisabledTracer, DisabledFlowToken> DisabledCategory::beginDurationWithFlow(
+    TracerLiteral, KeyValue auto &&...)
+{
+    return {};
+}
 
-            string.append(',');
-            convertToString(string, "id");
-            string.append(':');
-            string.append('\"');
-            string.append(sourceLocation.file_name());
-            string.append(':');
-            string.append(sourceLocation.line());
-            string.append('\"');
-        }
-    };
+inline EnabledAsynchronousToken EnabledCategory::beginAsynchronous(TracerLiteral traceName,
+                                                                   KeyValue auto &&...arguments)
+{
+    std::size_t id = createId();
 
-    using IsActive = std::true_type;
-    using AsynchronousTokenType = AsynchronousToken<EnabledCategory, Tracing::IsEnabled>;
-    using FlowTokenType = FlowToken<EnabledCategory, Tracing::IsEnabled>;
-    using TracerType = Tracer<EnabledCategory, std::true_type>;
-    using TokenType = Token<EnabledCategory, Tracing::IsEnabled>;
-    using CategoryFunctionPointer = EnabledCategory &(*) ();
+    begin('b', id, std::move(traceName), 0, IsFlow::No, std::forward<decltype(arguments)>(arguments)...);
 
-    friend AsynchronousTokenType;
-    friend TokenType;
-    friend FlowTokenType;
-    friend TracerType;
+    return {traceName, id, m_self};
+}
 
-    template<typename EventQueue>
-    EnabledCategory(TracerLiteral name,
-                    EventQueue &queue,
-                    EnabledEventQueueWithoutArguments &eventQueueWithoutArguments,
-                    CategoryFunctionPointer self)
-        : m_name{std::move(name)}
-        , m_eventQueue{queue}
-        , m_eventQueueWithoutArguments{eventQueueWithoutArguments}
-        , m_self{self}
-    {
-        static_assert(std::is_same_v<typename EventQueue::IsActive, std::true_type>,
-                      "A active category is not possible with an inactive event queue!");
-        m_idCounter = m_globalIdCounter += 1ULL << 32;
-        m_bindIdCounter = m_globalBindIdCounter += 1ULL << 32;
+inline std::pair<EnabledAsynchronousToken, EnabledFlowToken> EnabledCategory::beginAsynchronousWithFlow(
+    TracerLiteral traceName, KeyValue auto &&...arguments)
+{
+    std::size_t id = createId();
+    std::size_t bindId = createBindId();
+
+    begin('b',
+          id,
+          std::move(traceName),
+          bindId,
+          IsFlow::Out,
+          std::forward<decltype(arguments)>(arguments)...);
+
+    return {std::piecewise_construct,
+            std::forward_as_tuple(PrivateTag{}, traceName, id, m_self),
+            std::forward_as_tuple(PrivateTag{}, traceName, bindId, m_self)};
+}
+
+inline EnabledTracer EnabledCategory::beginDuration(TracerLiteral traceName,
+                                                    KeyValue auto &&...arguments)
+{
+    return {traceName, m_self, std::forward<decltype(arguments)>(arguments)...};
+}
+
+inline EnabledAsynchronousToken EnabledToken::beginAsynchronous(TracerLiteral name,
+                                                                KeyValue auto &&...arguments)
+{
+    if (m_id)
+        m_category().begin('b', m_id, name, 0, IsFlow::No, std::forward<decltype(arguments)>(arguments)...);
+
+    return {std::move(name), m_id, m_category};
+}
+
+inline std::pair<EnabledAsynchronousToken, EnabledFlowToken> EnabledToken::beginAsynchronousWithFlow(
+    TracerLiteral name, KeyValue auto &&...arguments)
+{
+    std::size_t bindId = 0;
+
+    if (m_id) {
+        auto &category = m_category();
+        bindId = category.createBindId();
+        category.begin(
+            'b', m_id, name, bindId, IsFlow::Out, std::forward<decltype(arguments)>(arguments)...);
     }
 
-    EnabledCategory(const EnabledCategory &) = delete;
-    EnabledCategory &operator=(const EnabledCategory &) = delete;
+    return {std::piecewise_construct,
+            std::forward_as_tuple(PrivateTag{}, std::move(name), m_id, m_category),
+            std::forward_as_tuple(PrivateTag{}, std::move(name), bindId, m_category)};
+}
 
-    template<typename... Arguments>
-    [[nodiscard]] AsynchronousTokenType beginAsynchronous(TracerLiteral traceName,
-                                                          Arguments &&...arguments)
-    {
-        std::size_t id = createId();
+inline EnabledTracer EnabledToken::beginDuration(TracerLiteral traceName, KeyValue auto &&...arguments)
+{
+    return {traceName, m_category, std::forward<decltype(arguments)>(arguments)...};
+}
 
-        begin('b', id, std::move(traceName), 0, IsFlow::No, std::forward<Arguments>(arguments)...);
+std::pair<EnabledTracer, EnabledFlowToken> EnabledToken::beginDurationWithFlow(
+    TracerLiteral traceName, KeyValue auto &&...arguments)
+{
+    std::size_t bindId = m_category().createBindId();
 
-        return {traceName, id, m_self};
+    return {std::piecewise_construct,
+            std::forward_as_tuple(PrivateTag{},
+                                  bindId,
+                                  IsFlow::Out,
+                                  traceName,
+                                  m_category,
+                                  std::forward<decltype(arguments)>(arguments)...),
+            std::forward_as_tuple(PrivateTag{}, traceName, bindId, m_category)};
+}
+
+template<typename Category>
+inline DisabledAsynchronousToken Token<Category>::beginAsynchronous(TracerLiteral, KeyValue auto &&...)
+{
+    return {};
+}
+
+template<typename Category>
+inline std::pair<DisabledAsynchronousToken, DisabledFlowToken> Token<Category>::beginAsynchronousWithFlow(
+    TracerLiteral, KeyValue auto &&...)
+{
+    return {};
+}
+
+template<typename Category>
+inline DisabledTracer Token<Category>::beginDuration(TracerLiteral, KeyValue auto &&...)
+{
+    return {};
+}
+
+template<typename Category>
+inline std::pair<DisabledTracer, DisabledFlowToken> Token<Category>::beginDurationWithFlow(
+    TracerLiteral, KeyValue auto &&...)
+{
+    return {};
+}
+
+inline EnabledAsynchronousToken AsynchronousToken<EnabledCategory>::begin(
+    const EnabledFlowToken &flowToken, TracerLiteral name, KeyValue auto &&...arguments)
+{
+    if (m_id)
+        m_category().begin('b',
+                           m_id,
+                           name,
+                           flowToken.bindId(),
+                           IsFlow::In,
+                           std::forward<decltype(arguments)>(arguments)...);
+
+    return {std::move(name), m_id, m_category};
+}
+
+inline EnabledToken EnabledAsynchronousToken::createToken()
+{
+    return {m_id, m_category};
+}
+
+std::pair<EnabledAsynchronousToken, EnabledFlowToken> EnabledAsynchronousToken::beginWithFlow(
+    TracerLiteral name, KeyValue auto &&...arguments)
+{
+    std::size_t bindId = 0;
+
+    if (m_id) {
+        auto &category = m_category();
+        bindId = category.createBindId();
+        category.begin(
+            'b', m_id, name, bindId, IsFlow::Out, std::forward<decltype(arguments)>(arguments)...);
     }
 
-    template<typename... Arguments>
-    [[nodiscard]] std::pair<AsynchronousTokenType, FlowTokenType> beginAsynchronousWithFlow(
-        TracerLiteral traceName, Arguments &&...arguments)
-    {
-        std::size_t id = createId();
-        std::size_t bindId = createBindId();
+    return {std::piecewise_construct,
+            std::forward_as_tuple(PrivateTag{}, std::move(name), m_id, m_category),
+            std::forward_as_tuple(PrivateTag{}, std::move(name), bindId, m_category)};
+}
 
-        begin('b', id, std::move(traceName), bindId, IsFlow::Out, std::forward<Arguments>(arguments)...);
+void EnabledAsynchronousToken::tick(const EnabledFlowToken &flowToken,
+                                    TracerLiteral name,
+                                    KeyValue auto &&...arguments)
+{
+    if (m_id) {
+        m_category().tick('n',
+                          m_id,
+                          std::move(name),
+                          flowToken.bindId(),
+                          IsFlow::In,
+                          std::forward<decltype(arguments)>(arguments)...);
+    }
+}
 
-        return {std::piecewise_construct,
-                std::forward_as_tuple(PrivateTag{}, traceName, id, m_self),
-                std::forward_as_tuple(PrivateTag{}, traceName, bindId, m_self)};
+EnabledFlowToken EnabledAsynchronousToken::tickWithFlow(TracerLiteral name,
+                                                        KeyValue auto &&...arguments)
+{
+    std::size_t bindId = 0;
+
+    if (m_id) {
+        auto &category = m_category();
+        bindId = category.createBindId();
+        category.tick(
+            'n', m_id, name, bindId, IsFlow::Out, std::forward<decltype(arguments)>(arguments)...);
     }
 
-    template<typename... Arguments>
-    [[nodiscard]] TracerType beginDuration(TracerLiteral traceName, Arguments &&...arguments)
-    {
-        return TracerType{traceName, m_self, std::forward<Arguments>(arguments)...};
-    }
+    return {PrivateTag{}, std::move(name), bindId, m_category};
+}
 
-    template<typename... Arguments>
-    [[nodiscard]] std::pair<TracerType, FlowTokenType> beginDurationWithFlow(TracerLiteral traceName,
-                                                                             Arguments &&...arguments)
-    {
-        std::size_t bindId = createBindId();
-
-        return {std::piecewise_construct,
-                std::forward_as_tuple(PrivateTag{},
-                                      bindId,
-                                      IsFlow::Out,
-                                      traceName,
-                                      m_self,
-                                      std::forward<Arguments>(arguments)...),
-                std::forward_as_tuple(PrivateTag{}, traceName, bindId, m_self)};
-    }
-
-    template<typename... Arguments>
-    void threadEvent(TracerLiteral traceName, Arguments &&...arguments)
-    {
-        if (isEnabled == IsEnabled::No)
-            return;
-
-        auto &traceEvent = getTraceEvent(eventQueue(arguments...));
-
-        traceEvent.time = Clock::now();
-        traceEvent.name = std::move(traceName);
-        traceEvent.category = traceName;
-        traceEvent.type = 'i';
-        traceEvent.id = 0;
-        traceEvent.bindId = 0;
-        traceEvent.flow = IsFlow::No;
-        if constexpr (sizeof...(arguments))
-            Internal::setArguments(traceEvent.arguments, std::forward<Arguments>(arguments)...);
-    }
-
-    EnabledEventQueueWithoutArguments &eventQueue() const { return m_eventQueueWithoutArguments; }
-
-    template<typename Arguments>
-    EnabledEventQueueWithArguments &eventQueue(const Arguments &...) const
-    {
-        return m_eventQueue;
-    }
-
-    std::string_view name() const { return m_name; }
-
-    static constexpr bool isActive() { return true; }
-
-    std::size_t createBindId() { return ++m_bindIdCounter; }
-
-    std::size_t createId() { return ++m_idCounter; }
-
-public:
-    IsEnabled isEnabled = IsEnabled::Yes;
-
-private:
-    template<typename... Arguments>
-    void begin(char type,
-               std::size_t id,
-               std::string_view traceName,
-               std::size_t bindId,
-               IsFlow flow,
-               Arguments &&...arguments)
-    {
-        if (isEnabled == IsEnabled::No)
-            return;
-
-        auto &traceEvent = getTraceEvent(eventQueue(arguments...));
-
-        traceEvent.name = std::move(traceName);
-        traceEvent.category = m_name;
-        traceEvent.type = type;
-        traceEvent.id = id;
-        traceEvent.bindId = bindId;
-        traceEvent.flow = flow;
-        if constexpr (sizeof...(arguments))
-            Internal::setArguments(traceEvent.arguments, std::forward<Arguments>(arguments)...);
-        traceEvent.time = Clock::now();
-    }
-
-    template<typename... Arguments>
-    void tick(char type,
-              std::size_t id,
-              std::string_view traceName,
-              std::size_t bindId,
-              IsFlow flow,
-              Arguments &&...arguments)
-    {
-        if (isEnabled == IsEnabled::No)
-            return;
-
-        auto time = Clock::now();
-
-        auto &traceEvent = getTraceEvent(eventQueue(arguments...));
-
-        traceEvent.name = std::move(traceName);
-        traceEvent.category = m_name;
-        traceEvent.time = time;
-        traceEvent.type = type;
-        traceEvent.id = id;
-        traceEvent.bindId = bindId;
-        traceEvent.flow = flow;
-        if constexpr (sizeof...(arguments))
-            Internal::setArguments(traceEvent.arguments, std::forward<Arguments>(arguments)...);
-    }
-
-    template<typename... Arguments>
-    void end(char type, std::size_t id, std::string_view traceName, Arguments &&...arguments)
-    {
-        if (isEnabled == IsEnabled::No)
-            return;
-
-        auto time = Clock::now();
-
-        auto &traceEvent = getTraceEvent(eventQueue(arguments...));
-
-        traceEvent.name = std::move(traceName);
-        traceEvent.category = m_name;
-        traceEvent.time = time;
-        traceEvent.type = type;
-        traceEvent.id = id;
-        traceEvent.bindId = 0;
-        traceEvent.flow = IsFlow::No;
-        if constexpr (sizeof...(arguments))
-            Internal::setArguments(traceEvent.arguments, std::forward<Arguments>(arguments)...);
-    }
-
-    CategoryFunctionPointer self() { return m_self; }
-
-private:
-    std::string_view m_name;
-    EnabledEventQueueWithArguments &m_eventQueue;
-    EnabledEventQueueWithoutArguments &m_eventQueueWithoutArguments;
-    inline static std::atomic<std::size_t> m_globalIdCounter;
-    std::size_t m_idCounter;
-    inline static std::atomic<std::size_t> m_globalBindIdCounter;
-    std::size_t m_bindIdCounter;
-    CategoryFunctionPointer m_self;
-};
+template<typename Category>
+DisabledFlowToken AsynchronousToken<Category>::tickWithFlow(TracerLiteral, KeyValue auto &&...)
+{
+    return {};
+}
 
 } // namespace NanotraceHR
diff --git a/src/libs/sqlite/sqlitebasestatement.h b/src/libs/sqlite/sqlitebasestatement.h
index b5d1ca600f7..169896f9ecc 100644
--- a/src/libs/sqlite/sqlitebasestatement.h
+++ b/src/libs/sqlite/sqlitebasestatement.h
@@ -543,10 +543,10 @@ public:
         using TracerCategory = std::decay_t<decltype(sqliteHighLevelCategory())>;
         StatementImplementation &m_statement;
         const source_location &m_sourceLocation;
-        NanotraceHR::Tracer<TracerCategory, typename TracerCategory::IsActive> tracer{
-            "range",
-            sqliteHighLevelCategory(),
-            NanotraceHR::keyValue("sqlite statement", m_statement.handle())};
+        NanotraceHR::Tracer<TracerCategory> tracer{"range",
+                                                   sqliteHighLevelCategory(),
+                                                   NanotraceHR::keyValue("sqlite statement",
+                                                                         m_statement.handle())};
     };
 
     template<typename ResultType>
diff --git a/src/plugins/qmldesigner/libs/designercore/imagecache/taskqueue.h b/src/plugins/qmldesigner/libs/designercore/imagecache/taskqueue.h
index 6a51267cb7f..b1390e764cd 100644
--- a/src/plugins/qmldesigner/libs/designercore/imagecache/taskqueue.h
+++ b/src/plugins/qmldesigner/libs/designercore/imagecache/taskqueue.h
@@ -25,8 +25,8 @@ public:
 
     ~TaskQueue() { destroy(); }
 
-    template<typename TraceEvent, NanotraceHR::Tracing isEnabled, typename... Arguments>
-    void addTask(NanotraceHR::Token<TraceEvent, isEnabled> traceToken, Arguments &&...arguments)
+    template<typename Category, typename... Arguments>
+    void addTask(NanotraceHR::Token<Category> traceToken, Arguments &&...arguments)
     {
         {
             std::unique_lock lock{m_mutex};
diff --git a/src/plugins/qmldesigner/libs/designercore/include/imagecacheauxiliarydata.h b/src/plugins/qmldesigner/libs/designercore/include/imagecacheauxiliarydata.h
index 3c7a328594a..c46d473b734 100644
--- a/src/plugins/qmldesigner/libs/designercore/include/imagecacheauxiliarydata.h
+++ b/src/plugins/qmldesigner/libs/designercore/include/imagecacheauxiliarydata.h
@@ -20,17 +20,17 @@ namespace ImageCache {
 #ifdef ENABLE_IMAGE_CACHE_TRACING
 
 using Category = NanotraceHR::EnabledCategory;
-using TraceToken = Category::FlowTokenType;
-using FlowToken = Category::FlowTokenType;
-using Token = Category::TokenType;
+using TraceToken = NanotraceHR::EnabledFlowToken;
+using FlowToken = NanotraceHR::EnabledFlowToken;
+using Token = NanotraceHR::EnabledToken;
 [[gnu::pure]] QMLDESIGNERCORE_EXPORT Category &category();
 
 #else
 
 using Category = NanotraceHR::DisabledCategory;
-using TraceToken = Category::FlowTokenType;
-using FlowToken = Category::FlowTokenType;
-using Token = Category::TokenType;
+using TraceToken = NanotraceHR::DisabledFlowToken;
+using FlowToken = NanotraceHR::DisabledFlowToken;
+using Token = NanotraceHR::DisabledToken;
 
 inline Category category()
 {
diff --git a/src/plugins/qmldesigner/libs/designercore/model/internalnode_p.h b/src/plugins/qmldesigner/libs/designercore/model/internalnode_p.h
index fee8341118c..256c783624a 100644
--- a/src/plugins/qmldesigner/libs/designercore/model/internalnode_p.h
+++ b/src/plugins/qmldesigner/libs/designercore/model/internalnode_p.h
@@ -59,7 +59,7 @@ public:
                           int majorVersion,
                           int minorVersion,
                           qint32 internalId,
-                          ModelTracing::Category::FlowTokenType flowTraceToken)
+                          ModelTracing::FlowToken flowTraceToken)
         : typeName(typeName.toByteArray())
         , majorVersion(majorVersion)
         , minorVersion(minorVersion)
diff --git a/src/plugins/qmldesigner/libs/designercore/projectstorage/projectstorageupdater.cpp b/src/plugins/qmldesigner/libs/designercore/projectstorage/projectstorageupdater.cpp
index bea3a65ca71..70ab08c2b26 100644
--- a/src/plugins/qmldesigner/libs/designercore/projectstorage/projectstorageupdater.cpp
+++ b/src/plugins/qmldesigner/libs/designercore/projectstorage/projectstorageupdater.cpp
@@ -30,7 +30,7 @@
 namespace QmlDesigner {
 constexpr auto category = ProjectStorageTracing::projectStorageUpdaterCategory;
 using NanotraceHR::keyValue;
-using Tracer = ProjectStorageTracing::Category::TracerType;
+using Tracer = NanotraceHR::Tracer<ProjectStorageTracing::Category>;
 
 template<typename String>
 void convertToString(String &string, const ProjectStorageUpdater::FileState &state)
diff --git a/src/plugins/qmldesigner/libs/designercore/projectstorage/projectstorageupdater.h b/src/plugins/qmldesigner/libs/designercore/projectstorage/projectstorageupdater.h
index 93430f00795..829dbd07918 100644
--- a/src/plugins/qmldesigner/libs/designercore/projectstorage/projectstorageupdater.h
+++ b/src/plugins/qmldesigner/libs/designercore/projectstorage/projectstorageupdater.h
@@ -168,7 +168,7 @@ private:
                                 NotUpdatedSourceIds &notUpdatedSourceIds,
                                 WatchedSourceIds &WatchedSourceIds,
                                 IsInsideProject isInsideProject,
-                                ProjectStorageTracing::Category::TracerType &tracer);
+                                NanotraceHR::Tracer<ProjectStorageTracing::Category> &tracer);
     void annotationDirectoryChanged(Utils::SmallStringView directoryPath,
                                     DirectoryPathId directoryId,
                                     DirectoryPathId annotationDirectoryId,
diff --git a/src/plugins/qmldesigner/libs/designercore/projectstorage/qmldocumentparser.cpp b/src/plugins/qmldesigner/libs/designercore/projectstorage/qmldocumentparser.cpp
index a5f632d3aaa..2645bae2acf 100644
--- a/src/plugins/qmldesigner/libs/designercore/projectstorage/qmldocumentparser.cpp
+++ b/src/plugins/qmldesigner/libs/designercore/projectstorage/qmldocumentparser.cpp
@@ -26,7 +26,7 @@ namespace QmlDesigner {
 constexpr auto category = ProjectStorageTracing::projectStorageUpdaterCategory;
 using NanotraceHR::keyValue;
 using Storage::IsInsideProject;
-using Tracer = ProjectStorageTracing::Category::TracerType;
+using Tracer = NanotraceHR::Tracer<ProjectStorageTracing::Category>;
 
 namespace QmlDom = QQmlJS::Dom;
 namespace Synchronization = Storage::Synchronization;
diff --git a/src/plugins/qmldesigner/libs/designercore/projectstorage/qmltypesparser.cpp b/src/plugins/qmldesigner/libs/designercore/projectstorage/qmltypesparser.cpp
index 11066e3307f..c7cffc0718e 100644
--- a/src/plugins/qmldesigner/libs/designercore/projectstorage/qmltypesparser.cpp
+++ b/src/plugins/qmldesigner/libs/designercore/projectstorage/qmltypesparser.cpp
@@ -28,7 +28,7 @@ namespace QmlDesigner {
 constexpr auto category = ProjectStorageTracing::projectStorageUpdaterCategory;
 using NanotraceHR::keyValue;
 using Storage::IsInsideProject;
-using Tracer = ProjectStorageTracing::Category::TracerType;
+using Tracer = NanotraceHR::Tracer<ProjectStorageTracing::Category>;
 using Storage::ModuleKind;
 namespace QmlDom = QQmlJS::Dom;
 
diff --git a/src/plugins/qmldesigner/libs/designercore/tracing/qmldesignertracing.cpp b/src/plugins/qmldesigner/libs/designercore/tracing/qmldesignertracing.cpp
index 7ea2a0223b8..dca7d3d751d 100644
--- a/src/plugins/qmldesigner/libs/designercore/tracing/qmldesignertracing.cpp
+++ b/src/plugins/qmldesigner/libs/designercore/tracing/qmldesignertracing.cpp
@@ -9,10 +9,10 @@ namespace QmlDesigner {
 
 using namespace NanotraceHR::Literals;
 
-#ifdef ENABLE_QMLDESIGNER_TRACING
-
 namespace Tracing {
 
+#ifdef ENABLE_QMLDESIGNER_TRACING
+
 namespace {
 
 using TraceFile = NanotraceHR::EnabledTraceFile;
@@ -42,11 +42,13 @@ EventQueueWithoutArguments &eventQueueWithoutArguments()
     return eventQueue;
 }
 
+#endif
+
 } // namespace Tracing
 
 namespace ModelTracing {
 
-#  ifdef ENABLE_MODEL_TRACING
+#ifdef ENABLE_MODEL_TRACING
 
 namespace {
 
@@ -62,13 +64,13 @@ Category &category()
     return category_;
 }
 
-#  endif
+#endif
 
 } // namespace ModelTracing
 
 namespace ProjectStorageTracing {
 
-#  ifdef ENABLE_PROJECT_STORAGE_TRACING
+#ifdef ENABLE_PROJECT_STORAGE_TRACING
 
 Category &projectStorageCategory()
 {
@@ -90,13 +92,13 @@ Category &projectStorageUpdaterCategory()
     return category;
 }
 
-#  endif
+#endif
 
 } // namespace ProjectStorageTracing
 
 namespace SourcePathStorageTracing {
 
-#  ifdef ENABLE_SOURCE_PATH_STORAGE_TRACING
+#ifdef ENABLE_SOURCE_PATH_STORAGE_TRACING
 
 Category &category()
 {
@@ -108,10 +110,8 @@ Category &category()
     return category_;
 }
 
-#  endif
+#endif
 
 } // namespace SourcePathStorageTracing
 
-#endif
-
 } // namespace QmlDesigner
diff --git a/src/plugins/qmldesigner/libs/designercore/tracing/qmldesignertracing.h b/src/plugins/qmldesigner/libs/designercore/tracing/qmldesignertracing.h
index a01883b988b..0c1eeea985f 100644
--- a/src/plugins/qmldesigner/libs/designercore/tracing/qmldesignertracing.h
+++ b/src/plugins/qmldesigner/libs/designercore/tracing/qmldesignertracing.h
@@ -28,14 +28,16 @@ namespace ModelTracing {
 
 using Category = NanotraceHR::EnabledCategory;
 using SourceLocation = Category::SourceLocation;
-using AsynchronousToken = Category::AsynchronousTokenType;
+using AsynchronousToken = NanotraceHR::EnabledAsynchronousToken;
+using FlowToken = NanotraceHR::EnabledFlowToken;
 [[gnu::pure]] QMLDESIGNERCORE_EXPORT Category &category();
 
 #else
 
 using Category = NanotraceHR::DisabledCategory;
 using SourceLocation = Category::SourceLocation;
-using AsynchronousToken = Category::AsynchronousTokenType;
+using AsynchronousToken = NanotraceHR::DisabledAsynchronousToken;
+using FlowToken = NanotraceHR::DisabledFlowToken;
 
 inline Category category()
 {
diff --git a/tests/unit/tests/unittests/imagecache/taskqueue-test.cpp b/tests/unit/tests/unittests/imagecache/taskqueue-test.cpp
index 0762b0d8921..6a80f5d840e 100644
--- a/tests/unit/tests/unittests/imagecache/taskqueue-test.cpp
+++ b/tests/unit/tests/unittests/imagecache/taskqueue-test.cpp
@@ -26,8 +26,6 @@ auto IsTask(Matcher matcher)
 
 class TaskQueue : public testing::Test
 {
-    using Category = NanotraceHR::DisabledCategory;
-
 protected:
     Notification notification;
     Notification waitInThread;
@@ -36,7 +34,7 @@ protected:
     using Queue = QmlDesigner::TaskQueue<Task,
                                          decltype(mockDispatchCallback.AsStdFunction()),
                                          decltype(mockCleanCallback.AsStdFunction())>;
-    NanotraceHR::Token<Category, NanotraceHR::Tracing::IsDisabled> dummyToken;
+    NanotraceHR::DisabledToken dummyToken;
 };
 
 TEST_F(TaskQueue, add_task_dispatches_task)