QmlDesigner: Add property editor tracing

Change-Id: I80dd04d1721c0ae3ab84c061f92e0646beb1ccf2 Reviewed-by: Thomas Hartmann <thomas.hartmann@qt.io>
2025-06-02 11:46:43 +02:00
parent 42fd3f8a60
commit 4a81749343
37 changed files with 1594 additions and 163 deletions
--- a/src/plugins/qmldesigner/CMakeLists.txt
+++ b/src/plugins/qmldesigner/CMakeLists.txt
@@ -32,10 +32,15 @@ env_with_default("QDS_DESIGNVIEWER_USE_STAGING" ENV_QDS_DESIGNVIEWER_USE_STAGING
 option(QDS_DESIGNVIEWER_USE_STAGING "Use staging API URL for Design Viewer" ${ENV_QDS_DESIGNVIEWER_USE_STAGING})
 add_feature_info("Use staging API URL for Design Viewer" ${QDS_DESIGNVIEWER_USE_STAGING} "")

+env_with_default("QTC_ENABLE_PROPERTY_EDITOR_TRACING" ENV_QTC_ENABLE_PROPERTY_EDITOR_TRACING OFF)
+option(ENABLE_PROPERTY_EDITOR_TRACING "Enable property editor tracing" ${ENV_QTC_ENABLE_PROPERTY_EDITOR_TRACING})
+add_feature_info("Property editor tracing" ${ENABLE_PROPERTY_EDITOR_TRACING} "")

 env_with_default("QTC_ENABLE_FORM_EDITOR_TRACING" ENV_QTC_ENABLE_FORM_EDITOR_TRACING OFF)
 option(ENABLE_FORM_EDITOR_TRACING "Enable form editor tracing" ${ENV_QTC_ENABLE_FORM_EDITOR_TRACING})
-add_feature_info("Model tracing" ${ENABLE_FORM_EDITOR_TRACING} "")
+add_feature_info("Form editor tracing" ${ENABLE_FORM_EDITOR_TRACING} "")
+
+

 if(QDS_DESIGNVIEWER_USE_STAGING)
  add_definitions(-DQDS_DESIGNVIEWER_USE_STAGING)
@@ -409,7 +414,9 @@ extend_qtc_plugin(QmlDesigner

 extend_qtc_plugin(QmlDesigner
  SOURCES_PREFIX components/propertyeditor
-  PUBLIC_INCLUDES components/propertyeditor
+  PUBLIC_INCLUDES components/propertyeditor  
+  PUBLIC_DEFINES
+    $<$<BOOL:${ENABLE_PROPERTY_EDITOR_TRACING}>:ENABLE_PROPERTY_EDITOR_TRACING>
  SOURCES
    aligndistribute.cpp aligndistribute.h
    assetimageprovider.cpp assetimageprovider.h
@@ -430,6 +437,7 @@ extend_qtc_plugin(QmlDesigner
    propertyeditorcontextobject.cpp propertyeditorcontextobject.h
    propertyeditordynamicpropertiesproxymodel.cpp propertyeditordynamicpropertiesproxymodel.h
    propertyeditorqmlbackend.cpp propertyeditorqmlbackend.h
+    propertyeditortracing.cpp propertyeditortracing.h
    propertyeditortransaction.cpp propertyeditortransaction.h
    propertyeditorvalue.cpp propertyeditorvalue.h
    propertyeditorview.cpp propertyeditorview.h
--- a/src/plugins/qmldesigner/components/propertyeditor/aligndistribute.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/aligndistribute.cpp
@@ -3,6 +3,8 @@

 #include "aligndistribute.h"

+#include "propertyeditortracing.h"
+
 #include <nodeabstractproperty.h>
 #include <qmldesignerplugin.h>
 #include <qmlmodelnodeproxy.h>
@@ -23,12 +25,18 @@ using namespace Utils;

 namespace QmlDesigner {

+static auto category = PropertyEditorTracing::category;
+
 AlignDistribute::AlignDistribute(QObject *parent)
    : QObject(parent)
-{}
+{
+    NanotraceHR::Tracer tracer{"align distribute constructor", category()};
+}

 bool AlignDistribute::multiSelection() const
 {
+    NanotraceHR::Tracer tracer{"align distribute multiSelection", category()};
+
    if (!m_qmlObjectNode.isValid())
        return false;

@@ -37,6 +45,8 @@ bool AlignDistribute::multiSelection() const

 bool AlignDistribute::selectionHasAnchors() const
 {
+    NanotraceHR::Tracer tracer{"align distribute selection has anchors", category()};
+
    if (!m_qmlObjectNode.isValid())
        return true;

@@ -51,6 +61,8 @@ bool AlignDistribute::selectionHasAnchors() const

 bool AlignDistribute::selectionExclusivlyItems() const
 {
+    NanotraceHR::Tracer tracer{"align distribute selection exclusivly items", category()};
+
    if (!m_qmlObjectNode.isValid())
        return false;

@@ -64,6 +76,8 @@ bool AlignDistribute::selectionExclusivlyItems() const

 bool AlignDistribute::selectionContainsRootItem() const
 {
+    NanotraceHR::Tracer tracer{"align distribute selection contains root item", category()};
+
    if (!m_qmlObjectNode.isValid())
        return true;

@@ -78,6 +92,8 @@ bool AlignDistribute::selectionContainsRootItem() const

 void AlignDistribute::setModelNodeBackend(const QVariant &modelNodeBackend)
 {
+    NanotraceHR::Tracer tracer{"align distribute set model node backend", category()};
+
    auto modelNodeBackendObject = modelNodeBackend.value<QObject *>();
    const auto backendObjectCasted = qobject_cast<const QmlModelNodeProxy *>(modelNodeBackendObject);

@@ -92,11 +108,15 @@ void AlignDistribute::setModelNodeBackend(const QVariant &modelNodeBackend)
 // function or associated MEMBER variable. The property will be invalid.
 QVariant AlignDistribute::modelNodeBackend() const
 {
+    NanotraceHR::Tracer tracer{"align distribute model node backend", category()};
+
    return {};
 }

 void AlignDistribute::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"align distribute register declarative type", category()};
+
    qmlRegisterType<AlignDistribute>("HelperWidgets", 2, 0, "AlignDistribute");
 }

@@ -256,7 +276,9 @@ inline static qreal getInstanceSceneY(const QmlItemNode &qmlItemNode)

 void AlignDistribute::alignObjects(Target target, AlignTo alignTo, const QString &keyObject)
 {
-    QTC_ASSERT(m_qmlObjectNode.isValid(), return );
+    NanotraceHR::Tracer tracer{"align distribute align objects", category()};
+
+    QTC_ASSERT(m_qmlObjectNode.isValid(), return);

    const auto selectionContext = SelectionContext(m_qmlObjectNode.view());
    if (selectionContext.selectedModelNodes().empty())
@@ -347,6 +369,8 @@ void AlignDistribute::alignObjects(Target target, AlignTo alignTo, const QString

 void AlignDistribute::distributeObjects(Target target, AlignTo alignTo, const QString &keyObject)
 {
+    NanotraceHR::Tracer tracer{"align distribute distribute objects", category()};
+
    QTC_ASSERT(m_qmlObjectNode.isValid(), return );

    const auto selectionContext = SelectionContext(m_qmlObjectNode.view());
@@ -508,6 +532,8 @@ void AlignDistribute::distributeSpacing(Dimension dimension,
                                        const qreal &distance,
                                        DistributeOrigin distributeOrigin)
 {
+    NanotraceHR::Tracer tracer{"align distribute distribute spacing", category()};
+
    QTC_ASSERT(m_qmlObjectNode.isValid(), return );

    const auto selectionContext = SelectionContext(m_qmlObjectNode.view());
@@ -637,6 +663,8 @@ void AlignDistribute::distributeSpacing(Dimension dimension,

 AlignDistribute::CompareFunction AlignDistribute::getCompareFunction(Target target) const
 {
+    NanotraceHR::Tracer tracer{"align distribute get compare function", category()};
+
    static const std::map<Target, CompareFunction> cmpMap = {{Target::Left, compareByLeft},
                                                             {Target::CenterH, compareByCenterH},
                                                             {Target::Right, compareByRight},
@@ -648,6 +676,8 @@ AlignDistribute::CompareFunction AlignDistribute::getCompareFunction(Target targ

 AlignDistribute::Dimension AlignDistribute::getDimension(Target target) const
 {
+    NanotraceHR::Tracer tracer{"align distribute get dimension", category()};
+
    switch (target) {
    case Target::Left:
    case Target::CenterH:
@@ -665,6 +695,8 @@ AlignDistribute::Dimension AlignDistribute::getDimension(Target target) const

 bool AlignDistribute::executePixelPerfectDialog() const
 {
+    NanotraceHR::Tracer tracer{"align distribute execute pixel perfect dialog", category()};
+
    Utils::CheckableDecider decider(Key("WarnAboutPixelPerfectDistribution"));

    QMessageBox::StandardButton pressed = Utils::CheckableMessageBox::question(
--- a/src/plugins/qmldesigner/components/propertyeditor/assetimageprovider.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/assetimageprovider.cpp
@@ -3,6 +3,8 @@

 #include "assetimageprovider.h"

+#include "propertyeditortracing.h"
+
 #include <asset.h>
 #include <imagecache/imagecacheimageresponse.h>

@@ -18,6 +20,9 @@ namespace QmlDesigner {
 QQuickImageResponse *AssetImageProvider::requestImageResponse(const QString &id,
                                                              const QSize &requestedSize)
 {
+    NanotraceHR::Tracer tracer{"asset image provider request image response",
+                               PropertyEditorTracing::category()};
+
    if (id.endsWith(".mesh"))
        return m_imageCacheProvider.requestImageResponse(id, {});

--- a/src/plugins/qmldesigner/components/propertyeditor/colorpalettebackend.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/colorpalettebackend.cpp
@@ -3,6 +3,8 @@

 #include "colorpalettebackend.h"

+#include "propertyeditortracing.h"
+
 #include <coreplugin/icore.h>

 #include <QApplication>
@@ -21,6 +23,8 @@ namespace QmlDesigner {

 QPointer<ColorPaletteBackend> ColorPaletteBackend::m_instance = nullptr;

+static auto category = PropertyEditorTracing::category;
+
 ColorPaletteBackend::ColorPaletteBackend()
    : m_currentPalette()
    , m_data()
@@ -29,6 +33,8 @@ ColorPaletteBackend::ColorPaletteBackend()
    , updateTimer(0)
 #endif
 {
+    NanotraceHR::Tracer tracer{"color palette backend constructor", category()};
+
    m_data.insert(g_recent, Palette(QmlDesigner::DesignerSettingsKey::COLOR_PALETTE_RECENT));
    m_data.insert(g_favorite, Palette(QmlDesigner::DesignerSettingsKey::COLOR_PALETTE_FAVORITE));

@@ -47,6 +53,8 @@ ColorPaletteBackend::ColorPaletteBackend()

 ColorPaletteBackend::~ColorPaletteBackend()
 {
+    NanotraceHR::Tracer tracer{"color palette backend destructor", category()};
+
    //writePalettes(); // TODO crash on QtDS close
    if (m_eyeDropperActive)
        eyeDropperLeave(QCursor::pos(), EyeDropperEventFilter::LeaveReason::Default);
@@ -54,19 +62,26 @@ ColorPaletteBackend::~ColorPaletteBackend()

 void ColorPaletteBackend::readPalettes()
 {
+    NanotraceHR::Tracer tracer{"color palette backend read palettes", category()};
+
    for (auto &palette : m_data)
        palette.read();
 }

 void ColorPaletteBackend::writePalettes()
 {
+    NanotraceHR::Tracer tracer{"color palette backend write palettes", category()};
+
    for (auto &palette : m_data)
        palette.write();
 }

 void ColorPaletteBackend::addColor(const QString &color, const QString &paletteName)
 {
+    NanotraceHR::Tracer tracer{"color palette backend add color", category()};
+
    auto found = m_data.find(paletteName);
+
    if (found == m_data.end()) {
        qWarning() << Q_FUNC_INFO << "Unknown palette: " << paletteName;
        return;
@@ -92,6 +107,8 @@ void ColorPaletteBackend::addColor(const QString &color, const QString &paletteN

 void ColorPaletteBackend::removeColor(int id, const QString &paletteName)
 {
+    NanotraceHR::Tracer tracer{"color palette backend remove color", category()};
+
    auto found = m_data.find(paletteName);

    if (found == m_data.end()) {
@@ -122,6 +139,8 @@ void ColorPaletteBackend::removeColor(int id, const QString &paletteName)

 void ColorPaletteBackend::addRecentColor(const QString &item)
 {
+    NanotraceHR::Tracer tracer{"color palette backend add recent color", category()};
+
    if (m_data[g_recent].m_colors.isEmpty()) {
        addColor(item, g_recent);
        return;
@@ -134,26 +153,36 @@ void ColorPaletteBackend::addRecentColor(const QString &item)

 void ColorPaletteBackend::addFavoriteColor(const QString &item)
 {
+    NanotraceHR::Tracer tracer{"color palette backend add favorite color", category()};
+
    addColor(item, g_favorite);
 }

 void ColorPaletteBackend::removeFavoriteColor(int id)
 {
+    NanotraceHR::Tracer tracer{"color palette backend  remove favorite color", category()};
+
    removeColor(id, g_favorite);
 }

 QStringList ColorPaletteBackend::palettes() const
 {
+    NanotraceHR::Tracer tracer{"color palette backend get palettes", category()};
+
    return m_data.keys();
 }

 const QString &ColorPaletteBackend::currentPalette() const
 {
+    NanotraceHR::Tracer tracer{"color palette backend get current palette", category()};
+
    return m_currentPalette;
 }

 void ColorPaletteBackend::setCurrentPalette(const QString &palette)
 {
+    NanotraceHR::Tracer tracer{"color palette backend set current palette", category()};
+
    if (!m_data.contains(palette)) {
        qWarning() << Q_FUNC_INFO << "Unknown palette: " << palette;
        return;
@@ -186,11 +215,15 @@ void ColorPaletteBackend::setCurrentPalette(const QString &palette)

 const QStringList &ColorPaletteBackend::currentPaletteColors() const
 {
+    NanotraceHR::Tracer tracer{"color palette backend get current palette colors", category()};
+
    return m_currentPaletteColors;
 }

 void ColorPaletteBackend::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"color palette backend register declarative type", category()};
+
    [[maybe_unused]] static const int typeIndex = qmlRegisterSingletonType<ColorPaletteBackend>(
        "QtQuickDesignerColorPalette", 1, 0, "ColorPaletteBackend", [](QQmlEngine *, QJSEngine *) {
            return new ColorPaletteBackend();
@@ -199,6 +232,8 @@ void ColorPaletteBackend::registerDeclarativeType()

 void ColorPaletteBackend::showDialog(QColor color)
 {
+    NanotraceHR::Tracer tracer{"color palette backend show dialog", category()};
+
    auto colorDialog = new QColorDialog(Core::ICore::dialogParent());
    colorDialog->setCurrentColor(color);
    colorDialog->setAttribute(Qt::WA_DeleteOnClose);
@@ -213,11 +248,15 @@ void ColorPaletteBackend::showDialog(QColor color)

 void ColorPaletteBackend::invokeEyeDropper()
 {
+    NanotraceHR::Tracer tracer{"color palette backend invoke eye dropper", category()};
+
    eyeDropperEnter();
 }

 void ColorPaletteBackend::eyeDropperEnter()
 {
+    NanotraceHR::Tracer tracer{"color palette backend eye dropper enter", category()};
+
    if (m_eyeDropperActive)
        return;

@@ -278,6 +317,8 @@ void ColorPaletteBackend::eyeDropperEnter()
 void ColorPaletteBackend::eyeDropperLeave(const QPoint &pos,
                                          EyeDropperEventFilter::LeaveReason actionOnLeave)
 {
+    NanotraceHR::Tracer tracer{"color palette backend eye dropper leave", category()};
+
    if (!m_eyeDropperActive)
        return;

@@ -306,6 +347,8 @@ void ColorPaletteBackend::eyeDropperLeave(const QPoint &pos,

 void ColorPaletteBackend::eyeDropperPointerMoved(const QPoint &pos)
 {
+    NanotraceHR::Tracer tracer{"color palette backend eye dropper pointer moved", category()};
+
    m_eyeDropperCurrentColor = grabScreenColor(pos);
    updateEyeDropperPosition(pos);
 }
@@ -318,11 +361,15 @@ const QSize g_halfPreviewSize = g_previewSize / 2;

 QColor ColorPaletteBackend::grabScreenColor(const QPoint &p)
 {
+    NanotraceHR::Tracer tracer{"color palette backend grab screen color", category()};
+
    return grabScreenRect(QRect(p, QSize(1, 1))).pixel(0, 0);
 }

 QImage ColorPaletteBackend::grabScreenRect(const QRect &r)
 {
+    NanotraceHR::Tracer tracer{"color palette backend grab screen rect", category()};
+
    QScreen *screen = QGuiApplication::screenAt(r.topLeft());
    if (!screen)
        screen = QGuiApplication::primaryScreen();
@@ -339,6 +386,8 @@ QImage ColorPaletteBackend::grabScreenRect(const QRect &r)

 void ColorPaletteBackend::updateEyeDropper()
 {
+    NanotraceHR::Tracer tracer{"color palette backend update eye dropper", category()};
+
 #ifndef QT_NO_CURSOR
    static QPoint lastGlobalPos;
    const QPoint newGlobalPos = QCursor::pos();
@@ -356,6 +405,8 @@ void ColorPaletteBackend::updateEyeDropper()

 void ColorPaletteBackend::updateEyeDropperPosition(const QPoint &globalPos)
 {
+    NanotraceHR::Tracer tracer{"color palette backend update eye dropper position", category()};
+
 #if QT_CONFIG(cursor)
    QPoint topLeft = globalPos - QPoint(g_halfCursorSize.width(), g_halfCursorSize.height());
    updateCursor(grabScreenRect(QRect(topLeft, g_cursorSize)));
@@ -364,6 +415,8 @@ void ColorPaletteBackend::updateEyeDropperPosition(const QPoint &globalPos)

 void ColorPaletteBackend::updateCursor(const QImage &image)
 {
+    NanotraceHR::Tracer tracer{"color palette backend update cursor", category()};
+
    QWindow *window = Core::ICore::mainWindow()->windowHandle();
    if (!window)
        return;
@@ -422,6 +475,7 @@ void ColorPaletteBackend::updateCursor(const QImage &image)

 bool ColorPaletteBackend::eyeDropperActive() const
 {
+    NanotraceHR::Tracer tracer{"color palette backend eye dropper active", category()};
    return m_eyeDropperActive;
 }

--- a/src/plugins/qmldesigner/components/propertyeditor/compatibleproperties.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/compatibleproperties.cpp
@@ -3,6 +3,8 @@

 #include "compatibleproperties.h"

+#include "propertyeditortracing.h"
+
 #include <bindingproperty.h>
 #include <qmlobjectnode.h>
 #include <qmltimelinekeyframegroup.h>
@@ -10,6 +12,8 @@

 namespace QmlDesigner {

+static auto category = PropertyEditorTracing::category;
+
 /*!
 * \internal
 * \brief Extracts and removes compatible properties from \param properties.
@@ -17,6 +21,8 @@ namespace QmlDesigner {
 */
 void CompatibleProperties::createCompatibilityMap(QList<PropertyName> &properties)
 {
+    NanotraceHR::Tracer tracer{"compatible properties compatibility map", category()};
+
    m_compatibilityMap.clear();
    if (m_oldInfo == m_newInfo || !m_oldInfo.isQtQuick3DMaterial() || !m_newInfo.isQtQuick3DMaterial())
        return;
@@ -63,6 +69,8 @@ void CompatibleProperties::createCompatibilityMap(QList<PropertyName> &propertie

 void CompatibleProperties::copyMappedProperties(const ModelNode &node)
 {
+    NanotraceHR::Tracer tracer{"compatible properties copy mapped properties", category()};
+
    if (m_compatibilityMap.isEmpty())
        return;
    // Copy mapped properties to new name. Note that this will only copy the base
@@ -95,6 +103,8 @@ void CompatibleProperties::copyMappedProperties(const ModelNode &node)

 void CompatibleProperties::applyCompatibleProperties(const ModelNode &node)
 {
+    NanotraceHR::Tracer tracer{"compatible properties apply compatible properties", category()};
+
    for (const auto &pair : m_compatibilityMap.asKeyValueRange()) {
        const CopyData &copyData = pair.second;
        if (copyData.isBinding) {
--- a/src/plugins/qmldesigner/components/propertyeditor/designerpropertymap.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/designerpropertymap.cpp
@@ -3,14 +3,21 @@

 #include "designerpropertymap.h"

+#include "propertyeditortracing.h"
+
 namespace QmlDesigner {

+static auto category = PropertyEditorTracing::category;
+
 DesignerPropertyMap::DesignerPropertyMap(QObject *parent) : QQmlPropertyMap(parent)
 {
+    NanotraceHR::Tracer tracer{"designer property map", category()};
 }

 QVariant DesignerPropertyMap::value(const QString &key) const
 {
+    NanotraceHR::Tracer tracer{"designer property map value", QmlDesigner::category()};
+
    if (contains(key))
        return QQmlPropertyMap::value(key);
    return QVariant();
@@ -18,7 +25,10 @@ QVariant DesignerPropertyMap::value(const QString &key) const

 void DesignerPropertyMap::registerDeclarativeType(const QString &name)
 {
-    qmlRegisterType<DesignerPropertyMap>("Bauhaus",1,0,name.toUtf8());
+    NanotraceHR::Tracer tracer{"designer property map register declarative type",
+                               QmlDesigner::category()};
+
+    qmlRegisterType<DesignerPropertyMap>("Bauhaus", 1, 0, name.toUtf8());
 }

 } //QmlDesigner
--- a/src/plugins/qmldesigner/components/propertyeditor/dynamicpropertiesproxymodel.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/dynamicpropertiesproxymodel.cpp
@@ -26,9 +26,10 @@
 #include "dynamicpropertiesproxymodel.h"

 #include "bindingproperty.h"
+#include "propertyeditortracing.h"
 #include "propertyeditorvalue.h"
-#include <scripteditorutils.h>

+#include <scripteditorutils.h>
 #include <dynamicpropertiesmodel.h>

 #include <abstractproperty.h>
@@ -45,6 +46,8 @@

 namespace QmlDesigner {

+static auto category = PropertyEditorTracing::category;
+
 static const int propertyNameRole = Qt::UserRole + 1;
 static const int propertyTypeRole = Qt::UserRole + 2;
 static const int propertyValueRole = Qt::UserRole + 3;
@@ -53,10 +56,13 @@ static const int propertyBindingRole = Qt::UserRole + 4;
 DynamicPropertiesProxyModel::DynamicPropertiesProxyModel(QObject *parent)
    : QAbstractListModel(parent)
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model constructor", category()};
 }

 void DynamicPropertiesProxyModel::initModel(DynamicPropertiesModel *model)
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model init model", category()};
+
    m_model = model;

    connect(m_model, &QAbstractItemModel::modelAboutToBeReset,
@@ -84,14 +90,18 @@ void DynamicPropertiesProxyModel::initModel(DynamicPropertiesModel *model)

 int DynamicPropertiesProxyModel::rowCount(const QModelIndex &) const
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model row count", category()};
+
    return m_model ? m_model->rowCount() : 0;
 }

 QHash<int, QByteArray> DynamicPropertiesProxyModel::roleNames() const
 {
-    static QHash<int, QByteArray> roleNames{{propertyNameRole,    "propertyName"},
-                                            {propertyTypeRole,    "propertyType"},
-                                            {propertyValueRole,   "propertyValue"},
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model role names", category()};
+
+    static QHash<int, QByteArray> roleNames{{propertyNameRole, "propertyName"},
+                                            {propertyTypeRole, "propertyType"},
+                                            {propertyValueRole, "propertyValue"},
                                            {propertyBindingRole, "propertyBinding"}};

    return roleNames;
@@ -99,6 +109,8 @@ QHash<int, QByteArray> DynamicPropertiesProxyModel::roleNames() const

 QVariant DynamicPropertiesProxyModel::data(const QModelIndex &index, int role) const
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model data", category()};
+
    if (index.isValid() && index.row() < rowCount()) {
        AbstractProperty property = m_model->propertyForRow(index.row());

@@ -132,6 +144,8 @@ QVariant DynamicPropertiesProxyModel::data(const QModelIndex &index, int role) c

 void DynamicPropertiesProxyModel::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model register declarative type", category()};
+
    static bool registered = false;
    if (!registered)
        qmlRegisterType<DynamicPropertiesProxyModel>("HelperWidgets", 2, 0, "DynamicPropertiesModel");
@@ -139,11 +153,14 @@ void DynamicPropertiesProxyModel::registerDeclarativeType()

 DynamicPropertiesModel *DynamicPropertiesProxyModel::dynamicPropertiesModel() const
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model dynamic properties model", category()};
    return m_model;
 }

 QString DynamicPropertiesProxyModel::newPropertyName() const
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model new property name", category()};
+
    DynamicPropertiesModel *propsModel = dynamicPropertiesModel();

    return QString::fromUtf8(uniquePropertyName("newName", propsModel->singleSelectedNode()));
@@ -151,6 +168,8 @@ QString DynamicPropertiesProxyModel::newPropertyName() const

 void DynamicPropertiesProxyModel::createProperty(const QString &name, const QString &type)
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model create property", category()};
+
    QmlDesignerPlugin::emitUsageStatistics(Constants::EVENT_PROPERTY_ADDED);

    TypeName typeName = type.toUtf8();
@@ -191,6 +210,8 @@ void DynamicPropertiesProxyModel::createProperty(const QString &name, const QStr

 DynamicPropertyRow::DynamicPropertyRow()
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model constructor", category()};
+
    m_backendValue = new PropertyEditorValue(this);

    QObject::connect(m_backendValue,
@@ -211,16 +232,22 @@ DynamicPropertyRow::DynamicPropertyRow()

 DynamicPropertyRow::~DynamicPropertyRow()
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model destructor", category()};
+
    clearProxyBackendValues();
 }

 void DynamicPropertyRow::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model register declarative type", category()};
+
    qmlRegisterType<DynamicPropertyRow>("HelperWidgets", 2, 0, "DynamicPropertyRow");
 }

 void DynamicPropertyRow::setRow(int r)
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model set row", category()};
+
    if (m_row == r)
        return;

@@ -231,11 +258,15 @@ void DynamicPropertyRow::setRow(int r)

 int DynamicPropertyRow::row() const
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model get row", category()};
+
    return m_row;
 }

 void DynamicPropertyRow::setModel(DynamicPropertiesProxyModel *model)
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model set model", category()};
+
    if (model == m_model)
        return;

@@ -259,21 +290,30 @@ void DynamicPropertyRow::setModel(DynamicPropertiesProxyModel *model)

 DynamicPropertiesProxyModel *DynamicPropertyRow::model() const
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model get model", category()};
+
    return m_model;
 }

 PropertyEditorValue *DynamicPropertyRow::backendValue() const
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model get backend value", category()};
+
    return m_backendValue;
 }

 void DynamicPropertyRow::remove()
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model remove", category()};
+
    m_model->dynamicPropertiesModel()->remove(m_row);
 }

 PropertyEditorValue *DynamicPropertyRow::createProxyBackendValue()
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model create proxy backend value",
+                               category()};
+
    auto *newValue = new PropertyEditorValue(this);
    m_proxyBackendValues.append(newValue);

@@ -284,12 +324,17 @@ PropertyEditorValue *DynamicPropertyRow::createProxyBackendValue()

 void DynamicPropertyRow::clearProxyBackendValues()
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model clear proxy backend values",
+                               category()};
+
    qDeleteAll(m_proxyBackendValues);
    m_proxyBackendValues.clear();
 }

 void DynamicPropertyRow::setupBackendValue()
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model setup backend value", category()};
+
    if (!m_model)
        return;

@@ -333,6 +378,8 @@ void DynamicPropertyRow::setupBackendValue()

 void DynamicPropertyRow::commitValue(const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model commit value", category()};
+
    if (m_lock)
        return;

@@ -381,6 +428,8 @@ void DynamicPropertyRow::commitValue(const QVariant &value)

 void DynamicPropertyRow::commitExpression(const QString &expression)
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model commit expression", category()};
+
    if (m_lock || m_row < 0)
        return;

@@ -428,6 +477,8 @@ void DynamicPropertyRow::commitExpression(const QString &expression)

 void DynamicPropertyRow::handleDataChanged(const QModelIndex &topLeft, const QModelIndex &, const QList<int> &)
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model handle data changed", category()};
+
    if (m_model->dynamicPropertiesModel()->isCallbackToModelBlocked())
        return;

@@ -437,6 +488,8 @@ void DynamicPropertyRow::handleDataChanged(const QModelIndex &topLeft, const QMo

 void DynamicPropertyRow::resetValue()
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model reset value", category()};
+
    if (m_lock || m_row < 0)
        return;

--- a/src/plugins/qmldesigner/components/propertyeditor/fileresourcesmodel.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/fileresourcesmodel.cpp
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

 #include "fileresourcesmodel.h"
+#include "propertyeditortracing.h"

 #include <coreplugin/icore.h>

@@ -19,10 +20,14 @@

 static QString s_lastBrowserPath;

+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 FileResourcesModel::FileResourcesModel(QObject *parent)
    : QObject(parent)
    , m_filter(QLatin1String("(*.*)"))
 {
+    NanotraceHR::Tracer tracer{"file resources model consstructor", category()};
+
    ProjectExplorer::Project *project = ProjectExplorer::ProjectManager::projectForFile(
        QmlDesigner::DocumentManager::currentFilePath());

@@ -36,6 +41,8 @@ FileResourcesModel::FileResourcesModel(QObject *parent)

 void FileResourcesModel::setModelNodeBackend(const QVariant &modelNodeBackend)
 {
+    NanotraceHR::Tracer tracer{"file resources model set model node backend", category()};
+
    auto modelNodeBackendObject = modelNodeBackend.value<QObject *>();

    const auto backendObjectCasted = qobject_cast<const QmlDesigner::QmlModelNodeProxy *>(
@@ -57,11 +64,15 @@ void FileResourcesModel::setModelNodeBackend(const QVariant &modelNodeBackend)

 QString FileResourcesModel::fileName() const
 {
+    NanotraceHR::Tracer tracer{"file resources model file name", category()};
+
    return m_fileName.toString();
 }

 void FileResourcesModel::setFileNameStr(const QString &fileName)
 {
+    NanotraceHR::Tracer tracer{"file resources model set file name", category()};
+
    setFileName(QUrl(fileName));
 }

@@ -77,6 +88,8 @@ void FileResourcesModel::setFileName(const QUrl &fileName)

 void FileResourcesModel::setPath(const QUrl &url)
 {
+    NanotraceHR::Tracer tracer{"file resources model set path", category()};
+
    m_path = url;
    refreshModel();

@@ -85,16 +98,22 @@ void FileResourcesModel::setPath(const QUrl &url)

 QUrl FileResourcesModel::path() const
 {
+    NanotraceHR::Tracer tracer{"file resources model path", category()};
+
    return m_path;
 }

 QUrl FileResourcesModel::docPath() const
 {
+    NanotraceHR::Tracer tracer{"file resources model doc path", category()};
+
    return QUrl::fromLocalFile(m_docPath.path());
 }

 void FileResourcesModel::setFilter(const QString &filter)
 {
+    NanotraceHR::Tracer tracer{"file resources model set filter", category()};
+
    if (m_filter == filter)
        return;

@@ -106,16 +125,22 @@ void FileResourcesModel::setFilter(const QString &filter)

 QString FileResourcesModel::filter() const
 {
+    NanotraceHR::Tracer tracer{"file resources model filter", category()};
+
    return m_filter;
 }

 QList<FileResourcesItem> FileResourcesModel::model() const
 {
+    NanotraceHR::Tracer tracer{"file resources model model", category()};
+
    return m_model;
 }

 void FileResourcesModel::openFileDialog(const QString &customPath)
 {
+    NanotraceHR::Tracer tracer{"file resources model open file dialog", category()};
+
    QString resourcePath = customPath.isEmpty() ? m_path.toLocalFile() : customPath;
    bool resourcePathChanged = m_lastResourcePath != resourcePath;
    m_lastResourcePath = resourcePath;
@@ -149,6 +174,8 @@ void FileResourcesModel::openFileDialog(const QString &customPath)

 QString FileResourcesModel::resolve(const QString &relative) const
 {
+    NanotraceHR::Tracer tracer{"file resources model resolve", category()};
+
    if (relative.startsWith('#'))
        return relative;

@@ -170,20 +197,26 @@ QString FileResourcesModel::resolve(const QString &relative) const

 bool FileResourcesModel::isLocal(const QString &path) const
 {
+    NanotraceHR::Tracer tracer{"file resources model is local", category()};
+
    return QUrl::fromUserInput(path, m_docPath.path()).isLocalFile();
 }

 void FileResourcesModel::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"file resources model register declarative type", category()};
+
    qmlRegisterType<FileResourcesModel>("HelperWidgets", 2, 0, "FileResourcesModel");
 }

 QVariant FileResourcesModel::modelNodeBackend() const
 {
+    NanotraceHR::Tracer tracer{"file resources model model node backend", category()};
+
    return QVariant();
 }

-bool filterMetaIcons(const QString &fileName)
+static bool filterMetaIcons(const QString &fileName)
 {
    QFileInfo info(fileName);

@@ -210,6 +243,8 @@ bool filterMetaIcons(const QString &fileName)

 void FileResourcesModel::refreshModel()
 {
+    NanotraceHR::Tracer tracer{"file resources model refresh model", category()};
+
    m_model.clear();

    if (m_path.isValid()) {
--- a/src/plugins/qmldesigner/components/propertyeditor/fontresourcesmodel.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/fontresourcesmodel.cpp
@@ -3,6 +3,7 @@

 #include "fontresourcesmodel.h"
 #include "fileresourcesmodel.h"
+#include "propertyeditortracing.h"

 #include <cmakeprojectmanager/cmakekitaspect.h>
 #include <designermcumanager.h>
@@ -32,6 +33,8 @@ using namespace Qt::Literals::StringLiterals;

 namespace {

+auto category = QmlDesigner::PropertyEditorTracing::category;
+
 QStringList makeFontFilesFilterList()
 {
    QStringList filterList;
@@ -100,11 +103,15 @@ QSet<QString> systemFonts()

 void FontResourcesModel::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"font resources model register declarative type", category()};
+
    qmlRegisterType<FontResourcesModel>("HelperWidgets", 2, 0, "FontResourcesModel");
 }

 QVariant FontResourcesModel::modelNodeBackend()
 {
+    NanotraceHR::Tracer tracer{"font resources model model node backend", category()};
+
    return {};
 }

@@ -112,16 +119,22 @@ FontResourcesModel::FontResourcesModel(QObject *parent)
    : QObject{parent}
    , m_resourceModel{std::make_unique<FileResourcesModel>()}
 {
+    NanotraceHR::Tracer tracer{"font resources model constructor", category()};
+
    m_resourceModel->setFilter(fontFilesFilterList().join(' '));
 }

 void FontResourcesModel::setModelNodeBackend(const QVariant &modelNodeBackend)
 {
+    NanotraceHR::Tracer tracer{"file resources model set model node backend", category()};
+
    m_resourceModel->setModelNodeBackend(modelNodeBackend);
 }

 QStringList FontResourcesModel::model() const
 {
+    NanotraceHR::Tracer tracer{"file resources model model", category()};
+
    QSet<QString> fonts;
    for (const auto &item : m_resourceModel->model()) {
        fonts.insert(fontFamily(item.absoluteFilePath()));
@@ -137,20 +150,28 @@ QStringList FontResourcesModel::model() const

 void FontResourcesModel::refreshModel()
 {
+    NanotraceHR::Tracer tracer{"file resources model refresh model", category()};
+
    m_resourceModel->refreshModel();
 }

 void FontResourcesModel::openFileDialog(const QString &customPath)
 {
+    NanotraceHR::Tracer tracer{"file resources model open file dialog", category()};
+
    m_resourceModel->openFileDialog(customPath);
 }

 QString FontResourcesModel::resolve(const QString &relative) const
 {
+    NanotraceHR::Tracer tracer{"file resources model resolve", category()};
+
    return m_resourceModel->resolve(relative);
 }

 bool FontResourcesModel::isLocal(const QString &path) const
 {
+    NanotraceHR::Tracer tracer{"file resources model is local", category()};
+
    return m_resourceModel->isLocal(path);
 }
--- a/src/plugins/qmldesigner/components/propertyeditor/fontresourcesmodel.h
+++ b/src/plugins/qmldesigner/components/propertyeditor/fontresourcesmodel.h
@@ -30,8 +30,8 @@ public:
    void refreshModel();

    Q_INVOKABLE void openFileDialog(const QString &customPath = {});
-    Q_INVOKABLE [[nodiscard]] QString resolve(const QString &relative) const;
-    Q_INVOKABLE [[nodiscard]] bool isLocal(const QString &path) const;
+    [[nodiscard]] Q_INVOKABLE QString resolve(const QString &relative) const;
+    [[nodiscard]] Q_INVOKABLE bool isLocal(const QString &path) const;

 signals:
    void fileNameChanged(const QUrl &fileName);
--- a/src/plugins/qmldesigner/components/propertyeditor/gradientmodel.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/gradientmodel.cpp
@@ -5,6 +5,7 @@

 #include "gradientpresetcustomlistmodel.h"
 #include "gradientpresetitem.h"
+#include "propertyeditortracing.h"
 #include "propertyeditorview.h"
 #include "qmlanchorbindingproxy.h"

@@ -22,6 +23,9 @@
 #include <QTimer>

 namespace {
+
+auto category = QmlDesigner::PropertyEditorTracing::category;
+
 constexpr auto widthBinding = [](const QStringView nodeName) -> QString {
    return QString("%1.width").arg(nodeName);
 };
@@ -257,10 +261,13 @@ void prepareGradient(const T &array,
 GradientModel::GradientModel(QObject *parent) :
    QAbstractListModel(parent)
 {
+    NanotraceHR::Tracer tracer{"gradient model constructor", category()};
 }

 int GradientModel::rowCount(const QModelIndex & /*parent*/) const
 {
+    NanotraceHR::Tracer tracer{"gradient model row count", category()};
+
    if (m_itemNode.modelNode().hasNodeProperty(gradientPropertyName().toUtf8())) {
        QmlDesigner::ModelNode gradientNode = m_itemNode.modelNode()
                                                  .nodeProperty(gradientPropertyName().toUtf8())
@@ -275,20 +282,21 @@ int GradientModel::rowCount(const QModelIndex & /*parent*/) const

 QHash<int, QByteArray> GradientModel::roleNames() const
 {
-    static QHash<int, QByteArray> roleNames{
-        {Qt::UserRole + 1, "position"},
-        {Qt::UserRole + 2, "color"},
-        {Qt::UserRole + 3, "readOnly"},
-        {Qt::UserRole + 4, "index"}
-    };
+    NanotraceHR::Tracer tracer{"gradient model role names", category()};
+
+    static QHash<int, QByteArray> roleNames{{Qt::UserRole + 1, "position"},
+                                            {Qt::UserRole + 2, "color"},
+                                            {Qt::UserRole + 3, "readOnly"},
+                                            {Qt::UserRole + 4, "index"}};

    return roleNames;
 }

 QVariant GradientModel::data(const QModelIndex &index, int role) const
 {
-    if (index.isValid() && index.row() < rowCount()) {
+    NanotraceHR::Tracer tracer{"gradient model data", category()};

+    if (index.isValid() && index.row() < rowCount()) {
        if (role == Qt::UserRole + 3) {
            if (index.row() == 0 || index.row() == (rowCount() - 1))
                return true;
@@ -312,6 +320,8 @@ QVariant GradientModel::data(const QModelIndex &index, int role) const

 int GradientModel::addStop(qreal position, const QColor &color)
 {
+    NanotraceHR::Tracer tracer{"gradient model add stop", category()};
+
    if (m_locked)
        return -1;

@@ -354,6 +364,8 @@ int GradientModel::addStop(qreal position, const QColor &color)

 void GradientModel::addGradient()
 {
+    NanotraceHR::Tracer tracer{"gradient model add gradient", category()};
+
    if (m_locked)
        return;

@@ -397,6 +409,8 @@ void GradientModel::addGradient()

 void GradientModel::setColor(int index, const QColor &color)
 {
+    NanotraceHR::Tracer tracer{"gradient model set color", category()};
+
    if (locked())
        return;

@@ -417,6 +431,8 @@ void GradientModel::setColor(int index, const QColor &color)

 void GradientModel::setPosition(int index, qreal positition)
 {
+    NanotraceHR::Tracer tracer{"gradient model set position", category()};
+
    if (locked())
        return;

@@ -431,6 +447,8 @@ void GradientModel::setPosition(int index, qreal positition)

 QColor GradientModel::getColor(int index) const
 {
+    NanotraceHR::Tracer tracer{"gradient model get color", category()};
+
    if (index < rowCount()) {
        QmlDesigner::ModelNode gradientNode =  m_itemNode.modelNode().nodeProperty(gradientPropertyName().toUtf8()).modelNode();
        QmlDesigner::QmlObjectNode stop = gradientNode.nodeListProperty("stops").at(index);
@@ -443,6 +461,8 @@ QColor GradientModel::getColor(int index) const

 qreal GradientModel::getPosition(int index) const
 {
+    NanotraceHR::Tracer tracer{"gradient model get position", category()};
+
    if (index < rowCount()) {
        QmlDesigner::ModelNode gradientNode =  m_itemNode.modelNode().nodeProperty(gradientPropertyName().toUtf8()).modelNode();
        QmlDesigner::QmlObjectNode stop = gradientNode.nodeListProperty("stops").at(index);
@@ -455,6 +475,8 @@ qreal GradientModel::getPosition(int index) const

 void GradientModel::removeStop(int index)
 {
+    NanotraceHR::Tracer tracer{"gradient model remove stop", category()};
+
    if (index < rowCount() - 1 && index != 0) {
        view()->executeInTransaction("GradientModel::removeStop", [this, index](){
            QmlDesigner::ModelNode gradientNode =  m_itemNode.modelNode().nodeProperty(gradientPropertyName().toUtf8()).modelNode();
@@ -476,6 +498,8 @@ void GradientModel::removeStop(int index)

 void GradientModel::deleteGradient()
 {
+    NanotraceHR::Tracer tracer{"gradient model delete gradient", category()};
+
    if (!m_itemNode.isValid())
        return;

@@ -490,21 +514,29 @@ void GradientModel::deleteGradient()

 void GradientModel::lock()
 {
+    NanotraceHR::Tracer tracer{"gradient model lock", category()};
+
    m_locked = true;
 }

 void GradientModel::unlock()
 {
+    NanotraceHR::Tracer tracer{"gradient model unlock", category()};
+
    m_locked = false;
 }

 void GradientModel::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"gradient model register declarative type", category()};
+
    qmlRegisterType<GradientModel>("HelperWidgets", 2, 0, "GradientModel");
 }

 qreal GradientModel::readGradientProperty(const QString &propertyName) const
 {
+    NanotraceHR::Tracer tracer{"gradient model read gradient property", category()};
+
    if (!m_itemNode.isValid())
        return 0;

@@ -520,11 +552,15 @@ qreal GradientModel::readGradientProperty(const QString &propertyName) const

 qreal GradientModel::readGradientPropertyPercentage(const QString &propertyName) const
 {
+    NanotraceHR::Tracer tracer{"gradient model read gradient property percentage", category()};
+
    return getPercentageGradientProperty(propertyName.toUtf8());
 }

 QString GradientModel::readGradientOrientation() const
 {
+    NanotraceHR::Tracer tracer{"gradient model read gradient orientation", category()};
+
    if (!m_itemNode.isValid())
        return QString();

@@ -541,6 +577,8 @@ QString GradientModel::readGradientOrientation() const
 GradientModel::GradientPropertyUnits GradientModel::readGradientPropertyUnits(
    const QString &propertyName) const
 {
+    NanotraceHR::Tracer tracer{"gradient model read gradient property units", category()};
+
    if (hasPercentageGradientProperty(propertyName))
        return GradientPropertyUnits::Percentage;

@@ -559,6 +597,8 @@ bool GradientModel::isPercentageSupportedByProperty(const QString &propertyName,

 void GradientModel::setupModel()
 {
+    NanotraceHR::Tracer tracer{"gradient model setup model", category()};
+
    m_locked = true;
    const QScopeGuard cleanup([&] { m_locked = false; });

@@ -568,7 +608,9 @@ void GradientModel::setupModel()

 void GradientModel::setAnchorBackend(const QVariant &anchorBackend)
 {
-    auto anchorBackendObject = anchorBackend.value<QObject*>();
+    NanotraceHR::Tracer tracer{"gradient model set anchor backend", category()};
+
+    auto anchorBackendObject = anchorBackend.value<QObject *>();

    const auto backendCasted =
            qobject_cast<const QmlDesigner::QmlAnchorBindingProxy *>(anchorBackendObject);
@@ -592,32 +634,44 @@ void GradientModel::setAnchorBackend(const QVariant &anchorBackend)

 QString GradientModel::gradientPropertyName() const
 {
+    NanotraceHR::Tracer tracer{"gradient model gradient property name", category()};
+
    return m_gradientPropertyName;
 }

 void GradientModel::setGradientPropertyName(const QString &name)
 {
+    NanotraceHR::Tracer tracer{"gradient model set gradient property name", category()};
+
    m_gradientPropertyName = name;
 }

 QString GradientModel::gradientTypeName() const
 {
+    NanotraceHR::Tracer tracer{"gradient model gradient type name", category()};
+
    return m_gradientTypeName;
 }

 void GradientModel::setGradientTypeName(const QString &name)
 {
+    NanotraceHR::Tracer tracer{"gradient model set gradient type name", category()};
+
    m_gradientTypeName = name;
 }

 bool GradientModel::hasGradient() const
 {
+    NanotraceHR::Tracer tracer{"gradient model has gradient", category()};
+
    return m_itemNode.isValid()
-            && m_itemNode.modelNode().hasProperty(gradientPropertyName().toUtf8());
+           && m_itemNode.modelNode().hasProperty(gradientPropertyName().toUtf8());
 }

 bool GradientModel::locked() const
 {
+    NanotraceHR::Tracer tracer{"gradient model locked", category()};
+
    if (m_locked)
        return true;

@@ -628,6 +682,8 @@ bool GradientModel::locked() const

 bool GradientModel::hasShapesImport() const
 {
+    NanotraceHR::Tracer tracer{"gradient model has shapes import", category()};
+
    if (m_itemNode.isValid()) {
        QmlDesigner::Import import = QmlDesigner::Import::createLibraryImport("QtQuick.Shapes", "1.0");
        return model()->hasImport(import, true, true);
@@ -638,6 +694,8 @@ bool GradientModel::hasShapesImport() const

 void GradientModel::ensureShapesImport()
 {
+    NanotraceHR::Tracer tracer{"gradient model ensure shapes import", category()};
+
    if (!hasShapesImport()) {
        QmlDesigner::Import timelineImport = QmlDesigner::Import::createLibraryImport("QtQuick.Shapes", "1.0");
        try {
@@ -650,6 +708,8 @@ void GradientModel::ensureShapesImport()

 void GradientModel::setupGradientProperties(const QmlDesigner::ModelNode &gradient)
 {
+    NanotraceHR::Tracer tracer{"gradient model setup gradient properties", category()};
+
    QTC_ASSERT(m_itemNode.isValid(), return);

    QTC_ASSERT(gradient.isValid(), return);
@@ -676,23 +736,31 @@ void GradientModel::setupGradientProperties(const QmlDesigner::ModelNode &gradie

 QmlDesigner::Model *GradientModel::model() const
 {
+    NanotraceHR::Tracer tracer{"gradient model model", category()};
+
    QTC_ASSERT(m_itemNode.isValid(), return nullptr);
    return m_itemNode.view()->model();
 }

 QmlDesigner::AbstractView *GradientModel::view() const
 {
+    NanotraceHR::Tracer tracer{"gradient model view", category()};
+
    QTC_ASSERT(m_itemNode.isValid(), return nullptr);
    return m_itemNode.view();
 }

 void GradientModel::resetPuppet()
 {
+    NanotraceHR::Tracer tracer{"gradient model reset puppet", category()};
+
    QTimer::singleShot(1000, view(), &QmlDesigner::AbstractView::resetPuppet);
 }

 QmlDesigner::ModelNode GradientModel::createGradientNode()
 {
+    NanotraceHR::Tracer tracer{"gradient model create gradient node", category()};
+
 #ifdef QDS_USE_PROJECTSTORAGE
    QmlDesigner::TypeName typeName = m_gradientTypeName.toUtf8();
    auto gradientNode = view()->createModelNode(typeName);
@@ -719,6 +787,8 @@ QmlDesigner::ModelNode GradientModel::createGradientNode()

 QmlDesigner::ModelNode GradientModel::createGradientStopNode()
 {
+    NanotraceHR::Tracer tracer{"gradient model create gradient stop node", category()};
+
 #ifdef QDS_USE_PROJECTSTORAGE
    return view()->createModelNode("GradientStop");
 #else
@@ -734,6 +804,8 @@ QmlDesigner::ModelNode GradientModel::createGradientStopNode()

 void GradientModel::deleteGradientNode(bool saveTransaction)
 {
+    NanotraceHR::Tracer tracer{"gradient model delete gradient node", category()};
+
    QmlDesigner::ModelNode modelNode = m_itemNode.modelNode();

    if (m_itemNode.isInBaseState()) {
@@ -754,6 +826,8 @@ void GradientModel::deleteGradientNode(bool saveTransaction)

 bool GradientModel::hasPercentageGradientProperty(const QString &propertyName) const
 {
+    NanotraceHR::Tracer tracer{"gradient model has percentage gradient property", category()};
+
    bool result = false;
    getPercentageGradientProperty(propertyName.toUtf8(), &result);
    return result;
@@ -762,6 +836,8 @@ bool GradientModel::hasPercentageGradientProperty(const QString &propertyName) c
 qreal GradientModel::getPercentageGradientProperty(const QmlDesigner::PropertyNameView propertyName,
                                                   bool *ok) const
 {
+    NanotraceHR::Tracer tracer{"gradient model get percentage gradient property", category()};
+
    if (ok != nullptr)
        *ok = false;

@@ -809,6 +885,8 @@ qreal GradientModel::getPercentageGradientProperty(const QmlDesigner::PropertyNa

 QVariant GradientModel::getGradientPropertyVariant(const QString &propertyName) const
 {
+    NanotraceHR::Tracer tracer{"gradient model get gradient property variant", category()};
+
    if (!m_itemNode.isValid())
        return {};

@@ -825,6 +903,8 @@ QVariant GradientModel::getGradientPropertyVariant(const QString &propertyName)
 ShapeGradientPropertyData GradientModel::getDefaultGradientPropertyData(
    const QmlDesigner::PropertyNameView propertyName, const QStringView &gradientType) const
 {
+    NanotraceHR::Tracer tracer{"gradient model get default gradient property data", category()};
+
    const auto *gradData = getDefaultGradientData(propertyName, gradientType);
    if (gradData != nullptr)
        return *gradData;
@@ -834,6 +914,8 @@ ShapeGradientPropertyData GradientModel::getDefaultGradientPropertyData(

 void GradientModel::setGradientProperty(const QString &propertyName, qreal value)
 {
+    NanotraceHR::Tracer tracer{"gradient model set gradient property", category()};
+
    QTC_ASSERT(m_itemNode.isValid(), return);

    QmlDesigner::QmlObjectNode gradient = m_itemNode.modelNode()
@@ -851,6 +933,8 @@ void GradientModel::setGradientProperty(const QString &propertyName, qreal value

 void GradientModel::setGradientPropertyPercentage(const QString &propertyName, qreal value)
 {
+    NanotraceHR::Tracer tracer{"gradient model set gradient property percentage", category()};
+
    QTC_ASSERT(m_itemNode.isValid(), return);

    QmlDesigner::QmlObjectNode gradient = m_itemNode.modelNode()
@@ -883,6 +967,8 @@ void GradientModel::setGradientPropertyPercentage(const QString &propertyName, q

 void GradientModel::setGradientOrientation(Qt::Orientation value)
 {
+    NanotraceHR::Tracer tracer{"gradient model set gradient orientation", category()};
+
    QTC_ASSERT(m_itemNode.isValid(), return);

    QmlDesigner::QmlObjectNode gradient = m_itemNode.modelNode()
@@ -903,6 +989,8 @@ void GradientModel::setGradientOrientation(Qt::Orientation value)
 void GradientModel::setGradientPropertyUnits(const QString &propertyName,
                                             GradientModel::GradientPropertyUnits value)
 {
+    NanotraceHR::Tracer tracer{"gradient model set gradient property units", category()};
+
    //translate from previous units to the new unit system
    const bool toPixels = (value == GradientPropertyUnits::Pixels);
    const bool toPercentage = (value == GradientPropertyUnits::Percentage);
@@ -952,6 +1040,8 @@ void GradientModel::setGradientPropertyUnits(const QString &propertyName,

 void GradientModel::setPresetByID(int presetID)
 {
+    NanotraceHR::Tracer tracer{"gradient model set preset by ID", category()};
+
    const QGradient gradient(GradientPresetItem::createGradientFromPreset(
        static_cast<GradientPresetItem::Preset>(presetID)));
    const QList<QGradientStop> gradientStops = gradient.stops().toList();
@@ -971,6 +1061,8 @@ void GradientModel::setPresetByStops(const QList<qreal> &stopsPositions,
                                     int stopsCount,
                                     bool saveTransaction)
 {
+    NanotraceHR::Tracer tracer{"gradient model set preset by stops", category()};
+
    if (m_locked)
        return;

@@ -1017,6 +1109,8 @@ void GradientModel::setPresetByStops(const QList<qreal> &stopsPositions,

 void GradientModel::savePreset()
 {
+    NanotraceHR::Tracer tracer{"gradient model save preset", category()};
+
    //preparing qgradient:
    QGradient currentGradient;
    QGradientStops currentStops;
@@ -1040,6 +1134,8 @@ void GradientModel::savePreset()

 void GradientModel::updateGradient()
 {
+    NanotraceHR::Tracer tracer{"gradient model update gradient", category()};
+
    beginResetModel();

    QList<qreal> stops;
--- a/src/plugins/qmldesigner/components/propertyeditor/gradientpresetcustomlistmodel.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/gradientpresetcustomlistmodel.cpp
@@ -3,6 +3,7 @@

 #include "gradientpresetcustomlistmodel.h"
 #include "gradientpresetitem.h"
+#include "propertyeditortracing.h"

 #include <coreplugin/icore.h>
 #include <utils/qtcassert.h>
@@ -14,7 +15,9 @@
 #include <QSettings>
 #include <QFile>

-namespace Internal {
+namespace {
+
+auto category = QmlDesigner::PropertyEditorTracing::category;

 const char settingsKey[] = "GradientPresetCustomList";
 const char settingsFileName[] = "GradientPresets.ini";
@@ -27,45 +30,56 @@ QString settingsFullFilePath(const QSettings::Scope &scope)
    return Core::ICore::userResourcePath(settingsFileName).toUrlishString();
 }

-} // namespace Internal
+} // namespace

 GradientPresetCustomListModel::GradientPresetCustomListModel(QObject *parent)
    : GradientPresetListModel(parent)
    , m_filename(getFilename())
 {
+    NanotraceHR::Tracer tracer{"gradient preset custom list model constructor", category()};
+
    readPresets();
 }

-GradientPresetCustomListModel::~GradientPresetCustomListModel() {}
+GradientPresetCustomListModel::~GradientPresetCustomListModel()
+{
+    NanotraceHR::Tracer tracer{"gradient preset custom list model destructor", category()};
+}

 void GradientPresetCustomListModel::registerDeclarativeType()
 {
-    qmlRegisterType<GradientPresetCustomListModel>("HelperWidgets",
-                                                   2,
-                                                   0,
-                                                   "GradientPresetCustomListModel");
+    NanotraceHR::Tracer tracer{"gradient preset custom list model register declarative type",
+                               category()};
+
+    qmlRegisterType<GradientPresetCustomListModel>("HelperWidgets", 2, 0, "GradientPresetCustomListModel");
 }

 QString GradientPresetCustomListModel::getFilename()
 {
-    return Internal::settingsFullFilePath(QSettings::UserScope);
+    NanotraceHR::Tracer tracer{"gradient preset custom list model get filename", category()};
+
+    return settingsFullFilePath(QSettings::UserScope);
 }

 void GradientPresetCustomListModel::storePresets(const QString &filename,
                                                 const QList<GradientPresetItem> &items)
 {
+    NanotraceHR::Tracer tracer{"gradient preset custom list model store presets", category()};
+
    const QList<QVariant> presets = Utils::transform<QList<QVariant>>(
        items, [](const GradientPresetItem &item) { return QVariant::fromValue(item); });

    QSettings settings(filename, QSettings::IniFormat);
    settings.clear();
-    settings.setValue(Internal::settingsKey, QVariant::fromValue(presets));
+    settings.setValue(settingsKey, QVariant::fromValue(presets));
 }

 QList<GradientPresetItem> GradientPresetCustomListModel::storedPresets(const QString &filename)
 {
+    NanotraceHR::Tracer tracer{"gradient preset custom list model stored presets", category()};
+
    const QSettings settings(filename, QSettings::IniFormat);
-    const QVariant presetSettings = settings.value(Internal::settingsKey);
+    const QVariant presetSettings = settings.value(settingsKey);

    if (!presetSettings.isValid())
        return {};
@@ -86,6 +100,8 @@ void GradientPresetCustomListModel::addGradient(const QList<qreal> &stopsPositio
                                                const QList<QString> &stopsColors,
                                                int stopsCount)
 {
+    NanotraceHR::Tracer tracer{"gradient preset custom list model add gradient", category()};
+
    QGradient tempGradient;
    QGradientStops gradientStops;
    QGradientStop gradientStop;
@@ -102,6 +118,8 @@ void GradientPresetCustomListModel::addGradient(const QList<qreal> &stopsPositio

 void GradientPresetCustomListModel::changePresetName(int id, const QString &newName)
 {
+    NanotraceHR::Tracer tracer{"gradient preset custom list model change preset name", category()};
+
    QTC_ASSERT(id >= 0, return);
    QTC_ASSERT(id < m_items.size(), return);
    m_items[id].setPresetName(newName);
@@ -110,6 +128,8 @@ void GradientPresetCustomListModel::changePresetName(int id, const QString &newN

 void GradientPresetCustomListModel::deletePreset(int id)
 {
+    NanotraceHR::Tracer tracer{"gradient preset custom list model delete preset", category()};
+
    QTC_ASSERT(id >= 0, return);
    QTC_ASSERT(id < m_items.size(), return);
    beginResetModel();
@@ -120,11 +140,15 @@ void GradientPresetCustomListModel::deletePreset(int id)

 void GradientPresetCustomListModel::writePresets()
 {
+    NanotraceHR::Tracer tracer{"gradient preset custom list model write presets", category()};
+
    storePresets(m_filename, m_items);
 }

 void GradientPresetCustomListModel::readPresets()
 {
+    NanotraceHR::Tracer tracer{"gradient preset custom list model read presets", category()};
+
    const QList<GradientPresetItem> presets = storedPresets(m_filename);
    beginResetModel();
    m_items.clear();
--- a/src/plugins/qmldesigner/components/propertyeditor/gradientpresetdefaultlistmodel.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/gradientpresetdefaultlistmodel.cpp
@@ -3,22 +3,33 @@

 #include "gradientpresetdefaultlistmodel.h"
 #include "gradientpresetitem.h"
+#include "propertyeditortracing.h"

 #include <QHash>
 #include <QByteArray>
 #include <QDebug>
 #include <QFile>

+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 GradientPresetDefaultListModel::GradientPresetDefaultListModel(QObject *parent)
    : GradientPresetListModel(parent)
 {
+    NanotraceHR::Tracer tracer{"gradient preset default list model constructor", category()};
+
    addAllPresets();
 }

-GradientPresetDefaultListModel::~GradientPresetDefaultListModel() {}
+GradientPresetDefaultListModel::~GradientPresetDefaultListModel()
+{
+    NanotraceHR::Tracer tracer{"gradient preset default list model destructor", category()};
+}

 void GradientPresetDefaultListModel::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"gradient preset default list model register declarative type",
+                               category()};
+
    qmlRegisterType<GradientPresetDefaultListModel>("HelperWidgets",
                                                    2,
                                                    0,
@@ -27,6 +38,8 @@ void GradientPresetDefaultListModel::registerDeclarativeType()

 void GradientPresetDefaultListModel::addAllPresets()
 {
+    NanotraceHR::Tracer tracer{"gradient preset default list model add all presets", category()};
+
    const QMetaObject &metaObj = QGradient::staticMetaObject;
    const QMetaEnum metaEnum = metaObj.enumerator(metaObj.indexOfEnumerator("Preset"));

--- a/src/plugins/qmldesigner/components/propertyeditor/gradientpresetitem.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/gradientpresetitem.cpp
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

 #include "gradientpresetitem.h"
+#include "propertyeditortracing.h"

 #include <utils/qtcassert.h>
 #include <utils/algorithm.h>
@@ -14,26 +15,36 @@

 #include <algorithm>

+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 GradientPresetItem::GradientPresetItem()
    : m_gradientVal(QGradient())
    , m_gradientID(Preset(0))
    , m_presetName(QString())
-{}
+{
+    NanotraceHR::Tracer tracer{"gradient preset item default constructor", category()};
+}

 GradientPresetItem::GradientPresetItem(const QGradient &value, const QString &name)
    : m_gradientVal(value)
    , m_gradientID(Preset(0))
    , m_presetName(name)
-{}
+{
+    NanotraceHR::Tracer tracer{"gradient preset item constructor with gradient and name", category()};
+}

 GradientPresetItem::GradientPresetItem(const Preset value)
    : m_gradientVal(createGradientFromPreset(value))
    , m_gradientID(value)
    , m_presetName(getNameByPreset(value))
-{}
+{
+    NanotraceHR::Tracer tracer{"gradient preset item constructor with preset", category()};
+}

 QVariant GradientPresetItem::getProperty(GradientPresetItem::Property id) const
 {
+    NanotraceHR::Tracer tracer{"gradient preset item get property", category()};
+
    QVariant out;

    switch (id) {
@@ -65,11 +76,15 @@ QVariant GradientPresetItem::getProperty(GradientPresetItem::Property id) const

 QGradient GradientPresetItem::gradientVal() const
 {
+    NanotraceHR::Tracer tracer{"gradient preset item gradient value", category()};
+
    return m_gradientVal;
 }

 void GradientPresetItem::setGradient(const QGradient &value)
 {
+    NanotraceHR::Tracer tracer{"gradient preset item set gradient", category()};
+
    m_gradientVal = value;
    m_gradientID = Preset(0);
    m_presetName = QString();
@@ -77,6 +92,8 @@ void GradientPresetItem::setGradient(const QGradient &value)

 void GradientPresetItem::setGradient(const Preset value)
 {
+    NanotraceHR::Tracer tracer{"gradient preset item set gradient by preset", category()};
+
    m_gradientID = value;
    m_gradientVal = createGradientFromPreset(value);
    m_presetName = getNameByPreset(value);
@@ -84,6 +101,8 @@ void GradientPresetItem::setGradient(const Preset value)

 QList<qreal> GradientPresetItem::stopsPosList() const
 {
+    NanotraceHR::Tracer tracer{"gradient preset item stops position list", category()};
+
    const QList<QPair<qreal, QColor>> subres = m_gradientVal.stops().toList();
    const QList<qreal> result = Utils::transform<QList<qreal>>(subres,
                                                               [](const QPair<qreal, QColor> &item) {
@@ -94,6 +113,8 @@ QList<qreal> GradientPresetItem::stopsPosList() const

 QList<QString> GradientPresetItem::stopsColorList() const
 {
+    NanotraceHR::Tracer tracer{"gradient preset item stops color list", category()};
+
    const QList<QPair<qreal, QColor>> subres = m_gradientVal.stops().toList();
    const QList<QString> result
        = Utils::transform<QList<QString>>(subres, [](const QPair<qreal, QColor> &item) {
@@ -104,26 +125,36 @@ QList<QString> GradientPresetItem::stopsColorList() const

 int GradientPresetItem::stopListSize() const
 {
+    NanotraceHR::Tracer tracer{"gradient preset item stop list size", category()};
+
    return m_gradientVal.stops().size();
 }

 void GradientPresetItem::setPresetName(const QString &value)
 {
+    NanotraceHR::Tracer tracer{"gradient preset item set preset name", category()};
+
    m_presetName = value;
 }

 QString GradientPresetItem::presetName() const
 {
+    NanotraceHR::Tracer tracer{"gradient preset item preset name", category()};
+
    return m_presetName;
 }

 int GradientPresetItem::presetID() const
 {
+    NanotraceHR::Tracer tracer{"gradient preset item preset ID", category()};
+
    return static_cast<int>(m_gradientID);
 }

 QString GradientPresetItem::getNameByPreset(Preset value)
 {
+    NanotraceHR::Tracer tracer{"gradient preset item get name by preset", category()};
+
    const QMetaObject &metaObj = QGradient::staticMetaObject;
    const QMetaEnum metaEnum = metaObj.enumerator(metaObj.indexOfEnumerator("Preset"));

@@ -143,6 +174,8 @@ QString GradientPresetItem::getNameByPreset(Preset value)

 QGradient GradientPresetItem::createGradientFromPreset(Preset value)
 {
+    NanotraceHR::Tracer tracer{"gradient preset item create gradient from preset", category()};
+
    return QGradient(value);
 }

@@ -156,6 +189,7 @@ QDebug &operator<<(QDebug &stream, const GradientPresetItem &gradient)

 QDataStream &operator<<(QDataStream &stream, const GradientPresetItem &gradient)
 {
+    NanotraceHR::Tracer tracer{"gradient preset item operator <<", category()};
    stream << gradient.m_gradientVal.stops();

    stream << static_cast<int>(gradient.m_gradientID);
@@ -165,6 +199,8 @@ QDataStream &operator<<(QDataStream &stream, const GradientPresetItem &gradient)

 QDataStream &operator>>(QDataStream &stream, GradientPresetItem &gradient)
 {
+    NanotraceHR::Tracer tracer{"gradient preset item operator >>", category()};
+
    QGradientStops stops;
    stream >> stops;
    gradient.m_gradientVal.setStops(stops);
--- a/src/plugins/qmldesigner/components/propertyeditor/gradientpresetlistmodel.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/gradientpresetlistmodel.cpp
@@ -3,35 +3,46 @@

 #include "gradientpresetlistmodel.h"
 #include "gradientpresetitem.h"
+#include "propertyeditortracing.h"

 #include <QHash>
 #include <QByteArray>
 #include <QDebug>

+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 GradientPresetListModel::GradientPresetListModel(QObject *parent)
    : QAbstractListModel(parent)
 {
-    m_roleNames
-        = {{static_cast<int>(GradientPresetItem::Property::objectNameRole), "objectName"},
-           {static_cast<int>(GradientPresetItem::Property::stopsPosListRole), "stopsPosList"},
-           {static_cast<int>(GradientPresetItem::Property::stopsColorListRole), "stopsColorList"},
-           {static_cast<int>(GradientPresetItem::Property::stopListSizeRole), "stopListSize"},
-           {static_cast<int>(GradientPresetItem::Property::presetNameRole), "presetName"},
-           {static_cast<int>(GradientPresetItem::Property::presetIDRole), "presetID"}};
+    NanotraceHR::Tracer tracer{"gradient preset list model constructor", category()};
+
+    m_roleNames = {{static_cast<int>(GradientPresetItem::Property::objectNameRole), "objectName"},
+                   {static_cast<int>(GradientPresetItem::Property::stopsPosListRole), "stopsPosList"},
+                   {static_cast<int>(GradientPresetItem::Property::stopsColorListRole),
+                    "stopsColorList"},
+                   {static_cast<int>(GradientPresetItem::Property::stopListSizeRole), "stopListSize"},
+                   {static_cast<int>(GradientPresetItem::Property::presetNameRole), "presetName"},
+                   {static_cast<int>(GradientPresetItem::Property::presetIDRole), "presetID"}};
 }

 GradientPresetListModel::~GradientPresetListModel()
 {
+    NanotraceHR::Tracer tracer{"gradient preset list model destructor", category()};
+
    clearItems();
 }

 int GradientPresetListModel::rowCount(const QModelIndex & /*parent*/) const
 {
+    NanotraceHR::Tracer tracer{"gradient preset list model row count", category()};
+
    return m_items.size();
 }

 QVariant GradientPresetListModel::data(const QModelIndex &index, int role) const
 {
+    NanotraceHR::Tracer tracer{"gradient preset list model data", category()};
+
    if (index.isValid() && (index.row() >= 0) && (index.row() < m_items.size())) {
        if (m_roleNames.contains(role)) {
            QVariant value = m_items.at(index.row())
@@ -53,11 +64,15 @@ QVariant GradientPresetListModel::data(const QModelIndex &index, int role) const

 QHash<int, QByteArray> GradientPresetListModel::roleNames() const
 {
+    NanotraceHR::Tracer tracer{"gradient preset list model role names", category()};
+
    return m_roleNames;
 }

 void GradientPresetListModel::clearItems()
 {
+    NanotraceHR::Tracer tracer{"gradient preset list model clear items", category()};
+
    beginResetModel();
    m_items.clear();
    endResetModel();
@@ -65,6 +80,8 @@ void GradientPresetListModel::clearItems()

 void GradientPresetListModel::addItem(const GradientPresetItem &element)
 {
+    NanotraceHR::Tracer tracer{"gradient preset list model add item", category()};
+
    beginResetModel();
    m_items.append(element);
    endResetModel();
@@ -72,16 +89,21 @@ void GradientPresetListModel::addItem(const GradientPresetItem &element)

 const QList<GradientPresetItem> &GradientPresetListModel::items() const
 {
+    NanotraceHR::Tracer tracer{"gradient preset list model items", category()};
+
    return m_items;
 }

 void GradientPresetListModel::sortItems()
 {
+    NanotraceHR::Tracer tracer{"gradient preset list model sort items", category()};

    std::ranges::sort(m_items, {}, &GradientPresetItem::presetID);
 }

 void GradientPresetListModel::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"gradient preset list model register declarative type", category()};
+
    qmlRegisterType<GradientPresetListModel>("HelperWidgets", 2, 0, "GradientPresetListModel");
 }
--- a/src/plugins/qmldesigner/components/propertyeditor/instanceimageprovider.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/instanceimageprovider.cpp
@@ -2,18 +2,23 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

 #include "instanceimageprovider.h"
+#include "propertyeditortracing.h"

 #include <abstractview.h>
 #include <QTimer>

+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 static const char INSTANCE_IMAGE_REQUEST_ID[] = "PropertyEditor.InstanceImage";

 namespace QmlDesigner {

 InstanceImageProvider::InstanceImageProvider()
    : QQuickImageProvider(Pixmap)
-    , m_delayTimer(new QTimer(this))
+    , m_delayTimer(std::make_unique<QTimer>())
 {
+    NanotraceHR::Tracer tracer{"instance image provider constructor", category()};
+
    m_delayTimer->setInterval(500);
    m_delayTimer->setSingleShot(true);
    m_delayTimer->callOnTimeout([this] { requestOne(); });
@@ -30,6 +35,8 @@ InstanceImageProvider::InstanceImageProvider()
 */
 QPixmap InstanceImageProvider::requestPixmap(const QString &id, QSize *size, const QSize &requestedSize)
 {
+    NanotraceHR::Tracer tracer{"instance image provider request pixmap", category()};
+
    using namespace Qt::StringLiterals;
    static const QPixmap defaultImage = QPixmap::fromImage(
        QImage(":/propertyeditor/images/defaultmaterialpreview.png"));
@@ -69,6 +76,8 @@ bool InstanceImageProvider::feedImage(const ModelNode &node,
                                      const QPixmap &pixmap,
                                      const QByteArray &requestId)
 {
+    NanotraceHR::Tracer tracer{"instance image provider feed image", category()};
+
    if (!requestId.startsWith(INSTANCE_IMAGE_REQUEST_ID))
        return false;

@@ -83,16 +92,22 @@ bool InstanceImageProvider::feedImage(const ModelNode &node,

 void InstanceImageProvider::setModelNode(const ModelNode &node)
 {
+    NanotraceHR::Tracer tracer{"instance image provider set model node", category()};
+
    m_requestedNode = node;
 }

 bool InstanceImageProvider::hasPendingRequest() const
 {
+    NanotraceHR::Tracer tracer{"instance image provider has pending request", category()};
+
    return !m_pendingRequest.isEmpty();
 }

 void InstanceImageProvider::requestOne()
 {
+    NanotraceHR::Tracer tracer{"instance image provider request one", category()};
+
    if (!m_requestedNode)
        return;

@@ -109,18 +124,24 @@ void InstanceImageProvider::requestOne()

 void InstanceImageProvider::requestOne(QSize size)
 {
+    NanotraceHR::Tracer tracer{"instance image provider request one with size", category()};
+
    prepareRequest(size);
    requestOne();
 }

 void InstanceImageProvider::postponeRequest(QSize size)
 {
+    NanotraceHR::Tracer tracer{"instance image provider postpone request", category()};
+
    prepareRequest(size);
-    QMetaObject::invokeMethod(m_delayTimer, static_cast<void (QTimer::*)()>(&QTimer::start));
+    QMetaObject::invokeMethod(m_delayTimer.get(), static_cast<void (QTimer::*)()>(&QTimer::start));
 }

 void InstanceImageProvider::prepareRequest(QSize size)
 {
+    NanotraceHR::Tracer tracer{"instance image provider prepare request", category()};
+
    m_requestedSize = size;
 }

@@ -131,16 +152,22 @@ void InstanceImageProvider::prepareRequest(QSize size)
 */
 bool InstanceImageProvider::dataAvailable(const ModelNode &node, QSize size)
 {
+    NanotraceHR::Tracer tracer{"instance image provider data available", category()};
+
    return !m_resetRequest && node == m_receivedNode && size == m_receivedImage.size();
 }

 void InstanceImageProvider::invalidate()
 {
+    NanotraceHR::Tracer tracer{"instance image provider invalidate", category()};
+
    m_resetRequest = true;
 }

 QPixmap InstanceImageProvider::getScaledImage(QSize size)
 {
+    NanotraceHR::Tracer tracer{"instance image provider get scaled image", category()};
+
    if (size == m_receivedImage.size())
        return m_receivedImage;
    else
--- a/src/plugins/qmldesigner/components/propertyeditor/instanceimageprovider.h
+++ b/src/plugins/qmldesigner/components/propertyeditor/instanceimageprovider.h
@@ -47,7 +47,7 @@ private:

    QPixmap m_receivedImage;

-    QTimer *m_delayTimer = nullptr;
+    std::unique_ptr<QTimer> m_delayTimer;
 };

 } // namespace QmlDesigner
--- a/src/plugins/qmldesigner/components/propertyeditor/itemfiltermodel.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/itemfiltermodel.cpp
@@ -3,6 +3,8 @@

 #include "itemfiltermodel.h"

+#include "propertyeditortracing.h"
+
 #include <abstractview.h>
 #include <model.h>
 #include <nodemetainfo.h>
@@ -15,6 +17,8 @@

 using namespace QmlDesigner;

+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 ItemFilterModel::ItemFilterModel(QObject *parent)
    : QAbstractListModel(parent)
    , m_typeFilter("QtQuick.Item")
@@ -23,7 +27,9 @@ ItemFilterModel::ItemFilterModel(QObject *parent)

 void ItemFilterModel::setModelNodeBackend(const QVariant &modelNodeBackend)
 {
-    auto modelNodeBackendObject = modelNodeBackend.value<QObject*>();
+    NanotraceHR::Tracer tracer{"item filter model set model node backend", category()};
+
+    auto modelNodeBackendObject = modelNodeBackend.value<QObject *>();

    const auto backendObjectCasted =
            qobject_cast<const QmlModelNodeProxy *>(modelNodeBackendObject);
@@ -44,6 +50,8 @@ void ItemFilterModel::setModelNodeBackend(const QVariant &modelNodeBackend)

 void ItemFilterModel::setTypeFilter(const QString &filter)
 {
+    NanotraceHR::Tracer tracer{"item filter model set type filter", category()};
+
    if (m_typeFilter == filter)
        return;

@@ -54,6 +62,8 @@ void ItemFilterModel::setTypeFilter(const QString &filter)

 void ItemFilterModel::setSelectionOnly(bool value)
 {
+    NanotraceHR::Tracer tracer{"item filter model set selection only", category()};
+
    if (m_selectionOnly == value)
        return;

@@ -64,12 +74,16 @@ void ItemFilterModel::setSelectionOnly(bool value)

 void ItemFilterModel::setSelectedItems(const QStringList &selectedItems)
 {
+    NanotraceHR::Tracer tracer{"item filter model set selected items", category()};
+
    m_selectedItems = selectedItems;
    emit selectedItemsChanged();
 }

 void ItemFilterModel::setValidationRoles(const QStringList &validationRoles)
 {
+    NanotraceHR::Tracer tracer{"item filter model set validation roles", category()};
+
    auto tmp = validationRoles;
    tmp.removeDuplicates();

@@ -83,21 +97,29 @@ void ItemFilterModel::setValidationRoles(const QStringList &validationRoles)

 QString ItemFilterModel::typeFilter() const
 {
+    NanotraceHR::Tracer tracer{"item filter model type filter", category()};
+
    return m_typeFilter;
 }

 bool ItemFilterModel::selectionOnly() const
 {
+    NanotraceHR::Tracer tracer{"item filter model selection only", category()};
+
    return m_selectionOnly;
 }

 QStringList ItemFilterModel::selectedItems() const
 {
+    NanotraceHR::Tracer tracer{"item filter model selected items", category()};
+
    return m_selectedItems;
 }

 QStringList ItemFilterModel::itemModel() const
 {
+    NanotraceHR::Tracer tracer{"item filter model item model", category()};
+
    AbstractView *view = m_modelNode.view();
    if (!view || !view->model())
        return {};
@@ -111,16 +133,22 @@ QStringList ItemFilterModel::itemModel() const

 QStringList ItemFilterModel::validationRoles() const
 {
+    NanotraceHR::Tracer tracer{"item filter model validation roles", category()};
+
    return m_validationRoles;
 }

 QStringList ItemFilterModel::validationItems() const
 {
+    NanotraceHR::Tracer tracer{"item filter model validation items", category()};
+
    return m_validationItems;
 }

 QVariant ItemFilterModel::modelItemData(int row) const
 {
+    NanotraceHR::Tracer tracer{"item filter model model item data", category()};
+
    QModelIndex idx = index(row, 0, {});
    if (!idx.isValid())
        return {};
@@ -141,6 +169,8 @@ QVariant ItemFilterModel::modelItemData(int row) const

 int ItemFilterModel::indexFromId(const QString &id) const
 {
+    NanotraceHR::Tracer tracer{"item filter model index from id", category()};
+
    AbstractView *view = m_modelNode.view();
    if (!view || !view->model())
        return -1;
@@ -156,16 +186,22 @@ int ItemFilterModel::indexFromId(const QString &id) const

 void ItemFilterModel::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"item filter model register declarative type", category()};
+
    qmlRegisterType<ItemFilterModel>("HelperWidgets", 2, 0, "ItemFilterModel");
 }

 int ItemFilterModel::rowCount(const QModelIndex &) const
 {
+    NanotraceHR::Tracer tracer{"item filter model row count", category()};
+
    return m_modelInternalIds.size();
 }

 QVariant ItemFilterModel::data(const QModelIndex &index, int role) const
 {
+    NanotraceHR::Tracer tracer{"item filter model data", category()};
+
    if (!index.isValid() || index.row() >= rowCount())
        return {};

@@ -188,6 +224,8 @@ QVariant ItemFilterModel::data(const QModelIndex &index, int role) const

 QHash<int, QByteArray> ItemFilterModel::roleNames() const
 {
+    NanotraceHR::Tracer tracer{"item filter model role names", category()};
+
    static QHash<int, QByteArray> roleNames{{IdRole, "id"},
                                            {NameRole, "name"},
                                            {IdAndNameRole, "idAndName"},
@@ -198,11 +236,15 @@ QHash<int, QByteArray> ItemFilterModel::roleNames() const

 QVariant ItemFilterModel::modelNodeBackend() const
 {
+    NanotraceHR::Tracer tracer{"item filter model model node backend", category()};
+
    return {};
 }

 ModelNode ItemFilterModel::modelNodeForRow(const int &row) const
 {
+    NanotraceHR::Tracer tracer{"item filter model model node for row", category()};
+
    if (row < 0 || row >= m_modelInternalIds.size())
        return {};

@@ -215,6 +257,8 @@ ModelNode ItemFilterModel::modelNodeForRow(const int &row) const

 void ItemFilterModel::setupModel()
 {
+    NanotraceHR::Tracer tracer{"item filter model setup model", category()};
+
    if (!m_modelNode.isValid() || !m_modelNode.view()->isAttached())
        return;

@@ -238,6 +282,8 @@ void ItemFilterModel::setupModel()

 void ItemFilterModel::setupValidationItems()
 {
+    NanotraceHR::Tracer tracer{"item filter model setup validation items", category()};
+
    QStringList validationItems;

    for (const QString &role : m_validationRoles) {
--- a/src/plugins/qmldesigner/components/propertyeditor/listvalidator.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/listvalidator.cpp
@@ -3,12 +3,20 @@

 #include "listvalidator.h"

+#include "propertyeditortracing.h"
+
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 ListValidator::ListValidator(QObject *parent)
    : QValidator{parent}
-{}
+{
+    NanotraceHR::Tracer tracer{"list validator constructor", category()};
+}

 QValidator::State ListValidator::validate(QString &input, int &) const
 {
+    NanotraceHR::Tracer tracer{"list validator validate", category()};
+
    if (input.isEmpty())
        return QValidator::Intermediate;

@@ -30,6 +38,8 @@ QValidator::State ListValidator::validate(QString &input, int &) const

 void ListValidator::fixup(QString &input) const
 {
+    NanotraceHR::Tracer tracer{"list validator fixup", category()};
+
    for (const QString &item : m_filterList) {
        if (item.compare(input, Qt::CaseInsensitive) == 0) {
            input = item;
@@ -40,6 +50,8 @@ void ListValidator::fixup(QString &input) const

 void ListValidator::setFilterList(const QStringList &filterList)
 {
+    NanotraceHR::Tracer tracer{"list validator set filter list", category()};
+
    if (m_filterList == filterList)
        return;

@@ -49,10 +61,14 @@ void ListValidator::setFilterList(const QStringList &filterList)

 QStringList ListValidator::filterList() const
 {
+    NanotraceHR::Tracer tracer{"list validator filter list", category()};
+
    return m_filterList;
 }

 void ListValidator::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"list validator register declarative type", category()};
+
    qmlRegisterType<ListValidator>("HelperWidgets", 2, 0, "ListValidator");
 }
--- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorcontextobject.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorcontextobject.cpp
@@ -3,17 +3,19 @@

 #include "propertyeditorcontextobject.h"

-#include "abstractview.h"
 #include "compatibleproperties.h"
-#include "easingcurvedialog.h"
-#include "nodemetainfo.h"
+#include "propertyeditortracing.h"
 #include "propertyeditorutils.h"
-#include "qml3dnode.h"
-#include "qmldesignerconstants.h"
-#include "qmldesignerplugin.h"
-#include "qmlmodelnodeproxy.h"
-#include "qmlobjectnode.h"
-#include "qmltimeline.h"
+
+#include <abstractview.h>
+#include <easingcurvedialog.h>
+#include <nodemetainfo.h>
+#include <qml3dnode.h>
+#include <qmldesignerconstants.h>
+#include <qmldesignerplugin.h>
+#include <qmlmodelnodeproxy.h>
+#include <qmlobjectnode.h>
+#include <qmltimeline.h>

 #include <qmldesignerbase/settings/designersettings.h>

@@ -34,6 +36,8 @@

 namespace QmlDesigner {

+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 static Q_LOGGING_CATEGORY(urlSpecifics, "qtc.propertyeditor.specifics", QtWarningMsg)

 PropertyEditorContextObject::PropertyEditorContextObject(QObject *parent)
@@ -43,10 +47,14 @@ PropertyEditorContextObject::PropertyEditorContextObject(QObject *parent)
    , m_backendValues(nullptr)
    , m_qmlComponent(nullptr)
    , m_qmlContext(nullptr)
-{}
+{
+    NanotraceHR::Tracer tracer{"property editor context object constructor", category()};
+}

 QString PropertyEditorContextObject::convertColorToString(const QVariant &color)
 {
+    NanotraceHR::Tracer tracer{"property editor context object convert color to string", category()};
+
    QString colorString;
    QColor theColor;
    if (color.canConvert(QMetaType(QMetaType::QColor))) {
@@ -69,13 +77,16 @@ QString PropertyEditorContextObject::convertColorToString(const QVariant &color)

 QColor PropertyEditorContextObject::colorFromString(const QString &colorString)
 {
+    NanotraceHR::Tracer tracer{"property editor context object color from string", category()};
+
    return QColor::fromString(colorString);
 }

 QString PropertyEditorContextObject::translateFunction()
 {
-    if (QmlDesignerPlugin::instance()->settings().value(
-            DesignerSettingsKey::TYPE_OF_QSTR_FUNCTION).toInt())
+    NanotraceHR::Tracer tracer{"property editor context object translate function", category()};
+
+    if (QmlDesignerPlugin::instance()->settings().value(DesignerSettingsKey::TYPE_OF_QSTR_FUNCTION).toInt())

        switch (QmlDesignerPlugin::instance()->settings().value(
                    DesignerSettingsKey::TYPE_OF_QSTR_FUNCTION).toInt()) {
@@ -90,6 +101,8 @@ QString PropertyEditorContextObject::translateFunction()

 QStringList PropertyEditorContextObject::autoComplete(const QString &text, int pos, bool explicitComplete, bool filter)
 {
+    NanotraceHR::Tracer tracer{"property editor context object auto complete", category()};
+
    if (m_model && m_model->rewriterView())
        return  Utils::filtered(m_model->rewriterView()->autoComplete(text, pos, explicitComplete), [filter](const QString &string) {
            return !filter || (!string.isEmpty() && string.at(0).isUpper()); });
@@ -99,6 +112,8 @@ QStringList PropertyEditorContextObject::autoComplete(const QString &text, int p

 void PropertyEditorContextObject::toggleExportAlias()
 {
+    NanotraceHR::Tracer tracer{"property editor context object toggle export alias", category()};
+
    QTC_ASSERT(m_model && m_model->rewriterView(), return);

    /* Ideally we should not missuse the rewriterView
@@ -127,6 +142,8 @@ void PropertyEditorContextObject::toggleExportAlias()

 void PropertyEditorContextObject::goIntoComponent()
 {
+    NanotraceHR::Tracer tracer{"property editor context object go into component", category()};
+
    QTC_ASSERT(m_model && m_model->rewriterView(), return);

    /* Ideally we should not missuse the rewriterView
@@ -142,6 +159,8 @@ void PropertyEditorContextObject::goIntoComponent()

 void PropertyEditorContextObject::changeTypeName(const QString &typeName)
 {
+    NanotraceHR::Tracer tracer{"property editor context object change type name", category()};
+
    QTC_ASSERT(m_model && m_model->rewriterView(), return);

    /* Ideally we should not missuse the rewriterView
@@ -295,11 +314,15 @@ void PropertyEditorContextObject::insertKeyframe(const QString &propertyName)

 QString PropertyEditorContextObject::activeDragSuffix() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object active drag suffix", category()};
+
    return m_activeDragSuffix;
 }

 void PropertyEditorContextObject::setActiveDragSuffix(const QString &suffix)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set active drag suffix", category()};
+
    if (m_activeDragSuffix != suffix) {
        m_activeDragSuffix = suffix;
        emit activeDragSuffixChanged();
@@ -308,22 +331,29 @@ void PropertyEditorContextObject::setActiveDragSuffix(const QString &suffix)

 int PropertyEditorContextObject::majorVersion() const
 {
-    return m_majorVersion;
+    NanotraceHR::Tracer tracer{"property editor context object major version", category()};

+    return m_majorVersion;
 }

 int PropertyEditorContextObject::majorQtQuickVersion() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object major Qt Quick version", category()};
+
    return m_majorQtQuickVersion;
 }

 int PropertyEditorContextObject::minorQtQuickVersion() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object minor Qt Quick version", category()};
+
    return m_minorQtQuickVersion;
 }

 void PropertyEditorContextObject::setMajorVersion(int majorVersion)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set major version", category()};
+
    if (m_majorVersion == majorVersion)
        return;

@@ -334,6 +364,9 @@ void PropertyEditorContextObject::setMajorVersion(int majorVersion)

 void PropertyEditorContextObject::setMajorQtQuickVersion(int majorVersion)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set major Qt Quick version",
+                               category()};
+
    if (m_majorQtQuickVersion == majorVersion)
        return;

@@ -345,6 +378,9 @@ void PropertyEditorContextObject::setMajorQtQuickVersion(int majorVersion)

 void PropertyEditorContextObject::setMinorQtQuickVersion(int minorVersion)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set minor Qt Quick version",
+                               category()};
+
    if (m_minorQtQuickVersion == minorVersion)
        return;

@@ -355,6 +391,8 @@ void PropertyEditorContextObject::setMinorQtQuickVersion(int minorVersion)

 int PropertyEditorContextObject::minorVersion() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object minor version", category()};
+
    return m_minorVersion;
 }

@@ -370,11 +408,14 @@ void PropertyEditorContextObject::setMinorVersion(int minorVersion)

 bool PropertyEditorContextObject::hasActiveTimeline() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object has active timeline", category()};
    return m_setHasActiveTimeline;
 }

 void PropertyEditorContextObject::setHasActiveTimeline(bool b)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set has active timeline", category()};
+
    if (b == m_setHasActiveTimeline)
        return;

@@ -384,12 +425,16 @@ void PropertyEditorContextObject::setHasActiveTimeline(bool b)

 void PropertyEditorContextObject::insertInQmlContext(QQmlContext *context)
 {
+    NanotraceHR::Tracer tracer{"property editor context object insert in QML context", category()};
+
    m_qmlContext = context;
    m_qmlContext->setContextObject(this);
 }

 QQmlComponent *PropertyEditorContextObject::specificQmlComponent()
 {
+    NanotraceHR::Tracer tracer{"property editor context object specific QML component", category()};
+
    if (m_qmlComponent)
        return m_qmlComponent;

@@ -408,11 +453,14 @@ QQmlComponent *PropertyEditorContextObject::specificQmlComponent()

 bool PropertyEditorContextObject::hasMultiSelection() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object has multi selection", category()};
+
    return m_hasMultiSelection;
 }

 void PropertyEditorContextObject::setHasMultiSelection(bool b)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set has multi selection", category()};
    if (b == m_hasMultiSelection)
        return;

@@ -422,11 +470,15 @@ void PropertyEditorContextObject::setHasMultiSelection(bool b)

 bool PropertyEditorContextObject::isSelectionLocked() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object is selection locked", category()};
+
    return m_isSelectionLocked;
 }

 void PropertyEditorContextObject::setIsSelectionLocked(bool lock)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set is selection locked", category()};
+
    if (lock == m_isSelectionLocked)
        return;

@@ -436,6 +488,8 @@ void PropertyEditorContextObject::setIsSelectionLocked(bool lock)

 void PropertyEditorContextObject::setInsightEnabled(bool value)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set insight enabled", category()};
+
    if (value != m_insightEnabled) {
        m_insightEnabled = value;
        emit insightEnabledChanged();
@@ -444,12 +498,16 @@ void PropertyEditorContextObject::setInsightEnabled(bool value)

 void PropertyEditorContextObject::setInsightCategories(const QStringList &categories)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set insight categories", category()};
+
    m_insightCategories = categories;
    emit insightCategoriesChanged();
 }

 bool PropertyEditorContextObject::hasQuick3DImport() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object has quick 3D import", category()};
+
    return m_hasQuick3DImport;
 }

@@ -460,6 +518,8 @@ void PropertyEditorContextObject::setEditorNodes(const ModelNodes &nodes)

 void PropertyEditorContextObject::setHasQuick3DImport(bool value)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set has quick 3D import", category()};
+
    if (value == m_hasQuick3DImport)
        return;

@@ -469,11 +529,15 @@ void PropertyEditorContextObject::setHasQuick3DImport(bool value)

 bool PropertyEditorContextObject::hasMaterialLibrary() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object has material library", category()};
+
    return m_hasMaterialLibrary;
 }

 void PropertyEditorContextObject::setHasMaterialLibrary(bool value)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set has material library", category()};
+
    if (value == m_hasMaterialLibrary)
        return;

@@ -483,11 +547,15 @@ void PropertyEditorContextObject::setHasMaterialLibrary(bool value)

 bool PropertyEditorContextObject::isQt6Project() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object is Qt6 project", category()};
+
    return m_isQt6Project;
 }

 void PropertyEditorContextObject::setIsQt6Project(bool value)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set is Qt6 project", category()};
+
    if (m_isQt6Project == value)
        return;

@@ -497,11 +565,15 @@ void PropertyEditorContextObject::setIsQt6Project(bool value)

 bool PropertyEditorContextObject::has3DModelSelected() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object has 3D model selected", category()};
+
    return m_has3DModelSelected;
 }

 void PropertyEditorContextObject::setHas3DModelSelected(bool value)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set has 3D model selected", category()};
+
    if (value == m_has3DModelSelected)
        return;

@@ -511,6 +583,8 @@ void PropertyEditorContextObject::setHas3DModelSelected(bool value)

 void PropertyEditorContextObject::setSpecificsUrl(const QUrl &newSpecificsUrl)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set specifics URL", category()};
+
    if (newSpecificsUrl == m_specificsUrl)
        return;

@@ -522,6 +596,8 @@ void PropertyEditorContextObject::setSpecificsUrl(const QUrl &newSpecificsUrl)

 void PropertyEditorContextObject::setSpecificQmlData(const QString &newSpecificQmlData)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set specific QML data", category()};
+
    if (m_specificQmlData == newSpecificQmlData)
        return;

@@ -536,6 +612,8 @@ void PropertyEditorContextObject::setSpecificQmlData(const QString &newSpecificQ

 void PropertyEditorContextObject::setStateName(const QString &newStateName)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set state name", category()};
+
    if (newStateName == m_stateName)
        return;

@@ -545,8 +623,10 @@ void PropertyEditorContextObject::setStateName(const QString &newStateName)

 void PropertyEditorContextObject::setAllStateNames(const QStringList &allStates)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set all state names", category()};
+
    if (allStates == m_allStateNames)
-            return;
+        return;

    m_allStateNames = allStates;
    emit allStateNamesChanged();
@@ -554,7 +634,9 @@ void PropertyEditorContextObject::setAllStateNames(const QStringList &allStates)

 void PropertyEditorContextObject::setIsBaseState(bool newIsBaseState)
 {
-    if (newIsBaseState ==  m_isBaseState)
+    NanotraceHR::Tracer tracer{"property editor context object set is base state", category()};
+
+    if (newIsBaseState == m_isBaseState)
        return;

    m_isBaseState = newIsBaseState;
@@ -563,6 +645,8 @@ void PropertyEditorContextObject::setIsBaseState(bool newIsBaseState)

 void PropertyEditorContextObject::setSelectionChanged(bool newSelectionChanged)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set selection changed", category()};
+
    if (newSelectionChanged == m_selectionChanged)
        return;

@@ -572,6 +656,8 @@ void PropertyEditorContextObject::setSelectionChanged(bool newSelectionChanged)

 void PropertyEditorContextObject::setBackendValues(QQmlPropertyMap *newBackendValues)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set backend values", category()};
+
    if (newBackendValues == m_backendValues)
        return;

@@ -581,16 +667,22 @@ void PropertyEditorContextObject::setBackendValues(QQmlPropertyMap *newBackendVa

 void PropertyEditorContextObject::setModel(Model *model)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set model", category()};
+
    m_model = model;
 }

 void PropertyEditorContextObject::triggerSelectionChanged()
 {
+    NanotraceHR::Tracer tracer{"property editor context object trigger selection changed", category()};
+
    setSelectionChanged(!m_selectionChanged);
 }

 void PropertyEditorContextObject::setHasAliasExport(bool hasAliasExport)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set has alias export", category()};
+
    if (m_aliasExport == hasAliasExport)
        return;

@@ -600,6 +692,8 @@ void PropertyEditorContextObject::setHasAliasExport(bool hasAliasExport)

 void PropertyEditorContextObject::setQuickWidget(QQuickWidget *newQuickWidget)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set quick widget", category()};
+
    m_quickWidget = newQuickWidget;
 }

@@ -616,6 +710,8 @@ void PropertyEditorContextObject::hideCursor()

 void PropertyEditorContextObject::restoreCursor()
 {
+    NanotraceHR::Tracer tracer{"property editor context object restore cursor", category()};
+
    if (!QApplication::overrideCursor())
        return;

@@ -627,6 +723,8 @@ void PropertyEditorContextObject::restoreCursor()

 void PropertyEditorContextObject::holdCursorInPlace()
 {
+    NanotraceHR::Tracer tracer{"property editor context object hold cursor in place", category()};
+
    if (!QApplication::overrideCursor())
        return;

@@ -636,6 +734,8 @@ void PropertyEditorContextObject::holdCursorInPlace()

 int PropertyEditorContextObject::devicePixelRatio()
 {
+    NanotraceHR::Tracer tracer{"property editor context object device pixel ratio", category()};
+
    if (QWidget *w = QApplication::activeWindow())
        return w->devicePixelRatio();

@@ -644,22 +744,28 @@ int PropertyEditorContextObject::devicePixelRatio()

 QStringList PropertyEditorContextObject::styleNamesForFamily(const QString &family)
 {
+    NanotraceHR::Tracer tracer{"property editor context object style names for family", category()};
+
    return QFontDatabase::styles(family);
 }

 QStringList PropertyEditorContextObject::allStatesForId(const QString &id)
 {
-      if (m_model && m_model->rewriterView()) {
-          const QmlObjectNode node = m_model->rewriterView()->modelNodeForId(id);
-          if (node.isValid())
-              return node.allStateNames();
-      }
+    NanotraceHR::Tracer tracer{"property editor context object all states for id", category()};
+
+    if (m_model && m_model->rewriterView()) {
+        const QmlObjectNode node = m_model->rewriterView()->modelNodeForId(id);
+        if (node.isValid())
+            return node.allStateNames();
+    }

      return {};
 }

 bool PropertyEditorContextObject::isBlocked(const QString &propName) const
 {
+    NanotraceHR::Tracer tracer{"property editor context object is blocked", category()};
+
    if (m_model && m_model->rewriterView()) {
        const QList<ModelNode> nodes = m_model->rewriterView()->selectedModelNodes();
        for (const auto &node : nodes) {
@@ -672,6 +778,8 @@ bool PropertyEditorContextObject::isBlocked(const QString &propName) const

 void PropertyEditorContextObject::verifyInsightImport()
 {
+    NanotraceHR::Tracer tracer{"property editor context object verify insight import", category()};
+
    Import import = Import::createLibraryImport("QtInsightTracker", "1.0");

    if (!m_model->hasImport(import))
@@ -680,6 +788,8 @@ void PropertyEditorContextObject::verifyInsightImport()

 QRect PropertyEditorContextObject::screenRect() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object screen rect", category()};
+
    if (m_quickWidget && m_quickWidget->screen())
        return m_quickWidget->screen()->availableGeometry();
    return  {};
@@ -687,6 +797,8 @@ QRect PropertyEditorContextObject::screenRect() const

 QPoint PropertyEditorContextObject::globalPos(const QPoint &point) const
 {
+    NanotraceHR::Tracer tracer{"property editor context object global pos", category()};
+
    if (m_quickWidget)
        return m_quickWidget->mapToGlobal(point);
    return point;
@@ -694,32 +806,44 @@ QPoint PropertyEditorContextObject::globalPos(const QPoint &point) const

 void PropertyEditorContextObject::handleToolBarAction(int action)
 {
+    NanotraceHR::Tracer tracer{"property editor context object handle toolbar action", category()};
+
    emit toolBarAction(action);
 }

 void PropertyEditorContextObject::saveExpandedState(const QString &sectionName, bool expanded)
 {
+    NanotraceHR::Tracer tracer{"property editor context object save expanded state", category()};
+
    s_expandedStateHash.insert(sectionName, expanded);
 }

 bool PropertyEditorContextObject::loadExpandedState(const QString &sectionName, bool defaultValue) const
 {
+    NanotraceHR::Tracer tracer{"property editor context object load expanded state", category()};
+
    return s_expandedStateHash.value(sectionName, defaultValue);
 }

 void EasingCurveEditor::registerDeclarativeType()
 {
-     qmlRegisterType<EasingCurveEditor>("HelperWidgets", 2, 0, "EasingCurveEditor");
+    NanotraceHR::Tracer tracer{"property editor context object register declarative type", category()};
+
+    qmlRegisterType<EasingCurveEditor>("HelperWidgets", 2, 0, "EasingCurveEditor");
 }

 void EasingCurveEditor::runDialog()
 {
+    NanotraceHR::Tracer tracer{"property editor context object run dialog", category()};
+
    if (m_modelNode.isValid())
        EasingCurveDialog::runDialog({ m_modelNode }, Core::ICore::dialogParent());
 }

 void EasingCurveEditor::setModelNodeBackend(const QVariant &modelNodeBackend)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set model node backend", category()};
+
    if (!modelNodeBackend.isNull() && modelNodeBackend.isValid()) {
        m_modelNodeBackend = modelNodeBackend;

@@ -738,6 +862,8 @@ void EasingCurveEditor::setModelNodeBackend(const QVariant &modelNodeBackend)

 QVariant EasingCurveEditor::modelNodeBackend() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object model node backend", category()};
+
    return m_modelNodeBackend;
 }

--- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditordynamicpropertiesproxymodel.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditordynamicpropertiesproxymodel.cpp
@@ -25,21 +25,31 @@

 #include "propertyeditordynamicpropertiesproxymodel.h"

+#include "propertyeditortracing.h"
+
 #include <dynamicpropertiesmodel.h>

 #include <propertyeditorview.h>

 namespace QmlDesigner {

+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 PropertyEditorDynamicPropertiesProxyModel::PropertyEditorDynamicPropertiesProxyModel(QObject *parent)
    : DynamicPropertiesProxyModel(parent)
 {
+    NanotraceHR::Tracer tracer{"property editor dynamic properties proxy model constructor",
+                               category()};
+
    if (PropertyEditorView::instance())
        initModel(PropertyEditorView::instance()->dynamicPropertiesModel());
 }

 void PropertyEditorDynamicPropertiesProxyModel::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{
+        "property editor dynamic properties proxy model register declarative type", category()};
+
    DynamicPropertiesProxyModel::registerDeclarativeType();
    qmlRegisterType<PropertyEditorDynamicPropertiesProxyModel>("HelperWidgets", 2, 0, "PropertyEditorDynamicPropertiesModel");
 }
--- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorqmlbackend.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorqmlbackend.cpp
@@ -4,6 +4,7 @@
 #include "propertyeditorqmlbackend.h"

 #include "instanceimageprovider.h"
+#include "propertyeditortracing.h"
 #include "propertyeditortransaction.h"
 #include "propertyeditorutils.h"
 #include "propertyeditorvalue.h"
@@ -51,6 +52,8 @@

 #include <tuple>

+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 static Q_LOGGING_CATEGORY(propertyEditorBenchmark, "qtc.propertyeditor.load", QtWarningMsg)

 static QmlJS::SimpleReaderNode::Ptr s_templateConfiguration = QmlJS::SimpleReaderNode::Ptr();
@@ -115,6 +118,8 @@ PropertyEditorQmlBackend::PropertyEditorQmlBackend(PropertyEditorView *propertyE
    , m_propertyEditorTransaction(std::make_unique<PropertyEditorTransaction>(propertyEditor))
    , m_dummyPropertyEditorValue(std::make_unique<PropertyEditorValue>())
 {
+    NanotraceHR::Tracer tracer{"property editor backend constructor", category()};
+
    m_contextObject->setQuickWidget(m_view.get());
    m_view->engine()->setOutputWarningsToStandardError(QmlDesignerPlugin::instance()
        ->settings().value(DesignerSettingsKey::SHOW_PROPERTYEDITOR_WARNINGS).toBool());
@@ -133,12 +138,17 @@ PropertyEditorQmlBackend::PropertyEditorQmlBackend(PropertyEditorView *propertyE
                     propertyEditor, &PropertyEditorView::changeValue);
 }

-PropertyEditorQmlBackend::~PropertyEditorQmlBackend() = default;
+PropertyEditorQmlBackend::~PropertyEditorQmlBackend()
+{
+    NanotraceHR::Tracer tracer{"property editor backend destructor", category()};
+}

 void PropertyEditorQmlBackend::setupPropertyEditorValue(PropertyNameView name,
                                                        PropertyEditorView *propertyEditor,
                                                        const NodeMetaInfo &type)
 {
+    NanotraceHR::Tracer tracer{"property editor backend setup property editor value", category()};
+
    QmlDesigner::PropertyName propertyName(name.toByteArray());
    propertyName.replace('.', '_');
    auto valueObject = qobject_cast<PropertyEditorValue*>(variantToQObject(backendValuesPropertyMap().value(QString::fromUtf8(propertyName))));
@@ -174,6 +184,8 @@ QVariant properDefaultAuxiliaryProperties(const QmlObjectNode &qmlObjectNode,
 QVariant properDefaultLayoutAttachedProperties(const QmlObjectNode &qmlObjectNode,
                                               PropertyNameView propertyName)
 {
+    NanotraceHR::Tracer tracer{"property editor backend proper default layout attached properties",
+                               category()};
    const QVariant value = qmlObjectNode.modelValue("Layout."_sv + propertyName);
    QVariant marginsValue = qmlObjectNode.modelValue("Layout.margins");

@@ -220,6 +232,8 @@ QVariant properDefaultInsightAttachedProperties(const QmlObjectNode &qmlObjectNo

 void PropertyEditorQmlBackend::setupLayoutAttachedProperties(const QmlObjectNode &qmlObjectNode, PropertyEditorView *propertyEditor)
 {
+    NanotraceHR::Tracer tracer{"property editor backend setup layout attached properties", category()};
+
    if (QmlItemNode(qmlObjectNode).isInLayout()) {
        static constexpr PropertyNameView propertyNames[] = {"alignment",
                                                             "column",
@@ -253,6 +267,9 @@ void PropertyEditorQmlBackend::setupLayoutAttachedProperties(const QmlObjectNode
 void PropertyEditorQmlBackend::setupInsightAttachedProperties(const QmlObjectNode &qmlObjectNode,
                                                              PropertyEditorView *propertyEditor)
 {
+    NanotraceHR::Tracer tracer{"property editor backend setup insight attached properties",
+                               category()};
+
    const PropertyName propertyName = "category";
    createPropertyEditorValue(qmlObjectNode,
                              "InsightCategory."_sv + propertyName,
@@ -263,6 +280,8 @@ void PropertyEditorQmlBackend::setupInsightAttachedProperties(const QmlObjectNod
 void PropertyEditorQmlBackend::setupAuxiliaryProperties(const QmlObjectNode &qmlObjectNode,
                                                        PropertyEditorView *propertyEditor)
 {
+    NanotraceHR::Tracer tracer{"property editor backend setup auxiliary properties", category()};
+
    const QmlItemNode itemNode(qmlObjectNode);

    auto createProperty = [&](auto &&...properties) {
@@ -336,12 +355,16 @@ void PropertyEditorQmlBackend::setupAuxiliaryProperties(const QmlObjectNode &qml
 void PropertyEditorQmlBackend::handleInstancePropertyChangedInModelNodeProxy(
    const ModelNode &modelNode, PropertyNameView propertyName)
 {
+    NanotraceHR::Tracer tracer{"property editor backend handle instance property changed", category()};
+
    m_backendModelNode.handleInstancePropertyChanged(modelNode, propertyName);
 }

 void PropertyEditorQmlBackend::handleAuxiliaryDataChanges(const QmlObjectNode &qmlObjectNode,
                                                          AuxiliaryDataKeyView key)
 {
+    NanotraceHR::Tracer tracer{"property editor backend handle auxiliary data changes", category()};
+
    if (qmlObjectNode.isRootModelNode() && isMaterialAuxiliaryKey(key)) {
        m_backendMaterialNode.handleAuxiliaryPropertyChanges();
        m_view->instanceImageProvider()->invalidate();
@@ -350,12 +373,16 @@ void PropertyEditorQmlBackend::handleAuxiliaryDataChanges(const QmlObjectNode &q

 void PropertyEditorQmlBackend::handleVariantPropertyChangedInModelNodeProxy(const VariantProperty &property)
 {
+    NanotraceHR::Tracer tracer{"property editor backend handle variant property changed", category()};
+
    m_backendModelNode.handleVariantPropertyChanged(property);
    updateInstanceImage();
 }

 void PropertyEditorQmlBackend::handleBindingPropertyChangedInModelNodeProxy(const BindingProperty &property)
 {
+    NanotraceHR::Tracer tracer{"property editor backend handle binding property changed", category()};
+
    m_backendModelNode.handleBindingPropertyChanged(property);
    m_backendTextureNode.handleBindingPropertyChanged(property);
    updateInstanceImage();
@@ -364,6 +391,9 @@ void PropertyEditorQmlBackend::handleBindingPropertyChangedInModelNodeProxy(cons
 void PropertyEditorQmlBackend::handleBindingPropertyInModelNodeProxyAboutToChange(
    const BindingProperty &property)
 {
+    NanotraceHR::Tracer tracer{"property editor backend handle binding property about to change",
+                               category()};
+
    if (m_backendMaterialNode.materialNode()) {
        ModelNode expressionNode = property.resolveToModelNode();
        if (expressionNode.metaInfo().isQtQuick3DTexture())
@@ -374,6 +404,8 @@ void PropertyEditorQmlBackend::handleBindingPropertyInModelNodeProxyAboutToChang

 void PropertyEditorQmlBackend::handlePropertiesRemovedInModelNodeProxy(const AbstractProperty &property)
 {
+    NanotraceHR::Tracer tracer{"property editor backend handle properties removed", category()};
+
    m_backendModelNode.handlePropertiesRemoved(property);
    m_backendTextureNode.handlePropertiesRemoved(property);
    updateInstanceImage();
@@ -395,6 +427,9 @@ void PropertyEditorQmlBackend::handleModelNodePreviewPixmapChanged(const ModelNo

 void PropertyEditorQmlBackend::handleModelSelectedNodesChanged(PropertyEditorView *propertyEditor)
 {
+    NanotraceHR::Tracer tracer{"property editor backend handle model selected nodes changed",
+                               category()};
+
    contextObject()->setHas3DModelSelected(!Utils3D::getSelectedModels(propertyEditor).isEmpty());
    m_backendTextureNode.updateSelectionDetails();
 }
@@ -404,6 +439,8 @@ void PropertyEditorQmlBackend::createPropertyEditorValue(const QmlObjectNode &qm
                                                         const QVariant &value,
                                                         PropertyEditorView *propertyEditor)
 {
+    NanotraceHR::Tracer tracer{"property editor backend create property editor value", category()};
+
    PropertyName propertyName(name.toByteArray());
    propertyName.replace('.', '_');
    auto valueObject = qobject_cast<PropertyEditorValue*>(variantToQObject(backendValuesPropertyMap().value(QString::fromUtf8(propertyName))));
@@ -441,6 +478,8 @@ void PropertyEditorQmlBackend::setValue(const QmlObjectNode &,
                                        PropertyNameView name,
                                        const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{"property editor backend set value", category()};
+
    // Vector*D values need to be split into their subcomponents
    if (value.typeId() == QMetaType::QVector2D) {
        const char *suffix[2] = {"_x", "_y"};
@@ -487,6 +526,8 @@ void PropertyEditorQmlBackend::setValue(const QmlObjectNode &,

 void PropertyEditorQmlBackend::setExpression(PropertyNameView propName, const QString &exp)
 {
+    NanotraceHR::Tracer tracer{"property editor backend set expression", category()};
+
    PropertyEditorValue *propertyValue = propertyValueForName(QString::fromUtf8(propName));
    if (propertyValue)
        propertyValue->setExpression(exp);
@@ -494,21 +535,29 @@ void PropertyEditorQmlBackend::setExpression(PropertyNameView propName, const QS

 QQmlContext *PropertyEditorQmlBackend::context()
 {
+    NanotraceHR::Tracer tracer{"property editor backend context", category()};
+
    return m_view->rootContext();
 }

 PropertyEditorContextObject *PropertyEditorQmlBackend::contextObject()
 {
+    NanotraceHR::Tracer tracer{"property editor backend context object", category()};
+
    return m_contextObject.get();
 }

 QQuickWidget *PropertyEditorQmlBackend::widget()
 {
+    NanotraceHR::Tracer tracer{"property editor backend widget", category()};
+
    return m_view.get();
 }

 void PropertyEditorQmlBackend::setSource(const QUrl &url)
 {
+    NanotraceHR::Tracer tracer{"property editor backend set source", category()};
+
    m_view->setSource(url);

    const bool showError = qEnvironmentVariableIsSet(Constants::ENVIRONMENT_SHOW_QML_ERRORS);
@@ -521,24 +570,37 @@ void PropertyEditorQmlBackend::setSource(const QUrl &url)

 QmlAnchorBindingProxy &PropertyEditorQmlBackend::backendAnchorBinding()
 {
+    NanotraceHR::Tracer tracer{"property editor backend backend anchor binding", category()};
+
    return m_backendAnchorBinding;
 }

-DesignerPropertyMap &PropertyEditorQmlBackend::backendValuesPropertyMap() {
+DesignerPropertyMap &PropertyEditorQmlBackend::backendValuesPropertyMap()
+{
+    NanotraceHR::Tracer tracer{"property editor backend backend values property map", category()};
+
    return m_backendValuesPropertyMap;
 }

-PropertyEditorTransaction *PropertyEditorQmlBackend::propertyEditorTransaction() {
+PropertyEditorTransaction *PropertyEditorQmlBackend::propertyEditorTransaction()
+{
+    NanotraceHR::Tracer tracer{"property editor backend property editor transaction", category()};
+
    return m_propertyEditorTransaction.get();
 }

 PropertyEditorValue *PropertyEditorQmlBackend::propertyValueForName(const QString &propertyName)
 {
-     return qobject_cast<PropertyEditorValue*>(variantToQObject(backendValuesPropertyMap().value(propertyName)));
+    NanotraceHR::Tracer tracer{"property editor backend property value for name", category()};
+
+    return qobject_cast<PropertyEditorValue *>(
+        variantToQObject(backendValuesPropertyMap().value(propertyName)));
 }

 void QmlDesigner::PropertyEditorQmlBackend::createPropertyEditorValues(const QmlObjectNode &qmlObjectNode, PropertyEditorView *propertyEditor)
 {
+    NanotraceHR::Tracer tracer{"property editor backend create property editor values", category()};
+
 #ifndef QDS_USE_PROJECTSTORAGE
    for (const auto &property : PropertyEditorUtils::filteredProperties(qmlObjectNode.metaInfo())) {
        auto propertyName = property.name();
@@ -563,6 +625,8 @@ PropertyEditorValue *PropertyEditorQmlBackend::insertValue(const QString &name,
                                                           const QVariant &value,
                                                           const ModelNode &modelNode)
 {
+    NanotraceHR::Tracer tracer{"property editor backend insert value", category()};
+
    auto valueObject = qobject_cast<PropertyEditorValue *>(
        variantToQObject(m_backendValuesPropertyMap.value(name)));
    if (!valueObject)
@@ -586,6 +650,8 @@ PropertyEditorValue *PropertyEditorQmlBackend::insertValue(const QString &name,

 void PropertyEditorQmlBackend::updateInstanceImage()
 {
+    NanotraceHR::Tracer tracer{"property editor backend update instance image", category()};
+
    m_view->instanceImageProvider()->invalidate();
    refreshPreview();
 }
@@ -595,6 +661,8 @@ void PropertyEditorQmlBackend::setup(const ModelNodes &editorNodes,
                                     const QUrl &qmlSpecificsFile,
                                     PropertyEditorView *propertyEditor)
 {
+    NanotraceHR::Tracer tracer{"property editor backend setup", category()};
+
    QmlObjectNode qmlObjectNode(editorNodes.isEmpty() ? ModelNode{} : editorNodes.first());
    if (!qmlObjectNode.isValid()) {
        qWarning() << "PropertyEditor: invalid node for setup";
@@ -694,11 +762,15 @@ void PropertyEditorQmlBackend::setup(const ModelNodes &editorNodes,

 QString PropertyEditorQmlBackend::propertyEditorResourcesPath()
 {
+    NanotraceHR::Tracer tracer{"property editor backend property editor resources path", category()};
+
    return resourcesPath("propertyEditorQmlSources");
 }

 QString PropertyEditorQmlBackend::scriptsEditorResourcesPath()
 {
+    NanotraceHR::Tracer tracer{"property editor backend scripts editor resources path", category()};
+
    return resourcesPath("scriptseditor");
 }

@@ -968,6 +1040,8 @@ QUrl PropertyEditorQmlBackend::getQmlFileUrl(const TypeName &relativeTypeName, c

 TypeName PropertyEditorQmlBackend::fixTypeNameForPanes(const TypeName &typeName)
 {
+    NanotraceHR::Tracer tracer{"property editor backend fix type name for panes", category()};
+
    TypeName fixedTypeName = typeName;
    fixedTypeName.replace('.', '/');
    return fixedTypeName;
@@ -975,6 +1049,8 @@ TypeName PropertyEditorQmlBackend::fixTypeNameForPanes(const TypeName &typeName)

 QString PropertyEditorQmlBackend::resourcesPath(const QString &dir)
 {
+    NanotraceHR::Tracer tracer{"property editor backend resources path", category()};
+
 #ifdef SHARE_QML_PATH
    if (Utils::qtcEnvironmentVariableIsSet("LOAD_QML_FROM_SOURCE"))
        return QLatin1String(SHARE_QML_PATH) + "/" + dir;
@@ -984,11 +1060,15 @@ QString PropertyEditorQmlBackend::resourcesPath(const QString &dir)

 void PropertyEditorQmlBackend::refreshBackendModel()
 {
+    NanotraceHR::Tracer tracer{"property editor backend refresh backend model", category()};
+
    m_backendModelNode.refresh();
 }

 void PropertyEditorQmlBackend::refreshPreview()
 {
+    NanotraceHR::Tracer tracer{"property editor backend refresh preview", category()};
+
    auto qmlPreview = widget()->rootObject();

    if (qmlPreview && qmlPreview->metaObject()->indexOfMethod("refreshPreview()") > -1)
@@ -997,6 +1077,8 @@ void PropertyEditorQmlBackend::refreshPreview()

 void PropertyEditorQmlBackend::setupContextProperties()
 {
+    NanotraceHR::Tracer tracer{"property editor backend setup context properties", category()};
+
    context()->setContextProperties({
        {"modelNodeBackend", QVariant::fromValue(&m_backendModelNode)},
        {"materialNodeBackend", QVariant::fromValue(&m_backendMaterialNode)},
@@ -1015,7 +1097,10 @@ TypeName PropertyEditorQmlBackend::qmlFileName(const NodeMetaInfo &nodeInfo)
 }
 #endif

-QUrl PropertyEditorQmlBackend::fileToUrl(const QString &filePath)  {
+QUrl PropertyEditorQmlBackend::fileToUrl(const QString &filePath)
+{
+    NanotraceHR::Tracer tracer{"property editor backend file to url", category()};
+
    QUrl fileUrl;

    if (filePath.isEmpty())
@@ -1035,11 +1120,15 @@ QUrl PropertyEditorQmlBackend::fileToUrl(const QString &filePath)  {

 QUrl PropertyEditorQmlBackend::emptyPaneUrl()
 {
+    NanotraceHR::Tracer tracer{"property editor backend empty pane url", category()};
+
    return fileToUrl(QDir(propertyEditorResourcesPath()).filePath("QtQuick/emptyPane.qml"_L1));
 }

 QString PropertyEditorQmlBackend::fileFromUrl(const QUrl &url)
 {
+    NanotraceHR::Tracer tracer{"property editor backend file from url", category()};
+
    if (url.scheme() == QStringLiteral("qrc")) {
        const QString &path = url.path();
        return QStringLiteral(":") + path;
@@ -1050,23 +1139,32 @@ QString PropertyEditorQmlBackend::fileFromUrl(const QUrl &url)

 bool PropertyEditorQmlBackend::checkIfUrlExists(const QUrl &url)
 {
+    NanotraceHR::Tracer tracer{"property editor backend check if url exists", category()};
+
    const QString &file = fileFromUrl(url);
    return !file.isEmpty() && QFileInfo::exists(file);
 }

 void PropertyEditorQmlBackend::emitSelectionToBeChanged()
 {
+    NanotraceHR::Tracer tracer{"property editor backend emit selection to be changed", category()};
+
    m_backendModelNode.emitSelectionToBeChanged();
 }

 void PropertyEditorQmlBackend::emitSelectionChanged()
 {
+    NanotraceHR::Tracer tracer{"property editor backend emit selection changed", category()};
+
    m_backendModelNode.emitSelectionChanged();
 }

 void PropertyEditorQmlBackend::setValueforLayoutAttachedProperties(const QmlObjectNode &qmlObjectNode,
                                                                   PropertyNameView name)
 {
+    NanotraceHR::Tracer tracer{"property editor backend set value for layout attached properties",
+                               category()};
+
    PropertyName propertyName = name.toByteArray();
    propertyName.replace("Layout.", "");
    setValue(qmlObjectNode, name, properDefaultLayoutAttachedProperties(qmlObjectNode, propertyName));
@@ -1083,6 +1181,9 @@ void PropertyEditorQmlBackend::setValueforLayoutAttachedProperties(const QmlObje
 void PropertyEditorQmlBackend::setValueforInsightAttachedProperties(const QmlObjectNode &qmlObjectNode,
                                                                    PropertyNameView name)
 {
+    NanotraceHR::Tracer tracer{"property editor backend set value for insight attached properties",
+                               category()};
+
    PropertyName propertyName = name.toByteArray();
    propertyName.replace("InsightCategory.", "");
    setValue(qmlObjectNode, name, properDefaultInsightAttachedProperties(qmlObjectNode, propertyName));
@@ -1091,6 +1192,9 @@ void PropertyEditorQmlBackend::setValueforInsightAttachedProperties(const QmlObj
 void PropertyEditorQmlBackend::setValueforAuxiliaryProperties(const QmlObjectNode &qmlObjectNode,
                                                              AuxiliaryDataKeyView key)
 {
+    NanotraceHR::Tracer tracer{"property editor backend set value for auxiliary properties",
+                               category()};
+
    const PropertyName propertyName = auxNamePostFix(key.name);
    setValue(qmlObjectNode, propertyName, qmlObjectNode.modelNode().auxiliaryDataWithDefault(key));
 }
--- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditortracing.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditortracing.cpp
@@ -0,0 +1,26 @@
+// Copyright (C) 2025 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "propertyeditortracing.h"
+
+#include <tracing/qmldesignertracing.h>
+
+#include <sqlitebasestatement.h>
+
+namespace QmlDesigner::PropertyEditorTracing {
+using namespace NanotraceHR::Literals;
+namespace {
+
+thread_local Category category_{"model",
+                                Tracing::eventQueueWithStringArguments(),
+                                Tracing::eventQueueWithoutArguments(),
+                                category};
+
+} // namespace
+
+Category &category()
+{
+    return category_;
+}
+
+} // namespace QmlDesigner::PropertyEditorTracing
--- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditortracing.h
+++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditortracing.h
@@ -0,0 +1,26 @@
+// Copyright (C) 2025 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include <qmldesignercomponents_global.h>
+
+#include <nanotrace/nanotracehr.h>
+
+#pragma once
+
+namespace QmlDesigner::PropertyEditorTracing {
+
+constexpr NanotraceHR::Tracing tracingStatus()
+{
+#ifdef ENABLE_PROPERTY_EDITOR_TRACING
+    return NanotraceHR::Tracing::IsEnabled;
+#else
+    return NanotraceHR::Tracing::IsDisabled;
+#endif
+}
+
+using Category = NanotraceHR::StringViewWithStringArgumentsCategory<tracingStatus()>;
+using SourceLocation = Category::SourceLocation;
+
+[[gnu::pure]] QMLDESIGNERCOMPONENTS_EXPORT Category &category();
+
+} // namespace QmlDesigner::PropertyEditorTracing
--- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditortransaction.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditortransaction.cpp
@@ -2,18 +2,26 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

 #include "propertyeditortransaction.h"
+
+#include "propertyeditortracing.h"
+
 #include <QTimerEvent>

 #include <QDebug>

 namespace QmlDesigner {

+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 PropertyEditorTransaction::PropertyEditorTransaction(QmlDesigner::PropertyEditorView *propertyEditor) : QObject(propertyEditor), m_propertyEditor(propertyEditor), m_timerId(-1)
 {
+    NanotraceHR::Tracer tracer{"property editor transaction constructor", category()};
 }

 void PropertyEditorTransaction::start()
 {
+    NanotraceHR::Tracer tracer{"property editor transaction start", category()};
+
    if (!m_propertyEditor->model())
        return;
    if (m_rewriterTransaction.isValid())
@@ -24,7 +32,9 @@ void PropertyEditorTransaction::start()

 void PropertyEditorTransaction::end()
 {
-    if (m_rewriterTransaction.isValid() &&  m_propertyEditor->model()) {
+    NanotraceHR::Tracer tracer{"property editor transaction end", category()};
+
+    if (m_rewriterTransaction.isValid() && m_propertyEditor->model()) {
        killTimer(m_timerId);
        m_rewriterTransaction.commit();
    }
@@ -32,6 +42,8 @@ void PropertyEditorTransaction::end()

 bool PropertyEditorTransaction::active() const
 {
+    NanotraceHR::Tracer tracer{"property editor transaction active", category()};
+
    return m_rewriterTransaction.isValid();
 }

@@ -39,6 +51,9 @@ void PropertyEditorTransaction::timerEvent(QTimerEvent *timerEvent)
 {
    if (timerEvent->timerId() != m_timerId)
        return;
+
+    NanotraceHR::Tracer tracer{"property editor transaction timer event", category()};
+
    killTimer(timerEvent->timerId());
    if (m_rewriterTransaction.isValid())
        m_rewriterTransaction.commit();
--- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorutils.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorutils.cpp
@@ -3,10 +3,14 @@

 #include "propertyeditorutils.h"

+#include "propertyeditortracing.h"
+
 namespace QmlDesigner {

 namespace PropertyEditorUtils {

+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 #ifndef QDS_USE_PROJECTSTORAGE

 static bool checkIfUnkownTypeProperty(const std::vector<PropertyName> &propertyNames,
@@ -31,6 +35,8 @@ static bool checkIfUnkownTypeProperty(const std::vector<PropertyName> &propertyN

 PropertyMetaInfos filteredProperties(const NodeMetaInfo &metaInfo)
 {
+    NanotraceHR::Tracer tracer{"property editor utils filtered properties", category()};
+
    auto properties = metaInfo.properties();

 #ifndef QDS_USE_PROJECTSTORAGE
--- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorvalue.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorvalue.cpp
@@ -3,20 +3,22 @@

 #include "propertyeditorvalue.h"

-#include "abstractview.h"
-#include "bindingproperty.h"
-#include "createtexture.h"
-#include "designermcumanager.h"
-#include "designmodewidget.h"
-#include "nodemetainfo.h"
-#include "nodeproperty.h"
+#include "propertyeditortracing.h"
 #include "propertyeditorutils.h"
 #include "propertyeditorview.h"
-#include "qmldesignerplugin.h"
-#include "qmlitemnode.h"
-#include "qmlobjectnode.h"
-#include "rewritertransaction.h"
-#include "rewritingexception.h"
+
+#include <abstractview.h>
+#include <bindingproperty.h>
+#include <createtexture.h>
+#include <designermcumanager.h>
+#include <designmodewidget.h>
+#include <nodemetainfo.h>
+#include <nodeproperty.h>
+#include <qmldesignerplugin.h>
+#include <qmlitemnode.h>
+#include <qmlobjectnode.h>
+#include <rewritertransaction.h>
+#include <rewritingexception.h>

 #include <enumeration.h>
 #include <utils3d.h>
@@ -28,14 +30,19 @@

 namespace QmlDesigner {

+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 PropertyEditorValue::PropertyEditorValue(QObject *parent)
    : QObject(parent),
      m_complexNode(new PropertyEditorNodeWrapper(this))
 {
+    NanotraceHR::Tracer tracer{"property editor value constructor", category()};
 }

 QVariant PropertyEditorValue::value() const
 {
+    NanotraceHR::Tracer tracer{"property editor value value", category()};
+
    QVariant returnValue = m_value;
    if (auto metaInfo = modelNode().metaInfo(); metaInfo.property(name()).propertyType().isUrl())
        returnValue = returnValue.toUrl().toString();
@@ -107,6 +114,8 @@ static bool compareVariants(const QVariant &value1, const QVariant &value2)

 void PropertyEditorValue::setValueWithEmit(const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{"property editor value set value with emit", category()};
+
    if (!compareVariants(value, m_value) || isBound()) {
        QVariant newValue = value;
        if (auto metaInfo = modelNode().metaInfo(); metaInfo.property(name()).propertyType().isUrl())
@@ -127,6 +136,8 @@ void PropertyEditorValue::setValueWithEmit(const QVariant &value)

 void PropertyEditorValue::setValue(const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{"property editor value set value", category()};
+
    const bool colorsEqual = cleverColorCompare(value, m_value);

    if (!compareVariants(m_value, value) && !cleverDoubleCompare(value, m_value) && !colorsEqual)
@@ -145,16 +156,22 @@ void PropertyEditorValue::setValue(const QVariant &value)

 QString PropertyEditorValue::enumeration() const
 {
+    NanotraceHR::Tracer tracer{"property editor value enumeration", category()};
+
    return m_value.value<Enumeration>().nameToString();
 }

 QString PropertyEditorValue::expression() const
 {
+    NanotraceHR::Tracer tracer{"property editor value expression", category()};
+
    return m_expression;
 }

 void PropertyEditorValue::setExpressionWithEmit(const QString &expression)
 {
+    NanotraceHR::Tracer tracer{"property editor value set expression with emit", category()};
+
    if (m_expression != expression) {
        setExpression(expression);
        m_value.clear();
@@ -166,7 +183,9 @@ void PropertyEditorValue::setExpressionWithEmit(const QString &expression)

 void PropertyEditorValue::setExpression(const QString &expression)
 {
-    if ( m_expression != expression) {
+    NanotraceHR::Tracer tracer{"property editor value set expression", category()};
+
+    if (m_expression != expression) {
        m_expression = expression;
        emit expressionChanged(QString());
    }
@@ -174,11 +193,15 @@ void PropertyEditorValue::setExpression(const QString &expression)

 QString PropertyEditorValue::valueToString() const
 {
+    NanotraceHR::Tracer tracer{"property editor value value to string", category()};
+
    return value().toString();
 }

 bool PropertyEditorValue::isInSubState() const
 {
+    NanotraceHR::Tracer tracer{"property editor value is in sub state", category()};
+
    const QmlObjectNode objectNode(modelNode());
    return objectNode.isValid() && objectNode.currentState().isValid()
           && objectNode.propertyAffectedByCurrentState(name());
@@ -186,42 +209,58 @@ bool PropertyEditorValue::isInSubState() const

 bool PropertyEditorValue::isBound() const
 {
+    NanotraceHR::Tracer tracer{"property editor value is bound", category()};
+
    const QmlObjectNode objectNode(modelNode());
    return m_forceBound || (objectNode.isValid() && objectNode.hasBindingProperty(name()));
 }

 bool PropertyEditorValue::isInModel() const
 {
+    NanotraceHR::Tracer tracer{"property editor value is in model", category()};
+
    return modelNode().hasProperty(name());
 }

 PropertyNameView PropertyEditorValue::name() const
 {
+    NanotraceHR::Tracer tracer{"property editor value name", category()};
+
    return m_name;
 }

 QString PropertyEditorValue::nameAsQString() const
 {
+    NanotraceHR::Tracer tracer{"property editor value name as QString", category()};
+
    return QString::fromUtf8(m_name);
 }

 void PropertyEditorValue::setName(PropertyNameView name)
 {
+    NanotraceHR::Tracer tracer{"property editor value set name", category()};
+
    m_name = name;
 }

 bool PropertyEditorValue::isValid() const
 {
+    NanotraceHR::Tracer tracer{"property editor value is valid", category()};
+
    return m_isValid;
 }

 void PropertyEditorValue::setIsValid(bool valid)
 {
+    NanotraceHR::Tracer tracer{"property editor value set is valid", category()};
+
    m_isValid = valid;
 }

 bool PropertyEditorValue::isTranslated() const
 {
+    NanotraceHR::Tracer tracer{"property editor value is translated", category()};
+
    if (modelNode().isValid()) {
        auto metaInfo = modelNode().metaInfo();
        auto isString = metaInfo.isValid() && metaInfo.hasProperty(name())
@@ -249,11 +288,15 @@ bool PropertyEditorValue::isTranslated() const

 bool PropertyEditorValue::hasActiveDrag() const
 {
+    NanotraceHR::Tracer tracer{"property editor value has active drag", category()};
+
    return m_hasActiveDrag;
 }

 void PropertyEditorValue::setHasActiveDrag(bool val)
 {
+    NanotraceHR::Tracer tracer{"property editor value set has active drag", category()};
+
    if (m_hasActiveDrag != val) {
        m_hasActiveDrag = val;
        emit hasActiveDragChanged();
@@ -272,6 +315,8 @@ static bool isAllowedSubclassType(const QString &type, const NodeMetaInfo &metaI

 bool PropertyEditorValue::isAvailable() const
 {
+    NanotraceHR::Tracer tracer{"property editor value is available", category()};
+
    if (!m_modelNode.isValid())
        return true;

@@ -322,11 +367,15 @@ bool PropertyEditorValue::isAvailable() const

 ModelNode PropertyEditorValue::modelNode() const
 {
+    NanotraceHR::Tracer tracer{"property editor value model node", category()};
+
    return m_modelNode;
 }

 void PropertyEditorValue::setModelNode(const ModelNode &modelNode)
 {
+    NanotraceHR::Tracer tracer{"property editor value set model node", category()};
+
    if (modelNode != m_modelNode) {
        m_modelNode = modelNode;
        m_complexNode->update();
@@ -336,11 +385,15 @@ void PropertyEditorValue::setModelNode(const ModelNode &modelNode)

 PropertyEditorNodeWrapper *PropertyEditorValue::complexNode()
 {
+    NanotraceHR::Tracer tracer{"property editor value complex node", category()};
+
    return m_complexNode;
 }

 void PropertyEditorValue::resetValue()
 {
+    NanotraceHR::Tracer tracer{"property editor value reset value", category()};
+
    if (m_value.isValid() || !m_expression.isEmpty() || isBound()) {
        m_value = QVariant();
        m_isBound = false;
@@ -353,6 +406,8 @@ void PropertyEditorValue::resetValue()

 void PropertyEditorValue::setEnumeration(const QString &scope, const QString &name)
 {
+    NanotraceHR::Tracer tracer{"property editor value set enumeration", category()};
+
    Enumeration newEnumeration(scope.toUtf8(), name.toUtf8());

    setValueWithEmit(QVariant::fromValue(newEnumeration));
@@ -360,11 +415,15 @@ void PropertyEditorValue::setEnumeration(const QString &scope, const QString &na

 void PropertyEditorValue::exportPropertyAsAlias()
 {
+    NanotraceHR::Tracer tracer{"property editor value export property as alias", category()};
+
    emit exportPropertyAsAliasRequested(nameAsQString());
 }

 bool PropertyEditorValue::hasPropertyAlias() const
 {
+    NanotraceHR::Tracer tracer{"property editor value has property alias", category()};
+
    if (!modelNode().isValid())
        return false;

@@ -387,16 +446,22 @@ bool PropertyEditorValue::hasPropertyAlias() const

 bool PropertyEditorValue::isAttachedProperty() const
 {
+    NanotraceHR::Tracer tracer{"property editor value is attached property", category()};
+
    return !nameAsQString().isEmpty() && nameAsQString().at(0).isUpper();
 }

 void PropertyEditorValue::removeAliasExport()
 {
+    NanotraceHR::Tracer tracer{"property editor value remove alias export", category()};
+
    emit removeAliasExportRequested(nameAsQString());
 }

 QString PropertyEditorValue::getTranslationContext() const
 {
+    NanotraceHR::Tracer tracer{"property editor value get translation context", category()};
+
    if (modelNode().isValid()) {
        if (auto metaInfo = modelNode().metaInfo();
            metaInfo.isValid() && metaInfo.hasProperty(name())
@@ -416,7 +481,10 @@ QString PropertyEditorValue::getTranslationContext() const

 bool PropertyEditorValue::isIdList() const
 {
-    if (modelNode().isValid() && modelNode().metaInfo().isValid() && modelNode().metaInfo().hasProperty(name())) {
+    NanotraceHR::Tracer tracer{"property editor value is id list", category()};
+
+    if (modelNode().isValid() && modelNode().metaInfo().isValid()
+        && modelNode().metaInfo().hasProperty(name())) {
        const QmlObjectNode objectNode(modelNode());
        if (objectNode.hasBindingProperty(name())) {
            static const QRegularExpression rx(QRegularExpression::anchoredPattern(
@@ -436,11 +504,15 @@ bool PropertyEditorValue::isIdList() const

 QStringList PropertyEditorValue::getExpressionAsList() const
 {
+    NanotraceHR::Tracer tracer{"property editor value get expression as list", category()};
+
    return generateStringList(expression());
 }

 QVector<double> PropertyEditorValue::getExpressionAsVector() const
 {
+    NanotraceHR::Tracer tracer{"property editor value get expression as vector", category()};
+
    const QRegularExpression rx(
        QRegularExpression::anchoredPattern("Qt.vector(2|3|4)d\\((.*?)\\)"));
    const QRegularExpressionMatch match = rx.match(expression());
@@ -469,6 +541,8 @@ QVector<double> PropertyEditorValue::getExpressionAsVector() const

 bool PropertyEditorValue::idListAdd(const QString &value)
 {
+    NanotraceHR::Tracer tracer{"property editor value id list add", category()};
+
    const QmlObjectNode objectNode(modelNode());
    if (!isIdList() && objectNode.isValid() && objectNode.hasProperty(name()))
        return false;
@@ -487,6 +561,8 @@ bool PropertyEditorValue::idListAdd(const QString &value)

 bool PropertyEditorValue::idListRemove(int idx)
 {
+    NanotraceHR::Tracer tracer{"property editor value id list remove", category()};
+
    QTC_ASSERT(isIdList(), return false);

    auto stringList = generateStringList(expression());
@@ -505,6 +581,8 @@ bool PropertyEditorValue::idListRemove(int idx)

 bool PropertyEditorValue::idListReplace(int idx, const QString &value)
 {
+    NanotraceHR::Tracer tracer{"property editor value id list replace", category()};
+
    QTC_ASSERT(isIdList(), return false);

    static const QRegularExpression rx(QRegularExpression::anchoredPattern(
@@ -525,6 +603,8 @@ bool PropertyEditorValue::idListReplace(int idx, const QString &value)

 void PropertyEditorValue::commitDrop(const QString &dropData)
 {
+    NanotraceHR::Tracer tracer{"property editor value commit drop", category()};
+
    if (m_modelNode.metaInfo().property(m_name).propertyType().isQtQuick3DTexture()) {
        m_modelNode.view()->executeInTransaction(__FUNCTION__, [&] {
            ModelNode texture = m_modelNode.view()->modelNodeForInternalId(dropData.toInt());
@@ -548,6 +628,8 @@ void PropertyEditorValue::commitDrop(const QString &dropData)

 void PropertyEditorValue::editMaterial(int idx)
 {
+    NanotraceHR::Tracer tracer{"property editor value edit material", category()};
+
    if (ModelNode material = Utils3D::getMaterialOfModel(m_modelNode, idx)) {
        QmlDesignerPlugin::instance()->mainWidget()->showDockWidget("Properties", true);
        material.selectNode();
@@ -556,6 +638,8 @@ void PropertyEditorValue::editMaterial(int idx)

 void PropertyEditorValue::setForceBound(bool b)
 {
+    NanotraceHR::Tracer tracer{"property editor value set force bound", category()};
+
    if (m_forceBound == b)
        return;
    m_forceBound = b;
@@ -565,6 +649,8 @@ void PropertyEditorValue::setForceBound(bool b)

 void PropertyEditorValue::insertKeyframe()
 {
+    NanotraceHR::Tracer tracer{"property editor value insert keyframe", category()};
+
    if (!m_modelNode.isValid())
        return;

@@ -582,6 +668,8 @@ void PropertyEditorValue::insertKeyframe()

 QStringList PropertyEditorValue::generateStringList(const QString &string) const
 {
+    NanotraceHR::Tracer tracer{"property editor value generate string list", category()};
+
    QString copy = string;
    copy = copy.remove("[").remove("]");

@@ -594,6 +682,8 @@ QStringList PropertyEditorValue::generateStringList(const QString &string) const

 QString PropertyEditorValue::generateString(const QStringList &stringList) const
 {
+    NanotraceHR::Tracer tracer{"property editor value generate string", category()};
+
    if (stringList.size() > 1)
        return "[" + stringList.join(",") + "]";
    else if (stringList.isEmpty())
@@ -604,6 +694,8 @@ QString PropertyEditorValue::generateString(const QStringList &stringList) const

 void PropertyEditorValue::registerDeclarativeTypes()
 {
+    NanotraceHR::Tracer tracer{"property editor value register declarative types", category()};
+
    qmlRegisterType<PropertyEditorValue>("HelperWidgets", 2, 0, "PropertyEditorValue");
    qmlRegisterType<PropertyEditorNodeWrapper>("HelperWidgets", 2, 0, "PropertyEditorNodeWrapper");
    qmlRegisterType<QQmlPropertyMap>("HelperWidgets", 2, 0, "QQmlPropertyMap");
@@ -613,6 +705,8 @@ PropertyEditorNodeWrapper::PropertyEditorNodeWrapper(PropertyEditorValue *parent
    : QObject(parent),
      m_valuesPropertyMap(this)
 {
+    NanotraceHR::Tracer tracer{"property editor value node wrapper constructor", category()};
+
    m_editorValue = parent;
    connect(m_editorValue, &PropertyEditorValue::modelNodeChanged, this, &PropertyEditorNodeWrapper::update);
 }
@@ -620,35 +714,48 @@ PropertyEditorNodeWrapper::PropertyEditorNodeWrapper(PropertyEditorValue *parent
 PropertyEditorNodeWrapper::PropertyEditorNodeWrapper(QObject *parent)
    : QObject(parent)
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper constructor", category()};
 }

 bool PropertyEditorNodeWrapper::exists() const
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper exists", category()};
+
    return m_editorValue && m_editorValue->modelNode().isValid() && m_modelNode.isValid();
 }

 QString PropertyEditorNodeWrapper::type() const
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper type", category()};
+
    return m_modelNode.simplifiedTypeName();
 }

 ModelNode PropertyEditorNodeWrapper::parentModelNode() const
 {
-    return  m_editorValue->modelNode();
+    NanotraceHR::Tracer tracer{"property editor node wrapper parent model node", category()};
+
+    return m_editorValue->modelNode();
 }

 PropertyNameView PropertyEditorNodeWrapper::propertyName() const
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper property name", category()};
+
    return m_editorValue->name();
 }

 QQmlPropertyMap *PropertyEditorNodeWrapper::properties()
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper properties", category()};
+
    return &m_valuesPropertyMap;
 }

 void PropertyEditorNodeWrapper::add(const QString &type)
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper add", category()};
+
    TypeName propertyType = type.toUtf8();

    if ((m_editorValue && m_editorValue->modelNode().isValid())) {
@@ -683,6 +790,8 @@ void PropertyEditorNodeWrapper::add(const QString &type)

 void PropertyEditorNodeWrapper::remove()
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper remove", category()};
+
    if ((m_editorValue && m_editorValue->modelNode().isValid())) {
        QmlObjectNode(m_modelNode).destroy();
        m_editorValue->modelNode().removeProperty(m_editorValue->name());
@@ -701,6 +810,8 @@ void PropertyEditorNodeWrapper::remove()

 void PropertyEditorNodeWrapper::changeValue(const QString &propertyName)
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper change value", category()};
+
    const PropertyName name = propertyName.toUtf8();

    if (name.isNull())
@@ -718,6 +829,8 @@ void PropertyEditorNodeWrapper::changeValue(const QString &propertyName)

 void PropertyEditorNodeWrapper::setup()
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper setup", category()};
+
    Q_ASSERT(m_editorValue);
    Q_ASSERT(m_editorValue->modelNode().isValid());

@@ -748,6 +861,8 @@ void PropertyEditorNodeWrapper::setup()

 void PropertyEditorNodeWrapper::update()
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper update", category()};
+
    if (!m_editorValue || !m_editorValue->modelNode().isValid())
        return;

@@ -763,6 +878,8 @@ void PropertyEditorNodeWrapper::update()

 QQmlPropertyMap *PropertyEditorSubSelectionWrapper::properties()
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper properties", category()};
+
    return &m_valuesPropertyMap;
 }

@@ -778,6 +895,9 @@ void PropertyEditorSubSelectionWrapper::createPropertyEditorValue(const QmlObjec
                                                                  PropertyNameView name,
                                                                  const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper create property editor value",
+                               category()};
+
    Utils::SmallString propertyName = name.toByteArray();
    propertyName.replace('.', '_');

@@ -816,6 +936,9 @@ void PropertyEditorSubSelectionWrapper::createPropertyEditorValue(const QmlObjec

 void PropertyEditorSubSelectionWrapper::exportPropertyAsAlias(const QString &name)
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper export property as alias",
+                               category()};
+
    if (name.isNull())
        return;

@@ -831,6 +954,9 @@ void PropertyEditorSubSelectionWrapper::exportPropertyAsAlias(const QString &nam

 void PropertyEditorSubSelectionWrapper::removeAliasExport(const QString &name)
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper remove alias export",
+                               category()};
+
    if (name.isNull())
        return;

@@ -846,12 +972,16 @@ void PropertyEditorSubSelectionWrapper::removeAliasExport(const QString &name)

 bool PropertyEditorSubSelectionWrapper::locked() const
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper locked", category()};
+
    return m_locked;
 }

 PropertyEditorSubSelectionWrapper::PropertyEditorSubSelectionWrapper(const ModelNode &modelNode)
    : m_modelNode(modelNode)
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper constructor", category()};
+
    QmlObjectNode qmlObjectNode(modelNode);

    QTC_ASSERT(qmlObjectNode.isValid(), return );
@@ -867,11 +997,15 @@ PropertyEditorSubSelectionWrapper::PropertyEditorSubSelectionWrapper(const Model

 ModelNode PropertyEditorSubSelectionWrapper::modelNode() const
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper model node", category()};
+
    return m_modelNode;
 }

 void PropertyEditorSubSelectionWrapper::deleteModelNode()
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper delete model node", category()};
+
    QmlObjectNode objectNode(m_modelNode);

    view()->executeInTransaction("PropertyEditorView::changeExpression", [&] {
@@ -882,7 +1016,9 @@ void PropertyEditorSubSelectionWrapper::deleteModelNode()

 void PropertyEditorSubSelectionWrapper::changeValue(const QString &name)
 {
-    QTC_ASSERT(m_modelNode.isValid(), return );
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper change value", category()};
+
+    QTC_ASSERT(m_modelNode.isValid(), return);

    if (name.isNull())
        return;
@@ -919,6 +1055,9 @@ void PropertyEditorSubSelectionWrapper::changeValue(const QString &name)

 void PropertyEditorSubSelectionWrapper::setValueFromModel(PropertyNameView name, const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper set value from model",
+                               category()};
+
    m_locked = true;

    QmlObjectNode qmlObjectNode(m_modelNode);
@@ -934,6 +1073,8 @@ void PropertyEditorSubSelectionWrapper::setValueFromModel(PropertyNameView name,

 void PropertyEditorSubSelectionWrapper::resetValue(PropertyNameView name)
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper reset value", category()};
+
    auto propertyValue = qobject_cast<PropertyEditorValue *>(
        variantToQObject(m_valuesPropertyMap.value(QString::fromUtf8(name))));
    if (propertyValue)
@@ -942,12 +1083,17 @@ void PropertyEditorSubSelectionWrapper::resetValue(PropertyNameView name)

 bool PropertyEditorSubSelectionWrapper::isRelevantModelNode(const ModelNode &modelNode) const
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper is relevant model node",
+                               category()};
+
    QmlObjectNode objectNode(m_modelNode);
    return modelNode == m_modelNode || objectNode.propertyChangeForCurrentState() == modelNode;
 }

 void PropertyEditorSubSelectionWrapper::changeExpression(const QString &propertyName)
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper change expression", category()};
+
    PropertyName name = propertyName.toUtf8();

    QTC_ASSERT(m_modelNode.isValid(), return );
@@ -981,6 +1127,9 @@ void PropertyEditorSubSelectionWrapper::changeExpression(const QString &property

 void PropertyEditorSubSelectionWrapper::removePropertyFromModel(PropertyNameView propertyName)
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper remove property from model",
+                               category()};
+
    QTC_ASSERT(m_modelNode.isValid(), return );

    m_locked = true;
@@ -1000,6 +1149,9 @@ void PropertyEditorSubSelectionWrapper::removePropertyFromModel(PropertyNameView
 void PropertyEditorSubSelectionWrapper::commitVariantValueToModel(PropertyNameView propertyName,
                                                                  const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{
+        "property editor sub selection wrapper commit variant value to model", category()};
+
    QTC_ASSERT(m_modelNode.isValid(), return );

    try {
@@ -1016,6 +1168,7 @@ void PropertyEditorSubSelectionWrapper::commitVariantValueToModel(PropertyNameVi

 AbstractView *PropertyEditorSubSelectionWrapper::view() const
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper view", category()};
    QTC_CHECK(m_modelNode.isValid());

    return m_modelNode.view();
--- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorview.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorview.cpp
@@ -4,6 +4,7 @@
 #include "propertyeditorview.h"

 #include "propertyeditorqmlbackend.h"
+#include "propertyeditortracing.h"
 #include "propertyeditortransaction.h"
 #include "propertyeditorvalue.h"
 #include "propertyeditorwidget.h"
@@ -50,6 +51,8 @@ enum {

 namespace QmlDesigner {

+static auto category = PropertyEditorTracing::category;
+
 constexpr QStringView quick3dImport{u"QtQuick3D"};

 static bool propertyIsAttachedLayoutProperty(PropertyNameView propertyName)
@@ -80,6 +83,8 @@ PropertyEditorView::PropertyEditorView(AsynchronousImageCache &imageCache,
    , m_propertyComponentGenerator{PropertyEditorQmlBackend::propertyEditorResourcesPath(), model()}
    , m_locked(false)
 {
+    NanotraceHR::Tracer tracer{"property editor view constructor", category()};
+
    m_qmlDir = PropertyEditorQmlBackend::propertyEditorResourcesPath();

    if (Utils::HostOsInfo::isMacHost())
@@ -101,11 +106,15 @@ PropertyEditorView::PropertyEditorView(AsynchronousImageCache &imageCache,

 PropertyEditorView::~PropertyEditorView()
 {
+    NanotraceHR::Tracer tracer{"property editor view destructor", category()};
+
    qDeleteAll(m_qmlBackendHash);
 }

 void PropertyEditorView::changeValue(const QString &name)
 {
+    NanotraceHR::Tracer tracer{"property editor view change value", category()};
+
    PropertyName propertyName = name.toUtf8();

    if (propertyName.isNull())
@@ -231,6 +240,8 @@ static bool isTrueFalseLiteral(const QString &expression)

 void PropertyEditorView::changeExpression(const QString &propertyName)
 {
+    NanotraceHR::Tracer tracer{"property editor view change expression", category()};
+
    PropertyName name = propertyName.toUtf8();

    if (name.isNull())
@@ -268,6 +279,8 @@ void PropertyEditorView::changeExpression(const QString &propertyName)

 void PropertyEditorView::exportPropertyAsAlias(const QString &name)
 {
+    NanotraceHR::Tracer tracer{"property editor view export property as alias", category()};
+
    if (name.isNull())
        return;

@@ -283,6 +296,8 @@ void PropertyEditorView::exportPropertyAsAlias(const QString &name)

 void PropertyEditorView::removeAliasExport(const QString &name)
 {
+    NanotraceHR::Tracer tracer{"property editor view remove alias export", category()};
+
    if (name.isNull())
        return;

@@ -298,21 +313,30 @@ void PropertyEditorView::removeAliasExport(const QString &name)

 bool PropertyEditorView::locked() const
 {
+    NanotraceHR::Tracer tracer{"property editor view locked", category()};
+
    return m_locked;
 }

 void PropertyEditorView::currentTimelineChanged(const ModelNode &)
 {
-    m_qmlBackEndForCurrentType->contextObject()->setHasActiveTimeline(QmlTimeline::hasActiveTimeline(this));
+    NanotraceHR::Tracer tracer{"property editor view current timeline changed", category()};
+
+    m_qmlBackEndForCurrentType->contextObject()->setHasActiveTimeline(
+        QmlTimeline::hasActiveTimeline(this));
 }

 void PropertyEditorView::refreshMetaInfos(const TypeIds &deletedTypeIds)
 {
+    NanotraceHR::Tracer tracer{"property editor view refresh meta infos", category()};
+
    m_propertyComponentGenerator.refreshMetaInfos(deletedTypeIds);
 }

 DynamicPropertiesModel *PropertyEditorView::dynamicPropertiesModel() const
 {
+    NanotraceHR::Tracer tracer{"property editor view dynamic properties model", category()};
+
    return m_dynamicPropertiesModel.get();
 }

@@ -320,6 +344,8 @@ void PropertyEditorView::setExpressionOnObjectNode(const QmlObjectNode &constObj
                                                   PropertyNameView name,
                                                   const QString &newExpression)
 {
+    NanotraceHR::Tracer tracer{"property editor view set expression on object node", category()};
+
    auto qmlObjectNode = constObjectNode;
    auto expression = newExpression;
    if (auto property = qmlObjectNode.modelNode().metaInfo().property(name)) {
@@ -374,7 +400,9 @@ void PropertyEditorView::setExpressionOnObjectNode(const QmlObjectNode &constObj

 void PropertyEditorView::generateAliasForProperty(const ModelNode &modelNode, const QString &name)
 {
-    QTC_ASSERT(modelNode.isValid(), return );
+    NanotraceHR::Tracer tracer{"property editor view generate alias for property", category()};
+
+    QTC_ASSERT(modelNode.isValid(), return);

    auto view = modelNode.view();

@@ -400,7 +428,9 @@ void PropertyEditorView::generateAliasForProperty(const ModelNode &modelNode, co

 void PropertyEditorView::removeAliasForProperty(const ModelNode &modelNode, const QString &propertyName)
 {
-    QTC_ASSERT(modelNode.isValid(), return );
+    NanotraceHR::Tracer tracer{"property editor view remove alias for property", category()};
+
+    QTC_ASSERT(modelNode.isValid(), return);

    auto view = modelNode.view();

@@ -420,6 +450,8 @@ void PropertyEditorView::removeAliasForProperty(const ModelNode &modelNode, cons

 PropertyEditorView *PropertyEditorView::instance()
 {
+    NanotraceHR::Tracer tracer{"property editor view instance", category()};
+
    static PropertyEditorView *s_instance = nullptr;

    if (s_instance)
@@ -438,6 +470,8 @@ PropertyEditorView *PropertyEditorView::instance()

 NodeMetaInfo PropertyEditorView::findCommonAncestor(const ModelNode &node)
 {
+    NanotraceHR::Tracer tracer{"property editor view find common ancestor", category()};
+
    if (!node.isValid())
        return node.metaInfo();

@@ -458,6 +492,8 @@ NodeMetaInfo PropertyEditorView::findCommonAncestor(const ModelNode &node)

 void PropertyEditorView::updateSize()
 {
+    NanotraceHR::Tracer tracer{"property editor view update size", category()};
+
    if (!m_qmlBackEndForCurrentType)
        return;
    auto frame = m_qmlBackEndForCurrentType->widget()->findChild<QWidget *>("propertyEditorFrame");
@@ -467,6 +503,8 @@ void PropertyEditorView::updateSize()

 void PropertyEditorView::resetView()
 {
+    NanotraceHR::Tracer tracer{"property editor view reset view", category()};
+
    if (model() == nullptr)
        return;

@@ -498,6 +536,8 @@ void PropertyEditorView::resetView()

 void PropertyEditorView::setIsSelectionLocked(bool locked)
 {
+    NanotraceHR::Tracer tracer{"property editor view set is selection locked", category()};
+
    if (m_isSelectionLocked != locked) {
        m_isSelectionLocked = locked;
        for (PropertyEditorQmlBackend *qmlBackend : std::as_const(m_qmlBackendHash))
@@ -555,6 +595,8 @@ PropertyEditorQmlBackend *getQmlBackend(QHash<QString, PropertyEditorQmlBackend
                                        PropertyEditorWidget *stackedWidget,
                                        PropertyEditorView *propertyEditorView)
 {
+    NanotraceHR::Tracer tracer{"property editor view get Qml Backend", category()};
+
    auto qmlFileName = qmlFileUrl.toString();
    PropertyEditorQmlBackend *currentQmlBackend = qmlBackendHash.value(qmlFileName);

@@ -649,20 +691,24 @@ void setupWidget(PropertyEditorQmlBackend *currentQmlBackend,

 void PropertyEditorView::handleToolBarAction(int action)
 {
+    NanotraceHR::Tracer tracer{"property editor view handle toolbar action", category()};
+
    switch (action) {
-        case PropertyEditorContextObject::SelectionLock: {
-            setIsSelectionLocked(true);
-            break;
-        }
+    case PropertyEditorContextObject::SelectionLock: {
+        setIsSelectionLocked(true);
+        break;
+    }
        case PropertyEditorContextObject::SelectionUnlock: {
            setIsSelectionLocked(false);
            break;
        }
-    }
+        }
 }

 void PropertyEditorView::setupQmlBackend()
 {
+    NanotraceHR::Tracer tracer{"property editor view setup Qml Backend", category()};
+
 #ifdef QDS_USE_PROJECTSTORAGE
    const NodeMetaInfo commonAncestor = findCommonAncestor(activeNode());
    auto selfAndPrototypes = commonAncestor.selfAndPrototypes();
@@ -740,6 +786,8 @@ void PropertyEditorView::setupQmlBackend()

 void PropertyEditorView::commitVariantValueToModel(PropertyNameView propertyName, const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{"property editor view commit variant value to model", category()};
+
    m_locked = true;
    try {
        RewriterTransaction transaction = beginRewriterTransaction("PropertyEditorView::commitVariantValueToMode");
@@ -759,6 +807,8 @@ void PropertyEditorView::commitVariantValueToModel(PropertyNameView propertyName

 void PropertyEditorView::commitAuxValueToModel(PropertyNameView propertyName, const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{"property editor view commit aux value to model", category()};
+
    m_locked = true;

    PropertyNameView name = propertyName;
@@ -782,6 +832,8 @@ void PropertyEditorView::commitAuxValueToModel(PropertyNameView propertyName, co

 void PropertyEditorView::removePropertyFromModel(PropertyNameView propertyName)
 {
+    NanotraceHR::Tracer tracer{"property editor view remove property from model", category()};
+
    m_locked = true;
    try {
        RewriterTransaction transaction = beginRewriterTransaction("PropertyEditorView::removePropertyFromModel");
@@ -802,22 +854,30 @@ void PropertyEditorView::removePropertyFromModel(PropertyNameView propertyName)

 bool PropertyEditorView::noValidSelection() const
 {
+    NanotraceHR::Tracer tracer{"property editor view no valid selection", category()};
+
    QTC_ASSERT(m_qmlBackEndForCurrentType, return true);
    return !QmlObjectNode::isValidQmlObjectNode(activeNode());
 }

 ModelNode PropertyEditorView::activeNode() const
 {
+    NanotraceHR::Tracer tracer{"property editor view active node", category()};
+
    return m_activeNode;
 }

 void PropertyEditorView::setActiveNode(const ModelNode &node)
 {
+    NanotraceHR::Tracer tracer{"property editor view set active node", category()};
+
    m_activeNode = node;
 }

 QList<ModelNode> PropertyEditorView::currentNodes() const
 {
+    NanotraceHR::Tracer tracer{"property editor view current nodes", category()};
+
    if (m_isSelectionLocked)
        return {m_activeNode};

@@ -827,6 +887,8 @@ QList<ModelNode> PropertyEditorView::currentNodes() const
 void PropertyEditorView::selectedNodesChanged(const QList<ModelNode> &,
                                          const QList<ModelNode> &)
 {
+    NanotraceHR::Tracer tracer{"property editor view selected nodes changed", category()};
+
    if (!m_isSelectionLocked)
        select();

@@ -837,6 +899,8 @@ void PropertyEditorView::selectedNodesChanged(const QList<ModelNode> &,

 bool PropertyEditorView::isNodeOrChildSelected(const ModelNode &node) const
 {
+    NanotraceHR::Tracer tracer{"property editor view is node or child selected", category()};
+
    if (activeNode().isValid() && node.isValid()) {
        const ModelNodes &nodeList = node.allSubModelNodesAndThisNode();
        return nodeList.contains(activeNode());
@@ -846,12 +910,16 @@ bool PropertyEditorView::isNodeOrChildSelected(const ModelNode &node) const

 void PropertyEditorView::resetSelectionLocked()
 {
+    NanotraceHR::Tracer tracer{"property editor view reset selection locked", category()};
+
    if (m_isSelectionLocked)
        setIsSelectionLocked(false);
 }

 void PropertyEditorView::resetIfNodeIsRemoved(const ModelNode &removedNode)
 {
+    NanotraceHR::Tracer tracer{"property editor view reset if node is removed", category()};
+
    if (isNodeOrChildSelected(removedNode)) {
        resetSelectionLocked();
        select();
@@ -860,6 +928,8 @@ void PropertyEditorView::resetIfNodeIsRemoved(const ModelNode &removedNode)

 void PropertyEditorView::nodeAboutToBeRemoved(const ModelNode &removedNode)
 {
+    NanotraceHR::Tracer tracer{"property editor view node about to be removed", category()};
+
    resetIfNodeIsRemoved(removedNode);

    const ModelNodes &allRemovedNodes = removedNode.allSubModelNodesAndThisNode();
@@ -880,6 +950,8 @@ void PropertyEditorView::nodeAboutToBeRemoved(const ModelNode &removedNode)

 void PropertyEditorView::nodeRemoved(const ModelNode &, const NodeAbstractProperty &, PropertyChangeFlags)
 {
+    NanotraceHR::Tracer tracer{"property editor view node removed", category()};
+
    if (m_qmlBackEndForCurrentType && m_textureAboutToBeRemoved)
        m_qmlBackEndForCurrentType->refreshBackendModel();

@@ -888,6 +960,8 @@ void PropertyEditorView::nodeRemoved(const ModelNode &, const NodeAbstractProper

 void PropertyEditorView::modelAttached(Model *model)
 {
+    NanotraceHR::Tracer tracer{"property editor view model attached", category()};
+
    AbstractView::modelAttached(model);

    if constexpr (useProjectStorage())
@@ -902,6 +976,8 @@ void PropertyEditorView::modelAttached(Model *model)

 void PropertyEditorView::modelAboutToBeDetached(Model *model)
 {
+    NanotraceHR::Tracer tracer{"property editor view model about to be detached", category()};
+
    AbstractView::modelAboutToBeDetached(model);
    m_qmlBackEndForCurrentType->propertyEditorTransaction()->end();

@@ -911,6 +987,8 @@ void PropertyEditorView::modelAboutToBeDetached(Model *model)

 void PropertyEditorView::propertiesRemoved(const QList<AbstractProperty> &propertyList)
 {
+    NanotraceHR::Tracer tracer{"property editor view properties removed", category()};
+
    if (noValidSelection())
        return;

@@ -985,12 +1063,16 @@ void PropertyEditorView::propertiesRemoved(const QList<AbstractProperty> &proper

 void PropertyEditorView::propertiesAboutToBeRemoved(const QList<AbstractProperty> &propertyList)
 {
+    NanotraceHR::Tracer tracer{"property editor view properties about to be removed", category()};
+
    for (const auto &property : propertyList)
        m_dynamicPropertiesModel->removeItem(property);
 }

 void PropertyEditorView::variantPropertiesChanged(const QList<VariantProperty>& propertyList, PropertyChangeFlags /*propertyChange*/)
 {
+    NanotraceHR::Tracer tracer{"property editor view variant properties changed", category()};
+
    if (noValidSelection())
        return;

@@ -1042,6 +1124,8 @@ void PropertyEditorView::variantPropertiesChanged(const QList<VariantProperty>&
 void PropertyEditorView::bindingPropertiesChanged(const QList<BindingProperty> &propertyList,
                                                  PropertyChangeFlags /*propertyChange*/)
 {
+    NanotraceHR::Tracer tracer{"property editor view binding properties changed", category()};
+
    if (noValidSelection())
        return;

@@ -1085,6 +1169,8 @@ void PropertyEditorView::auxiliaryDataChanged(const ModelNode &node,
                                              [[maybe_unused]] AuxiliaryDataKeyView key,
                                              const QVariant &data)
 {
+    NanotraceHR::Tracer tracer{"property editor view auxiliary data changed", category()};
+
    if (noValidSelection())
        return;

@@ -1114,12 +1200,17 @@ void PropertyEditorView::auxiliaryDataChanged(const ModelNode &node,
 void PropertyEditorView::signalDeclarationPropertiesChanged(
    const QVector<SignalDeclarationProperty> &propertyList, PropertyChangeFlags /* propertyChange */)
 {
+    NanotraceHR::Tracer tracer{"property editor view signal declaration properties changed",
+                               category()};
+
    for (const SignalDeclarationProperty &property : propertyList)
        m_dynamicPropertiesModel->updateItem(property);
 }

 void PropertyEditorView::instanceInformationsChanged(const QMultiHash<ModelNode, InformationName> &informationChangedHash)
 {
+    NanotraceHR::Tracer tracer{"property editor view instance informations changed", category()};
+
    if (noValidSelection())
        return;

@@ -1133,6 +1224,8 @@ void PropertyEditorView::instanceInformationsChanged(const QMultiHash<ModelNode,

 void PropertyEditorView::nodeIdChanged(const ModelNode &node, const QString &newId, const QString &oldId)
 {
+    NanotraceHR::Tracer tracer{"property editor view node id changed", category()};
+
    if (noValidSelection())
        return;

@@ -1156,6 +1249,8 @@ void PropertyEditorView::nodeIdChanged(const ModelNode &node, const QString &new

 void PropertyEditorView::select()
 {
+    NanotraceHR::Tracer tracer{"property editor view select", category()};
+
    if (m_qmlBackEndForCurrentType)
        m_qmlBackEndForCurrentType->emitSelectionToBeChanged();

@@ -1164,6 +1259,8 @@ void PropertyEditorView::select()

 void PropertyEditorView::setActiveNodeToSelection()
 {
+    NanotraceHR::Tracer tracer{"property editor view set active node to selection", category()};
+
    const auto selectedNodeList = currentNodes();

    setActiveNode(ModelNode());
@@ -1179,6 +1276,8 @@ void PropertyEditorView::setActiveNodeToSelection()

 void PropertyEditorView::forceSelection(const ModelNode &node)
 {
+    NanotraceHR::Tracer tracer{"property editor view force selection", category()};
+
    if (node == activeNode())
        return;

@@ -1191,11 +1290,15 @@ void PropertyEditorView::forceSelection(const ModelNode &node)

 bool PropertyEditorView::hasWidget() const
 {
+    NanotraceHR::Tracer tracer{"property editor view has widget", category()};
+
    return true;
 }

 WidgetInfo PropertyEditorView::widgetInfo()
 {
+    NanotraceHR::Tracer tracer{"property editor view widget info", category()};
+
    return createWidgetInfo(m_stackedWidget,
                            QStringLiteral("Properties"),
                            WidgetInfo::RightPane,
@@ -1205,6 +1308,8 @@ WidgetInfo PropertyEditorView::widgetInfo()

 void PropertyEditorView::currentStateChanged(const ModelNode &node)
 {
+    NanotraceHR::Tracer tracer{"property editor view current state changed", category()};
+
    QmlModelState newQmlModelState(node);
    Q_ASSERT(newQmlModelState.isValid());
    if (debug)
@@ -1214,6 +1319,8 @@ void PropertyEditorView::currentStateChanged(const ModelNode &node)

 void PropertyEditorView::instancePropertyChanged(const QList<QPair<ModelNode, PropertyName> > &propertyList)
 {
+    NanotraceHR::Tracer tracer{"property editor view instance property changed", category()};
+
    if (!activeNode().isValid())
        return;

@@ -1251,13 +1358,17 @@ void PropertyEditorView::instancePropertyChanged(const QList<QPair<ModelNode, Pr

 void PropertyEditorView::rootNodeTypeChanged(const QString &/*type*/, int /*majorVersion*/, int /*minorVersion*/)
 {
+    NanotraceHR::Tracer tracer{"property editor view root node type changed", category()};
+
    resetView();
 }

 void PropertyEditorView::nodeTypeChanged(const ModelNode &node, const TypeName &, int, int)
 {
-     if (node == activeNode())
-         resetView();
+    NanotraceHR::Tracer tracer{"property editor view node type changed", category()};
+
+    if (node == activeNode())
+        resetView();
 }

 void PropertyEditorView::nodeReparented(const ModelNode &node,
@@ -1265,6 +1376,8 @@ void PropertyEditorView::nodeReparented(const ModelNode &node,
                                        const NodeAbstractProperty & /*oldPropertyParent*/,
                                        AbstractView::PropertyChangeFlags /*propertyChange*/)
 {
+    NanotraceHR::Tracer tracer{"property editor view node reparented", category()};
+
    if (node == activeNode())
        m_qmlBackEndForCurrentType->backendAnchorBinding().setup(QmlItemNode(activeNode()));

@@ -1285,6 +1398,8 @@ void PropertyEditorView::nodeReparented(const ModelNode &node,

 void PropertyEditorView::importsChanged(const Imports &addedImports, const Imports &removedImports)
 {
+    NanotraceHR::Tracer tracer{"property editor view imports changed", category()};
+
    if (!m_qmlBackEndForCurrentType)
        return;

@@ -1299,6 +1414,8 @@ void PropertyEditorView::customNotification([[maybe_unused]] const AbstractView
                                            const QList<ModelNode> &nodeList,
                                            [[maybe_unused]] const QList<QVariant> &data)
 {
+    NanotraceHR::Tracer tracer{"property editor view custom notification", category()};
+
    if (identifier == "force_editing_node") {
        if (!nodeList.isEmpty())
            forceSelection(nodeList.first());
@@ -1309,6 +1426,8 @@ void PropertyEditorView::modelNodePreviewPixmapChanged(const ModelNode &node,
                                                       const QPixmap &pixmap,
                                                       const QByteArray &requestId)
 {
+    NanotraceHR::Tracer tracer{"property editor view model node preview pixmap changed", category()};
+
    if (node != activeNode())
        return;

@@ -1318,6 +1437,8 @@ void PropertyEditorView::modelNodePreviewPixmapChanged(const ModelNode &node,

 void PropertyEditorView::highlightTextureProperties(bool highlight)
 {
+    NanotraceHR::Tracer tracer{"property editor view highlight texture properties", category()};
+
    NodeMetaInfo metaInfo = activeNode().metaInfo();
    QTC_ASSERT(metaInfo.isValid(), return);

@@ -1334,6 +1455,8 @@ void PropertyEditorView::highlightTextureProperties(bool highlight)

 void PropertyEditorView::dragStarted(QMimeData *mimeData)
 {
+    NanotraceHR::Tracer tracer{"property editor view drag started", category()};
+
    if (mimeData->hasFormat(Constants::MIME_TYPE_ASSETS)) {
        const QString assetPath = QString::fromUtf8(mimeData->data(Constants::MIME_TYPE_ASSETS))
                                      .split(',')[0];
@@ -1354,6 +1477,8 @@ void PropertyEditorView::dragStarted(QMimeData *mimeData)

 void PropertyEditorView::dragEnded()
 {
+    NanotraceHR::Tracer tracer{"property editor view drag ended", category()};
+
    m_qmlBackEndForCurrentType->contextObject()->setActiveDragSuffix("");
    highlightTextureProperties(false);
 }
@@ -1362,6 +1487,8 @@ void PropertyEditorView::setValue(const QmlObjectNode &qmlObjectNode,
                                  PropertyNameView name,
                                  const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{"property editor view set value", category()};
+
    m_locked = true;
    m_qmlBackEndForCurrentType->setValue(qmlObjectNode, name, value);
    m_locked = false;
@@ -1369,6 +1496,8 @@ void PropertyEditorView::setValue(const QmlObjectNode &qmlObjectNode,

 bool PropertyEditorView::eventFilter(QObject *obj, QEvent *event)
 {
+    NanotraceHR::Tracer tracer{"property editor view event filter", category()};
+
    if (event->type() == QEvent::FocusOut) {
        if (m_qmlBackEndForCurrentType && m_qmlBackEndForCurrentType->widget() == obj)
            QMetaObject::invokeMethod(m_qmlBackEndForCurrentType->widget()->rootObject(), "closeContextMenu");
@@ -1378,6 +1507,8 @@ bool PropertyEditorView::eventFilter(QObject *obj, QEvent *event)

 void PropertyEditorView::reloadQml()
 {
+    NanotraceHR::Tracer tracer{"property editor view reload Qml", category()};
+
    m_qmlBackendHash.clear();
    while (QWidget *widget = m_stackedWidget->widget(0)) {
        m_stackedWidget->removeWidget(widget);
--- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorwidget.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorwidget.cpp
@@ -3,18 +3,26 @@

 #include "propertyeditorwidget.h"

+#include "propertyeditortracing.h"
+
 #include <qmldesignerconstants.h>
 #include <qmldesignerplugin.h>

 namespace QmlDesigner {

+static auto category = PropertyEditorTracing::category;
+
 PropertyEditorWidget::PropertyEditorWidget(QWidget *parent) : QStackedWidget(parent)
 {
+    NanotraceHR::Tracer tracer{"property editor widget constructor", category()};
+
    QmlDesignerPlugin::trackWidgetFocusTime(this, Constants::EVENT_PROPERTYEDITOR_TIME);
 }

 void PropertyEditorWidget::resizeEvent(QResizeEvent * event)
 {
+    NanotraceHR::Tracer tracer{"property editor widget resize event", category()};
+
    QStackedWidget::resizeEvent(event);
    emit resized();
 }
--- a/src/plugins/qmldesigner/components/propertyeditor/propertynamevalidator.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/propertynamevalidator.cpp
@@ -3,16 +3,24 @@

 #include "propertynamevalidator.h"

-#include "modelutils.h"
+#include "propertyeditortracing.h"
+
+#include <modelutils.h>

 #include <QRegularExpression>

+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 PropertyNameValidator::PropertyNameValidator(QObject *parent)
    : QValidator(parent)
-{}
+{
+    NanotraceHR::Tracer tracer{"property name validator constructor", category()};
+}

 QValidator::State PropertyNameValidator::validate(QString &input, int &) const
 {
+    NanotraceHR::Tracer tracer{"property name validator validate", category()};
+
    if (input.isEmpty())
        return QValidator::Intermediate;

@@ -32,5 +40,7 @@ QValidator::State PropertyNameValidator::validate(QString &input, int &) const

 void PropertyNameValidator::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"property name validator register declarative type", category()};
+
    qmlRegisterType<PropertyNameValidator>("HelperWidgets", 2, 0, "PropertyNameValidator");
 }
--- a/src/plugins/qmldesigner/components/propertyeditor/qmlanchorbindingproxy.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/qmlanchorbindingproxy.cpp
@@ -3,6 +3,8 @@

 #include "qmlanchorbindingproxy.h"

+#include "propertyeditortracing.h"
+
 #include <abstractview.h>
 #include <exception.h>
 #include <modelnodeoperations.h>
@@ -22,6 +24,9 @@ class ModelNode;
 class NodeState;

 namespace {
+
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 const Utils::SmallString auxDataString("anchors_");

 Utils::SmallString auxPropertyString(Utils::SmallStringView name)
@@ -47,12 +52,18 @@ QmlAnchorBindingProxy::QmlAnchorBindingProxy(QObject *parent) :
    m_relativeVerticalTarget(Center), m_relativeHorizontalTarget(Center),
    m_locked(false), m_ignoreQml(false)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy constructor", category()};
 }

-QmlAnchorBindingProxy::~QmlAnchorBindingProxy() = default;
+QmlAnchorBindingProxy::~QmlAnchorBindingProxy()
+{
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy destructor", category()};
+}

 void QmlAnchorBindingProxy::setup(const QmlItemNode &fxItemNode)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy setup", category()};
+
    m_qmlItemNode = fxItemNode;

    m_ignoreQml = true;
@@ -80,6 +91,8 @@ void QmlAnchorBindingProxy::setup(const QmlItemNode &fxItemNode)

 void QmlAnchorBindingProxy::invalidate(const QmlItemNode &fxItemNode)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy invalidate", category()};
+
    if (m_locked)
        return;

@@ -92,13 +105,8 @@ void QmlAnchorBindingProxy::invalidate(const QmlItemNode &fxItemNode)
        return node.modelNode().parentProperty().parentModelNode();
    };

-    m_verticalTarget =
-            m_horizontalTarget =
-            m_topTarget =
-            m_bottomTarget =
-            m_leftTarget =
-            m_rightTarget =
-            parentModelNode(m_qmlItemNode);
+    m_verticalTarget = m_horizontalTarget = m_topTarget = m_bottomTarget = m_leftTarget = m_rightTarget = parentModelNode(
+        m_qmlItemNode);

    setupAnchorTargets();

@@ -121,6 +129,8 @@ void QmlAnchorBindingProxy::invalidate(const QmlItemNode &fxItemNode)

 void QmlAnchorBindingProxy::setupAnchorTargets()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy setup anchor targets", category()};
+
    if (m_qmlItemNode.modelNode().hasParentProperty())
        setDefaultAnchorTarget(m_qmlItemNode.modelNode().parentProperty().parentModelNode());
    else
@@ -209,7 +219,9 @@ void QmlAnchorBindingProxy::setupAnchorTargets()
    }

    if (horizontalCentered()) {
-        ModelNode targetNode = m_qmlItemNode.anchors().instanceAnchor(AnchorLineHorizontalCenter).qmlItemNode();
+        ModelNode targetNode = m_qmlItemNode.anchors()
+                                   .instanceAnchor(AnchorLineHorizontalCenter)
+                                   .qmlItemNode();
        if (targetNode.isValid())
            m_horizontalTarget = targetNode;
    }
@@ -217,6 +229,8 @@ void QmlAnchorBindingProxy::setupAnchorTargets()

 void QmlAnchorBindingProxy::emitAnchorSignals()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy emit anchor signals", category()};
+
    emit topAnchorChanged();
    emit bottomAnchorChanged();
    emit leftAnchorChanged();
@@ -233,6 +247,8 @@ void QmlAnchorBindingProxy::emitAnchorSignals()

 void QmlAnchorBindingProxy::setDefaultRelativeTopTarget()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set default relative top target", category()};
+
    if (m_topTarget.modelNode() == m_qmlItemNode.modelNode().parentProperty().parentModelNode()) {
        m_relativeTopTarget = SameEdge;
    } else {
@@ -242,6 +258,9 @@ void QmlAnchorBindingProxy::setDefaultRelativeTopTarget()

 void QmlAnchorBindingProxy::setDefaultRelativeBottomTarget()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set default relative bottom target",
+                               category()};
+
    if (m_bottomTarget.modelNode() == m_qmlItemNode.modelNode().parentProperty().parentModelNode()) {
        m_relativeBottomTarget = SameEdge;
    } else {
@@ -251,6 +270,9 @@ void QmlAnchorBindingProxy::setDefaultRelativeBottomTarget()

 void QmlAnchorBindingProxy::setDefaultRelativeLeftTarget()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set default relative left target",
+                               category()};
+
    if (m_leftTarget.modelNode() == m_qmlItemNode.modelNode().parentProperty().parentModelNode()) {
        m_relativeLeftTarget = SameEdge;
    } else {
@@ -260,6 +282,9 @@ void QmlAnchorBindingProxy::setDefaultRelativeLeftTarget()

 void QmlAnchorBindingProxy::setDefaultRelativeRightTarget()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set default relative right target",
+                               category()};
+
    if (m_rightTarget.modelNode() == m_qmlItemNode.modelNode().parentProperty().parentModelNode()) {
        m_relativeRightTarget = SameEdge;
    } else {
@@ -267,23 +292,32 @@ void QmlAnchorBindingProxy::setDefaultRelativeRightTarget()
    }
 }

-bool QmlAnchorBindingProxy::executeInTransaction(const QByteArray &identifier, const AbstractView::OperationBlock &lambda)
+bool QmlAnchorBindingProxy::executeInTransaction(const QByteArray &identifier,
+                                                 const AbstractView::OperationBlock &lambda)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy execute in transaction", category()};
+
    return m_qmlItemNode.modelNode().view()->executeInTransaction(identifier, lambda);
 }

 bool QmlAnchorBindingProxy::hasParent() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy has parent", category()};
+
    return m_qmlItemNode.hasNodeParent();
 }

 bool QmlAnchorBindingProxy::isInLayout() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy is in layout", category()};
+
    return m_qmlItemNode.isInLayout();
 }

 bool QmlAnchorBindingProxy::isFilled() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy is filled", category()};
+
    return hasAnchors() && topAnchored() && bottomAnchored() && leftAnchored() && rightAnchored()
           && (m_qmlItemNode.instanceValue("anchors.topMargin").toInt() == 0)
           && (m_qmlItemNode.instanceValue("anchors.bottomMargin").toInt() == 0)
@@ -293,32 +327,42 @@ bool QmlAnchorBindingProxy::isFilled() const

 bool QmlAnchorBindingProxy::topAnchored() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy top anchored", category()};
+
    return m_qmlItemNode.anchors().instanceHasAnchor(AnchorLineTop);
 }

 bool QmlAnchorBindingProxy::bottomAnchored() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy bottom anchored", category()};
+
    return m_qmlItemNode.anchors().instanceHasAnchor(AnchorLineBottom);
 }

 bool QmlAnchorBindingProxy::leftAnchored() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy left anchored", category()};
+
    return m_qmlItemNode.anchors().instanceHasAnchor(AnchorLineLeft);
 }

 bool QmlAnchorBindingProxy::rightAnchored() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy right anchored", category()};
+
    return m_qmlItemNode.anchors().instanceHasAnchor(AnchorLineRight);
 }

 bool QmlAnchorBindingProxy::hasAnchors() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy has anchors", category()};
+
    return m_qmlItemNode.anchors().instanceHasAnchors();
 }

-
 void QmlAnchorBindingProxy::setTopTarget(const QString &target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set top target", category()};

    if (m_ignoreQml)
        return;
@@ -331,7 +375,7 @@ void QmlAnchorBindingProxy::setTopTarget(const QString &target)
    if (!newTarget.isValid())
        return;

-    executeInTransaction("QmlAnchorBindingProxy::setTopTarget", [this, newTarget](){
+    executeInTransaction("QmlAnchorBindingProxy::setTopTarget", [this, newTarget]() {
        m_topTarget = newTarget;
        setDefaultRelativeTopTarget();
        anchorTop();
@@ -340,9 +384,10 @@ void QmlAnchorBindingProxy::setTopTarget(const QString &target)
    emit topTargetChanged();
 }

-
 void QmlAnchorBindingProxy::setBottomTarget(const QString &target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set bottom target", category()};
+
    if (m_ignoreQml)
        return;

@@ -354,11 +399,10 @@ void QmlAnchorBindingProxy::setBottomTarget(const QString &target)
    if (!newTarget.isValid())
        return;

-    executeInTransaction("QmlAnchorBindingProxy::setBottomTarget", [this, newTarget](){
+    executeInTransaction("QmlAnchorBindingProxy::setBottomTarget", [this, newTarget]() {
        m_bottomTarget = newTarget;
        setDefaultRelativeBottomTarget();
        anchorBottom();
-
    });

    emit bottomTargetChanged();
@@ -366,6 +410,8 @@ void QmlAnchorBindingProxy::setBottomTarget(const QString &target)

 void QmlAnchorBindingProxy::setLeftTarget(const QString &target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set left target", category()};
+
    if (m_ignoreQml)
        return;

@@ -377,7 +423,7 @@ void QmlAnchorBindingProxy::setLeftTarget(const QString &target)
    if (!newTarget.isValid())
        return;

-    executeInTransaction("QmlAnchorBindingProxy::setLeftTarget", [this, newTarget](){
+    executeInTransaction("QmlAnchorBindingProxy::setLeftTarget", [this, newTarget]() {
        m_leftTarget = newTarget;
        setDefaultRelativeLeftTarget();
        anchorLeft();
@@ -388,6 +434,8 @@ void QmlAnchorBindingProxy::setLeftTarget(const QString &target)

 void QmlAnchorBindingProxy::setRightTarget(const QString &target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set right target", category()};
+
    if (m_ignoreQml)
        return;

@@ -399,7 +447,7 @@ void QmlAnchorBindingProxy::setRightTarget(const QString &target)
    if (!newTarget.isValid())
        return;

-    executeInTransaction("QmlAnchorBindingProxy::setRightTarget", [this, newTarget](){
+    executeInTransaction("QmlAnchorBindingProxy::setRightTarget", [this, newTarget]() {
        m_rightTarget = newTarget;
        setDefaultRelativeRightTarget();
        anchorRight();
@@ -410,6 +458,8 @@ void QmlAnchorBindingProxy::setRightTarget(const QString &target)

 void QmlAnchorBindingProxy::setVerticalTarget(const QString &target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set vertical target", category()};
+
    if (m_ignoreQml)
        return;

@@ -421,7 +471,7 @@ void QmlAnchorBindingProxy::setVerticalTarget(const QString &target)
    if (!newTarget.isValid())
        return;

-    executeInTransaction("QmlAnchorBindingProxy::setVerticalTarget", [this, newTarget](){
+    executeInTransaction("QmlAnchorBindingProxy::setVerticalTarget", [this, newTarget]() {
        m_verticalTarget = newTarget;
        anchorVertical();
    });
@@ -431,6 +481,8 @@ void QmlAnchorBindingProxy::setVerticalTarget(const QString &target)

 void QmlAnchorBindingProxy::setHorizontalTarget(const QString &target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set horizontal target", category()};
+
    if (m_ignoreQml)
        return;

@@ -442,7 +494,7 @@ void QmlAnchorBindingProxy::setHorizontalTarget(const QString &target)
    if (!newTarget.isValid())
        return;

-    executeInTransaction("QmlAnchorBindingProxy::setHorizontalTarget", [this, newTarget](){
+    executeInTransaction("QmlAnchorBindingProxy::setHorizontalTarget", [this, newTarget]() {
        m_horizontalTarget = newTarget;
        anchorHorizontal();
    });
@@ -452,13 +504,15 @@ void QmlAnchorBindingProxy::setHorizontalTarget(const QString &target)

 void QmlAnchorBindingProxy::setRelativeAnchorTargetTop(QmlAnchorBindingProxy::RelativeAnchorTarget target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set relative anchor target top", category()};
+
    if (m_ignoreQml)
        return;

    if (target == m_relativeTopTarget)
        return;

-    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetTop", [this, target](){
+    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetTop", [this, target]() {
        m_relativeTopTarget = target;
        anchorTop();
    });
@@ -468,13 +522,16 @@ void QmlAnchorBindingProxy::setRelativeAnchorTargetTop(QmlAnchorBindingProxy::Re

 void QmlAnchorBindingProxy::setRelativeAnchorTargetBottom(QmlAnchorBindingProxy::RelativeAnchorTarget target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set relative anchor target bottom",
+                               category()};
+
    if (m_ignoreQml)
        return;

    if (target == m_relativeBottomTarget)
        return;

-    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetBottom", [this, target](){
+    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetBottom", [this, target]() {
        m_relativeBottomTarget = target;
        anchorBottom();
    });
@@ -484,16 +541,17 @@ void QmlAnchorBindingProxy::setRelativeAnchorTargetBottom(QmlAnchorBindingProxy:

 void QmlAnchorBindingProxy::setRelativeAnchorTargetLeft(QmlAnchorBindingProxy::RelativeAnchorTarget target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set relative anchor target left", category()};
+
    if (m_ignoreQml)
        return;

    if (target == m_relativeLeftTarget)
        return;

-    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetLeft", [this, target](){
+    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetLeft", [this, target]() {
        m_relativeLeftTarget = target;
        anchorLeft();
-
    });

    emit relativeAnchorTargetLeftChanged();
@@ -501,31 +559,36 @@ void QmlAnchorBindingProxy::setRelativeAnchorTargetLeft(QmlAnchorBindingProxy::R

 void QmlAnchorBindingProxy::setRelativeAnchorTargetRight(QmlAnchorBindingProxy::RelativeAnchorTarget target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set relative anchor target right",
+                               category()};
+
    if (m_ignoreQml)
        return;

    if (target == m_relativeRightTarget)
        return;

-    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetRight", [this, target](){
+    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetRight", [this, target]() {
        m_relativeRightTarget = target;
        anchorRight();
    });

    emit relativeAnchorTargetRightChanged();
-
 }

-void QmlAnchorBindingProxy::setRelativeAnchorTargetVertical(QmlAnchorBindingProxy::RelativeAnchorTarget target)
+void QmlAnchorBindingProxy::setRelativeAnchorTargetVertical(
+    QmlAnchorBindingProxy::RelativeAnchorTarget target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set relative anchor target vertical",
+                               category()};
+
    if (m_ignoreQml)
        return;

    if (target == m_relativeVerticalTarget)
        return;

-
-    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetVertical", [this, target](){
+    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetVertical", [this, target]() {
        m_relativeVerticalTarget = target;
        anchorVertical();
    });
@@ -533,15 +596,19 @@ void QmlAnchorBindingProxy::setRelativeAnchorTargetVertical(QmlAnchorBindingProx
    emit relativeAnchorTargetVerticalChanged();
 }

-void QmlAnchorBindingProxy::setRelativeAnchorTargetHorizontal(QmlAnchorBindingProxy::RelativeAnchorTarget target)
+void QmlAnchorBindingProxy::setRelativeAnchorTargetHorizontal(
+    QmlAnchorBindingProxy::RelativeAnchorTarget target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set relative anchor target horizontal",
+                               category()};
+
    if (m_ignoreQml)
        return;

    if (target == m_relativeHorizontalTarget)
        return;

-    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetHorizontal", [this, target](){
+    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetHorizontal", [this, target]() {
        m_relativeHorizontalTarget = target;
        anchorHorizontal();
    });
@@ -551,6 +618,8 @@ void QmlAnchorBindingProxy::setRelativeAnchorTargetHorizontal(QmlAnchorBindingPr

 QStringList QmlAnchorBindingProxy::possibleTargetItems() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy possible target items", category()};
+
    QStringList stringList;
    if (!m_qmlItemNode.isValid())
        return stringList;
@@ -563,7 +632,8 @@ QStringList QmlAnchorBindingProxy::possibleTargetItems() const
    //We currently have no instanceChildren().
    //So we double check here if the instanceParents are equal.
    for (const QmlItemNode &node : std::as_const(itemList))
-        if (node.isValid() && (node.instanceParent().modelNode() != m_qmlItemNode.instanceParent().modelNode()))
+        if (node.isValid()
+            && (node.instanceParent().modelNode() != m_qmlItemNode.instanceParent().modelNode()))
            itemList.removeAll(node);

    for (const QmlItemNode &itemNode : std::as_const(itemList)) {
@@ -581,7 +651,9 @@ QStringList QmlAnchorBindingProxy::possibleTargetItems() const

 void QmlAnchorBindingProxy::registerDeclarativeType()
 {
-    qmlRegisterType<QmlAnchorBindingProxy>("HelperWidgets",2,0,"AnchorBindingProxy");
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy register declarative type", category()};
+
+    qmlRegisterType<QmlAnchorBindingProxy>("HelperWidgets", 2, 0, "AnchorBindingProxy");
 }

 int QmlAnchorBindingProxy::indexOfPossibleTargetItem(const QString &targetName) const
@@ -591,8 +663,9 @@ int QmlAnchorBindingProxy::indexOfPossibleTargetItem(const QString &targetName)

 void QmlAnchorBindingProxy::resetLayout()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy reset layout", category()};

-    executeInTransaction("QmlAnchorBindingProxy::resetLayout", [this](){
+    executeInTransaction("QmlAnchorBindingProxy::resetLayout", [this]() {
        m_qmlItemNode.anchors().removeAnchors();
        m_qmlItemNode.anchors().removeMargins();

@@ -602,15 +675,17 @@ void QmlAnchorBindingProxy::resetLayout()
        restoreProperty(modelNode(), "height");
    });

-        emit topAnchorChanged();
-        emit bottomAnchorChanged();
-        emit leftAnchorChanged();
-        emit rightAnchorChanged();
-        emit anchorsChanged();
-    }
+    emit topAnchorChanged();
+    emit bottomAnchorChanged();
+    emit leftAnchorChanged();
+    emit rightAnchorChanged();
+    emit anchorsChanged();
+}

 void QmlAnchorBindingProxy::setBottomAnchor(bool anchor)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set bottom anchor", category()};
+
    if (!m_qmlItemNode.hasNodeParent())
        return;

@@ -639,6 +714,8 @@ void QmlAnchorBindingProxy::setBottomAnchor(bool anchor)

 void QmlAnchorBindingProxy::setLeftAnchor(bool anchor)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set left anchor", category()};
+
    if (!m_qmlItemNode.hasNodeParent())
        return;

@@ -668,6 +745,8 @@ void QmlAnchorBindingProxy::setLeftAnchor(bool anchor)

 void QmlAnchorBindingProxy::setRightAnchor(bool anchor)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set right anchor", category()};
+
    if (!m_qmlItemNode.hasNodeParent())
        return;

@@ -696,6 +775,8 @@ void QmlAnchorBindingProxy::setRightAnchor(bool anchor)
 }
 QRectF QmlAnchorBindingProxy::parentBoundingBox()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy parent bounding box", category()};
+
    if (m_qmlItemNode.hasInstanceParent()) {
        if (m_qmlItemNode.instanceParentItem().instanceContentItemBoundingRect().isValid())
            return m_qmlItemNode.instanceParentItem().instanceContentItemBoundingRect();
@@ -707,6 +788,8 @@ void QmlAnchorBindingProxy::setRightAnchor(bool anchor)

 QRectF QmlAnchorBindingProxy::boundingBox(const QmlItemNode &node)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy bounding box", category()};
+
    if (node.isValid())
        return node.instanceTransformWithContentTransform().mapRect(node.instanceBoundingRect());

@@ -715,11 +798,16 @@ QRectF QmlAnchorBindingProxy::boundingBox(const QmlItemNode &node)

 QRectF QmlAnchorBindingProxy::transformedBoundingBox()
 {
-    return m_qmlItemNode.instanceTransformWithContentTransform().mapRect(m_qmlItemNode.instanceBoundingRect());
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy transformed bounding box", category()};
+
+    return m_qmlItemNode.instanceTransformWithContentTransform().mapRect(
+        m_qmlItemNode.instanceBoundingRect());
 }

 void QmlAnchorBindingProxy::anchorTop()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy anchor top", category()};
+
    m_locked = true;

    bool topTargetIsParent = m_topTarget == m_qmlItemNode.instanceParentItem();
@@ -746,6 +834,8 @@ void QmlAnchorBindingProxy::anchorTop()

 void QmlAnchorBindingProxy::anchorBottom()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy anchor bottom", category()};
+
    m_locked = true;

    bool bottomTargetIsParent = m_bottomTarget == m_qmlItemNode.instanceParentItem();
@@ -772,6 +862,8 @@ void QmlAnchorBindingProxy::anchorBottom()

 void QmlAnchorBindingProxy::anchorLeft()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy anchor left", category()};
+
    m_locked = true;

    bool leftTargetIsParent = m_leftTarget == m_qmlItemNode.instanceParentItem();
@@ -798,6 +890,8 @@ void QmlAnchorBindingProxy::anchorLeft()

 void QmlAnchorBindingProxy::anchorRight()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy anchor right", category()};
+
    m_locked = true;

    bool rightTargetIsParent = m_rightTarget == m_qmlItemNode.instanceParentItem();
@@ -824,6 +918,8 @@ void QmlAnchorBindingProxy::anchorRight()

 void QmlAnchorBindingProxy::anchorVertical()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy anchor vertical", category()};
+
    m_locked = true;
    if (m_relativeVerticalTarget == SameEdge) {
        m_qmlItemNode.anchors().setAnchor(AnchorLineVerticalCenter, m_verticalTarget, AnchorLineRight);
@@ -839,6 +935,8 @@ void QmlAnchorBindingProxy::anchorVertical()

 void QmlAnchorBindingProxy::anchorHorizontal()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy anchor horizontal", category()};
+
    m_locked = true;
    if (m_relativeHorizontalTarget == SameEdge) {
        m_qmlItemNode.anchors().setAnchor(AnchorLineHorizontalCenter, m_horizontalTarget, AnchorLineRight);
@@ -853,6 +951,8 @@ void QmlAnchorBindingProxy::anchorHorizontal()

 QmlItemNode QmlAnchorBindingProxy::targetIdToNode(const QString &id) const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy target id to node", category()};
+
    QmlItemNode itemNode;

    if (m_qmlItemNode.isValid() && m_qmlItemNode.view()) {
@@ -868,6 +968,8 @@ QmlItemNode QmlAnchorBindingProxy::targetIdToNode(const QString &id) const

 QString QmlAnchorBindingProxy::idForNode(const QmlItemNode &qmlItemNode) const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy id for node", category()};
+
    if (!qmlItemNode.modelNode().isValid())
        return {};

@@ -882,11 +984,15 @@ QString QmlAnchorBindingProxy::idForNode(const QmlItemNode &qmlItemNode) const

 ModelNode QmlAnchorBindingProxy::modelNode() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy model node", category()};
+
    return m_qmlItemNode.modelNode();
 }

 void QmlAnchorBindingProxy::setTopAnchor(bool anchor)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set top anchor", category()};
+
    if (!m_qmlItemNode.hasNodeParent())
        return ;

@@ -913,7 +1019,9 @@ void QmlAnchorBindingProxy::setTopAnchor(bool anchor)
 }

 void QmlAnchorBindingProxy::removeTopAnchor() {
-    executeInTransaction("QmlAnchorBindingProxy::removeTopAnchor", [this](){
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy remove top anchor", category()};
+
+    executeInTransaction("QmlAnchorBindingProxy::removeTopAnchor", [this]() {
        m_qmlItemNode.anchors().removeAnchor(AnchorLineTop);
        m_qmlItemNode.anchors().removeMargin(AnchorLineTop);

@@ -925,7 +1033,9 @@ void QmlAnchorBindingProxy::removeTopAnchor() {

 void QmlAnchorBindingProxy::removeBottomAnchor()
 {
-    executeInTransaction("QmlAnchorBindingProxy::removeBottomAnchor", [this](){
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy remove bottom anchor", category()};
+
+    executeInTransaction("QmlAnchorBindingProxy::removeBottomAnchor", [this]() {
        m_qmlItemNode.anchors().removeAnchor(AnchorLineBottom);
        m_qmlItemNode.anchors().removeMargin(AnchorLineBottom);

@@ -937,7 +1047,9 @@ void QmlAnchorBindingProxy::removeBottomAnchor()

 void QmlAnchorBindingProxy::removeLeftAnchor()
 {
-    executeInTransaction("QmlAnchorBindingProxy::removeLeftAnchor", [this](){
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy remove left anchor", category()};
+
+    executeInTransaction("QmlAnchorBindingProxy::removeLeftAnchor", [this]() {
        m_qmlItemNode.anchors().removeAnchor(AnchorLineLeft);
        m_qmlItemNode.anchors().removeMargin(AnchorLineLeft);

@@ -949,7 +1061,9 @@ void QmlAnchorBindingProxy::removeLeftAnchor()

 void QmlAnchorBindingProxy::removeRightAnchor()
 {
-    executeInTransaction("QmlAnchorBindingProxy::removeRightAnchor", [this](){
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy remove right anchor", category()};
+
+    executeInTransaction("QmlAnchorBindingProxy::removeRightAnchor", [this]() {
        m_qmlItemNode.anchors().removeAnchor(AnchorLineRight);
        m_qmlItemNode.anchors().removeMargin(AnchorLineRight);

@@ -961,6 +1075,8 @@ void QmlAnchorBindingProxy::removeRightAnchor()

 void QmlAnchorBindingProxy::setVerticalCentered(bool centered)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set vertical centered", category()};
+
    if (!m_qmlItemNode.hasNodeParent())
        return ;

@@ -995,6 +1111,8 @@ void QmlAnchorBindingProxy::setVerticalCentered(bool centered)

 void QmlAnchorBindingProxy::setHorizontalCentered(bool centered)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set horizontal centered", category()};
+
    if (!m_qmlItemNode.hasNodeParent())
        return ;

@@ -1028,46 +1146,65 @@ void QmlAnchorBindingProxy::setHorizontalCentered(bool centered)

 bool QmlAnchorBindingProxy::verticalCentered()
 {
-    return m_qmlItemNode.isValid() && m_qmlItemNode.anchors().instanceHasAnchor(AnchorLineVerticalCenter);
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy vertical centered", category()};
+
+    return m_qmlItemNode.isValid()
+           && m_qmlItemNode.anchors().instanceHasAnchor(AnchorLineVerticalCenter);
 }

 QString QmlAnchorBindingProxy::topTarget() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy top target", category()};
+
    return idForNode(m_topTarget);
 }

 QString QmlAnchorBindingProxy::bottomTarget() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy bottom target", category()};
+
    return idForNode(m_bottomTarget);
 }

 QString QmlAnchorBindingProxy::leftTarget() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy left target", category()};
+
    return idForNode(m_leftTarget);
 }

 QString QmlAnchorBindingProxy::rightTarget() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy right target", category()};
+
    return idForNode(m_rightTarget);
 }

 QmlAnchorBindingProxy::RelativeAnchorTarget QmlAnchorBindingProxy::relativeAnchorTargetTop() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy relative anchor target top", category()};
+
    return m_relativeTopTarget;
 }

 QmlAnchorBindingProxy::RelativeAnchorTarget QmlAnchorBindingProxy::relativeAnchorTargetBottom() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy relative anchor target bottom", category()};
+
    return m_relativeBottomTarget;
 }

 QmlAnchorBindingProxy::RelativeAnchorTarget QmlAnchorBindingProxy::relativeAnchorTargetLeft() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy relative anchor target left", category()};
+
    return m_relativeLeftTarget;
 }

 QmlAnchorBindingProxy::RelativeAnchorTarget QmlAnchorBindingProxy::relativeAnchorTargetRight() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy relative anchor target right", category()};
+
    return m_relativeRightTarget;
 }

@@ -1078,16 +1215,23 @@ QmlAnchorBindingProxy::RelativeAnchorTarget QmlAnchorBindingProxy::relativeAncho

 QmlAnchorBindingProxy::RelativeAnchorTarget QmlAnchorBindingProxy::relativeAnchorTargetHorizontal() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy relative anchor target horizontal",
+                               category()};
+
    return m_relativeHorizontalTarget;
 }

 QString QmlAnchorBindingProxy::verticalTarget() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy vertical target", category()};
+
    return idForNode(m_verticalTarget);
 }

 QString QmlAnchorBindingProxy::horizontalTarget() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy horizontal target", category()};
+
    return idForNode(m_horizontalTarget);
 }

@@ -1098,6 +1242,8 @@ bool QmlAnchorBindingProxy::horizontalCentered()

 void QmlAnchorBindingProxy::fill()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy fill", category()};
+
    executeInTransaction("QmlAnchorBindingProxy::fill", [this](){
        backupPropertyAndRemove(modelNode(), "x");
        backupPropertyAndRemove(modelNode(), "y");
@@ -1122,6 +1268,8 @@ void QmlAnchorBindingProxy::fill()

 void QmlAnchorBindingProxy::centerIn()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy center in", category()};
+
    executeInTransaction("QmlAnchorBindingProxy::centerIn", [this]() {
        backupPropertyAndRemove(modelNode(), "x");
        backupPropertyAndRemove(modelNode(), "y");
@@ -1139,6 +1287,8 @@ void QmlAnchorBindingProxy::centerIn()

 void QmlAnchorBindingProxy::setDefaultAnchorTarget(const ModelNode &modelNode)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set default anchor target", category()};
+
    m_verticalTarget = modelNode;
    m_horizontalTarget = modelNode;
    m_topTarget = modelNode;
--- a/src/plugins/qmldesigner/components/propertyeditor/qmlmaterialnodeproxy.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/qmlmaterialnodeproxy.cpp
@@ -3,6 +3,8 @@

 #include "qmlmaterialnodeproxy.h"

+#include "propertyeditortracing.h"
+
 #include <auxiliarydataproperties.h>
 #include <designmodewidget.h>
 #include <nodeinstanceview.h>
@@ -14,6 +16,8 @@

 namespace QmlDesigner {

+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 using namespace Qt::StringLiterals;

 static bool allMaterialTypesAre(const ModelNodes &materials, const QString &materialType)
@@ -33,6 +37,8 @@ QmlMaterialNodeProxy::QmlMaterialNodeProxy()
    : QObject()
    , m_previewUpdateTimer(this)
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy constructor", category()};
+
    m_previewUpdateTimer.setInterval(200);
    m_previewUpdateTimer.setSingleShot(true);
    m_previewUpdateTimer.callOnTimeout(
@@ -43,6 +49,8 @@ QmlMaterialNodeProxy::~QmlMaterialNodeProxy() = default;

 void QmlMaterialNodeProxy::setup(const ModelNodes &editorNodes)
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy setup", category()};
+
    QmlObjectNode objectNode = editorNodes.isEmpty() ? ModelNode{} : editorNodes.first();
    const QmlObjectNode material = objectNode.metaInfo().isQtQuick3DMaterial() ? objectNode
                                                                               : QmlObjectNode{};
@@ -54,16 +62,22 @@ void QmlMaterialNodeProxy::setup(const ModelNodes &editorNodes)

 ModelNode QmlMaterialNodeProxy::materialNode() const
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy material node", category()};
+
    return m_materialNode;
 }

 ModelNodes QmlMaterialNodeProxy::editorNodes() const
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy editor nodes", category()};
+
    return m_editorNodes;
 }

 void QmlMaterialNodeProxy::setPossibleTypes(const QStringList &types)
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy set possible types", category()};
+
    if (types == m_possibleTypes)
        return;

@@ -75,6 +89,8 @@ void QmlMaterialNodeProxy::setPossibleTypes(const QStringList &types)

 void QmlMaterialNodeProxy::updatePossibleTypes()
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy update possible types", category()};
+
    static const QStringList basicTypes{
        "CustomMaterial",
        "DefaultMaterial",
@@ -107,12 +123,16 @@ void QmlMaterialNodeProxy::updatePossibleTypes()

 void QmlMaterialNodeProxy::setCurrentType(const QString &type)
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy set current type", category()};
+
    m_currentType = type.split('.').last();
    updatePossibleTypeIndex();
 }

 void QmlMaterialNodeProxy::toolBarAction(int action)
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy tool bar action", category()};
+
    QTC_ASSERT(hasQuick3DImport(), return);

    switch (ToolBarAction(action)) {
@@ -151,6 +171,8 @@ void QmlMaterialNodeProxy::toolBarAction(int action)

 void QmlMaterialNodeProxy::setPreviewEnv(const QString &envAndValue)
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy set preview env", category()};
+
    if (envAndValue.isEmpty())
        return;

@@ -188,6 +210,8 @@ void QmlMaterialNodeProxy::setPreviewEnv(const QString &envAndValue)

 void QmlMaterialNodeProxy::setPreviewModel(const QString &modelStr)
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy set preview model", category()};
+
    if (modelStr.isEmpty())
        return;

@@ -212,6 +236,9 @@ void QmlMaterialNodeProxy::setPreviewModel(const QString &modelStr)

 void QmlMaterialNodeProxy::handleAuxiliaryPropertyChanges()
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy handle auxiliary property changes",
+                               category()};
+
    if (!hasQuick3DImport())
        return;

@@ -220,11 +247,15 @@ void QmlMaterialNodeProxy::handleAuxiliaryPropertyChanges()

 void QmlMaterialNodeProxy::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy register declarative type", category()};
+
    qmlRegisterType<QmlMaterialNodeProxy>("HelperWidgets", 2, 0, "QmlMaterialNodeProxy");
 }

 void QmlMaterialNodeProxy::updatePossibleTypeIndex()
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy update possible type index", category()};
+
    int newIndex = -1;
    if (!m_currentType.isEmpty())
        newIndex = m_possibleTypes.indexOf(m_currentType);
@@ -239,6 +270,8 @@ void QmlMaterialNodeProxy::updatePossibleTypeIndex()

 void QmlMaterialNodeProxy::updatePreviewModel()
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy update preview model", category()};
+
    if (!hasQuick3DImport())
        return;

@@ -275,6 +308,8 @@ void QmlMaterialNodeProxy::updatePreviewModel()

 void QmlMaterialNodeProxy::setMaterialNode(const QmlObjectNode &material)
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy set material node", category()};
+
    if (material == m_materialNode)
        return;

@@ -284,16 +319,22 @@ void QmlMaterialNodeProxy::setMaterialNode(const QmlObjectNode &material)

 void QmlMaterialNodeProxy::setEditorNodes(const ModelNodes &editorNodes)
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy set editor nodes", category()};
+
    m_editorNodes = editorNodes;
 }

 bool QmlMaterialNodeProxy::hasQuick3DImport() const
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy has quick3d import", category()};
+
    return materialNode().isValid() && materialNode().model()->hasImport("QtQuick3D"_L1);
 }

 AbstractView *QmlMaterialNodeProxy::materialView() const
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy material view", category()};
+
    return materialNode().view();
 }

--- a/src/plugins/qmldesigner/components/propertyeditor/qmlmodelnodeproxy.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/qmlmodelnodeproxy.cpp
@@ -1,8 +1,9 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

-#include "abstractview.h"
 #include "qmlmodelnodeproxy.h"
+#include "abstractview.h"
+#include "propertyeditortracing.h"

 #include <nodemetainfo.h>

@@ -17,18 +18,25 @@

 namespace QmlDesigner {

+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 QmlModelNodeProxy::QmlModelNodeProxy(QObject *parent) :
    QObject(parent)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy constructor", category()};
 }

 void QmlModelNodeProxy::setup(const ModelNode &node)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy setup", category()};
+
    setup(ModelNodes{node});
 }

 void QmlModelNodeProxy::setup(const ModelNodes &editorNodes)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy setup with editor nodes", category()};
+
    m_qmlObjectNode = editorNodes.isEmpty() ? ModelNode{} : editorNodes.first();
    m_editorNodes = editorNodes;

@@ -39,11 +47,15 @@ void QmlModelNodeProxy::setup(const ModelNodes &editorNodes)

 void QmlModelNodeProxy::registerDeclarativeType()
 {
-    qmlRegisterType<QmlModelNodeProxy>("HelperWidgets",2,0,"ModelNodeProxy");
+    NanotraceHR::Tracer tracer{"qml model node proxy register declarative type", category()};
+
+    qmlRegisterType<QmlModelNodeProxy>("HelperWidgets", 2, 0, "ModelNodeProxy");
 }

 void QmlModelNodeProxy::emitSelectionToBeChanged()
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy emit selection to be changed", category()};
+
    emit selectionToBeChanged();
 }

@@ -54,16 +66,22 @@ void QmlModelNodeProxy::emitSelectionChanged()

 void QmlModelNodeProxy::refresh()
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy refresh", category()};
+
    emit refreshRequired();
 }

 QmlObjectNode QmlModelNodeProxy::qmlObjectNode() const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy qml object node", category()};
+
    return m_qmlObjectNode;
 }

 ModelNode QmlModelNodeProxy::modelNode() const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy model node", category()};
+
    return m_qmlObjectNode.modelNode();
 }

@@ -74,11 +92,15 @@ ModelNodes QmlModelNodeProxy::editorNodes() const

 ModelNode QmlModelNodeProxy::singleSelectedNode() const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy single selected node", category()};
+
    return multiSelection() ? ModelNode{} : modelNode();
 }

 bool QmlModelNodeProxy::multiSelection() const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy multi selection", category()};
+
    if (!m_qmlObjectNode.isValid())
        return false;

@@ -87,6 +109,8 @@ bool QmlModelNodeProxy::multiSelection() const

 QString QmlModelNodeProxy::nodeId() const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy node id", category()};
+
    if (!m_qmlObjectNode.isValid())
        return {};

@@ -98,6 +122,8 @@ QString QmlModelNodeProxy::nodeId() const

 QString QmlModelNodeProxy::nodeObjectName() const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy node object name", category()};
+
    if (!m_qmlObjectNode.isValid())
        return {};

@@ -109,6 +135,8 @@ QString QmlModelNodeProxy::nodeObjectName() const

 QString QmlModelNodeProxy::simplifiedTypeName() const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy simplified type name", category()};
+
    if (!m_qmlObjectNode.isValid())
        return {};

@@ -125,6 +153,8 @@ static QList<int> toInternalIdList(const QList<ModelNode> &nodes)

 QList<int> QmlModelNodeProxy::allChildren(int internalId) const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy all children", category()};
+
    ModelNode modelNode = m_qmlObjectNode.modelNode();

    QTC_ASSERT(modelNode.isValid(), return {});
@@ -137,6 +167,8 @@ QList<int> QmlModelNodeProxy::allChildren(int internalId) const

 QList<int> QmlModelNodeProxy::allChildrenOfType(const QString &typeName, int internalId) const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy all children of type", category()};
+
    ModelNode modelNode = m_qmlObjectNode.modelNode();

    QTC_ASSERT(modelNode.isValid(), return {});
@@ -149,6 +181,8 @@ QList<int> QmlModelNodeProxy::allChildrenOfType(const QString &typeName, int int

 QString QmlModelNodeProxy::simplifiedTypeName(int internalId) const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy simplified type name", category()};
+
    ModelNode modelNode = m_qmlObjectNode.modelNode();

    QTC_ASSERT(modelNode.isValid(), return {});
@@ -158,6 +192,8 @@ QString QmlModelNodeProxy::simplifiedTypeName(int internalId) const

 PropertyEditorSubSelectionWrapper *QmlModelNodeProxy::findWrapper(int internalId) const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy find wrapper", category()};
+
    for (const auto &item : qAsConst(m_subselection)) {
        if (item->modelNode().internalId() == internalId)
            return item.data();
@@ -168,6 +204,8 @@ PropertyEditorSubSelectionWrapper *QmlModelNodeProxy::findWrapper(int internalId

 PropertyEditorSubSelectionWrapper *QmlModelNodeProxy::registerSubSelectionWrapper(int internalId)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy register sub selection wrapper", category()};
+
    auto result = findWrapper(internalId);

    if (result)
@@ -193,6 +231,8 @@ void QmlModelNodeProxy::createModelNode(int internalIdParent,
                                        const QString &typeName,
                                        const QString &requiredImport)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy create model node", category()};
+
    auto parentModelNode = m_qmlObjectNode.modelNode();

    QTC_ASSERT(parentModelNode.isValid(), return );
@@ -231,6 +271,8 @@ void QmlModelNodeProxy::moveNode(int internalIdParent,
                                 int fromIndex,
                                 int toIndex)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy move node", category()};
+
    ModelNode modelNode = m_qmlObjectNode.modelNode();

    QTC_ASSERT(modelNode.isValid(), return );
@@ -247,6 +289,8 @@ void QmlModelNodeProxy::moveNode(int internalIdParent,

 bool QmlModelNodeProxy::isInstanceOf(const QString &typeName, int internalId) const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy is instance of", category()};
+
    ModelNode modelNode = m_qmlObjectNode.modelNode();

    QTC_ASSERT(modelNode.isValid(), return {});
@@ -261,6 +305,8 @@ bool QmlModelNodeProxy::isInstanceOf(const QString &typeName, int internalId) co

 void QmlModelNodeProxy::changeType(int internalId, const QString &typeName)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy change type", category()};
+
    QTC_ASSERT(m_qmlObjectNode.isValid(), return );

    ModelNode node = m_qmlObjectNode.view()->modelNodeForInternalId(internalId);
@@ -279,6 +325,8 @@ void QmlModelNodeProxy::changeType(int internalId, const QString &typeName)
 void QmlModelNodeProxy::handleInstancePropertyChanged(const ModelNode &modelNode,
                                                      PropertyNameView propertyName)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy handle instance property changed", category()};
+
    const QmlObjectNode qmlObjectNode(modelNode);

    for (const auto &item : qAsConst(m_subselection)) {
@@ -295,6 +343,8 @@ void QmlModelNodeProxy::handleInstancePropertyChanged(const ModelNode &modelNode

 void QmlModelNodeProxy::handleBindingPropertyChanged(const BindingProperty &property)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy handle binding property changed", category()};
+
    for (const auto &item : qAsConst(m_subselection)) {
        if (item && item->isRelevantModelNode(property.parentModelNode())) {
            QmlObjectNode objectNode(item->modelNode());
@@ -308,6 +358,8 @@ void QmlModelNodeProxy::handleBindingPropertyChanged(const BindingProperty &prop

 void QmlModelNodeProxy::handleVariantPropertyChanged(const VariantProperty &property)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy handle variant property changed", category()};
+
    for (const auto &item : qAsConst(m_subselection)) {
        if (item && item->isRelevantModelNode(property.parentModelNode())) {
            QmlObjectNode objectNode(item->modelNode());
@@ -321,6 +373,8 @@ void QmlModelNodeProxy::handleVariantPropertyChanged(const VariantProperty &prop

 void QmlModelNodeProxy::handlePropertiesRemoved(const AbstractProperty &property)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy handle properties removed", category()};
+
    for (const auto &item : qAsConst(m_subselection)) {
        if (item && item->isRelevantModelNode(property.parentModelNode())) {
            QmlObjectNode objectNode(item->modelNode());
@@ -332,11 +386,15 @@ void QmlModelNodeProxy::handlePropertiesRemoved(const AbstractProperty &property

 QList<int> QmlModelNodeProxy::allChildren(const ModelNode &modelNode) const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy all children", category()};
+
    return toInternalIdList(modelNode.directSubModelNodes());
 }

 QList<int> QmlModelNodeProxy::allChildrenOfType(const ModelNode &modelNode, const QString &typeName) const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy all children of type", category()};
+
    QTC_ASSERT(modelNode.isValid(), return {});

    NodeMetaInfo metaInfo = modelNode.model()->metaInfo(typeName.toUtf8());
--- a/src/plugins/qmldesigner/components/propertyeditor/qmltexturenodeproxy.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/qmltexturenodeproxy.cpp
@@ -3,6 +3,8 @@

 #include "qmltexturenodeproxy.h"

+#include "propertyeditortracing.h"
+
 #include <abstractview.h>
 #include <createtexture.h>
 #include <designmodewidget.h>
@@ -13,14 +15,24 @@

 namespace QmlDesigner {

+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 using namespace Qt::StringLiterals;

-QmlTextureNodeProxy::QmlTextureNodeProxy() = default;
+QmlTextureNodeProxy::QmlTextureNodeProxy()
+{
+    NanotraceHR::Tracer tracer{"qml texture node proxy constructor", category()};
+}

-QmlTextureNodeProxy::~QmlTextureNodeProxy() = default;
+QmlTextureNodeProxy::~QmlTextureNodeProxy()
+{
+    NanotraceHR::Tracer tracer{"qml texture node proxy destructor", category()};
+}

 void QmlTextureNodeProxy::setup(const QmlObjectNode &objectNode)
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy setup", category()};
+
    const QmlObjectNode texture = objectNode.metaInfo().isQtQuick3DTexture() ? objectNode
                                                                             : QmlObjectNode{};

@@ -30,6 +42,8 @@ void QmlTextureNodeProxy::setup(const QmlObjectNode &objectNode)

 void QmlTextureNodeProxy::updateSelectionDetails()
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy update selection details", category()};
+
    QScopeGuard falseSetter{
        std::bind_front(&QmlTextureNodeProxy::setSelectedNodeAcceptsMaterial, this, false)};

@@ -46,6 +60,8 @@ void QmlTextureNodeProxy::updateSelectionDetails()

 void QmlTextureNodeProxy::handlePropertyChanged(const AbstractProperty &property)
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy handle property changed", category()};
+
    if (!textureNode())
        return;

@@ -65,31 +81,43 @@ void QmlTextureNodeProxy::handlePropertyChanged(const AbstractProperty &property

 void QmlTextureNodeProxy::handleBindingPropertyChanged(const BindingProperty &property)
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy handle binding property changed", category()};
+
    handlePropertyChanged(property);
 }

 void QmlTextureNodeProxy::handlePropertiesRemoved(const AbstractProperty &property)
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy handle properties removed", category()};
+
    handlePropertyChanged(property);
 }

 QmlObjectNode QmlTextureNodeProxy::textureNode() const
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy texture node", category()};
+
    return m_textureNode;
 }

 bool QmlTextureNodeProxy::hasTexture() const
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy has texture", category()};
+
    return textureNode().isValid();
 }

 bool QmlTextureNodeProxy::selectedNodeAcceptsMaterial() const
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy selected node accepts material", category()};
+
    return m_selectedNodeAcceptsMaterial;
 }

 QString QmlTextureNodeProxy::resolveResourcePath(const QString &path) const
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy resolve resource path", category()};
+
    if (path.isEmpty())
        return ":/propertyeditor/images/texture_default.png";

@@ -108,6 +136,8 @@ QString QmlTextureNodeProxy::resolveResourcePath(const QString &path) const

 void QmlTextureNodeProxy::toolbarAction(int action)
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy toolbar action", category()};
+
    if (!hasQuick3DImport())
        return;

@@ -146,11 +176,15 @@ void QmlTextureNodeProxy::toolbarAction(int action)

 void QmlTextureNodeProxy::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy register declarative type", category()};
+
    qmlRegisterType<QmlTextureNodeProxy>("HelperWidgets", 2, 0, "QmlTextureNodeProxy");
 }

 void QmlTextureNodeProxy::setTextureNode(const QmlObjectNode &node)
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy set texture node", category()};
+
    if (m_textureNode == node)
        return;
    m_textureNode = node;
@@ -159,6 +193,9 @@ void QmlTextureNodeProxy::setTextureNode(const QmlObjectNode &node)

 void QmlTextureNodeProxy::setSelectedNodeAcceptsMaterial(bool value)
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy set selected node accepts material",
+                               category()};
+
    if (m_selectedNodeAcceptsMaterial == value)
        return;
    m_selectedNodeAcceptsMaterial = value;
@@ -167,6 +204,8 @@ void QmlTextureNodeProxy::setSelectedNodeAcceptsMaterial(bool value)

 bool QmlTextureNodeProxy::hasQuick3DImport() const
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy has quick3d import", category()};
+
    return textureNode().isValid() && textureNode().model()->hasImport("QtQuick3D"_L1);
 }

--- a/src/plugins/qmldesigner/components/propertyeditor/quick2propertyeditorview.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/quick2propertyeditorview.cpp
@@ -3,14 +3,7 @@

 #include "quick2propertyeditorview.h"

-#include <qmldesignerconstants.h>
-#include <scripteditorbackend.h>
-
 #include "aligndistribute.h"
-#include "annotationeditor/annotationeditor.h"
-#include "assetimageprovider.h"
-#include "bindingeditor/actioneditor.h"
-#include "bindingeditor/bindingeditor.h"
 #include "colorpalettebackend.h"
 #include "fileresourcesmodel.h"
 #include "fontresourcesmodel.h"
@@ -22,23 +15,37 @@
 #include "listvalidator.h"
 #include "propertychangesmodel.h"
 #include "propertyeditorcontextobject.h"
+#include "propertyeditordynamicpropertiesproxymodel.h"
 #include "propertyeditorqmlbackend.h"
+#include "propertyeditortracing.h"
 #include "propertyeditorvalue.h"
 #include "propertymodel.h"
 #include "propertynamevalidator.h"
 #include "qmlanchorbindingproxy.h"
 #include "qmlmaterialnodeproxy.h"
 #include "qmltexturenodeproxy.h"
-#include "richtexteditor/richtexteditorproxy.h"
-#include "propertyeditordynamicpropertiesproxymodel.h"
-#include "theme.h"
 #include "tooltip.h"

+#include <qmldesignerconstants.h>
+#include <scripteditorbackend.h>
+
+#include <annotationeditor/annotationeditor.h>
+#include <assetimageprovider.h>
+#include <bindingeditor/actioneditor.h>
+#include <bindingeditor/bindingeditor.h>
+
+#include <richtexteditor/richtexteditorproxy.h>
+#include <theme.h>
+
 namespace QmlDesigner {

+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 Quick2PropertyEditorView::Quick2PropertyEditorView(AsynchronousImageCache &imageCache)
    : QQuickWidget()
 {
+    NanotraceHR::Tracer tracer{"quick2 property editor view constructor", category()};
+
    setObjectName(Constants::OBJECT_NAME_PROPERTY_EDITOR);
    setResizeMode(QQuickWidget::SizeRootObjectToView);
    Theme::setupTheme(engine());
--- a/src/plugins/qmldesigner/components/propertyeditor/tooltip.cpp
+++ b/src/plugins/qmldesigner/components/propertyeditor/tooltip.cpp
@@ -2,18 +2,27 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

 #include "tooltip.h"
+
+#include "propertyeditortracing.h"
+
 #include <qquickwindow.h>
 #include <qquickitem.h>
 #include <QtQuick/QQuickRenderControl>
 #include <QtWidgets/qtwidgetsglobal.h>
 #include <qtooltip.h>

+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 Tooltip::Tooltip(QObject *parent)
    : QObject(parent)
-{}
+{
+    NanotraceHR::Tracer tracer{"tooltip constructor", category()};
+}

 void Tooltip::showText(QQuickItem *item, const QPointF &pos, const QString &str)
 {
+    NanotraceHR::Tracer tracer{"tooltip show text", category()};
+
    if (!item || !item->window())
        return;

@@ -29,11 +38,15 @@ void Tooltip::showText(QQuickItem *item, const QPointF &pos, const QString &str)

 void Tooltip::hideText()
 {
+    NanotraceHR::Tracer tracer{"tooltip hide text", category()};
+
    QToolTip::hideText();
 }

 void Tooltip::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"tooltip register declarative type", category()};
+
    qmlRegisterType<Tooltip>("StudioControls", 1, 0, "ToolTipExt");
    qmlRegisterType<Tooltip>("HelperWidgets", 2, 0, "Tooltip");
 }
--- a/src/plugins/qmldesigner/libs/designercore/CMakeLists.txt
+++ b/src/plugins/qmldesigner/libs/designercore/CMakeLists.txt
@@ -49,7 +49,7 @@ extend_qtc_library(QmlDesignerCore
 )

 extend_qtc_library(QmlDesignerCore
-  CONDITION ENABLE_PROJECT_STORAGE_TRACING OR ENABLE_SOURCE_PATH_STORAGE_TRACING OR ENABLE_IMAGE_CACHE_TRACING OR ENABLE_MODEL_TRACING OR ENABLE_FORM_EDITOR_TRACING
+  CONDITION ENABLE_PROJECT_STORAGE_TRACING OR ENABLE_SOURCE_PATH_STORAGE_TRACING OR ENABLE_IMAGE_CACHE_TRACING OR ENABLE_MODEL_TRACING OR ENABLE_FORM_EDITOR_TRACING OR ENABLE_PROPERTY_EDITOR_TRACING
  PUBLIC_DEPENDS Nanotrace
  PUBLIC_DEFINES
    ENABLE_QMLDESIGNER_TRACING