Data Relationships Framework

  • Release version: Yokohama
  • Updated January 30, 2025
  • 5 minutes to read
    • Summarize
    Summarized using AI
    This content was generated using new OpenAI-powered functionality. Results are provided on an as is basis and are not guaranteed to be accurate or complete.

    Summary of Data Relationships Framework

    The Data Relationships Framework (applicationsngrcrelconfig) is integrated with the Business Continuity Management (BCM) application starting from the Yokohama release. It provides a foundational framework to fetch and manage dependencies for Business Impact Analyses (BIAs), plans, and events by sourcing data from CMDB, BIA, and Business Continuity Plans (BCP).

    Show full answer Show less

    The framework enables configuration of main object types (main nodes) and their relationships with child nodes, allowing BCM users to efficiently track and update dependencies across different sources. A scheduled job regularly scans and retrieves updated dependencies to maintain accurate relationship data.

    Key Features

    • Unified API: Offers a single API to fetch dependencies from multiple configured sources (BIA, BCP, CMDB).
    • Main Node Configuration: Allows BCM administrators to define main nodes including their source, table name, and filters to control how and what dependency data is retrieved.
    • Node Relationship Configuration: Supports defining how main nodes relate to child nodes such as assets, risks, or other objects to build comprehensive dependency maps.
    • Scheduled Dependency Updates: Automatically detects changes and fetches updated dependency data to ensure plans and events reflect current relationships.
    • Role-Based Access: Includes roles for administrators to configure relationships and readers who can view relationship data; all BCM users have reader access by default.
    • Configuration Tables: Utilizes new tables for main node and node relationship configurations and existing relationship registries to store and manage dependency data systematically.
    • Performance Control: Enables selection of data sources and filtering conditions to optimize data retrieval and system performance.

    Practical Use and Configuration

    BCM administrators can configure dependency sources via modules such as Main Node Configuration and Relationship Registries within the Data Relationships Framework. These configurations define where and how dependency data is pulled, including impact analysis, planning, and event dependency updates. Conditions set within configurations help limit retrieved data to necessary information only.

    For example, the framework can map incidents as main nodes to affected assets and associated risks as child nodes, creating a clear, multi-level dependency graph that supports BCM decision-making.

    Limitations

    • Fetched dependency data is specific to its configured use and cannot be repurposed for other contexts.
    • Only the predefined sources within the framework can be used for fetching dependency updates; custom sources cannot be added.

    Next Steps for Customers

    • Create Main Node Configuration Records: Define sources and filtering criteria to specify how dependencies are fetched for your BCM objects.
    • Update Node Relationship Configurations: Specify relationships between main nodes and child nodes to accurately represent dependencies.
    • Create Relationship Registry Records: Set up how different object types relate to each other within the BCM context.
    • Configure Framework Properties: Adjust settings to fine-tune framework behavior according to organizational needs.

    By leveraging the Data Relationships Framework, ServiceNow BCM customers can achieve streamlined, automated dependency management across BIAs, plans, and events, enhancing the accuracy and responsiveness of continuity planning and response activities.

    The Data Relationships Framework application (sn_grc_rel_config) supports the BCM application with the underlying framework to fetch the dependencies in the BIAs, plans, and events from different sources such as CMDB, BIA, and BCP. Beginning with the Yokohama release, the Data Relationships Framework (sn_grc_rel_config) application is installed with the BCM application by default.

    Framework for fetching the dependencies

    The Data Relationships Framework (sn_grc_rel_config) stores the configurations for how a main object type can relate to other object types. It enables the users to configure the source (main node) for the dependency updates, configure its relationship with the child nodes, and fetch the dependencies for the selected object.

    A scheduled job scans the object configuration data at regular intervals and checks if any dependencies have been updated. If any changes are observed in the dependencies, the scheduled job fetches the dependencies of the selected object from one of the configured sources such as BIA, BCP, or CMDB.

    Benefits of the Data Relationships Framework

    The Data Relationships Framework provides the following benefits for the BCM application users:
    • Provides a single API to fetch the dependencies from different sources.
    • Supports the configuration of the main node (source) and maintains its relationships with its child nodes such as assets, risks, and so on.
    • Enables the users to control the performance by selecting different sources.

    Roles associated with the Data Relationships Framework

    The following roles are associated with the Data Relationships Framework application.
    Table 1. Roles associated with the Data Relationships Framework
    Roles Description
    Data Relationships Framework administrator [sn_grc_rel_config.admin] Configures the relationship of the object types such as the relationship of the main node to the child nodes.
    Data Relationships Framework reader [sn_grc_rel_config.reader] Views the data for the object types as defined in the Data Relationships Framework.
    Note:
    All BCM application users have the Data Relationships Framework reader role.

    Tables for the framework

    To support the Data Relationships Framework, the following new tables have been added and existing tables have been revised.
    Table 2. Tables used for the Data Relationships Framework
    New and existing tables Table Description
    New table Main node configuration [sn_grc_rel_config_main_node_confi] Table to store the configuration of the main node from where the dependencies are fetched.
    New table Node relationship configuration [sn_grc_rel_config_node_rel_config] Table to store the configuration that determines the dependencies of the main node and child nodes. It also maintains a reference to the main node configuration.
    Existing table Relationship registries [sn_data_registry_relationship] Table to determine the relationship of an object with other objects.

    Modules for configuring the relationships

    The BCM application users can navigate to Data Relationship Framework in the application navigator and access its modules for configuring the relationships.

    Module path.

    The Data Relationships Framework application consists of the following modules:

    1. Main node configuration: Configure the details of the main node such as its name, source, table name, filter conditions, and so on as shown in the following examples.

      Main node configuration.

      The following main node configurations are provided as sources with the base system as shown in the following example:

      Base system configuration.

      • BIA upstream dependency
      • BIA downstream dependencies
      • CMDB
      • Plan primary assets
      • Plan related assets
      The BCM administrators use the main node configuration to perform the following tasks:
      • Configure the Impact analysis dependency update configuration module and fetch the dependency updates into a BIA (add the dependency updates to the BIA) from these sources.Sources.
      • Configure the Planning dependency update configuration module and fetch the planning dependency updates into a plan (add the updated related assets to the plan) from these sources.
      • Configure the Event dependency source configuration module and configure the sources for the event dependency updates (add the updated impacted assets to a recovery event).
      Note:
      All the information on how data should be pulled is stored in the Main node configuration, which is attached to the records. This configuration determines the order in which the data is pulled. To reduce the amount of data pulled and how it is pulled, you must configure the conditions in both the Main node configuration and the records. This verifies that only the necessary data is retrieved.

      The main node configuration records for plans and CMDB are shown in the following examples.

      Main node configuration for a BCP.

      Sample main node configuration.

      For information on creating a main node configuration record, see Create a main node configuration record.

    2. Relationship registries: Configure the relationship registries for the main node. Relationship registries are part of the 360-degree configuration in GRC where a user can define how one object has a related object. The configuration details of a relationship registry record such as its name, table, relationship type, relationship table, and so on are shown in the form.

      New relationship registry record.

      A sample relationship registry record for a BIA and BIA template is shown in the following example.

      Sample relationship registry record.

      For information on creating a relationship registry record, see Create a relationship registry record.

    3. Properties: Configure the properties of the Data Relationships Framework as shown in the following example.

      Properties for the Data Relationship Framework.

      For information on configuring the properties, see Configure the properties for the Data Relationships Framework.

    Use cases for the Data Relationships Framework

    The Data Relationships Framework is used to configure the node and asset relationships such as mapping a main node to its child node or mapping an asset to a risk.

    Consider the following use case that shows the main node configuration and its relationships.

    Data relationship framework.

    In this example, INC1010 is the main node where the source is an Incident. INC1010 has two child nodes:
    1. Asset A: The affected configuration item for Asset A is Risk A.
    2. INC1011: The affected configuration items (CIs) for INC1011 are Asset B and Asset C. For Asset B, the affected configuration item is Risk B.
    With the underlying Data Relationships Framework, the following relationships are configured:
    • Main nodes:
      • INC1010 -> Asset A
      • INC1010 -> INC1011
    • Node relationships:
      • Asset A -> Risk A
      • INC1011 -> Asset B
      • INC1011 -> Asset C
      • Asset B -> Risk B
    • Input nodes:
      • Source = Incident
      • Record = INC1010
      • Max Levels = 5
      • Max Nodes = 1000
    • Output nodes:
      • INC1010
      • Asset A
      • INC1011
      • Risk A
      • Asset B
      • Asset C
      • Risk B
    • Edges:
      • INC1010 -> Asset A
      • INC1010 -> INC1011
      • Asset A -> Risk A
      • INC1011 -> Asset B
      • INC1011 -> Asset C
      • Asset B -> Risk B

    Limitations of using the Data Relationships Framework

    The Data Relationships Framework has the following limitations:
    • The data fetched for an object cannot be reused for another purpose.
    • The sources provided in the framework must be used for fetching the dependency updates into an object. It is not possible to configure your own sources for fetching the data.

    For more information on the administrative setup for the configuration records, see Dependency Configuration records.