src/app.py

This document will dive deeper into the initial structure of the app.py file when starting working with Apps.

The file consists of a few main parts:

1. Logger initialization

2. Asset definition

3. App initialization

4. Actions definitions

5. App CLI invocation

Here’s an example app.py file which uses a wide variety of the features available in the SDK:

from collections.abc import Generator, Iterator
from datetime import UTC, datetime
from pathlib import Path
from zoneinfo import ZoneInfo

from soar_sdk.abstract import SOARClient
from soar_sdk.action_results import ActionOutput, MakeRequestOutput, OutputField
from soar_sdk.app import App
from soar_sdk.asset import AssetField, BaseAsset, FieldCategory
from soar_sdk.logging import getLogger
from soar_sdk.models.artifact import Artifact
from soar_sdk.models.container import Container
from soar_sdk.models.finding import Finding, FindingAttachment, FindingEmail
from soar_sdk.params import (
    MakeRequestParams,
    OnESPollParams,
    OnPollParams,
    Param,
    Params,
)

logger = getLogger()

APP_ID = "9b388c08-67de-4ca4-817f-26f8fb7cbf55"
AUTH_FILESYSTEM_MARKER = "papp-37866-auth-filesystem-marker"
CACHE_FILESYSTEM_MARKER = "papp-37866-cache-filesystem-marker"
INGEST_FILESYSTEM_MARKER = "papp-37866-ingest-filesystem-marker"

SAMPLE_EMAILS = [
    {
        "from": "phishing@malicious-domain.example.com",
        "to": "employee1@company.example.com",
        "subject": "Urgent: Verify your account",
        "date": None,
        "body": (
            "Dear user,\n\n"
            "Your account has been compromised. Please click the link below "
            "to verify your identity immediately.\n\n"
            "https://malicious-login.example.com/verify?token=abc123\n\n"
            "Regards,\nIT Support"
        ),
        "urls": [
            "https://malicious-login.example.com/verify?token=abc123",
        ],
        "attachment_name": "invoice.pdf",
        "attachment_data": b"fake pdf attachment content",
    },
    {
        "from": "spam@spoofed-bank.example.com",
        "to": "employee2@company.example.com",
        "subject": "Your payment is overdue",
        "date": None,
        "body": (
            "Hello,\n\n"
            "We noticed an outstanding balance on your account. "
            "Please review the attached statement and submit payment.\n\n"
            "https://fake-payment.example.com/pay\n\n"
            "Thank you,\nBilling Department"
        ),
        "urls": [
            "https://fake-payment.example.com/pay",
        ],
        "attachment_name": "statement.xlsx",
        "attachment_data": b"fake spreadsheet content",
    },
]


class Asset(BaseAsset):
    base_url: str = AssetField(default="https://example")
    api_key: str = AssetField(sensitive=True, description="API key for authentication")
    secret_alias: str = AssetField(
        sensitive=True,
        alias="bearer_token",
        description="Secret asset param with an alias",
    )
    key_header: str = AssetField(
        default="Authorization",
        value_list=["Authorization", "X-API-Key"],
        description="Header for API key authentication",
    )
    timezone: ZoneInfo
    timezone_with_default: ZoneInfo = AssetField(
        default=ZoneInfo("America/Denver"), category=FieldCategory.ACTION
    )


app = App(
    asset_cls=Asset,
    name="example_app",
    appid=APP_ID,
    app_type="sandbox",
    product_vendor="Splunk Inc.",
    logo="logo.svg",
    logo_dark="logo_dark.svg",
    product_name="Example App",
    publisher="Splunk Inc.",
    min_phantom_version="6.2.2.134",
)


@app.test_connectivity()
def test_connectivity(soar: SOARClient, asset: Asset) -> None:
    soar.get("rest/version")
    container_id = soar.get_executing_container_id()
    logger.info(f"current executing container's container_id is: {container_id}")
    asset_id = soar.get_asset_id()
    logger.info(f"current executing container's asset_id is: {asset_id}")
    logger.info(f"testing connectivity against {asset.base_url}")
    logger.debug("hello")
    logger.warning("this is a warning")
    logger.progress("this is a progress message")
    logger.info(f"secret_alias value is {asset.secret_alias}")
    assert asset.secret_alias == "example bearer"


class ActionOutputSummary(ActionOutput):
    is_success: bool


@app.action()
def test_summary_with_list_output(
    params: Params, asset: Asset, soar: SOARClient
) -> list[ActionOutput]:
    soar.set_summary(ActionOutputSummary(is_success=True))
    return [ActionOutput(), ActionOutput()]


@app.action()
def test_empty_list_output(
    params: Params, asset: Asset, soar: SOARClient
) -> list[ActionOutput]:
    return []


class JsonOutput(ActionOutput):
    name: str = OutputField(example_values=["John", "Jane", "Jim"], column_name="Name")
    age: int = OutputField(example_values=[25, 30, 35], column_name="Age")


class TableParams(Params):
    company_name: str = Param(column_name="Company Name", default="Splunk")


@app.action(render_as="json")
def test_json_output(params: Params, asset: Asset, soar: SOARClient) -> JsonOutput:
    return JsonOutput(name="John", age=25)


@app.action(render_as="table")
def test_table_output(
    params: TableParams, asset: Asset, soar: SOARClient
) -> JsonOutput:
    return JsonOutput(name="John", age=25)


from .actions.reverse_string import render_reverse_string_view

app.register_action(
    "actions.reverse_string:reverse_string",
    action_type="investigate",
    read_only=True,
    verbose="Reverses a string.",
    view_template="reverse_string.html",
    view_handler=render_reverse_string_view,
)


app.register_action(
    "actions.permissive_action:permissive_reverse_string",
    action_type="investigate",
    verbose="Reverses a string but doesn't care if it gets all its output fields.",
    view_template="reverse_string.html",
    view_handler=render_reverse_string_view,
)

from .actions.generate_category import render_statistics_chart

app.register_action(
    "actions.generate_category:generate_statistics",
    action_type="investigate",
    verbose="Generate statistics with pie chart reusable component.",
    view_handler=render_statistics_chart,
)


class MakeRequestParamsCustom(MakeRequestParams):
    endpoint: str = Param(
        description="The endpoint to send the request to. Base url is already included in the endpoint.",
        required=True,
    )


@app.make_request()
def http_action(params: MakeRequestParamsCustom, asset: Asset) -> MakeRequestOutput:
    logger.info(f"HTTP action triggered with params: {params}")
    return MakeRequestOutput(
        status_code=200,
        response_body=f"Base url is {asset.base_url}",
    )


@app.on_poll()
def on_poll(
    params: OnPollParams, soar: SOARClient, asset: Asset
) -> Iterator[Container | Artifact]:
    if params.is_manual_poll():
        logger.info("Manual poll (poll now) detected")
    else:
        logger.info("Scheduled poll detected")

    # Create container first for artifacts
    yield Container(
        name="Network Alerts",
        description="Some network-related alerts",
        severity="medium",
    )

    # Simulate collecting 2 network artifacts that will be put in the network alerts container
    for i in range(1, 3):
        logger.info(f"Processing network artifact {i}")

        alert_id = f"testalert-{datetime.now(UTC).strftime('%Y%m%d')}-{i}"
        artifact = Artifact(
            name=f"Network Alert {i}",
            label="alert",
            severity="medium",
            source_data_identifier=alert_id,
            type="network",
            description=f"Example network alert {i} from polling operation",
            data={
                "alert_id": alert_id,
                "source_ip": f"10.0.0.{i}",
                "destination_ip": "192.168.0.1",
                "protocol": "TCP",
            },
        )

        yield artifact


@app.on_es_poll()
def on_es_poll(
    params: OnESPollParams, soar: SOARClient, asset: Asset
) -> Generator[Finding, int | None]:
    for i, email_data in enumerate(SAMPLE_EMAILS, start=1):
        logger.info(f"Processing test finding {i}")

        date_str = datetime.now(UTC).strftime("%a, %d %b %Y %H:%M:%S +0000")
        raw_eml = (
            f"From: {email_data['from']}\r\n"
            f"To: {email_data['to']}\r\n"
            f"Subject: {email_data['subject']}\r\n"
            f"Date: {date_str}\r\n"
            f"MIME-Version: 1.0\r\n"
            f"Content-Type: text/plain; charset=utf-8\r\n"
            f"\r\n"
            f"{email_data['body']}"
        )

        yield Finding(
            rule_title=f"Test Finding {i}: {email_data['subject']}",
            email=FindingEmail(
                headers={
                    "From": email_data["from"],
                    "To": email_data["to"],
                    "Subject": email_data["subject"],
                    "Date": date_str,
                    "Content-Type": "text/plain; charset=utf-8",
                },
                body=email_data["body"],
                urls=email_data["urls"],
            ),
            attachments=[
                FindingAttachment(
                    file_name=f"email_{i}.eml",
                    data=raw_eml.encode("utf-8"),
                    is_raw_email=True,
                ),
                FindingAttachment(
                    file_name=email_data["attachment_name"],
                    data=email_data["attachment_data"],
                    is_raw_email=False,
                ),
            ],
        )


app.register_action(
    "actions.async_action:async_process",
    action_type="investigate",
    verbose="Processes a message asynchronously with concurrent HTTP requests.",
)

app.register_action(
    "actions.async_action:sync_process",
    action_type="investigate",
    verbose="Processes a message synchronously with sequential HTTP requests.",
)


class GeneratorActionOutput(ActionOutput):
    iteration: int


class GeneratorActionSummary(ActionOutput):
    total_iterations: int


class StageVaultTmpFileParams(Params):
    file_name: str
    file_content: str


class StageVaultTmpFileOutput(ActionOutput):
    file_path: str


@app.action(summary_type=GeneratorActionSummary)
def generator_action(
    params: Params, soar: SOARClient[GeneratorActionSummary], asset: Asset
) -> Iterator[GeneratorActionOutput]:
    """Generates a sequence of numbers."""
    logger.info(f"Generator action triggered with params: {params}")
    for i in range(5):
        yield GeneratorActionOutput(iteration=i)
    soar.set_summary(GeneratorActionSummary(total_iterations=5))


@app.action()
def write_state(params: Params, soar: SOARClient, asset: Asset) -> ActionOutput:
    asset.cache_state.clear()
    assert asset.cache_state == {}
    asset.cache_state["value"] = "banana"
    return ActionOutput()


@app.action()
def read_state(params: Params, soar: SOARClient, asset: Asset) -> ActionOutput:
    assert asset.cache_state == {"value": "banana"}
    return ActionOutput()


class FilesystemStateOutput(ActionOutput):
    state_file_path: str
    raw_state_json: str


def _asset_state_file_path(soar: SOARClient, asset: Asset) -> Path:
    return Path(asset.cache_state.backend.get_state_dir()) / (
        f"{soar.get_asset_id()}_state.json"
    )


@app.action(read_only=False)
def write_filesystem_state(
    params: Params, soar: SOARClient, asset: Asset
) -> ActionOutput:
    asset.auth_state.put_all({"auth_marker": AUTH_FILESYSTEM_MARKER})
    asset.cache_state.put_all({"cache_marker": CACHE_FILESYSTEM_MARKER})
    asset.ingest_state.put_all({"ingest_marker": INGEST_FILESYSTEM_MARKER})
    return ActionOutput()


@app.action()
def read_filesystem_state(
    params: Params, soar: SOARClient, asset: Asset
) -> FilesystemStateOutput:
    state_file_path = _asset_state_file_path(soar, asset)
    return FilesystemStateOutput(
        state_file_path=str(state_file_path),
        raw_state_json=state_file_path.read_text(encoding="utf-8"),
    )


@app.action(read_only=False)
def stage_vault_tmp_file(
    params: StageVaultTmpFileParams, soar: SOARClient, asset: Asset
) -> StageVaultTmpFileOutput:
    vault_tmp_dir = Path(soar.vault.get_vault_tmp_dir())
    file_path = vault_tmp_dir / Path(params.file_name).name
    file_path.write_text(params.file_content, encoding="utf-8")
    return StageVaultTmpFileOutput(file_path=str(file_path))


if __name__ == "__main__":
    app.cli()

Components of the app.py File

Let’s dive deeper into each part of the app.py file above:

Logger Initialization

Logger initialization

from soar_sdk.logging import getLogger
from soar_sdk.models.artifact import Artifact
from soar_sdk.models.container import Container
from soar_sdk.models.finding import Finding, FindingAttachment, FindingEmail
from soar_sdk.params import (
    MakeRequestParams,
    OnESPollParams,
    OnPollParams,
    Param,
    Params,
)

logger = getLogger()

The SDK provides a logging interface via the getLogger() function. This is a standard Python logger which is pre-configured to work with either the local CLI or the Splunk SOAR platform. Within the platform,

• logger.debug() and logger.warning() messages are written to the spawn.log file at DEBUG level.

• logger.error() and logger.critical() messages are written to the spawn.log file at ERROR level.

• logger.info() messages are sent to the Splunk SOAR platform as persistent action progress messages, visible in the UI.

• logger.progress() messages are sent to the Splunk SOAR platform as transient action progress messages, visible in the UI, but overwritten by subsequent progress messages.

When running locally via the CLI, all log messages are printed to the console, in colors corresponding to their log level.

Asset Definition

Asset definition

class Asset(BaseAsset):
    base_url: str = AssetField(default="https://example")
    api_key: str = AssetField(sensitive=True, description="API key for authentication")
    secret_alias: str = AssetField(
        sensitive=True,
        alias="bearer_token",
        description="Secret asset param with an alias",
    )
    key_header: str = AssetField(
        default="Authorization",
        value_list=["Authorization", "X-API-Key"],
        description="Header for API key authentication",
    )
    timezone: ZoneInfo
    timezone_with_default: ZoneInfo = AssetField(
        default=ZoneInfo("America/Denver"), category=FieldCategory.ACTION
    )

Apps should define an asset class to hold configuration information for the app. The asset class should be a pydantic model that inherits from BaseAsset and defines the app’s configuration fields. Fields requiring metadata should be defined using an instance of AssetField(). The SDK uses this information to generate the asset configuration form in the Splunk SOAR platform UI.

App Initialization

App initialization

app = App(
    asset_cls=Asset,
    name="example_app",
    appid=APP_ID,
    app_type="sandbox",
    product_vendor="Splunk Inc.",
    logo="logo.svg",
    logo_dark="logo_dark.svg",
    product_name="Example App",
    publisher="Splunk Inc.",
    min_phantom_version="6.2.2.134",
)

This is how you initialize the basic App instance. The app object will be used to register actions, views, and/or webhooks. Keep in mind this object variable and its path are referenced by pyproject.toml so the Splunk SOAR platform knows where the app instance is provided.

Action Definitions

Actions are defined as standalone functions, with a few important rules and recommendations.

Action Metadata

Action definition carry with them important metadata which is used by the Splunk SOAR platform to present the action in the UI, and to generate the app’s manifest. Often, this metadata can be derived automatically from the action function’s signature:

• The action’s “identifier” is, by default, the name of the action function (e.g. my_action).

• The action’s “name” is, by default, the action function’s name with spaces instead of underscores (e.g. my action).

• The action’s “description” is, by default, the action function’s docstring.

• The action’s “type” is, by default, generic unless the action is one of the reserved names like test connectivity or on poll.

Note

By convention, action names should be lowercase, with 2-3 words. Keep action names short but descriptive, and avoid using the name of the app or external service in action names. Where feasible, it’s recommended to consider reusing action names across different apps (e.g. get email) to provide a more consistent user experience.

Action Arguments

There is a magic element, similar to pytest fixtures, in the action arguments. The type hints for the argument definitions of an action function are critical to this mechanism. The rules are as follows:

• The first positional argument of an action function must be the params argument, and its type hint must be a Pydantic model inheriting from Params. The position and type of this argument are required. The name params is a convention, but not strictly required.

• If an action function has any argument named soar, at runtime the SDK will provide an instance of a SOARClient implementation as that argument, which is already authenticated with Splunk SOAR. The type hint for this argument should be SOARClient.

• If an action function has any argument named asset, at runtime the SDK will provide an instance of the app’s asset class, populated with the asset configuration for the current action run. The type hint for this argument should be the app’s asset class.

Note

The special actions which define their own decorators have stricter rules about the type of the params argument. For example, the on poll action must take an OnPollParams instance as its params argument, and test connectivity must take no params argument at all.

Action Returns

An action’s return type annotation is critical for the Splunk SOAR platform to understand, via datapaths, what an action’s output looks like. In practice, this means that you must define a class inheriting from ActionOutput to represent the action’s output, and then return an instance of that class from your action function:

from soar_sdk.action_results import ActionOutput

class MyActionOutput(ActionOutput):
    field1: str
    field2: int

@app.action()
def my_action(params: MyActionParams) -> MyActionOutput:
    # action logic here
    return MyActionOutput(field1="value", field2=42)

Advanced Return Types

For more advanced use cases, an action’s return type can be a list, Iterator, or AsyncGenerator that yields multiple ActionOutput objects:

list

@app.action()
def my_action_list(params: MyActionParams) -> list[MyActionOutput]:
    # action logic here
    return [
        MyActionOutput(field1="value1", field2=1),
        MyActionOutput(field1="value2", field2=2)
    ]

Iterator

from typing import Iterator

@app.action()
def my_action_iterator(params: MyActionParams) -> Iterator[MyActionOutput]:
    # action logic here
    yield MyActionOutput(field1="value1", field2=1)
    yield MyActionOutput(field1="value2", field2=2)

AsyncGenerator

from typing import AsyncGenerator

@app.action()
async def my_action_async_generator(
    params: MyActionParams,
    asset: Asset,
) -> AsyncGenerator[MyActionOutput]:
    async with client = httpx.AsyncClient() as client:
        async for i in range(10):
            response = await client.get(
                f"{asset.base_url}/data",
                params={"page": i}
            )
            yield MyActionOutput(**response.json())

test connectivity Action

Test connectivity action definition

@app.test_connectivity()
def test_connectivity(soar: SOARClient, asset: Asset) -> None:
    soar.get("rest/version")
    container_id = soar.get_executing_container_id()
    logger.info(f"current executing container's container_id is: {container_id}")
    asset_id = soar.get_asset_id()
    logger.info(f"current executing container's asset_id is: {asset_id}")
    logger.info(f"testing connectivity against {asset.base_url}")
    logger.debug("hello")
    logger.warning("this is a warning")
    logger.progress("this is a progress message")
    logger.info(f"secret_alias value is {asset.secret_alias}")
    assert asset.secret_alias == "example bearer"

All apps must register exactly one test connectivity action in order to be considered valid by Splunk SOAR. This action takes no parameters, and is used to verify that the app and its associated asset configuration are working correctly. Running test connectivity on the Splunk SOAR platform should answer the questions:

• Can the app connect to the external service?

• Can the app authenticate with the external service?

• Does the app have the necessary permissions to perform its actions?

A successful test connectivity action should return None, and a failure should raise an ActionFailure with a descriptive error message.

on poll Action

on poll action definition

@app.on_poll()
def on_poll(
    params: OnPollParams, soar: SOARClient, asset: Asset
) -> Iterator[Container | Artifact]:
    if params.is_manual_poll():
        logger.info("Manual poll (poll now) detected")
    else:
        logger.info("Scheduled poll detected")

    # Create container first for artifacts
    yield Container(
        name="Network Alerts",
        description="Some network-related alerts",
        severity="medium",
    )

    # Simulate collecting 2 network artifacts that will be put in the network alerts container
    for i in range(1, 3):
        logger.info(f"Processing network artifact {i}")

        alert_id = f"testalert-{datetime.now(UTC).strftime('%Y%m%d')}-{i}"
        artifact = Artifact(
            name=f"Network Alert {i}",
            label="alert",
            severity="medium",
            source_data_identifier=alert_id,
            type="network",
            description=f"Example network alert {i} from polling operation",
            data={
                "alert_id": alert_id,
                "source_ip": f"10.0.0.{i}",
                "destination_ip": "192.168.0.1",
                "protocol": "TCP",
            },
        )

        yield artifact

on poll is another special action that apps may choose to implement. This action always takes an OnPollParams instance as its parameter. If defined, this action will be called in order to ingest new data into the Splunk SOAR platform. The action should yield Container and/or Artifact instances representing the new data to be ingested. The SDK will handle actually creating the containers and artifacts in the platform.

Make Request Action

Make request action definition

@app.make_request()
def http_action(params: MakeRequestParamsCustom, asset: Asset) -> MakeRequestOutput:
    logger.info(f"HTTP action triggered with params: {params}")
    return MakeRequestOutput(
        status_code=200,
        response_body=f"Base url is {asset.base_url}",
    )

Apps may define a special “make request” action, which can be used to interact with the underlying external service’s REST API directly. Having this action available can be useful when there are parts of the REST API that don’t have dedicated actions implemented in the app.

We create an action by decorating a function with the app.action decorator. The default action_type is generic, so usually you will not have to provide this argument for the decorator. This is not the case for the test action type though, so we provide this type here explicitly.

Custom Actions

Actions can be registered one of two ways:

@app.action()

Using the action() decorator to decorate a standalone function.

decorated action definition

@app.action(summary_type=GeneratorActionSummary)
def generator_action(
    params: Params, soar: SOARClient[GeneratorActionSummary], asset: Asset
) -> Iterator[GeneratorActionOutput]:
    """Generates a sequence of numbers."""
    logger.info(f"Generator action triggered with params: {params}")
    for i in range(5):
        yield GeneratorActionOutput(iteration=i)
    soar.set_summary(GeneratorActionSummary(total_iterations=5))

app.register_action()

Using the register_action() method to register a function which may be defined in another module.

The two methods are functionally equivalent. The decorator method is often more convenient for simple actions, while the registration method may be preferable for larger apps where actions are defined in separate modules. Apps may use either or both methods to register their actions.

Action Synchronization

Use ActionLock when an action must coordinate with other action runs. For example, a read-modify-write operation can prevent overlapping executions for every asset that points to the same server:

from soar_sdk.meta.actions import ActionLock


@app.action(
    lock=ActionLock(
        data_path="configuration.server",
        timeout=600,
    )
)
def update_configuration(
    params: UpdateConfigurationParams,
    soar: SOARClient,
    asset: Asset,
) -> UpdateConfigurationOutput:
    ...

An ActionLock is always enabled and exclusive. The SDK emits enabled=true and concurrency=false in the app manifest, restricting each resolved lock name to one action run at a time. data_path may identify an action parameter, an asset configuration field, or a constant lock name. Actions that resolve to the same lock name are serialized. If data_path is omitted, Splunk SOAR uses the asset as the lock name. timeout limits how long the platform waits to acquire the lock.

The older enable_concurrency_lock=True argument is deprecated but remains supported for backward compatibility. Remove the argument to retain the platform’s default concurrency behavior. Use lock=ActionLock() only when exclusive action locking is required.

Note

soar-apps convert does not translate existing manifest lock metadata. Review synchronization requirements and add ActionLock explicitly after conversion when exclusive locking is required.

App CLI Invocation

App CLI invocation

if __name__ == "__main__":
    app.cli()

A generic invocation to the app’s cli() method, which enables running the app actions directly from command line. The app template created by soarapps init includes this snippet by default, and it is recommended to keep it in order to facilitate local testing and debugging of your app actions.