Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi IDP Pulumi Cloud Packages Tutorials
  1. Packages
  2. Honeycombio Provider
  3. API Docs
  4. FlexibleBoard
honeycombio 0.35.0 published on Wednesday, May 14, 2025 by honeycombio
honeycombio/terraform-provider-honeycombio

honeycombio.FlexibleBoard

Explore with Pulumi AI

honeycombio logo
honeycombio 0.35.0 published on Wednesday, May 14, 2025 by honeycombio
honeycombio/terraform-provider-honeycombio

    # Resource: honeycombio.FlexibleBoard

    Creates a flexible board. For more information about boards, check out Create Custom Boards.

    Example Usage

    Simple Flexible Board

    import * as pulumi from "@pulumi/pulumi";
import * as fs from "fs";
import * as honeycombio from "@pulumi/honeycombio";

const config = new pulumi.Config();
const dataset = config.require("dataset");
const latencyByUseridQuerySpecification = honeycombio.getQuerySpecification({
    timeRange: 86400,
    breakdowns: ["app.user_id"],
    calculations: [
        {
            op: "HEATMAP",
            column: "duration_ms",
        },
        {
            op: "P99",
            column: "duration_ms",
        },
    ],
    filters: [{
        column: "trace.parent_id",
        op: "does-not-exist",
    }],
    orders: [{
        column: "duration_ms",
        op: "P99",
        order: "descending",
    }],
});
const latencyByUseridQuery = new honeycombio.Query("latencyByUseridQuery", {
    dataset: dataset,
    queryJson: latencyByUseridQuerySpecification.then(latencyByUseridQuerySpecification => latencyByUseridQuerySpecification.json),
});
const latencyByUseridQueryAnnotation = new honeycombio.QueryAnnotation("latencyByUseridQueryAnnotation", {
    dataset: dataset,
    queryId: latencyByUseridQuery.id,
    description: "A breakdown of trace latency by User over the last 24 hours",
});
const requestLatencySli = new honeycombio.DerivedColumn("requestLatencySli", {
    alias: "sli.request_latency",
    description: "SLI: request latency less than 300ms",
    dataset: dataset,
    expression: fs.readFileSync("../sli/sli.request_latency.honeycomb", "utf8"),
});
const slo = new honeycombio.Slo("slo", {
    description: "example SLO",
    dataset: dataset,
    sli: requestLatencySli.alias,
    targetPercentage: 99.9,
    timePeriod: 30,
    tags: {
        team: "web",
    },
});
const overview = new honeycombio.FlexibleBoard("overview", {
    description: "My flexible baord description",
    panels: [
        {
            type: "query",
            positions: [{
                xCoordinate: 0,
                yCoordinate: 0,
                width: 6,
                height: 6,
            }],
            queryPanels: [{
                queryId: latencyByUseridQuery.id,
                queryAnnotationId: latencyByUseridQueryAnnotation.queryAnnotationId,
                queryStyle: "combo",
                visualizationSettings: [{
                    useUtcXaxis: true,
                    charts: [{
                        chartType: "line",
                        chartIndex: 0,
                        omitMissingValues: true,
                        useLogScale: true,
                    }],
                }],
            }],
        },
        {
            type: "slo",
            sloPanels: [{
                sloId: slo.sloId,
            }],
        },
    ],
});

    import pulumi
import pulumi_honeycombio as honeycombio

config = pulumi.Config()
dataset = config.require("dataset")
latency_by_userid_query_specification = honeycombio.get_query_specification(time_range=86400,
    breakdowns=["app.user_id"],
    calculations=[
        {
            "op": "HEATMAP",
            "column": "duration_ms",
        },
        {
            "op": "P99",
            "column": "duration_ms",
        },
    ],
    filters=[{
        "column": "trace.parent_id",
        "op": "does-not-exist",
    }],
    orders=[{
        "column": "duration_ms",
        "op": "P99",
        "order": "descending",
    }])
latency_by_userid_query = honeycombio.Query("latencyByUseridQuery",
    dataset=dataset,
    query_json=latency_by_userid_query_specification.json)
latency_by_userid_query_annotation = honeycombio.QueryAnnotation("latencyByUseridQueryAnnotation",
    dataset=dataset,
    query_id=latency_by_userid_query.id,
    description="A breakdown of trace latency by User over the last 24 hours")
request_latency_sli = honeycombio.DerivedColumn("requestLatencySli",
    alias="sli.request_latency",
    description="SLI: request latency less than 300ms",
    dataset=dataset,
    expression=(lambda path: open(path).read())("../sli/sli.request_latency.honeycomb"))
slo = honeycombio.Slo("slo",
    description="example SLO",
    dataset=dataset,
    sli=request_latency_sli.alias,
    target_percentage=99.9,
    time_period=30,
    tags={
        "team": "web",
    })
overview = honeycombio.FlexibleBoard("overview",
    description="My flexible baord description",
    panels=[
        {
            "type": "query",
            "positions": [{
                "x_coordinate": 0,
                "y_coordinate": 0,
                "width": 6,
                "height": 6,
            }],
            "query_panels": [{
                "query_id": latency_by_userid_query.id,
                "query_annotation_id": latency_by_userid_query_annotation.query_annotation_id,
                "query_style": "combo",
                "visualization_settings": [{
                    "use_utc_xaxis": True,
                    "charts": [{
                        "chart_type": "line",
                        "chart_index": 0,
                        "omit_missing_values": True,
                        "use_log_scale": True,
                    }],
                }],
            }],
        },
        {
            "type": "slo",
            "slo_panels": [{
                "slo_id": slo.slo_id,
            }],
        },
    ])

    package main

import (
	"os"

	"github.com/pulumi/pulumi-terraform-provider/sdks/go/honeycombio/honeycombio"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func readFileOrPanic(path string) pulumi.StringPtrInput {
	data, err := os.ReadFile(path)
	if err != nil {
		panic(err.Error())
	}
	return pulumi.String(string(data))
}

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		dataset := cfg.Require("dataset")
		latencyByUseridQuerySpecification, err := honeycombio.GetQuerySpecification(ctx, &honeycombio.GetQuerySpecificationArgs{
			TimeRange: pulumi.Float64Ref(86400),
			Breakdowns: []string{
				"app.user_id",
			},
			Calculations: []honeycombio.GetQuerySpecificationCalculation{
				{
					Op:     "HEATMAP",
					Column: pulumi.StringRef("duration_ms"),
				},
				{
					Op:     "P99",
					Column: pulumi.StringRef("duration_ms"),
				},
			},
			Filters: []honeycombio.GetQuerySpecificationFilter{
				{
					Column: "trace.parent_id",
					Op:     "does-not-exist",
				},
			},
			Orders: []honeycombio.GetQuerySpecificationOrder{
				{
					Column: pulumi.StringRef("duration_ms"),
					Op:     pulumi.StringRef("P99"),
					Order:  pulumi.StringRef("descending"),
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		latencyByUseridQuery, err := honeycombio.NewQuery(ctx, "latencyByUseridQuery", &honeycombio.QueryArgs{
			Dataset:   pulumi.String(dataset),
			QueryJson: pulumi.String(latencyByUseridQuerySpecification.Json),
		})
		if err != nil {
			return err
		}
		latencyByUseridQueryAnnotation, err := honeycombio.NewQueryAnnotation(ctx, "latencyByUseridQueryAnnotation", &honeycombio.QueryAnnotationArgs{
			Dataset:     pulumi.String(dataset),
			QueryId:     latencyByUseridQuery.ID(),
			Description: pulumi.String("A breakdown of trace latency by User over the last 24 hours"),
		})
		if err != nil {
			return err
		}
		requestLatencySli, err := honeycombio.NewDerivedColumn(ctx, "requestLatencySli", &honeycombio.DerivedColumnArgs{
			Alias:       pulumi.String("sli.request_latency"),
			Description: pulumi.String("SLI: request latency less than 300ms"),
			Dataset:     pulumi.String(dataset),
			Expression:  pulumi.String(readFileOrPanic("../sli/sli.request_latency.honeycomb")),
		})
		if err != nil {
			return err
		}
		slo, err := honeycombio.NewSlo(ctx, "slo", &honeycombio.SloArgs{
			Description:      pulumi.String("example SLO"),
			Dataset:          pulumi.String(dataset),
			Sli:              requestLatencySli.Alias,
			TargetPercentage: pulumi.Float64(99.9),
			TimePeriod:       pulumi.Float64(30),
			Tags: pulumi.StringMap{
				"team": pulumi.String("web"),
			},
		})
		if err != nil {
			return err
		}
		_, err = honeycombio.NewFlexibleBoard(ctx, "overview", &honeycombio.FlexibleBoardArgs{
			Description: pulumi.String("My flexible baord description"),
			Panels: honeycombio.FlexibleBoardPanelArray{
				&honeycombio.FlexibleBoardPanelArgs{
					Type: pulumi.String("query"),
					Positions: honeycombio.FlexibleBoardPanelPositionArray{
						&honeycombio.FlexibleBoardPanelPositionArgs{
							XCoordinate: pulumi.Float64(0),
							YCoordinate: pulumi.Float64(0),
							Width:       pulumi.Float64(6),
							Height:      pulumi.Float64(6),
						},
					},
					QueryPanels: honeycombio.FlexibleBoardPanelQueryPanelArray{
						&honeycombio.FlexibleBoardPanelQueryPanelArgs{
							QueryId:           latencyByUseridQuery.ID(),
							QueryAnnotationId: latencyByUseridQueryAnnotation.QueryAnnotationId,
							QueryStyle:        pulumi.String("combo"),
							VisualizationSettings: honeycombio.FlexibleBoardPanelQueryPanelVisualizationSettingArray{
								&honeycombio.FlexibleBoardPanelQueryPanelVisualizationSettingArgs{
									UseUtcXaxis: pulumi.Bool(true),
									Charts: honeycombio.FlexibleBoardPanelQueryPanelVisualizationSettingChartArray{
										&honeycombio.FlexibleBoardPanelQueryPanelVisualizationSettingChartArgs{
											ChartType:         pulumi.String("line"),
											ChartIndex:        pulumi.Float64(0),
											OmitMissingValues: pulumi.Bool(true),
											UseLogScale:       pulumi.Bool(true),
										},
									},
								},
							},
						},
					},
				},
				&honeycombio.FlexibleBoardPanelArgs{
					Type: pulumi.String("slo"),
					SloPanels: honeycombio.FlexibleBoardPanelSloPanelArray{
						&honeycombio.FlexibleBoardPanelSloPanelArgs{
							SloId: slo.SloId,
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.IO;
using System.Linq;
using Pulumi;
using Honeycombio = Pulumi.Honeycombio;

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var dataset = config.Require("dataset");
    var latencyByUseridQuerySpecification = Honeycombio.GetQuerySpecification.Invoke(new()
    {
        TimeRange = 86400,
        Breakdowns = new[]
        {
            "app.user_id",
        },
        Calculations = new[]
        {
            new Honeycombio.Inputs.GetQuerySpecificationCalculationInputArgs
            {
                Op = "HEATMAP",
                Column = "duration_ms",
            },
            new Honeycombio.Inputs.GetQuerySpecificationCalculationInputArgs
            {
                Op = "P99",
                Column = "duration_ms",
            },
        },
        Filters = new[]
        {
            new Honeycombio.Inputs.GetQuerySpecificationFilterInputArgs
            {
                Column = "trace.parent_id",
                Op = "does-not-exist",
            },
        },
        Orders = new[]
        {
            new Honeycombio.Inputs.GetQuerySpecificationOrderInputArgs
            {
                Column = "duration_ms",
                Op = "P99",
                Order = "descending",
            },
        },
    });

    var latencyByUseridQuery = new Honeycombio.Query("latencyByUseridQuery", new()
    {
        Dataset = dataset,
        QueryJson = latencyByUseridQuerySpecification.Apply(getQuerySpecificationResult => getQuerySpecificationResult.Json),
    });

    var latencyByUseridQueryAnnotation = new Honeycombio.QueryAnnotation("latencyByUseridQueryAnnotation", new()
    {
        Dataset = dataset,
        QueryId = latencyByUseridQuery.Id,
        Description = "A breakdown of trace latency by User over the last 24 hours",
    });

    var requestLatencySli = new Honeycombio.DerivedColumn("requestLatencySli", new()
    {
        Alias = "sli.request_latency",
        Description = "SLI: request latency less than 300ms",
        Dataset = dataset,
        Expression = File.ReadAllText("../sli/sli.request_latency.honeycomb"),
    });

    var slo = new Honeycombio.Slo("slo", new()
    {
        Description = "example SLO",
        Dataset = dataset,
        Sli = requestLatencySli.Alias,
        TargetPercentage = 99.9,
        TimePeriod = 30,
        Tags = 
        {
            { "team", "web" },
        },
    });

    var overview = new Honeycombio.FlexibleBoard("overview", new()
    {
        Description = "My flexible baord description",
        Panels = new[]
        {
            new Honeycombio.Inputs.FlexibleBoardPanelArgs
            {
                Type = "query",
                Positions = new[]
                {
                    new Honeycombio.Inputs.FlexibleBoardPanelPositionArgs
                    {
                        XCoordinate = 0,
                        YCoordinate = 0,
                        Width = 6,
                        Height = 6,
                    },
                },
                QueryPanels = new[]
                {
                    new Honeycombio.Inputs.FlexibleBoardPanelQueryPanelArgs
                    {
                        QueryId = latencyByUseridQuery.Id,
                        QueryAnnotationId = latencyByUseridQueryAnnotation.QueryAnnotationId,
                        QueryStyle = "combo",
                        VisualizationSettings = new[]
                        {
                            new Honeycombio.Inputs.FlexibleBoardPanelQueryPanelVisualizationSettingArgs
                            {
                                UseUtcXaxis = true,
                                Charts = new[]
                                {
                                    new Honeycombio.Inputs.FlexibleBoardPanelQueryPanelVisualizationSettingChartArgs
                                    {
                                        ChartType = "line",
                                        ChartIndex = 0,
                                        OmitMissingValues = true,
                                        UseLogScale = true,
                                    },
                                },
                            },
                        },
                    },
                },
            },
            new Honeycombio.Inputs.FlexibleBoardPanelArgs
            {
                Type = "slo",
                SloPanels = new[]
                {
                    new Honeycombio.Inputs.FlexibleBoardPanelSloPanelArgs
                    {
                        SloId = slo.SloId,
                    },
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.honeycombio.HoneycombioFunctions;
import com.pulumi.honeycombio.inputs.GetQuerySpecificationArgs;
import com.pulumi.honeycombio.Query;
import com.pulumi.honeycombio.QueryArgs;
import com.pulumi.honeycombio.QueryAnnotation;
import com.pulumi.honeycombio.QueryAnnotationArgs;
import com.pulumi.honeycombio.DerivedColumn;
import com.pulumi.honeycombio.DerivedColumnArgs;
import com.pulumi.honeycombio.Slo;
import com.pulumi.honeycombio.SloArgs;
import com.pulumi.honeycombio.FlexibleBoard;
import com.pulumi.honeycombio.FlexibleBoardArgs;
import com.pulumi.honeycombio.inputs.FlexibleBoardPanelArgs;
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) {
        final var config = ctx.config();
        final var dataset = config.get("dataset");
        final var latencyByUseridQuerySpecification = HoneycombioFunctions.getQuerySpecification(GetQuerySpecificationArgs.builder()
            .timeRange(86400)
            .breakdowns("app.user_id")
            .calculations(            
                GetQuerySpecificationCalculationArgs.builder()
                    .op("HEATMAP")
                    .column("duration_ms")
                    .build(),
                GetQuerySpecificationCalculationArgs.builder()
                    .op("P99")
                    .column("duration_ms")
                    .build())
            .filters(GetQuerySpecificationFilterArgs.builder()
                .column("trace.parent_id")
                .op("does-not-exist")
                .build())
            .orders(GetQuerySpecificationOrderArgs.builder()
                .column("duration_ms")
                .op("P99")
                .order("descending")
                .build())
            .build());

        var latencyByUseridQuery = new Query("latencyByUseridQuery", QueryArgs.builder()
            .dataset(dataset)
            .queryJson(latencyByUseridQuerySpecification.applyValue(getQuerySpecificationResult -> getQuerySpecificationResult.json()))
            .build());

        var latencyByUseridQueryAnnotation = new QueryAnnotation("latencyByUseridQueryAnnotation", QueryAnnotationArgs.builder()
            .dataset(dataset)
            .queryId(latencyByUseridQuery.id())
            .description("A breakdown of trace latency by User over the last 24 hours")
            .build());

        var requestLatencySli = new DerivedColumn("requestLatencySli", DerivedColumnArgs.builder()
            .alias("sli.request_latency")
            .description("SLI: request latency less than 300ms")
            .dataset(dataset)
            .expression(Files.readString(Paths.get("../sli/sli.request_latency.honeycomb")))
            .build());

        var slo = new Slo("slo", SloArgs.builder()
            .description("example SLO")
            .dataset(dataset)
            .sli(requestLatencySli.alias())
            .targetPercentage(99.9)
            .timePeriod(30)
            .tags(Map.of("team", "web"))
            .build());

        var overview = new FlexibleBoard("overview", FlexibleBoardArgs.builder()
            .description("My flexible baord description")
            .panels(            
                FlexibleBoardPanelArgs.builder()
                    .type("query")
                    .positions(FlexibleBoardPanelPositionArgs.builder()
                        .xCoordinate(0)
                        .yCoordinate(0)
                        .width(6)
                        .height(6)
                        .build())
                    .queryPanels(FlexibleBoardPanelQueryPanelArgs.builder()
                        .queryId(latencyByUseridQuery.id())
                        .queryAnnotationId(latencyByUseridQueryAnnotation.queryAnnotationId())
                        .queryStyle("combo")
                        .visualizationSettings(FlexibleBoardPanelQueryPanelVisualizationSettingArgs.builder()
                            .useUtcXaxis(true)
                            .charts(FlexibleBoardPanelQueryPanelVisualizationSettingChartArgs.builder()
                                .chartType("line")
                                .chartIndex(0)
                                .omitMissingValues(true)
                                .useLogScale(true)
                                .build())
                            .build())
                        .build())
                    .build(),
                FlexibleBoardPanelArgs.builder()
                    .type("slo")
                    .sloPanels(FlexibleBoardPanelSloPanelArgs.builder()
                        .sloId(slo.sloId())
                        .build())
                    .build())
            .build());

    }
}

    configuration:
  dataset:
    type: string
resources:
  latencyByUseridQuery:
    type: honeycombio:Query
    properties:
      dataset: ${dataset}
      queryJson: ${latencyByUseridQuerySpecification.json}
  latencyByUseridQueryAnnotation:
    type: honeycombio:QueryAnnotation
    properties:
      dataset: ${dataset}
      queryId: ${latencyByUseridQuery.id}
      description: A breakdown of trace latency by User over the last 24 hours
  requestLatencySli:
    type: honeycombio:DerivedColumn
    properties:
      alias: sli.request_latency
      description: 'SLI: request latency less than 300ms'
      dataset: ${dataset}
      # heredoc also works
      expression:
        fn::readFile: ../sli/sli.request_latency.honeycomb
  slo:
    type: honeycombio:Slo
    properties:
      description: example SLO
      dataset: ${dataset}
      sli: ${requestLatencySli.alias}
      targetPercentage: 99.9
      timePeriod: 30
      tags:
        team: web
  overview:
    type: honeycombio:FlexibleBoard
    properties:
      description: My flexible baord description
      panels:
        - type: query
          positions:
            - xCoordinate: 0
              yCoordinate: 0
              width: 6
              height: 6
          queryPanels:
            - queryId: ${latencyByUseridQuery.id}
              queryAnnotationId: ${latencyByUseridQueryAnnotation.queryAnnotationId}
              queryStyle: combo
              visualizationSettings:
                - useUtcXaxis: true
                  charts:
                    - chartType: line
                      chartIndex: 0
                      omitMissingValues: true
                      useLogScale: true
        - type: slo
          sloPanels:
            - sloId: ${slo.sloId}
variables:
  latencyByUseridQuerySpecification:
    fn::invoke:
      function: honeycombio:getQuerySpecification
      arguments:
        timeRange: 86400
        breakdowns:
          - app.user_id
        calculations:
          - op: HEATMAP
            column: duration_ms
          - op: P99
            column: duration_ms
        filters:
          - column: trace.parent_id
            op: does-not-exist
        orders:
          - column: duration_ms
            op: P99
            order: descending

    Create FlexibleBoard Resource

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

    Constructor syntax

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

@overload
def FlexibleBoard(resource_name: str,
                  opts: Optional[ResourceOptions] = None,
                  description: Optional[str] = None,
                  name: Optional[str] = None,
                  panels: Optional[Sequence[FlexibleBoardPanelArgs]] = None)
    func NewFlexibleBoard(ctx *Context, name string, args *FlexibleBoardArgs, opts ...ResourceOption) (*FlexibleBoard, error)
    public FlexibleBoard(string name, FlexibleBoardArgs? args = null, CustomResourceOptions? opts = null)
    public FlexibleBoard(String name, FlexibleBoardArgs args)
public FlexibleBoard(String name, FlexibleBoardArgs args, CustomResourceOptions options)

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

    Parameters

    name string
    The unique name of the resource.
    args FlexibleBoardArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args FlexibleBoardArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args FlexibleBoardArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args FlexibleBoardArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args FlexibleBoardArgs
    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 flexibleBoardResource = new Honeycombio.FlexibleBoard("flexibleBoardResource", new()
{
    Description = "string",
    Name = "string",
    Panels = new[]
    {
        new Honeycombio.Inputs.FlexibleBoardPanelArgs
        {
            Type = "string",
            Positions = new[]
            {
                new Honeycombio.Inputs.FlexibleBoardPanelPositionArgs
                {
                    Height = 0,
                    Width = 0,
                    XCoordinate = 0,
                    YCoordinate = 0,
                },
            },
            QueryPanels = new[]
            {
                new Honeycombio.Inputs.FlexibleBoardPanelQueryPanelArgs
                {
                    QueryAnnotationId = "string",
                    QueryId = "string",
                    QueryStyle = "string",
                    VisualizationSettings = new[]
                    {
                        new Honeycombio.Inputs.FlexibleBoardPanelQueryPanelVisualizationSettingArgs
                        {
                            Charts = new[]
                            {
                                new Honeycombio.Inputs.FlexibleBoardPanelQueryPanelVisualizationSettingChartArgs
                                {
                                    ChartIndex = 0,
                                    ChartType = "string",
                                    OmitMissingValues = false,
                                    UseLogScale = false,
                                },
                            },
                            HideCompare = false,
                            HideHovers = false,
                            HideMarkers = false,
                            PreferOverlaidCharts = false,
                            UseUtcXaxis = false,
                        },
                    },
                },
            },
            SloPanels = new[]
            {
                new Honeycombio.Inputs.FlexibleBoardPanelSloPanelArgs
                {
                    SloId = "string",
                },
            },
        },
    },
});

    example, err := honeycombio.NewFlexibleBoard(ctx, "flexibleBoardResource", &honeycombio.FlexibleBoardArgs{
	Description: pulumi.String("string"),
	Name:        pulumi.String("string"),
	Panels: honeycombio.FlexibleBoardPanelArray{
		&honeycombio.FlexibleBoardPanelArgs{
			Type: pulumi.String("string"),
			Positions: honeycombio.FlexibleBoardPanelPositionArray{
				&honeycombio.FlexibleBoardPanelPositionArgs{
					Height:      pulumi.Float64(0),
					Width:       pulumi.Float64(0),
					XCoordinate: pulumi.Float64(0),
					YCoordinate: pulumi.Float64(0),
				},
			},
			QueryPanels: honeycombio.FlexibleBoardPanelQueryPanelArray{
				&honeycombio.FlexibleBoardPanelQueryPanelArgs{
					QueryAnnotationId: pulumi.String("string"),
					QueryId:           pulumi.String("string"),
					QueryStyle:        pulumi.String("string"),
					VisualizationSettings: honeycombio.FlexibleBoardPanelQueryPanelVisualizationSettingArray{
						&honeycombio.FlexibleBoardPanelQueryPanelVisualizationSettingArgs{
							Charts: honeycombio.FlexibleBoardPanelQueryPanelVisualizationSettingChartArray{
								&honeycombio.FlexibleBoardPanelQueryPanelVisualizationSettingChartArgs{
									ChartIndex:        pulumi.Float64(0),
									ChartType:         pulumi.String("string"),
									OmitMissingValues: pulumi.Bool(false),
									UseLogScale:       pulumi.Bool(false),
								},
							},
							HideCompare:          pulumi.Bool(false),
							HideHovers:           pulumi.Bool(false),
							HideMarkers:          pulumi.Bool(false),
							PreferOverlaidCharts: pulumi.Bool(false),
							UseUtcXaxis:          pulumi.Bool(false),
						},
					},
				},
			},
			SloPanels: honeycombio.FlexibleBoardPanelSloPanelArray{
				&honeycombio.FlexibleBoardPanelSloPanelArgs{
					SloId: pulumi.String("string"),
				},
			},
		},
	},
})

    var flexibleBoardResource = new FlexibleBoard("flexibleBoardResource", FlexibleBoardArgs.builder()
    .description("string")
    .name("string")
    .panels(FlexibleBoardPanelArgs.builder()
        .type("string")
        .positions(FlexibleBoardPanelPositionArgs.builder()
            .height(0.0)
            .width(0.0)
            .xCoordinate(0.0)
            .yCoordinate(0.0)
            .build())
        .queryPanels(FlexibleBoardPanelQueryPanelArgs.builder()
            .queryAnnotationId("string")
            .queryId("string")
            .queryStyle("string")
            .visualizationSettings(FlexibleBoardPanelQueryPanelVisualizationSettingArgs.builder()
                .charts(FlexibleBoardPanelQueryPanelVisualizationSettingChartArgs.builder()
                    .chartIndex(0.0)
                    .chartType("string")
                    .omitMissingValues(false)
                    .useLogScale(false)
                    .build())
                .hideCompare(false)
                .hideHovers(false)
                .hideMarkers(false)
                .preferOverlaidCharts(false)
                .useUtcXaxis(false)
                .build())
            .build())
        .sloPanels(FlexibleBoardPanelSloPanelArgs.builder()
            .sloId("string")
            .build())
        .build())
    .build());

    flexible_board_resource = honeycombio.FlexibleBoard("flexibleBoardResource",
    description="string",
    name="string",
    panels=[{
        "type": "string",
        "positions": [{
            "height": 0,
            "width": 0,
            "x_coordinate": 0,
            "y_coordinate": 0,
        }],
        "query_panels": [{
            "query_annotation_id": "string",
            "query_id": "string",
            "query_style": "string",
            "visualization_settings": [{
                "charts": [{
                    "chart_index": 0,
                    "chart_type": "string",
                    "omit_missing_values": False,
                    "use_log_scale": False,
                }],
                "hide_compare": False,
                "hide_hovers": False,
                "hide_markers": False,
                "prefer_overlaid_charts": False,
                "use_utc_xaxis": False,
            }],
        }],
        "slo_panels": [{
            "slo_id": "string",
        }],
    }])

    const flexibleBoardResource = new honeycombio.FlexibleBoard("flexibleBoardResource", {
    description: "string",
    name: "string",
    panels: [{
        type: "string",
        positions: [{
            height: 0,
            width: 0,
            xCoordinate: 0,
            yCoordinate: 0,
        }],
        queryPanels: [{
            queryAnnotationId: "string",
            queryId: "string",
            queryStyle: "string",
            visualizationSettings: [{
                charts: [{
                    chartIndex: 0,
                    chartType: "string",
                    omitMissingValues: false,
                    useLogScale: false,
                }],
                hideCompare: false,
                hideHovers: false,
                hideMarkers: false,
                preferOverlaidCharts: false,
                useUtcXaxis: false,
            }],
        }],
        sloPanels: [{
            sloId: "string",
        }],
    }],
});

    type: honeycombio:FlexibleBoard
properties:
    description: string
    name: string
    panels:
        - positions:
            - height: 0
              width: 0
              xCoordinate: 0
              yCoordinate: 0
          queryPanels:
            - queryAnnotationId: string
              queryId: string
              queryStyle: string
              visualizationSettings:
                - charts:
                    - chartIndex: 0
                      chartType: string
                      omitMissingValues: false
                      useLogScale: false
                  hideCompare: false
                  hideHovers: false
                  hideMarkers: false
                  preferOverlaidCharts: false
                  useUtcXaxis: false
          sloPanels:
            - sloId: string
          type: string

    FlexibleBoard 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 FlexibleBoard resource accepts the following input properties:

    Description string
    Description of the board. Supports Markdown.
    Name string
    Name of the board.
    Panels List<FlexibleBoardPanel>
    zero or more configurations blocks
    Description string
    Description of the board. Supports Markdown.
    Name string
    Name of the board.
    Panels []FlexibleBoardPanelArgs
    zero or more configurations blocks
    description String
    Description of the board. Supports Markdown.
    name String
    Name of the board.
    panels List<FlexibleBoardPanel>
    zero or more configurations blocks
    description string
    Description of the board. Supports Markdown.
    name string
    Name of the board.
    panels FlexibleBoardPanel[]
    zero or more configurations blocks
    description str
    Description of the board. Supports Markdown.
    name str
    Name of the board.
    panels Sequence[FlexibleBoardPanelArgs]
    zero or more configurations blocks
    description String
    Description of the board. Supports Markdown.
    name String
    Name of the board.
    panels List<Property Map>
    zero or more configurations blocks

    Outputs

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

    BoardUrl string
    The URL to the board in the Honeycomb UI.
    Id string
    The provider-assigned unique ID for this managed resource.
    BoardUrl string
    The URL to the board in the Honeycomb UI.
    Id string
    The provider-assigned unique ID for this managed resource.
    boardUrl String
    The URL to the board in the Honeycomb UI.
    id String
    The provider-assigned unique ID for this managed resource.
    boardUrl string
    The URL to the board in the Honeycomb UI.
    id string
    The provider-assigned unique ID for this managed resource.
    board_url str
    The URL to the board in the Honeycomb UI.
    id str
    The provider-assigned unique ID for this managed resource.
    boardUrl String
    The URL to the board in the Honeycomb UI.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing FlexibleBoard Resource

    Get an existing FlexibleBoard 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?: FlexibleBoardState, opts?: CustomResourceOptions): FlexibleBoard
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        board_url: Optional[str] = None,
        description: Optional[str] = None,
        name: Optional[str] = None,
        panels: Optional[Sequence[FlexibleBoardPanelArgs]] = None) -> FlexibleBoard
    func GetFlexibleBoard(ctx *Context, name string, id IDInput, state *FlexibleBoardState, opts ...ResourceOption) (*FlexibleBoard, error)
    public static FlexibleBoard Get(string name, Input<string> id, FlexibleBoardState? state, CustomResourceOptions? opts = null)
    public static FlexibleBoard get(String name, Output<String> id, FlexibleBoardState state, CustomResourceOptions options)
    resources:  _:    type: honeycombio:FlexibleBoard    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    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
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    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
    The unique name of the resulting resource.
    id
    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
    The unique name of the resulting resource.
    id
    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:
    BoardUrl string
    The URL to the board in the Honeycomb UI.
    Description string
    Description of the board. Supports Markdown.
    Name string
    Name of the board.
    Panels List<FlexibleBoardPanel>
    zero or more configurations blocks
    BoardUrl string
    The URL to the board in the Honeycomb UI.
    Description string
    Description of the board. Supports Markdown.
    Name string
    Name of the board.
    Panels []FlexibleBoardPanelArgs
    zero or more configurations blocks
    boardUrl String
    The URL to the board in the Honeycomb UI.
    description String
    Description of the board. Supports Markdown.
    name String
    Name of the board.
    panels List<FlexibleBoardPanel>
    zero or more configurations blocks
    boardUrl string
    The URL to the board in the Honeycomb UI.
    description string
    Description of the board. Supports Markdown.
    name string
    Name of the board.
    panels FlexibleBoardPanel[]
    zero or more configurations blocks
    board_url str
    The URL to the board in the Honeycomb UI.
    description str
    Description of the board. Supports Markdown.
    name str
    Name of the board.
    panels Sequence[FlexibleBoardPanelArgs]
    zero or more configurations blocks
    boardUrl String
    The URL to the board in the Honeycomb UI.
    description String
    Description of the board. Supports Markdown.
    name String
    Name of the board.
    panels List<Property Map>
    zero or more configurations blocks

    Supporting Types

    FlexibleBoardPanel, FlexibleBoardPanelArgs

    Type string
    The panel type, either "query" or "slo".
    Positions List<FlexibleBoardPanelPosition>
    Single configuration block to determine position of the panel.
    QueryPanels List<FlexibleBoardPanelQueryPanel>
    This is only required for type query panels. Single configuration block that contains board query information.
    SloPanels List<FlexibleBoardPanelSloPanel>
    This is only required for type slo panels. Single configuration block that contains board slo information.
    Type string
    The panel type, either "query" or "slo".
    Positions []FlexibleBoardPanelPosition
    Single configuration block to determine position of the panel.
    QueryPanels []FlexibleBoardPanelQueryPanel
    This is only required for type query panels. Single configuration block that contains board query information.
    SloPanels []FlexibleBoardPanelSloPanel
    This is only required for type slo panels. Single configuration block that contains board slo information.
    type String
    The panel type, either "query" or "slo".
    positions List<FlexibleBoardPanelPosition>
    Single configuration block to determine position of the panel.
    queryPanels List<FlexibleBoardPanelQueryPanel>
    This is only required for type query panels. Single configuration block that contains board query information.
    sloPanels List<FlexibleBoardPanelSloPanel>
    This is only required for type slo panels. Single configuration block that contains board slo information.
    type string
    The panel type, either "query" or "slo".
    positions FlexibleBoardPanelPosition[]
    Single configuration block to determine position of the panel.
    queryPanels FlexibleBoardPanelQueryPanel[]
    This is only required for type query panels. Single configuration block that contains board query information.
    sloPanels FlexibleBoardPanelSloPanel[]
    This is only required for type slo panels. Single configuration block that contains board slo information.
    type str
    The panel type, either "query" or "slo".
    positions Sequence[FlexibleBoardPanelPosition]
    Single configuration block to determine position of the panel.
    query_panels Sequence[FlexibleBoardPanelQueryPanel]
    This is only required for type query panels. Single configuration block that contains board query information.
    slo_panels Sequence[FlexibleBoardPanelSloPanel]
    This is only required for type slo panels. Single configuration block that contains board slo information.
    type String
    The panel type, either "query" or "slo".
    positions List<Property Map>
    Single configuration block to determine position of the panel.
    queryPanels List<Property Map>
    This is only required for type query panels. Single configuration block that contains board query information.
    sloPanels List<Property Map>
    This is only required for type slo panels. Single configuration block that contains board slo information.

    FlexibleBoardPanelPosition, FlexibleBoardPanelPositionArgs

    Height double
    The height of the panel in rows. Defaults to 4.
    Width double
    The width of the panel in honeycomb UI columns. Defaults to 6 for queries and 3 for slos. Maximum value is 12.
    XCoordinate double
    The x-axis origin point for placing the panel within the layout.
    YCoordinate double
    The y-axis origin point for placing the panel within the layout.
    Height float64
    The height of the panel in rows. Defaults to 4.
    Width float64
    The width of the panel in honeycomb UI columns. Defaults to 6 for queries and 3 for slos. Maximum value is 12.
    XCoordinate float64
    The x-axis origin point for placing the panel within the layout.
    YCoordinate float64
    The y-axis origin point for placing the panel within the layout.
    height Double
    The height of the panel in rows. Defaults to 4.
    width Double
    The width of the panel in honeycomb UI columns. Defaults to 6 for queries and 3 for slos. Maximum value is 12.
    xCoordinate Double
    The x-axis origin point for placing the panel within the layout.
    yCoordinate Double
    The y-axis origin point for placing the panel within the layout.
    height number
    The height of the panel in rows. Defaults to 4.
    width number
    The width of the panel in honeycomb UI columns. Defaults to 6 for queries and 3 for slos. Maximum value is 12.
    xCoordinate number
    The x-axis origin point for placing the panel within the layout.
    yCoordinate number
    The y-axis origin point for placing the panel within the layout.
    height float
    The height of the panel in rows. Defaults to 4.
    width float
    The width of the panel in honeycomb UI columns. Defaults to 6 for queries and 3 for slos. Maximum value is 12.
    x_coordinate float
    The x-axis origin point for placing the panel within the layout.
    y_coordinate float
    The y-axis origin point for placing the panel within the layout.
    height Number
    The height of the panel in rows. Defaults to 4.
    width Number
    The width of the panel in honeycomb UI columns. Defaults to 6 for queries and 3 for slos. Maximum value is 12.
    xCoordinate Number
    The x-axis origin point for placing the panel within the layout.
    yCoordinate Number
    The y-axis origin point for placing the panel within the layout.

    FlexibleBoardPanelQueryPanel, FlexibleBoardPanelQueryPanelArgs

    QueryAnnotationId string
    The ID of the Query Annotation to associate with this query.
    QueryId string
    The ID of the Query to show on the board.
    QueryStyle string
    How the query should be displayed within the board, either graph (the default), table or combo.
    VisualizationSettings List<FlexibleBoardPanelQueryPanelVisualizationSetting>
    A configuration block to manage the query visualization and charts.
    QueryAnnotationId string
    The ID of the Query Annotation to associate with this query.
    QueryId string
    The ID of the Query to show on the board.
    QueryStyle string
    How the query should be displayed within the board, either graph (the default), table or combo.
    VisualizationSettings []FlexibleBoardPanelQueryPanelVisualizationSetting
    A configuration block to manage the query visualization and charts.
    queryAnnotationId String
    The ID of the Query Annotation to associate with this query.
    queryId String
    The ID of the Query to show on the board.
    queryStyle String
    How the query should be displayed within the board, either graph (the default), table or combo.
    visualizationSettings List<FlexibleBoardPanelQueryPanelVisualizationSetting>
    A configuration block to manage the query visualization and charts.
    queryAnnotationId string
    The ID of the Query Annotation to associate with this query.
    queryId string
    The ID of the Query to show on the board.
    queryStyle string
    How the query should be displayed within the board, either graph (the default), table or combo.
    visualizationSettings FlexibleBoardPanelQueryPanelVisualizationSetting[]
    A configuration block to manage the query visualization and charts.
    query_annotation_id str
    The ID of the Query Annotation to associate with this query.
    query_id str
    The ID of the Query to show on the board.
    query_style str
    How the query should be displayed within the board, either graph (the default), table or combo.
    visualization_settings Sequence[FlexibleBoardPanelQueryPanelVisualizationSetting]
    A configuration block to manage the query visualization and charts.
    queryAnnotationId String
    The ID of the Query Annotation to associate with this query.
    queryId String
    The ID of the Query to show on the board.
    queryStyle String
    How the query should be displayed within the board, either graph (the default), table or combo.
    visualizationSettings List<Property Map>
    A configuration block to manage the query visualization and charts.

    FlexibleBoardPanelQueryPanelVisualizationSetting, FlexibleBoardPanelQueryPanelVisualizationSettingArgs

    Charts List<FlexibleBoardPanelQueryPanelVisualizationSettingChart>
    a configuration block to manage the query's charts.
    HideCompare bool
    Hide comparison values.
    HideHovers bool
    Disable Graph tooltips in the results display when hovering over a graph.
    HideMarkers bool
    Hide markers from appearing on graph.
    PreferOverlaidCharts bool
    Combine any visualized AVG, MIN, MAX, and PERCENTILE clauses into a single chart.
    UseUtcXaxis bool
    Display UTC Time X-Axis or Localtime X-Axis.
    Charts []FlexibleBoardPanelQueryPanelVisualizationSettingChart
    a configuration block to manage the query's charts.
    HideCompare bool
    Hide comparison values.
    HideHovers bool
    Disable Graph tooltips in the results display when hovering over a graph.
    HideMarkers bool
    Hide markers from appearing on graph.
    PreferOverlaidCharts bool
    Combine any visualized AVG, MIN, MAX, and PERCENTILE clauses into a single chart.
    UseUtcXaxis bool
    Display UTC Time X-Axis or Localtime X-Axis.
    charts List<FlexibleBoardPanelQueryPanelVisualizationSettingChart>
    a configuration block to manage the query's charts.
    hideCompare Boolean
    Hide comparison values.
    hideHovers Boolean
    Disable Graph tooltips in the results display when hovering over a graph.
    hideMarkers Boolean
    Hide markers from appearing on graph.
    preferOverlaidCharts Boolean
    Combine any visualized AVG, MIN, MAX, and PERCENTILE clauses into a single chart.
    useUtcXaxis Boolean
    Display UTC Time X-Axis or Localtime X-Axis.
    charts FlexibleBoardPanelQueryPanelVisualizationSettingChart[]
    a configuration block to manage the query's charts.
    hideCompare boolean
    Hide comparison values.
    hideHovers boolean
    Disable Graph tooltips in the results display when hovering over a graph.
    hideMarkers boolean
    Hide markers from appearing on graph.
    preferOverlaidCharts boolean
    Combine any visualized AVG, MIN, MAX, and PERCENTILE clauses into a single chart.
    useUtcXaxis boolean
    Display UTC Time X-Axis or Localtime X-Axis.
    charts Sequence[FlexibleBoardPanelQueryPanelVisualizationSettingChart]
    a configuration block to manage the query's charts.
    hide_compare bool
    Hide comparison values.
    hide_hovers bool
    Disable Graph tooltips in the results display when hovering over a graph.
    hide_markers bool
    Hide markers from appearing on graph.
    prefer_overlaid_charts bool
    Combine any visualized AVG, MIN, MAX, and PERCENTILE clauses into a single chart.
    use_utc_xaxis bool
    Display UTC Time X-Axis or Localtime X-Axis.
    charts List<Property Map>
    a configuration block to manage the query's charts.
    hideCompare Boolean
    Hide comparison values.
    hideHovers Boolean
    Disable Graph tooltips in the results display when hovering over a graph.
    hideMarkers Boolean
    Hide markers from appearing on graph.
    preferOverlaidCharts Boolean
    Combine any visualized AVG, MIN, MAX, and PERCENTILE clauses into a single chart.
    useUtcXaxis Boolean
    Display UTC Time X-Axis or Localtime X-Axis.

    FlexibleBoardPanelQueryPanelVisualizationSettingChart, FlexibleBoardPanelQueryPanelVisualizationSettingChartArgs

    ChartIndex double
    index of the charts this configuration corresponds to.
    ChartType string
    the type of chart to render. Some example values: line, tsbar, stacked, stat, tsbar, cpie, cbar. Default to default
    OmitMissingValues bool
    Interpolates between points when the intervening time buckets have no matching events. Use to display a continuous line graph with no drops to zero.
    UseLogScale bool
    Use logarithmic scale on Y axis. The y-axis of a Log Scale graph increases exponentially. Useful for data with an extremely large range of values.
    ChartIndex float64
    index of the charts this configuration corresponds to.
    ChartType string
    the type of chart to render. Some example values: line, tsbar, stacked, stat, tsbar, cpie, cbar. Default to default
    OmitMissingValues bool
    Interpolates between points when the intervening time buckets have no matching events. Use to display a continuous line graph with no drops to zero.
    UseLogScale bool
    Use logarithmic scale on Y axis. The y-axis of a Log Scale graph increases exponentially. Useful for data with an extremely large range of values.
    chartIndex Double
    index of the charts this configuration corresponds to.
    chartType String
    the type of chart to render. Some example values: line, tsbar, stacked, stat, tsbar, cpie, cbar. Default to default
    omitMissingValues Boolean
    Interpolates between points when the intervening time buckets have no matching events. Use to display a continuous line graph with no drops to zero.
    useLogScale Boolean
    Use logarithmic scale on Y axis. The y-axis of a Log Scale graph increases exponentially. Useful for data with an extremely large range of values.
    chartIndex number
    index of the charts this configuration corresponds to.
    chartType string
    the type of chart to render. Some example values: line, tsbar, stacked, stat, tsbar, cpie, cbar. Default to default
    omitMissingValues boolean
    Interpolates between points when the intervening time buckets have no matching events. Use to display a continuous line graph with no drops to zero.
    useLogScale boolean
    Use logarithmic scale on Y axis. The y-axis of a Log Scale graph increases exponentially. Useful for data with an extremely large range of values.
    chart_index float
    index of the charts this configuration corresponds to.
    chart_type str
    the type of chart to render. Some example values: line, tsbar, stacked, stat, tsbar, cpie, cbar. Default to default
    omit_missing_values bool
    Interpolates between points when the intervening time buckets have no matching events. Use to display a continuous line graph with no drops to zero.
    use_log_scale bool
    Use logarithmic scale on Y axis. The y-axis of a Log Scale graph increases exponentially. Useful for data with an extremely large range of values.
    chartIndex Number
    index of the charts this configuration corresponds to.
    chartType String
    the type of chart to render. Some example values: line, tsbar, stacked, stat, tsbar, cpie, cbar. Default to default
    omitMissingValues Boolean
    Interpolates between points when the intervening time buckets have no matching events. Use to display a continuous line graph with no drops to zero.
    useLogScale Boolean
    Use logarithmic scale on Y axis. The y-axis of a Log Scale graph increases exponentially. Useful for data with an extremely large range of values.

    FlexibleBoardPanelSloPanel, FlexibleBoardPanelSloPanelArgs

    SloId string
    the ID of the SLO to add to the board.
    SloId string
    the ID of the SLO to add to the board.
    sloId String
    the ID of the SLO to add to the board.
    sloId string
    the ID of the SLO to add to the board.
    slo_id str
    the ID of the SLO to add to the board.
    sloId String
    the ID of the SLO to add to the board.

    Import

    Boards can be imported using their ID, e.g.

    $ pulumi import honeycombio:index/flexibleBoard:FlexibleBoard my_board AobW9oAZX71

    You can find the ID in the URL bar when visiting the board from the UI.

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    honeycombio honeycombio/terraform-provider-honeycombio
    License
    Notes
    This Pulumi package is based on the honeycombio Terraform Provider.
    honeycombio logo
    honeycombio 0.35.0 published on Wednesday, May 14, 2025 by honeycombio
    honeycombio/terraform-provider-honeycombio