Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. Databricks Provider
  3. API Docs
  4. LakehouseMonitor
Databricks v1.63.0 published on Thursday, Mar 13, 2025 by Pulumi
pulumi/pulumi-databricks

databricks.LakehouseMonitor

Explore with Pulumi AI

Databricks v1.63.0 published on Thursday, Mar 13, 2025 by Pulumi
pulumi/pulumi-databricks

NOTE: This resource has been deprecated and will be removed soon. Please use the databricks.QualityMonitor resource instead.

This resource allows you to manage Lakehouse Monitors in Databricks.

A databricks.LakehouseMonitor is attached to a databricks.SqlTable and can be of type timeseries, snapshot or inference.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as databricks from "@pulumi/databricks";

const sandbox = new databricks.Catalog("sandbox", {
    name: "sandbox",
    comment: "this catalog is managed by terraform",
    properties: {
        purpose: "testing",
    },
});
const things = new databricks.Schema("things", {
    catalogName: sandbox.id,
    name: "things",
    comment: "this database is managed by terraform",
    properties: {
        kind: "various",
    },
});
const myTestTable = new databricks.SqlTable("myTestTable", {
    catalogName: "main",
    schemaName: things.name,
    name: "bar",
    tableType: "MANAGED",
    dataSourceFormat: "DELTA",
    columns: [{
        name: "timestamp",
        type: "int",
    }],
});
const testTimeseriesMonitor = new databricks.LakehouseMonitor("testTimeseriesMonitor", {
    tableName: pulumi.interpolate`${sandbox.name}.${things.name}.${myTestTable.name}`,
    assetsDir: pulumi.interpolate`/Shared/provider-test/databricks_lakehouse_monitoring/${myTestTable.name}`,
    outputSchemaName: pulumi.interpolate`${sandbox.name}.${things.name}`,
    timeSeries: {
        granularities: ["1 hour"],
        timestampCol: "timestamp",
    },
});
Copy
import pulumi
import pulumi_databricks as databricks

sandbox = databricks.Catalog("sandbox",
    name="sandbox",
    comment="this catalog is managed by terraform",
    properties={
        "purpose": "testing",
    })
things = databricks.Schema("things",
    catalog_name=sandbox.id,
    name="things",
    comment="this database is managed by terraform",
    properties={
        "kind": "various",
    })
my_test_table = databricks.SqlTable("myTestTable",
    catalog_name="main",
    schema_name=things.name,
    name="bar",
    table_type="MANAGED",
    data_source_format="DELTA",
    columns=[{
        "name": "timestamp",
        "type": "int",
    }])
test_timeseries_monitor = databricks.LakehouseMonitor("testTimeseriesMonitor",
    table_name=pulumi.Output.all(
        sandboxName=sandbox.name,
        thingsName=things.name,
        myTestTableName=my_test_table.name
).apply(lambda resolved_outputs: f"{resolved_outputs['sandboxName']}.{resolved_outputs['thingsName']}.{resolved_outputs['myTestTableName']}")
,
    assets_dir=my_test_table.name.apply(lambda name: f"/Shared/provider-test/databricks_lakehouse_monitoring/{name}"),
    output_schema_name=pulumi.Output.all(
        sandboxName=sandbox.name,
        thingsName=things.name
).apply(lambda resolved_outputs: f"{resolved_outputs['sandboxName']}.{resolved_outputs['thingsName']}")
,
    time_series={
        "granularities": ["1 hour"],
        "timestamp_col": "timestamp",
    })
Copy
package main

import (
	"fmt"

	"github.com/pulumi/pulumi-databricks/sdk/go/databricks"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		sandbox, err := databricks.NewCatalog(ctx, "sandbox", &databricks.CatalogArgs{
			Name:    pulumi.String("sandbox"),
			Comment: pulumi.String("this catalog is managed by terraform"),
			Properties: pulumi.StringMap{
				"purpose": pulumi.String("testing"),
			},
		})
		if err != nil {
			return err
		}
		things, err := databricks.NewSchema(ctx, "things", &databricks.SchemaArgs{
			CatalogName: sandbox.ID(),
			Name:        pulumi.String("things"),
			Comment:     pulumi.String("this database is managed by terraform"),
			Properties: pulumi.StringMap{
				"kind": pulumi.String("various"),
			},
		})
		if err != nil {
			return err
		}
		myTestTable, err := databricks.NewSqlTable(ctx, "myTestTable", &databricks.SqlTableArgs{
			CatalogName:      pulumi.String("main"),
			SchemaName:       things.Name,
			Name:             pulumi.String("bar"),
			TableType:        pulumi.String("MANAGED"),
			DataSourceFormat: pulumi.String("DELTA"),
			Columns: databricks.SqlTableColumnArray{
				&databricks.SqlTableColumnArgs{
					Name: pulumi.String("timestamp"),
					Type: pulumi.String("int"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = databricks.NewLakehouseMonitor(ctx, "testTimeseriesMonitor", &databricks.LakehouseMonitorArgs{
			TableName: pulumi.All(sandbox.Name, things.Name, myTestTable.Name).ApplyT(func(_args []interface{}) (string, error) {
				sandboxName := _args[0].(string)
				thingsName := _args[1].(string)
				myTestTableName := _args[2].(string)
				return fmt.Sprintf("%v.%v.%v", sandboxName, thingsName, myTestTableName), nil
			}).(pulumi.StringOutput),
			AssetsDir: myTestTable.Name.ApplyT(func(name string) (string, error) {
				return fmt.Sprintf("/Shared/provider-test/databricks_lakehouse_monitoring/%v", name), nil
			}).(pulumi.StringOutput),
			OutputSchemaName: pulumi.All(sandbox.Name, things.Name).ApplyT(func(_args []interface{}) (string, error) {
				sandboxName := _args[0].(string)
				thingsName := _args[1].(string)
				return fmt.Sprintf("%v.%v", sandboxName, thingsName), nil
			}).(pulumi.StringOutput),
			TimeSeries: &databricks.LakehouseMonitorTimeSeriesArgs{
				Granularities: pulumi.StringArray{
					pulumi.String("1 hour"),
				},
				TimestampCol: pulumi.String("timestamp"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Databricks = Pulumi.Databricks;

return await Deployment.RunAsync(() => 
{
    var sandbox = new Databricks.Catalog("sandbox", new()
    {
        Name = "sandbox",
        Comment = "this catalog is managed by terraform",
        Properties = 
        {
            { "purpose", "testing" },
        },
    });

    var things = new Databricks.Schema("things", new()
    {
        CatalogName = sandbox.Id,
        Name = "things",
        Comment = "this database is managed by terraform",
        Properties = 
        {
            { "kind", "various" },
        },
    });

    var myTestTable = new Databricks.SqlTable("myTestTable", new()
    {
        CatalogName = "main",
        SchemaName = things.Name,
        Name = "bar",
        TableType = "MANAGED",
        DataSourceFormat = "DELTA",
        Columns = new[]
        {
            new Databricks.Inputs.SqlTableColumnArgs
            {
                Name = "timestamp",
                Type = "int",
            },
        },
    });

    var testTimeseriesMonitor = new Databricks.LakehouseMonitor("testTimeseriesMonitor", new()
    {
        TableName = Output.Tuple(sandbox.Name, things.Name, myTestTable.Name).Apply(values =>
        {
            var sandboxName = values.Item1;
            var thingsName = values.Item2;
            var myTestTableName = values.Item3;
            return $"{sandboxName}.{thingsName}.{myTestTableName}";
        }),
        AssetsDir = myTestTable.Name.Apply(name => $"/Shared/provider-test/databricks_lakehouse_monitoring/{name}"),
        OutputSchemaName = Output.Tuple(sandbox.Name, things.Name).Apply(values =>
        {
            var sandboxName = values.Item1;
            var thingsName = values.Item2;
            return $"{sandboxName}.{thingsName}";
        }),
        TimeSeries = new Databricks.Inputs.LakehouseMonitorTimeSeriesArgs
        {
            Granularities = new[]
            {
                "1 hour",
            },
            TimestampCol = "timestamp",
        },
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.databricks.Catalog;
import com.pulumi.databricks.CatalogArgs;
import com.pulumi.databricks.Schema;
import com.pulumi.databricks.SchemaArgs;
import com.pulumi.databricks.SqlTable;
import com.pulumi.databricks.SqlTableArgs;
import com.pulumi.databricks.inputs.SqlTableColumnArgs;
import com.pulumi.databricks.LakehouseMonitor;
import com.pulumi.databricks.LakehouseMonitorArgs;
import com.pulumi.databricks.inputs.LakehouseMonitorTimeSeriesArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var sandbox = new Catalog("sandbox", CatalogArgs.builder()
            .name("sandbox")
            .comment("this catalog is managed by terraform")
            .properties(Map.of("purpose", "testing"))
            .build());

        var things = new Schema("things", SchemaArgs.builder()
            .catalogName(sandbox.id())
            .name("things")
            .comment("this database is managed by terraform")
            .properties(Map.of("kind", "various"))
            .build());

        var myTestTable = new SqlTable("myTestTable", SqlTableArgs.builder()
            .catalogName("main")
            .schemaName(things.name())
            .name("bar")
            .tableType("MANAGED")
            .dataSourceFormat("DELTA")
            .columns(SqlTableColumnArgs.builder()
                .name("timestamp")
                .type("int")
                .build())
            .build());

        var testTimeseriesMonitor = new LakehouseMonitor("testTimeseriesMonitor", LakehouseMonitorArgs.builder()
            .tableName(Output.tuple(sandbox.name(), things.name(), myTestTable.name()).applyValue(values -> {
                var sandboxName = values.t1;
                var thingsName = values.t2;
                var myTestTableName = values.t3;
                return String.format("%s.%s.%s", sandboxName,thingsName,myTestTableName);
            }))
            .assetsDir(myTestTable.name().applyValue(name -> String.format("/Shared/provider-test/databricks_lakehouse_monitoring/%s", name)))
            .outputSchemaName(Output.tuple(sandbox.name(), things.name()).applyValue(values -> {
                var sandboxName = values.t1;
                var thingsName = values.t2;
                return String.format("%s.%s", sandboxName,thingsName);
            }))
            .timeSeries(LakehouseMonitorTimeSeriesArgs.builder()
                .granularities("1 hour")
                .timestampCol("timestamp")
                .build())
            .build());

    }
}
Copy
resources:
  sandbox:
    type: databricks:Catalog
    properties:
      name: sandbox
      comment: this catalog is managed by terraform
      properties:
        purpose: testing
  things:
    type: databricks:Schema
    properties:
      catalogName: ${sandbox.id}
      name: things
      comment: this database is managed by terraform
      properties:
        kind: various
  myTestTable:
    type: databricks:SqlTable
    properties:
      catalogName: main
      schemaName: ${things.name}
      name: bar
      tableType: MANAGED
      dataSourceFormat: DELTA
      columns:
        - name: timestamp
          type: int
  testTimeseriesMonitor:
    type: databricks:LakehouseMonitor
    properties:
      tableName: ${sandbox.name}.${things.name}.${myTestTable.name}
      assetsDir: /Shared/provider-test/databricks_lakehouse_monitoring/${myTestTable.name}
      outputSchemaName: ${sandbox.name}.${things.name}
      timeSeries:
        granularities:
          - 1 hour
        timestampCol: timestamp
Copy

Inference Monitor

import * as pulumi from "@pulumi/pulumi";
import * as databricks from "@pulumi/databricks";

const testMonitorInference = new databricks.LakehouseMonitor("testMonitorInference", {
    tableName: `${sandbox.name}.${things.name}.${myTestTable.name}`,
    assetsDir: `/Shared/provider-test/databricks_lakehouse_monitoring/${myTestTable.name}`,
    outputSchemaName: `${sandbox.name}.${things.name}`,
    inferenceLog: {
        granularities: ["1 hour"],
        timestampCol: "timestamp",
        predictionCol: "prediction",
        modelIdCol: "model_id",
        problemType: "PROBLEM_TYPE_REGRESSION",
    },
});
Copy
import pulumi
import pulumi_databricks as databricks

test_monitor_inference = databricks.LakehouseMonitor("testMonitorInference",
    table_name=f"{sandbox['name']}.{things['name']}.{my_test_table['name']}",
    assets_dir=f"/Shared/provider-test/databricks_lakehouse_monitoring/{my_test_table['name']}",
    output_schema_name=f"{sandbox['name']}.{things['name']}",
    inference_log={
        "granularities": ["1 hour"],
        "timestamp_col": "timestamp",
        "prediction_col": "prediction",
        "model_id_col": "model_id",
        "problem_type": "PROBLEM_TYPE_REGRESSION",
    })
Copy
package main

import (
	"fmt"

	"github.com/pulumi/pulumi-databricks/sdk/go/databricks"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := databricks.NewLakehouseMonitor(ctx, "testMonitorInference", &databricks.LakehouseMonitorArgs{
			TableName:        pulumi.Sprintf("%v.%v.%v", sandbox.Name, things.Name, myTestTable.Name),
			AssetsDir:        pulumi.Sprintf("/Shared/provider-test/databricks_lakehouse_monitoring/%v", myTestTable.Name),
			OutputSchemaName: pulumi.Sprintf("%v.%v", sandbox.Name, things.Name),
			InferenceLog: &databricks.LakehouseMonitorInferenceLogArgs{
				Granularities: pulumi.StringArray{
					pulumi.String("1 hour"),
				},
				TimestampCol:  pulumi.String("timestamp"),
				PredictionCol: pulumi.String("prediction"),
				ModelIdCol:    pulumi.String("model_id"),
				ProblemType:   pulumi.String("PROBLEM_TYPE_REGRESSION"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Databricks = Pulumi.Databricks;

return await Deployment.RunAsync(() => 
{
    var testMonitorInference = new Databricks.LakehouseMonitor("testMonitorInference", new()
    {
        TableName = $"{sandbox.Name}.{things.Name}.{myTestTable.Name}",
        AssetsDir = $"/Shared/provider-test/databricks_lakehouse_monitoring/{myTestTable.Name}",
        OutputSchemaName = $"{sandbox.Name}.{things.Name}",
        InferenceLog = new Databricks.Inputs.LakehouseMonitorInferenceLogArgs
        {
            Granularities = new[]
            {
                "1 hour",
            },
            TimestampCol = "timestamp",
            PredictionCol = "prediction",
            ModelIdCol = "model_id",
            ProblemType = "PROBLEM_TYPE_REGRESSION",
        },
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.databricks.LakehouseMonitor;
import com.pulumi.databricks.LakehouseMonitorArgs;
import com.pulumi.databricks.inputs.LakehouseMonitorInferenceLogArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var testMonitorInference = new LakehouseMonitor("testMonitorInference", LakehouseMonitorArgs.builder()
            .tableName(String.format("%s.%s.%s", sandbox.name(),things.name(),myTestTable.name()))
            .assetsDir(String.format("/Shared/provider-test/databricks_lakehouse_monitoring/%s", myTestTable.name()))
            .outputSchemaName(String.format("%s.%s", sandbox.name(),things.name()))
            .inferenceLog(LakehouseMonitorInferenceLogArgs.builder()
                .granularities("1 hour")
                .timestampCol("timestamp")
                .predictionCol("prediction")
                .modelIdCol("model_id")
                .problemType("PROBLEM_TYPE_REGRESSION")
                .build())
            .build());

    }
}
Copy
resources:
  testMonitorInference:
    type: databricks:LakehouseMonitor
    properties:
      tableName: ${sandbox.name}.${things.name}.${myTestTable.name}
      assetsDir: /Shared/provider-test/databricks_lakehouse_monitoring/${myTestTable.name}
      outputSchemaName: ${sandbox.name}.${things.name}
      inferenceLog:
        granularities:
          - 1 hour
        timestampCol: timestamp
        predictionCol: prediction
        modelIdCol: model_id
        problemType: PROBLEM_TYPE_REGRESSION
Copy

Snapshot Monitor

import * as pulumi from "@pulumi/pulumi";
import * as databricks from "@pulumi/databricks";

const testMonitorInference = new databricks.LakehouseMonitor("testMonitorInference", {
    tableName: `${sandbox.name}.${things.name}.${myTestTable.name}`,
    assetsDir: `/Shared/provider-test/databricks_lakehouse_monitoring/${myTestTable.name}`,
    outputSchemaName: `${sandbox.name}.${things.name}`,
    snapshot: {},
});
Copy
import pulumi
import pulumi_databricks as databricks

test_monitor_inference = databricks.LakehouseMonitor("testMonitorInference",
    table_name=f"{sandbox['name']}.{things['name']}.{my_test_table['name']}",
    assets_dir=f"/Shared/provider-test/databricks_lakehouse_monitoring/{my_test_table['name']}",
    output_schema_name=f"{sandbox['name']}.{things['name']}",
    snapshot={})
Copy
package main

import (
	"fmt"

	"github.com/pulumi/pulumi-databricks/sdk/go/databricks"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := databricks.NewLakehouseMonitor(ctx, "testMonitorInference", &databricks.LakehouseMonitorArgs{
			TableName:        pulumi.Sprintf("%v.%v.%v", sandbox.Name, things.Name, myTestTable.Name),
			AssetsDir:        pulumi.Sprintf("/Shared/provider-test/databricks_lakehouse_monitoring/%v", myTestTable.Name),
			OutputSchemaName: pulumi.Sprintf("%v.%v", sandbox.Name, things.Name),
			Snapshot:         &databricks.LakehouseMonitorSnapshotArgs{},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Databricks = Pulumi.Databricks;

return await Deployment.RunAsync(() => 
{
    var testMonitorInference = new Databricks.LakehouseMonitor("testMonitorInference", new()
    {
        TableName = $"{sandbox.Name}.{things.Name}.{myTestTable.Name}",
        AssetsDir = $"/Shared/provider-test/databricks_lakehouse_monitoring/{myTestTable.Name}",
        OutputSchemaName = $"{sandbox.Name}.{things.Name}",
        Snapshot = null,
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.databricks.LakehouseMonitor;
import com.pulumi.databricks.LakehouseMonitorArgs;
import com.pulumi.databricks.inputs.LakehouseMonitorSnapshotArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var testMonitorInference = new LakehouseMonitor("testMonitorInference", LakehouseMonitorArgs.builder()
            .tableName(String.format("%s.%s.%s", sandbox.name(),things.name(),myTestTable.name()))
            .assetsDir(String.format("/Shared/provider-test/databricks_lakehouse_monitoring/%s", myTestTable.name()))
            .outputSchemaName(String.format("%s.%s", sandbox.name(),things.name()))
            .snapshot()
            .build());

    }
}
Copy
resources:
  testMonitorInference:
    type: databricks:LakehouseMonitor
    properties:
      tableName: ${sandbox.name}.${things.name}.${myTestTable.name}
      assetsDir: /Shared/provider-test/databricks_lakehouse_monitoring/${myTestTable.name}
      outputSchemaName: ${sandbox.name}.${things.name}
      snapshot: {}
Copy

The following resources are often used in the same context:

  • databricks.Catalog
  • databricks.Schema
  • databricks.SqlTable

Create LakehouseMonitor Resource

Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

Constructor syntax

new LakehouseMonitor(name: string, args: LakehouseMonitorArgs, opts?: CustomResourceOptions);
@overload
def LakehouseMonitor(resource_name: str,
                     args: LakehouseMonitorArgs,
                     opts: Optional[ResourceOptions] = None)

@overload
def LakehouseMonitor(resource_name: str,
                     opts: Optional[ResourceOptions] = None,
                     assets_dir: Optional[str] = None,
                     table_name: Optional[str] = None,
                     output_schema_name: Optional[str] = None,
                     notifications: Optional[LakehouseMonitorNotificationsArgs] = None,
                     inference_log: Optional[LakehouseMonitorInferenceLogArgs] = None,
                     latest_monitor_failure_msg: Optional[str] = None,
                     data_classification_config: Optional[LakehouseMonitorDataClassificationConfigArgs] = None,
                     custom_metrics: Optional[Sequence[LakehouseMonitorCustomMetricArgs]] = None,
                     schedule: Optional[LakehouseMonitorScheduleArgs] = None,
                     skip_builtin_dashboard: Optional[bool] = None,
                     slicing_exprs: Optional[Sequence[str]] = None,
                     snapshot: Optional[LakehouseMonitorSnapshotArgs] = None,
                     baseline_table_name: Optional[str] = None,
                     time_series: Optional[LakehouseMonitorTimeSeriesArgs] = None,
                     warehouse_id: Optional[str] = None)
func NewLakehouseMonitor(ctx *Context, name string, args LakehouseMonitorArgs, opts ...ResourceOption) (*LakehouseMonitor, error)
public LakehouseMonitor(string name, LakehouseMonitorArgs args, CustomResourceOptions? opts = null)
public LakehouseMonitor(String name, LakehouseMonitorArgs args)
public LakehouseMonitor(String name, LakehouseMonitorArgs args, CustomResourceOptions options)

type: databricks:LakehouseMonitor
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

Parameters

name This property is required. string
The unique name of the resource.
args This property is required. LakehouseMonitorArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
resource_name This property is required. str
The unique name of the resource.
args This property is required. LakehouseMonitorArgs
The arguments to resource properties.
opts ResourceOptions
Bag of options to control resource's behavior.
ctx Context
Context object for the current deployment.
name This property is required. string
The unique name of the resource.
args This property is required. LakehouseMonitorArgs
The arguments to resource properties.
opts ResourceOption
Bag of options to control resource's behavior.
name This property is required. string
The unique name of the resource.
args This property is required. LakehouseMonitorArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
name This property is required. String
The unique name of the resource.
args This property is required. LakehouseMonitorArgs
The arguments to resource properties.
options CustomResourceOptions
Bag of options to control resource's behavior.

Constructor example

The following reference example uses placeholder values for all input properties.

var lakehouseMonitorResource = new Databricks.LakehouseMonitor("lakehouseMonitorResource", new()
{
    AssetsDir = "string",
    TableName = "string",
    OutputSchemaName = "string",
    Notifications = new Databricks.Inputs.LakehouseMonitorNotificationsArgs
    {
        OnFailure = new Databricks.Inputs.LakehouseMonitorNotificationsOnFailureArgs
        {
            EmailAddresses = new[]
            {
                "string",
            },
        },
        OnNewClassificationTagDetected = new Databricks.Inputs.LakehouseMonitorNotificationsOnNewClassificationTagDetectedArgs
        {
            EmailAddresses = new[]
            {
                "string",
            },
        },
    },
    InferenceLog = new Databricks.Inputs.LakehouseMonitorInferenceLogArgs
    {
        Granularities = new[]
        {
            "string",
        },
        ModelIdCol = "string",
        PredictionCol = "string",
        ProblemType = "string",
        TimestampCol = "string",
        LabelCol = "string",
        PredictionProbaCol = "string",
    },
    LatestMonitorFailureMsg = "string",
    DataClassificationConfig = new Databricks.Inputs.LakehouseMonitorDataClassificationConfigArgs
    {
        Enabled = false,
    },
    CustomMetrics = new[]
    {
        new Databricks.Inputs.LakehouseMonitorCustomMetricArgs
        {
            Definition = "string",
            InputColumns = new[]
            {
                "string",
            },
            Name = "string",
            OutputDataType = "string",
            Type = "string",
        },
    },
    Schedule = new Databricks.Inputs.LakehouseMonitorScheduleArgs
    {
        QuartzCronExpression = "string",
        TimezoneId = "string",
        PauseStatus = "string",
    },
    SkipBuiltinDashboard = false,
    SlicingExprs = new[]
    {
        "string",
    },
    Snapshot = null,
    BaselineTableName = "string",
    TimeSeries = new Databricks.Inputs.LakehouseMonitorTimeSeriesArgs
    {
        Granularities = new[]
        {
            "string",
        },
        TimestampCol = "string",
    },
    WarehouseId = "string",
});
Copy
example, err := databricks.NewLakehouseMonitor(ctx, "lakehouseMonitorResource", &databricks.LakehouseMonitorArgs{
	AssetsDir:        pulumi.String("string"),
	TableName:        pulumi.String("string"),
	OutputSchemaName: pulumi.String("string"),
	Notifications: &databricks.LakehouseMonitorNotificationsArgs{
		OnFailure: &databricks.LakehouseMonitorNotificationsOnFailureArgs{
			EmailAddresses: pulumi.StringArray{
				pulumi.String("string"),
			},
		},
		OnNewClassificationTagDetected: &databricks.LakehouseMonitorNotificationsOnNewClassificationTagDetectedArgs{
			EmailAddresses: pulumi.StringArray{
				pulumi.String("string"),
			},
		},
	},
	InferenceLog: &databricks.LakehouseMonitorInferenceLogArgs{
		Granularities: pulumi.StringArray{
			pulumi.String("string"),
		},
		ModelIdCol:         pulumi.String("string"),
		PredictionCol:      pulumi.String("string"),
		ProblemType:        pulumi.String("string"),
		TimestampCol:       pulumi.String("string"),
		LabelCol:           pulumi.String("string"),
		PredictionProbaCol: pulumi.String("string"),
	},
	LatestMonitorFailureMsg: pulumi.String("string"),
	DataClassificationConfig: &databricks.LakehouseMonitorDataClassificationConfigArgs{
		Enabled: pulumi.Bool(false),
	},
	CustomMetrics: databricks.LakehouseMonitorCustomMetricArray{
		&databricks.LakehouseMonitorCustomMetricArgs{
			Definition: pulumi.String("string"),
			InputColumns: pulumi.StringArray{
				pulumi.String("string"),
			},
			Name:           pulumi.String("string"),
			OutputDataType: pulumi.String("string"),
			Type:           pulumi.String("string"),
		},
	},
	Schedule: &databricks.LakehouseMonitorScheduleArgs{
		QuartzCronExpression: pulumi.String("string"),
		TimezoneId:           pulumi.String("string"),
		PauseStatus:          pulumi.String("string"),
	},
	SkipBuiltinDashboard: pulumi.Bool(false),
	SlicingExprs: pulumi.StringArray{
		pulumi.String("string"),
	},
	Snapshot:          &databricks.LakehouseMonitorSnapshotArgs{},
	BaselineTableName: pulumi.String("string"),
	TimeSeries: &databricks.LakehouseMonitorTimeSeriesArgs{
		Granularities: pulumi.StringArray{
			pulumi.String("string"),
		},
		TimestampCol: pulumi.String("string"),
	},
	WarehouseId: pulumi.String("string"),
})
Copy
var lakehouseMonitorResource = new LakehouseMonitor("lakehouseMonitorResource", LakehouseMonitorArgs.builder()
    .assetsDir("string")
    .tableName("string")
    .outputSchemaName("string")
    .notifications(LakehouseMonitorNotificationsArgs.builder()
        .onFailure(LakehouseMonitorNotificationsOnFailureArgs.builder()
            .emailAddresses("string")
            .build())
        .onNewClassificationTagDetected(LakehouseMonitorNotificationsOnNewClassificationTagDetectedArgs.builder()
            .emailAddresses("string")
            .build())
        .build())
    .inferenceLog(LakehouseMonitorInferenceLogArgs.builder()
        .granularities("string")
        .modelIdCol("string")
        .predictionCol("string")
        .problemType("string")
        .timestampCol("string")
        .labelCol("string")
        .predictionProbaCol("string")
        .build())
    .latestMonitorFailureMsg("string")
    .dataClassificationConfig(LakehouseMonitorDataClassificationConfigArgs.builder()
        .enabled(false)
        .build())
    .customMetrics(LakehouseMonitorCustomMetricArgs.builder()
        .definition("string")
        .inputColumns("string")
        .name("string")
        .outputDataType("string")
        .type("string")
        .build())
    .schedule(LakehouseMonitorScheduleArgs.builder()
        .quartzCronExpression("string")
        .timezoneId("string")
        .pauseStatus("string")
        .build())
    .skipBuiltinDashboard(false)
    .slicingExprs("string")
    .snapshot()
    .baselineTableName("string")
    .timeSeries(LakehouseMonitorTimeSeriesArgs.builder()
        .granularities("string")
        .timestampCol("string")
        .build())
    .warehouseId("string")
    .build());
Copy
lakehouse_monitor_resource = databricks.LakehouseMonitor("lakehouseMonitorResource",
    assets_dir="string",
    table_name="string",
    output_schema_name="string",
    notifications={
        "on_failure": {
            "email_addresses": ["string"],
        },
        "on_new_classification_tag_detected": {
            "email_addresses": ["string"],
        },
    },
    inference_log={
        "granularities": ["string"],
        "model_id_col": "string",
        "prediction_col": "string",
        "problem_type": "string",
        "timestamp_col": "string",
        "label_col": "string",
        "prediction_proba_col": "string",
    },
    latest_monitor_failure_msg="string",
    data_classification_config={
        "enabled": False,
    },
    custom_metrics=[{
        "definition": "string",
        "input_columns": ["string"],
        "name": "string",
        "output_data_type": "string",
        "type": "string",
    }],
    schedule={
        "quartz_cron_expression": "string",
        "timezone_id": "string",
        "pause_status": "string",
    },
    skip_builtin_dashboard=False,
    slicing_exprs=["string"],
    snapshot={},
    baseline_table_name="string",
    time_series={
        "granularities": ["string"],
        "timestamp_col": "string",
    },
    warehouse_id="string")
Copy
const lakehouseMonitorResource = new databricks.LakehouseMonitor("lakehouseMonitorResource", {
    assetsDir: "string",
    tableName: "string",
    outputSchemaName: "string",
    notifications: {
        onFailure: {
            emailAddresses: ["string"],
        },
        onNewClassificationTagDetected: {
            emailAddresses: ["string"],
        },
    },
    inferenceLog: {
        granularities: ["string"],
        modelIdCol: "string",
        predictionCol: "string",
        problemType: "string",
        timestampCol: "string",
        labelCol: "string",
        predictionProbaCol: "string",
    },
    latestMonitorFailureMsg: "string",
    dataClassificationConfig: {
        enabled: false,
    },
    customMetrics: [{
        definition: "string",
        inputColumns: ["string"],
        name: "string",
        outputDataType: "string",
        type: "string",
    }],
    schedule: {
        quartzCronExpression: "string",
        timezoneId: "string",
        pauseStatus: "string",
    },
    skipBuiltinDashboard: false,
    slicingExprs: ["string"],
    snapshot: {},
    baselineTableName: "string",
    timeSeries: {
        granularities: ["string"],
        timestampCol: "string",
    },
    warehouseId: "string",
});
Copy
type: databricks:LakehouseMonitor
properties:
    assetsDir: string
    baselineTableName: string
    customMetrics:
        - definition: string
          inputColumns:
            - string
          name: string
          outputDataType: string
          type: string
    dataClassificationConfig:
        enabled: false
    inferenceLog:
        granularities:
            - string
        labelCol: string
        modelIdCol: string
        predictionCol: string
        predictionProbaCol: string
        problemType: string
        timestampCol: string
    latestMonitorFailureMsg: string
    notifications:
        onFailure:
            emailAddresses:
                - string
        onNewClassificationTagDetected:
            emailAddresses:
                - string
    outputSchemaName: string
    schedule:
        pauseStatus: string
        quartzCronExpression: string
        timezoneId: string
    skipBuiltinDashboard: false
    slicingExprs:
        - string
    snapshot: {}
    tableName: string
    timeSeries:
        granularities:
            - string
        timestampCol: string
    warehouseId: string
Copy

LakehouseMonitor Resource Properties

To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

Inputs

In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

The LakehouseMonitor resource accepts the following input properties:

AssetsDir This property is required. string
The directory to store the monitoring assets (Eg. Dashboard and Metric Tables)
OutputSchemaName This property is required. string
Schema where output metric tables are created
TableName This property is required. string
The full name of the table to attach the monitor too. Its of the format {catalog}.{schema}.{tableName}
BaselineTableName string
Name of the baseline table from which drift metrics are computed from.Columns in the monitored table should also be present in the baseline table.
CustomMetrics List<LakehouseMonitorCustomMetric>
Custom metrics to compute on the monitored table. These can be aggregate metrics, derived metrics (from already computed aggregate metrics), or drift metrics (comparing metrics across time windows).
DataClassificationConfig LakehouseMonitorDataClassificationConfig
The data classification config for the monitor
InferenceLog LakehouseMonitorInferenceLog
Configuration for the inference log monitor
LatestMonitorFailureMsg string
Notifications LakehouseMonitorNotifications
The notification settings for the monitor. The following optional blocks are supported, each consisting of the single string array field with name email_addresses containing a list of emails to notify:
Schedule LakehouseMonitorSchedule
The schedule for automatically updating and refreshing metric tables. This block consists of following fields:
SkipBuiltinDashboard bool
Whether to skip creating a default dashboard summarizing data quality metrics.
SlicingExprs List<string>
List of column expressions to slice data with for targeted analysis. The data is grouped by each expression independently, resulting in a separate slice for each predicate and its complements. For high-cardinality columns, only the top 100 unique values by frequency will generate slices.
Snapshot LakehouseMonitorSnapshot
Configuration for monitoring snapshot tables.
TimeSeries LakehouseMonitorTimeSeries
Configuration for monitoring timeseries tables.
WarehouseId string
Optional argument to specify the warehouse for dashboard creation. If not specified, the first running warehouse will be used.
AssetsDir This property is required. string
The directory to store the monitoring assets (Eg. Dashboard and Metric Tables)
OutputSchemaName This property is required. string
Schema where output metric tables are created
TableName This property is required. string
The full name of the table to attach the monitor too. Its of the format {catalog}.{schema}.{tableName}
BaselineTableName string
Name of the baseline table from which drift metrics are computed from.Columns in the monitored table should also be present in the baseline table.
CustomMetrics []LakehouseMonitorCustomMetricArgs
Custom metrics to compute on the monitored table. These can be aggregate metrics, derived metrics (from already computed aggregate metrics), or drift metrics (comparing metrics across time windows).
DataClassificationConfig LakehouseMonitorDataClassificationConfigArgs
The data classification config for the monitor
InferenceLog LakehouseMonitorInferenceLogArgs
Configuration for the inference log monitor
LatestMonitorFailureMsg string
Notifications LakehouseMonitorNotificationsArgs
The notification settings for the monitor. The following optional blocks are supported, each consisting of the single string array field with name email_addresses containing a list of emails to notify:
Schedule LakehouseMonitorScheduleArgs
The schedule for automatically updating and refreshing metric tables. This block consists of following fields:
SkipBuiltinDashboard bool
Whether to skip creating a default dashboard summarizing data quality metrics.
SlicingExprs []string
List of column expressions to slice data with for targeted analysis. The data is grouped by each expression independently, resulting in a separate slice for each predicate and its complements. For high-cardinality columns, only the top 100 unique values by frequency will generate slices.
Snapshot LakehouseMonitorSnapshotArgs
Configuration for monitoring snapshot tables.
TimeSeries LakehouseMonitorTimeSeriesArgs
Configuration for monitoring timeseries tables.
WarehouseId string
Optional argument to specify the warehouse for dashboard creation. If not specified, the first running warehouse will be used.
assetsDir This property is required. String
The directory to store the monitoring assets (Eg. Dashboard and Metric Tables)
outputSchemaName This property is required. String
Schema where output metric tables are created
tableName This property is required. String
The full name of the table to attach the monitor too. Its of the format {catalog}.{schema}.{tableName}
baselineTableName String
Name of the baseline table from which drift metrics are computed from.Columns in the monitored table should also be present in the baseline table.
customMetrics List<LakehouseMonitorCustomMetric>
Custom metrics to compute on the monitored table. These can be aggregate metrics, derived metrics (from already computed aggregate metrics), or drift metrics (comparing metrics across time windows).
dataClassificationConfig LakehouseMonitorDataClassificationConfig
The data classification config for the monitor
inferenceLog LakehouseMonitorInferenceLog
Configuration for the inference log monitor
latestMonitorFailureMsg String
notifications LakehouseMonitorNotifications
The notification settings for the monitor. The following optional blocks are supported, each consisting of the single string array field with name email_addresses containing a list of emails to notify:
schedule LakehouseMonitorSchedule
The schedule for automatically updating and refreshing metric tables. This block consists of following fields:
skipBuiltinDashboard Boolean
Whether to skip creating a default dashboard summarizing data quality metrics.
slicingExprs List<String>
List of column expressions to slice data with for targeted analysis. The data is grouped by each expression independently, resulting in a separate slice for each predicate and its complements. For high-cardinality columns, only the top 100 unique values by frequency will generate slices.
snapshot LakehouseMonitorSnapshot
Configuration for monitoring snapshot tables.
timeSeries LakehouseMonitorTimeSeries
Configuration for monitoring timeseries tables.
warehouseId String
Optional argument to specify the warehouse for dashboard creation. If not specified, the first running warehouse will be used.
assetsDir This property is required. string
The directory to store the monitoring assets (Eg. Dashboard and Metric Tables)
outputSchemaName This property is required. string
Schema where output metric tables are created
tableName This property is required. string
The full name of the table to attach the monitor too. Its of the format {catalog}.{schema}.{tableName}
baselineTableName string
Name of the baseline table from which drift metrics are computed from.Columns in the monitored table should also be present in the baseline table.
customMetrics LakehouseMonitorCustomMetric[]
Custom metrics to compute on the monitored table. These can be aggregate metrics, derived metrics (from already computed aggregate metrics), or drift metrics (comparing metrics across time windows).
dataClassificationConfig LakehouseMonitorDataClassificationConfig
The data classification config for the monitor
inferenceLog LakehouseMonitorInferenceLog
Configuration for the inference log monitor
latestMonitorFailureMsg string
notifications LakehouseMonitorNotifications
The notification settings for the monitor. The following optional blocks are supported, each consisting of the single string array field with name email_addresses containing a list of emails to notify:
schedule LakehouseMonitorSchedule
The schedule for automatically updating and refreshing metric tables. This block consists of following fields:
skipBuiltinDashboard boolean
Whether to skip creating a default dashboard summarizing data quality metrics.
slicingExprs string[]
List of column expressions to slice data with for targeted analysis. The data is grouped by each expression independently, resulting in a separate slice for each predicate and its complements. For high-cardinality columns, only the top 100 unique values by frequency will generate slices.
snapshot LakehouseMonitorSnapshot
Configuration for monitoring snapshot tables.
timeSeries LakehouseMonitorTimeSeries
Configuration for monitoring timeseries tables.
warehouseId string
Optional argument to specify the warehouse for dashboard creation. If not specified, the first running warehouse will be used.
assets_dir This property is required. str
The directory to store the monitoring assets (Eg. Dashboard and Metric Tables)
output_schema_name This property is required. str
Schema where output metric tables are created
table_name This property is required. str
The full name of the table to attach the monitor too. Its of the format {catalog}.{schema}.{tableName}
baseline_table_name str
Name of the baseline table from which drift metrics are computed from.Columns in the monitored table should also be present in the baseline table.
custom_metrics Sequence[LakehouseMonitorCustomMetricArgs]
Custom metrics to compute on the monitored table. These can be aggregate metrics, derived metrics (from already computed aggregate metrics), or drift metrics (comparing metrics across time windows).
data_classification_config LakehouseMonitorDataClassificationConfigArgs
The data classification config for the monitor
inference_log LakehouseMonitorInferenceLogArgs
Configuration for the inference log monitor
latest_monitor_failure_msg str
notifications LakehouseMonitorNotificationsArgs
The notification settings for the monitor. The following optional blocks are supported, each consisting of the single string array field with name email_addresses containing a list of emails to notify:
schedule LakehouseMonitorScheduleArgs
The schedule for automatically updating and refreshing metric tables. This block consists of following fields:
skip_builtin_dashboard bool
Whether to skip creating a default dashboard summarizing data quality metrics.
slicing_exprs Sequence[str]
List of column expressions to slice data with for targeted analysis. The data is grouped by each expression independently, resulting in a separate slice for each predicate and its complements. For high-cardinality columns, only the top 100 unique values by frequency will generate slices.
snapshot LakehouseMonitorSnapshotArgs
Configuration for monitoring snapshot tables.
time_series LakehouseMonitorTimeSeriesArgs
Configuration for monitoring timeseries tables.
warehouse_id str
Optional argument to specify the warehouse for dashboard creation. If not specified, the first running warehouse will be used.
assetsDir This property is required. String
The directory to store the monitoring assets (Eg. Dashboard and Metric Tables)
outputSchemaName This property is required. String
Schema where output metric tables are created
tableName This property is required. String
The full name of the table to attach the monitor too. Its of the format {catalog}.{schema}.{tableName}
baselineTableName String
Name of the baseline table from which drift metrics are computed from.Columns in the monitored table should also be present in the baseline table.
customMetrics List<Property Map>
Custom metrics to compute on the monitored table. These can be aggregate metrics, derived metrics (from already computed aggregate metrics), or drift metrics (comparing metrics across time windows).
dataClassificationConfig Property Map
The data classification config for the monitor
inferenceLog Property Map
Configuration for the inference log monitor
latestMonitorFailureMsg String
notifications Property Map
The notification settings for the monitor. The following optional blocks are supported, each consisting of the single string array field with name email_addresses containing a list of emails to notify:
schedule Property Map
The schedule for automatically updating and refreshing metric tables. This block consists of following fields:
skipBuiltinDashboard Boolean
Whether to skip creating a default dashboard summarizing data quality metrics.
slicingExprs List<String>
List of column expressions to slice data with for targeted analysis. The data is grouped by each expression independently, resulting in a separate slice for each predicate and its complements. For high-cardinality columns, only the top 100 unique values by frequency will generate slices.
snapshot Property Map
Configuration for monitoring snapshot tables.
timeSeries Property Map
Configuration for monitoring timeseries tables.
warehouseId String
Optional argument to specify the warehouse for dashboard creation. If not specified, the first running warehouse will be used.

Outputs

All input properties are implicitly available as output properties. Additionally, the LakehouseMonitor resource produces the following output properties:

DashboardId string
The ID of the generated dashboard.
DriftMetricsTableName string
The full name of the drift metrics table. Format: catalog_name.schema_name.table_name.
Id string
The provider-assigned unique ID for this managed resource.
MonitorVersion string
The version of the monitor config (e.g. 1,2,3). If negative, the monitor may be corrupted
ProfileMetricsTableName string
The full name of the profile metrics table. Format: catalog_name.schema_name.table_name.
Status string
Status of the Monitor
DashboardId string
The ID of the generated dashboard.
DriftMetricsTableName string
The full name of the drift metrics table. Format: catalog_name.schema_name.table_name.
Id string
The provider-assigned unique ID for this managed resource.
MonitorVersion string
The version of the monitor config (e.g. 1,2,3). If negative, the monitor may be corrupted
ProfileMetricsTableName string
The full name of the profile metrics table. Format: catalog_name.schema_name.table_name.
Status string
Status of the Monitor
dashboardId String
The ID of the generated dashboard.
driftMetricsTableName String
The full name of the drift metrics table. Format: catalog_name.schema_name.table_name.
id String
The provider-assigned unique ID for this managed resource.
monitorVersion String
The version of the monitor config (e.g. 1,2,3). If negative, the monitor may be corrupted
profileMetricsTableName String
The full name of the profile metrics table. Format: catalog_name.schema_name.table_name.
status String
Status of the Monitor
dashboardId string
The ID of the generated dashboard.
driftMetricsTableName string
The full name of the drift metrics table. Format: catalog_name.schema_name.table_name.
id string
The provider-assigned unique ID for this managed resource.
monitorVersion string
The version of the monitor config (e.g. 1,2,3). If negative, the monitor may be corrupted
profileMetricsTableName string
The full name of the profile metrics table. Format: catalog_name.schema_name.table_name.
status string
Status of the Monitor
dashboard_id str
The ID of the generated dashboard.
drift_metrics_table_name str
The full name of the drift metrics table. Format: catalog_name.schema_name.table_name.
id str
The provider-assigned unique ID for this managed resource.
monitor_version str
The version of the monitor config (e.g. 1,2,3). If negative, the monitor may be corrupted
profile_metrics_table_name str
The full name of the profile metrics table. Format: catalog_name.schema_name.table_name.
status str
Status of the Monitor
dashboardId String
The ID of the generated dashboard.
driftMetricsTableName String
The full name of the drift metrics table. Format: catalog_name.schema_name.table_name.
id String
The provider-assigned unique ID for this managed resource.
monitorVersion String
The version of the monitor config (e.g. 1,2,3). If negative, the monitor may be corrupted
profileMetricsTableName String
The full name of the profile metrics table. Format: catalog_name.schema_name.table_name.
status String
Status of the Monitor

Look up Existing LakehouseMonitor Resource

Get an existing LakehouseMonitor resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

public static get(name: string, id: Input<ID>, state?: LakehouseMonitorState, opts?: CustomResourceOptions): LakehouseMonitor
@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        assets_dir: Optional[str] = None,
        baseline_table_name: Optional[str] = None,
        custom_metrics: Optional[Sequence[LakehouseMonitorCustomMetricArgs]] = None,
        dashboard_id: Optional[str] = None,
        data_classification_config: Optional[LakehouseMonitorDataClassificationConfigArgs] = None,
        drift_metrics_table_name: Optional[str] = None,
        inference_log: Optional[LakehouseMonitorInferenceLogArgs] = None,
        latest_monitor_failure_msg: Optional[str] = None,
        monitor_version: Optional[str] = None,
        notifications: Optional[LakehouseMonitorNotificationsArgs] = None,
        output_schema_name: Optional[str] = None,
        profile_metrics_table_name: Optional[str] = None,
        schedule: Optional[LakehouseMonitorScheduleArgs] = None,
        skip_builtin_dashboard: Optional[bool] = None,
        slicing_exprs: Optional[Sequence[str]] = None,
        snapshot: Optional[LakehouseMonitorSnapshotArgs] = None,
        status: Optional[str] = None,
        table_name: Optional[str] = None,
        time_series: Optional[LakehouseMonitorTimeSeriesArgs] = None,
        warehouse_id: Optional[str] = None) -> LakehouseMonitor
func GetLakehouseMonitor(ctx *Context, name string, id IDInput, state *LakehouseMonitorState, opts ...ResourceOption) (*LakehouseMonitor, error)
public static LakehouseMonitor Get(string name, Input<string> id, LakehouseMonitorState? state, CustomResourceOptions? opts = null)
public static LakehouseMonitor get(String name, Output<String> id, LakehouseMonitorState state, CustomResourceOptions options)
resources:  _:    type: databricks:LakehouseMonitor    get:      id: ${id}
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
resource_name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
The following state arguments are supported:
AssetsDir string
The directory to store the monitoring assets (Eg. Dashboard and Metric Tables)
BaselineTableName string
Name of the baseline table from which drift metrics are computed from.Columns in the monitored table should also be present in the baseline table.
CustomMetrics List<LakehouseMonitorCustomMetric>
Custom metrics to compute on the monitored table. These can be aggregate metrics, derived metrics (from already computed aggregate metrics), or drift metrics (comparing metrics across time windows).
DashboardId string
The ID of the generated dashboard.
DataClassificationConfig LakehouseMonitorDataClassificationConfig
The data classification config for the monitor
DriftMetricsTableName string
The full name of the drift metrics table. Format: catalog_name.schema_name.table_name.
InferenceLog LakehouseMonitorInferenceLog
Configuration for the inference log monitor
LatestMonitorFailureMsg string
MonitorVersion string
The version of the monitor config (e.g. 1,2,3). If negative, the monitor may be corrupted
Notifications LakehouseMonitorNotifications
The notification settings for the monitor. The following optional blocks are supported, each consisting of the single string array field with name email_addresses containing a list of emails to notify:
OutputSchemaName string
Schema where output metric tables are created
ProfileMetricsTableName string
The full name of the profile metrics table. Format: catalog_name.schema_name.table_name.
Schedule LakehouseMonitorSchedule
The schedule for automatically updating and refreshing metric tables. This block consists of following fields:
SkipBuiltinDashboard bool
Whether to skip creating a default dashboard summarizing data quality metrics.
SlicingExprs List<string>
List of column expressions to slice data with for targeted analysis. The data is grouped by each expression independently, resulting in a separate slice for each predicate and its complements. For high-cardinality columns, only the top 100 unique values by frequency will generate slices.
Snapshot LakehouseMonitorSnapshot
Configuration for monitoring snapshot tables.
Status string
Status of the Monitor
TableName string
The full name of the table to attach the monitor too. Its of the format {catalog}.{schema}.{tableName}
TimeSeries LakehouseMonitorTimeSeries
Configuration for monitoring timeseries tables.
WarehouseId string
Optional argument to specify the warehouse for dashboard creation. If not specified, the first running warehouse will be used.
AssetsDir string
The directory to store the monitoring assets (Eg. Dashboard and Metric Tables)
BaselineTableName string
Name of the baseline table from which drift metrics are computed from.Columns in the monitored table should also be present in the baseline table.
CustomMetrics []LakehouseMonitorCustomMetricArgs
Custom metrics to compute on the monitored table. These can be aggregate metrics, derived metrics (from already computed aggregate metrics), or drift metrics (comparing metrics across time windows).
DashboardId string
The ID of the generated dashboard.
DataClassificationConfig LakehouseMonitorDataClassificationConfigArgs
The data classification config for the monitor
DriftMetricsTableName string
The full name of the drift metrics table. Format: catalog_name.schema_name.table_name.
InferenceLog LakehouseMonitorInferenceLogArgs
Configuration for the inference log monitor
LatestMonitorFailureMsg string
MonitorVersion string
The version of the monitor config (e.g. 1,2,3). If negative, the monitor may be corrupted
Notifications LakehouseMonitorNotificationsArgs
The notification settings for the monitor. The following optional blocks are supported, each consisting of the single string array field with name email_addresses containing a list of emails to notify:
OutputSchemaName string
Schema where output metric tables are created
ProfileMetricsTableName string
The full name of the profile metrics table. Format: catalog_name.schema_name.table_name.
Schedule LakehouseMonitorScheduleArgs
The schedule for automatically updating and refreshing metric tables. This block consists of following fields:
SkipBuiltinDashboard bool
Whether to skip creating a default dashboard summarizing data quality metrics.
SlicingExprs []string
List of column expressions to slice data with for targeted analysis. The data is grouped by each expression independently, resulting in a separate slice for each predicate and its complements. For high-cardinality columns, only the top 100 unique values by frequency will generate slices.
Snapshot LakehouseMonitorSnapshotArgs
Configuration for monitoring snapshot tables.
Status string
Status of the Monitor
TableName string
The full name of the table to attach the monitor too. Its of the format {catalog}.{schema}.{tableName}
TimeSeries LakehouseMonitorTimeSeriesArgs
Configuration for monitoring timeseries tables.
WarehouseId string
Optional argument to specify the warehouse for dashboard creation. If not specified, the first running warehouse will be used.
assetsDir String
The directory to store the monitoring assets (Eg. Dashboard and Metric Tables)
baselineTableName String
Name of the baseline table from which drift metrics are computed from.Columns in the monitored table should also be present in the baseline table.
customMetrics List<LakehouseMonitorCustomMetric>
Custom metrics to compute on the monitored table. These can be aggregate metrics, derived metrics (from already computed aggregate metrics), or drift metrics (comparing metrics across time windows).
dashboardId String
The ID of the generated dashboard.
dataClassificationConfig LakehouseMonitorDataClassificationConfig
The data classification config for the monitor
driftMetricsTableName String
The full name of the drift metrics table. Format: catalog_name.schema_name.table_name.
inferenceLog LakehouseMonitorInferenceLog
Configuration for the inference log monitor
latestMonitorFailureMsg String
monitorVersion String
The version of the monitor config (e.g. 1,2,3). If negative, the monitor may be corrupted
notifications LakehouseMonitorNotifications
The notification settings for the monitor. The following optional blocks are supported, each consisting of the single string array field with name email_addresses containing a list of emails to notify:
outputSchemaName String
Schema where output metric tables are created
profileMetricsTableName String
The full name of the profile metrics table. Format: catalog_name.schema_name.table_name.
schedule LakehouseMonitorSchedule
The schedule for automatically updating and refreshing metric tables. This block consists of following fields:
skipBuiltinDashboard Boolean
Whether to skip creating a default dashboard summarizing data quality metrics.
slicingExprs List<String>
List of column expressions to slice data with for targeted analysis. The data is grouped by each expression independently, resulting in a separate slice for each predicate and its complements. For high-cardinality columns, only the top 100 unique values by frequency will generate slices.
snapshot LakehouseMonitorSnapshot
Configuration for monitoring snapshot tables.
status String
Status of the Monitor
tableName String
The full name of the table to attach the monitor too. Its of the format {catalog}.{schema}.{tableName}
timeSeries LakehouseMonitorTimeSeries
Configuration for monitoring timeseries tables.
warehouseId String
Optional argument to specify the warehouse for dashboard creation. If not specified, the first running warehouse will be used.
assetsDir string
The directory to store the monitoring assets (Eg. Dashboard and Metric Tables)
baselineTableName string
Name of the baseline table from which drift metrics are computed from.Columns in the monitored table should also be present in the baseline table.
customMetrics LakehouseMonitorCustomMetric[]
Custom metrics to compute on the monitored table. These can be aggregate metrics, derived metrics (from already computed aggregate metrics), or drift metrics (comparing metrics across time windows).
dashboardId string
The ID of the generated dashboard.
dataClassificationConfig LakehouseMonitorDataClassificationConfig
The data classification config for the monitor
driftMetricsTableName string
The full name of the drift metrics table. Format: catalog_name.schema_name.table_name.
inferenceLog LakehouseMonitorInferenceLog
Configuration for the inference log monitor
latestMonitorFailureMsg string
monitorVersion string
The version of the monitor config (e.g. 1,2,3). If negative, the monitor may be corrupted
notifications LakehouseMonitorNotifications
The notification settings for the monitor. The following optional blocks are supported, each consisting of the single string array field with name email_addresses containing a list of emails to notify:
outputSchemaName string
Schema where output metric tables are created
profileMetricsTableName string
The full name of the profile metrics table. Format: catalog_name.schema_name.table_name.
schedule LakehouseMonitorSchedule
The schedule for automatically updating and refreshing metric tables. This block consists of following fields:
skipBuiltinDashboard boolean
Whether to skip creating a default dashboard summarizing data quality metrics.
slicingExprs string[]
List of column expressions to slice data with for targeted analysis. The data is grouped by each expression independently, resulting in a separate slice for each predicate and its complements. For high-cardinality columns, only the top 100 unique values by frequency will generate slices.
snapshot LakehouseMonitorSnapshot
Configuration for monitoring snapshot tables.
status string
Status of the Monitor
tableName string
The full name of the table to attach the monitor too. Its of the format {catalog}.{schema}.{tableName}
timeSeries LakehouseMonitorTimeSeries
Configuration for monitoring timeseries tables.
warehouseId string
Optional argument to specify the warehouse for dashboard creation. If not specified, the first running warehouse will be used.
assets_dir str
The directory to store the monitoring assets (Eg. Dashboard and Metric Tables)
baseline_table_name str
Name of the baseline table from which drift metrics are computed from.Columns in the monitored table should also be present in the baseline table.
custom_metrics Sequence[LakehouseMonitorCustomMetricArgs]
Custom metrics to compute on the monitored table. These can be aggregate metrics, derived metrics (from already computed aggregate metrics), or drift metrics (comparing metrics across time windows).
dashboard_id str
The ID of the generated dashboard.
data_classification_config LakehouseMonitorDataClassificationConfigArgs
The data classification config for the monitor
drift_metrics_table_name str
The full name of the drift metrics table. Format: catalog_name.schema_name.table_name.
inference_log LakehouseMonitorInferenceLogArgs
Configuration for the inference log monitor
latest_monitor_failure_msg str
monitor_version str
The version of the monitor config (e.g. 1,2,3). If negative, the monitor may be corrupted
notifications LakehouseMonitorNotificationsArgs
The notification settings for the monitor. The following optional blocks are supported, each consisting of the single string array field with name email_addresses containing a list of emails to notify:
output_schema_name str
Schema where output metric tables are created
profile_metrics_table_name str
The full name of the profile metrics table. Format: catalog_name.schema_name.table_name.
schedule LakehouseMonitorScheduleArgs
The schedule for automatically updating and refreshing metric tables. This block consists of following fields:
skip_builtin_dashboard bool
Whether to skip creating a default dashboard summarizing data quality metrics.
slicing_exprs Sequence[str]
List of column expressions to slice data with for targeted analysis. The data is grouped by each expression independently, resulting in a separate slice for each predicate and its complements. For high-cardinality columns, only the top 100 unique values by frequency will generate slices.
snapshot LakehouseMonitorSnapshotArgs
Configuration for monitoring snapshot tables.
status str
Status of the Monitor
table_name str
The full name of the table to attach the monitor too. Its of the format {catalog}.{schema}.{tableName}
time_series LakehouseMonitorTimeSeriesArgs
Configuration for monitoring timeseries tables.
warehouse_id str
Optional argument to specify the warehouse for dashboard creation. If not specified, the first running warehouse will be used.
assetsDir String
The directory to store the monitoring assets (Eg. Dashboard and Metric Tables)
baselineTableName String
Name of the baseline table from which drift metrics are computed from.Columns in the monitored table should also be present in the baseline table.
customMetrics List<Property Map>
Custom metrics to compute on the monitored table. These can be aggregate metrics, derived metrics (from already computed aggregate metrics), or drift metrics (comparing metrics across time windows).
dashboardId String
The ID of the generated dashboard.
dataClassificationConfig Property Map
The data classification config for the monitor
driftMetricsTableName String
The full name of the drift metrics table. Format: catalog_name.schema_name.table_name.
inferenceLog Property Map
Configuration for the inference log monitor
latestMonitorFailureMsg String
monitorVersion String
The version of the monitor config (e.g. 1,2,3). If negative, the monitor may be corrupted
notifications Property Map
The notification settings for the monitor. The following optional blocks are supported, each consisting of the single string array field with name email_addresses containing a list of emails to notify:
outputSchemaName String
Schema where output metric tables are created
profileMetricsTableName String
The full name of the profile metrics table. Format: catalog_name.schema_name.table_name.
schedule Property Map
The schedule for automatically updating and refreshing metric tables. This block consists of following fields:
skipBuiltinDashboard Boolean
Whether to skip creating a default dashboard summarizing data quality metrics.
slicingExprs List<String>
List of column expressions to slice data with for targeted analysis. The data is grouped by each expression independently, resulting in a separate slice for each predicate and its complements. For high-cardinality columns, only the top 100 unique values by frequency will generate slices.
snapshot Property Map
Configuration for monitoring snapshot tables.
status String
Status of the Monitor
tableName String
The full name of the table to attach the monitor too. Its of the format {catalog}.{schema}.{tableName}
timeSeries Property Map
Configuration for monitoring timeseries tables.
warehouseId String
Optional argument to specify the warehouse for dashboard creation. If not specified, the first running warehouse will be used.

Supporting Types

LakehouseMonitorCustomMetric
, LakehouseMonitorCustomMetricArgs

Definition This property is required. string
create metric definition
InputColumns This property is required. List<string>
Columns on the monitored table to apply the custom metrics to.
Name This property is required. string
Name of the custom metric.
OutputDataType This property is required. string
The output type of the custom metric.
Type This property is required. string
The type of the custom metric.
Definition This property is required. string
create metric definition
InputColumns This property is required. []string
Columns on the monitored table to apply the custom metrics to.
Name This property is required. string
Name of the custom metric.
OutputDataType This property is required. string
The output type of the custom metric.
Type This property is required. string
The type of the custom metric.
definition This property is required. String
create metric definition
inputColumns This property is required. List<String>
Columns on the monitored table to apply the custom metrics to.
name This property is required. String
Name of the custom metric.
outputDataType This property is required. String
The output type of the custom metric.
type This property is required. String
The type of the custom metric.
definition This property is required. string
create metric definition
inputColumns This property is required. string[]
Columns on the monitored table to apply the custom metrics to.
name This property is required. string
Name of the custom metric.
outputDataType This property is required. string
The output type of the custom metric.
type This property is required. string
The type of the custom metric.
definition This property is required. str
create metric definition
input_columns This property is required. Sequence[str]
Columns on the monitored table to apply the custom metrics to.
name This property is required. str
Name of the custom metric.
output_data_type This property is required. str
The output type of the custom metric.
type This property is required. str
The type of the custom metric.
definition This property is required. String
create metric definition
inputColumns This property is required. List<String>
Columns on the monitored table to apply the custom metrics to.
name This property is required. String
Name of the custom metric.
outputDataType This property is required. String
The output type of the custom metric.
type This property is required. String
The type of the custom metric.

LakehouseMonitorDataClassificationConfig
, LakehouseMonitorDataClassificationConfigArgs

Enabled bool
Enabled bool
enabled Boolean
enabled boolean
enabled bool
enabled Boolean

LakehouseMonitorInferenceLog
, LakehouseMonitorInferenceLogArgs

Granularities This property is required. List<string>
List of granularities to use when aggregating data into time windows based on their timestamp.
ModelIdCol This property is required. string
Column of the model id or version
PredictionCol This property is required. string
Column of the model prediction
ProblemType This property is required. string
Problem type the model aims to solve. Either PROBLEM_TYPE_CLASSIFICATION or PROBLEM_TYPE_REGRESSION
TimestampCol This property is required. string
Column of the timestamp of predictions
LabelCol string
Column of the model label
PredictionProbaCol string
Column of the model prediction probabilities
Granularities This property is required. []string
List of granularities to use when aggregating data into time windows based on their timestamp.
ModelIdCol This property is required. string
Column of the model id or version
PredictionCol This property is required. string
Column of the model prediction
ProblemType This property is required. string
Problem type the model aims to solve. Either PROBLEM_TYPE_CLASSIFICATION or PROBLEM_TYPE_REGRESSION
TimestampCol This property is required. string
Column of the timestamp of predictions
LabelCol string
Column of the model label
PredictionProbaCol string
Column of the model prediction probabilities
granularities This property is required. List<String>
List of granularities to use when aggregating data into time windows based on their timestamp.
modelIdCol This property is required. String
Column of the model id or version
predictionCol This property is required. String
Column of the model prediction
problemType This property is required. String
Problem type the model aims to solve. Either PROBLEM_TYPE_CLASSIFICATION or PROBLEM_TYPE_REGRESSION
timestampCol This property is required. String
Column of the timestamp of predictions
labelCol String
Column of the model label
predictionProbaCol String
Column of the model prediction probabilities
granularities This property is required. string[]
List of granularities to use when aggregating data into time windows based on their timestamp.
modelIdCol This property is required. string
Column of the model id or version
predictionCol This property is required. string
Column of the model prediction
problemType This property is required. string
Problem type the model aims to solve. Either PROBLEM_TYPE_CLASSIFICATION or PROBLEM_TYPE_REGRESSION
timestampCol This property is required. string
Column of the timestamp of predictions
labelCol string
Column of the model label
predictionProbaCol string
Column of the model prediction probabilities
granularities This property is required. Sequence[str]
List of granularities to use when aggregating data into time windows based on their timestamp.
model_id_col This property is required. str
Column of the model id or version
prediction_col This property is required. str
Column of the model prediction
problem_type This property is required. str
Problem type the model aims to solve. Either PROBLEM_TYPE_CLASSIFICATION or PROBLEM_TYPE_REGRESSION
timestamp_col This property is required. str
Column of the timestamp of predictions
label_col str
Column of the model label
prediction_proba_col str
Column of the model prediction probabilities
granularities This property is required. List<String>
List of granularities to use when aggregating data into time windows based on their timestamp.
modelIdCol This property is required. String
Column of the model id or version
predictionCol This property is required. String
Column of the model prediction
problemType This property is required. String
Problem type the model aims to solve. Either PROBLEM_TYPE_CLASSIFICATION or PROBLEM_TYPE_REGRESSION
timestampCol This property is required. String
Column of the timestamp of predictions
labelCol String
Column of the model label
predictionProbaCol String
Column of the model prediction probabilities

LakehouseMonitorNotifications
, LakehouseMonitorNotificationsArgs

OnFailure LakehouseMonitorNotificationsOnFailure
who to send notifications to on monitor failure.
OnNewClassificationTagDetected LakehouseMonitorNotificationsOnNewClassificationTagDetected
Who to send notifications to when new data classification tags are detected.
OnFailure LakehouseMonitorNotificationsOnFailure
who to send notifications to on monitor failure.
OnNewClassificationTagDetected LakehouseMonitorNotificationsOnNewClassificationTagDetected
Who to send notifications to when new data classification tags are detected.
onFailure LakehouseMonitorNotificationsOnFailure
who to send notifications to on monitor failure.
onNewClassificationTagDetected LakehouseMonitorNotificationsOnNewClassificationTagDetected
Who to send notifications to when new data classification tags are detected.
onFailure LakehouseMonitorNotificationsOnFailure
who to send notifications to on monitor failure.
onNewClassificationTagDetected LakehouseMonitorNotificationsOnNewClassificationTagDetected
Who to send notifications to when new data classification tags are detected.
on_failure LakehouseMonitorNotificationsOnFailure
who to send notifications to on monitor failure.
on_new_classification_tag_detected LakehouseMonitorNotificationsOnNewClassificationTagDetected
Who to send notifications to when new data classification tags are detected.
onFailure Property Map
who to send notifications to on monitor failure.
onNewClassificationTagDetected Property Map
Who to send notifications to when new data classification tags are detected.

LakehouseMonitorNotificationsOnFailure
, LakehouseMonitorNotificationsOnFailureArgs

EmailAddresses List<string>
emailAddresses List<String>
email_addresses Sequence[str]
emailAddresses List<String>

LakehouseMonitorNotificationsOnNewClassificationTagDetected
, LakehouseMonitorNotificationsOnNewClassificationTagDetectedArgs

EmailAddresses List<string>
emailAddresses List<String>
email_addresses Sequence[str]
emailAddresses List<String>

LakehouseMonitorSchedule
, LakehouseMonitorScheduleArgs

QuartzCronExpression This property is required. string
string expression that determines when to run the monitor. See Quartz documentation for examples.
TimezoneId This property is required. string
string with timezone id (e.g., PST) in which to evaluate the Quartz expression.
PauseStatus string
optional string field that indicates whether a schedule is paused (PAUSED) or not (UNPAUSED).
QuartzCronExpression This property is required. string
string expression that determines when to run the monitor. See Quartz documentation for examples.
TimezoneId This property is required. string
string with timezone id (e.g., PST) in which to evaluate the Quartz expression.
PauseStatus string
optional string field that indicates whether a schedule is paused (PAUSED) or not (UNPAUSED).
quartzCronExpression This property is required. String
string expression that determines when to run the monitor. See Quartz documentation for examples.
timezoneId This property is required. String
string with timezone id (e.g., PST) in which to evaluate the Quartz expression.
pauseStatus String
optional string field that indicates whether a schedule is paused (PAUSED) or not (UNPAUSED).
quartzCronExpression This property is required. string
string expression that determines when to run the monitor. See Quartz documentation for examples.
timezoneId This property is required. string
string with timezone id (e.g., PST) in which to evaluate the Quartz expression.
pauseStatus string
optional string field that indicates whether a schedule is paused (PAUSED) or not (UNPAUSED).
quartz_cron_expression This property is required. str
string expression that determines when to run the monitor. See Quartz documentation for examples.
timezone_id This property is required. str
string with timezone id (e.g., PST) in which to evaluate the Quartz expression.
pause_status str
optional string field that indicates whether a schedule is paused (PAUSED) or not (UNPAUSED).
quartzCronExpression This property is required. String
string expression that determines when to run the monitor. See Quartz documentation for examples.
timezoneId This property is required. String
string with timezone id (e.g., PST) in which to evaluate the Quartz expression.
pauseStatus String
optional string field that indicates whether a schedule is paused (PAUSED) or not (UNPAUSED).

LakehouseMonitorTimeSeries
, LakehouseMonitorTimeSeriesArgs

Granularities This property is required. List<string>
List of granularities to use when aggregating data into time windows based on their timestamp.
TimestampCol This property is required. string
Column of the timestamp of predictions
Granularities This property is required. []string
List of granularities to use when aggregating data into time windows based on their timestamp.
TimestampCol This property is required. string
Column of the timestamp of predictions
granularities This property is required. List<String>
List of granularities to use when aggregating data into time windows based on their timestamp.
timestampCol This property is required. String
Column of the timestamp of predictions
granularities This property is required. string[]
List of granularities to use when aggregating data into time windows based on their timestamp.
timestampCol This property is required. string
Column of the timestamp of predictions
granularities This property is required. Sequence[str]
List of granularities to use when aggregating data into time windows based on their timestamp.
timestamp_col This property is required. str
Column of the timestamp of predictions
granularities This property is required. List<String>
List of granularities to use when aggregating data into time windows based on their timestamp.
timestampCol This property is required. String
Column of the timestamp of predictions

Package Details

Repository
databricks pulumi/pulumi-databricks
License
Apache-2.0
Notes
This Pulumi package is based on the databricks Terraform Provider.
Databricks v1.63.0 published on Thursday, Mar 13, 2025 by Pulumi
pulumi/pulumi-databricks