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
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
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
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
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
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
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
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
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
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​

For technical details about fields, searchability, and relationships, view the Columns tab in DataHub.