diff --git a/src/plugins/qmldesigner/qmltools/qml3dnode.cpp b/src/plugins/qmldesigner/qmltools/qml3dnode.cpp
index f372a906e75..473f22d99ff 100644
--- a/src/plugins/qmldesigner/qmltools/qml3dnode.cpp
+++ b/src/plugins/qmldesigner/qmltools/qml3dnode.cpp
@@ -14,24 +14,45 @@
 
 namespace QmlDesigner {
 
-bool Qml3DNode::isValid() const
+static auto category = ModelTracing::category;
+
+bool Qml3DNode::isValid(SL sl) const
 {
-    return isValidQml3DNode(modelNode());
+    return isValidQml3DNode(modelNode(), sl);
 }
 
-bool Qml3DNode::isValidQml3DNode(const ModelNode &modelNode)
+bool Qml3DNode::isValidQml3DNode(const ModelNode &modelNode, SL sl)
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml 3d node is valid Qml 3D node",
+                               category(),
+                               keyValue("model node", modelNode),
+                               keyValue("caller location", sl)};
+
     return isValidQmlObjectNode(modelNode) && (modelNode.metaInfo().isQtQuick3DNode());
 }
 
-bool Qml3DNode::isValidVisualRoot(const ModelNode &modelNode)
+bool Qml3DNode::isValidVisualRoot(const ModelNode &modelNode, SL sl)
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml 3d node is valid visual root",
+                               category(),
+                               keyValue("model node", modelNode),
+                               keyValue("caller location", sl)};
+
     return isValidQmlObjectNode(modelNode)
            && (modelNode.metaInfo().isQtQuick3DNode() || modelNode.metaInfo().isQtQuick3DMaterial());
 }
 
-bool Qml3DNode::handleEulerRotation(PropertyNameView name)
+bool Qml3DNode::handleEulerRotation(PropertyNameView name, SL sl)
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"1ml 3d node handle euler rotation",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("property name", name),
+                               keyValue("caller location", sl)};
+
     if (isBlocked(name))
         return false;
 
@@ -41,8 +62,15 @@ bool Qml3DNode::handleEulerRotation(PropertyNameView name)
     return true;
 }
 
-bool Qml3DNode::isBlocked(PropertyNameView propName) const
+bool Qml3DNode::isBlocked(PropertyNameView propName, SL sl) const
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml 3d node is blocked",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("property name", propName),
+                               keyValue("caller location", sl)};
+
     if (modelNode().isValid() && propName.startsWith("eulerRotation"))
         return modelNode().auxiliaryDataWithDefault(rotBlockProperty).toBool();
 
@@ -335,8 +363,14 @@ static bool transformHasScalingAndRotation(const QMatrix4x4 &transform)
     return !hasUniformScale && hasRotation;
 }
 
-bool Qml3DNode::hasAnimatedTransform()
+bool Qml3DNode::hasAnimatedTransform(SL sl)
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml 3d node has animated transform",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("caller location", sl)};
+
     QmlTimeline timeline = currentTimeline();
     if (!timeline)
         return false;
@@ -416,8 +450,14 @@ void Qml3DNode::setLocalTransform(const QMatrix4x4 &newParentSceneTransform,
     setProp("eulerRotation.z", eulerRotation.z(), 0.f);
 }
 
-void Qml3DNode::reparentWithTransform(NodeAbstractProperty &parentProperty)
+void Qml3DNode::reparentWithTransform(NodeAbstractProperty &parentProperty, SL sl)
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml 3d node reparent with transform",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("caller location", sl)};
+
     Qml3DNode oldParent3d;
     if (modelNode().hasParentProperty())
         oldParent3d = modelNode().parentProperty().parentModelNode();
diff --git a/src/plugins/qmldesigner/qmltools/qml3dnode.h b/src/plugins/qmldesigner/qmltools/qml3dnode.h
index 62d17d54750..567306bb8ec 100644
--- a/src/plugins/qmldesigner/qmltools/qml3dnode.h
+++ b/src/plugins/qmldesigner/qmltools/qml3dnode.h
@@ -19,18 +19,25 @@ class QMLDESIGNER_EXPORT Qml3DNode : public QmlVisualNode
 {
     friend class QmlAnchors;
 public:
-    Qml3DNode() : QmlVisualNode() {}
-    Qml3DNode(const ModelNode &modelNode)  : QmlVisualNode(modelNode) {}
-    bool isValid() const;
+    Qml3DNode()
+        : QmlVisualNode()
+    {}
+
+    Qml3DNode(const ModelNode &modelNode)
+        : QmlVisualNode(modelNode)
+    {}
+
+    bool isValid(SL sl = {}) const;
     explicit operator bool() const { return isValid(); }
-    static bool isValidQml3DNode(const ModelNode &modelNode);
-    static bool isValidVisualRoot(const ModelNode &modelNode);
 
-    bool handleEulerRotation(PropertyNameView name);
-    bool isBlocked(PropertyNameView propName) const;
+    static bool isValidQml3DNode(const ModelNode &modelNode, SL sl = {});
+    static bool isValidVisualRoot(const ModelNode &modelNode, SL sl = {});
 
-    void reparentWithTransform(NodeAbstractProperty &parentProperty);
-    bool hasAnimatedTransform();
+    bool handleEulerRotation(PropertyNameView name, SL sl = {});
+    bool isBlocked(PropertyNameView propName, SL sl = {}) const;
+
+    void reparentWithTransform(NodeAbstractProperty &parentProperty, SL sl = {});
+    bool hasAnimatedTransform(SL sl = {});
 
     friend auto qHash(const Qml3DNode &node) { return qHash(node.modelNode()); }
 
@@ -43,7 +50,9 @@ private:
                            bool adjustScale);
 };
 
-QMLDESIGNER_EXPORT QList<ModelNode> toModelNodeList(const QList<Qml3DNode> &fxItemNodeList);
-QMLDESIGNER_EXPORT QList<Qml3DNode> toQml3DNodeList(const QList<ModelNode> &modelNodeList);
+QMLDESIGNER_EXPORT QList<ModelNode> toModelNodeList(const QList<Qml3DNode> &fxItemNodeList,
+                                                    ModelTracing::SourceLocation sl = {});
+QMLDESIGNER_EXPORT QList<Qml3DNode> toQml3DNodeList(const QList<ModelNode> &modelNodeList,
+                                                    ModelTracing::SourceLocation sl = {});
 
 } //QmlDesigner