From c5cd9c9124ac8821fb5d89e0a7695a999fcccb01 Mon Sep 17 00:00:00 2001
From: Roman Valovic <xvalovic@mendelu.cz>
Date: Mon, 12 Oct 2026 13:09:42 +0200
Subject: [PATCH 1/2] feat: migrate computed attributes with metrics

Legacy computed attributes (attr.comp.X + label.comp.X) are fetched in the
metrics step, translated to Cloud computedAttribute entities
(SELECT CASE WHEN SUM({metric/..}) .. END BY {label/..} ALL OTHER) and
deployed between plain metrics and metrics that reference them.
Metrics, insights and dashboards now reference them as
{computed_attribute/label.comp.X} / type "computedAttribute".

risk: low

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 README.md                                     |  11 ++
 .../backends/cloud/client.py                  |  22 ++++
 .../backends/cloud/object_creator_strategy.py |  30 +++++
 src/gooddata_legacy2cloud/constants.py        |   1 +
 .../dashboards/drill_converter.py             |   3 +-
 .../dashboards/filter_context.py              |  11 +-
 src/gooddata_legacy2cloud/helpers.py          |  18 +++
 src/gooddata_legacy2cloud/id_mappings.py      |   8 ++
 .../insights/cloud_insight.py                 |  11 +-
 .../metrics/computed_attribute.py             | 119 ++++++++++++++++++
 .../metrics/data_classes.py                   |   1 +
 .../metrics/maql/content_tree_modifier.py     |   9 +-
 src/gooddata_legacy2cloud/output_writer.py    |   3 +
 .../workflows/migrate_metrics.py              |  66 ++++++++--
 .../legacy_objects/objects_by_uri.json        |  45 +++++++
 .../with_computed_attribute_cloud.json        |  69 ++++++++++
 .../with_computed_attribute_legacy.json       |  63 ++++++++++
 .../legacy_objects/computed_attribute.json    |  56 +++++++++
 .../legacy_objects/objects_by_uri.json        |  20 +++
 .../metrics/mapping_files/metric_mappings.csv |   1 +
 .../test_cases/computed_attribute_cloud.json  |  19 +++
 .../with_computed_attribute_cloud.json        |  17 +++
 .../with_computed_attribute_legacy.json       |  63 ++++++++++
 .../with_unresolved_identifier_cloud.json     |   6 +-
 .../with_unresolved_identifier_legacy.json    |   4 +-
 .../shared/mapping_files/ldm_mappings.csv     |   1 +
 tests/test_computed_attributes.py             |  65 ++++++++++
 tests/test_insights.py                        |   1 +
 tests/test_metrics.py                         |   1 +
 29 files changed, 724 insertions(+), 20 deletions(-)
 create mode 100644 src/gooddata_legacy2cloud/metrics/computed_attribute.py
 create mode 100644 tests/data/insights/test_cases/with_computed_attribute_cloud.json
 create mode 100644 tests/data/insights/test_cases/with_computed_attribute_legacy.json
 create mode 100644 tests/data/metrics/legacy_objects/computed_attribute.json
 create mode 100644 tests/data/metrics/test_cases/computed_attribute_cloud.json
 create mode 100644 tests/data/metrics/test_cases/with_computed_attribute_cloud.json
 create mode 100644 tests/data/metrics/test_cases/with_computed_attribute_legacy.json
 create mode 100644 tests/test_computed_attributes.py

diff --git a/README.md b/README.md
index 04ea8ba..40b28bd 100644
--- a/README.md
+++ b/README.md
@@ -377,11 +377,22 @@ Script generates:
 - MAQL transformation log to `metrics_maql.log`
 - Failed Cloud metrics to `cloud_failed_metrics.json`
 - Skipped objects IDs to `cloud_skipped_metrics.json`
+- Computed attribute mappings to `computed_attribute_mappings.csv`
+- Failed / skipped computed attributes to `cloud_failed_computed_attributes.json` / `cloud_skipped_computed_attributes.json`
+- Computed attribute dumps to `legacy_computed_attributes.json` / `cloud_computed_attributes.json` (with `--dump-legacy` / `--dump-cloud`)
 
 Script reads:
 
 - LDM mappings from `ldm_mappings.csv`
 
+Computed attributes:
+
+- Legacy computed attributes (`attr.comp.X` + `label.comp.X`) are migrated together with metrics as Cloud computed attributes with ID `label.comp.X`. The Legacy `CASE WHEN` definition is translated to `SELECT CASE WHEN SUM({metric/...}) <= n THEN "bucket" ... END BY {label/...} ALL OTHER`.
+- Metrics, insights and dashboards reference them as `{computed_attribute/label.comp.X}` / `"type": "computedAttribute"`.
+- Deployment order is: metrics → computed attributes → metrics using computed attributes.
+- Requires the `enableComputedAttributes` feature flag in Cloud, on the parent workspace and on every child workspace that uses them (it is not inherited). Cloud computed attributes are in Beta: exports, date dimension and period-over-period are not supported with them.
+- Only one-metric, numeric-threshold definitions are supported; other definitions are logged as errors and skipped.
+
 Notes:
 
 - If any element values are missing within the Legacy metric, they are replaced with `--MISSING VALUE--`. Such metrics can be found in `metrics_maql.log` file and these metrics are also marked with [WARN] in their title (unless `--suppress-migration-warnings` is used). Warnings are always printed to console.
diff --git a/src/gooddata_legacy2cloud/backends/cloud/client.py b/src/gooddata_legacy2cloud/backends/cloud/client.py
index 5d49785..cc71f97 100644
--- a/src/gooddata_legacy2cloud/backends/cloud/client.py
+++ b/src/gooddata_legacy2cloud/backends/cloud/client.py
@@ -257,6 +257,28 @@ def update_metric(self, metric_id, metric):
         url = f"api/v1/entities/workspaces/{self.ws}/metrics/{metric_id}"
         return self._put(url, metric)
 
+    def get_computed_attributes(self, page=0, origin: str = "ALL"):
+        """Sends a GET request to the server to get all computed attributes."""
+        url = f"api/v1/entities/workspaces/{self.ws}/computedAttributes?origin={origin}&size={CLOUD_REQUEST_PAGE_SIZE}&page={page}"
+        try:
+            result = self._get(url)
+            data = result["data"]
+            if len(data) == CLOUD_REQUEST_PAGE_SIZE:
+                data.extend(self.get_computed_attributes(page + 1))
+            return data
+        except KeyError:
+            return []
+
+    def create_computed_attribute(self, computed_attribute):
+        """Post a computed attribute to the server."""
+        url = f"api/v1/entities/workspaces/{self.ws}/computedAttributes"
+        return self._post(url, computed_attribute)
+
+    def update_computed_attribute(self, computed_attribute_id, computed_attribute):
+        """Update a computed attribute on the server."""
+        url = f"api/v1/entities/workspaces/{self.ws}/computedAttributes/{computed_attribute_id}"
+        return self._put(url, computed_attribute)
+
     def remove_metric(self, metric_id):
         """Sends a DELETE request to the server."""
         url = f"api/v1/entities/workspaces/{self.ws}/metrics/{metric_id}"
diff --git a/src/gooddata_legacy2cloud/backends/cloud/object_creator_strategy.py b/src/gooddata_legacy2cloud/backends/cloud/object_creator_strategy.py
index 093fcb8..599f638 100644
--- a/src/gooddata_legacy2cloud/backends/cloud/object_creator_strategy.py
+++ b/src/gooddata_legacy2cloud/backends/cloud/object_creator_strategy.py
@@ -27,6 +27,8 @@
 CLOUD_FAILED_REPORTS_FILE = "cloud_failed_reports.json"
 CLOUD_FAILED_PP_DASHBOARDS_FILE = "cloud_failed_pp_dashboards.json"
 CLOUD_SKIPPED_METRICS_FILE = "cloud_skipped_metrics.json"
+CLOUD_FAILED_COMPUTED_ATTRIBUTES_FILE = "cloud_failed_computed_attributes.json"
+CLOUD_SKIPPED_COMPUTED_ATTRIBUTES_FILE = "cloud_skipped_computed_attributes.json"
 CLOUD_SKIPPED_INSIGHTS_FILE = "cloud_skipped_insights.json"
 CLOUD_SKIPPED_KPI_COMPARISON_INSIGHTS_FILE = (
     "cloud_skipped_kpi_comparison_insights.json"
@@ -147,6 +149,28 @@ def get_object_type(self) -> str:
         return "metric"
 
 
+class ComputedAttributeCreationStrategy(CreationStrategy):
+    """Strategy for creating computed attributes"""
+
+    def get_existing_objects(self) -> List[Dict]:
+        return self.cloud_client.get_computed_attributes()
+
+    def create_object(self, obj: T) -> Any:
+        return self.cloud_client.create_computed_attribute(obj)
+
+    def update_object(self, obj: T) -> Any:
+        return self.cloud_client.update_computed_attribute(obj["data"]["id"], obj)
+
+    def disable_object(self, obj: T, response: Response) -> Any:
+        return obj  # no placeholder for computed attributes
+
+    def get_object_link(self, domain: str, workspace_id: str, obj_id: str) -> str:
+        return f"{domain}/api/v1/entities/workspaces/{workspace_id}/computedAttributes/{obj_id}"
+
+    def get_object_type(self) -> str:
+        return "computed_attribute"
+
+
 class InsightCreationStrategy(CreationStrategy):
     """Strategy for creating insights"""
 
@@ -463,6 +487,12 @@ class ObjectConfig(TypedDict):
         "skipped_file": CLOUD_SKIPPED_METRICS_FILE,
         "log_file_mode": "w",
     },
+    "computed_attribute": {
+        "strategy_class": ComputedAttributeCreationStrategy,
+        "failed_file": CLOUD_FAILED_COMPUTED_ATTRIBUTES_FILE,
+        "skipped_file": CLOUD_SKIPPED_COMPUTED_ATTRIBUTES_FILE,
+        "log_file_mode": "w",
+    },
     "insight": {
         "strategy_class": InsightCreationStrategy,
         "failed_file": CLOUD_FAILED_INSIGHTS_FILE,
diff --git a/src/gooddata_legacy2cloud/constants.py b/src/gooddata_legacy2cloud/constants.py
index 0e5617b..8ed3d66 100644
--- a/src/gooddata_legacy2cloud/constants.py
+++ b/src/gooddata_legacy2cloud/constants.py
@@ -10,6 +10,7 @@
 
 LDM_MAPPING_FILE = "ldm_mappings.csv"
 METRIC_MAPPING_FILE = "metric_mappings.csv"
+COMPUTED_ATTRIBUTE_MAPPING_FILE = "computed_attribute_mappings.csv"
 INSIGHT_MAPPING_FILE = "insight_mappings.csv"
 DASHBOARD_MAPPING_FILE = "dashboard_mappings.csv"
 REPORT_MAPPING_FILE = "report_mappings.csv"
diff --git a/src/gooddata_legacy2cloud/dashboards/drill_converter.py b/src/gooddata_legacy2cloud/dashboards/drill_converter.py
index 84a779c..97a04e3 100644
--- a/src/gooddata_legacy2cloud/dashboards/drill_converter.py
+++ b/src/gooddata_legacy2cloud/dashboards/drill_converter.py
@@ -11,6 +11,7 @@
 from typing import Optional
 
 from gooddata_legacy2cloud.dashboards.data_classes import DashboardContext
+from gooddata_legacy2cloud.helpers import cloud_display_form_type
 
 logger = logging.getLogger("migration")
 
@@ -61,7 +62,7 @@ def _get_attribute_identifier(self, legacy_attribute_id: str) -> dict:
         return {
             "identifier": {
                 "id": cloud_id,
-                "type": "label",  # Most Legacy attributes map to Cloud labels
+                "type": cloud_display_form_type(legacy_attribute_id),
             }
         }
 
diff --git a/src/gooddata_legacy2cloud/dashboards/filter_context.py b/src/gooddata_legacy2cloud/dashboards/filter_context.py
index 752986f..a34345c 100644
--- a/src/gooddata_legacy2cloud/dashboards/filter_context.py
+++ b/src/gooddata_legacy2cloud/dashboards/filter_context.py
@@ -2,7 +2,7 @@
 import logging
 
 from gooddata_legacy2cloud.dashboards.data_classes import DashboardContext
-from gooddata_legacy2cloud.helpers import get_cloud_id
+from gooddata_legacy2cloud.helpers import cloud_display_form_type, get_cloud_id
 from gooddata_legacy2cloud.metrics.attribute_element import AttributeElement
 from gooddata_legacy2cloud.metrics.contants import DELETED_VALUE
 from gooddata_legacy2cloud.models.cloud.filter_context import (
@@ -28,13 +28,18 @@ def __init__(self, ctx: DashboardContext, filter_context_uri: str):
     @staticmethod
     def _transform_filter_type_value(obj: dict) -> str:
         filter_type = obj["attributeDisplayForm"]["meta"]["category"].lower()
-        filter_type = "label" if filter_type == "attributedisplayform" else filter_type
+        if filter_type == "attributedisplayform":
+            return cloud_display_form_type(
+                obj["attributeDisplayForm"]["meta"]["identifier"]
+            )
         return filter_type
 
     @staticmethod
     def _transform_attribute_type_value(obj: dict) -> str:
         attr_type = obj["attribute"]["meta"]["category"].lower()
-        return "label" if attr_type == "attribute" else attr_type
+        if attr_type == "attribute":
+            return cloud_display_form_type(obj["attribute"]["meta"]["identifier"])
+        return attr_type
 
     def _get_filter_attribute_elements(
         self, attribute_elements: list
diff --git a/src/gooddata_legacy2cloud/helpers.py b/src/gooddata_legacy2cloud/helpers.py
index 6c668e7..aa1c0a2 100644
--- a/src/gooddata_legacy2cloud/helpers.py
+++ b/src/gooddata_legacy2cloud/helpers.py
@@ -170,6 +170,24 @@ def resolve_kpi_description(legacy_client: LegacyClient, obj: dict[str, Any]) ->
     return metric_obj["metric"]["meta"].get("summary", "")
 
 
+COMPUTED_ATTRIBUTE_PREFIXES = ("attr.comp.", "label.comp.")
+
+
+def is_computed_attribute(legacy_identifier: str) -> bool:
+    """Legacy computed attributes always use the attr.comp./label.comp. prefix."""
+    return legacy_identifier.startswith(COMPUTED_ATTRIBUTE_PREFIXES)
+
+
+def computed_attribute_cloud_id(legacy_identifier: str) -> str:
+    """Cloud computed attribute id is the Legacy label id (label.comp.X)."""
+    return "label." + legacy_identifier.split(".", 1)[1]
+
+
+def cloud_display_form_type(legacy_identifier: str) -> str:
+    """Entity type Cloud expects for a Legacy display form reference."""
+    return "computedAttribute" if is_computed_attribute(legacy_identifier) else "label"
+
+
 def get_cloud_id(title: str, legacy_identifier: str) -> str:
     """
     Returns the Cloud metric identifier.
diff --git a/src/gooddata_legacy2cloud/id_mappings.py b/src/gooddata_legacy2cloud/id_mappings.py
index aacaa06..184dc1f 100644
--- a/src/gooddata_legacy2cloud/id_mappings.py
+++ b/src/gooddata_legacy2cloud/id_mappings.py
@@ -8,6 +8,11 @@
 import logging
 import os
 
+from gooddata_legacy2cloud.helpers import (
+    computed_attribute_cloud_id,
+    is_computed_attribute,
+)
+
 logger = logging.getLogger("migration")
 
 
@@ -71,6 +76,9 @@ def search_mapping_identifier(self, legacy_identifier):
         if legacy_identifier in self.id_mapping:
             return self.id_mapping[legacy_identifier]
 
+        if is_computed_attribute(legacy_identifier):
+            return computed_attribute_cloud_id(legacy_identifier)
+
         raise ValueError(
             f"Search Cloud Id - Unknown Legacy identifier {legacy_identifier}"
         )
diff --git a/src/gooddata_legacy2cloud/insights/cloud_insight.py b/src/gooddata_legacy2cloud/insights/cloud_insight.py
index 654fa04..e884144 100644
--- a/src/gooddata_legacy2cloud/insights/cloud_insight.py
+++ b/src/gooddata_legacy2cloud/insights/cloud_insight.py
@@ -8,7 +8,11 @@
 import logging
 import uuid
 
-from gooddata_legacy2cloud.helpers import get_cloud_id, parse_legacy_tags
+from gooddata_legacy2cloud.helpers import (
+    cloud_display_form_type,
+    get_cloud_id,
+    parse_legacy_tags,
+)
 from gooddata_legacy2cloud.id_mappings import IdMappings
 from gooddata_legacy2cloud.insights.data_classes import InsightContext
 from gooddata_legacy2cloud.insights.period_comparison_insight import (
@@ -141,7 +145,10 @@ def _transform_identifier_in_date_filter(self, filter: dict, filter_name: str):
     @staticmethod
     def _transform_filter_type_value(obj: dict) -> str:
         filter_type = obj["attributeDisplayForm"]["meta"]["category"].lower()
-        filter_type = "label" if filter_type == "attributedisplayform" else filter_type
+        if filter_type == "attributedisplayform":
+            return cloud_display_form_type(
+                obj["attributeDisplayForm"]["meta"]["identifier"]
+            )
         return filter_type
 
     def _process_cyclical_date_filter(
diff --git a/src/gooddata_legacy2cloud/metrics/computed_attribute.py b/src/gooddata_legacy2cloud/metrics/computed_attribute.py
new file mode 100644
index 0000000..122d1ca
--- /dev/null
+++ b/src/gooddata_legacy2cloud/metrics/computed_attribute.py
@@ -0,0 +1,119 @@
+# (C) 2026 GoodData Corporation
+"""
+Transforms Legacy computed attributes (attr.comp.X + label.comp.X) into Cloud
+computed attribute entities defined by a MAQL CASE expression.
+"""
+
+import logging
+import re
+
+from gooddata_legacy2cloud.backends.legacy.client import LegacyClient
+from gooddata_legacy2cloud.helpers import (
+    computed_attribute_cloud_id,
+    is_computed_attribute,
+    parse_legacy_tags,
+)
+from gooddata_legacy2cloud.metrics.data_classes import MetricContext
+
+logger = logging.getLogger("migration")
+
+_WHEN = (
+    r"when \{(?P<metric>[^}]+)\} (?P<op><=|<|>=|>|=) (?P<value>-?\d+(?:\.\d+)?) "
+    r'then \{[^?}]+\?"(?P<label>[^"]*)"\}'
+)
+_ELSE = r'else \{[^?}]+\?"(?P<else_label>[^"]*)"\}'
+# ponytail: strict grammar covering every CA seen so far (single metric,
+# numeric thresholds, literal labels); extend when a real CA does not match
+_REL = re.compile(
+    rf"^to \{{(?P<base>[^}}]+)\}} as case (?P<whens>(?:{_WHEN}(?:, )?)+) ?(?:{_ELSE})? ?end$",
+    re.S,
+)
+_WHEN_RE = re.compile(_WHEN)
+_ELSE_RE = re.compile(_ELSE)
+
+
+def fetch_legacy_computed_attributes(legacy_client: LegacyClient) -> list[dict]:
+    """Returns full Legacy attribute objects of all computed attributes."""
+    entries = legacy_client.get_attributes()["query"]["entries"]
+    return [
+        legacy_client.get_object(entry["link"])
+        for entry in entries
+        if is_computed_attribute(entry.get("identifier", ""))
+    ]
+
+
+def build_cloud_computed_attribute(ctx: MetricContext, attribute: dict) -> dict:
+    """
+    Builds a Cloud computed attribute entity from a Legacy attribute object.
+
+    Args:
+        ctx: Metric context with ldm and metric mappings.
+        attribute: Legacy attribute object (``{"attribute": {...}}``).
+
+    Returns:
+        Cloud entity payload for POST /computedAttributes.
+
+    Raises:
+        ValueError: If the Legacy definition does not match the supported grammar
+            or references unknown objects.
+    """
+    meta = attribute["attribute"]["meta"]
+    relations = attribute["attribute"]["content"].get("rel", [])
+    if len(relations) != 1:
+        raise ValueError(f"Expected exactly one relation, got {len(relations)}")
+
+    match = _REL.match(relations[0].strip())
+    if not match:
+        raise ValueError(f"Unsupported computed attribute definition: {relations[0]}")
+
+    if ctx.metric_mappings is None:
+        raise ValueError("Metric mappings are required for computed attributes")
+
+    branches = []
+    for when in _WHEN_RE.finditer(match["whens"]):
+        metric_id = ctx.metric_mappings.search_mapping_identifier(when["metric"])
+        branches.append(
+            f"WHEN SUM({{metric/{metric_id}}}) {when['op']} {when['value']} "
+            f'THEN "{when["label"]}"'
+        )
+    else_match = _ELSE_RE.search(relations[0])
+    if else_match:
+        branches.append(f'ELSE "{else_match["else_label"]}"')
+
+    base_id = ctx.ldm_mappings.search_mapping_identifier(match["base"])
+    maql = (
+        "SELECT CASE " + " ".join(branches) + f" END BY {{label/{base_id}}} ALL OTHER"
+    )
+
+    return {
+        "data": {
+            "type": "computedAttribute",
+            "id": computed_attribute_cloud_id(meta["identifier"]),
+            "attributes": {
+                "title": meta["title"],
+                "description": meta.get("summary", ""),
+                "tags": parse_legacy_tags(meta),
+                "dataType": "STRING",
+                "content": {"maql": maql},
+            },
+        }
+    }
+
+
+def build_cloud_computed_attributes(
+    ctx: MetricContext, attributes: list[dict]
+) -> list[dict]:
+    """Builds all computed attributes, logging and skipping the invalid ones."""
+    result = []
+    for attribute in attributes:
+        meta = attribute["attribute"]["meta"]
+        try:
+            result.append(build_cloud_computed_attribute(ctx, attribute))
+        except ValueError as exc:
+            logger.error(
+                "Computed attribute '%s' (%s) cannot be migrated: %s",
+                meta["title"],
+                meta["identifier"],
+                exc,
+            )
+    return result
diff --git a/src/gooddata_legacy2cloud/metrics/data_classes.py b/src/gooddata_legacy2cloud/metrics/data_classes.py
index 136fc67..87d840c 100644
--- a/src/gooddata_legacy2cloud/metrics/data_classes.py
+++ b/src/gooddata_legacy2cloud/metrics/data_classes.py
@@ -20,3 +20,4 @@ class MetricContext:
         default=False
     )  # suppress migration warnings from objects
     client_prefix: str | None = field(default=None)
+    metric_mappings: IdMappings | None = field(default=None)
diff --git a/src/gooddata_legacy2cloud/metrics/maql/content_tree_modifier.py b/src/gooddata_legacy2cloud/metrics/maql/content_tree_modifier.py
index 808dd38..5f0ea01 100644
--- a/src/gooddata_legacy2cloud/metrics/maql/content_tree_modifier.py
+++ b/src/gooddata_legacy2cloud/metrics/maql/content_tree_modifier.py
@@ -2,7 +2,7 @@
 import logging
 
 from gooddata_legacy2cloud.constants import TIME_MACROS
-from gooddata_legacy2cloud.helpers import get_cloud_id
+from gooddata_legacy2cloud.helpers import get_cloud_id, is_computed_attribute
 from gooddata_legacy2cloud.metrics.attribute_element import AttributeElement
 from gooddata_legacy2cloud.metrics.contants import DELETED_VALUE, MISSING_VALUE
 from gooddata_legacy2cloud.metrics.data_classes import MetricContext
@@ -302,9 +302,12 @@ def _get_uri_to_object_map(self, dependent_objects: list):
                             "parent": object_item["parent"],
                         }
                     else:
+                        attribute_id = obj["attribute"]["meta"]["identifier"]
                         objects_map[key] = {
-                            "id": obj["attribute"]["meta"]["identifier"],
-                            "type": "label",
+                            "id": attribute_id,
+                            "type": "computed_attribute"
+                            if is_computed_attribute(attribute_id)
+                            else "label",
                             "parent": object_item["parent"],
                         }
                 elif "metric" in obj:
diff --git a/src/gooddata_legacy2cloud/output_writer.py b/src/gooddata_legacy2cloud/output_writer.py
index 10a04e0..3941367 100644
--- a/src/gooddata_legacy2cloud/output_writer.py
+++ b/src/gooddata_legacy2cloud/output_writer.py
@@ -9,6 +9,7 @@
 import logging
 
 from gooddata_legacy2cloud.backends.cloud.object_creator_strategy import (
+    CLOUD_SKIPPED_COMPUTED_ATTRIBUTES_FILE,
     CLOUD_SKIPPED_DASHBOARDS_FILE,
     CLOUD_SKIPPED_INSIGHTS_FILE,
     CLOUD_SKIPPED_METRICS_FILE,
@@ -164,6 +165,8 @@ def write_skipped_objects(self, skipped_objects, object_type):
             filename = CLOUD_SKIPPED_DASHBOARDS_FILE
         elif object_type == "report":
             filename = CLOUD_SKIPPED_REPORTS_FILE
+        elif object_type == "computed_attribute":
+            filename = CLOUD_SKIPPED_COMPUTED_ATTRIBUTES_FILE
         else:
             raise ValueError(f"Unsupported object type: {object_type}")
 
diff --git a/src/gooddata_legacy2cloud/workflows/migrate_metrics.py b/src/gooddata_legacy2cloud/workflows/migrate_metrics.py
index 78d78a0..6a793fa 100644
--- a/src/gooddata_legacy2cloud/workflows/migrate_metrics.py
+++ b/src/gooddata_legacy2cloud/workflows/migrate_metrics.py
@@ -17,6 +17,7 @@
 from gooddata_legacy2cloud.backends.legacy.objects import fetch_objects_with_filters
 from gooddata_legacy2cloud.config.configuration_objects import MetricConfig
 from gooddata_legacy2cloud.config.env_vars import EnvVars
+from gooddata_legacy2cloud.constants import COMPUTED_ATTRIBUTE_MAPPING_FILE
 from gooddata_legacy2cloud.helpers import (
     duration,
     prefix_filename,
@@ -33,6 +34,10 @@
     get_mapping_files,
 )
 from gooddata_legacy2cloud.metrics.cloud_metrics_builder import CloudMetricsBuilder
+from gooddata_legacy2cloud.metrics.computed_attribute import (
+    build_cloud_computed_attributes,
+    fetch_legacy_computed_attributes,
+)
 from gooddata_legacy2cloud.metrics.data_classes import MetricContext
 from gooddata_legacy2cloud.metrics.element_prefetcher import ElementPrefetcher
 from gooddata_legacy2cloud.models.enums import Operation
@@ -40,6 +45,8 @@
 
 LEGACY_METRICS_FILE = "legacy_metrics.json"
 CLOUD_METRICS_FILE = "cloud_metrics.json"
+LEGACY_COMPUTED_ATTRIBUTES_FILE = "legacy_computed_attributes.json"
+CLOUD_COMPUTED_ATTRIBUTES_FILE = "cloud_computed_attributes.json"
 
 logger = logging.getLogger("migration")
 configure_logger()
@@ -141,6 +148,7 @@ def migrate_metrics(config: MetricConfig):
         ignore_folders=config.ignore_folders,
         suppress_warnings=config.object_migration_config.suppress_migration_warnings,
         client_prefix=config.common_config.client_prefix,
+        metric_mappings=metric_mappings,
     )
     metrics_builder = CloudMetricsBuilder(ctx)
     metrics_builder.process_legacy_metrics(legacy_metrics)
@@ -161,18 +169,34 @@ def migrate_metrics(config: MetricConfig):
         write_content_to_file(CLOUD_METRICS_FILE, json.dumps(cloud_metrics, indent=4))
         logger.info("Cloud metrics dumped to '%s'", prefix_filename(CLOUD_METRICS_FILE))
 
+    cloud_computed_attributes = migrate_computed_attributes(config, ctx)
+
     if not config.common_config.skip_deploy:
         if config.object_migration_config.overwrite_existing:
             operation = Operation.CREATE_OR_UPDATE_WITH_ERROR_FALLBACK
+            ca_operation = Operation.CREATE_OR_UPDATE_WITH_RETRY
         else:
             operation = Operation.CREATE_WITH_ERROR_FALLBACK
-
-        process_objects(
-            cloud_client,
-            cloud_metrics,
-            "metric",
-            operation,
-        )
+            ca_operation = Operation.CREATE_WITH_RETRY
+
+        # metrics -> computed attributes (built on metrics) -> metrics using them
+        metrics_on_ca = [
+            m
+            for m in cloud_metrics
+            if "{computed_attribute/" in m["data"]["attributes"]["content"]["maql"]
+        ]
+        plain_metrics = [m for m in cloud_metrics if m not in metrics_on_ca]
+
+        process_objects(cloud_client, plain_metrics, "metric", operation)
+        if cloud_computed_attributes:
+            process_objects(
+                cloud_client,
+                cloud_computed_attributes,
+                "computed_attribute",
+                ca_operation,
+            )
+        if metrics_on_ca:
+            process_objects(cloud_client, metrics_on_ca, "metric", operation)
 
     execution_time = duration(start_time)
     legacy_client.logout()
@@ -180,6 +204,34 @@ def migrate_metrics(config: MetricConfig):
     logger.info("----Executed %d Cloud requests----", cloud_client.request_count.get())
 
 
+def migrate_computed_attributes(config: MetricConfig, ctx: MetricContext) -> list:
+    """Fetches, converts and maps Legacy computed attributes; returns Cloud ones."""
+    logger.info("----Fetching Legacy computed attributes----")
+    legacy_attributes = fetch_legacy_computed_attributes(ctx.legacy_client)
+    if config.object_migration_config.dump_legacy:
+        write_content_to_file(
+            LEGACY_COMPUTED_ATTRIBUTES_FILE, json.dumps(legacy_attributes, indent=4)
+        )
+
+    logger.info(
+        "----Processing Legacy computed attributes (%d)----", len(legacy_attributes)
+    )
+    cloud_attributes = build_cloud_computed_attributes(ctx, legacy_attributes)
+
+    mapping_writer = OutputWriter(COMPUTED_ATTRIBUTE_MAPPING_FILE)
+    for attribute in cloud_attributes:
+        cloud_id = attribute["data"]["id"]
+        legacy_id = "attr." + cloud_id.split(".", 1)[1]
+        mapping_writer.write_identifier_relation(legacy_id, cloud_id)
+        mapping_writer.write_identifier_relation(cloud_id, cloud_id)
+
+    if config.object_migration_config.dump_cloud:
+        write_content_to_file(
+            CLOUD_COMPUTED_ATTRIBUTES_FILE, json.dumps(cloud_attributes, indent=4)
+        )
+    return cloud_attributes
+
+
 def migrate_metrics_cli():
     args = parse_metric_cli_args()
     config = MetricConfig.from_kwargs(**args.__dict__)
diff --git a/tests/data/insights/legacy_objects/objects_by_uri.json b/tests/data/insights/legacy_objects/objects_by_uri.json
index c505167..e800031 100644
--- a/tests/data/insights/legacy_objects/objects_by_uri.json
+++ b/tests/data/insights/legacy_objects/objects_by_uri.json
@@ -517,5 +517,50 @@
       },
       "content": {}
     }
+  },
+  "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/9001": {
+    "attribute": {
+      "content": {
+        "displayForms": [
+          {
+            "links": {
+              "elements": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/9002/elements"
+            },
+            "meta": {
+              "identifier": "attr.comp.computedAttr"
+            }
+          }
+        ]
+      },
+      "meta": {
+        "category": "attribute",
+        "identifier": "attr.comp.computedAttr"
+      }
+    }
+  },
+  "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/9002": {
+    "attributeDisplayForm": {
+      "content": {
+        "expression": "[/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/4151]",
+        "formOf": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/9001"
+      },
+      "links": {
+        "elements": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/9002/elements"
+      },
+      "meta": {
+        "author": "/gdc/account/profile/5cc081c981561ae1d3f81481b50f002c",
+        "category": "attributeDisplayForm",
+        "contributor": "/gdc/account/profile/5cc081c981561ae1d3f81481b50f002c",
+        "created": "2025-04-09 17:05:22",
+        "deprecated": "0",
+        "identifier": "label.comp.computedAttr",
+        "isProduction": 1,
+        "summary": "",
+        "tags": "",
+        "title": "Computed Attr",
+        "updated": "2025-04-09 17:05:22",
+        "uri": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/9002"
+      }
+    }
   }
 }
diff --git a/tests/data/insights/test_cases/with_computed_attribute_cloud.json b/tests/data/insights/test_cases/with_computed_attribute_cloud.json
new file mode 100644
index 0000000..53af98c
--- /dev/null
+++ b/tests/data/insights/test_cases/with_computed_attribute_cloud.json
@@ -0,0 +1,69 @@
+[
+    {
+        "data": {
+            "id": "avg_item_price_per_category_abb6SWS81yFv",
+            "type": "visualizationObject",
+            "attributes": {
+                "title": "Avg item price per category",
+                "description": "",
+                "tags": [
+                    "finance",
+                    "revenue"
+                ],
+                "createdAt": "",
+                "content": {
+                    "filters": [],
+                    "attributeFilterConfigs": {},
+                    "buckets": [
+                        {
+                            "items": [
+                                {
+                                    "measure": {
+                                        "localIdentifier": "97b94dad34c84bc39dd59342a448a9cb",
+                                        "definition": {
+                                            "measureDefinition": {
+                                                "item": {
+                                                    "identifier": {
+                                                        "id": "orderitems.f_itemprice",
+                                                        "type": "fact"
+                                                    }
+                                                },
+                                                "aggregation": "avg",
+                                                "filters": []
+                                            }
+                                        },
+                                        "format": "#,##0.00",
+                                        "title": "Avg Item Price"
+                                    }
+                                }
+                            ],
+                            "localIdentifier": "measures"
+                        },
+                        {
+                            "items": [
+                                {
+                                    "attribute": {
+                                        "displayForm": {
+                                            "identifier": {
+                                                "id": "label.comp.computedAttr",
+                                                "type": "computedAttribute"
+                                            }
+                                        },
+                                        "localIdentifier": "d6f211db045248f08cc861b88eecfe12"
+                                    }
+                                }
+                            ],
+                            "localIdentifier": "view"
+                        }
+                    ],
+                    "createdAt": "2025-04-10 09:25:16",
+                    "modifiedAt": "2025-04-10 09:25:16",
+                    "sorts": [],
+                    "properties": {},
+                    "visualizationUrl": "local:bar",
+                    "version": "2"
+                }
+            }
+        }
+    }
+]
diff --git a/tests/data/insights/test_cases/with_computed_attribute_legacy.json b/tests/data/insights/test_cases/with_computed_attribute_legacy.json
new file mode 100644
index 0000000..5364746
--- /dev/null
+++ b/tests/data/insights/test_cases/with_computed_attribute_legacy.json
@@ -0,0 +1,63 @@
+[
+    {
+        "visualizationObject": {
+            "meta": {
+                "updated": "2025-04-10 09:25:16",
+                "deprecated": "0",
+                "uri": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/4839",
+                "contributor": "/gdc/account/profile/5cc081c981561ae1d3f81481b50f002c",
+                "created": "2025-04-10 09:25:16",
+                "category": "visualizationObject",
+                "title": "Avg item price per category",
+                "isProduction": 1,
+                "summary": "",
+                "author": "/gdc/account/profile/5cc081c981561ae1d3f81481b50f002c",
+                "identifier": "abb6SWS81yFv",
+                "tags": "finance revenue"
+            },
+            "content": {
+                "buckets": [
+                    {
+                        "localIdentifier": "measures",
+                        "items": [
+                            {
+                                "measure": {
+                                    "localIdentifier": "97b94dad34c84bc39dd59342a448a9cb",
+                                    "definition": {
+                                        "measureDefinition": {
+                                            "item": {
+                                                "uri": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/4769"
+                                            },
+                                            "aggregation": "avg"
+                                        }
+                                    },
+                                    "format": "#,##0.00",
+                                    "title": "Avg Item Price"
+                                }
+                            }
+                        ]
+                    },
+                    {
+                        "localIdentifier": "view",
+                        "items": [
+                            {
+                                "visualizationAttribute": {
+                                    "localIdentifier": "d6f211db045248f08cc861b88eecfe12",
+                                    "displayForm": {
+                                        "uri": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/9002"
+                                    }
+                                }
+                            }
+                        ]
+                    }
+                ],
+                "visualizationClass": {
+                    "uri": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/14"
+                }
+            },
+            "links": {
+                "explain": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/4839/explain"
+            }
+        }
+    }
+]
diff --git a/tests/data/metrics/legacy_objects/computed_attribute.json b/tests/data/metrics/legacy_objects/computed_attribute.json
new file mode 100644
index 0000000..b1f8a7e
--- /dev/null
+++ b/tests/data/metrics/legacy_objects/computed_attribute.json
@@ -0,0 +1,56 @@
+{
+    "attribute": {
+        "meta": {
+            "isProduction": 1,
+            "uri": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/4229",
+            "contributor": "/gdc/account/profile/5cc081c981561ae1d3f81481b50f002c",
+            "tags": "_lcm_managed_object embed release",
+            "created": "2025-02-03 06:05:20",
+            "category": "attribute",
+            "updated": "2026-09-01 09:10:38",
+            "author": "/gdc/account/profile/5cc081c981561ae1d3f81481b50f002c",
+            "identifier": "attr.comp.h29rLOz",
+            "deprecated": "0",
+            "summary": "Time ranges to group segments based on their time in queue.",
+            "title": "Segments by Queue Time Buckets"
+        },
+        "content": {
+            "pk": [
+                {
+                    "data": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/980",
+                    "type": "col"
+                }
+            ],
+            "displayForms": [
+                {
+                    "content": {
+                        "formOf": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/4229",
+                        "default": 1,
+                        "expression": "[/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/982]"
+                    },
+                    "links": {
+                        "elements": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/4230/elements"
+                    },
+                    "meta": {
+                        "updated": "2026-09-01 09:10:38",
+                        "deprecated": "0",
+                        "summary": "",
+                        "author": "/gdc/account/profile/5cc081c981561ae1d3f81481b50f002c",
+                        "identifier": "label.comp.h29rLOz",
+                        "title": "Segments by Queue Time Buckets",
+                        "isProduction": 1,
+                        "uri": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/4230",
+                        "contributor": "/gdc/account/profile/5cc081c981561ae1d3f81481b50f002c",
+                        "tags": "_lcm_managed_object",
+                        "category": "attributeDisplayForm",
+                        "created": "2025-02-03 06:05:20"
+                    }
+                }
+            ],
+            "rel": [
+                "to {attr.segment.segmentkey} as case when {aeB03p0tbrQw} <= 9 then {attr.comp.h29rLOz?\"00:00-00:09\"}, when {aeB03p0tbrQw} <= 19 then {attr.comp.h29rLOz?\"00:10-00:19\"}, when {aeB03p0tbrQw} <= 29 then {attr.comp.h29rLOz?\"00:20-00:29\"}, when {aeB03p0tbrQw} <= 39 then {attr.comp.h29rLOz?\"00:30-00:39\"}, when {aeB03p0tbrQw} <= 49 then {attr.comp.h29rLOz?\"00:40-00:49\"}, when {aeB03p0tbrQw} <= 59 then {attr.comp.h29rLOz?\"00:50-00:59\"}, when {aeB03p0tbrQw} <= 69 then {attr.comp.h29rLOz?\"01:00-01:09\"}, when {aeB03p0tbrQw} <= 79 then {attr.comp.h29rLOz?\"01:10-01:19\"}, when {aeB03p0tbrQw} <= 89 then {attr.comp.h29rLOz?\"01:20-01:29\"}, when {aeB03p0tbrQw} <= 99 then {attr.comp.h29rLOz?\"01:30-01:39\"}, when {aeB03p0tbrQw} <= 109 then {attr.comp.h29rLOz?\"01:40-01:49\"}, when {aeB03p0tbrQw} <= 119 then {attr.comp.h29rLOz?\"01:50-01:59\"}, when {aeB03p0tbrQw} <= 139 then {attr.comp.h29rLOz?\"02:00-02:19\"}, when {aeB03p0tbrQw} <= 159 then {attr.comp.h29rLOz?\"02:20-02:39\"}, when {aeB03p0tbrQw} <= 179 then {attr.comp.h29rLOz?\"02:40-02:59\"}, when {aeB03p0tbrQw} <= 199 then {attr.comp.h29rLOz?\"03:00-03:19\"}, when {aeB03p0tbrQw} <= 219 then {attr.comp.h29rLOz?\"03:20-03:39\"}, when {aeB03p0tbrQw} <= 239 then {attr.comp.h29rLOz?\"03:40-03:59\"}, when {aeB03p0tbrQw} <= 259 then {attr.comp.h29rLOz?\"04:00-04:19\"}, when {aeB03p0tbrQw} <= 279 then {attr.comp.h29rLOz?\"04:20-04:39\"}, when {aeB03p0tbrQw} <= 299 then {attr.comp.h29rLOz?\"04:40-04:59\"}, when {aeB03p0tbrQw} <= 359 then {attr.comp.h29rLOz?\"05:00-05:59\"}, when {aeB03p0tbrQw} <= 419 then {attr.comp.h29rLOz?\"06:00-06:59\"}, when {aeB03p0tbrQw} <= 479 then {attr.comp.h29rLOz?\"07:00-07:59\"}, when {aeB03p0tbrQw} <= 539 then {attr.comp.h29rLOz?\"08:00-08:59\"}, when {aeB03p0tbrQw} <= 599 then {attr.comp.h29rLOz?\"09:00-09:59\"}, when {aeB03p0tbrQw} <= 659 then {attr.comp.h29rLOz?\"10:00-10:59\"}, when {aeB03p0tbrQw} <= 719 then {attr.comp.h29rLOz?\"11:00-11:59\"}, when {aeB03p0tbrQw} <= 779 then {attr.comp.h29rLOz?\"12:00-12:59\"}, when {aeB03p0tbrQw} <= 839 then {attr.comp.h29rLOz?\"13:00-13:59\"}, when {aeB03p0tbrQw} <= 899 then {attr.comp.h29rLOz?\"14:00-14:59\"}, when {aeB03p0tbrQw} <= 959 then {attr.comp.h29rLOz?\"15:00-15:59\"}, when {aeB03p0tbrQw} <= 1019 then {attr.comp.h29rLOz?\"16:00-16:59\"}, when {aeB03p0tbrQw} <= 1079 then {attr.comp.h29rLOz?\"17:00-17:59\"}, when {aeB03p0tbrQw} <= 1139 then {attr.comp.h29rLOz?\"18:00-18:59\"}, when {aeB03p0tbrQw} <= 1199 then {attr.comp.h29rLOz?\"19:00-19:59\"}, when {aeB03p0tbrQw} > 1199 then {attr.comp.h29rLOz?\"20:00 +\"} else {attr.comp.h29rLOz?\"\"} end"
+            ],
+            "dimension": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/4206"
+        }
+    }
+}
diff --git a/tests/data/metrics/legacy_objects/objects_by_uri.json b/tests/data/metrics/legacy_objects/objects_by_uri.json
index 0956ad0..5e2b9b8 100644
--- a/tests/data/metrics/legacy_objects/objects_by_uri.json
+++ b/tests/data/metrics/legacy_objects/objects_by_uri.json
@@ -370,5 +370,25 @@
     "attributeElements": {
       "elements": []
     }
+  },
+  "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/9003": {
+    "attribute": {
+      "content": {
+        "displayForms": [
+          {
+            "links": {
+              "elements": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/9004/elements"
+            },
+            "meta": {
+              "identifier": "label.unknown.attribute"
+            }
+          }
+        ]
+      },
+      "meta": {
+        "category": "attribute",
+        "identifier": "attr.unknown.attribute"
+      }
+    }
   }
 }
diff --git a/tests/data/metrics/mapping_files/metric_mappings.csv b/tests/data/metrics/mapping_files/metric_mappings.csv
index d8e0294..ddce9ec 100644
--- a/tests/data/metrics/mapping_files/metric_mappings.csv
+++ b/tests/data/metrics/mapping_files/metric_mappings.csv
@@ -1 +1,2 @@
 aaD6TzxvzYiV,avg_order_item_total_price_aaD6TzxvzYiV
+aeB03p0tbrQw,aeB03p0tbrQw
diff --git a/tests/data/metrics/test_cases/computed_attribute_cloud.json b/tests/data/metrics/test_cases/computed_attribute_cloud.json
new file mode 100644
index 0000000..6fd9256
--- /dev/null
+++ b/tests/data/metrics/test_cases/computed_attribute_cloud.json
@@ -0,0 +1,19 @@
+{
+    "data": {
+        "type": "computedAttribute",
+        "id": "label.comp.h29rLOz",
+        "attributes": {
+            "title": "Segments by Queue Time Buckets",
+            "description": "Time ranges to group segments based on their time in queue.",
+            "tags": [
+                "_lcm_managed_object",
+                "embed",
+                "release"
+            ],
+            "dataType": "STRING",
+            "content": {
+                "maql": "SELECT CASE WHEN SUM({metric/aeB03p0tbrQw}) <= 9 THEN \"00:00-00:09\" WHEN SUM({metric/aeB03p0tbrQw}) <= 19 THEN \"00:10-00:19\" WHEN SUM({metric/aeB03p0tbrQw}) <= 29 THEN \"00:20-00:29\" WHEN SUM({metric/aeB03p0tbrQw}) <= 39 THEN \"00:30-00:39\" WHEN SUM({metric/aeB03p0tbrQw}) <= 49 THEN \"00:40-00:49\" WHEN SUM({metric/aeB03p0tbrQw}) <= 59 THEN \"00:50-00:59\" WHEN SUM({metric/aeB03p0tbrQw}) <= 69 THEN \"01:00-01:09\" WHEN SUM({metric/aeB03p0tbrQw}) <= 79 THEN \"01:10-01:19\" WHEN SUM({metric/aeB03p0tbrQw}) <= 89 THEN \"01:20-01:29\" WHEN SUM({metric/aeB03p0tbrQw}) <= 99 THEN \"01:30-01:39\" WHEN SUM({metric/aeB03p0tbrQw}) <= 109 THEN \"01:40-01:49\" WHEN SUM({metric/aeB03p0tbrQw}) <= 119 THEN \"01:50-01:59\" WHEN SUM({metric/aeB03p0tbrQw}) <= 139 THEN \"02:00-02:19\" WHEN SUM({metric/aeB03p0tbrQw}) <= 159 THEN \"02:20-02:39\" WHEN SUM({metric/aeB03p0tbrQw}) <= 179 THEN \"02:40-02:59\" WHEN SUM({metric/aeB03p0tbrQw}) <= 199 THEN \"03:00-03:19\" WHEN SUM({metric/aeB03p0tbrQw}) <= 219 THEN \"03:20-03:39\" WHEN SUM({metric/aeB03p0tbrQw}) <= 239 THEN \"03:40-03:59\" WHEN SUM({metric/aeB03p0tbrQw}) <= 259 THEN \"04:00-04:19\" WHEN SUM({metric/aeB03p0tbrQw}) <= 279 THEN \"04:20-04:39\" WHEN SUM({metric/aeB03p0tbrQw}) <= 299 THEN \"04:40-04:59\" WHEN SUM({metric/aeB03p0tbrQw}) <= 359 THEN \"05:00-05:59\" WHEN SUM({metric/aeB03p0tbrQw}) <= 419 THEN \"06:00-06:59\" WHEN SUM({metric/aeB03p0tbrQw}) <= 479 THEN \"07:00-07:59\" WHEN SUM({metric/aeB03p0tbrQw}) <= 539 THEN \"08:00-08:59\" WHEN SUM({metric/aeB03p0tbrQw}) <= 599 THEN \"09:00-09:59\" WHEN SUM({metric/aeB03p0tbrQw}) <= 659 THEN \"10:00-10:59\" WHEN SUM({metric/aeB03p0tbrQw}) <= 719 THEN \"11:00-11:59\" WHEN SUM({metric/aeB03p0tbrQw}) <= 779 THEN \"12:00-12:59\" WHEN SUM({metric/aeB03p0tbrQw}) <= 839 THEN \"13:00-13:59\" WHEN SUM({metric/aeB03p0tbrQw}) <= 899 THEN \"14:00-14:59\" WHEN SUM({metric/aeB03p0tbrQw}) <= 959 THEN \"15:00-15:59\" WHEN SUM({metric/aeB03p0tbrQw}) <= 1019 THEN \"16:00-16:59\" WHEN SUM({metric/aeB03p0tbrQw}) <= 1079 THEN \"17:00-17:59\" WHEN SUM({metric/aeB03p0tbrQw}) <= 1139 THEN \"18:00-18:59\" WHEN SUM({metric/aeB03p0tbrQw}) <= 1199 THEN \"19:00-19:59\" WHEN SUM({metric/aeB03p0tbrQw}) > 1199 THEN \"20:00 +\" ELSE \"\" END BY {label/segment.segmentkey} ALL OTHER"
+            }
+        }
+    }
+}
diff --git a/tests/data/metrics/test_cases/with_computed_attribute_cloud.json b/tests/data/metrics/test_cases/with_computed_attribute_cloud.json
new file mode 100644
index 0000000..78472aa
--- /dev/null
+++ b/tests/data/metrics/test_cases/with_computed_attribute_cloud.json
@@ -0,0 +1,17 @@
+[
+    {
+        "data": {
+            "id": "metric_with_computed_attribute_aaCompAttrMetric1",
+            "type": "metric",
+            "attributes": {
+                "title": "Metric with computed attribute",
+                "tags": [],
+                "description": "",
+                "content": {
+                    "format": "#,##0.00",
+                    "maql": "SELECT COUNT({computed_attribute/label.comp.computedAttr})"
+                }
+            }
+        }
+    }
+]
diff --git a/tests/data/metrics/test_cases/with_computed_attribute_legacy.json b/tests/data/metrics/test_cases/with_computed_attribute_legacy.json
new file mode 100644
index 0000000..ca057c1
--- /dev/null
+++ b/tests/data/metrics/test_cases/with_computed_attribute_legacy.json
@@ -0,0 +1,63 @@
+[
+    {
+        "metric": {
+            "content": {
+                "format": "#,##0.00",
+                "tree": {
+                    "position": {
+                        "line": 1,
+                        "column": 14
+                    },
+                    "type": "metric",
+                    "content": [
+                        {
+                            "content": [
+                                {
+                                    "type": "function",
+                                    "value": "COUNT",
+                                    "position": {
+                                        "column": 21,
+                                        "line": 1
+                                    },
+                                    "content": [
+                                        {
+                                            "value": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/9001",
+                                            "type": "attribute object",
+                                            "position": {
+                                                "column": 28,
+                                                "line": 1
+                                            }
+                                        }
+                                    ]
+                                }
+                            ],
+                            "type": "expression",
+                            "position": {
+                                "column": 21,
+                                "line": 1
+                            }
+                        }
+                    ]
+                },
+                "expression": "SELECT COUNT([/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/9001])"
+            },
+            "meta": {
+                "isProduction": 1,
+                "summary": "",
+                "contributor": "/gdc/account/profile/5cc081c981561ae1d3f81481b50f002c",
+                "updated": "2025-04-10 09:26:53",
+                "identifier": "aaCompAttrMetric1",
+                "tags": "",
+                "uri": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/9010",
+                "title": "Metric with computed attribute",
+                "created": "2025-04-10 09:24:10",
+                "category": "metric",
+                "deprecated": "0",
+                "author": "/gdc/account/profile/5cc081c981561ae1d3f81481b50f002c"
+            },
+            "links": {
+                "explain2": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/9010/explain2"
+            }
+        }
+    }
+]
diff --git a/tests/data/metrics/test_cases/with_unresolved_identifier_cloud.json b/tests/data/metrics/test_cases/with_unresolved_identifier_cloud.json
index 9b51642..f2c3802 100644
--- a/tests/data/metrics/test_cases/with_unresolved_identifier_cloud.json
+++ b/tests/data/metrics/test_cases/with_unresolved_identifier_cloud.json
@@ -5,11 +5,13 @@
             "type": "metric",
             "attributes": {
                 "title": "[ERROR] Metric with computed attribute",
-                "tags": ["ERROR"],
+                "tags": [
+                    "ERROR"
+                ],
                 "description": "",
                 "content": {
                     "format": "#,##0.00",
-                    "maql": "#Failed MAQL:\n#SELECT COUNT([/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/9001])\n\n#Error:\n#Search Cloud Id - Unknown Legacy identifier attr.comp.computedAttr\n\nSELECT SQRT(-1)"
+                    "maql": "#Failed MAQL:\n#SELECT COUNT([/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/9003])\n\n#Error:\n#Search Cloud Id - Unknown Legacy identifier attr.unknown.attribute\n\nSELECT SQRT(-1)"
                 }
             }
         }
diff --git a/tests/data/metrics/test_cases/with_unresolved_identifier_legacy.json b/tests/data/metrics/test_cases/with_unresolved_identifier_legacy.json
index ca057c1..d3a6745 100644
--- a/tests/data/metrics/test_cases/with_unresolved_identifier_legacy.json
+++ b/tests/data/metrics/test_cases/with_unresolved_identifier_legacy.json
@@ -21,7 +21,7 @@
                                     },
                                     "content": [
                                         {
-                                            "value": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/9001",
+                                            "value": "/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/9003",
                                             "type": "attribute object",
                                             "position": {
                                                 "column": 28,
@@ -39,7 +39,7 @@
                         }
                     ]
                 },
-                "expression": "SELECT COUNT([/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/9001])"
+                "expression": "SELECT COUNT([/gdc/md/dinu996plcf6ajcp6wygnqn952uyom9u/obj/9003])"
             },
             "meta": {
                 "isProduction": 1,
diff --git a/tests/data/shared/mapping_files/ldm_mappings.csv b/tests/data/shared/mapping_files/ldm_mappings.csv
index ddb3c3d..98b19dd 100644
--- a/tests/data/shared/mapping_files/ldm_mappings.csv
+++ b/tests/data/shared/mapping_files/ldm_mappings.csv
@@ -103,3 +103,4 @@ attr.convertcurrency.currencycode,convertcurrency.currencycode
 label.convertcurrency.currencycode,convertcurrency.currencycode
 label.datasetwithformerpk.anotherattribute,datasetwithformerpk.anotherattribute
 attr.datasetwithformerpk.anotherattribute,datasetwithformerpk.anotherattribute
+attr.segment.segmentkey,segment.segmentkey
diff --git a/tests/test_computed_attributes.py b/tests/test_computed_attributes.py
new file mode 100644
index 0000000..d96e5ab
--- /dev/null
+++ b/tests/test_computed_attributes.py
@@ -0,0 +1,65 @@
+# (C) 2026 GoodData Corporation
+"""
+Verifies the transformation of Legacy computed attributes to Cloud ones.
+All calls to Legacy and Cloud are mocked, data is loaded from `tests/data/metrics`.
+"""
+
+import dataclasses
+
+import pytest
+
+from gooddata_legacy2cloud.helpers import cloud_display_form_type
+from gooddata_legacy2cloud.id_mappings import IdMappings
+from gooddata_legacy2cloud.output_writer import OutputWriter
+from gooddata_legacy2cloud.metrics.computed_attribute import (
+    build_cloud_computed_attribute,
+    build_cloud_computed_attributes,
+)
+from tests.test_utils import dicts_are_equal, load_json
+
+LEGACY_FILE = "tests/data/metrics/legacy_objects/computed_attribute.json"
+CLOUD_FILE = "tests/data/metrics/test_cases/computed_attribute_cloud.json"
+METRIC_MAPPINGS = "tests/data/metrics/mapping_files/metric_mappings.csv"
+
+
+@pytest.fixture
+def ca_context(metrics_context):
+    return dataclasses.replace(
+        metrics_context, metric_mappings=IdMappings(METRIC_MAPPINGS)
+    )
+
+
+def test_computed_attribute_transformation(ca_context) -> None:
+    attribute, expected = load_json(LEGACY_FILE), load_json(CLOUD_FILE)
+    assert isinstance(attribute, dict) and isinstance(expected, dict)
+    actual = build_cloud_computed_attribute(ca_context, attribute)
+    dicts_are_equal(actual, expected)
+    dicts_are_equal(expected, actual)
+
+
+def test_unsupported_definition_is_skipped(ca_context) -> None:
+    attribute = load_json(LEGACY_FILE)
+    assert isinstance(attribute, dict)
+    attribute["attribute"]["content"]["rel"] = [
+        "to {attr.segment.segmentkey} as case when {aeB03p0tbrQw} "
+        'between 1 and 9 then {attr.comp.h29rLOz?"x"} end'
+    ]
+    with pytest.raises(ValueError, match="Unsupported"):
+        build_cloud_computed_attribute(ca_context, attribute)
+    assert build_cloud_computed_attributes(ca_context, [attribute]) == []
+
+
+def test_computed_attribute_ids_and_types() -> None:
+    mappings = IdMappings()
+    assert mappings.search_mapping_identifier("attr.comp.X") == "label.comp.X"
+    assert mappings.search_mapping_identifier("label.comp.X") == "label.comp.X"
+    with pytest.raises(ValueError):
+        mappings.search_mapping_identifier("attr.other.X")
+    assert cloud_display_form_type("label.comp.X") == "computedAttribute"
+    assert cloud_display_form_type("label.products.category") == "label"
+
+
+def test_skipped_computed_attributes_file(tmp_path, monkeypatch) -> None:
+    monkeypatch.chdir(tmp_path)
+    OutputWriter("unused.csv").write_skipped_objects([], "computed_attribute")
+    assert (tmp_path / "cloud_skipped_computed_attributes.json").exists()
diff --git a/tests/test_insights.py b/tests/test_insights.py
index 9077255..2235134 100644
--- a/tests/test_insights.py
+++ b/tests/test_insights.py
@@ -20,6 +20,7 @@
     "case_file_name",
     [
         "basic_insight",
+        "with_computed_attribute",
         "with_missing_value_in_color_definition",
         "with_metric_value_filter",
         "with_top_filter",
diff --git a/tests/test_metrics.py b/tests/test_metrics.py
index d955111..319213c 100644
--- a/tests/test_metrics.py
+++ b/tests/test_metrics.py
@@ -25,6 +25,7 @@
         "with_date_filters",
         "using_deprecated_metric",
         "with_unresolved_identifier",
+        "with_computed_attribute",
     ],
 )
 def test_metrics_migration(

From e6991ec5542ac16b5567ba24c75c7f12934fe2ee Mon Sep 17 00:00:00 2001
From: Roman Valovic <xvalovic@mendelu.cz>
Date: Tue, 13 Oct 2026 09:48:36 +0200
Subject: [PATCH 2/2] feat: migrate creator/modifier of metrics and insights

dashboard-permissions gets --include-metrics / --include-insights: Legacy
author -> Cloud createdBy and Legacy contributor -> Cloud modifiedBy are
set in the workspace layout for metrics and insights (no permissions).
Dashboards now also get modifiedBy from contributor instead of author.

risk: low

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 README.md                                     |   9 +-
 .../arg_parsing/arg_parser.py                 |  12 +++
 .../config/configuration_objects.py           |  17 +++
 .../dashboard_permissions/change_formatter.py |   8 +-
 .../dashboard_permissions/data_classes.py     |   3 +
 .../permissions_updater.py                    |  84 +++++++++++++--
 .../insights/cloud_insight.py                 |  11 +-
 .../layout/layout_manager.py                  | 100 +++++++++---------
 .../user_management/legacy_users.py           |   4 +-
 .../migrate_dashboard_permissions.py          |  65 +++++++++---
 tests/test_layout_manager.py                  |  76 +++++++++++++
 11 files changed, 306 insertions(+), 83 deletions(-)
 create mode 100644 tests/test_layout_manager.py

diff --git a/README.md b/README.md
index 40b28bd..6a7a5a5 100644
--- a/README.md
+++ b/README.md
@@ -572,7 +572,7 @@ gooddata-legacy2cloud dashboard-permissions
 **What this script does:**
 
 1. Fetches selected Legacy dashboards based on filter parameters
-2. Identifies the creator (account that created the dashboard) from Legacy
+2. Identifies the creator (`author`) and last modifier (`contributor`) from Legacy
 3. Collects sharing information (grantees) from Legacy dashboard permissions
 4. Maps Legacy users to Cloud users based on either Legacy `email` field or Legacy `login` field
 5. Maps Legacy user groups to Cloud user groups based on group names
@@ -599,6 +599,10 @@ gooddata-legacy2cloud dashboard-permissions
 
 **Dashboard Permissions-specific options:**
 
+**--include-metrics** - Also migrate creator/modifier of metrics (Legacy `author` → Cloud `createdBy`, Legacy `contributor` → Cloud `modifiedBy`). Metrics have no permissions, only these two fields are updated. Reads `metric_mappings.csv` (`--metric-mapping-file`).
+
+**--include-insights** - Also migrate creator/modifier of insights, same as above. Reads `insight_mappings.csv` (`--insight-mapping-file`).
+
 **--dump-layout** - Store the layout JSON locally before and after modifications for debugging purposes
 
 **--use-email** - Use Legacy email field instead of login field when matching Legacy users to Cloud users. By default, the script uses the login field from Legacy users to match against Cloud user emails. With this parameter it uses email field from Legacy users to match against Cloud user emails.
@@ -636,6 +640,9 @@ gooddata-legacy2cloud dashboard-permissions --permission VIEW
 
 # Update with client prefix
 gooddata-legacy2cloud dashboard-permissions --client-prefix client1_ --legacy-ws client1_legacy_ws --cloud-ws client1_cloud_ws
+
+# Also set creator/modifier of metrics and insights
+gooddata-legacy2cloud dashboard-permissions --include-metrics --include-insights
 ```
 
 **Important notes:**
diff --git a/src/gooddata_legacy2cloud/arg_parsing/arg_parser.py b/src/gooddata_legacy2cloud/arg_parsing/arg_parser.py
index e666946..3a1c179 100644
--- a/src/gooddata_legacy2cloud/arg_parsing/arg_parser.py
+++ b/src/gooddata_legacy2cloud/arg_parsing/arg_parser.py
@@ -648,6 +648,18 @@ def parse_dashboard_permission_cli_args() -> argparse.Namespace:
     add_object_filter_arguments(parser)
     add_dashboard_mapping_arguments(parser)
     add_pp_dashboard_mapping_arguments(parser)
+    add_metric_mapping_arguments(parser)
+    add_insight_mapping_arguments(parser)
+    parser.add_argument(
+        "--include-metrics",
+        action="store_true",
+        help="Also migrate creator/modifier (author/contributor) of metrics",
+    )
+    parser.add_argument(
+        "--include-insights",
+        action="store_true",
+        help="Also migrate creator/modifier (author/contributor) of insights",
+    )
     parser.add_argument(
         "--dump-layout",
         action="store_true",
diff --git a/src/gooddata_legacy2cloud/config/configuration_objects.py b/src/gooddata_legacy2cloud/config/configuration_objects.py
index b991385..ed7a26f 100644
--- a/src/gooddata_legacy2cloud/config/configuration_objects.py
+++ b/src/gooddata_legacy2cloud/config/configuration_objects.py
@@ -62,8 +62,25 @@ class DashboardPermissionsConfig(BaseConfig):
         + "is treated as default and also used for output, all files are used "
         + f"for input. Default: [{PIXEL_PERFECT_DASHBOARD_MAPPING_FILE}]",
     )
+    metric_mapping_file: list[str] = Field(
+        default_factory=lambda: [METRIC_MAPPING_FILE],
+        description=f"Metric mappings file name(s). Default: [{METRIC_MAPPING_FILE}]",
+    )
+    insight_mapping_file: list[str] = Field(
+        default_factory=lambda: [INSIGHT_MAPPING_FILE],
+        description="Insight mappings file name(s). "
+        + f"Default: [{INSIGHT_MAPPING_FILE}]",
+    )
 
     # Custom migration arguments
+    include_metrics: bool = Field(
+        default=False,
+        description="Also migrate creator/modifier of metrics",
+    )
+    include_insights: bool = Field(
+        default=False,
+        description="Also migrate creator/modifier of insights",
+    )
     dump_layout: bool = Field(
         default=False,
         description="Save the layout JSON before and after modifications",
diff --git a/src/gooddata_legacy2cloud/dashboard_permissions/change_formatter.py b/src/gooddata_legacy2cloud/dashboard_permissions/change_formatter.py
index c015c15..3f07867 100644
--- a/src/gooddata_legacy2cloud/dashboard_permissions/change_formatter.py
+++ b/src/gooddata_legacy2cloud/dashboard_permissions/change_formatter.py
@@ -15,11 +15,15 @@ def format_change_line(change: ActualChange) -> str:
         Formatted string containing dashboard, action, and target context.
     """
 
-    prefix = f"  Dashboard: '{change.dashboard_title}' (ID: {change.dashboard_id}) - "
+    prefix = (
+        f"  {change.object_type.capitalize()}: '{change.dashboard_title}' "
+        f"(ID: {change.dashboard_id}) - "
+    )
 
     if change.change_type == "creator_updated":
         return (
-            f"{prefix}Changed creator from '{change.old_value}' to '{change.new_value}'"
+            f"{prefix}Changed creator / modifier from '{change.old_value}' "
+            f"to '{change.new_value}'"
         )
 
     if change.change_type == "permission_removed":
diff --git a/src/gooddata_legacy2cloud/dashboard_permissions/data_classes.py b/src/gooddata_legacy2cloud/dashboard_permissions/data_classes.py
index 2e0a3bd..47625a9 100644
--- a/src/gooddata_legacy2cloud/dashboard_permissions/data_classes.py
+++ b/src/gooddata_legacy2cloud/dashboard_permissions/data_classes.py
@@ -36,6 +36,7 @@ class ActualChange:
     new_value: str = field(default="")
     old_permission: str = field(default="")
     new_permission: str = field(default="")
+    object_type: str = field(default="dashboard")
 
 
 @dataclass(frozen=True)
@@ -67,3 +68,5 @@ class DashboardPermissionContext:
     keep_existing_permissions: bool = field(default=False)
     print_user_mappings: bool = field(default=False)
     client_prefix: str | None = field(default=None)
+    metric_mappings: IdMappings | None = field(default=None)
+    insight_mappings: IdMappings | None = field(default=None)
diff --git a/src/gooddata_legacy2cloud/dashboard_permissions/permissions_updater.py b/src/gooddata_legacy2cloud/dashboard_permissions/permissions_updater.py
index b8063f2..ee07515 100644
--- a/src/gooddata_legacy2cloud/dashboard_permissions/permissions_updater.py
+++ b/src/gooddata_legacy2cloud/dashboard_permissions/permissions_updater.py
@@ -5,6 +5,7 @@
 from gooddata_legacy2cloud.dashboard_permissions.data_classes import (
     DashboardPermissionContext,
 )
+from gooddata_legacy2cloud.id_mappings import IdMappings
 from gooddata_legacy2cloud.layout.layout_manager import (
     update_object_creators_in_layout,
 )
@@ -47,6 +48,8 @@ def __init__(self, context: DashboardPermissionContext):
         """
         self.ctx = context
         self.legacy_dashboards: list[dict] = []
+        self.legacy_metrics: list[dict] = []
+        self.legacy_insights: list[dict] = []
         self.legacy_user_map: dict[str, str] = {}
         self.cloud_user_map: dict[str, str] = {}
         self.user_mappings: dict[str, UserMapping] = {}
@@ -59,18 +62,26 @@ def __init__(self, context: DashboardPermissionContext):
         self.identifier_plural = f"{self.identifier_type}s"
 
     def process_dashboards(
-        self, legacy_dashboards: list[dict]
+        self,
+        legacy_dashboards: list[dict],
+        legacy_metrics: list[dict] | None = None,
+        legacy_insights: list[dict] | None = None,
     ) -> tuple[list[ObjectUpdate], dict[str, int]]:
         """
-        Process Legacy dashboards and prepare permission updates.
+        Process Legacy dashboards (permissions + creators) and optionally
+        metrics and insights (creators only) and prepare layout updates.
 
         Args:
             legacy_dashboards: List of Legacy dashboard objects
+            legacy_metrics: List of Legacy metric objects
+            legacy_insights: List of Legacy insight objects
 
         Returns:
             tuple: (list of ObjectUpdate instances, skip statistics dictionary)
         """
         self.legacy_dashboards = legacy_dashboards
+        self.legacy_metrics = legacy_metrics or []
+        self.legacy_insights = legacy_insights or []
 
         # Fetch and map users
         self._fetch_and_map_users()
@@ -118,10 +129,12 @@ def _fetch_and_map_users(self) -> None:
             legacy_users, self.identifier_type
         )
 
-        # Extract creator IDs
-        user_ids = extract_creator_modifier_ids(self.legacy_dashboards)
+        # Extract creator and modifier IDs
+        user_ids = extract_creator_modifier_ids(
+            self.legacy_dashboards + self.legacy_metrics + self.legacy_insights
+        )
         logger.info(
-            "Found %s unique creator %s in dashboards",
+            "Found %s unique creator/modifier %s in objects",
             len(user_ids),
             self.identifier_plural,
         )
@@ -317,8 +330,63 @@ def _build_object_updates(self) -> tuple[list[ObjectUpdate], dict[str, int]]:
             if update:
                 object_updates.append(update)
 
+        for objects, object_type, mappings in (
+            (self.legacy_metrics, "metric", self.ctx.metric_mappings),
+            (self.legacy_insights, "insight", self.ctx.insight_mappings),
+        ):
+            if objects:
+                logger.info("----Processing %ss----", object_type)
+            for obj in objects:
+                update = self._process_creator_only(
+                    obj, object_type, mappings, skip_stats
+                )
+                if update:
+                    object_updates.append(update)
+
         return object_updates, skip_stats
 
+    def _process_creator_only(
+        self,
+        obj: dict,
+        object_type: str,
+        mappings: IdMappings | None,
+        skip_stats: dict[str, int],
+    ) -> ObjectUpdate | None:
+        """Build a creator/modifier-only update for a metric or an insight."""
+        if not obj or len(obj) != 1 or mappings is None:
+            return None
+        root_obj = next(iter(obj.values()))
+        if not isinstance(root_obj, dict) or "meta" not in root_obj:
+            return None
+        meta = root_obj["meta"]
+        cloud_object_id = mappings.get_value_by_key(meta.get("identifier"))
+        if not cloud_object_id:
+            skip_stats["no_cloud_mapping"] += 1
+            return None
+        legacy_creator_id = self._extract_profile_id(meta.get("author"))
+        cloud_creator_id, creator_email = self._get_mapped_user(legacy_creator_id)
+        if not cloud_creator_id:
+            skip_stats["no_user_mapping"] += 1
+            logger.warning(
+                "Creator '%s' not mapped for %s '%s' - skipped",
+                creator_email or legacy_creator_id,
+                object_type,
+                meta.get("title", ""),
+            )
+            return None
+        legacy_modifier_id = self._extract_profile_id(meta.get("contributor"))
+        cloud_modifier_id, _ = self._get_mapped_user(legacy_modifier_id)
+        return ObjectUpdate(
+            legacy_object_id=meta.get("identifier"),
+            legacy_object_title=meta.get("title", ""),
+            cloud_object_id=cloud_object_id,
+            object_type=object_type,
+            legacy_creator_id=legacy_creator_id,
+            legacy_modifier_id=legacy_modifier_id,
+            cloud_creator_id=cloud_creator_id,
+            cloud_modifier_id=cloud_modifier_id,
+        )
+
     def _process_single_dashboard(
         self, obj: dict, idx: int, skip_stats: dict[str, int]
     ) -> ObjectUpdate | None:
@@ -344,6 +412,8 @@ def _process_single_dashboard(
         creator_uri = dashboard_meta.get("author")
         legacy_creator_id = self._extract_profile_id(creator_uri)
         cloud_creator_id, creator_email = self._get_mapped_user(legacy_creator_id)
+        legacy_modifier_id = self._extract_profile_id(dashboard_meta.get("contributor"))
+        cloud_modifier_id, _ = self._get_mapped_user(legacy_modifier_id)
 
         # Process grantees if sharing is not skipped
         grantee_user_ids, grantee_mappings, grantee_group_ids, group_mappings = (
@@ -376,9 +446,9 @@ def _process_single_dashboard(
             cloud_object_id=cloud_object_id,
             object_type="dashboard",
             legacy_creator_id=legacy_creator_id,
-            legacy_modifier_id=None,
+            legacy_modifier_id=legacy_modifier_id,
             cloud_creator_id=cloud_creator_id,
-            cloud_modifier_id=None,
+            cloud_modifier_id=cloud_modifier_id,
             grantee_user_ids=grantee_user_ids if grantee_user_ids else None,
             grantee_group_ids=grantee_group_ids if grantee_group_ids else None,
         )
diff --git a/src/gooddata_legacy2cloud/insights/cloud_insight.py b/src/gooddata_legacy2cloud/insights/cloud_insight.py
index e884144..408ca18 100644
--- a/src/gooddata_legacy2cloud/insights/cloud_insight.py
+++ b/src/gooddata_legacy2cloud/insights/cloud_insight.py
@@ -11,6 +11,7 @@
 from gooddata_legacy2cloud.helpers import (
     cloud_display_form_type,
     get_cloud_id,
+    is_computed_attribute,
     parse_legacy_tags,
 )
 from gooddata_legacy2cloud.id_mappings import IdMappings
@@ -357,13 +358,15 @@ def _get_filters(self, filters: list, origin: str) -> list:
     def _transform_bucket(
         self, mapping: IdMappings, bucket: dict, legacy_object: dict, bucket_type: str
     ):
-        cloud_id = mapping.search_mapping_identifier(
-            legacy_object[bucket_type]["meta"]["identifier"]
-        )
+        legacy_id = legacy_object[bucket_type]["meta"]["identifier"]
+        cloud_id = mapping.search_mapping_identifier(legacy_id)
         bucket["measure"]["definition"]["measureDefinition"]["item"] = {
             "identifier": {
                 "id": cloud_id,
-                "type": legacy_object[bucket_type]["meta"]["category"],
+                # COUNT(attr.comp.X) has to reference the computed attribute entity
+                "type": "computedAttribute"
+                if is_computed_attribute(legacy_id)
+                else legacy_object[bucket_type]["meta"]["category"],
             }
         }
         bucket["measure"]["definition"]["measureDefinition"]["filters"] = (
diff --git a/src/gooddata_legacy2cloud/layout/layout_manager.py b/src/gooddata_legacy2cloud/layout/layout_manager.py
index eb36333..9877ef7 100644
--- a/src/gooddata_legacy2cloud/layout/layout_manager.py
+++ b/src/gooddata_legacy2cloud/layout/layout_manager.py
@@ -11,6 +11,12 @@
 
 logger = logging.getLogger("migration")
 
+LAYOUT_SECTIONS = {
+    "dashboard": "analyticalDashboards",
+    "metric": "metrics",
+    "insight": "visualizationObjects",
+}
+
 
 def find_dashboard_in_layout(layout: dict, dashboard_id: str) -> dict | None:
     """
@@ -46,8 +52,9 @@ def update_object_creators_in_layout(
     """
     Updates creator fields and permissions in the layout for specified objects.
 
-    Modifies the createdBy field, modifiedBy field (if present), and permissions
-    in analyticalDashboards section, leaving all other sections and fields untouched.
+    Modifies the createdBy field and modifiedBy field (if present) of dashboards,
+    metrics and insights, and permissions of dashboards, leaving all other
+    sections and fields untouched.
 
     Args:
         layout: The workspace layout dictionary
@@ -63,56 +70,43 @@ def update_object_creators_in_layout(
     """
     updates_made = 0
     actual_changes: list[ActualChange] = []
-
-    # Navigate to analyticalDashboards section
     analytics = layout.get("analytics", {})
-    analytical_dashboards = analytics.get("analyticalDashboards", [])
-
-    # Create a mapping of Cloud dashboard IDs to update info
-    update_map = {obj.cloud_object_id: obj for obj in object_updates}
 
-    # Track which dashboards were found in the layout
-    found_dashboard_ids = set()
+    # Create a mapping of (object type, Cloud ID) to update info
+    update_map = {(obj.object_type, obj.cloud_object_id): obj for obj in object_updates}
+    found_keys = set()
 
-    # Update each dashboard
-    for dashboard in analytical_dashboards:
-        dashboard_id = dashboard.get("id")
-        if dashboard_id not in update_map:
-            continue
-        update_info = update_map[dashboard_id]
-        dashboard_title = dashboard.get("title", "Untitled")
-        dashboard_changes = []
-        dashboard_changes.extend(
-            _update_creator_fields(
-                dashboard,
-                dashboard_id,
-                dashboard_title,
-                update_info,
-                skip_creators,
-            )
-        )
-        dashboard_changes.extend(
-            _sync_permissions(
-                dashboard,
-                dashboard_id,
-                dashboard_title,
-                update_info,
-                skip_creators,
-                skip_individual_grantees,
-                skip_group_grantees,
-                permission_level,
-                keep_existing_permissions,
+    for object_type, section in LAYOUT_SECTIONS.items():
+        for obj in analytics.get(section, []):
+            key = (object_type, obj.get("id"))
+            if key not in update_map:
+                continue
+            update_info = update_map[key]
+            title = obj.get("title", "Untitled")
+            changes = _update_creator_fields(
+                obj, key[1], title, update_info, skip_creators
             )
-        )
-        if dashboard_changes:
-            for change in dashboard_changes:
+            if object_type == "dashboard":
+                changes.extend(
+                    _sync_permissions(
+                        obj,
+                        key[1],
+                        title,
+                        update_info,
+                        skip_creators,
+                        skip_individual_grantees,
+                        skip_group_grantees,
+                        permission_level,
+                        keep_existing_permissions,
+                    )
+                )
+            for change in changes:
                 actual_changes.append(change)
                 logger.info("%s", format_change_line(change))
-        updates_made += 1
-        found_dashboard_ids.add(dashboard_id)
+            updates_made += 1
+            found_keys.add(key)
 
-    # Calculate how many dashboards were not found in the layout
-    not_found_count = len(update_map) - len(found_dashboard_ids)
+    not_found_count = len(update_map) - len(found_keys)
 
     return layout, updates_made, not_found_count, actual_changes
 
@@ -124,24 +118,26 @@ def _update_creator_fields(
     update_info: ObjectUpdate,
     skip_creators: bool,
 ) -> list[ActualChange]:
-    """Update createdBy/modifiedBy metadata."""
+    """Update createdBy (Legacy author) and modifiedBy (Legacy contributor)."""
     if skip_creators or not update_info.has_creator_mapping:
         return []
     new_creator = update_info.cloud_creator_id or ""
+    new_modifier = update_info.cloud_modifier_id or new_creator
     old_creator = dashboard.get("createdBy", {}).get("id", "None")
-    if old_creator == new_creator:
+    old_modifier = dashboard.get("modifiedBy", {}).get("id", new_modifier)
+    if old_creator == new_creator and old_modifier == new_modifier:
         return []
-    user_ref = {"id": new_creator, "type": "user"}
-    dashboard["createdBy"] = user_ref
+    dashboard["createdBy"] = {"id": new_creator, "type": "user"}
     if "modifiedBy" in dashboard:
-        dashboard["modifiedBy"] = user_ref
+        dashboard["modifiedBy"] = {"id": new_modifier, "type": "user"}
     return [
         ActualChange(
             dashboard_id=dashboard_id,
             dashboard_title=dashboard_title,
             change_type="creator_updated",
-            old_value=old_creator,
-            new_value=new_creator,
+            old_value=f"{old_creator} / {old_modifier}",
+            new_value=f"{new_creator} / {new_modifier}",
+            object_type=update_info.object_type,
         )
     ]
 
diff --git a/src/gooddata_legacy2cloud/user_management/legacy_users.py b/src/gooddata_legacy2cloud/user_management/legacy_users.py
index 8772f0e..c588ec2 100644
--- a/src/gooddata_legacy2cloud/user_management/legacy_users.py
+++ b/src/gooddata_legacy2cloud/user_management/legacy_users.py
@@ -31,8 +31,8 @@ def extract_creator_modifier_ids(objects: list[dict]) -> set[str]:
                     if creator_id:
                         user_ids.add(creator_id)
 
-                # Extract modifier ID from createdBy field (despite the name, it's the last modifier)
-                modifier = obj_meta.get("createdBy")
+                # Extract modifier ID (Bear `contributor` = last modifier)
+                modifier = obj_meta.get("contributor") or obj_meta.get("createdBy")
                 if modifier:
                     # Extract ID from URI like /gdc/account/profile/USER_ID
                     if modifier.startswith("/gdc/account/profile/"):
diff --git a/src/gooddata_legacy2cloud/workflows/migrate_dashboard_permissions.py b/src/gooddata_legacy2cloud/workflows/migrate_dashboard_permissions.py
index 340694c..39312e5 100644
--- a/src/gooddata_legacy2cloud/workflows/migrate_dashboard_permissions.py
+++ b/src/gooddata_legacy2cloud/workflows/migrate_dashboard_permissions.py
@@ -134,17 +134,32 @@ def _load_legacy_dashboards(
     return dashboards
 
 
+def _load_mappings(
+    config: DashboardPermissionsConfig, files: list[str], label: str
+) -> IdMappings:
+    """Resolve mapping files (with client prefix) and load them."""
+    resolved, status = get_mapping_files(
+        files=files, client_prefix=config.common_config.client_prefix
+    )
+    logger.info("  %s mappings: %s", label, format_mapping_files_info(resolved, status))
+    return IdMappings(resolved)
+
+
 def _build_context(
     config: DashboardPermissionsConfig,
     legacy_client: LegacyClient,
     cloud_client: CloudClient,
     dashboard_mappings: IdMappings,
+    metric_mappings: IdMappings | None = None,
+    insight_mappings: IdMappings | None = None,
 ) -> DashboardPermissionContext:
     """Assemble context used by PermissionsUpdater."""
     return DashboardPermissionContext(
         legacy_client=legacy_client,
         cloud_client=cloud_client,
         dashboard_mappings=dashboard_mappings,
+        metric_mappings=metric_mappings,
+        insight_mappings=insight_mappings,
         use_email=config.use_email,
         skip_creators=config.skip_creators,
         skip_individual_grantees=config.skip_individual_grantees,
@@ -160,12 +175,10 @@ def _log_skip_stats(skip_stats: dict[str, int]) -> None:
     """Log statistics describing skipped dashboards."""
     no_mapping = skip_stats.get("no_cloud_mapping", 0)
     if no_mapping > 0:
-        logger.warning(
-            "Skipped %d dashboards: not found in dashboard_mappings.csv", no_mapping
-        )
+        logger.warning("Skipped %d objects: not found in mapping files", no_mapping)
     no_user = skip_stats.get("no_user_mapping", 0)
     if no_user > 0:
-        logger.warning("Skipped %d dashboards: creator not found in Cloud", no_user)
+        logger.warning("Skipped %d objects: creator not found in Cloud", no_user)
 
 
 def _apply_updates_if_needed(
@@ -177,7 +190,7 @@ def _apply_updates_if_needed(
     """Apply updates or log dry-run message based on CLI flags."""
     if config.common_config.skip_deploy:
         logger.info(
-            "[SKIP DEPLOY] Would update %d dashboard creator records",
+            "[SKIP DEPLOY] Would update %d object creator records",
             len(object_updates),
         )
         logger.info("(use without --skip-deploy to apply changes)")
@@ -217,12 +230,10 @@ def _apply_updates_if_needed(
 
     if original_hash == modified_hash:
         logger.info("No changes detected in layout - skipping API update")
-        logger.info(
-            "Processed %d dashboards (no permission changes needed)", updates_made
-        )
+        logger.info("Processed %d objects (no changes needed)", updates_made)
         if not_found_count > 0:
             logger.info(
-                "%d Dashboards from Legacy not found in Cloud layout",
+                "%d objects from Legacy not found in Cloud layout",
                 not_found_count,
             )
         return actual_changes
@@ -231,10 +242,10 @@ def _apply_updates_if_needed(
     response = cloud_client.update_workspace_layout(modified_layout)
     if response.status_code in (200, 204):
         logger.info("Layout updated successfully")
-        logger.info("Updated %d dashboards", updates_made)
+        logger.info("Updated %d objects", updates_made)
         if not_found_count > 0:
             logger.info(
-                "%d Dashboards from Legacy not found in Cloud layout",
+                "%d objects from Legacy not found in Cloud layout",
                 not_found_count,
             )
     else:
@@ -314,13 +325,37 @@ def migrate_dashboard_permissions(config: DashboardPermissionsConfig):
         dashboard_mappings,
     )
 
+    # Optionally load metrics and insights (creator/modifier only)
+    legacy_metrics: list[dict] = []
+    legacy_insights: list[dict] = []
+    metric_mappings = insight_mappings = None
+    if config.include_metrics:
+        metric_mappings = _load_mappings(config, config.metric_mapping_file, "Metric")
+        legacy_metrics = fetch_objects_with_filters(
+            legacy_client, "metric", filter_params, "metrics"
+        )
+    if config.include_insights:
+        insight_mappings = _load_mappings(
+            config, config.insight_mapping_file, "Insight"
+        )
+        legacy_insights = fetch_objects_with_filters(
+            legacy_client, "visualizationObject", filter_params, "insights"
+        )
+
     # Build context and create and instance of PermissionsUpdater
-    context = _build_context(config, legacy_client, cloud_client, dashboard_mappings)
+    context = _build_context(
+        config,
+        legacy_client,
+        cloud_client,
+        dashboard_mappings,
+        metric_mappings,
+        insight_mappings,
+    )
     permissions_updater = PermissionsUpdater(context)
 
-    # Process dashboards and build object updates
+    # Process objects and build layout updates
     object_updates, skip_stats = permissions_updater.process_dashboards(
-        legacy_dashboards
+        legacy_dashboards, legacy_metrics, legacy_insights
     )
 
     # Log skip statistics
@@ -329,7 +364,7 @@ def migrate_dashboard_permissions(config: DashboardPermissionsConfig):
         logger.info("----No objects to update----")
         legacy_client.logout()
         return
-    logger.info("Found mappings for %d dashboards", len(object_updates))
+    logger.info("Found mappings for %d objects", len(object_updates))
 
     # Apply updates if needed
     actual_changes = _apply_updates_if_needed(
diff --git a/tests/test_layout_manager.py b/tests/test_layout_manager.py
new file mode 100644
index 0000000..f1970a5
--- /dev/null
+++ b/tests/test_layout_manager.py
@@ -0,0 +1,76 @@
+# (C) 2026 GoodData Corporation
+"""Creator/modifier updates in the Cloud layout for dashboards, metrics, insights."""
+
+from typing import Any
+
+from gooddata_legacy2cloud.layout.layout_manager import (
+    update_object_creators_in_layout,
+)
+from gooddata_legacy2cloud.user_management.data_classes import ObjectUpdate
+from gooddata_legacy2cloud.user_management.legacy_users import (
+    extract_creator_modifier_ids,
+)
+
+OLD = {"id": "old", "type": "user"}
+
+
+def _update(object_type: str, cloud_id: str, modifier: str | None) -> ObjectUpdate:
+    return ObjectUpdate(
+        legacy_object_id=cloud_id,
+        legacy_object_title=cloud_id,
+        cloud_object_id=cloud_id,
+        object_type=object_type,
+        legacy_creator_id="legacy-a",
+        legacy_modifier_id="legacy-c" if modifier else None,
+        cloud_creator_id="author",
+        cloud_modifier_id=modifier,
+    )
+
+
+def test_creators_updated_for_all_object_types() -> None:
+    layout: dict[str, dict[str, list[dict[str, Any]]]] = {
+        "analytics": {
+            "analyticalDashboards": [
+                {"id": "d1", "title": "D", "createdBy": OLD, "modifiedBy": OLD}
+            ],
+            "metrics": [
+                {"id": "m1", "title": "M", "createdBy": OLD, "modifiedBy": OLD}
+            ],
+            "visualizationObjects": [{"id": "i1", "title": "I", "createdBy": OLD}],
+        }
+    }
+    updates = [
+        _update("dashboard", "d1", "contributor"),
+        _update("metric", "m1", None),
+        _update("insight", "i1", "contributor"),
+        _update("metric", "missing", None),
+    ]
+    _, made, not_found, changes = update_object_creators_in_layout(layout, updates)
+    a = layout["analytics"]
+    assert (made, not_found) == (3, 1)
+    assert a["analyticalDashboards"][0]["createdBy"]["id"] == "author"
+    assert a["analyticalDashboards"][0]["modifiedBy"]["id"] == "contributor"
+    assert a["analyticalDashboards"][0]["permissions"][0]["assignee"]["id"] == "author"
+    assert a["metrics"][0]["modifiedBy"]["id"] == "author"  # no modifier -> creator
+    assert a["visualizationObjects"][0]["createdBy"]["id"] == "author"
+    assert "modifiedBy" not in a["visualizationObjects"][0]
+    assert "permissions" not in a["metrics"][0]
+    assert {c.object_type for c in changes if c.change_type == "creator_updated"} == {
+        "dashboard",
+        "metric",
+        "insight",
+    }
+
+
+def test_contributor_is_collected_as_modifier() -> None:
+    objects = [
+        {
+            "metric": {
+                "meta": {
+                    "author": "/gdc/account/profile/aaa",
+                    "contributor": "/gdc/account/profile/bbb",
+                }
+            }
+        }
+    ]
+    assert extract_creator_modifier_ids(objects) == {"aaa", "bbb"}