diff --git a/src/libs/nanotrace/nanotracehr.cpp b/src/libs/nanotrace/nanotracehr.cpp
index 4837cfe9787..e8c9abd7747 100644
--- a/src/libs/nanotrace/nanotracehr.cpp
+++ b/src/libs/nanotrace/nanotracehr.cpp
@@ -24,14 +24,14 @@ void printEvent(std::ostream &out, const TraceEvent &event, qint64 processId, st
 {
     out << R"({"ph":")" << event.type << R"(","name":")" << event.name << R"(","cat":")"
         << event.category << R"(","ts":")"
-        << static_cast<double>(event.time.time_since_epoch().count()) / 1000 << R"(","pid":")"
-        << processId << R"(","tid":")" << threadId << R"(")";
+        << static_cast<double>(event.time.time_since_epoch().count()) / 1000 << R"(","pid":)"
+        << processId << R"(,"tid":)" << threadId;
 
     if (event.type == 'X')
         out << R"(,"dur":)" << static_cast<double>(event.duration.count()) / 1000;
 
     if (event.id != 0)
-        out << R"(,"id":)" << event.id;
+        out << R"(,"id":")" << event.id << R"(")";
 
     if (event.arguments.size())
         out << R"(,"args":)" << event.arguments;
@@ -45,9 +45,9 @@ void writeMetaEvent(TraceFile<true> *file, std::string_view key, std::string_vie
     auto &out = file->out;
 
     if (out.is_open()) {
-        file->out << R"({"name":")" << key << R"(","ph":"M", "pid":")"
-                  << QCoreApplication::applicationPid() << R"(","tid":")"
-                  << std::this_thread::get_id() << R"(","args":{"name":")" << value << R"("}})"
+        file->out << R"({"name":")" << key << R"(","ph":"M", "pid":)"
+                  << QCoreApplication::applicationPid() << R"(,"tid":)"
+                  << std::this_thread::get_id() << R"(,"args":{"name":")" << value << R"("}})"
                   << ",\n";
     }
 }
@@ -194,6 +194,6 @@ void EventQueue<TraceEvent, std::true_type>::flush()
     }
 }
 
-template class NANOTRACE_EXPORT EventQueue<StringViewTraceEvent, std::true_type>;
-template class NANOTRACE_EXPORT EventQueue<StringTraceEvent, std::true_type>;
+template class EventQueue<StringViewTraceEvent, std::true_type>;
+template class EventQueue<StringTraceEvent, std::true_type>;
 } // namespace NanotraceHR
diff --git a/src/libs/nanotrace/nanotracehr.h b/src/libs/nanotrace/nanotracehr.h
index caa7f142d7e..d90f57b9e7f 100644
--- a/src/libs/nanotrace/nanotracehr.h
+++ b/src/libs/nanotrace/nanotracehr.h
@@ -58,6 +58,7 @@ constexpr TracerLiteral operator""_t(const char *text, size_t size)
 } // namespace Literals
 
 using namespace Literals;
+
 template<typename String>
 struct TraceEvent
 {
@@ -142,6 +143,7 @@ public:
     TraceFile &operator=(TraceFile &&) = delete;
 
     ~TraceFile() { finalizeFile(*this); }
+
     std::string filePath;
     std::mutex fileMutex;
     std::future<void> processing;
@@ -257,43 +259,108 @@ TraceEvent &getTraceEvent(EnabledEventQueue<TraceEvent> &eventQueue)
     return eventQueue.currentEvents[eventQueue.eventsIndex++];
 }
 
-template<bool enabled>
+template<typename Category, bool enabled>
 class Token
 {
 public:
     using IsActive = std::false_type;
+    using ArgumentType = typename Category::ArgumentType;
 
-    constexpr std::size_t operator*() const { return 0; }
+    Token() {}
+
+    ~Token() {}
+
+    constexpr Token(const Token &) = delete;
+    constexpr Token &operator=(const Token &) = delete;
+
+    constexpr Token(Token &&other) noexcept = default;
+
+    constexpr Token &operator=(Token &&other) noexcept = default;
 
     constexpr explicit operator bool() const { return false; }
 
     static constexpr bool isActive() { return false; }
+
+    Token begin(ArgumentType) { return Token{}; }
+
+    void tick(ArgumentType) {}
+
+    void end() {}
 };
 
 template<typename TraceEvent, bool enabled>
 class Category;
 
-template<>
-class Token<true>
+template<typename Category>
+class Token<Category, true>
 {
-    friend Category<StringViewTraceEvent, true>;
-    friend Category<StringTraceEvent, true>;
-
-    Token(std::size_t id)
-        : m_id{id}
+    Token(std::string_view name, std::size_t id, Category &category)
+        : m_name{name}
+        , m_id{id}
+        , m_category{&category}
     {}
 
 public:
     using IsActive = std::true_type;
+    using StringType = typename Category::StringType;
+    using ArgumentType = typename Category::ArgumentType;
 
-    constexpr std::size_t operator*() const { return m_id; }
+    friend Category;
+
+    Token() = default;
+
+    Token(const Token &) = delete;
+    Token &operator=(const Token &) = delete;
+
+    Token(Token &&other) noexcept
+        : m_name{other.m_name}
+        , m_id{std::exchange(other.m_id, 0)}
+        , m_category{std::exchange(other.m_category, nullptr)}
+    {}
+
+    Token &operator=(Token &&other) noexcept
+    {
+        if (&other != this) {
+            m_name = other.m_name;
+            m_id = std::exchange(other.m_id, 0);
+            m_category = std::exchange(other.m_category, nullptr);
+        }
+
+        return *this;
+    }
+
+    ~Token() { end(); }
 
     constexpr explicit operator bool() const { return m_id; }
 
     static constexpr bool isActive() { return true; }
 
+    Token begin(ArgumentType name)
+    {
+        if (m_id)
+            m_category->beginAsynchronous(m_id, name);
+
+        return Token{m_name, m_id, *m_category};
+    }
+
+    void tick(ArgumentType name)
+    {
+        if (m_id)
+            m_category->tickAsynchronous(m_id, name);
+    }
+
+    void end()
+    {
+        if (m_id)
+            m_category->endAsynchronous(m_id, m_name);
+
+        m_id = 0;
+    }
+
 private:
-    std::size_t m_id;
+    StringType m_name;
+    std::size_t m_id = 0;
+    Category *m_category = nullptr;
 };
 
 template<typename TraceEvent, bool enabled>
@@ -302,16 +369,15 @@ class Category
 public:
     using IsActive = std::false_type;
     using ArgumentType = typename TraceEvent::ArgumentType;
+    using TokenType = Token<Category, false>;
 
     Category(ArgumentType, EventQueue<TraceEvent, std::true_type> &) {}
 
     Category(ArgumentType, EventQueue<TraceEvent, std::false_type> &) {}
 
-    Token<false> beginAsynchronous(ArgumentType) { return {}; }
+    TokenType beginAsynchronous(ArgumentType) { return {}; }
 
-    void tickAsynchronous(Token<false>, ArgumentType) {}
-
-    void endAsynchronous(Token<false>, ArgumentType) {}
+    void tickAsynchronous(ArgumentType) {}
 
     static constexpr bool isActive() { return false; }
 };
@@ -323,6 +389,9 @@ public:
     using IsActive = std::true_type;
     using ArgumentType = typename TraceEvent::ArgumentType;
     using StringType = typename TraceEvent::StringType;
+    using TokenType = Token<Category, true>;
+
+    friend TokenType;
 
     template<typename EventQueue>
     Category(ArgumentType name, EventQueue &queue)
@@ -334,43 +403,13 @@ public:
         idCounter = globalIdCounter += 1ULL << 32;
     }
 
-    Token<true> beginAsynchronous(ArgumentType traceName)
+    TokenType beginAsynchronous(ArgumentType traceName)
     {
-        auto id = ++idCounter;
-        auto &traceEvent = getTraceEvent(m_eventQueue);
-        traceEvent.name = std::move(traceName);
-        traceEvent.category = m_name;
-        traceEvent.time = Clock::now();
-        traceEvent.type = 'b';
-        traceEvent.id = id;
+        std::size_t id = ++idCounter;
 
-        return id;
-    }
+        beginAsynchronous(id, traceName);
 
-    void tickAsynchronous(Token<true> token, ArgumentType traceName)
-    {
-        if (!token)
-            return;
-
-        auto &traceEvent = getTraceEvent(m_eventQueue);
-        traceEvent.name = std::move(traceName);
-        traceEvent.category = m_name;
-        traceEvent.time = Clock::now();
-        traceEvent.type = 'n';
-        traceEvent.id = *token;
-    }
-
-    void endAsynchronous(Token<true> token, ArgumentType traceName)
-    {
-        if (!token)
-            return;
-
-        auto &traceEvent = getTraceEvent(m_eventQueue);
-        traceEvent.name = std::move(traceName);
-        traceEvent.category = m_name;
-        traceEvent.time = Clock::now();
-        traceEvent.type = 'e';
-        traceEvent.id = *token;
+        return {traceName, id, *this};
     }
 
     EnabledEventQueue<TraceEvent> &eventQueue() const { return m_eventQueue; }
@@ -379,6 +418,39 @@ public:
 
     static constexpr bool isActive() { return true; }
 
+private:
+    void beginAsynchronous(std::size_t id, StringType traceName)
+    {
+        auto &traceEvent = getTraceEvent(m_eventQueue);
+        traceEvent.name = std::move(traceName);
+        traceEvent.category = m_name;
+        traceEvent.type = 'b';
+        traceEvent.id = id;
+        traceEvent.time = Clock::now();
+    }
+
+    void tickAsynchronous(std::size_t id, StringType traceName)
+    {
+        auto time = Clock::now();
+        auto &traceEvent = getTraceEvent(m_eventQueue);
+        traceEvent.name = std::move(traceName);
+        traceEvent.category = m_name;
+        traceEvent.time = time;
+        traceEvent.type = 'n';
+        traceEvent.id = id;
+    }
+
+    void endAsynchronous(std::size_t id, StringType traceName)
+    {
+        auto time = Clock::now();
+        auto &traceEvent = getTraceEvent(m_eventQueue);
+        traceEvent.name = std::move(traceName);
+        traceEvent.category = m_name;
+        traceEvent.time = time;
+        traceEvent.type = 'e';
+        traceEvent.id = id;
+    }
+
 private:
     StringType m_name;
     EnabledEventQueue<TraceEvent> &m_eventQueue;
diff --git a/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagecache.cpp b/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagecache.cpp
index 4da56f18eae..19fba2e15c5 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagecache.cpp
+++ b/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagecache.cpp
@@ -15,8 +15,9 @@ namespace QmlDesigner {
 
 using namespace NanotraceHR::Literals;
 
+namespace ImageCache {
 namespace {
-using TraceFile = NanotraceHR::TraceFile<imageCacheTracingIsEnabled()>;
+using TraceFile = NanotraceHR::TraceFile<ImageCache::tracingIsEnabled()>;
 
 TraceFile traceFile{"qml_designer.json"};
 
@@ -24,14 +25,14 @@ thread_local auto eventQueueData = NanotraceHR::makeEventQueueData<NanotraceHR::
     traceFile);
 thread_local NanotraceHR::EventQueue eventQueue = eventQueueData.createEventQueue();
 
-thread_local NanotraceHR::StringViewCategory<imageCacheTracingIsEnabled()> category{"image cache"_t,
-                                                                                    eventQueue};
+thread_local Category category_{"image cache"_t, eventQueue};
 } // namespace
 
-NanotraceHR::StringViewCategory<imageCacheTracingIsEnabled()> &imageCacheCategory()
+Category &category()
 {
-    return category;
+    return category_;
 }
+} // namespace ImageCache
 
 AsynchronousImageCache::AsynchronousImageCache(ImageCacheStorageInterface &storage,
                                                ImageCacheGeneratorInterface &generator,
@@ -52,7 +53,7 @@ void AsynchronousImageCache::request(Utils::SmallStringView name,
                                      ImageCache::CaptureImageCallback captureCallback,
                                      ImageCache::AbortCallback abortCallback,
                                      ImageCache::AuxiliaryData auxiliaryData,
-                                     ImageCacheTraceToken traceToken,
+                                     ImageCache::TraceToken traceToken,
                                      ImageCacheStorageInterface &storage,
                                      ImageCacheGeneratorInterface &generator,
                                      TimeStampProviderInterface &timeStampProvider)
@@ -62,11 +63,7 @@ void AsynchronousImageCache::request(Utils::SmallStringView name,
 
     const auto timeStamp = timeStampProvider.timeStamp(name);
     auto requestImageFromStorage = [&](RequestType requestType) {
-        imageCacheCategory().tickAsynchronous(traceToken, "start fetching image from storage"_t);
-
-        QScopeGuard finally{[=] {
-            imageCacheCategory().tickAsynchronous(traceToken, "end fetching image from storage"_t);
-        }};
+        auto storageTraceToken = traceToken.begin("fetching image from storage"_t);
         switch (requestType) {
         case RequestType::Image:
             return storage.fetchImage(id, timeStamp);
@@ -80,22 +77,24 @@ void AsynchronousImageCache::request(Utils::SmallStringView name,
 
         return storage.fetchImage(id, timeStamp);
     };
+
     const auto entry = requestImageFromStorage(requestType);
 
     if (entry) {
         if (entry->isNull()) {
+            traceToken.tick("there was an null image in storage"_t);
             abortCallback(ImageCache::AbortReason::Failed);
-            imageCacheCategory().endAsynchronous(traceToken,
-                                                 "abort image request because entry in database is null"_t);
         } else {
             captureCallback(*entry);
-            imageCacheCategory().endAsynchronous(traceToken, "image request delivered from storage"_t);
         }
+        traceToken.end();
     } else {
-        auto callback =
+        auto imageGeneratedCallback =
             [captureCallback = std::move(captureCallback),
-             requestType,
-             traceToken](const QImage &image, const QImage &midSizeImage, const QImage &smallImage) {
+             requestType](const QImage &image,
+                          const QImage &midSizeImage,
+                          const QImage &smallImage,
+                          ImageCache::TraceToken traceToken) {
                 auto selectImage = [](RequestType requestType,
                                       const QImage &image,
                                       const QImage &midSizeImage,
@@ -113,19 +112,27 @@ void AsynchronousImageCache::request(Utils::SmallStringView name,
 
                     return image;
                 };
+                traceToken.end();
                 captureCallback(selectImage(requestType, image, midSizeImage, smallImage));
-                imageCacheCategory().endAsynchronous(traceToken,
-                                                     "image request delivered from generation"_t);
             };
 
-        imageCacheCategory().tickAsynchronous(traceToken, "request image generation"_t);
+        auto imageGenerationAbortedCallback =
+            [abortCallback = std::move(abortCallback)](ImageCache::AbortReason reason,
+                                                       ImageCache::TraceToken traceToken) {
+                traceToken.tick("image could not be created"_t);
+                traceToken.end();
+                abortCallback(reason);
+            };
+
+        traceToken.tick("call the generator"_t);
 
         generator.generateImage(name,
                                 extraId,
                                 timeStamp,
-                                std::move(callback),
-                                std::move(abortCallback),
-                                std::move(auxiliaryData));
+                                std::move(imageGeneratedCallback),
+                                std::move(imageGenerationAbortedCallback),
+                                std::move(auxiliaryData),
+                                std::move(traceToken));
     }
 }
 
@@ -135,7 +142,7 @@ void AsynchronousImageCache::requestImage(Utils::SmallStringView name,
                                           Utils::SmallStringView extraId,
                                           ImageCache::AuxiliaryData auxiliaryData)
 {
-    auto traceToken = imageCacheCategory().beginAsynchronous(
+    auto traceToken = ImageCache::category().beginAsynchronous(
         "request image in asynchornous image cache"_t);
     m_taskQueue.addTask(std::move(name),
                         std::move(extraId),
@@ -143,7 +150,7 @@ void AsynchronousImageCache::requestImage(Utils::SmallStringView name,
                         std::move(abortCallback),
                         std::move(auxiliaryData),
                         RequestType::Image,
-                        traceToken);
+                        std ::move(traceToken));
 }
 
 void AsynchronousImageCache::requestMidSizeImage(Utils::SmallStringView name,
@@ -152,7 +159,7 @@ void AsynchronousImageCache::requestMidSizeImage(Utils::SmallStringView name,
                                                  Utils::SmallStringView extraId,
                                                  ImageCache::AuxiliaryData auxiliaryData)
 {
-    auto traceToken = imageCacheCategory().beginAsynchronous(
+    auto traceToken = ImageCache::category().beginAsynchronous(
         "request mid size image in asynchornous image cache"_t);
     m_taskQueue.addTask(std::move(name),
                         std::move(extraId),
@@ -160,7 +167,7 @@ void AsynchronousImageCache::requestMidSizeImage(Utils::SmallStringView name,
                         std::move(abortCallback),
                         std::move(auxiliaryData),
                         RequestType::MidSizeImage,
-                        traceToken);
+                        std ::move(traceToken));
 }
 
 void AsynchronousImageCache::requestSmallImage(Utils::SmallStringView name,
@@ -169,7 +176,7 @@ void AsynchronousImageCache::requestSmallImage(Utils::SmallStringView name,
                                                Utils::SmallStringView extraId,
                                                ImageCache::AuxiliaryData auxiliaryData)
 {
-    auto traceToken = imageCacheCategory().beginAsynchronous(
+    auto traceToken = ImageCache::category().beginAsynchronous(
         "request small size image in asynchornous image cache"_t);
     m_taskQueue.addTask(std::move(name),
                         std::move(extraId),
@@ -177,7 +184,7 @@ void AsynchronousImageCache::requestSmallImage(Utils::SmallStringView name,
                         std::move(abortCallback),
                         std::move(auxiliaryData),
                         RequestType::SmallImage,
-                        traceToken);
+                        std ::move(traceToken));
 }
 
 void AsynchronousImageCache::clean()
@@ -186,4 +193,31 @@ void AsynchronousImageCache::clean()
     m_taskQueue.clean();
 }
 
+void AsynchronousImageCache::Dispatch::operator()(Entry &entry)
+{
+    using namespace NanotraceHR::Literals;
+
+    request(entry.name,
+            entry.extraId,
+            entry.requestType,
+            std::move(entry.captureCallback),
+            std::move(entry.abortCallback),
+            std::move(entry.auxiliaryData),
+            std::move(entry.traceToken),
+            storage,
+            generator,
+            timeStampProvider);
+}
+
+void AsynchronousImageCache::Clean::operator()(Entry &entry)
+{
+    using namespace NanotraceHR::Literals;
+
+    entry.traceToken.tick("cleaning up in the cache"_t);
+
+    entry.abortCallback(ImageCache::AbortReason::Abort);
+
+    entry.traceToken.end();
+}
+
 } // namespace QmlDesigner
diff --git a/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagefactory.cpp b/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagefactory.cpp
index a711f1ad7d8..9ed3a34f7d6 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagefactory.cpp
+++ b/src/plugins/qmldesigner/designercore/imagecache/asynchronousimagefactory.cpp
@@ -46,7 +46,10 @@ void AsynchronousImageFactory::request(Utils::SmallStringView name,
     if (currentModifiedTime < (storageModifiedTime + pause))
         return;
 
-    auto capture = [&](const QImage &image, const QImage &midSizeImage, const QImage &smallImage) {
+    auto capture = [&](const QImage &image,
+                       const QImage &midSizeImage,
+                       const QImage &smallImage,
+                       ImageCache::TraceToken) {
         storage.storeImage(id, currentModifiedTime, image, midSizeImage, smallImage);
     };
 
@@ -54,7 +57,7 @@ void AsynchronousImageFactory::request(Utils::SmallStringView name,
                     extraId,
                     std::move(auxiliaryData),
                     std::move(capture),
-                    ImageCache::AbortCallback{});
+                    ImageCache::InternalAbortCallback{});
 }
 
 void AsynchronousImageFactory::clean()
diff --git a/src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.cpp b/src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.cpp
index 4530290fbe3..6b37940c072 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.cpp
+++ b/src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.cpp
@@ -73,8 +73,12 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
                                 Utils::SmallStringView state,
                                 const ImageCache::AuxiliaryData &auxiliaryData,
                                 CaptureCallback captureCallback,
-                                AbortCallback abortCallback)
+                                AbortCallback abortCallback,
+                                ImageCache::TraceToken traceToken)
 {
+    using namespace NanotraceHR::Literals;
+    auto collectorTraceToken = traceToken.begin("generate image in standard collector"_t);
+
     RewriterView rewriterView{m_externalDependencies, RewriterView::Amend};
     NodeInstanceView nodeInstanceView{m_connectionManager, m_externalDependencies};
     nodeInstanceView.setCaptureImageMinimumAndMaximumSize(captureImageMinimumSize,
@@ -101,7 +105,7 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
     if (!rewriterView.errors().isEmpty() || (!rewriterView.rootModelNode().metaInfo().isGraphicalItem()
                                         && !is3DRoot)) {
         if (abortCallback)
-            abortCallback(ImageCache::AbortReason::Failed);
+            abortCallback(ImageCache::AbortReason::Failed, std::move(traceToken));
         return;
     }
 
@@ -117,21 +121,17 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
     if (stateNode.isValid())
         rewriterView.setCurrentStateNode(stateNode);
 
-    auto callback = [=, captureCallback = std::move(captureCallback)](const QImage &image) {
-        if (nullImageHandling == ImageCacheCollectorNullImageHandling::CaptureNullImage
-            || !image.isNull()) {
-            QImage midSizeImage = scaleImage(image, QSize{300, 300});
-            QImage smallImage = scaleImage(midSizeImage, QSize{96, 96});
-            captureCallback(image, midSizeImage, smallImage);
-        }
-    };
+    QImage captureImage;
+
+    auto callback = [&](const QImage &image) { captureImage = image; };
 
     if (!m_target)
         return;
 
     nodeInstanceView.setTarget(m_target.data());
     m_connectionManager.setCallback(std::move(callback));
-    nodeInstanceView.setCrashCallback([=] { abortCallback(ImageCache::AbortReason::Failed); });
+    bool isCrashed = false;
+    nodeInstanceView.setCrashCallback([&] { isCrashed = true; });
     model->setNodeInstanceView(&nodeInstanceView);
 
     bool capturedDataArrived = m_connectionManager.waitForCapturedData();
@@ -142,8 +142,18 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
     model->setNodeInstanceView({});
     model->setRewriterView({});
 
+    if (isCrashed)
+        abortCallback(ImageCache::AbortReason::Failed, std::move(traceToken));
+
     if (!capturedDataArrived && abortCallback)
-        abortCallback(ImageCache::AbortReason::Failed);
+        abortCallback(ImageCache::AbortReason::Failed, std::move(traceToken));
+
+    if (nullImageHandling == ImageCacheCollectorNullImageHandling::CaptureNullImage
+        || !captureImage.isNull()) {
+        QImage midSizeImage = scaleImage(captureImage, QSize{300, 300});
+        QImage smallImage = scaleImage(midSizeImage, QSize{96, 96});
+        captureCallback(captureImage, midSizeImage, smallImage, std::move(traceToken));
+    }
 }
 
 ImageCacheCollectorInterface::ImageTuple ImageCacheCollector::createImage(
diff --git a/src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.h b/src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.h
index 87ebedba048..e5230ea2b23 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.h
+++ b/src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.h
@@ -41,7 +41,8 @@ public:
                Utils::SmallStringView state,
                const ImageCache::AuxiliaryData &auxiliaryData,
                CaptureCallback captureCallback,
-               AbortCallback abortCallback) override;
+               AbortCallback abortCallback,
+               ImageCache::TraceToken traceToken) override;
 
     ImageTuple createImage(Utils::SmallStringView filePath,
                            Utils::SmallStringView state,
diff --git a/src/plugins/qmldesigner/designercore/imagecache/imagecachecollectorinterface.h b/src/plugins/qmldesigner/designercore/imagecache/imagecachecollectorinterface.h
index 057ab6f03e5..e6c70f31939 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/imagecachecollectorinterface.h
+++ b/src/plugins/qmldesigner/designercore/imagecache/imagecachecollectorinterface.h
@@ -15,14 +15,15 @@ class ImageCacheCollectorInterface
 {
 public:
     using CaptureCallback = ImageCache::CaptureImageWithScaledImagesCallback;
-    using AbortCallback = ImageCache::AbortCallback;
+    using AbortCallback = ImageCache::InternalAbortCallback;
     using ImageTuple = std::tuple<QImage, QImage, QImage>;
 
     virtual void start(Utils::SmallStringView filePath,
                        Utils::SmallStringView extraId,
                        const ImageCache::AuxiliaryData &auxiliaryData,
                        CaptureCallback captureCallback,
-                       AbortCallback abortCallback)
+                       AbortCallback abortCallback,
+                       ImageCache::TraceToken traceToken = {})
         = 0;
 
     virtual ImageTuple createImage(Utils::SmallStringView filePath,
diff --git a/src/plugins/qmldesigner/designercore/imagecache/imagecachedispatchcollector.h b/src/plugins/qmldesigner/designercore/imagecache/imagecachedispatchcollector.h
index 274cf72ad67..59cd77505ad 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/imagecachedispatchcollector.h
+++ b/src/plugins/qmldesigner/designercore/imagecache/imagecachedispatchcollector.h
@@ -12,13 +12,15 @@ class ImageCacheDispatchCollector final : public ImageCacheCollectorInterface
 {
 public:
     ImageCacheDispatchCollector(CollectorEntries collectors)
-        : m_collectors{std::move(collectors)} {};
+        : m_collectors{std::move(collectors)}
+    {}
 
     void start(Utils::SmallStringView filePath,
                Utils::SmallStringView state,
                const ImageCache::AuxiliaryData &auxiliaryData,
                CaptureCallback captureCallback,
-               AbortCallback abortCallback) override
+               AbortCallback abortCallback,
+               ImageCache::TraceToken traceToken) override
     {
         std::apply(
             [&](const auto &...collectors) {
@@ -27,6 +29,7 @@ public:
                               auxiliaryData,
                               std::move(captureCallback),
                               std::move(abortCallback),
+                              std::move(traceToken),
                               collectors...);
             },
             m_collectors);
@@ -61,6 +64,7 @@ private:
                        const ImageCache::AuxiliaryData &auxiliaryData,
                        CaptureCallback captureCallback,
                        AbortCallback abortCallback,
+                       ImageCache::TraceToken traceToken,
                        const Collector &collector,
                        const Collectors &...collectors)
     {
@@ -69,13 +73,15 @@ private:
                                     state,
                                     auxiliaryData,
                                     std::move(captureCallback),
-                                    std::move(abortCallback));
+                                    std::move(abortCallback),
+                                    std::move(traceToken));
         } else {
             dispatchStart(filePath,
                           state,
                           auxiliaryData,
                           std::move(captureCallback),
                           std::move(abortCallback),
+                          std::move(traceToken),
                           collectors...);
         }
     }
@@ -84,10 +90,11 @@ private:
                        Utils::SmallStringView,
                        const ImageCache::AuxiliaryData &,
                        CaptureCallback,
-                       AbortCallback abortCallback)
+                       AbortCallback abortCallback,
+                       ImageCache::TraceToken traceToken)
     {
         qWarning() << "ImageCacheDispatchCollector: cannot handle file type.";
-        abortCallback(ImageCache::AbortReason::Failed);
+        abortCallback(ImageCache::AbortReason::Failed, std::move(traceToken));
     }
 
     template<typename Collector, typename... Collectors>
diff --git a/src/plugins/qmldesigner/designercore/imagecache/imagecachefontcollector.cpp b/src/plugins/qmldesigner/designercore/imagecache/imagecachefontcollector.cpp
index 2e0c4813ec8..5c10e2e2ce4 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/imagecachefontcollector.cpp
+++ b/src/plugins/qmldesigner/designercore/imagecache/imagecachefontcollector.cpp
@@ -94,7 +94,8 @@ void ImageCacheFontCollector::start(Utils::SmallStringView name,
                                     Utils::SmallStringView,
                                     const ImageCache::AuxiliaryData &auxiliaryDataValue,
                                     CaptureCallback captureCallback,
-                                    AbortCallback abortCallback)
+                                    AbortCallback abortCallback,
+                                    ImageCache::TraceToken traceToken)
 {
     QFont font;
     if (resolveFont(QString(name), font) >= 0) {
@@ -107,12 +108,12 @@ void ImageCacheFontCollector::start(Utils::SmallStringView name,
             QImage image = createFontImage(text, textColor, font, size);
 
             if (!image.isNull()) {
-                captureCallback(std::move(image), {}, {});
+                captureCallback(std::move(image), {}, {}, std::move(traceToken));
                 return;
             }
         }
     }
-    abortCallback(ImageCache::AbortReason::Failed);
+    abortCallback(ImageCache::AbortReason::Failed, std::move(traceToken));
 }
 
 ImageCacheCollectorInterface::ImageTuple ImageCacheFontCollector::createImage(
diff --git a/src/plugins/qmldesigner/designercore/imagecache/imagecachefontcollector.h b/src/plugins/qmldesigner/designercore/imagecache/imagecachefontcollector.h
index ff7f624e223..104e48e9b2f 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/imagecachefontcollector.h
+++ b/src/plugins/qmldesigner/designercore/imagecache/imagecachefontcollector.h
@@ -18,7 +18,8 @@ public:
                Utils::SmallStringView extraId,
                const ImageCache::AuxiliaryData &auxiliaryData,
                CaptureCallback captureCallback,
-               AbortCallback abortCallback) override;
+               AbortCallback abortCallback,
+               ImageCache::TraceToken traceToken) override;
 
     ImageTuple createImage(Utils::SmallStringView filePath,
                            Utils::SmallStringView extraId,
diff --git a/src/plugins/qmldesigner/designercore/imagecache/imagecachegenerator.cpp b/src/plugins/qmldesigner/designercore/imagecache/imagecachegenerator.cpp
index c61327ee087..93ddbd38015 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/imagecachegenerator.cpp
+++ b/src/plugins/qmldesigner/designercore/imagecache/imagecachegenerator.cpp
@@ -42,8 +42,9 @@ void ImageCacheGenerator::generateImage(Utils::SmallStringView name,
                                         Utils::SmallStringView extraId,
                                         Sqlite::TimeStamp timeStamp,
                                         ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback,
-                                        ImageCache::AbortCallback &&abortCallback,
-                                        ImageCache::AuxiliaryData &&auxiliaryData)
+                                        ImageCache::InternalAbortCallback &&abortCallback,
+                                        ImageCache::AuxiliaryData &&auxiliaryData,
+                                        ImageCache::TraceToken traceToken)
 {
     {
         std::lock_guard lock{m_mutex};
@@ -64,7 +65,8 @@ void ImageCacheGenerator::generateImage(Utils::SmallStringView name,
                                  std::move(auxiliaryData),
                                  timeStamp,
                                  std::move(captureCallback),
-                                 std::move(abortCallback));
+                                 std::move(abortCallback),
+                                 std::move(traceToken));
         }
     }
 
@@ -89,9 +91,14 @@ void callCallbacks(const Callbacks &callbacks, Argument &&...arguments)
 
 void ImageCacheGenerator::clean()
 {
+    using namespace NanotraceHR::Literals;
+
     std::lock_guard lock{m_mutex};
-    for (Task &task : m_tasks)
-        callCallbacks(task.abortCallbacks, ImageCache::AbortReason::Abort);
+    for (Task &task : m_tasks) {
+        task.traceToken.tick("cleaning up in the generator"_t);
+        task.traceToken.end();
+        callCallbacks(task.abortCallbacks, ImageCache::AbortReason::Abort, std::move(task.traceToken));
+    }
     m_tasks.clear();
 }
 
@@ -124,27 +131,43 @@ void ImageCacheGenerator::startGeneration()
             task.filePath,
             task.extraId,
             std::move(task.auxiliaryData),
-            [this, task](const QImage &image, const QImage &midSizeImage, const QImage &smallImage) {
+            [this,
+             abortCallbacks = task.abortCallbacks,
+             captureCallbacks = std::move(task.captureCallbacks),
+             filePath = task.filePath,
+             extraId = task.extraId,
+             timeStamp = task.timeStamp](const QImage &image,
+                                         const QImage &midSizeImage,
+                                         const QImage &smallImage,
+                                         ImageCache::TraceToken traceToken) {
                 if (image.isNull() && midSizeImage.isNull() && smallImage.isNull())
-                    callCallbacks(task.abortCallbacks, ImageCache::AbortReason::Failed);
+                    callCallbacks(abortCallbacks,
+                                  ImageCache::AbortReason::Failed,
+                                  std::move(traceToken));
                 else
-                    callCallbacks(task.captureCallbacks, image, midSizeImage, smallImage);
+                    callCallbacks(captureCallbacks,
+                                  image,
+                                  midSizeImage,
+                                  smallImage,
+                                  std::move(traceToken));
 
-                m_storage.storeImage(createId(task.filePath, task.extraId),
-                                     task.timeStamp,
+                m_storage.storeImage(createId(filePath, extraId),
+                                     timeStamp,
                                      image,
                                      midSizeImage,
                                      smallImage);
             },
-            [this, task](ImageCache::AbortReason abortReason) {
-                callCallbacks(task.abortCallbacks, abortReason);
+            [this,
+             abortCallbacks = task.abortCallbacks,
+             filePath = task.filePath,
+             extraId = task.extraId,
+             timeStamp = task.timeStamp](ImageCache::AbortReason abortReason,
+                                         ImageCache::TraceToken traceToken) {
+                callCallbacks(abortCallbacks, abortReason, std::move(traceToken));
                 if (abortReason != ImageCache::AbortReason::Abort)
-                    m_storage.storeImage(createId(task.filePath, task.extraId),
-                                         task.timeStamp,
-                                         {},
-                                         {},
-                                         {});
-            });
+                    m_storage.storeImage(createId(filePath, extraId), timeStamp, {}, {}, {});
+            },
+            std::move(task.traceToken));
 
         std::lock_guard lock{m_mutex};
         if (m_tasks.empty())
diff --git a/src/plugins/qmldesigner/designercore/imagecache/imagecachegenerator.h b/src/plugins/qmldesigner/designercore/imagecache/imagecachegenerator.h
index cfac1e0ef05..e89e25bcb29 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/imagecachegenerator.h
+++ b/src/plugins/qmldesigner/designercore/imagecache/imagecachegenerator.h
@@ -34,8 +34,9 @@ public:
                        Utils::SmallStringView extraId,
                        Sqlite::TimeStamp timeStamp,
                        ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback,
-                       ImageCache::AbortCallback &&abortCallback,
-                       ImageCache::AuxiliaryData &&auxiliaryData) override;
+                       ImageCache::InternalAbortCallback &&abortCallback,
+                       ImageCache::AuxiliaryData &&auxiliaryData,
+                       ImageCache::TraceToken traceToken = {}) override;
     void clean() override;
 
     void waitForFinished() override;
@@ -44,26 +45,30 @@ private:
     struct Task
     {
         Task() = default;
+
         Task(Utils::SmallStringView filePath,
              Utils::SmallStringView extraId,
              ImageCache::AuxiliaryData &&auxiliaryData,
              Sqlite::TimeStamp timeStamp,
              ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback,
-             ImageCache::AbortCallback &&abortCallback)
+             ImageCache::InternalAbortCallback &&abortCallback,
+             ImageCache::TraceToken traceToken)
             : filePath(filePath)
             , extraId(std::move(extraId))
             , auxiliaryData(std::move(auxiliaryData))
             , captureCallbacks({std::move(captureCallback)})
             , abortCallbacks({std::move(abortCallback)})
             , timeStamp(timeStamp)
+            , traceToken{std::move(traceToken)}
         {}
 
         Utils::PathString filePath;
         Utils::SmallString extraId;
         ImageCache::AuxiliaryData auxiliaryData;
         std::vector<ImageCache::CaptureImageWithScaledImagesCallback> captureCallbacks;
-        std::vector<ImageCache::AbortCallback> abortCallbacks;
+        std::vector<ImageCache::InternalAbortCallback> abortCallbacks;
         Sqlite::TimeStamp timeStamp;
+        ImageCache::TraceToken traceToken;
     };
 
     void startGeneration();
@@ -71,7 +76,6 @@ private:
     [[nodiscard]] std::tuple<std::unique_lock<std::mutex>, bool> waitForEntries();
     void stopThread();
 
-private:
 private:
     std::unique_ptr<QThread> m_backgroundThread;
     mutable std::mutex m_mutex;
diff --git a/src/plugins/qmldesigner/designercore/imagecache/imagecachegeneratorinterface.h b/src/plugins/qmldesigner/designercore/imagecache/imagecachegeneratorinterface.h
index d18f0def323..3708a204d63 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/imagecachegeneratorinterface.h
+++ b/src/plugins/qmldesigner/designercore/imagecache/imagecachegeneratorinterface.h
@@ -18,8 +18,9 @@ public:
                                Utils::SmallStringView extraId,
                                Sqlite::TimeStamp timeStamp,
                                ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback,
-                               ImageCache::AbortCallback &&abortCallback,
-                               ImageCache::AuxiliaryData &&auxiliaryData)
+                               ImageCache::InternalAbortCallback &&abortCallback,
+                               ImageCache::AuxiliaryData &&auxiliaryData,
+                               ImageCache::TraceToken = {})
         = 0;
 
     virtual void clean() = 0;
diff --git a/src/plugins/qmldesigner/designercore/imagecache/meshimagecachecollector.cpp b/src/plugins/qmldesigner/designercore/imagecache/meshimagecachecollector.cpp
index 2063de8f3aa..726c049555d 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/meshimagecachecollector.cpp
+++ b/src/plugins/qmldesigner/designercore/imagecache/meshimagecachecollector.cpp
@@ -30,7 +30,8 @@ void MeshImageCacheCollector::start(Utils::SmallStringView name,
                                     Utils::SmallStringView state,
                                     const ImageCache::AuxiliaryData &auxiliaryData,
                                     CaptureCallback captureCallback,
-                                    AbortCallback abortCallback)
+                                    AbortCallback abortCallback,
+                                    ImageCache::TraceToken traceToken)
 {
     QTemporaryFile file(QDir::tempPath() + "/mesh-XXXXXX.qml");
     if (file.open()) {
@@ -63,7 +64,8 @@ void MeshImageCacheCollector::start(Utils::SmallStringView name,
 
     Utils::PathString path{file.fileName()};
 
-    m_imageCacheCollector.start(path, state, auxiliaryData, captureCallback, abortCallback);
+    m_imageCacheCollector
+        .start(path, state, auxiliaryData, captureCallback, abortCallback, std::move(traceToken));
 }
 
 ImageCacheCollectorInterface::ImageTuple MeshImageCacheCollector::createImage(
diff --git a/src/plugins/qmldesigner/designercore/imagecache/meshimagecachecollector.h b/src/plugins/qmldesigner/designercore/imagecache/meshimagecachecollector.h
index 17b1a412bc1..067c9033608 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/meshimagecachecollector.h
+++ b/src/plugins/qmldesigner/designercore/imagecache/meshimagecachecollector.h
@@ -29,7 +29,8 @@ public:
                Utils::SmallStringView state,
                const ImageCache::AuxiliaryData &auxiliaryData,
                CaptureCallback captureCallback,
-               AbortCallback abortCallback) override;
+               AbortCallback abortCallback,
+               ImageCache::TraceToken traceToken = {}) override;
 
     ImageTuple createImage(Utils::SmallStringView filePath,
                            Utils::SmallStringView state,
diff --git a/src/plugins/qmldesigner/designercore/imagecache/taskqueue.h b/src/plugins/qmldesigner/designercore/imagecache/taskqueue.h
index 67b0904eed0..36c2d6bb7a5 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/taskqueue.h
+++ b/src/plugins/qmldesigner/designercore/imagecache/taskqueue.h
@@ -83,7 +83,7 @@ private:
         Task task = std::move(m_tasks.front());
         m_tasks.pop_front();
 
-        return {task};
+        return {std::move(task)};
     }
 
     void ensureThreadIsRunning()
diff --git a/src/plugins/qmldesigner/designercore/imagecache/textureimagecachecollector.cpp b/src/plugins/qmldesigner/designercore/imagecache/textureimagecachecollector.cpp
index af310ae6e7d..9ec83c0e5b3 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/textureimagecachecollector.cpp
+++ b/src/plugins/qmldesigner/designercore/imagecache/textureimagecachecollector.cpp
@@ -17,7 +17,8 @@ void TextureImageCacheCollector::start(Utils::SmallStringView name,
                                        Utils::SmallStringView,
                                        const ImageCache::AuxiliaryData &,
                                        CaptureCallback captureCallback,
-                                       AbortCallback abortCallback)
+                                       AbortCallback abortCallback,
+                                       ImageCache::TraceToken traceToken)
 {
     Asset asset {QString(name)};
     QImage image;
@@ -31,11 +32,11 @@ void TextureImageCacheCollector::start(Utils::SmallStringView name,
     }
 
     if (image.isNull())
-        abortCallback(ImageCache::AbortReason::Failed);
+        abortCallback(ImageCache::AbortReason::Failed, std::move(traceToken));
     else
         image = image.scaled(QSize{300, 300}, Qt::KeepAspectRatio);
 
-    captureCallback({}, image, {});
+    captureCallback({}, image, {}, std::move(traceToken));
 }
 
 ImageCacheCollectorInterface::ImageTuple TextureImageCacheCollector::createImage(
diff --git a/src/plugins/qmldesigner/designercore/imagecache/textureimagecachecollector.h b/src/plugins/qmldesigner/designercore/imagecache/textureimagecachecollector.h
index 67876d7641a..fceb06100bc 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/textureimagecachecollector.h
+++ b/src/plugins/qmldesigner/designercore/imagecache/textureimagecachecollector.h
@@ -17,7 +17,8 @@ public:
                Utils::SmallStringView state,
                const ImageCache::AuxiliaryData &auxiliaryData,
                CaptureCallback captureCallback,
-               AbortCallback abortCallback) override;
+               AbortCallback abortCallback,
+               ImageCache::TraceToken traceToken = {}) override;
 
     ImageTuple createImage(Utils::SmallStringView filePath,
                            Utils::SmallStringView state,
diff --git a/src/plugins/qmldesigner/designercore/include/asynchronousimagecache.h b/src/plugins/qmldesigner/designercore/include/asynchronousimagecache.h
index fc03cccce8e..b1948f566bd 100644
--- a/src/plugins/qmldesigner/designercore/include/asynchronousimagecache.h
+++ b/src/plugins/qmldesigner/designercore/include/asynchronousimagecache.h
@@ -3,10 +3,11 @@
 
 #pragma once
 
+#include <qmldesignercorelib_exports.h>
+
 #include "asynchronousimagecacheinterface.h"
 
 #include <imagecache/taskqueue.h>
-#include <nanotrace/nanotracehr.h>
 
 #include <condition_variable>
 #include <deque>
@@ -22,19 +23,6 @@ class ImageCacheStorageInterface;
 class ImageCacheGeneratorInterface;
 class ImageCacheCollectorInterface;
 
-constexpr bool imageCacheTracingIsEnabled()
-{
-#ifdef ENABLE_IMAGE_CACHE_TRACING
-    return NanotraceHR::isTracerActive();
-#else
-    return false;
-#endif
-}
-
-using ImageCacheTraceToken = NanotraceHR::Token<imageCacheTracingIsEnabled()>;
-
-NanotraceHR::StringViewCategory<imageCacheTracingIsEnabled()> &imageCacheCategory();
-
 class AsynchronousImageCache final : public AsynchronousImageCacheInterface
 {
 public:
@@ -74,14 +62,14 @@ private:
               ImageCache::AbortCallback &&abortCallback,
               ImageCache::AuxiliaryData &&auxiliaryData,
               RequestType requestType,
-              ImageCacheTraceToken traceToken)
+              ImageCache::TraceToken traceToken)
             : name{std::move(name)}
             , extraId{std::move(extraId)}
             , captureCallback{std::move(captureCallback)}
             , abortCallback{std::move(abortCallback)}
             , auxiliaryData{std::move(auxiliaryData)}
             , requestType{requestType}
-            , traceToken{traceToken}
+            , traceToken{std::move(traceToken)}
         {}
 
         Utils::PathString name;
@@ -90,7 +78,7 @@ private:
         ImageCache::AbortCallback abortCallback;
         ImageCache::AuxiliaryData auxiliaryData;
         RequestType requestType = RequestType::Image;
-        ImageCacheTraceToken traceToken;
+        ImageCache::TraceToken traceToken;
     };
 
     static void request(Utils::SmallStringView name,
@@ -99,26 +87,14 @@ private:
                         ImageCache::CaptureImageCallback captureCallback,
                         ImageCache::AbortCallback abortCallback,
                         ImageCache::AuxiliaryData auxiliaryData,
-                        ImageCacheTraceToken traceToken,
+                        ImageCache::TraceToken traceToken,
                         ImageCacheStorageInterface &storage,
                         ImageCacheGeneratorInterface &generator,
                         TimeStampProviderInterface &timeStampProvider);
 
     struct Dispatch
     {
-        void operator()(Entry &entry)
-        {
-            request(entry.name,
-                    entry.extraId,
-                    entry.requestType,
-                    std::move(entry.captureCallback),
-                    std::move(entry.abortCallback),
-                    std::move(entry.auxiliaryData),
-                    entry.traceToken,
-                    storage,
-                    generator,
-                    timeStampProvider);
-        }
+        QMLDESIGNERCORE_EXPORT void operator()(Entry &entry);
 
         ImageCacheStorageInterface &storage;
         ImageCacheGeneratorInterface &generator;
@@ -127,13 +103,7 @@ private:
 
     struct Clean
     {
-        void operator()(Entry &entry)
-        {
-            using namespace NanotraceHR::Literals;
-
-            entry.abortCallback(ImageCache::AbortReason::Abort);
-            imageCacheCategory().endAsynchronous(entry.traceToken, "aborted for cleanup"_t);
-        }
+        QMLDESIGNERCORE_EXPORT void operator()(Entry &entry);
     };
 
 private:
diff --git a/src/plugins/qmldesigner/designercore/include/imagecacheauxiliarydata.h b/src/plugins/qmldesigner/designercore/include/imagecacheauxiliarydata.h
index c147fb0753a..b27816f0548 100644
--- a/src/plugins/qmldesigner/designercore/include/imagecacheauxiliarydata.h
+++ b/src/plugins/qmldesigner/designercore/include/imagecacheauxiliarydata.h
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <nanotrace/nanotracehr.h>
 #include <utils/span.h>
 
 #include <QImage>
@@ -16,6 +17,19 @@ namespace QmlDesigner {
 
 namespace ImageCache {
 
+constexpr bool tracingIsEnabled()
+{
+#ifdef ENABLE_IMAGE_CACHE_TRACING
+    return NanotraceHR::isTracerActive();
+#else
+    return false;
+#endif
+}
+
+using Category = NanotraceHR::StringViewCategory<tracingIsEnabled()>;
+using TraceToken = Category::TokenType;
+Category &category();
+
 class FontCollectorSizeAuxiliaryData
 {
 public:
@@ -46,9 +60,11 @@ using AuxiliaryData = std::variant<std::monostate,
 enum class AbortReason : char { Abort, Failed, NoEntry };
 
 using CaptureImageCallback = std::function<void(const QImage &)>;
-using CaptureImageWithScaledImagesCallback = std::function<
-    void(const QImage &image, const QImage &midSizeImage, const QImage &smallImage)>;
+using CaptureImageWithScaledImagesCallback = std::function<void(
+    const QImage &image, const QImage &midSizeImage, const QImage &smallImage, ImageCache::TraceToken)>;
 using AbortCallback = std::function<void(ImageCache::AbortReason)>;
+using InternalAbortCallback = std::function<void(ImageCache::AbortReason, ImageCache::TraceToken)>;
+
 } // namespace ImageCache
 
 } // namespace QmlDesigner
diff --git a/tests/unit/tests/mocks/imagecachecollectormock.h b/tests/unit/tests/mocks/imagecachecollectormock.h
index d8a8608faa6..0947df3f4d1 100644
--- a/tests/unit/tests/mocks/imagecachecollectormock.h
+++ b/tests/unit/tests/mocks/imagecachecollectormock.h
@@ -16,7 +16,8 @@ public:
                  Utils::SmallStringView state,
                  const QmlDesigner::ImageCache::AuxiliaryData &auxiliaryData,
                  ImageCacheCollectorInterface::CaptureCallback captureCallback,
-                 ImageCacheCollectorInterface::AbortCallback abortCallback),
+                 ImageCacheCollectorInterface::AbortCallback abortCallback,
+                 QmlDesigner::ImageCache::TraceToken),
                 (override));
 
     MOCK_METHOD(ImageTuple,
diff --git a/tests/unit/tests/mocks/mockimagecachegenerator.h b/tests/unit/tests/mocks/mockimagecachegenerator.h
index 30d322ac7f2..ee673c8ed4c 100644
--- a/tests/unit/tests/mocks/mockimagecachegenerator.h
+++ b/tests/unit/tests/mocks/mockimagecachegenerator.h
@@ -16,8 +16,9 @@ public:
                  Utils::SmallStringView state,
                  Sqlite::TimeStamp timeStamp,
                  QmlDesigner::ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback,
-                 QmlDesigner::ImageCache::AbortCallback &&abortCallback,
-                 QmlDesigner::ImageCache::AuxiliaryData &&auxiliaryData),
+                 QmlDesigner::ImageCache::InternalAbortCallback &&abortCallback,
+                 QmlDesigner::ImageCache::AuxiliaryData &&auxiliaryData,
+                 QmlDesigner::ImageCache::TraceToken),
                 (override));
     MOCK_METHOD(void, clean, (), (override));
     MOCK_METHOD(void, waitForFinished, (), (override));
diff --git a/tests/unit/tests/unittests/imagecache/asynchronousimagecache-test.cpp b/tests/unit/tests/unittests/imagecache/asynchronousimagecache-test.cpp
index e7c51c40fc4..7dd283579d5 100644
--- a/tests/unit/tests/unittests/imagecache/asynchronousimagecache-test.cpp
+++ b/tests/unit/tests/unittests/imagecache/asynchronousimagecache-test.cpp
@@ -93,8 +93,8 @@ TEST_F(AsynchronousImageCache, request_image_request_image_from_generator)
         .WillByDefault(Return(Sqlite::TimeStamp{123}));
 
     EXPECT_CALL(mockGenerator,
-                generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
+                generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _, _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto, auto) { notification.notify(); });
 
     cache.requestImage("/path/to/Component.qml",
                        mockCaptureCallback.AsStdFunction(),
@@ -104,9 +104,9 @@ TEST_F(AsynchronousImageCache, request_image_request_image_from_generator)
 
 TEST_F(AsynchronousImageCache, request_image_calls_capture_callback_with_image_from_generator)
 {
-    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto &&callback, auto, auto) {
-            callback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
+    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto &&callback, auto, auto, auto) {
+            callback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
             notification.notify();
         });
 
@@ -120,9 +120,9 @@ TEST_F(AsynchronousImageCache, request_image_calls_capture_callback_with_image_f
 
 TEST_F(AsynchronousImageCache, request_image_calls_abort_callback_from_generator)
 {
-    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto) {
-            abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
+    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto, auto) {
+            abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
             notification.notify();
         });
 
@@ -200,8 +200,8 @@ TEST_F(AsynchronousImageCache, request_mid_size_image_request_image_from_generat
         .WillByDefault(Return(Sqlite::TimeStamp{123}));
 
     EXPECT_CALL(mockGenerator,
-                generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
+                generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _, _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto, auto) { notification.notify(); });
 
     cache.requestMidSizeImage("/path/to/Component.qml",
                               mockCaptureCallback.AsStdFunction(),
@@ -211,9 +211,9 @@ TEST_F(AsynchronousImageCache, request_mid_size_image_request_image_from_generat
 
 TEST_F(AsynchronousImageCache, request_mid_size_image_calls_capture_callback_with_image_from_generator)
 {
-    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto &&callback, auto, auto) {
-            callback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
+    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto &&callback, auto, auto, auto) {
+            callback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
             notification.notify();
         });
 
@@ -227,9 +227,9 @@ TEST_F(AsynchronousImageCache, request_mid_size_image_calls_capture_callback_wit
 
 TEST_F(AsynchronousImageCache, request_mid_size_image_calls_abort_callback_from_generator)
 {
-    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto) {
-            abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
+    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto, auto) {
+            abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
             notification.notify();
         });
 
@@ -306,8 +306,8 @@ TEST_F(AsynchronousImageCache, request_small_image_request_image_from_generator)
         .WillByDefault(Return(Sqlite::TimeStamp{123}));
 
     EXPECT_CALL(mockGenerator,
-                generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
+                generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _, _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto, auto) { notification.notify(); });
 
     cache.requestSmallImage("/path/to/Component.qml",
                             mockCaptureCallback.AsStdFunction(),
@@ -317,9 +317,9 @@ TEST_F(AsynchronousImageCache, request_small_image_request_image_from_generator)
 
 TEST_F(AsynchronousImageCache, request_small_image_calls_capture_callback_with_image_from_generator)
 {
-    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto &&callback, auto, auto) {
-            callback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
+    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto &&callback, auto, auto, auto) {
+            callback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
             notification.notify();
         });
 
@@ -333,9 +333,9 @@ TEST_F(AsynchronousImageCache, request_small_image_calls_capture_callback_with_i
 
 TEST_F(AsynchronousImageCache, request_small_image_calls_abort_callback_from_generator)
 {
-    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto) {
-            abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
+    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto, auto) {
+            abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
             notification.notify();
         });
 
@@ -349,9 +349,9 @@ TEST_F(AsynchronousImageCache, request_small_image_calls_abort_callback_from_gen
 
 TEST_F(AsynchronousImageCache, clean_removes_entries)
 {
-    EXPECT_CALL(mockGenerator, generateImage(_, _, _, _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto &&captureCallback, auto &&, auto) {
-            captureCallback(QImage{}, QImage{}, QImage{});
+    EXPECT_CALL(mockGenerator, generateImage(_, _, _, _, _, _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto &&captureCallback, auto &&, auto, auto) {
+            captureCallback(QImage{}, QImage{}, QImage{}, {});
             waitInThread.wait();
         });
     cache.requestSmallImage("/path/to/Component1.qml",
@@ -369,8 +369,8 @@ TEST_F(AsynchronousImageCache, clean_removes_entries)
 
 TEST_F(AsynchronousImageCache, clean_calls_abort)
 {
-    ON_CALL(mockGenerator, generateImage(_, _, _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto, auto &&, auto) { waitInThread.wait(); });
+    ON_CALL(mockGenerator, generateImage(_, _, _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto, auto &&, auto, auto) { waitInThread.wait(); });
     cache.requestSmallImage("/path/to/Component1.qml",
                             mockCaptureCallback.AsStdFunction(),
                             mockAbortCallback.AsStdFunction());
@@ -399,8 +399,9 @@ TEST_F(AsynchronousImageCache, after_clean_new_jobs_works)
 {
     cache.clean();
 
-    EXPECT_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto &&, auto &&, auto) { notification.notify(); });
+    EXPECT_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
+        .WillRepeatedly(
+            [&](auto, auto, auto, auto &&, auto &&, auto, auto) { notification.notify(); });
 
     cache.requestSmallImage("/path/to/Component.qml",
                             mockCaptureCallback.AsStdFunction(),
@@ -460,8 +461,8 @@ TEST_F(AsynchronousImageCache, request_image_with_extra_id_request_image_from_ge
 
     EXPECT_CALL(mockGenerator,
                 generateImage(
-                    Eq("/path/to/Component.qml"), Eq("extraId1"), Eq(Sqlite::TimeStamp{123}), _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto) { notification.notify(); });
+                    Eq("/path/to/Component.qml"), Eq("extraId1"), Eq(Sqlite::TimeStamp{123}), _, _, _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
 
     cache.requestImage("/path/to/Component.qml",
                        mockCaptureCallback.AsStdFunction(),
@@ -477,8 +478,8 @@ TEST_F(AsynchronousImageCache, request_mid_size_image_with_extra_id_request_imag
 
     EXPECT_CALL(mockGenerator,
                 generateImage(
-                    Eq("/path/to/Component.qml"), Eq("extraId1"), Eq(Sqlite::TimeStamp{123}), _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto) { notification.notify(); });
+                    Eq("/path/to/Component.qml"), Eq("extraId1"), Eq(Sqlite::TimeStamp{123}), _, _, _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
 
     cache.requestMidSizeImage("/path/to/Component.qml",
                               mockCaptureCallback.AsStdFunction(),
@@ -494,8 +495,8 @@ TEST_F(AsynchronousImageCache, request_small_image_with_extra_id_request_image_f
 
     EXPECT_CALL(mockGenerator,
                 generateImage(
-                    Eq("/path/to/Component.qml"), Eq("extraId1"), Eq(Sqlite::TimeStamp{123}), _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto) { notification.notify(); });
+                    Eq("/path/to/Component.qml"), Eq("extraId1"), Eq(Sqlite::TimeStamp{123}), _, _, _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
 
     cache.requestSmallImage("/path/to/Component.qml",
                             mockCaptureCallback.AsStdFunction(),
@@ -521,8 +522,9 @@ TEST_F(AsynchronousImageCache, request_image_with_auxiliary_data_request_image_f
                                   AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
                                               ElementsAre(QSize{20, 11})),
                                         Field(&FontCollectorSizesAuxiliaryData::colorName,
-                                              Eq(u"color"))))))
-        .WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto) { notification.notify(); });
+                                              Eq(u"color")))),
+                              _))
+        .WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
 
     cache.requestImage("/path/to/Component.qml",
                        mockCaptureCallback.AsStdFunction(),
@@ -549,8 +551,9 @@ TEST_F(AsynchronousImageCache, request_mid_size_image_with_auxiliary_data_reques
                                   AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
                                               ElementsAre(QSize{20, 11})),
                                         Field(&FontCollectorSizesAuxiliaryData::colorName,
-                                              Eq(u"color"))))))
-        .WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto) { notification.notify(); });
+                                              Eq(u"color")))),
+                              _))
+        .WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
 
     cache.requestMidSizeImage("/path/to/Component.qml",
                               mockCaptureCallback.AsStdFunction(),
@@ -577,8 +580,9 @@ TEST_F(AsynchronousImageCache, request_small_image_with_auxiliary_data_request_i
                                   AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
                                               ElementsAre(QSize{20, 11})),
                                         Field(&FontCollectorSizesAuxiliaryData::colorName,
-                                              Eq(u"color"))))))
-        .WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto) { notification.notify(); });
+                                              Eq(u"color")))),
+                              _))
+        .WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
 
     cache.requestSmallImage("/path/to/Component.qml",
                             mockCaptureCallback.AsStdFunction(),
diff --git a/tests/unit/tests/unittests/imagecache/asynchronousimagefactory-test.cpp b/tests/unit/tests/unittests/imagecache/asynchronousimagefactory-test.cpp
index b26b4b7c708..966d18f95e6 100644
--- a/tests/unit/tests/unittests/imagecache/asynchronousimagefactory-test.cpp
+++ b/tests/unit/tests/unittests/imagecache/asynchronousimagefactory-test.cpp
@@ -43,8 +43,9 @@ TEST_F(AsynchronousImageFactory, request_image_request_image_from_collector)
                       IsEmpty(),
                       VariantWith<std::monostate>(std::monostate{}),
                       _,
+                      _,
                       _))
-        .WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
 
     factory.generate("/path/to/Component.qml");
     notification.wait();
@@ -57,8 +58,9 @@ TEST_F(AsynchronousImageFactory, request_image_with_extra_id_request_image_from_
                       Eq("foo"),
                       VariantWith<std::monostate>(std::monostate{}),
                       _,
+                      _,
                       _))
-        .WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
 
     factory.generate("/path/to/Component.qml", "foo");
     notification.wait();
@@ -77,8 +79,9 @@ TEST_F(AsynchronousImageFactory, request_image_with_auxiliary_data_request_image
                                 Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")),
                                 Field(&FontCollectorSizesAuxiliaryData::text, Eq(u"some text")))),
                       _,
+                      _,
                       _))
-        .WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
 
     factory.generate("/path/to/Component.qml",
                      "foo",
@@ -99,7 +102,7 @@ TEST_F(AsynchronousImageFactory, dont_request_image_request_image_from_collector
     ON_CALL(timeStampProviderMock, timeStamp(Eq("/path/to/Component.qml")))
         .WillByDefault(Return(Sqlite::TimeStamp{1}));
 
-    EXPECT_CALL(collectorMock, start(_, _, _, _, _)).Times(0);
+    EXPECT_CALL(collectorMock, start(_, _, _, _, _, _)).Times(0);
 
     factory.generate("/path/to/Component.qml");
     notification.wait();
@@ -113,7 +116,7 @@ TEST_F(AsynchronousImageFactory, request_image_request_image_from_collector_if_f
         .WillByDefault(Return(Sqlite::TimeStamp{125}));
     ON_CALL(timeStampProviderMock, pause()).WillByDefault(Return(Sqlite::TimeStamp{1}));
 
-    EXPECT_CALL(collectorMock, start(_, _, _, _, _)).WillOnce([&](auto, auto, auto, auto, auto) {
+    EXPECT_CALL(collectorMock, start(_, _, _, _, _, _)).WillOnce([&](auto, auto, auto, auto, auto, auto) {
         notification.notify();
     });
 
@@ -123,15 +126,15 @@ TEST_F(AsynchronousImageFactory, request_image_request_image_from_collector_if_f
 
 TEST_F(AsynchronousImageFactory, clean_removes_entries)
 {
-    EXPECT_CALL(collectorMock, start(Eq("/path/to/Component1.qml"), _, _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto, auto) {
+    EXPECT_CALL(collectorMock, start(Eq("/path/to/Component1.qml"), _, _, _, _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) {
             notification.notify();
             waitInThread.wait();
         });
     factory.generate("/path/to/Component1.qml");
     notification.wait();
 
-    EXPECT_CALL(collectorMock, start(Eq("/path/to/Component3.qml"), _, _, _, _)).Times(0);
+    EXPECT_CALL(collectorMock, start(Eq("/path/to/Component3.qml"), _, _, _, _, _)).Times(0);
 
     factory.generate("/path/to/Component3.qml");
     factory.clean();
@@ -147,8 +150,9 @@ TEST_F(AsynchronousImageFactory, after_clean_new_jobs_works)
                       IsEmpty(),
                       VariantWith<std::monostate>(std::monostate{}),
                       _,
+                      _,
                       _))
-        .WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
 
     factory.generate("/path/to/Component.qml");
     notification.wait();
@@ -166,9 +170,10 @@ TEST_F(AsynchronousImageFactory, capture_image_callback_stores_image)
                   Eq("id"),
                   VariantWith<std::monostate>(std::monostate{}),
                   _,
+                  _,
                   _))
-        .WillByDefault([&](auto, auto, auto, auto capture, auto) {
-            capture(image1, midSizeImage1, smallImage1);
+        .WillByDefault([&](auto, auto, auto, auto capture, auto, auto) {
+            capture(image1, midSizeImage1, smallImage1, {});
         });
 
     EXPECT_CALL(storageMock,
diff --git a/tests/unit/tests/unittests/imagecache/imagecachedispatchcollector-test.cpp b/tests/unit/tests/unittests/imagecache/imagecachedispatchcollector-test.cpp
index 8d459916ffc..b463a5a698e 100644
--- a/tests/unit/tests/unittests/imagecache/imagecachedispatchcollector-test.cpp
+++ b/tests/unit/tests/unittests/imagecache/imagecachedispatchcollector-test.cpp
@@ -12,6 +12,7 @@
 
 namespace {
 using QmlDesigner::ImageCache::FontCollectorSizesAuxiliaryData;
+using QmlDesigner::ImageCache::TraceToken;
 
 MATCHER_P(IsIcon, icon, std::string(negation ? "isn't " : "is ") + PrintToString(icon))
 {
@@ -47,8 +48,8 @@ protected:
 
 protected:
     std::vector<QSize> sizes{{20, 11}};
-    NiceMock<MockFunction<void(const QImage &, const QImage &, const QImage &)>> captureCallbackMock;
-    NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason)>> abortCallbackMock;
+    NiceMock<MockFunction<void(const QImage &, const QImage &, const QImage &, TraceToken)>> captureCallbackMock;
+    NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason, TraceToken)>> abortCallbackMock;
     NiceMock<ImageCacheCollectorMock> collectorMock1;
     NiceMock<ImageCacheCollectorMock> collectorMock2;
     QImage image1{1, 1, QImage::Format_ARGB32};
@@ -83,8 +84,8 @@ TEST_F(ImageCacheDispatchCollector, call_qml_collector_start)
             },
             &collectorMock2))};
 
-    EXPECT_CALL(captureCallbackMock, Call(_, _, _));
-    EXPECT_CALL(abortCallbackMock, Call(_));
+    EXPECT_CALL(captureCallbackMock, Call(_, _, _, _));
+    EXPECT_CALL(abortCallbackMock, Call(_, _));
     EXPECT_CALL(collectorMock2,
                 start(Eq("foo.qml"),
                       Eq("state"),
@@ -93,18 +94,20 @@ TEST_F(ImageCacheDispatchCollector, call_qml_collector_start)
                                       ElementsAre(QSize{20, 11})),
                                 Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")))),
                       _,
+                      _,
                       _))
-        .WillRepeatedly([&](auto, auto, auto, auto captureCallback, auto abortCallback) {
-            captureCallback({}, {}, {});
-            abortCallback(QmlDesigner::ImageCache::AbortReason::Abort);
+        .WillRepeatedly([&](auto, auto, auto, auto captureCallback, auto abortCallback, auto) {
+            captureCallback({}, {}, {}, {});
+            abortCallback(QmlDesigner::ImageCache::AbortReason::Abort, {});
         });
-    EXPECT_CALL(collectorMock1, start(_, _, _, _, _)).Times(0);
+    EXPECT_CALL(collectorMock1, start(_, _, _, _, _, _)).Times(0);
 
     collector.start("foo.qml",
                     "state",
                     FontCollectorSizesAuxiliaryData{sizes, "color", "text"},
                     captureCallbackMock.AsStdFunction(),
-                    abortCallbackMock.AsStdFunction());
+                    abortCallbackMock.AsStdFunction(),
+                    {});
 }
 
 TEST_F(ImageCacheDispatchCollector, call_ui_file_collector_start)
@@ -119,8 +122,8 @@ TEST_F(ImageCacheDispatchCollector, call_ui_file_collector_start)
                           const QmlDesigner::ImageCache::AuxiliaryData &) { return true; },
                        &collectorMock2))};
 
-    EXPECT_CALL(captureCallbackMock, Call(_, _, _));
-    EXPECT_CALL(abortCallbackMock, Call(_));
+    EXPECT_CALL(captureCallbackMock, Call(_, _, _, _));
+    EXPECT_CALL(abortCallbackMock, Call(_, _));
     EXPECT_CALL(collectorMock1,
                 start(Eq("foo.ui.qml"),
                       Eq("state"),
@@ -129,18 +132,20 @@ TEST_F(ImageCacheDispatchCollector, call_ui_file_collector_start)
                                       ElementsAre(QSize{20, 11})),
                                 Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")))),
                       _,
+                      _,
                       _))
-        .WillRepeatedly([&](auto, auto, auto, auto captureCallback, auto abortCallback) {
-            captureCallback({}, {}, {});
-            abortCallback(QmlDesigner::ImageCache::AbortReason::Abort);
+        .WillRepeatedly([&](auto, auto, auto, auto captureCallback, auto abortCallback, auto) {
+            captureCallback({}, {}, {}, {});
+            abortCallback(QmlDesigner::ImageCache::AbortReason::Abort, {});
         });
-    EXPECT_CALL(collectorMock2, start(_, _, _, _, _)).Times(0);
+    EXPECT_CALL(collectorMock2, start(_, _, _, _, _, _)).Times(0);
 
     collector.start("foo.ui.qml",
                     "state",
                     FontCollectorSizesAuxiliaryData{sizes, "color", "text"},
                     captureCallbackMock.AsStdFunction(),
-                    abortCallbackMock.AsStdFunction());
+                    abortCallbackMock.AsStdFunction(),
+                    {});
 }
 
 TEST_F(ImageCacheDispatchCollector, dont_call_collector_start_for_unknown_file)
@@ -155,14 +160,15 @@ TEST_F(ImageCacheDispatchCollector, dont_call_collector_start_for_unknown_file)
                           const QmlDesigner::ImageCache::AuxiliaryData &) { return false; },
                        &collectorMock2))};
 
-    EXPECT_CALL(collectorMock2, start(_, _, _, _, _)).Times(0);
-    EXPECT_CALL(collectorMock1, start(_, _, _, _, _)).Times(0);
+    EXPECT_CALL(collectorMock2, start(_, _, _, _, _, _)).Times(0);
+    EXPECT_CALL(collectorMock1, start(_, _, _, _, _, _)).Times(0);
 
     collector.start("foo.mesh",
                     "state",
                     FontCollectorSizesAuxiliaryData{sizes, "color", "text"},
                     captureCallbackMock.AsStdFunction(),
-                    abortCallbackMock.AsStdFunction());
+                    abortCallbackMock.AsStdFunction(),
+                    {});
 }
 
 TEST_F(ImageCacheDispatchCollector, call_first_collector_create_icon)
diff --git a/tests/unit/tests/unittests/imagecache/imagecachegenerator-test.cpp b/tests/unit/tests/unittests/imagecache/imagecachegenerator-test.cpp
index 878552964a8..15e31764ad7 100644
--- a/tests/unit/tests/unittests/imagecache/imagecachegenerator-test.cpp
+++ b/tests/unit/tests/unittests/imagecache/imagecachegenerator-test.cpp
@@ -13,6 +13,8 @@
 
 namespace {
 
+using QmlDesigner::ImageCache::TraceToken;
+
 class ImageCacheGenerator : public testing::Test
 {
 protected:
@@ -34,8 +36,8 @@ protected:
     QImage image1{10, 10, QImage::Format_ARGB32};
     QImage midSizeImage1{5, 5, QImage::Format_ARGB32};
     QImage smallImage1{1, 1, QImage::Format_ARGB32};
-    NiceMock<MockFunction<void(const QImage &, const QImage &, const QImage &)>> imageCallbackMock;
-    NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason)>> abortCallbackMock;
+    NiceMock<MockFunction<void(const QImage &, const QImage &, const QImage &, TraceToken)>> imageCallbackMock;
+    NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason, TraceToken)>> abortCallbackMock;
     NiceMock<ImageCacheCollectorMock> collectorMock;
     NiceMock<MockImageCacheStorage> storageMock;
     QmlDesigner::ImageCacheGenerator generator{collectorMock, storageMock};
@@ -43,13 +45,13 @@ protected:
 
 TEST_F(ImageCacheGenerator, calls_collector_with_capture_callback)
 {
-    EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto captureCallback, auto) {
-            captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
+    EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
         });
-    EXPECT_CALL(imageCallbackMock, Call(_, _, _))
+    EXPECT_CALL(imageCallbackMock, Call(_, _, _, _))
         .WillRepeatedly(
-            [&](const QImage &, const QImage &, const QImage &) { notification.notify(); });
+            [&](const QImage &, const QImage &, const QImage &, auto) { notification.notify(); });
 
     generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {}, {});
     notification.wait();
@@ -57,8 +59,8 @@ TEST_F(ImageCacheGenerator, calls_collector_with_capture_callback)
 
 TEST_F(ImageCacheGenerator, calls_collector_only_if_not_processing)
 {
-    EXPECT_CALL(collectorMock, start(AnyOf(Eq("name"), Eq("name2")), _, _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
+    EXPECT_CALL(collectorMock, start(AnyOf(Eq("name"), Eq("name2")), _, _, _, _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
 
     generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {}, {});
     generator.generateImage("name2", {}, {}, imageCallbackMock.AsStdFunction(), {}, {});
@@ -67,16 +69,17 @@ TEST_F(ImageCacheGenerator, calls_collector_only_if_not_processing)
 
 TEST_F(ImageCacheGenerator, process_task_after_first_finished)
 {
-    ON_CALL(imageCallbackMock, Call(_, _, _))
-        .WillByDefault([&](const QImage &, const QImage &, const QImage &) { notification.notify(); });
+    ON_CALL(imageCallbackMock, Call(_, _, _, _))
+        .WillByDefault(
+            [&](const QImage &, const QImage &, const QImage &, auto) { notification.notify(); });
 
-    EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillOnce([&](auto, auto, auto, auto captureCallback, auto) {
-            captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
+    EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillOnce([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
         });
-    EXPECT_CALL(collectorMock, start(Eq("name2"), _, _, _, _))
-        .WillOnce([&](auto, auto, auto, auto captureCallback, auto) {
-            captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
+    EXPECT_CALL(collectorMock, start(Eq("name2"), _, _, _, _, _))
+        .WillOnce([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
         });
 
     generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {}, {});
@@ -86,13 +89,13 @@ TEST_F(ImageCacheGenerator, process_task_after_first_finished)
 
 TEST_F(ImageCacheGenerator, dont_crash_at_destructing_generator)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
-            captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
         });
 
     generator.generateImage(
-        "name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
+        "name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {}, {});
     generator.generateImage(
         "name2", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
     generator.generateImage(
@@ -103,9 +106,9 @@ TEST_F(ImageCacheGenerator, dont_crash_at_destructing_generator)
 
 TEST_F(ImageCacheGenerator, store_image)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
-            captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
         });
 
     EXPECT_CALL(storageMock,
@@ -122,9 +125,9 @@ TEST_F(ImageCacheGenerator, store_image)
 
 TEST_F(ImageCacheGenerator, store_image_with_extra_id)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
-            captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
         });
 
     EXPECT_CALL(storageMock,
@@ -141,9 +144,9 @@ TEST_F(ImageCacheGenerator, store_image_with_extra_id)
 
 TEST_F(ImageCacheGenerator, store_null_image)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
-            captureCallback(QImage{}, QImage{}, QImage{});
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback(QImage{}, QImage{}, QImage{}, {});
         });
 
     EXPECT_CALL(
@@ -158,9 +161,9 @@ TEST_F(ImageCacheGenerator, store_null_image)
 
 TEST_F(ImageCacheGenerator, store_null_image_with_extra_id)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
-            captureCallback(QImage{}, QImage{}, QImage{});
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback(QImage{}, QImage{}, QImage{}, {});
         });
 
     EXPECT_CALL(storageMock,
@@ -182,19 +185,20 @@ TEST_F(ImageCacheGenerator, store_null_image_with_extra_id)
 
 TEST_F(ImageCacheGenerator, abort_callback)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
-            captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
         });
-    ON_CALL(collectorMock, start(Eq("name2"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto, auto abortCallback) {
-            abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
+    ON_CALL(collectorMock, start(Eq("name2"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto, auto abortCallback, auto) {
+            abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
         });
 
-    EXPECT_CALL(imageCallbackMock, Call(_, _, _))
-        .WillOnce([&](const QImage &, const QImage &, const QImage &) { notification.notify(); });
-    EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed)))
-        .WillOnce([&](auto) { notification.notify(); });
+    EXPECT_CALL(imageCallbackMock, Call(_, _, _, _))
+        .WillOnce(
+            [&](const QImage &, const QImage &, const QImage &, auto) { notification.notify(); });
+    EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed), _))
+        .WillOnce([&](auto, auto) { notification.notify(); });
 
     generator.generateImage(
         "name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
@@ -205,12 +209,12 @@ TEST_F(ImageCacheGenerator, abort_callback)
 
 TEST_F(ImageCacheGenerator, store_null_image_for_abort_callback_abort)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto, auto abortCallback) {
-            abortCallback(QmlDesigner::ImageCache::AbortReason::Abort);
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto, auto abortCallback, auto) {
+            abortCallback(QmlDesigner::ImageCache::AbortReason::Abort, {});
         });
-    ON_CALL(collectorMock, start(Eq("dummyNotify"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto, auto) { notification.notify(); });
+    ON_CALL(collectorMock, start(Eq("dummyNotify"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
 
     EXPECT_CALL(storageMock, storeImage(Eq("name"), _, _, _, _)).Times(0);
 
@@ -222,9 +226,9 @@ TEST_F(ImageCacheGenerator, store_null_image_for_abort_callback_abort)
 
 TEST_F(ImageCacheGenerator, dont_store_null_image_for_abort_callback_failed)
 {
-    ON_CALL(collectorMock, start(_, _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto, auto abortCallback) {
-            abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
+    ON_CALL(collectorMock, start(_, _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto, auto abortCallback, auto) {
+            abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
         });
 
     EXPECT_CALL(
@@ -239,13 +243,13 @@ TEST_F(ImageCacheGenerator, dont_store_null_image_for_abort_callback_failed)
 
 TEST_F(ImageCacheGenerator, abort_for_null_image)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
-            captureCallback(QImage{}, QImage{}, QImage{});
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback(QImage{}, QImage{}, QImage{}, {});
         });
 
-    EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed)))
-        .WillOnce([&](auto) { notification.notify(); });
+    EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed), _))
+        .WillOnce([&](auto, auto) { notification.notify(); });
 
     generator.generateImage(
         "name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
@@ -254,13 +258,13 @@ TEST_F(ImageCacheGenerator, abort_for_null_image)
 
 TEST_F(ImageCacheGenerator, call_image_callback_if_small_image_is_not_null)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
-            captureCallback({}, {}, smallImage1);
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback({}, {}, smallImage1, {});
         });
 
-    EXPECT_CALL(imageCallbackMock, Call(Eq(QImage()), Eq(QImage()), Eq(smallImage1)))
-        .WillOnce([&](auto, auto, auto) { notification.notify(); });
+    EXPECT_CALL(imageCallbackMock, Call(Eq(QImage()), Eq(QImage()), Eq(smallImage1), _))
+        .WillOnce([&](auto, auto, auto, auto) { notification.notify(); });
 
     generator.generateImage(
         "name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
@@ -269,9 +273,9 @@ TEST_F(ImageCacheGenerator, call_image_callback_if_small_image_is_not_null)
 
 TEST_F(ImageCacheGenerator, store_image_if_small_image_is_not_null)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
-            captureCallback({}, {}, smallImage1);
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback({}, {}, smallImage1, {});
         });
 
     EXPECT_CALL(storageMock, storeImage(_, _, Eq(QImage()), Eq(QImage()), Eq(smallImage1)))
@@ -284,13 +288,13 @@ TEST_F(ImageCacheGenerator, store_image_if_small_image_is_not_null)
 
 TEST_F(ImageCacheGenerator, call_image_callback_if_mid_size_image_is_not_null)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
-            captureCallback({}, midSizeImage1, {});
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback({}, midSizeImage1, {}, {});
         });
 
-    EXPECT_CALL(imageCallbackMock, Call(Eq(QImage()), Eq(midSizeImage1), Eq(QImage{})))
-        .WillOnce([&](auto, auto, auto) { notification.notify(); });
+    EXPECT_CALL(imageCallbackMock, Call(Eq(QImage()), Eq(midSizeImage1), Eq(QImage{}), _))
+        .WillOnce([&](auto, auto, auto, auto) { notification.notify(); });
 
     generator.generateImage(
         "name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
@@ -299,9 +303,9 @@ TEST_F(ImageCacheGenerator, call_image_callback_if_mid_size_image_is_not_null)
 
 TEST_F(ImageCacheGenerator, store_image_if_mid_size_image_is_not_null)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
-            captureCallback({}, midSizeImage1, {});
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback({}, midSizeImage1, {}, {});
         });
 
     EXPECT_CALL(storageMock, storeImage(_, _, Eq(QImage()), Eq(midSizeImage1), Eq(QImage())))
@@ -314,12 +318,13 @@ TEST_F(ImageCacheGenerator, store_image_if_mid_size_image_is_not_null)
 
 TEST_F(ImageCacheGenerator, call_image_callback_if_image_is_not_null)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillByDefault(
-            [&](auto, auto, auto, auto captureCallback, auto) { captureCallback(image1, {}, {}); });
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback(image1, {}, {}, {});
+        });
 
-    EXPECT_CALL(imageCallbackMock, Call(Eq(image1), Eq(QImage{}), Eq(QImage{})))
-        .WillOnce([&](auto, auto, auto) { notification.notify(); });
+    EXPECT_CALL(imageCallbackMock, Call(Eq(image1), Eq(QImage{}), Eq(QImage{}), _))
+        .WillOnce([&](auto, auto, auto, auto) { notification.notify(); });
 
     generator.generateImage(
         "name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
@@ -328,9 +333,10 @@ TEST_F(ImageCacheGenerator, call_image_callback_if_image_is_not_null)
 
 TEST_F(ImageCacheGenerator, store_image_if_image_is_not_null)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillByDefault(
-            [&](auto, auto, auto, auto captureCallback, auto) { captureCallback(image1, {}, {}); });
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback(image1, {}, {}, {});
+        });
 
     EXPECT_CALL(storageMock, storeImage(_, _, Eq(image1), Eq(QImage{}), Eq(QImage{})))
         .WillOnce([&](auto, auto, auto, auto, auto) { notification.notify(); });
@@ -342,9 +348,10 @@ TEST_F(ImageCacheGenerator, store_image_if_image_is_not_null)
 
 TEST_F(ImageCacheGenerator, call_wal_checkpoint_full_if_queue_is_empty)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillByDefault(
-            [&](auto, auto, auto, auto captureCallback, auto) { captureCallback({}, {}, {}); });
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback({}, {}, {}, {});
+        });
 
     EXPECT_CALL(storageMock, walCheckpointFull()).WillRepeatedly([&]() { notification.notify(); });
 
@@ -357,17 +364,16 @@ TEST_F(ImageCacheGenerator, call_wal_checkpoint_full_if_queue_is_empty)
 
 TEST_F(ImageCacheGenerator, clean_is_calling_abort_callback)
 {
-    ON_CALL(collectorMock, start(_, _, _, _, _)).WillByDefault([&](auto, auto, auto, auto, auto) {
-        notification.wait();
-    });
+    ON_CALL(collectorMock, start(_, _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto, auto, auto) { notification.wait(); });
     generator.generateImage(
         "name", {}, {11}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
     generator.generateImage(
         "name2", {}, {11}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
 
-    EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Abort)))
+    EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Abort), _))
         .Times(AtLeast(1))
-        .WillRepeatedly([&](auto) { waitInThread.notify(); });
+        .WillRepeatedly([&](auto, auto) { waitInThread.notify(); });
 
     generator.clean();
     notification.notify();
@@ -376,14 +382,14 @@ TEST_F(ImageCacheGenerator, clean_is_calling_abort_callback)
 
 TEST_F(ImageCacheGenerator, wait_for_finished)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
             waitInThread.wait();
-            captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
+            captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
         });
-    ON_CALL(collectorMock, start(Eq("name2"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
-            captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
+    ON_CALL(collectorMock, start(Eq("name2"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
         });
 
     generator.generateImage(
@@ -391,7 +397,7 @@ TEST_F(ImageCacheGenerator, wait_for_finished)
     generator.generateImage(
         "name2", {}, {11}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
 
-    EXPECT_CALL(imageCallbackMock, Call(_, _, _)).Times(AtMost(2));
+    EXPECT_CALL(imageCallbackMock, Call(_, _, _, _)).Times(AtMost(2));
 
     waitInThread.notify();
     generator.waitForFinished();
@@ -399,8 +405,8 @@ TEST_F(ImageCacheGenerator, wait_for_finished)
 
 TEST_F(ImageCacheGenerator, calls_collector_with_extra_id)
 {
-    EXPECT_CALL(collectorMock, start(Eq("name"), Eq("extraId1"), _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
+    EXPECT_CALL(collectorMock, start(Eq("name"), Eq("extraId1"), _, _, _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
 
     generator.generateImage("name", "extraId1", {}, imageCallbackMock.AsStdFunction(), {}, {});
     notification.wait();
@@ -419,8 +425,9 @@ TEST_F(ImageCacheGenerator, calls_collector_with_auxiliary_data)
                                       ElementsAre(QSize{20, 11})),
                                 Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")))),
                       _,
+                      _,
                       _))
-        .WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
 
     generator.generateImage("name",
                             {},
@@ -433,12 +440,12 @@ TEST_F(ImageCacheGenerator, calls_collector_with_auxiliary_data)
 
 TEST_F(ImageCacheGenerator, merge_tasks)
 {
-    EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto, auto) { waitInThread.wait(); });
-    EXPECT_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
+    EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
+    EXPECT_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
 
-    EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _));
+    EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _, _));
 
     generator.generateImage("waitDummy", {}, {}, {}, {}, {});
     generator.generateImage("name", {}, {}, {}, {}, {});
@@ -450,13 +457,13 @@ TEST_F(ImageCacheGenerator, merge_tasks)
 
 TEST_F(ImageCacheGenerator, dont_merge_tasks_with_different_id)
 {
-    EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto, auto) { waitInThread.wait(); });
+    EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
 
-    EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
-    EXPECT_CALL(collectorMock, start(Eq("name2"), _, _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
+    EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
+    EXPECT_CALL(collectorMock, start(Eq("name2"), _, _, _, _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
 
     generator.generateImage("waitDummy", {}, {}, {}, {}, {});
     generator.generateImage("name", {}, {}, {}, {}, {});
@@ -467,12 +474,12 @@ TEST_F(ImageCacheGenerator, dont_merge_tasks_with_different_id)
 
 TEST_F(ImageCacheGenerator, merge_tasks_with_same_extra_id)
 {
-    EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto, auto) { waitInThread.wait(); });
-    EXPECT_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
+    EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
+    EXPECT_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
 
-    EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _));
+    EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _, _));
 
     generator.generateImage("waitDummy", {}, {}, {}, {}, {});
     generator.generateImage("name", "id1", {}, {}, {}, {});
@@ -484,12 +491,12 @@ TEST_F(ImageCacheGenerator, merge_tasks_with_same_extra_id)
 
 TEST_F(ImageCacheGenerator, dont_merge_tasks_with_different_extra_id)
 {
-    EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _))
-        .WillRepeatedly([&](auto, auto, auto, auto, auto) { waitInThread.wait(); });
+    EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
 
-    EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _))
+    EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
         .Times(2)
-        .WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
+        .WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
 
     generator.generateImage("waitDummy", {}, {}, {}, {}, {});
     generator.generateImage("name", "id1", {}, {}, {}, {});
@@ -500,13 +507,13 @@ TEST_F(ImageCacheGenerator, dont_merge_tasks_with_different_extra_id)
 
 TEST_F(ImageCacheGenerator, use_last_time_stamp_if_tasks_are_merged)
 {
-    ON_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto, auto) { waitInThread.wait(); });
-    ON_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto, auto) { notification.notify(); });
-    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto, auto abortCallback) {
-            abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
+    ON_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
+    ON_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto, auto abortCallback, auto) {
+            abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
         });
 
     EXPECT_CALL(storageMock, storeImage(Eq("name"), Eq(Sqlite::TimeStamp{4}), _, _, _));
@@ -521,18 +528,18 @@ TEST_F(ImageCacheGenerator, use_last_time_stamp_if_tasks_are_merged)
 
 TEST_F(ImageCacheGenerator, merge_capture_callback_if_tasks_are_merged)
 {
-    NiceMock<MockFunction<void(const QImage &, const QImage &, const QImage &)>> newerImageCallbackMock;
-    ON_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto, auto) { waitInThread.wait(); });
-    ON_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto, auto) { notification.notify(); });
-    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto imageCallback, auto) {
-            imageCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
+    NiceMock<MockFunction<void(const QImage &, const QImage &, const QImage &, TraceToken)>> newerImageCallbackMock;
+    ON_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
+    ON_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto imageCallback, auto, auto) {
+            imageCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
         });
 
-    EXPECT_CALL(imageCallbackMock, Call(_, _, _));
-    EXPECT_CALL(newerImageCallbackMock, Call(_, _, _));
+    EXPECT_CALL(imageCallbackMock, Call(_, _, _, _));
+    EXPECT_CALL(newerImageCallbackMock, Call(_, _, _, _));
 
     generator.generateImage("waitDummy", {}, {}, {}, {}, {});
     generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {}, {});
@@ -544,18 +551,18 @@ TEST_F(ImageCacheGenerator, merge_capture_callback_if_tasks_are_merged)
 
 TEST_F(ImageCacheGenerator, merge_abort_callback_if_tasks_are_merged)
 {
-    NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason)>> newerAbortCallbackMock;
-    ON_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto, auto) { waitInThread.wait(); });
-    ON_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto, auto) { notification.notify(); });
-    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
-        .WillByDefault([&](auto, auto, auto, auto, auto abortCallback) {
-            abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
+    NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason, TraceToken)>> newerAbortCallbackMock;
+    ON_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
+    ON_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
+        .WillByDefault([&](auto, auto, auto, auto, auto abortCallback, auto) {
+            abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
         });
 
-    EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed)));
-    EXPECT_CALL(newerAbortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed)));
+    EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed), _));
+    EXPECT_CALL(newerAbortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed), _));
 
     generator.generateImage("waitDummy", {}, {}, {}, {}, {});
     generator.generateImage("name", {}, {}, {}, abortCallbackMock.AsStdFunction(), {});
@@ -567,9 +574,9 @@ TEST_F(ImageCacheGenerator, merge_abort_callback_if_tasks_are_merged)
 
 TEST_F(ImageCacheGenerator, dont_call_null_image_callback)
 {
-    EXPECT_CALL(collectorMock, start(_, _, _, _, _))
-        .WillOnce([&](auto, auto, auto, auto captureCallback, auto) {
-            captureCallback(image1, midSizeImage1, smallImage1);
+    EXPECT_CALL(collectorMock, start(_, _, _, _, _, _))
+        .WillOnce([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback(image1, midSizeImage1, smallImage1, {});
             notification.notify();
         });
 
@@ -579,9 +586,9 @@ TEST_F(ImageCacheGenerator, dont_call_null_image_callback)
 
 TEST_F(ImageCacheGenerator, dont_call_null_abort_callback_for_null_image)
 {
-    EXPECT_CALL(collectorMock, start(_, _, _, _, _))
-        .WillOnce([&](auto, auto, auto, auto captureCallback, auto) {
-            captureCallback(QImage{}, QImage{}, QImage{});
+    EXPECT_CALL(collectorMock, start(_, _, _, _, _, _))
+        .WillOnce([&](auto, auto, auto, auto captureCallback, auto, auto) {
+            captureCallback(QImage{}, QImage{}, QImage{}, {});
             notification.notify();
         });
 
@@ -591,9 +598,9 @@ TEST_F(ImageCacheGenerator, dont_call_null_abort_callback_for_null_image)
 
 TEST_F(ImageCacheGenerator, dont_call_null_abort_callback)
 {
-    EXPECT_CALL(collectorMock, start(_, _, _, _, _))
-        .WillOnce([&](auto, auto, auto, auto, auto abortCallback) {
-            abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
+    EXPECT_CALL(collectorMock, start(_, _, _, _, _, _))
+        .WillOnce([&](auto, auto, auto, auto, auto abortCallback, auto) {
+            abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
             notification.notify();
         });