Sign in Dashboard Get started
  1. Registry
  2. Packages
  3. Sumologic Provider
  4. API Docs
  5. LookupTable
Viewing docs for sumologic 3.3.2
published on Wednesday, Sep 2, 2026 by sumologic
Schema (JSON)
sumologic/terraform-provider-sumologic

sumologic.LookupTable

sumologic logo
Viewing docs for sumologic 3.3.2
published on Wednesday, Sep 2, 2026 by sumologic
Schema (JSON)
sumologic/terraform-provider-sumologic

    Provides a Sumologic Lookup Table.

    Create LookupTable Resource

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

    Constructor syntax

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

@overload
def LookupTable(resource_name: str,
                opts: Optional[ResourceOptions] = None,
                description: Optional[str] = None,
                content: Optional[str] = None,
                fields: Optional[Sequence[LookupTableFieldArgs]] = None,
                lookup_table_id: Optional[str] = None,
                name: Optional[str] = None,
                parent_folder_id: Optional[str] = None,
                primary_keys: Optional[Sequence[str]] = None,
                size_limit_action: Optional[str] = None,
                timeouts: Optional[LookupTableTimeoutsArgs] = None,
                ttl: Optional[float] = None)
    func NewLookupTable(ctx *Context, name string, args LookupTableArgs, opts ...ResourceOption) (*LookupTable, error)
    public LookupTable(string name, LookupTableArgs args, CustomResourceOptions? opts = null)
    public LookupTable(String name, LookupTableArgs args)
public LookupTable(String name, LookupTableArgs args, CustomResourceOptions options)

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


    resource "sumologic_lookup_table" "name" {
    # resource properties
}

    Parameters

    name string
    The unique name of the resource.
    args LookupTableArgs
    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 LookupTableArgs
    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 LookupTableArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args LookupTableArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args LookupTableArgs
    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 lookupTableResource = new Sumologic.LookupTable("lookupTableResource", new()
{
    Description = "string",
    Content = "string",
    Fields = new[]
    {
        new Sumologic.Inputs.LookupTableFieldArgs
        {
            FieldName = "string",
            FieldType = "string",
        },
    },
    LookupTableId = "string",
    Name = "string",
    ParentFolderId = "string",
    PrimaryKeys = new[]
    {
        "string",
    },
    SizeLimitAction = "string",
    Timeouts = new Sumologic.Inputs.LookupTableTimeoutsArgs
    {
        Create = "string",
        Delete = "string",
        Read = "string",
        Update = "string",
    },
    Ttl = 0.0,
});

    example, err := sumologic.NewLookupTable(ctx, "lookupTableResource", &sumologic.LookupTableArgs{
	Description: pulumi.String("string"),
	Content:     pulumi.String("string"),
	Fields: sumologic.LookupTableFieldArray{
		&sumologic.LookupTableFieldArgs{
			FieldName: pulumi.String("string"),
			FieldType: pulumi.String("string"),
		},
	},
	LookupTableId:  pulumi.String("string"),
	Name:           pulumi.String("string"),
	ParentFolderId: pulumi.String("string"),
	PrimaryKeys: pulumi.StringArray{
		pulumi.String("string"),
	},
	SizeLimitAction: pulumi.String("string"),
	Timeouts: &sumologic.LookupTableTimeoutsArgs{
		Create: pulumi.String("string"),
		Delete: pulumi.String("string"),
		Read:   pulumi.String("string"),
		Update: pulumi.String("string"),
	},
	Ttl: pulumi.Float64(0),
})

    resource "sumologic_lookup_table" "lookupTableResource" {
  lifecycle {
    create_before_destroy = true
  }
  description = "string"
  content     = "string"
  fields {
    field_name = "string"
    field_type = "string"
  }
  lookup_table_id   = "string"
  name              = "string"
  parent_folder_id  = "string"
  primary_keys      = ["string"]
  size_limit_action = "string"
  timeouts = {
    create = "string"
    delete = "string"
    read   = "string"
    update = "string"
  }
  ttl = 0
}

    var lookupTableResource = new LookupTable("lookupTableResource", LookupTableArgs.builder()
    .description("string")
    .content("string")
    .fields(LookupTableFieldArgs.builder()
        .fieldName("string")
        .fieldType("string")
        .build())
    .lookupTableId("string")
    .name("string")
    .parentFolderId("string")
    .primaryKeys("string")
    .sizeLimitAction("string")
    .timeouts(LookupTableTimeoutsArgs.builder()
        .create("string")
        .delete("string")
        .read("string")
        .update("string")
        .build())
    .ttl(0.0)
    .build());

    lookup_table_resource = sumologic.LookupTable("lookupTableResource",
    description="string",
    content="string",
    fields=[{
        "field_name": "string",
        "field_type": "string",
    }],
    lookup_table_id="string",
    name="string",
    parent_folder_id="string",
    primary_keys=["string"],
    size_limit_action="string",
    timeouts={
        "create": "string",
        "delete": "string",
        "read": "string",
        "update": "string",
    },
    ttl=float(0))

    const lookupTableResource = new sumologic.LookupTable("lookupTableResource", {
    description: "string",
    content: "string",
    fields: [{
        fieldName: "string",
        fieldType: "string",
    }],
    lookupTableId: "string",
    name: "string",
    parentFolderId: "string",
    primaryKeys: ["string"],
    sizeLimitAction: "string",
    timeouts: {
        create: "string",
        "delete": "string",
        read: "string",
        update: "string",
    },
    ttl: 0,
});

    type: sumologic:LookupTable
properties:
    content: string
    description: string
    fields:
        - fieldName: string
          fieldType: string
    lookupTableId: string
    name: string
    parentFolderId: string
    primaryKeys:
        - string
    sizeLimitAction: string
    timeouts:
        create: string
        delete: string
        read: string
        update: string
    ttl: 0

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

    Description string
    The description of the lookup table.
    Content string
    CSV content to populate the lookup table with, e.g. file("${path.module}/lookup.csv"). Notes:

    • The first row must be a header with column names matching fields.field_name (case-insensitive).
    • Every field in fields must have a matching column, and every field listed in primary_keys must be present.
    • Uploading replaces all existing rows in the table (it is not merged with existing data).
    • Removing this argument truncates the table rather than leaving it unmanaged.
    • This value cannot be read back from the Sumo Logic API. Importing an existing table will show a diff on the first plan if content is set locally, and the state stores a hash of the content rather than the content itself.
    • CSV structure (headers, column count, quoting) is validated at plan time. Cell values are not validated against field_type locally - that is enforced by the API at apply time.
    • The API's upload limit is 100MB per CSV; values over 10MB produce a plan-time warning recommending an ingest pipeline or scheduled search instead.
    • If the upload completes with some rows rejected (e.g. duplicate primary keys), pulumi up still succeeds but shows a warning with the rejected-row detail.
    Fields List<LookupTableField>
    The list of fields in the lookup table.

    • fieldName - (Required) The name of the field.
    • fieldType - (Required) The data type of the field. Supported types: boolean, int, long, double, string
    • primaryKeys - (Required) The names of the fields that make up the primary key for the lookup table. These will be a subset of the fields that the table will contain.
    LookupTableId string
    Name string
    The name of the lookup table.
    ParentFolderId string
    The parent-folder-path identifier of the lookup table in the Library.
    PrimaryKeys List<string>
    The primary key field names.
    SizeLimitAction string
    Timeouts LookupTableTimeouts
    Ttl double
    A time to live for each entry in the lookup table (in minutes). 365 days is the maximum time to live for each entry that you can specify. Setting it to 0 means that the records will not expire automatically.

    • sizeLimitAction - (Optional) The action that needs to be taken when the size limit is reached for the table. The possible values can be StopIncomingMessages or DeleteOldData. DeleteOldData will start deleting old data once size limit is reached whereas StopIncomingMessages will discard all the updates made to the lookup table once size limit is reached.
    Description string
    The description of the lookup table.
    Content string
    CSV content to populate the lookup table with, e.g. file("${path.module}/lookup.csv"). Notes:

    • The first row must be a header with column names matching fields.field_name (case-insensitive).
    • Every field in fields must have a matching column, and every field listed in primary_keys must be present.
    • Uploading replaces all existing rows in the table (it is not merged with existing data).
    • Removing this argument truncates the table rather than leaving it unmanaged.
    • This value cannot be read back from the Sumo Logic API. Importing an existing table will show a diff on the first plan if content is set locally, and the state stores a hash of the content rather than the content itself.
    • CSV structure (headers, column count, quoting) is validated at plan time. Cell values are not validated against field_type locally - that is enforced by the API at apply time.
    • The API's upload limit is 100MB per CSV; values over 10MB produce a plan-time warning recommending an ingest pipeline or scheduled search instead.
    • If the upload completes with some rows rejected (e.g. duplicate primary keys), pulumi up still succeeds but shows a warning with the rejected-row detail.
    Fields []LookupTableFieldArgs
    The list of fields in the lookup table.

    • fieldName - (Required) The name of the field.
    • fieldType - (Required) The data type of the field. Supported types: boolean, int, long, double, string
    • primaryKeys - (Required) The names of the fields that make up the primary key for the lookup table. These will be a subset of the fields that the table will contain.
    LookupTableId string
    Name string
    The name of the lookup table.
    ParentFolderId string
    The parent-folder-path identifier of the lookup table in the Library.
    PrimaryKeys []string
    The primary key field names.
    SizeLimitAction string
    Timeouts LookupTableTimeoutsArgs
    Ttl float64
    A time to live for each entry in the lookup table (in minutes). 365 days is the maximum time to live for each entry that you can specify. Setting it to 0 means that the records will not expire automatically.

    • sizeLimitAction - (Optional) The action that needs to be taken when the size limit is reached for the table. The possible values can be StopIncomingMessages or DeleteOldData. DeleteOldData will start deleting old data once size limit is reached whereas StopIncomingMessages will discard all the updates made to the lookup table once size limit is reached.
    description string
    The description of the lookup table.
    content string
    CSV content to populate the lookup table with, e.g. file("${path.module}/lookup.csv"). Notes:

    • The first row must be a header with column names matching fields.field_name (case-insensitive).
    • Every field in fields must have a matching column, and every field listed in primary_keys must be present.
    • Uploading replaces all existing rows in the table (it is not merged with existing data).
    • Removing this argument truncates the table rather than leaving it unmanaged.
    • This value cannot be read back from the Sumo Logic API. Importing an existing table will show a diff on the first plan if content is set locally, and the state stores a hash of the content rather than the content itself.
    • CSV structure (headers, column count, quoting) is validated at plan time. Cell values are not validated against field_type locally - that is enforced by the API at apply time.
    • The API's upload limit is 100MB per CSV; values over 10MB produce a plan-time warning recommending an ingest pipeline or scheduled search instead.
    • If the upload completes with some rows rejected (e.g. duplicate primary keys), pulumi up still succeeds but shows a warning with the rejected-row detail.
    fields list(object)
    The list of fields in the lookup table.

    • fieldName - (Required) The name of the field.
    • fieldType - (Required) The data type of the field. Supported types: boolean, int, long, double, string
    • primaryKeys - (Required) The names of the fields that make up the primary key for the lookup table. These will be a subset of the fields that the table will contain.
    lookup_table_id string
    name string
    The name of the lookup table.
    parent_folder_id string
    The parent-folder-path identifier of the lookup table in the Library.
    primary_keys list(string)
    The primary key field names.
    size_limit_action string
    timeouts object
    ttl number
    A time to live for each entry in the lookup table (in minutes). 365 days is the maximum time to live for each entry that you can specify. Setting it to 0 means that the records will not expire automatically.

    • sizeLimitAction - (Optional) The action that needs to be taken when the size limit is reached for the table. The possible values can be StopIncomingMessages or DeleteOldData. DeleteOldData will start deleting old data once size limit is reached whereas StopIncomingMessages will discard all the updates made to the lookup table once size limit is reached.
    description String
    The description of the lookup table.
    content String
    CSV content to populate the lookup table with, e.g. file("${path.module}/lookup.csv"). Notes:

    • The first row must be a header with column names matching fields.field_name (case-insensitive).
    • Every field in fields must have a matching column, and every field listed in primary_keys must be present.
    • Uploading replaces all existing rows in the table (it is not merged with existing data).
    • Removing this argument truncates the table rather than leaving it unmanaged.
    • This value cannot be read back from the Sumo Logic API. Importing an existing table will show a diff on the first plan if content is set locally, and the state stores a hash of the content rather than the content itself.
    • CSV structure (headers, column count, quoting) is validated at plan time. Cell values are not validated against field_type locally - that is enforced by the API at apply time.
    • The API's upload limit is 100MB per CSV; values over 10MB produce a plan-time warning recommending an ingest pipeline or scheduled search instead.
    • If the upload completes with some rows rejected (e.g. duplicate primary keys), pulumi up still succeeds but shows a warning with the rejected-row detail.
    fields List<LookupTableField>
    The list of fields in the lookup table.

    • fieldName - (Required) The name of the field.
    • fieldType - (Required) The data type of the field. Supported types: boolean, int, long, double, string
    • primaryKeys - (Required) The names of the fields that make up the primary key for the lookup table. These will be a subset of the fields that the table will contain.
    lookupTableId String
    name String
    The name of the lookup table.
    parentFolderId String
    The parent-folder-path identifier of the lookup table in the Library.
    primaryKeys List<String>
    The primary key field names.
    sizeLimitAction String
    timeouts LookupTableTimeouts
    ttl Double
    A time to live for each entry in the lookup table (in minutes). 365 days is the maximum time to live for each entry that you can specify. Setting it to 0 means that the records will not expire automatically.

    • sizeLimitAction - (Optional) The action that needs to be taken when the size limit is reached for the table. The possible values can be StopIncomingMessages or DeleteOldData. DeleteOldData will start deleting old data once size limit is reached whereas StopIncomingMessages will discard all the updates made to the lookup table once size limit is reached.
    description string
    The description of the lookup table.
    content string
    CSV content to populate the lookup table with, e.g. file("${path.module}/lookup.csv"). Notes:

    • The first row must be a header with column names matching fields.field_name (case-insensitive).
    • Every field in fields must have a matching column, and every field listed in primary_keys must be present.
    • Uploading replaces all existing rows in the table (it is not merged with existing data).
    • Removing this argument truncates the table rather than leaving it unmanaged.
    • This value cannot be read back from the Sumo Logic API. Importing an existing table will show a diff on the first plan if content is set locally, and the state stores a hash of the content rather than the content itself.
    • CSV structure (headers, column count, quoting) is validated at plan time. Cell values are not validated against field_type locally - that is enforced by the API at apply time.
    • The API's upload limit is 100MB per CSV; values over 10MB produce a plan-time warning recommending an ingest pipeline or scheduled search instead.
    • If the upload completes with some rows rejected (e.g. duplicate primary keys), pulumi up still succeeds but shows a warning with the rejected-row detail.
    fields LookupTableField[]
    The list of fields in the lookup table.

    • fieldName - (Required) The name of the field.
    • fieldType - (Required) The data type of the field. Supported types: boolean, int, long, double, string
    • primaryKeys - (Required) The names of the fields that make up the primary key for the lookup table. These will be a subset of the fields that the table will contain.
    lookupTableId string
    name string
    The name of the lookup table.
    parentFolderId string
    The parent-folder-path identifier of the lookup table in the Library.
    primaryKeys string[]
    The primary key field names.
    sizeLimitAction string
    timeouts LookupTableTimeouts
    ttl number
    A time to live for each entry in the lookup table (in minutes). 365 days is the maximum time to live for each entry that you can specify. Setting it to 0 means that the records will not expire automatically.

    • sizeLimitAction - (Optional) The action that needs to be taken when the size limit is reached for the table. The possible values can be StopIncomingMessages or DeleteOldData. DeleteOldData will start deleting old data once size limit is reached whereas StopIncomingMessages will discard all the updates made to the lookup table once size limit is reached.
    description str
    The description of the lookup table.
    content str
    CSV content to populate the lookup table with, e.g. file("${path.module}/lookup.csv"). Notes:

    • The first row must be a header with column names matching fields.field_name (case-insensitive).
    • Every field in fields must have a matching column, and every field listed in primary_keys must be present.
    • Uploading replaces all existing rows in the table (it is not merged with existing data).
    • Removing this argument truncates the table rather than leaving it unmanaged.
    • This value cannot be read back from the Sumo Logic API. Importing an existing table will show a diff on the first plan if content is set locally, and the state stores a hash of the content rather than the content itself.
    • CSV structure (headers, column count, quoting) is validated at plan time. Cell values are not validated against field_type locally - that is enforced by the API at apply time.
    • The API's upload limit is 100MB per CSV; values over 10MB produce a plan-time warning recommending an ingest pipeline or scheduled search instead.
    • If the upload completes with some rows rejected (e.g. duplicate primary keys), pulumi up still succeeds but shows a warning with the rejected-row detail.
    fields Sequence[LookupTableFieldArgs]
    The list of fields in the lookup table.

    • fieldName - (Required) The name of the field.
    • fieldType - (Required) The data type of the field. Supported types: boolean, int, long, double, string
    • primaryKeys - (Required) The names of the fields that make up the primary key for the lookup table. These will be a subset of the fields that the table will contain.
    lookup_table_id str
    name str
    The name of the lookup table.
    parent_folder_id str
    The parent-folder-path identifier of the lookup table in the Library.
    primary_keys Sequence[str]
    The primary key field names.
    size_limit_action str
    timeouts LookupTableTimeoutsArgs
    ttl float
    A time to live for each entry in the lookup table (in minutes). 365 days is the maximum time to live for each entry that you can specify. Setting it to 0 means that the records will not expire automatically.

    • sizeLimitAction - (Optional) The action that needs to be taken when the size limit is reached for the table. The possible values can be StopIncomingMessages or DeleteOldData. DeleteOldData will start deleting old data once size limit is reached whereas StopIncomingMessages will discard all the updates made to the lookup table once size limit is reached.
    description String
    The description of the lookup table.
    content String
    CSV content to populate the lookup table with, e.g. file("${path.module}/lookup.csv"). Notes:

    • The first row must be a header with column names matching fields.field_name (case-insensitive).
    • Every field in fields must have a matching column, and every field listed in primary_keys must be present.
    • Uploading replaces all existing rows in the table (it is not merged with existing data).
    • Removing this argument truncates the table rather than leaving it unmanaged.
    • This value cannot be read back from the Sumo Logic API. Importing an existing table will show a diff on the first plan if content is set locally, and the state stores a hash of the content rather than the content itself.
    • CSV structure (headers, column count, quoting) is validated at plan time. Cell values are not validated against field_type locally - that is enforced by the API at apply time.
    • The API's upload limit is 100MB per CSV; values over 10MB produce a plan-time warning recommending an ingest pipeline or scheduled search instead.
    • If the upload completes with some rows rejected (e.g. duplicate primary keys), pulumi up still succeeds but shows a warning with the rejected-row detail.
    fields List<Property Map>
    The list of fields in the lookup table.

    • fieldName - (Required) The name of the field.
    • fieldType - (Required) The data type of the field. Supported types: boolean, int, long, double, string
    • primaryKeys - (Required) The names of the fields that make up the primary key for the lookup table. These will be a subset of the fields that the table will contain.
    lookupTableId String
    name String
    The name of the lookup table.
    parentFolderId String
    The parent-folder-path identifier of the lookup table in the Library.
    primaryKeys List<String>
    The primary key field names.
    sizeLimitAction String
    timeouts Property Map
    ttl Number
    A time to live for each entry in the lookup table (in minutes). 365 days is the maximum time to live for each entry that you can specify. Setting it to 0 means that the records will not expire automatically.

    • sizeLimitAction - (Optional) The action that needs to be taken when the size limit is reached for the table. The possible values can be StopIncomingMessages or DeleteOldData. DeleteOldData will start deleting old data once size limit is reached whereas StopIncomingMessages will discard all the updates made to the lookup table once size limit is reached.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the LookupTable 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 LookupTable Resource

    Get an existing LookupTable 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?: LookupTableState, opts?: CustomResourceOptions): LookupTable
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        content: Optional[str] = None,
        description: Optional[str] = None,
        fields: Optional[Sequence[LookupTableFieldArgs]] = None,
        lookup_table_id: Optional[str] = None,
        name: Optional[str] = None,
        parent_folder_id: Optional[str] = None,
        primary_keys: Optional[Sequence[str]] = None,
        size_limit_action: Optional[str] = None,
        timeouts: Optional[LookupTableTimeoutsArgs] = None,
        ttl: Optional[float] = None) -> LookupTable
    func GetLookupTable(ctx *Context, name string, id IDInput, state *LookupTableState, opts ...ResourceOption) (*LookupTable, error)
    public static LookupTable Get(string name, Input<string> id, LookupTableState? state, CustomResourceOptions? opts = null)
    public static LookupTable get(String name, Output<String> id, LookupTableState state, CustomResourceOptions options)
    resources:  _:    type: sumologic:LookupTable    get:      id: ${id}
    import {
  to = sumologic_lookup_table.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:
    Content string
    CSV content to populate the lookup table with, e.g. file("${path.module}/lookup.csv"). Notes:

    • The first row must be a header with column names matching fields.field_name (case-insensitive).
    • Every field in fields must have a matching column, and every field listed in primary_keys must be present.
    • Uploading replaces all existing rows in the table (it is not merged with existing data).
    • Removing this argument truncates the table rather than leaving it unmanaged.
    • This value cannot be read back from the Sumo Logic API. Importing an existing table will show a diff on the first plan if content is set locally, and the state stores a hash of the content rather than the content itself.
    • CSV structure (headers, column count, quoting) is validated at plan time. Cell values are not validated against field_type locally - that is enforced by the API at apply time.
    • The API's upload limit is 100MB per CSV; values over 10MB produce a plan-time warning recommending an ingest pipeline or scheduled search instead.
    • If the upload completes with some rows rejected (e.g. duplicate primary keys), pulumi up still succeeds but shows a warning with the rejected-row detail.
    Description string
    The description of the lookup table.
    Fields List<LookupTableField>
    The list of fields in the lookup table.

    • fieldName - (Required) The name of the field.
    • fieldType - (Required) The data type of the field. Supported types: boolean, int, long, double, string
    • primaryKeys - (Required) The names of the fields that make up the primary key for the lookup table. These will be a subset of the fields that the table will contain.
    LookupTableId string
    Name string
    The name of the lookup table.
    ParentFolderId string
    The parent-folder-path identifier of the lookup table in the Library.
    PrimaryKeys List<string>
    The primary key field names.
    SizeLimitAction string
    Timeouts LookupTableTimeouts
    Ttl double
    A time to live for each entry in the lookup table (in minutes). 365 days is the maximum time to live for each entry that you can specify. Setting it to 0 means that the records will not expire automatically.

    • sizeLimitAction - (Optional) The action that needs to be taken when the size limit is reached for the table. The possible values can be StopIncomingMessages or DeleteOldData. DeleteOldData will start deleting old data once size limit is reached whereas StopIncomingMessages will discard all the updates made to the lookup table once size limit is reached.
    Content string
    CSV content to populate the lookup table with, e.g. file("${path.module}/lookup.csv"). Notes:

    • The first row must be a header with column names matching fields.field_name (case-insensitive).
    • Every field in fields must have a matching column, and every field listed in primary_keys must be present.
    • Uploading replaces all existing rows in the table (it is not merged with existing data).
    • Removing this argument truncates the table rather than leaving it unmanaged.
    • This value cannot be read back from the Sumo Logic API. Importing an existing table will show a diff on the first plan if content is set locally, and the state stores a hash of the content rather than the content itself.
    • CSV structure (headers, column count, quoting) is validated at plan time. Cell values are not validated against field_type locally - that is enforced by the API at apply time.
    • The API's upload limit is 100MB per CSV; values over 10MB produce a plan-time warning recommending an ingest pipeline or scheduled search instead.
    • If the upload completes with some rows rejected (e.g. duplicate primary keys), pulumi up still succeeds but shows a warning with the rejected-row detail.
    Description string
    The description of the lookup table.
    Fields []LookupTableFieldArgs
    The list of fields in the lookup table.

    • fieldName - (Required) The name of the field.
    • fieldType - (Required) The data type of the field. Supported types: boolean, int, long, double, string
    • primaryKeys - (Required) The names of the fields that make up the primary key for the lookup table. These will be a subset of the fields that the table will contain.
    LookupTableId string
    Name string
    The name of the lookup table.
    ParentFolderId string
    The parent-folder-path identifier of the lookup table in the Library.
    PrimaryKeys []string
    The primary key field names.
    SizeLimitAction string
    Timeouts LookupTableTimeoutsArgs
    Ttl float64
    A time to live for each entry in the lookup table (in minutes). 365 days is the maximum time to live for each entry that you can specify. Setting it to 0 means that the records will not expire automatically.

    • sizeLimitAction - (Optional) The action that needs to be taken when the size limit is reached for the table. The possible values can be StopIncomingMessages or DeleteOldData. DeleteOldData will start deleting old data once size limit is reached whereas StopIncomingMessages will discard all the updates made to the lookup table once size limit is reached.
    content string
    CSV content to populate the lookup table with, e.g. file("${path.module}/lookup.csv"). Notes:

    • The first row must be a header with column names matching fields.field_name (case-insensitive).
    • Every field in fields must have a matching column, and every field listed in primary_keys must be present.
    • Uploading replaces all existing rows in the table (it is not merged with existing data).
    • Removing this argument truncates the table rather than leaving it unmanaged.
    • This value cannot be read back from the Sumo Logic API. Importing an existing table will show a diff on the first plan if content is set locally, and the state stores a hash of the content rather than the content itself.
    • CSV structure (headers, column count, quoting) is validated at plan time. Cell values are not validated against field_type locally - that is enforced by the API at apply time.
    • The API's upload limit is 100MB per CSV; values over 10MB produce a plan-time warning recommending an ingest pipeline or scheduled search instead.
    • If the upload completes with some rows rejected (e.g. duplicate primary keys), pulumi up still succeeds but shows a warning with the rejected-row detail.
    description string
    The description of the lookup table.
    fields list(object)
    The list of fields in the lookup table.

    • fieldName - (Required) The name of the field.
    • fieldType - (Required) The data type of the field. Supported types: boolean, int, long, double, string
    • primaryKeys - (Required) The names of the fields that make up the primary key for the lookup table. These will be a subset of the fields that the table will contain.
    lookup_table_id string
    name string
    The name of the lookup table.
    parent_folder_id string
    The parent-folder-path identifier of the lookup table in the Library.
    primary_keys list(string)
    The primary key field names.
    size_limit_action string
    timeouts object
    ttl number
    A time to live for each entry in the lookup table (in minutes). 365 days is the maximum time to live for each entry that you can specify. Setting it to 0 means that the records will not expire automatically.

    • sizeLimitAction - (Optional) The action that needs to be taken when the size limit is reached for the table. The possible values can be StopIncomingMessages or DeleteOldData. DeleteOldData will start deleting old data once size limit is reached whereas StopIncomingMessages will discard all the updates made to the lookup table once size limit is reached.
    content String
    CSV content to populate the lookup table with, e.g. file("${path.module}/lookup.csv"). Notes:

    • The first row must be a header with column names matching fields.field_name (case-insensitive).
    • Every field in fields must have a matching column, and every field listed in primary_keys must be present.
    • Uploading replaces all existing rows in the table (it is not merged with existing data).
    • Removing this argument truncates the table rather than leaving it unmanaged.
    • This value cannot be read back from the Sumo Logic API. Importing an existing table will show a diff on the first plan if content is set locally, and the state stores a hash of the content rather than the content itself.
    • CSV structure (headers, column count, quoting) is validated at plan time. Cell values are not validated against field_type locally - that is enforced by the API at apply time.
    • The API's upload limit is 100MB per CSV; values over 10MB produce a plan-time warning recommending an ingest pipeline or scheduled search instead.
    • If the upload completes with some rows rejected (e.g. duplicate primary keys), pulumi up still succeeds but shows a warning with the rejected-row detail.
    description String
    The description of the lookup table.
    fields List<LookupTableField>
    The list of fields in the lookup table.

    • fieldName - (Required) The name of the field.
    • fieldType - (Required) The data type of the field. Supported types: boolean, int, long, double, string
    • primaryKeys - (Required) The names of the fields that make up the primary key for the lookup table. These will be a subset of the fields that the table will contain.
    lookupTableId String
    name String
    The name of the lookup table.
    parentFolderId String
    The parent-folder-path identifier of the lookup table in the Library.
    primaryKeys List<String>
    The primary key field names.
    sizeLimitAction String
    timeouts LookupTableTimeouts
    ttl Double
    A time to live for each entry in the lookup table (in minutes). 365 days is the maximum time to live for each entry that you can specify. Setting it to 0 means that the records will not expire automatically.

    • sizeLimitAction - (Optional) The action that needs to be taken when the size limit is reached for the table. The possible values can be StopIncomingMessages or DeleteOldData. DeleteOldData will start deleting old data once size limit is reached whereas StopIncomingMessages will discard all the updates made to the lookup table once size limit is reached.
    content string
    CSV content to populate the lookup table with, e.g. file("${path.module}/lookup.csv"). Notes:

    • The first row must be a header with column names matching fields.field_name (case-insensitive).
    • Every field in fields must have a matching column, and every field listed in primary_keys must be present.
    • Uploading replaces all existing rows in the table (it is not merged with existing data).
    • Removing this argument truncates the table rather than leaving it unmanaged.
    • This value cannot be read back from the Sumo Logic API. Importing an existing table will show a diff on the first plan if content is set locally, and the state stores a hash of the content rather than the content itself.
    • CSV structure (headers, column count, quoting) is validated at plan time. Cell values are not validated against field_type locally - that is enforced by the API at apply time.
    • The API's upload limit is 100MB per CSV; values over 10MB produce a plan-time warning recommending an ingest pipeline or scheduled search instead.
    • If the upload completes with some rows rejected (e.g. duplicate primary keys), pulumi up still succeeds but shows a warning with the rejected-row detail.
    description string
    The description of the lookup table.
    fields LookupTableField[]
    The list of fields in the lookup table.

    • fieldName - (Required) The name of the field.
    • fieldType - (Required) The data type of the field. Supported types: boolean, int, long, double, string
    • primaryKeys - (Required) The names of the fields that make up the primary key for the lookup table. These will be a subset of the fields that the table will contain.
    lookupTableId string
    name string
    The name of the lookup table.
    parentFolderId string
    The parent-folder-path identifier of the lookup table in the Library.
    primaryKeys string[]
    The primary key field names.
    sizeLimitAction string
    timeouts LookupTableTimeouts
    ttl number
    A time to live for each entry in the lookup table (in minutes). 365 days is the maximum time to live for each entry that you can specify. Setting it to 0 means that the records will not expire automatically.

    • sizeLimitAction - (Optional) The action that needs to be taken when the size limit is reached for the table. The possible values can be StopIncomingMessages or DeleteOldData. DeleteOldData will start deleting old data once size limit is reached whereas StopIncomingMessages will discard all the updates made to the lookup table once size limit is reached.
    content str
    CSV content to populate the lookup table with, e.g. file("${path.module}/lookup.csv"). Notes:

    • The first row must be a header with column names matching fields.field_name (case-insensitive).
    • Every field in fields must have a matching column, and every field listed in primary_keys must be present.
    • Uploading replaces all existing rows in the table (it is not merged with existing data).
    • Removing this argument truncates the table rather than leaving it unmanaged.
    • This value cannot be read back from the Sumo Logic API. Importing an existing table will show a diff on the first plan if content is set locally, and the state stores a hash of the content rather than the content itself.
    • CSV structure (headers, column count, quoting) is validated at plan time. Cell values are not validated against field_type locally - that is enforced by the API at apply time.
    • The API's upload limit is 100MB per CSV; values over 10MB produce a plan-time warning recommending an ingest pipeline or scheduled search instead.
    • If the upload completes with some rows rejected (e.g. duplicate primary keys), pulumi up still succeeds but shows a warning with the rejected-row detail.
    description str
    The description of the lookup table.
    fields Sequence[LookupTableFieldArgs]
    The list of fields in the lookup table.

    • fieldName - (Required) The name of the field.
    • fieldType - (Required) The data type of the field. Supported types: boolean, int, long, double, string
    • primaryKeys - (Required) The names of the fields that make up the primary key for the lookup table. These will be a subset of the fields that the table will contain.
    lookup_table_id str
    name str
    The name of the lookup table.
    parent_folder_id str
    The parent-folder-path identifier of the lookup table in the Library.
    primary_keys Sequence[str]
    The primary key field names.
    size_limit_action str
    timeouts LookupTableTimeoutsArgs
    ttl float
    A time to live for each entry in the lookup table (in minutes). 365 days is the maximum time to live for each entry that you can specify. Setting it to 0 means that the records will not expire automatically.

    • sizeLimitAction - (Optional) The action that needs to be taken when the size limit is reached for the table. The possible values can be StopIncomingMessages or DeleteOldData. DeleteOldData will start deleting old data once size limit is reached whereas StopIncomingMessages will discard all the updates made to the lookup table once size limit is reached.
    content String
    CSV content to populate the lookup table with, e.g. file("${path.module}/lookup.csv"). Notes:

    • The first row must be a header with column names matching fields.field_name (case-insensitive).
    • Every field in fields must have a matching column, and every field listed in primary_keys must be present.
    • Uploading replaces all existing rows in the table (it is not merged with existing data).
    • Removing this argument truncates the table rather than leaving it unmanaged.
    • This value cannot be read back from the Sumo Logic API. Importing an existing table will show a diff on the first plan if content is set locally, and the state stores a hash of the content rather than the content itself.
    • CSV structure (headers, column count, quoting) is validated at plan time. Cell values are not validated against field_type locally - that is enforced by the API at apply time.
    • The API's upload limit is 100MB per CSV; values over 10MB produce a plan-time warning recommending an ingest pipeline or scheduled search instead.
    • If the upload completes with some rows rejected (e.g. duplicate primary keys), pulumi up still succeeds but shows a warning with the rejected-row detail.
    description String
    The description of the lookup table.
    fields List<Property Map>
    The list of fields in the lookup table.

    • fieldName - (Required) The name of the field.
    • fieldType - (Required) The data type of the field. Supported types: boolean, int, long, double, string
    • primaryKeys - (Required) The names of the fields that make up the primary key for the lookup table. These will be a subset of the fields that the table will contain.
    lookupTableId String
    name String
    The name of the lookup table.
    parentFolderId String
    The parent-folder-path identifier of the lookup table in the Library.
    primaryKeys List<String>
    The primary key field names.
    sizeLimitAction String
    timeouts Property Map
    ttl Number
    A time to live for each entry in the lookup table (in minutes). 365 days is the maximum time to live for each entry that you can specify. Setting it to 0 means that the records will not expire automatically.

    • sizeLimitAction - (Optional) The action that needs to be taken when the size limit is reached for the table. The possible values can be StopIncomingMessages or DeleteOldData. DeleteOldData will start deleting old data once size limit is reached whereas StopIncomingMessages will discard all the updates made to the lookup table once size limit is reached.

    Supporting Types

    LookupTableField, LookupTableFieldArgs

    FieldName string
    FieldType string
    FieldName string
    FieldType string
    field_name string
    field_type string
    fieldName String
    fieldType String
    fieldName string
    fieldType string
    fieldName String
    fieldType String

    LookupTableTimeouts, LookupTableTimeoutsArgs

    Create string
    Delete string
    Read string
    Update string
    Create string
    Delete string
    Read string
    Update string
    create string
    delete string
    read string
    update string
    create String
    delete String
    read String
    update String
    create string
    delete string
    read string
    update string
    create str
    delete str
    read str
    update str
    create String
    delete String
    read String
    update String

    Import

    Lookup Tables can be imported using the id, e.g.:

    hcl

    $ pulumi import sumologic:index/lookupTable:LookupTable test 1234567890

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

    Package Details

    Repository
    Sumo Logic sumologic/terraform-provider-sumologic
    License
    Notes
    This Pulumi package is based on the sumologic Terraform Provider.
    sumologic logo
    Viewing docs for sumologic 3.3.2
    published on Wednesday, Sep 2, 2026 by sumologic
    Schema (JSON)
    sumologic/terraform-provider-sumologic

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial