cmdbsyncer 4.1.0.dev14__tar.gz → 4.1.0.dev15__tar.gz

{cmdbsyncer-4.1.0.dev14 → cmdbsyncer-4.1.0.dev15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmdbsyncer
-Version: 4.1.0.dev14
+Version: 4.1.0.dev15
 Summary: Rule-based modular synchronizer for Checkmk, Netbox, Ansible, I-DOIT, Jira CMDB and 15+ other CMDB/monitoring systems
 Author-email: Kuhn & Ruess GmbH <info@kuhn-ruess.de>
 Maintainer-email: Bastian Kuhn <mail@bastian-kuhn.de>

cmdbsyncer-4.1.0.dev15/application/buildinfo.txt

@@ -0,0 +1 @@
+BUILD_DATE=2026-05-12T15:19:26Z

{cmdbsyncer-4.1.0.dev14 → cmdbsyncer-4.1.0.dev15}/application/changelog/v4.1.md

@@ -53,8 +53,12 @@
 - FEAT: Quick-search on Rule Management matches name and ruleset
 - FIX: Saving a rule with outcomes that target different rulesets is rejected with a flash
 - FEAT: New "Manage Notification Rules" view exports notification rules to Checkmk 2.4 / 2.5 with `cmdbsyncer checkmk export_notifications`; admin edits are detected and corrected on the next run
+- FIX: Host debug page — clicking the "Setup Rules" group on a Checkmk host now expands its rule table (the space in the group name was breaking the collapse anchor)
 - FIX: HW/SW inventorize fetches the inventory tree via the REST API's `host_mk_inventory` Livestatus column instead of the legacy `host_inv_api.py` endpoint — works behind OIDC/SSO proxies that block the Multisite path. Parses both Checkmk 2.5's JSON blob and older releases' Python-repr blob. Each multiprocessing worker also gets its own MongoDB connection, and on failure the failing hostname, exception type and full traceback are reported instead of a misleading "Timeout error"
 
+### Jira
+- FEAT: Jira Cloud plugin can now export host fields to Jira Assets objects. Configure target object type and per-attribute field mapping (with autocomplete from the cached Jira schema) in Modules → Jira Cloud → Export Rules, run with `cmdbsyncer jira sync_schema <account>` and `cmdbsyncer jira export_cloud <account>`. Multiple rules let one run write to several object types; create-on-missing is opt-in and unchanged objects are not re-sent
+
 ### API
 - FEAT: `/api/v1/objects/<hostname>/relations` reads, adds and removes typed Host relations (CMDB_MODE only)
 - FIX: `/api/v1/objects/all` rejects `limit > 10000`

cmdbsyncer-4.1.0.dev15/application/plugins/jira_cloud/__init__.py

@@ -0,0 +1,60 @@
+"""Jira Cloud plugin."""
+import click
+from application.plugins.jira import jira_cli
+
+from syncerapi.v1 import (
+    register_cronjob,
+)
+
+from .jira_cloud import import_jira_cloud
+from .export import export_jira_cloud
+from .schema_sync import sync_jira_schema
+
+@jira_cli.command('import_cloud')
+@click.argument("account")
+@click.option("--debug", is_flag=True)
+def cmd_import_jira(account, debug):
+    """
+    Import from Cloud Instance
+    """
+    try:
+        import_jira_cloud(account, debug)
+    except Exception as error:  # pylint: disable=broad-exception-caught
+        if debug:
+            raise
+        print(f"Error: {error}")
+
+
+@jira_cli.command('export_cloud')
+@click.argument("account")
+@click.option("--debug", is_flag=True)
+def cmd_export_jira(account, debug):
+    """
+    Export Hosts/Fields to a Jira Cloud Assets Instance
+    """
+    try:
+        export_jira_cloud(account, debug)
+    except Exception as error:  # pylint: disable=broad-exception-caught
+        if debug:
+            raise
+        print(f"Error: {error}")
+
+
+@jira_cli.command('sync_schema')
+@click.argument("account")
+@click.option("--debug", is_flag=True)
+def cmd_sync_jira_schema(account, debug):
+    """
+    Cache the Jira Cloud Assets schema (used by the export GUI / plugin)
+    """
+    try:
+        sync_jira_schema(account, debug)
+    except Exception as error:  # pylint: disable=broad-exception-caught
+        if debug:
+            raise
+        print(f"Error: {error}")
+
+
+register_cronjob('Jira Cloud: Import Hosts', import_jira_cloud)
+register_cronjob('Jira Cloud: Export Objects', export_jira_cloud)
+register_cronjob('Jira Cloud: Sync Schema', sync_jira_schema)

cmdbsyncer-4.1.0.dev15/application/plugins/jira_cloud/admin_views.py

@@ -0,0 +1,39 @@
+"""Flask-Admin registration for the Jira Cloud Export views."""
+from application.modules.rule.views import RewriteAttributeView
+
+from .views import (
+    JiraCloudFilterView,
+    JiraExportRuleView,
+    JiraSchemaCacheView,
+)
+from .models import (
+    JiraCloudFilterRule,
+    JiraCloudRewriteAttributeRule,
+    JiraExportRule,
+    JiraSchemaCache,
+)
+
+
+def register_admin_views(admin):
+    """Register the Jira Cloud submenu."""
+    admin.add_sub_category(name="Jira Cloud", parent_name="Modules")
+
+    admin.add_view(JiraCloudFilterView(
+        JiraCloudFilterRule,
+        name="Filter", category="Jira Cloud",
+        menu_icon_type='fa', menu_icon_value='fa-filter'))
+
+    admin.add_view(RewriteAttributeView(
+        JiraCloudRewriteAttributeRule,
+        name="Rewrite Attributes", category="Jira Cloud",
+        menu_icon_type='fa', menu_icon_value='fa-exchange'))
+
+    admin.add_view(JiraExportRuleView(
+        JiraExportRule,
+        name="Export Rules", category="Jira Cloud",
+        menu_icon_type='fa', menu_icon_value='fa-upload'))
+
+    admin.add_view(JiraSchemaCacheView(
+        JiraSchemaCache,
+        name="Schema Cache", category="Jira Cloud",
+        menu_icon_type='fa', menu_icon_value='fa-database'))

cmdbsyncer-4.1.0.dev15/application/plugins/jira_cloud/export.py

@@ -0,0 +1,303 @@
+"""
+Export host attributes to Jira Cloud Assets objects.
+
+Every enabled JiraExportRule is loaded into a single rule engine, every
+referenced object type's existing objects are bulk-fetched once via AQL,
+and hosts are iterated exactly once.  Per host the engine merges all
+matching rules' outcomes; we then walk the resulting per-type field
+bundles, diff against the cached existing values and only PUT/POST when
+something actually changed.
+
+The lookup attribute is always "Name" — Jira Assets' default label
+attribute on every object type.
+"""
+# pylint: disable=too-many-locals,too-many-branches,too-many-nested-blocks
+# pylint: disable=too-many-statements
+import json
+from collections import defaultdict
+
+from rich.progress import Progress, SpinnerColumn, MofNCompleteColumn, TimeElapsedColumn
+
+from syncerapi.v1 import (
+    Host,
+    cc,
+)
+
+from application import logger
+from application.modules.rule.filter import Filter
+from application.modules.rule.rewrite import Rewrite
+from application.plugins.jira_cloud.jira_cloud import JiraCloud
+from application.plugins.jira_cloud.models import (
+    JiraCloudFilterRule,
+    JiraCloudRewriteAttributeRule,
+    JiraExportRule,
+    JiraSchemaCache,
+)
+from application.plugins.jira_cloud.rules import JiraExportAttributeRule
+
+
+LOOKUP_ATTRIBUTE_NAME = "Name"
+
+
+class JiraCloudExport(JiraCloud):
+    """Export driver."""
+
+    name = "Jira Cloud: Export Objects"
+    source = "jira_cloud_export"
+
+    def __init__(self, account):
+        super().__init__(account)
+        self._schema_cache = None
+        # type_id -> (type_entry, name_to_id, lookup_attr_id, existing_map)
+        self._type_state = {}
+
+        # Honour rewrite + filter rules the same way Checkmk does —
+        # the Plugin base class calls them inside `get_attributes`, so
+        # we don't have to invoke them anywhere in here.
+        self.rewrite = Rewrite()
+        self.rewrite.cache_name = "jira_cloud_rewrite"
+        self.rewrite.rules = (
+            JiraCloudRewriteAttributeRule
+            .objects(enabled=True).order_by('sort_field'))
+
+        self.filter = Filter()
+        self.filter.cache_name = "jira_cloud_filter"
+        self.filter.rules = JiraCloudFilterRule.objects(enabled=True).order_by('sort_field')
+
+    def _load_schema(self):
+        """Cache lookup for the persisted schema; fail loud if missing."""
+        if self._schema_cache is None:
+            doc = JiraSchemaCache.objects(account=self.account_name).first()
+            if not doc:
+                raise ValueError(
+                    f"No Jira schema cache for account '{self.account_name}'. "
+                    f"Run `cmdbsyncer jira sync_schema {self.account_name}` first."
+                )
+            self._schema_cache = doc
+        return self._schema_cache
+
+    def _get_type(self, object_type_id):
+        """Return the cached object type or None."""
+        for entry in self._load_schema().object_types:
+            if entry.object_type_id == object_type_id:
+                return entry
+        return None
+
+    def _build_payload(self, object_type_id, attr_values):
+        """Translate {attribute_id: value} into the Atlassian write format."""
+        return {
+            "objectTypeId": str(object_type_id),
+            "attributes": [
+                {
+                    "objectTypeAttributeId": str(attr_id),
+                    "objectAttributeValues": [{"value": str(value)}],
+                }
+                for attr_id, value in attr_values.items()
+            ],
+        }
+
+    def _existing_objects(self, type_name, lookup_attr_id):
+        """
+        Map ``{lookup_value: (object_id, {attr_id: current_value})}`` for
+        every existing object of the target type.
+
+        The AQL response carries attributes only by id (no name), so the
+        caller resolves the lookup attribute's id from the schema cache
+        and passes it in.
+        """
+        existing = {}
+        ql = f'objectType = "{type_name}"'
+        for obj in self._iter_aql_objects(ql):
+            current_attrs = {}
+            lookup_value = None
+            for attr in obj.get('attributes', []):
+                attr_id = int(attr.get('objectTypeAttributeId', 0))
+                values = attr.get('objectAttributeValues') or []
+                if not values:
+                    continue
+                value = values[0].get('value')
+                current_attrs[attr_id] = value
+                if attr_id == lookup_attr_id:
+                    lookup_value = value
+            if lookup_value is not None:
+                existing[lookup_value] = (obj['id'], current_attrs)
+        return existing
+
+    def _prepare_type(self, object_type_id):
+        """
+        Load schema + existing objects for one object type and remember
+        the state.  Returns the state tuple or ``None`` when the type or
+        its ``Name`` attribute isn't cached.
+        """
+        if object_type_id in self._type_state:
+            return self._type_state[object_type_id]
+
+        type_entry = self._get_type(object_type_id)
+        if not type_entry:
+            print(f"{cc.WARNING} -- {cc.ENDC}object_type_id={object_type_id} "
+                  f"not in schema cache, skipping its outcomes")
+            self._type_state[object_type_id] = None
+            return None
+
+        name_to_id = {a.name: a.attribute_id for a in type_entry.attributes}
+        if LOOKUP_ATTRIBUTE_NAME not in name_to_id:
+            print(f"{cc.WARNING} -- {cc.ENDC}'{type_entry.name}' has no "
+                  f"'{LOOKUP_ATTRIBUTE_NAME}' attribute, skipping its outcomes")
+            self._type_state[object_type_id] = None
+            return None
+        lookup_attr_id = name_to_id[LOOKUP_ATTRIBUTE_NAME]
+
+        print(f"{cc.OKGREEN} -- {cc.ENDC}Preparing "
+              f"{type_entry.schema_name} / {type_entry.name} "
+              f"(type id {object_type_id})")
+        existing = self._existing_objects(type_entry.name, lookup_attr_id)
+        print(f"{cc.OKGREEN}  + {cc.ENDC}{len(existing)} existing object(s) loaded")
+
+        state = (type_entry, name_to_id, lookup_attr_id, existing)
+        self._type_state[object_type_id] = state
+        return state
+
+    def _put_object(self, object_id, object_type_id, attr_values):
+        """Update an existing Jira Assets object."""
+        payload = self._build_payload(object_type_id, attr_values)
+        self.inner_request(
+            method="PUT",
+            url=f"{self.base_url}/v1/object/{object_id}",
+            headers=self.headers, auth=self.auth,
+            data=json.dumps(payload),
+        )
+
+    def _post_object(self, object_type_id, attr_values):
+        """Create a new Jira Assets object."""
+        payload = self._build_payload(object_type_id, attr_values)
+        self.inner_request(
+            method="POST",
+            url=f"{self.base_url}/v1/object/create",
+            headers=self.headers, auth=self.auth,
+            data=json.dumps(payload),
+        )
+
+    def export_objects(self):
+        """Single-pass export: prepare types, iterate hosts once."""
+        rules = list(JiraExportRule.objects(enabled=True).order_by('sort_field'))
+        if not rules:
+            print(f"{cc.WARNING} -- {cc.ENDC}No enabled JiraExportRule rows, "
+                  f"nothing to do")
+            return
+
+        all_type_ids = sorted({
+            type_id
+            for r in rules
+            for o in (r.outcomes or [])
+            if (type_id := o.object_type_id) is not None
+        })
+        if not all_type_ids:
+            print(f"{cc.WARNING} -- {cc.ENDC}No outcomes on any enabled rule, "
+                  f"nothing to do")
+            return
+
+        for type_id in all_type_ids:
+            self._prepare_type(type_id)
+
+        rule_engine = JiraExportAttributeRule()
+        rule_engine.rules = rules
+        rule_engine.debug = self.debug
+        rule_engine.name = self.name
+        cache_key = "jira_cloud_export"
+
+        # Honour the per-account object_filter the user picks on the
+        # Account → Plugin Settings line for this plugin, same as every
+        # other outbound syncer.
+        object_filter = self.config.get('settings', {}).get(self.name, {}).get('filter')
+        db_objects = Host.objects_by_filter(object_filter)
+        total = db_objects.count()
+        counts = defaultdict(lambda: {"updated": 0, "created": 0,
+                                      "unchanged": 0, "skipped": 0})
+
+        with Progress(SpinnerColumn(), MofNCompleteColumn(),
+                      *Progress.get_default_columns(),
+                      TimeElapsedColumn()) as progress:
+            console = progress.console.print
+            task = progress.add_task("Jira Cloud export", total=total)
+            for db_host in db_objects:
+                progress.advance(task)
+                try:
+                    self._process_host(db_host, rule_engine, cache_key,
+                                       counts, console)
+                except Exception as error:  # pylint: disable=broad-exception-caught
+                    if self.debug:
+                        raise
+                    logger.exception("Export failed for %s", db_host.hostname)
+                    self.log_details.append(
+                        (f'export_error {db_host.hostname}', str(error)))
+
+        for type_id in all_type_ids:
+            c = counts[type_id]
+            summary = (f"updated={c['updated']} created={c['created']} "
+                       f"unchanged={c['unchanged']} skipped={c['skipped']}")
+            type_entry = self._get_type(type_id)
+            label = type_entry.name if type_entry else f"type {type_id}"
+            print(f"{cc.OKGREEN} == {cc.ENDC}{label} [type {type_id}]: {summary}")
+            self.log_details.append((f'type {type_id}', summary))
+
+    # pylint: disable-next=too-many-arguments,too-many-positional-arguments
+    def _process_host(self, db_host, rule_engine, cache_key, counts, console):
+        """Apply every matching rule to one host."""
+        attrs = self.get_attributes(db_host, cache_key)
+        if not attrs:
+            return
+        outcomes = rule_engine.get_outcomes(db_host, attrs['all'])
+        fields_by_type = outcomes.get('fields_by_type') or {}
+        if not fields_by_type:
+            return
+        lookup_value = db_host.hostname
+
+        for type_id_str, fields in fields_by_type.items():
+            type_id = int(type_id_str)
+            state = self._type_state.get(type_id)
+            if not state:
+                counts[type_id]["skipped"] += 1
+                continue
+            _entry, name_to_id, lookup_attr_id, existing = state
+
+            target_attrs = {}
+            unknown = []
+            for name, value in fields.items():
+                if name not in name_to_id:
+                    unknown.append(name)
+                    continue
+                target_attrs[name_to_id[name]] = value
+            if unknown:
+                console(f"{cc.WARNING}   ? {cc.ENDC}"
+                        f"{db_host.hostname} [type {type_id}]: "
+                        f"unknown Jira attribute(s) {unknown}")
+            if not target_attrs:
+                counts[type_id]["skipped"] += 1
+                continue
+
+            if lookup_value in existing:
+                obj_id, current = existing[lookup_value]
+                changed = {a: v for a, v in target_attrs.items()
+                           if str(current.get(a, '')) != str(v)}
+                if not changed:
+                    counts[type_id]["unchanged"] += 1
+                    continue
+                self._put_object(obj_id, type_id, changed)
+                console(f"{cc.OKGREEN}   ↻ {cc.ENDC}"
+                        f"{db_host.hostname} [type {type_id}] "
+                        f"({len(changed)} field(s))")
+                counts[type_id]["updated"] += 1
+            else:
+                if lookup_attr_id not in target_attrs:
+                    target_attrs[lookup_attr_id] = lookup_value
+                self._post_object(type_id, target_attrs)
+                console(f"{cc.OKBLUE}   + {cc.ENDC}"
+                        f"{db_host.hostname} [type {type_id}] (created)")
+                counts[type_id]["created"] += 1
+
+
+def export_jira_cloud(account, debug=False):
+    """Entry point for CLI / cronjob."""
+    syncer = JiraCloudExport(account)
+    syncer.debug = debug
+    syncer.export_objects()

cmdbsyncer-4.1.0.dev15/application/plugins/jira_cloud/models.py

@@ -0,0 +1,159 @@
+"""
+Jira Cloud Export Models
+"""
+# pylint: disable=too-few-public-methods
+from application import db
+from application.modules.rule.models import rule_types
+
+
+class JiraExportOutcome(db.EmbeddedDocument):
+    """
+    One field mapping: a Jira attribute on a specific object type
+    receives a (Jinja-rendered) value.
+
+    Object type and attribute are stored together in a single ``target``
+    string of the form ``"<object_type_id>|<attribute_name>"``.  In
+    Jira Assets, attributes belong to their type — attribute "Name" on
+    "Hardware Server" is a different attribute from "Name" on
+    "Laptop", with different ids — so the GUI presents a single
+    dropdown over all (type, attribute) pairs and that's what we store.
+    """
+    target = db.StringField(required=True)
+    value = db.StringField()
+    meta = {
+        'strict': False,
+    }
+
+    @property
+    def object_type_id(self):
+        """Convenience accessor: int part of ``target``."""
+        if not self.target or '|' not in self.target:
+            return None
+        try:
+            return int(self.target.split('|', 1)[0])
+        except (ValueError, TypeError):
+            return None
+
+    @property
+    def jira_attribute(self):
+        """Convenience accessor: name part of ``target``."""
+        if not self.target or '|' not in self.target:
+            return ''
+        return self.target.split('|', 1)[1]
+
+
+class JiraExportRule(db.Document):
+    """
+    Defines which hosts get exported to Jira Cloud Assets and which
+    fields are written.
+
+    The set of target object types follows from the rule's outcomes
+    (one outcome = one field on one object type) — a single rule may
+    cover several object types at once.
+    """
+    name = db.StringField(required=True, unique=True)
+    documentation = db.StringField()
+
+    condition_typ = db.StringField(choices=rule_types)
+    conditions = db.ListField(field=db.EmbeddedDocumentField(document_type='FullCondition'))
+    render_full_conditions = db.StringField()  # GUI preview helper
+
+    outcomes = db.ListField(field=db.EmbeddedDocumentField(document_type='JiraExportOutcome'))
+    render_jira_export_outcome = db.StringField()  # GUI preview helper
+
+    last_match = db.BooleanField(default=False)
+    enabled = db.BooleanField(default=True)
+    sort_field = db.IntField(default=0)
+    meta = {
+        'strict': False,
+    }
+
+
+class JiraCloudRewriteAttributeRule(db.Document):
+    """
+    Rewrite host attribute keys/values before the export rule engine
+    evaluates them — mirrors the Checkmk / Netbox rewrite pattern.
+    """
+    name = db.StringField()
+    documentation = db.StringField()
+
+    condition_typ = db.StringField(choices=rule_types)
+    conditions = db.ListField(field=db.EmbeddedDocumentField(document_type='FullCondition'))
+    render_full_conditions = db.StringField()  # GUI preview helper
+
+    outcomes = db.ListField(
+        field=db.EmbeddedDocumentField(document_type='AttributeRewriteAction'))
+    render_attribute_rewrite = db.StringField()  # GUI preview helper
+
+    last_match = db.BooleanField(default=False)
+    enabled = db.BooleanField(default=True)
+    sort_field = db.IntField(default=0)
+    meta = {
+        'strict': False,
+    }
+
+
+class JiraCloudFilterRule(db.Document):
+    """
+    Exclude hosts from the Jira Cloud export.
+
+    Mirrors the Checkmk pattern: hosts matching this rule (any
+    ``ignore_hosts`` filter action) are dropped by the Plugin base
+    class's ``get_attributes`` before the export rule engine sees them.
+    """
+    name = db.StringField(required=True, unique=True)
+    documentation = db.StringField()
+    condition_typ = db.StringField(choices=rule_types)
+    conditions = db.ListField(field=db.EmbeddedDocumentField(document_type="FullCondition"))
+    render_full_conditions = db.StringField()  # GUI preview helper
+
+    outcomes = db.ListField(field=db.EmbeddedDocumentField(document_type="FilterAction"))
+    render_filter_outcome = db.StringField()  # GUI preview helper
+
+    last_match = db.BooleanField(default=False)
+    enabled = db.BooleanField(default=True)
+    sort_field = db.IntField(default=0)
+
+    meta = {
+        'strict': False,
+    }
+
+
+class JiraSchemaAttribute(db.EmbeddedDocument):
+    """One attribute belonging to an object type."""
+    attribute_id = db.IntField(required=True)
+    name = db.StringField(required=True)
+    type_name = db.StringField()
+    editable = db.BooleanField(default=True)
+    meta = {
+        'strict': False,
+    }
+
+
+class JiraSchemaObjectType(db.EmbeddedDocument):
+    """One Jira Assets object type with its attributes."""
+    object_type_id = db.IntField(required=True)
+    name = db.StringField(required=True)
+    schema_id = db.IntField()
+    schema_name = db.StringField()
+    attributes = db.ListField(field=db.EmbeddedDocumentField(document_type='JiraSchemaAttribute'))
+    meta = {
+        'strict': False,
+    }
+
+
+class JiraSchemaCache(db.Document):
+    """
+    Per-account snapshot of the Jira Cloud Assets schema.
+
+    Populated by `cmdbsyncer jira sync_schema <account>` and consumed by
+    the export plugin (attribute-name → id resolution, validation) and
+    by the GUI (autocomplete suggestions in the rule form).
+    """
+    account = db.StringField(required=True, unique=True)
+    updated = db.DateTimeField()
+    object_types = db.ListField(
+        field=db.EmbeddedDocumentField(document_type='JiraSchemaObjectType'))
+    meta = {
+        'strict': False,
+    }

{cmdbsyncer-4.1.0.dev14 → cmdbsyncer-4.1.0.dev15}/application/plugins/jira_cloud/plugin.json

@@ -7,8 +7,8 @@
     "account_presets" : {
     },
     "account_custom_field_presets": {
-        "workspace_id": "Required",
-        "ql_query": "Required",
+        "workspace_id": "00000000-0000-0000-0000-000000000000",
+        "ql_query": "objectType = \"Server\"",
         "verify_cert": "True",
         "ca_cert_chain": "",
         "ca_root_cert": ""

cmdbsyncer-4.1.0.dev15/application/plugins/jira_cloud/rules.py

@@ -0,0 +1,51 @@
+"""
+Jira Cloud Export Rule
+"""
+from application.modules.rule.rule import Rule
+from application.helpers.syncer_jinja import render_jinja
+
+
+class JiraExportAttributeRule(Rule):
+    """
+    Resolves the per-host outcome of one or more JiraExportRule rows.
+
+    All enabled rules are loaded into a single engine instance so the
+    export plugin can iterate hosts once and let the engine merge every
+    matching rule's outcomes per host.  Outcomes are grouped by Jira
+    object type id; missing objects are always created (filter out
+    hosts you don't want exported via a JiraCloudFilterRule).
+    """
+    name = "Jira Cloud -> Export Attributes"
+
+    def add_outcomes(self, _rule, rule_outcomes, outcomes):
+        """
+        Build per-type field bundles.
+
+        Output shape::
+
+            outcomes['fields_by_type'] = {
+                "<type_id>": {"<attr_name>": "<rendered_value>", ...},
+                ...
+            }
+
+        Mongo DictFields require string keys, so ``object_type_id`` is
+        stored as a string and converted back to int by the consumer.
+        Empty/None-rendered values are dropped so an unset host attribute
+        does not blank out a populated field in Jira.
+        """
+        outcomes.setdefault('fields_by_type', {})
+        for outcome in rule_outcomes:
+            target = (outcome.get('target') or '').strip()
+            if '|' not in target:
+                continue
+            type_id_str, attr = target.split('|', 1)
+            attr = attr.strip()
+            if not type_id_str or not attr:
+                continue
+            template = outcome.get('value') or ''
+            rendered = render_jinja(template, mode="nullify", **self.attributes)
+            rendered = (rendered or '').strip()
+            if rendered in ('', 'None'):
+                continue
+            outcomes['fields_by_type'].setdefault(type_id_str, {})[attr] = rendered
+        return outcomes