Skip to main content
Version: Next

Dashboard

Dashboards are collections of visualizations and charts that provide insights into data. In DataHub, dashboards represent collections of charts (visualizations) typically found in Business Intelligence (BI) platforms and data visualization tools. Dashboards are typically ingested from platforms like Looker, Tableau, PowerBI, Superset, Mode, Grafana, and other BI tools.

Identity​

Dashboards are identified by two pieces of information:

  • The platform that they belong to: This is the specific BI tool or dashboarding platform that hosts the dashboard. Examples include looker, tableau, powerbi, superset, mode, etc. This corresponds to the dashboardTool field in the dashboard's key aspect.
  • The dashboard identifier in the specific platform: Each platform has its own way of uniquely identifying dashboards within its system. For example, Looker uses identifiers like dashboards.999999, while PowerBI might use GUIDs, and Tableau uses site-relative paths.

An example of a dashboard identifier is urn:li:dashboard:(looker,dashboards.999999).

For platforms with multiple instances (e.g., separate Looker deployments for different environments), the URN can include a platform instance identifier: urn:li:dashboard:(looker,dashboards.999999,prod-instance).

Important Capabilities​

Dashboard Information and Metadata​

The core metadata about a dashboard is stored in the dashboardInfo aspect. This includes:

  • Title: The display name of the dashboard (searchable, auto-complete enabled)
  • Description: A detailed description of what the dashboard shows
  • Dashboard URL: A link to view the dashboard in its native platform
  • Access Level: The access level of the dashboard (PUBLIC or PRIVATE)
  • Last Modified: Audit stamps tracking when the dashboard was created, modified, or deleted
  • Last Refreshed: Timestamp of when the dashboard data was last refreshed, including who refreshed it
  • Custom Properties: Platform-specific metadata as key-value pairs

The following code snippet shows you how to create a dashboard with basic information.

Python SDK: Create a dashboard
# Inlined from /metadata-ingestion/examples/library/dashboard_create_simple.py
from datahub.metadata.urns import TagUrn
from datahub.sdk import Dashboard, DataHubClient

client = DataHubClient.from_env()

dashboard = Dashboard(
    name="example_dashboard",
    platform="looker",
    description="looker dashboard for production",
    tags=[TagUrn(name="production"), TagUrn(name="data_engineering")],
)

client.entities.upsert(dashboard)

For more complex dashboard creation with charts and datasets:

Python SDK: Create a dashboard with charts and datasets
# Inlined from /metadata-ingestion/examples/library/dashboard_create_complex.py
from datahub.metadata.urns import TagUrn
from datahub.sdk import Chart, Dashboard, DataHubClient, Dataset

client = DataHubClient.from_env()
dashboard1 = Dashboard(
    name="example_dashboard_2",
    platform="looker",
    description="looker dashboard for production",
)
chart = Chart(
    name="example_chart",
    platform="looker",
    description="looker chart for production",
)

input_dataset = Dataset(
    name="example_dataset5",
    platform="snowflake",
    description="snowflake dataset for production",
)


dashboard2 = Dashboard(
    name="example_dashboard",
    platform="looker",
    description="looker dashboard for production",
    tags=[TagUrn(name="production"), TagUrn(name="data_engineering")],
    input_datasets=[input_dataset.urn],
    charts=[chart.urn],
    dashboards=[dashboard1.urn],
)


client.entities.upsert(dashboard1)
client.entities.upsert(chart)
client.entities.upsert(input_dataset)

client.entities.upsert(dashboard2)

Container Relationships - Charts in Dashboards​

Dashboards act as containers for charts. The dashboardInfo aspect's chartEdges field tracks which charts belong to the dashboard, creating a hierarchical relationship:

Dashboard (Container)
├── Chart 1 (Bar Chart)
├── Chart 2 (Pie Chart)
└── Chart 3 (Line Chart)

Each chart edge includes:

  • Destination URN: The URN of the chart
  • Created: Audit stamps for when the chart was added
  • Last Modified: Audit stamps for when the relationship was modified
  • Properties: Optional custom properties for the relationship

This relationship enables:

  • Navigation: Users can browse from dashboards to their constituent charts
  • Dependency Tracking: Understanding which charts belong to which dashboards
  • Metadata Propagation: Ownership and tags can be inherited from dashboard to charts
  • Impact Analysis: When a dashboard is deprecated, identify all affected charts
Python SDK: Add charts to a dashboard
# Inlined from /metadata-ingestion/examples/library/dashboard_add_charts.py
from datahub.sdk import Chart, Dashboard, DataHubClient

client = DataHubClient.from_env()

# Create charts that belong to the dashboard
chart1 = Chart(platform="looker", name="sales_by_region_chart")
chart2 = Chart(platform="looker", name="revenue_trend_chart")
chart3 = Chart(platform="looker", name="customer_count_chart")

# Create dashboard with charts
dashboard = Dashboard(
    platform="looker",
    name="sales_dashboard",
    display_name="Sales Overview Dashboard",
    description="Comprehensive sales analytics dashboard",
)

# Add charts to the dashboard
dashboard.add_chart(chart1)
dashboard.add_chart(chart2)
dashboard.add_chart(chart3)

# Upsert the dashboard (this will also create the chart relationships)
client.entities.upsert(dashboard)

Data Lineage - Dataset Dependencies​

Dashboards often consume data from one or more datasets. The dashboardInfo aspect's datasetEdges field tracks these relationships, creating Consumes relationships in the metadata graph. This enables:

  • Impact Analysis: Understanding which dashboards are affected when a dataset changes
  • Data Lineage Visualization: Showing the flow of data from source datasets through to dashboards
  • Dependency Tracking: Identifying all upstream dependencies for a dashboard
  • Compliance: Tracking which dashboards use sensitive or regulated data
Python SDK: Add dataset lineage to a dashboard
# Inlined from /metadata-ingestion/examples/library/dashboard_add_lineage.py
from datahub.sdk import Dashboard, DataHubClient, Dataset

client = DataHubClient.from_env()

# Define the source datasets
sales_dataset = Dataset(platform="bigquery", name="project.dataset.sales")
customer_dataset = Dataset(platform="bigquery", name="project.dataset.customers")
products_dataset = Dataset(platform="bigquery", name="project.dataset.products")

# Create dashboard with lineage to upstream datasets
dashboard = Dashboard(
    platform="looker",
    name="sales_dashboard",
    display_name="Sales Overview Dashboard",
    description="Dashboard showing sales metrics across regions and products",
)

# Add dataset dependencies
dashboard.add_input_dataset(sales_dataset)
dashboard.add_input_dataset(customer_dataset)
dashboard.add_input_dataset(products_dataset)

# Upsert the dashboard (this will create the Consumes relationships)
client.entities.upsert(dashboard)

Nested Dashboards​

Some platforms support dashboards that contain other dashboards (e.g., PowerBI Apps that contain multiple dashboards). The dashboardInfo aspect's dashboards field tracks these nested relationships, enabling hierarchical dashboard organization:

PowerBI App (Dashboard)
├── Sales Dashboard (Dashboard)
│   ├── Chart 1
│   └── Chart 2
└── Marketing Dashboard (Dashboard)
    ├── Chart 3
    └── Chart 4

This is particularly useful for platforms like PowerBI where Apps act as top-level containers for multiple dashboards.

Field-Level Lineage​

The inputFields aspect (optional) provides fine-grained tracking of which specific dataset fields (columns) are referenced by the dashboard. Each input field creates a consumesField relationship to a schemaField entity, enabling:

  • Column-Level Impact Analysis: Understanding which dashboards use a specific column
  • Data Sensitivity Tracking: Identifying dashboards that display sensitive fields
  • Schema Change Impact: Predicting the effect of schema changes on dashboards

Editable Properties​

DataHub separates metadata that comes from ingestion sources (in dashboardInfo) from metadata that users edit in the DataHub UI (in editableDashboardProperties). This separation ensures that:

  • User edits are preserved across ingestion runs
  • Source system metadata remains authoritative for its fields
  • Users can enhance metadata without interfering with automated ingestion

The editableDashboardProperties aspect currently supports:

  • Description: A user-provided description that supplements or overrides the ingested description
Python SDK: Update editable dashboard properties
# Inlined from /metadata-ingestion/examples/library/dashboard_update_editable.py
import datahub.metadata.schema_classes as models
from datahub.sdk import DashboardUrn, DataHubClient

client = DataHubClient.from_env()

dashboard_urn = DashboardUrn("looker", "dashboards.999999")

dashboard = client.entities.get(dashboard_urn)

current_editable = dashboard._get_aspect(models.EditableDashboardPropertiesClass)

if current_editable:
    current_editable.description = "Updated description added via DataHub UI"
else:
    current_editable = models.EditableDashboardPropertiesClass(
        description="Updated description added via DataHub UI"
    )
    dashboard._set_aspect(current_editable)

client.entities.update(dashboard)
print(f"Updated editable properties for dashboard {dashboard_urn}")

Tags and Glossary Terms​

Dashboards can have Tags or Terms attached to them. Read this blog to understand the difference between tags and terms.

Adding Tags to a Dashboard​

Tags are added to dashboards using the globalTags aspect.

Python SDK: Add a tag to a dashboard
# Inlined from /metadata-ingestion/examples/library/dashboard_add_tag.py
from datahub.sdk import DashboardUrn, DataHubClient, TagUrn

client = DataHubClient.from_env()

dashboard = client.entities.get(DashboardUrn("looker", "dashboards.999999"))

dashboard.add_tag(TagUrn("Production"))

client.entities.update(dashboard)

print(f"Added tag {TagUrn('Production')} to dashboard {dashboard.urn}")

Adding Glossary Terms to a Dashboard​

Glossary terms are added using the glossaryTerms aspect.

Python SDK: Add a glossary term to a dashboard
# Inlined from /metadata-ingestion/examples/library/dashboard_add_term.py
from datahub.metadata.urns import GlossaryTermUrn
from datahub.sdk import DashboardUrn, DataHubClient

client = DataHubClient.from_env()

dashboard = client.entities.get(DashboardUrn("looker", "dashboards.999999"))

dashboard.add_term(GlossaryTermUrn("SalesMetrics"))

client.entities.update(dashboard)

print(f"Added term {GlossaryTermUrn('SalesMetrics')} to dashboard {dashboard.urn}")

Ownership​

Ownership is associated with a dashboard using the ownership aspect. Owners can be of different types such as DATAOWNER, TECHNICAL_OWNER, BUSINESS_OWNER, etc. Ownership can be inherited from source systems or added in DataHub.

Python SDK: Add an owner to a dashboard
# Inlined from /metadata-ingestion/examples/library/dashboard_add_owner.py
from datahub.sdk import CorpUserUrn, DashboardUrn, DataHubClient

client = DataHubClient.from_env()

dashboard = client.entities.get(DashboardUrn("looker", "dashboards.999999"))

dashboard.add_owner(CorpUserUrn("jdoe"))

client.entities.update(dashboard)

print(f"Added owner {CorpUserUrn('jdoe')} to dashboard {dashboard.urn}")

Usage Statistics​

Dashboards can track usage metrics through the dashboardUsageStatistics aspect (experimental). This timeseries aspect captures:

  • Views Count: Total number of times the dashboard has been viewed
  • Executions Count: Number of times the dashboard has been refreshed or synced
  • Unique User Count: Number of distinct users who viewed the dashboard
  • Per-User Counts: Detailed usage breakdown by individual users
  • Favorites Count: Number of users who favorited the dashboard
  • Last Viewed At: Timestamp of the most recent view
  • Event Granularity: Bucketing for statistics (daily, hourly)

Usage statistics help identify:

  • Popular dashboards that might need performance optimization
  • Unused dashboards that could be deprecated
  • User engagement patterns
  • Dashboard adoption metrics
Python SDK: Add usage statistics to a dashboard
# Inlined from /metadata-ingestion/examples/library/dashboard_usage.py
from datetime import datetime
from typing import List

import datahub.metadata.schema_classes as models
from datahub.metadata.urns import CorpUserUrn
from datahub.sdk import DataHubClient
from datahub.sdk.dashboard import Dashboard

client = DataHubClient.from_env()

# Day 1: User activity and absolute usage statistics
usage_day_1_user_counts: List[models.DashboardUserUsageCountsClass] = [
    models.DashboardUserUsageCountsClass(
        user=str(CorpUserUrn("user1")),
        executionsCount=3,
        usageCount=3,
    ),
    models.DashboardUserUsageCountsClass(
        user=str(CorpUserUrn("user2")),
        executionsCount=2,
        usageCount=2,
    ),
]

usage_day_1_stats = models.DashboardUsageStatisticsClass(
    timestampMillis=round(
        datetime.strptime("2022-02-09", "%Y-%m-%d").timestamp() * 1000
    ),
    eventGranularity=models.TimeWindowSizeClass(unit=models.CalendarIntervalClass.DAY),
    uniqueUserCount=2,
    executionsCount=5,
    userCounts=usage_day_1_user_counts,
)

absolute_usage_day_1_stats = models.DashboardUsageStatisticsClass(
    timestampMillis=round(
        datetime.strptime("2022-02-09", "%Y-%m-%d").timestamp() * 1000
    ),
    favoritesCount=100,
    viewsCount=25,
    lastViewedAt=round(
        datetime.strptime("2022-02-09 04:45:30", "%Y-%m-%d %H:%M:%S").timestamp() * 1000
    ),
)

dashboard = Dashboard(
    platform="looker",
    name="dashboards.999999",
    extra_aspects=[usage_day_1_stats, absolute_usage_day_1_stats],
)

client.entities.update(dashboard)

# Day 2: Updated user activity and absolute usage statistics
usage_day_2_user_counts: List[models.DashboardUserUsageCountsClass] = [
    models.DashboardUserUsageCountsClass(
        user=str(CorpUserUrn("user1")),
        executionsCount=4,
        usageCount=4,
    ),
    models.DashboardUserUsageCountsClass(
        user=str(CorpUserUrn("user2")),
        executionsCount=6,
        usageCount=6,
    ),
]

usage_day_2_stats = models.DashboardUsageStatisticsClass(
    timestampMillis=round(
        datetime.strptime("2022-02-10", "%Y-%m-%d").timestamp() * 1000
    ),
    eventGranularity=models.TimeWindowSizeClass(unit=models.CalendarIntervalClass.DAY),
    uniqueUserCount=2,
    executionsCount=10,
    userCounts=usage_day_2_user_counts,
)

absolute_usage_day_2_stats = models.DashboardUsageStatisticsClass(
    timestampMillis=round(
        datetime.strptime("2022-02-10", "%Y-%m-%d").timestamp() * 1000
    ),
    favoritesCount=100,
    viewsCount=27,
    lastViewedAt=round(
        datetime.strptime("2022-02-10 10:45:30", "%Y-%m-%d %H:%M:%S").timestamp() * 1000
    ),
)

dashboard = Dashboard(
    platform="looker",
    name="dashboards.999999",
    extra_aspects=[usage_day_2_stats, absolute_usage_day_2_stats],
)

client.entities.update(dashboard)

# Day 3: Single user activity and absolute usage statistics
usage_day_3_user_counts: List[models.DashboardUserUsageCountsClass] = [
    models.DashboardUserUsageCountsClass(
        user=str(CorpUserUrn("user1")),
        executionsCount=2,
        usageCount=2,
    ),
]

usage_day_3_stats = models.DashboardUsageStatisticsClass(
    timestampMillis=round(
        datetime.strptime("2022-02-11", "%Y-%m-%d").timestamp() * 1000
    ),
    eventGranularity=models.TimeWindowSizeClass(unit=models.CalendarIntervalClass.DAY),
    uniqueUserCount=1,
    executionsCount=2,
    userCounts=usage_day_3_user_counts,
)

absolute_usage_day_3_stats = models.DashboardUsageStatisticsClass(
    timestampMillis=round(
        datetime.strptime("2022-02-11", "%Y-%m-%d").timestamp() * 1000
    ),
    favoritesCount=102,
    viewsCount=30,
    lastViewedAt=round(
        datetime.strptime("2022-02-11 02:45:30", "%Y-%m-%d %H:%M:%S").timestamp() * 1000
    ),
)

dashboard = Dashboard(
    platform="looker",
    name="dashboards.999999",
    extra_aspects=[usage_day_3_stats, absolute_usage_day_3_stats],
)

client.entities.update(dashboard)

Organizational Context​

Domains​

Dashboards can be organized into Domains (business areas or data products) using the domains aspect. This helps with:

  • Organizing dashboards by business function
  • Access control and governance
  • Discovery by domain experts

Container Hierarchy​

Dashboards can belong to higher-level containers (e.g., a Tableau project or PowerBI workspace). The container aspect tracks this relationship, creating a hierarchical structure:

Tableau Project (Container)
├── Sales Dashboard
├── Marketing Dashboard
└── Finance Dashboard

This hierarchy is important for:

  • Navigating related dashboards
  • Understanding organizational structure
  • Propagating metadata (like ownership) from container to dashboards

Embedding and External URLs​

The embed aspect stores URLs that allow embedding the dashboard in external applications or viewing it in its native platform. The dashboardUrl field in dashboardInfo provides a direct link to the dashboard. This supports:

  • Embedding dashboards in wikis or documentation
  • Deep linking to the dashboard in the BI tool
  • Integration with external portals

Dashboard Subtypes​

Dashboards from different platforms may have platform-specific subtypes defined in the subTypes aspect. Examples include:

  • PowerBI: PowerBI App (a container for multiple PowerBI dashboards)
  • Looker: Different Looker dashboard types
  • Tableau: Workbook types

Subtypes help users understand the platform-specific nature of the dashboard.

Integration with External Systems​

Ingestion from BI Platforms​

Dashboards are typically ingested automatically from BI platforms using DataHub's ingestion connectors:

  • Looker: Ingests dashboards and their elements (charts/looks)
  • Tableau: Ingests dashboards (workbooks) and their sheets
  • PowerBI: Ingests reports and apps (which can contain multiple dashboards)
  • Superset: Ingests dashboards with their charts
  • Mode: Ingests reports (dashboards) and queries
  • Grafana: Ingests dashboards with their panels

Each connector maps platform-specific dashboard metadata to DataHub's standardized dashboard model, including:

  • Dashboard title, description, and URL
  • Container relationships (charts within dashboards)
  • Dataset dependencies (lineage)
  • Ownership information
  • Custom platform-specific properties

Querying Dashboard Information​

You can retrieve dashboard information using DataHub's REST API:

Fetch dashboard entity snapshot
curl 'http://localhost:8080/entities/urn%3Ali%3Adashboard%3A(looker,dashboards.999999)'

The response includes all aspects of the dashboard, including:

  • Dashboard information (title, description, URL)
  • Charts contained in the dashboard
  • Datasets consumed by the dashboard
  • Ownership, tags, and terms
  • Usage statistics
  • And all other configured aspects

Relationships API​

You can query dashboard relationships to understand its connections to other entities:

Find charts contained in a dashboard
curl 'http://localhost:8080/relationships?direction=OUTGOING&urn=urn%3Ali%3Adashboard%3A(looker,dashboards.999999)&types=Contains'

This returns all charts that belong to this dashboard.

Find datasets consumed by a dashboard
curl 'http://localhost:8080/relationships?direction=OUTGOING&urn=urn%3Ali%3Adashboard%3A(looker,dashboards.999999)&types=Consumes'

This returns all datasets that this dashboard depends on.

Find which dashboards contain a specific chart
curl 'http://localhost:8080/relationships?direction=INCOMING&urn=urn%3Ali%3Achart%3A(looker,look%2F1234)&types=Contains'

This returns all dashboards that contain the specified chart.

GraphQL API​

Dashboards are fully supported in DataHub's GraphQL API, which provides:

  • Queries: Search, browse, and retrieve dashboards
  • Mutations: Create, update, and delete dashboards
  • Faceted Search: Filter dashboards by tool, access level, and other attributes
  • Lineage Queries: Traverse upstream (datasets) and downstream relationships
  • Batch Loading: Efficiently load multiple dashboards
  • Usage Statistics: Query dashboard usage metrics

The GraphQL Dashboard type includes all standard metadata fields plus dashboard-specific properties like charts, datasets, and usage statistics.

Notable Exceptions​

Platform-Specific Variations​

Different BI platforms have different concepts that map to dashboards:

  • Tableau: A Tableau "workbook" maps to a DataHub dashboard entity. A workbook contains multiple "sheets" (charts). Tableau also has "dashboards" within workbooks that are collections of sheets - these are also modeled as dashboard entities in DataHub.

  • PowerBI: PowerBI has "reports" (which map to dashboards) and "apps" (which are containers for multiple reports). Apps are also modeled as dashboards but with a subtype distinguishing them.

  • Looker: Looker dashboards contain "elements" which can be charts, looks, or text elements. Each visual element becomes a chart in DataHub.

  • Superset: Superset dashboards contain "slices" (charts). The relationship is straightforward dashboard-to-chart.

Deprecated Fields​

The dashboardInfo.charts and dashboardInfo.datasets fields are deprecated in favor of dashboardInfo.chartEdges and dashboardInfo.datasetEdges. The Edges versions provide richer relationship metadata including timestamps and actors for when relationships were created or modified.

Container vs Parent​

Dashboards serve dual roles:

  • They are containers for charts (via chartEdges)
  • They can have parent containers themselves (e.g., a Tableau project or PowerBI workspace)

This two-level hierarchy is important for understanding organizational structure.

Dashboards frequently interact with these other DataHub entities:

  • Chart: Dashboards contain charts (visual elements)
  • Dataset: Dashboards consume data from datasets
  • SchemaField: Dashboards may reference specific fields/columns through field-level lineage
  • DataPlatform: Dashboards are associated with a specific BI platform
  • Container: Dashboards can belong to higher-level containers (projects, workspaces)
  • Domain: Dashboards can be organized into business domains
  • GlossaryTerm: Dashboards can be annotated with business terms
  • Tag: Dashboards can be tagged for classification and discovery
  • CorpUser / CorpGroup: Dashboards have owners and are used by users

Technical Reference Guide​

The sections above provide an overview of how to use this entity. The following sections provide detailed technical information about how metadata is stored and represented in DataHub.

Aspects are the individual pieces of metadata that can be attached to an entity. Each aspect contains specific information (like ownership, tags, or properties) and is stored as a separate record, allowing for flexible and incremental metadata updates.

Relationships show how this entity connects to other entities in the metadata graph. These connections are derived from the fields within each aspect and form the foundation of DataHub's knowledge graph.

Reading the Field Tables​

Each aspect's field table includes an Annotations column that provides additional metadata about how fields are used:

  • ⚠️ Deprecated: This field is deprecated and may be removed in a future version. Check the description for the recommended alternative
  • Searchable: This field is indexed and can be searched in DataHub's search interface
  • Searchable (fieldname): When the field name in parentheses is shown, it indicates the field is indexed under a different name in the search index. For example, dashboardTool is indexed as tool
  • → RelationshipName: This field creates a relationship to another entity. The arrow indicates this field contains a reference (URN) to another entity, and the name indicates the type of relationship (e.g., → Contains, → OwnedBy)

Fields with complex types (like Edge, AuditStamp) link to their definitions in the Common Types section below.

Aspects​

dashboardKey​

Key for a Dashboard

FieldTypeRequiredDescriptionAnnotations
dashboardToolstring✓The name of the dashboard tool such as looker, redash etc.Searchable (tool)
dashboardIdstring✓Unique id for the dashboard. This id should be globally unique for a dashboarding tool even when ...

dashboardInfo​

Information about a dashboard

FieldTypeRequiredDescriptionAnnotations
customPropertiesmap✓Custom property bag.Searchable
externalUrlstringURL where the reference existSearchable
titlestring✓Title of the dashboardSearchable
descriptionstring✓Detailed description about the dashboardSearchable
chartsstring[]✓Charts in a dashboard Deprecated! Use chartEdges instead.⚠️ Deprecated, → Contains
chartEdgesEdge[]Charts in a dashboard→ Contains
datasetsstring[]✓Datasets consumed by a dashboard Deprecated! Use datasetEdges instead.⚠️ Deprecated, → Consumes
datasetEdgesEdge[]Datasets consumed by a dashboard→ Consumes
dashboardsEdge[]✓Dashboards included by this dashboard. Some dashboard entities (e.g. PowerBI Apps) can contain ot...→ DashboardContainsDashboard
lastModifiedChangeAuditStamps✓Captures information about who created/last modified/deleted this dashboard and when
dashboardUrlstringURL for the dashboard. This could be used as an external link on DataHub to allow users access/vi...Searchable
accessAccessLevelAccess level for the dashboardSearchable
lastRefreshedlongThe time when this dashboard last refreshed

editableDashboardProperties​

Stores editable changes made to properties. This separates changes made from ingestion pipelines and edits in the UI to avoid accidental overwrites of user-provided data by ingestion pipelines

FieldTypeRequiredDescriptionAnnotations
createdAuditStamp✓An AuditStamp corresponding to the creation of this resource/association/sub-resource. A value of...
lastModifiedAuditStamp✓An AuditStamp corresponding to the last modification of this resource/association/sub-resource. I...
deletedAuditStampAn AuditStamp corresponding to the deletion of this resource/association/sub-resource. Logically,...
descriptionstringEdited documentation of the dashboardSearchable (editedDescription)

ownership​

Ownership information of an entity.

FieldTypeRequiredDescriptionAnnotations
ownersOwner[]✓List of owners of the entity.
ownerTypesmapOwnership type to Owners map, populated via mutation hook.Searchable
lastModifiedAuditStamp✓Audit stamp containing who last modified the record and when. A value of 0 in the time field indi...

status​

The lifecycle status metadata of an entity, e.g. dataset, metric, feature, etc. This aspect is used to represent soft deletes conventionally.

FieldTypeRequiredDescriptionAnnotations
removedboolean✓Whether the entity has been removed (soft-deleted).Searchable

globalTags​

Tag aspect used for applying tags to an entity

FieldTypeRequiredDescriptionAnnotations
tagsTagAssociation[]✓Tags associated with a given entitySearchable, → TaggedWith

browsePaths​

Shared aspect containing Browse Paths to be indexed for an entity.

FieldTypeRequiredDescriptionAnnotations
pathsstring[]✓A list of valid browse paths for the entity. Browse paths are expected to be forward slash-separ...Searchable

glossaryTerms​

Related business terms information

FieldTypeRequiredDescriptionAnnotations
termsGlossaryTermAssociation[]✓The related business terms
auditStampAuditStamp✓Audit stamp containing who reported the related business term

institutionalMemory​

Institutional memory of an entity. This is a way to link to relevant documentation and provide description of the documentation. Institutional or tribal knowledge is very important for users to leverage the entity.

FieldTypeRequiredDescriptionAnnotations
elementsInstitutionalMemoryMetadata[]✓List of records that represent institutional memory of an entity. Each record consists of a link,...

dataPlatformInstance​

The specific instance of the data platform that this entity belongs to

FieldTypeRequiredDescriptionAnnotations
platformstring✓Data PlatformSearchable
instancestringInstance of the data platform (e.g. db instance)Searchable (platformInstance)

browsePathsV2​

Shared aspect containing a Browse Path to be indexed for an entity.

FieldTypeRequiredDescriptionAnnotations
pathBrowsePathEntry[]✓A valid browse path for the entity. This field is provided by DataHub by default. This aspect is ...Searchable

domains​

Links from an Asset to its Domains

FieldTypeRequiredDescriptionAnnotations
domainsstring[]✓The Domains attached to an AssetSearchable, → AssociatedWith

applications​

Links from an Asset to its Applications

FieldTypeRequiredDescriptionAnnotations
applicationsstring[]✓The Applications attached to an AssetSearchable, → AssociatedWith

container​

Link from an asset to its parent container

FieldTypeRequiredDescriptionAnnotations
containerstring✓The parent container of an assetSearchable, → IsPartOf

deprecation​

Deprecation status of an entity

FieldTypeRequiredDescriptionAnnotations
deprecatedboolean✓Whether the entity is deprecated.Searchable
decommissionTimelongThe time user plan to decommission this entity.
notestring✓Additional information about the entity deprecation plan, such as the wiki, doc, RB.
actorstring✓The user URN which will be credited for modifying this deprecation content.
replacementstring

inputFields​

Information about the fields a chart or dashboard references

FieldTypeRequiredDescriptionAnnotations
fieldsInputField[]✓List of fields being referenced

subTypes​

Sub Types. Use this aspect to specialize a generic Entity e.g. Making a Dataset also be a View or also be a LookerExplore

FieldTypeRequiredDescriptionAnnotations
typeNamesstring[]✓The names of the specific types.Searchable

embed​

Information regarding rendering an embed for an asset.

FieldTypeRequiredDescriptionAnnotations
renderUrlstringAn embed URL to be rendered inside of an iframe.

structuredProperties​

Properties about an entity governed by StructuredPropertyDefinition

FieldTypeRequiredDescriptionAnnotations
propertiesStructuredPropertyValueAssignment[]✓Custom property bag.

incidentsSummary​

Summary related incidents on an entity.

FieldTypeRequiredDescriptionAnnotations
resolvedIncidentsstring[]✓Resolved incidents for an asset Deprecated! Use the richer resolvedIncidentsDetails instead.⚠️ Deprecated
activeIncidentsstring[]✓Active incidents for an asset Deprecated! Use the richer activeIncidentsDetails instead.⚠️ Deprecated
resolvedIncidentDetailsIncidentSummaryDetails[]✓Summary details about the set of resolved incidentsSearchable, → ResolvedIncidents
activeIncidentDetailsIncidentSummaryDetails[]✓Summary details about the set of active incidentsSearchable, → ActiveIncidents

forms​

Forms that are assigned to this entity to be filled out

FieldTypeRequiredDescriptionAnnotations
incompleteFormsFormAssociation[]✓All incomplete forms assigned to the entity.Searchable
completedFormsFormAssociation[]✓All complete forms assigned to the entity.Searchable
verificationsFormVerificationAssociation[]✓Verifications that have been applied to the entity via completed forms.Searchable

testResults​

Information about a Test Result

FieldTypeRequiredDescriptionAnnotations
failingTestResult[]✓Results that are failingSearchable, → IsFailing
passingTestResult[]✓Results that are passingSearchable, → IsPassing

dashboardUsageStatistics (Timeseries)​

Experimental (Subject to breaking change) -- Stats corresponding to dashboard's usage.

If this aspect represents the latest snapshot of the statistics about a Dashboard, the eventGranularity field should be null. If this aspect represents a bucketed window of usage statistics (e.g. over a day), then the eventGranularity field should be set accordingly.

FieldTypeRequiredDescriptionAnnotations
timestampMillislong✓The event timestamp field as epoch at UTC in milli seconds.
eventGranularityTimeWindowSizeGranularity of the event if applicable
partitionSpecPartitionSpecThe optional partition specification.
messageIdstringThe optional messageId, if provided serves as a custom user-defined unique identifier for an aspe...
viewsCountintThe total number of times dashboard has been viewed
executionsCountintThe total number of dashboard executions (refreshes / syncs)
uniqueUserCountintUnique user count
userCountsDashboardUserUsageCounts[]Users within this bucket, with frequency counts
favoritesCountintThe total number of times that the dashboard has been favorited
lastViewedAtlongLast viewed at This should not be set in cases where statistics are windowed.

Common Types​

These types are used across multiple aspects in this entity.

AuditStamp​

Data captured on a resource/association/sub-resource level giving insight into when that resource/association/sub-resource moved into a particular lifecycle stage, and who acted to move it into that specific lifecycle stage.

Fields:

  • time (long): When did the resource/association/sub-resource move into the specific lifecyc...
  • actor (string): The entity (e.g. a member URN) which will be credited for moving the resource...
  • impersonator (string?): The entity (e.g. a service URN) which performs the change on behalf of the Ac...
  • message (string?): Additional context around how DataHub was informed of the particular change. ...

ChangeAuditStamps​

Data captured on a resource/association/sub-resource level giving insight into when that resource/association/sub-resource moved into various lifecycle stages, and who acted to move it into those lifecycle stages. The recommended best practice is to include this record in your record schema, and annotate its fields as @readOnly in your resource. See https://github.com/linkedin/rest.li/wiki/Validation-in-Rest.li#restli-validation-annotations

Fields:

  • created (AuditStamp): An AuditStamp corresponding to the creation of this resource/association/sub-...
  • lastModified (AuditStamp): An AuditStamp corresponding to the last modification of this resource/associa...
  • deleted (AuditStamp?): An AuditStamp corresponding to the deletion of this resource/association/sub-...

Edge​

A common structure to represent all edges to entities when used inside aspects as collections This ensures that all edges have common structure around audit-stamps and will support PATCH, time-travel automatically.

Fields:

  • sourceUrn (string?): Urn of the source of this relationship edge. If not specified, assumed to be ...
  • destinationUrn (string): Urn of the destination of this relationship edge.
  • created (AuditStamp?): Audit stamp containing who created this relationship edge and when
  • lastModified (AuditStamp?): Audit stamp containing who last modified this relationship edge and when
  • properties (map?): A generic properties bag that allows us to store specific information on this...

FormAssociation​

Properties of an applied form.

Fields:

  • urn (string): Urn of the applied form
  • incompletePrompts (FormPromptAssociation[]): A list of prompts that are not yet complete for this form.
  • completedPrompts (FormPromptAssociation[]): A list of prompts that have been completed for this form.

IncidentSummaryDetails​

Summary statistics about incidents on an entity.

Fields:

  • urn (string): The urn of the incident
  • type (string): The type of an incident
  • createdAt (long): The time at which the incident was raised in milliseconds since epoch.
  • resolvedAt (long?): The time at which the incident was marked as resolved in milliseconds since e...
  • priority (int?): The priority of the incident

TestResult​

Information about a Test Result

Fields:

  • test (string): The urn of the test
  • type (TestResultType): The type of the result
  • testDefinitionMd5 (string?): The md5 of the test definition that was used to compute this result. See Test...
  • lastComputed (AuditStamp?): The audit stamp of when the result was computed, including the actor who comp...

Relationships​

Self​

These are the relationships to itself, stored in this entity's aspects

  • DashboardContainsDashboard (via dashboardInfo.dashboards)

Outgoing​

These are the relationships stored in this entity's aspects

  • Contains

    • Chart via dashboardInfo.charts
    • Chart via dashboardInfo.chartEdges

  • Consumes

    • Dataset via dashboardInfo.datasets
    • Dataset via dashboardInfo.datasetEdges

  • OwnedBy

    • Corpuser via ownership.owners.owner
    • CorpGroup via ownership.owners.owner

  • ownershipType

    • OwnershipType via ownership.owners.typeUrn

  • TaggedWith

    • Tag via globalTags.tags
    • Tag via inputFields.fields.schemaField.globalTags.tags

  • TermedWith

    • GlossaryTerm via glossaryTerms.terms.urn
    • GlossaryTerm via inputFields.fields.schemaField.glossaryTerms.terms.urn

  • AssociatedWith

    • Domain via domains.domains
    • Application via applications.applications

  • IsPartOf

    • Container via container.container

  • consumesField

    • SchemaField via inputFields.fields.schemaFieldUrn

  • SchemaFieldTaggedWith

    • Tag via inputFields.fields.schemaField.globalTags

  • SchemaFieldWithGlossaryTerm

    • GlossaryTerm via inputFields.fields.schemaField.glossaryTerms

  • ResolvedIncidents

    • Incident via incidentsSummary.resolvedIncidentDetails

  • ActiveIncidents

    • Incident via incidentsSummary.activeIncidentDetails

  • IsFailing

    • Test via testResults.failing

  • IsPassing

    • Test via testResults.passing

Global Metadata Model​

Global Graph