Working with Columns

Columns define the schema of your datasets and control how fields are displayed and queried in the Honeycomb UI.

Basic Column Operations

List Columns

async def list_columns(client: HoneycombClient, dataset: str) -> list[Column]:
    """List all columns in a dataset.

    Args:
        client: Authenticated HoneycombClient
        dataset: Dataset slug to list columns from

    Returns:
        List of columns
    """
    columns = await client.columns.list_async(dataset)
    for column in columns:
        hidden = " (hidden)" if column.hidden else ""
        print(f"{column.key_name}: {column.type.value}{hidden}")
    return columns

Get a Specific Column

async def get_column(client: HoneycombClient, dataset: str, column_id: str) -> Column:
    """Get a specific column by ID.

    Args:
        client: Authenticated HoneycombClient
        dataset: Dataset slug containing the column
        column_id: ID of the column to retrieve

    Returns:
        The column object
    """
    column = await client.columns.get_async(dataset, column_id)
    print(f"Column: {column.key_name} ({column.type.value})")
    if column.description:
        print(f"Description: {column.description}")
    print(f"Hidden: {column.hidden}")
    return column

Delete a Column

async def delete_column(client: HoneycombClient, dataset: str, column_id: str) -> None:
    """Delete a column.

    Args:
        client: Authenticated HoneycombClient
        dataset: Dataset slug containing the column
        column_id: ID of the column to delete
    """
    await client.columns.delete_async(dataset, column_id)

Creating Columns

Basic Column

async def create_basic_column(client: HoneycombClient, dataset: str) -> str:
    """Create a basic float column.

    Args:
        client: Authenticated HoneycombClient
        dataset: Dataset slug to create column in

    Returns:
        The created column ID
    """
    column = await client.columns.create_async(
        dataset,
        ColumnCreate(
            key_name="response_time_ms",
            type=ColumnType.float,
            description="API response time in milliseconds",
        ),
    )
    return column.id

Hidden Column

Hidden columns are excluded from autocomplete and raw data field lists:

async def create_hidden_column(client: HoneycombClient, dataset: str) -> str:
    """Create a hidden column (excluded from autocomplete).

    Args:
        client: Authenticated HoneycombClient
        dataset: Dataset slug to create column in

    Returns:
        The created column ID
    """
    column = await client.columns.create_async(
        dataset,
        ColumnCreate(
            key_name="internal_trace_id",
            type=ColumnType.string,
            description="Internal tracing identifier",
            hidden=True,
        ),
    )
    return column.id

Updating Columns

async def update_column(
    client: HoneycombClient, dataset: str, column_id: str
) -> Column:
    """Update a column's description and hidden status.

    Args:
        client: Authenticated HoneycombClient
        dataset: Dataset slug containing the column
        column_id: ID of the column to update

    Returns:
        The updated column object
    """
    # Get existing column first to preserve values
    existing = await client.columns.get_async(dataset, column_id)

    # Update with new values
    updated = await client.columns.update_async(
        dataset,
        column_id,
        ColumnCreate(
            key_name=existing.key_name,
            type=existing.type,
            description="Updated description for response time",
            hidden=False,  # Make visible in autocomplete
        ),
    )
    return updated

Column Types

Available column types:

• ColumnType.STRING - Text data (default)
• ColumnType.INTEGER - Whole numbers
• ColumnType.FLOAT - Decimal numbers
• ColumnType.BOOLEAN - True/false values

Sync Usage

All column operations have sync equivalents:

with HoneycombClient(api_key="...", sync=True) as client:
    columns = client.columns.list("my-dataset")
    column = client.columns.create("my-dataset", ColumnCreate(...))
    column = client.columns.get("my-dataset", column_id)
    updated = client.columns.update("my-dataset", column_id, ColumnCreate(...))
    client.columns.delete("my-dataset", column_id)