Sign in Dashboard Get started
  1. Packages
  2. Packages
  3. Vercel Provider
  4. API Docs
  5. TraceDrain
Viewing docs for Vercel v5.4.1
published on Wednesday, Jul 22, 2026 by Pulumiverse
Schema (JSON)
pulumiverse/pulumi-vercel

vercel.TraceDrain

vercel logo
Viewing docs for Vercel v5.4.1
published on Wednesday, Jul 22, 2026 by Pulumiverse
Schema (JSON)
pulumiverse/pulumi-vercel

    Provides a configurable Trace Drain resource.

    Trace Drains forward OpenTelemetry trace data from your deployments to an OTLP/HTTP compatible endpoint.

    Only Pro and Enterprise teams can create configurable Trace Drains.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as vercel from "@pulumiverse/vercel";

const example = new vercel.TraceDrain("example", {
    name: "example-trace-drain",
    deliveryFormat: "json",
    endpoint: "https://example.com/v1/traces",
    projectIds: [exampleVercelProject.id],
    samplingRules: [{
        rate: 0.8,
        environment: "production",
        requestPath: "/api",
    }],
});

    import pulumi
import pulumiverse_vercel as vercel

example = vercel.TraceDrain("example",
    name="example-trace-drain",
    delivery_format="json",
    endpoint="https://example.com/v1/traces",
    project_ids=[example_vercel_project["id"]],
    sampling_rules=[{
        "rate": 0.8,
        "environment": "production",
        "request_path": "/api",
    }])

    package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-vercel/sdk/v5/go/vercel"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := vercel.NewTraceDrain(ctx, "example", &vercel.TraceDrainArgs{
			Name:           pulumi.String("example-trace-drain"),
			DeliveryFormat: pulumi.String("json"),
			Endpoint:       pulumi.String("https://example.com/v1/traces"),
			ProjectIds: pulumi.StringArray{
				exampleVercelProject.Id,
			},
			SamplingRules: vercel.TraceDrainSamplingRuleArray{
				&vercel.TraceDrainSamplingRuleArgs{
					Rate:        pulumi.Float64(0.8),
					Environment: pulumi.String("production"),
					RequestPath: pulumi.String("/api"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Vercel = Pulumiverse.Vercel;

return await Deployment.RunAsync(() => 
{
    var example = new Vercel.TraceDrain("example", new()
    {
        Name = "example-trace-drain",
        DeliveryFormat = "json",
        Endpoint = "https://example.com/v1/traces",
        ProjectIds = new[]
        {
            exampleVercelProject.Id,
        },
        SamplingRules = new[]
        {
            new Vercel.Inputs.TraceDrainSamplingRuleArgs
            {
                Rate = 0.8,
                Environment = "production",
                RequestPath = "/api",
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumiverse.vercel.TraceDrain;
import com.pulumiverse.vercel.TraceDrainArgs;
import com.pulumi.vercel.inputs.TraceDrainSamplingRuleArgs;
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 example = new TraceDrain("example", TraceDrainArgs.builder()
            .name("example-trace-drain")
            .deliveryFormat("json")
            .endpoint("https://example.com/v1/traces")
            .projectIds(exampleVercelProject.id())
            .samplingRules(TraceDrainSamplingRuleArgs.builder()
                .rate(0.8)
                .environment("production")
                .requestPath("/api")
                .build())
            .build());

    }
}

    resources:
  example:
    type: vercel:TraceDrain
    properties:
      name: example-trace-drain
      deliveryFormat: json
      endpoint: https://example.com/v1/traces
      projectIds:
        - ${exampleVercelProject.id}
      samplingRules:
        - rate: 0.8
          environment: production
          requestPath: /api

    Example coming soon!

    Create TraceDrain Resource

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

    Constructor syntax

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

@overload
def TraceDrain(resource_name: str,
               opts: Optional[ResourceOptions] = None,
               delivery_format: Optional[str] = None,
               endpoint: Optional[str] = None,
               headers: Optional[Mapping[str, str]] = None,
               name: Optional[str] = None,
               project_ids: Optional[Sequence[str]] = None,
               sampling_rules: Optional[Sequence[TraceDrainSamplingRuleArgs]] = None,
               secret: Optional[str] = None,
               team_id: Optional[str] = None)
    func NewTraceDrain(ctx *Context, name string, args TraceDrainArgs, opts ...ResourceOption) (*TraceDrain, error)
    public TraceDrain(string name, TraceDrainArgs args, CustomResourceOptions? opts = null)
    public TraceDrain(String name, TraceDrainArgs args)
public TraceDrain(String name, TraceDrainArgs args, CustomResourceOptions options)

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


    resource "vercel_trace_drain" "name" {
    # resource properties
}

    Parameters

    name string
    The unique name of the resource.
    args TraceDrainArgs
    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 TraceDrainArgs
    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 TraceDrainArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args TraceDrainArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args TraceDrainArgs
    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 traceDrainResource = new Vercel.TraceDrain("traceDrainResource", new()
{
    DeliveryFormat = "string",
    Endpoint = "string",
    Headers = 
    {
        { "string", "string" },
    },
    Name = "string",
    ProjectIds = new[]
    {
        "string",
    },
    SamplingRules = new[]
    {
        new Vercel.Inputs.TraceDrainSamplingRuleArgs
        {
            Rate = 0,
            Environment = "string",
            RequestPath = "string",
        },
    },
    Secret = "string",
    TeamId = "string",
});

    example, err := vercel.NewTraceDrain(ctx, "traceDrainResource", &vercel.TraceDrainArgs{
	DeliveryFormat: pulumi.String("string"),
	Endpoint:       pulumi.String("string"),
	Headers: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Name: pulumi.String("string"),
	ProjectIds: pulumi.StringArray{
		pulumi.String("string"),
	},
	SamplingRules: vercel.TraceDrainSamplingRuleArray{
		&vercel.TraceDrainSamplingRuleArgs{
			Rate:        pulumi.Float64(0),
			Environment: pulumi.String("string"),
			RequestPath: pulumi.String("string"),
		},
	},
	Secret: pulumi.String("string"),
	TeamId: pulumi.String("string"),
})

    resource "vercel_trace_drain" "traceDrainResource" {
  lifecycle {
    create_before_destroy = true
  }
  delivery_format = "string"
  endpoint        = "string"
  headers = {
    "string" = "string"
  }
  name        = "string"
  project_ids = ["string"]
  sampling_rules {
    rate         = 0
    environment  = "string"
    request_path = "string"
  }
  secret  = "string"
  team_id = "string"
}

    var traceDrainResource = new TraceDrain("traceDrainResource", TraceDrainArgs.builder()
    .deliveryFormat("string")
    .endpoint("string")
    .headers(Map.of("string", "string"))
    .name("string")
    .projectIds("string")
    .samplingRules(TraceDrainSamplingRuleArgs.builder()
        .rate(0.0)
        .environment("string")
        .requestPath("string")
        .build())
    .secret("string")
    .teamId("string")
    .build());

    trace_drain_resource = vercel.TraceDrain("traceDrainResource",
    delivery_format="string",
    endpoint="string",
    headers={
        "string": "string",
    },
    name="string",
    project_ids=["string"],
    sampling_rules=[{
        "rate": float(0),
        "environment": "string",
        "request_path": "string",
    }],
    secret="string",
    team_id="string")

    const traceDrainResource = new vercel.TraceDrain("traceDrainResource", {
    deliveryFormat: "string",
    endpoint: "string",
    headers: {
        string: "string",
    },
    name: "string",
    projectIds: ["string"],
    samplingRules: [{
        rate: 0,
        environment: "string",
        requestPath: "string",
    }],
    secret: "string",
    teamId: "string",
});

    type: vercel:TraceDrain
properties:
    deliveryFormat: string
    endpoint: string
    headers:
        string: string
    name: string
    projectIds:
        - string
    samplingRules:
        - environment: string
          rate: 0
          requestPath: string
    secret: string
    teamId: string

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

    DeliveryFormat string
    The OTLP/HTTP format trace data should be delivered in. Can be json or proto.
    Endpoint string
    The OTLP/HTTP traces endpoint. This should be the full traces endpoint URL, commonly ending in /v1/traces.
    Headers Dictionary<string, string>
    Custom headers to include in requests to the trace drain endpoint.
    Name string
    A human-readable name for the trace drain.
    ProjectIds List<string>
    A list of project IDs that the trace drain should be associated with. If omitted, traces will be sent for all projects.
    SamplingRules List<Pulumiverse.Vercel.Inputs.TraceDrainSamplingRule>
    Ordered sampling rules for traces sent to this drain. If omitted, all traces are sent.
    Secret string
    A custom secret used to sign trace drain events. If omitted, Vercel generates one.
    TeamId string
    The ID of the team the Trace Drain should exist under. Required when configuring a team resource if a default team has not been set in the provider.
    DeliveryFormat string
    The OTLP/HTTP format trace data should be delivered in. Can be json or proto.
    Endpoint string
    The OTLP/HTTP traces endpoint. This should be the full traces endpoint URL, commonly ending in /v1/traces.
    Headers map[string]string
    Custom headers to include in requests to the trace drain endpoint.
    Name string
    A human-readable name for the trace drain.
    ProjectIds []string
    A list of project IDs that the trace drain should be associated with. If omitted, traces will be sent for all projects.
    SamplingRules []TraceDrainSamplingRuleArgs
    Ordered sampling rules for traces sent to this drain. If omitted, all traces are sent.
    Secret string
    A custom secret used to sign trace drain events. If omitted, Vercel generates one.
    TeamId string
    The ID of the team the Trace Drain should exist under. Required when configuring a team resource if a default team has not been set in the provider.
    delivery_format string
    The OTLP/HTTP format trace data should be delivered in. Can be json or proto.
    endpoint string
    The OTLP/HTTP traces endpoint. This should be the full traces endpoint URL, commonly ending in /v1/traces.
    headers map(string)
    Custom headers to include in requests to the trace drain endpoint.
    name string
    A human-readable name for the trace drain.
    project_ids list(string)
    A list of project IDs that the trace drain should be associated with. If omitted, traces will be sent for all projects.
    sampling_rules list(object)
    Ordered sampling rules for traces sent to this drain. If omitted, all traces are sent.
    secret string
    A custom secret used to sign trace drain events. If omitted, Vercel generates one.
    team_id string
    The ID of the team the Trace Drain should exist under. Required when configuring a team resource if a default team has not been set in the provider.
    deliveryFormat String
    The OTLP/HTTP format trace data should be delivered in. Can be json or proto.
    endpoint String
    The OTLP/HTTP traces endpoint. This should be the full traces endpoint URL, commonly ending in /v1/traces.
    headers Map<String,String>
    Custom headers to include in requests to the trace drain endpoint.
    name String
    A human-readable name for the trace drain.
    projectIds List<String>
    A list of project IDs that the trace drain should be associated with. If omitted, traces will be sent for all projects.
    samplingRules List<TraceDrainSamplingRule>
    Ordered sampling rules for traces sent to this drain. If omitted, all traces are sent.
    secret String
    A custom secret used to sign trace drain events. If omitted, Vercel generates one.
    teamId String
    The ID of the team the Trace Drain should exist under. Required when configuring a team resource if a default team has not been set in the provider.
    deliveryFormat string
    The OTLP/HTTP format trace data should be delivered in. Can be json or proto.
    endpoint string
    The OTLP/HTTP traces endpoint. This should be the full traces endpoint URL, commonly ending in /v1/traces.
    headers {[key: string]: string}
    Custom headers to include in requests to the trace drain endpoint.
    name string
    A human-readable name for the trace drain.
    projectIds string[]
    A list of project IDs that the trace drain should be associated with. If omitted, traces will be sent for all projects.
    samplingRules TraceDrainSamplingRule[]
    Ordered sampling rules for traces sent to this drain. If omitted, all traces are sent.
    secret string
    A custom secret used to sign trace drain events. If omitted, Vercel generates one.
    teamId string
    The ID of the team the Trace Drain should exist under. Required when configuring a team resource if a default team has not been set in the provider.
    delivery_format str
    The OTLP/HTTP format trace data should be delivered in. Can be json or proto.
    endpoint str
    The OTLP/HTTP traces endpoint. This should be the full traces endpoint URL, commonly ending in /v1/traces.
    headers Mapping[str, str]
    Custom headers to include in requests to the trace drain endpoint.
    name str
    A human-readable name for the trace drain.
    project_ids Sequence[str]
    A list of project IDs that the trace drain should be associated with. If omitted, traces will be sent for all projects.
    sampling_rules Sequence[TraceDrainSamplingRuleArgs]
    Ordered sampling rules for traces sent to this drain. If omitted, all traces are sent.
    secret str
    A custom secret used to sign trace drain events. If omitted, Vercel generates one.
    team_id str
    The ID of the team the Trace Drain should exist under. Required when configuring a team resource if a default team has not been set in the provider.
    deliveryFormat String
    The OTLP/HTTP format trace data should be delivered in. Can be json or proto.
    endpoint String
    The OTLP/HTTP traces endpoint. This should be the full traces endpoint URL, commonly ending in /v1/traces.
    headers Map<String>
    Custom headers to include in requests to the trace drain endpoint.
    name String
    A human-readable name for the trace drain.
    projectIds List<String>
    A list of project IDs that the trace drain should be associated with. If omitted, traces will be sent for all projects.
    samplingRules List<Property Map>
    Ordered sampling rules for traces sent to this drain. If omitted, all traces are sent.
    secret String
    A custom secret used to sign trace drain events. If omitted, Vercel generates one.
    teamId String
    The ID of the team the Trace Drain should exist under. Required when configuring a team resource if a default team has not been set in the provider.

    Outputs

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

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing TraceDrain Resource

    Get an existing TraceDrain 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?: TraceDrainState, opts?: CustomResourceOptions): TraceDrain
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        delivery_format: Optional[str] = None,
        endpoint: Optional[str] = None,
        headers: Optional[Mapping[str, str]] = None,
        name: Optional[str] = None,
        project_ids: Optional[Sequence[str]] = None,
        sampling_rules: Optional[Sequence[TraceDrainSamplingRuleArgs]] = None,
        secret: Optional[str] = None,
        team_id: Optional[str] = None) -> TraceDrain
    func GetTraceDrain(ctx *Context, name string, id IDInput, state *TraceDrainState, opts ...ResourceOption) (*TraceDrain, error)
    public static TraceDrain Get(string name, Input<string> id, TraceDrainState? state, CustomResourceOptions? opts = null)
    public static TraceDrain get(String name, Output<String> id, TraceDrainState state, CustomResourceOptions options)
    resources:  _:    type: vercel:TraceDrain    get:      id: ${id}
    import {
  to = vercel_trace_drain.example
  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:
    DeliveryFormat string
    The OTLP/HTTP format trace data should be delivered in. Can be json or proto.
    Endpoint string
    The OTLP/HTTP traces endpoint. This should be the full traces endpoint URL, commonly ending in /v1/traces.
    Headers Dictionary<string, string>
    Custom headers to include in requests to the trace drain endpoint.
    Name string
    A human-readable name for the trace drain.
    ProjectIds List<string>
    A list of project IDs that the trace drain should be associated with. If omitted, traces will be sent for all projects.
    SamplingRules List<Pulumiverse.Vercel.Inputs.TraceDrainSamplingRule>
    Ordered sampling rules for traces sent to this drain. If omitted, all traces are sent.
    Secret string
    A custom secret used to sign trace drain events. If omitted, Vercel generates one.
    TeamId string
    The ID of the team the Trace Drain should exist under. Required when configuring a team resource if a default team has not been set in the provider.
    DeliveryFormat string
    The OTLP/HTTP format trace data should be delivered in. Can be json or proto.
    Endpoint string
    The OTLP/HTTP traces endpoint. This should be the full traces endpoint URL, commonly ending in /v1/traces.
    Headers map[string]string
    Custom headers to include in requests to the trace drain endpoint.
    Name string
    A human-readable name for the trace drain.
    ProjectIds []string
    A list of project IDs that the trace drain should be associated with. If omitted, traces will be sent for all projects.
    SamplingRules []TraceDrainSamplingRuleArgs
    Ordered sampling rules for traces sent to this drain. If omitted, all traces are sent.
    Secret string
    A custom secret used to sign trace drain events. If omitted, Vercel generates one.
    TeamId string
    The ID of the team the Trace Drain should exist under. Required when configuring a team resource if a default team has not been set in the provider.
    delivery_format string
    The OTLP/HTTP format trace data should be delivered in. Can be json or proto.
    endpoint string
    The OTLP/HTTP traces endpoint. This should be the full traces endpoint URL, commonly ending in /v1/traces.
    headers map(string)
    Custom headers to include in requests to the trace drain endpoint.
    name string
    A human-readable name for the trace drain.
    project_ids list(string)
    A list of project IDs that the trace drain should be associated with. If omitted, traces will be sent for all projects.
    sampling_rules list(object)
    Ordered sampling rules for traces sent to this drain. If omitted, all traces are sent.
    secret string
    A custom secret used to sign trace drain events. If omitted, Vercel generates one.
    team_id string
    The ID of the team the Trace Drain should exist under. Required when configuring a team resource if a default team has not been set in the provider.
    deliveryFormat String
    The OTLP/HTTP format trace data should be delivered in. Can be json or proto.
    endpoint String
    The OTLP/HTTP traces endpoint. This should be the full traces endpoint URL, commonly ending in /v1/traces.
    headers Map<String,String>
    Custom headers to include in requests to the trace drain endpoint.
    name String
    A human-readable name for the trace drain.
    projectIds List<String>
    A list of project IDs that the trace drain should be associated with. If omitted, traces will be sent for all projects.
    samplingRules List<TraceDrainSamplingRule>
    Ordered sampling rules for traces sent to this drain. If omitted, all traces are sent.
    secret String
    A custom secret used to sign trace drain events. If omitted, Vercel generates one.
    teamId String
    The ID of the team the Trace Drain should exist under. Required when configuring a team resource if a default team has not been set in the provider.
    deliveryFormat string
    The OTLP/HTTP format trace data should be delivered in. Can be json or proto.
    endpoint string
    The OTLP/HTTP traces endpoint. This should be the full traces endpoint URL, commonly ending in /v1/traces.
    headers {[key: string]: string}
    Custom headers to include in requests to the trace drain endpoint.
    name string
    A human-readable name for the trace drain.
    projectIds string[]
    A list of project IDs that the trace drain should be associated with. If omitted, traces will be sent for all projects.
    samplingRules TraceDrainSamplingRule[]
    Ordered sampling rules for traces sent to this drain. If omitted, all traces are sent.
    secret string
    A custom secret used to sign trace drain events. If omitted, Vercel generates one.
    teamId string
    The ID of the team the Trace Drain should exist under. Required when configuring a team resource if a default team has not been set in the provider.
    delivery_format str
    The OTLP/HTTP format trace data should be delivered in. Can be json or proto.
    endpoint str
    The OTLP/HTTP traces endpoint. This should be the full traces endpoint URL, commonly ending in /v1/traces.
    headers Mapping[str, str]
    Custom headers to include in requests to the trace drain endpoint.
    name str
    A human-readable name for the trace drain.
    project_ids Sequence[str]
    A list of project IDs that the trace drain should be associated with. If omitted, traces will be sent for all projects.
    sampling_rules Sequence[TraceDrainSamplingRuleArgs]
    Ordered sampling rules for traces sent to this drain. If omitted, all traces are sent.
    secret str
    A custom secret used to sign trace drain events. If omitted, Vercel generates one.
    team_id str
    The ID of the team the Trace Drain should exist under. Required when configuring a team resource if a default team has not been set in the provider.
    deliveryFormat String
    The OTLP/HTTP format trace data should be delivered in. Can be json or proto.
    endpoint String
    The OTLP/HTTP traces endpoint. This should be the full traces endpoint URL, commonly ending in /v1/traces.
    headers Map<String>
    Custom headers to include in requests to the trace drain endpoint.
    name String
    A human-readable name for the trace drain.
    projectIds List<String>
    A list of project IDs that the trace drain should be associated with. If omitted, traces will be sent for all projects.
    samplingRules List<Property Map>
    Ordered sampling rules for traces sent to this drain. If omitted, all traces are sent.
    secret String
    A custom secret used to sign trace drain events. If omitted, Vercel generates one.
    teamId String
    The ID of the team the Trace Drain should exist under. Required when configuring a team resource if a default team has not been set in the provider.

    Supporting Types

    TraceDrainSamplingRule, TraceDrainSamplingRuleArgs

    Rate double
    Sampling rate from 0 to 1.
    Environment string
    Environment to apply this sampling rule to. Can be production or preview.
    RequestPath string
    Request path prefix to apply this sampling rule to.
    Rate float64
    Sampling rate from 0 to 1.
    Environment string
    Environment to apply this sampling rule to. Can be production or preview.
    RequestPath string
    Request path prefix to apply this sampling rule to.
    rate number
    Sampling rate from 0 to 1.
    environment string
    Environment to apply this sampling rule to. Can be production or preview.
    request_path string
    Request path prefix to apply this sampling rule to.
    rate Double
    Sampling rate from 0 to 1.
    environment String
    Environment to apply this sampling rule to. Can be production or preview.
    requestPath String
    Request path prefix to apply this sampling rule to.
    rate number
    Sampling rate from 0 to 1.
    environment string
    Environment to apply this sampling rule to. Can be production or preview.
    requestPath string
    Request path prefix to apply this sampling rule to.
    rate float
    Sampling rate from 0 to 1.
    environment str
    Environment to apply this sampling rule to. Can be production or preview.
    request_path str
    Request path prefix to apply this sampling rule to.
    rate Number
    Sampling rate from 0 to 1.
    environment String
    Environment to apply this sampling rule to. Can be production or preview.
    requestPath String
    Request path prefix to apply this sampling rule to.

    Import

    The pulumi import command can be used, for example:

    If importing into a personal account, or with a default team configured in the provider, simply use the trace_drain_id.

    $ pulumi import vercel:index/traceDrain:TraceDrain example drn_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

    Alternatively, you can import via team_id/trace_drain_id.

    $ pulumi import vercel:index/traceDrain:TraceDrain example team_xxxxxxxxxxxxxxxxxxxxxxxx/drn_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

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

    Package Details

    Repository
    vercel pulumiverse/pulumi-vercel
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the vercel Terraform Provider.
    vercel logo
    Viewing docs for Vercel v5.4.1
    published on Wednesday, Jul 22, 2026 by Pulumiverse
    Schema (JSON)
    pulumiverse/pulumi-vercel

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial