Oracle Resumable Suspended Session Guard with Kestra

id: oracle-resumable-space-suspended-session-guard
namespace: company.team

description: |
  Find Oracle sessions that RESUMABLE space allocation has frozen at
  dba_resumable.status = 'SUSPENDED' past a grace window, still holding their table and
  transaction locks with their transaction open, then either grow the tablespace they
  ran out of or end the frozen statement with DBMS_RESUMABLE.ABORT behind a dry-run gate
  plus a human approval, then read dba_resumable again and fail the run if any session
  is still suspended.

inputs:
  - id: jdbc_url
    type: STRING
    displayName: Oracle JDBC URL
    description: Point this at the PDB service, not the CDB root. dba_resumable is
      per container.
    defaults: "jdbc:oracle:thin:@//oracle-host:1521/FREEPDB1"

  - id: username
    type: STRING
    displayName: Database user
    description: A user that can read dba_resumable, v$session, v$lock,
      dba_data_files plus dba_tablespaces. It also needs EXECUTE on
      DBMS_RESUMABLE. SELECT_CATALOG_ROLE covers the reads. The abort and the
      datafile resize both need DBA.
    defaults: SYSTEM

  - id: password
    type: STRING
    displayName: Database password
    description: Defaults to the ORACLE_PASSWORD secret. Override per run for local
      testing only.
    defaults: "{{ secret('ORACLE_PASSWORD') }}"

  - id: grace_minutes
    type: INT
    displayName: Grace window in minutes
    description: How long a statement may sit SUSPENDED before it counts as a
      finding. A short space pause that an autoextend clears on its own is
      normal, so this window is what separates it from a session that is never
      coming back.
    defaults: 10

  - id: remediation
    type: SELECT
    displayName: What to do about a frozen session
    description: >-
      abort_session ends the suspended statement with DBMS_RESUMABLE.ABORT,
      which rolls its transaction back and releases every lock it holds.
      add_space resizes the first datafile of the tablespace the statement ran
      out of, which lets the statement carry on where it stopped.
    values:
      - abort_session
      - add_space
    defaults: abort_session

  - id: add_space_mb
    type: INT
    displayName: Megabytes to add
    description: Used by add_space only. Added to the current size of the
      lowest-numbered datafile in the tablespace named in the space error.
    defaults: 256

  - id: excluded_resumable_names
    type: ARRAY
    itemType: STRING
    displayName: Resumable statement names never touched
    description: >-
      Exact dba_resumable.name values this flow must leave alone, for a long
      load that is meant to wait for a DBA. The default is a sentinel that
      matches nothing, because Oracle reads an empty string as NULL so an empty
      list would exclude every row.
    defaults:
      - __NO_EXCLUSION__

  - id: verify_delay
    type: DURATION
    displayName: Settle before re-reading
    description: Oracle rechecks a suspended statement on a timer rather than the
      instant space appears, so give it this long before reading dba_resumable
      again.
    defaults: PT20S

  - id: auto_remediate
    type: BOOL
    displayName: Auto remediate
    description: Allow the abort or the datafile resize to run. Off by default.
    defaults: false

  - id: dry_run
    type: BOOL
    displayName: Dry run
    description: Must be false, together with auto_remediate, before anything is changed.
    defaults: true

variables:
  detect_sql: |
    SELECT x.*, TO_CHAR(x.suspended_minutes) AS suspended_minutes_text
      FROM (
        SELECT TO_CHAR(r.session_id) AS session_id_text,
               NVL(u.username, TO_CHAR(r.user_id)) AS db_user,
               NVL(r.name, '(unnamed)') AS resumable_name,
               r.status AS resumable_status,
               TO_CHAR(r.error_number) AS error_number_text,
               r.suspend_time AS suspend_time,
               NVL(r.error_parameter1, '(none)') AS space_object,
               NVL(t.tablespace_name, '(no growable tablespace)') AS growable_tablespace,
               NVL(s.program, '(unknown)') AS client_program,
               TO_CHAR((SELECT COUNT(*) FROM v$session b WHERE b.blocking_session = r.session_id)) AS blocked_sessions_text,
               TO_CHAR((SELECT COUNT(*) FROM v$lock k WHERE k.sid = r.session_id AND k.type IN ('TM', 'TX'))) AS held_locks_text,
               'DECLARE v_cnt NUMBER; BEGIN SELECT COUNT(*) INTO v_cnt FROM dba_resumable WHERE session_id = '
                 || TO_CHAR(r.session_id)
                 || ' AND status = ''SUSPENDED'' AND NVL(name, ''(unnamed)'') = '''
                 || REPLACE(NVL(r.name, '(unnamed)'), '''', '''''')
                 || '''; IF v_cnt = 1 THEN DBMS_RESUMABLE.ABORT('
                 || TO_CHAR(NVL(r.coord_session_id, r.session_id))
                 || '); END IF; END;' AS abort_sql,
               (SELECT 'ALTER DATABASE DATAFILE ''' || f.file_name || ''' RESIZE '
                         || TO_CHAR(CEIL(f.bytes / 1048576) + {{ inputs.add_space_mb }}) || 'M'
                  FROM dba_data_files f
                 WHERE f.tablespace_name = t.tablespace_name
                   AND f.file_id = (SELECT MIN(f2.file_id) FROM dba_data_files f2
                                     WHERE f2.tablespace_name = t.tablespace_name)) AS grow_sql,
               CASE WHEN VALIDATE_CONVERSION(r.suspend_time AS DATE, 'MM/DD/YY HH24:MI:SS') = 1
                    THEN ROUND((SYSDATE - TO_DATE(r.suspend_time, 'MM/DD/YY HH24:MI:SS')) * 1440, 1)
                    ELSE ROUND(NVL(s.last_call_et, 0) / 60, 1) END AS suspended_minutes,
               r.error_msg AS error_msg
          FROM dba_resumable r
          LEFT JOIN v$session s ON s.sid = r.session_id
          LEFT JOIN dba_users u ON u.user_id = r.user_id
          LEFT JOIN dba_tablespaces t ON t.tablespace_name = r.error_parameter1
         WHERE r.status = 'SUSPENDED'
           AND NVL(r.name, '(unnamed)') NOT IN ('{{ inputs.excluded_resumable_names | join("','") }}')
      ) x
     WHERE x.suspended_minutes >= {{ inputs.grace_minutes }}
     ORDER BY x.suspended_minutes DESC

  reverify_sql: |
    SELECT TO_CHAR(r.session_id) AS session_id_text,
           r.status AS resumable_status,
           NVL(r.name, '(unnamed)') AS resumable_name,
           TO_CHAR(r.error_number) AS error_number_text,
           r.suspend_time AS suspend_time,
           r.error_msg AS error_msg
      FROM dba_resumable r
     WHERE r.status = 'SUSPENDED'
       AND r.session_id IN ({{ outputs.collect.values.sids }})
     ORDER BY r.session_id

tasks:
  - id: detect
    type: io.kestra.plugin.jdbc.oracle.Query
    description: Read-only. Every dba_resumable row still SUSPENDED past the grace
      window, with the user, the space error, the tablespace it ran out of, how
      many TM or TX locks it is holding and how many other sessions it is
      blocking.
    url: "{{ inputs.jdbc_url }}"
    username: "{{ inputs.username }}"
    password: "{{ inputs.password }}"
    fetchType: FETCH
    sql: "{{ render(vars.detect_sql) }}"

  - id: collect
    type: io.kestra.plugin.core.output.OutputValues
    description: The session id list for the re-read, plus the deduplicated
      statements each remediation mode would run.
    values:
      sids: "{{ outputs.detect.size > 0 ? (outputs.detect.rows |
        jq('map(.SESSION_ID_TEXT) | unique | join(\",\")') | first) : '-1' }}"
      abort_sql: "{{ outputs.detect.rows | jq('map(.ABORT_SQL) | unique') | first |
        toJson }}"
      grow_sql: "{{ outputs.detect.rows | jq('map(.GROW_SQL) | map(select(. != null))
        | unique') | first | toJson }}"

  - id: summary
    type: io.kestra.plugin.core.log.Log
    message: >-
      Oracle resumable check on {{ inputs.jdbc_url }}: {{ outputs.detect.size }}
      session(s) SUSPENDED for at least {{ inputs.grace_minutes }} minute(s). {{
      outputs.detect.rows | jq('map(.DB_USER + " sid " + .SESSION_ID_TEXT + " ["
      + .RESUMABLE_NAME + "] ORA-" + .ERROR_NUMBER_TEXT + " on " + .SPACE_OBJECT
      + ", suspended " + .SUSPENDED_MINUTES_TEXT + " min, holding " +
      .HELD_LOCKS_TEXT + " lock(s), blocking " + .BLOCKED_SESSIONS_TEXT + "
      session(s)") | join(" | ")') | first }}

  - id: route
    type: io.kestra.plugin.core.flow.If
    condition: "{{ outputs.detect.size > 0 }}"
    then:
      - id: alert
        type: io.kestra.plugin.slack.notifications.SlackIncomingWebhook
        description: A suspended statement raises no error anywhere, so this is the only
          notice anybody gets.
        url: "{{ secret('SLACK_WEBHOOK_URL') }}"
        payload: |
          {{ {'text': 'Oracle ' ~ inputs.jdbc_url ~ ': ' ~ outputs.detect.size ~ ' resumable session(s) SUSPENDED past ' ~ inputs.grace_minutes ~ ' min, holding locks. ' ~ (outputs.detect.rows | jq('map(.DB_USER + " sid " + .SESSION_ID_TEXT + " ORA-" + .ERROR_NUMBER_TEXT + " on " + .SPACE_OBJECT + " for " + .SUSPENDED_MINUTES_TEXT + " min, blocking " + .BLOCKED_SESSIONS_TEXT) | join("; ")') | first) ~ '. ' ~ (inputs.auto_remediate and not inputs.dry_run ? ('Remediation ' ~ inputs.remediation ~ ' is waiting for approval.') : ('No change applied (auto_remediate=' ~ inputs.auto_remediate ~ ', dry_run=' ~ inputs.dry_run ~ ').'))} | toJson }}

      - id: remediate_gate
        type: io.kestra.plugin.core.flow.If
        condition: "{{ inputs.auto_remediate and not inputs.dry_run }}"
        then:
          - id: approve
            type: io.kestra.plugin.core.flow.Pause
            description: >-
              Read the session list in summary before answering. abort_session
              rolls the suspended transaction back, so every row the statement
              had already written is lost and the application sees its load
              fail. Abort the wrong session and you have killed a job that only
              needed a bigger datafile. add_space writes to a datafile and
              cannot be undone by resizing back down if the file has grown into
              the new space. Resume with approved=true to act on exactly the
              sessions listed. Resume with no answer or kill the execution to
              leave them alone.
            onResume:
              - id: approved
                type: BOOL
                displayName: Approve the listed remediation on exactly these suspended sessions
                required: false

          - id: do_remediate
            type: io.kestra.plugin.core.flow.If
            condition: "{{ outputs.approve.onResume.approved ?? false }}"
            then:
              - id: pick_mode
                type: io.kestra.plugin.core.flow.Switch
                value: "{{ inputs.remediation }}"
                cases:
                  abort_session:
                    - id: remediate_abort
                      type: io.kestra.plugin.core.flow.Loop
                      description: Remediation loop. One guarded DBMS_RESUMABLE.ABORT per suspended
                        session, concurrencyLimit 1 so two aborts never race on
                        the same dictionary row.
                      concurrencyLimit: 1
                      values: "{{ outputs.collect.values.abort_sql }}"
                      tasks:
                        - id: abort_one
                          type: io.kestra.plugin.jdbc.oracle.Query
                          description: >-
                            The block re-reads dba_resumable and aborts only if
                            that session id is still SUSPENDED under the same
                            statement name, so a session that freed itself
                            between the detect and now is left running.
                            allowFailure, because the re-read is the gate, not
                            this task.
                          allowFailure: true
                          url: "{{ inputs.jdbc_url }}"
                          username: "{{ inputs.username }}"
                          password: "{{ inputs.password }}"
                          fetchType: NONE
                          sql: "{{ item.value }}"
                  add_space:
                    - id: grow_route
                      type: io.kestra.plugin.core.flow.If
                      condition: "{{ fromJson(outputs.collect.values.grow_sql) | length > 0 }}"
                      then:
                        - id: remediate_grow
                          type: io.kestra.plugin.core.flow.Loop
                          description: Remediation loop. One datafile RESIZE per tablespace named in a
                            space error, concurrencyLimit 1 so two resizes never
                            touch the same file at once.
                          concurrencyLimit: 1
                          values: "{{ outputs.collect.values.grow_sql }}"
                          tasks:
                            - id: grow_one
                              type: io.kestra.plugin.jdbc.oracle.Query
                              description: ALTER DATABASE DATAFILE RESIZE for one tablespace. allowFailure,
                                because a file that cannot grow must still reach
                                the re-read.
                              allowFailure: true
                              url: "{{ inputs.jdbc_url }}"
                              username: "{{ inputs.username }}"
                              password: "{{ inputs.password }}"
                              fetchType: NONE
                              sql: "{{ item.value }}"
                      else:
                        - id: nothing_to_grow
                          type: io.kestra.plugin.core.log.Log
                          level: WARN
                          message: "None of the suspended sessions named a tablespace that has a datafile
                            to resize, so add_space has nothing to run. Undo
                            quota and temp errors are the usual reason. The
                            re-read below is still the gate."
                defaults:
                  - id: unknown_mode
                    type: io.kestra.plugin.core.execution.Fail
                    errorMessage: "remediation '{{ inputs.remediation }}' is not a mode this flow
                      implements. Use abort_session or add_space."

              - id: settle
                type: io.kestra.plugin.core.flow.Sleep
                description: Oracle rechecks a suspended statement on its own timer, so an
                  add_space that worked still needs a moment before
                  dba_resumable catches up.
                duration: "{{ inputs.verify_delay }}"

              - id: reverify
                type: io.kestra.plugin.jdbc.oracle.Query
                description: Read dba_resumable again for exactly the session ids that were
                  found suspended.
                url: "{{ inputs.jdbc_url }}"
                username: "{{ inputs.username }}"
                password: "{{ inputs.password }}"
                fetchType: FETCH
                sql: "{{ render(vars.reverify_sql) }}"

              - id: verify_result
                type: io.kestra.plugin.core.flow.If
                condition: "{{ outputs.reverify.size > 0 }}"
                then:
                  - id: still_suspended
                    type: io.kestra.plugin.core.execution.Fail
                    errorMessage: >-
                      {{ outputs.reverify.size }} of {{ outputs.detect.size }}
                      session(s) are still SUSPENDED after {{ inputs.remediation
                      }}: {{ outputs.reverify.rows | jq('map("sid " +
                      .SESSION_ID_TEXT + " [" + .RESUMABLE_NAME + "] ORA-" +
                      .ERROR_NUMBER_TEXT) | join(", ")') | first }}. The locks
                      are still held. A resize can be refused by the filesystem
                      or by the 32 GB smallfile datafile ceiling. An abort is
                      refused when the user lacks EXECUTE on DBMS_RESUMABLE.
                else:
                  - id: cleared
                    type: io.kestra.plugin.core.log.Log
                    message: "Cleared by {{ inputs.remediation }}: {{ outputs.detect.size }}
                      suspended session(s) before, {{ outputs.reverify.size }}
                      after. Statements run: {{ inputs.remediation ==
                      'abort_session' ?
                      (fromJson(outputs.collect.values.abort_sql) | length) :
                      (fromJson(outputs.collect.values.grow_sql) | length) }}."
            else:
              - id: not_approved
                type: io.kestra.plugin.core.log.Log
                message: "Approval not given, so nothing was aborted or resized. {{
                  outputs.detect.size }} session(s) are still SUSPENDED and
                  still holding their locks."
    else:
      - id: clean
        type: io.kestra.plugin.core.log.Log
        message: "No resumable statement has been SUSPENDED for {{ inputs.grace_minutes
          }} minute(s) or more. Nothing frozen."

errors:
  - id: alert_flow_failure
    type: io.kestra.plugin.slack.notifications.SlackIncomingWebhook
    url: "{{ secret('SLACK_WEBHOOK_URL') }}"
    payload: |
      {{ {'text': 'Oracle resumable suspended session guard failed on ' ~ inputs.jdbc_url ~ ' (execution ' ~ execution.id ~ '). A session may still be suspended and holding locks. Check the logs.'} | toJson }}

triggers:
  - id: every_15_minutes
    type: io.kestra.plugin.core.trigger.Schedule
    description: Shipped disabled and always in safe mode (report only).
    cron: "*/15 * * * *"
    disabled: true
    inputs:
      auto_remediate: false
      dry_run: true

Turn on RESUMABLE space allocation and an Oracle statement that runs out of space stops raising ORA-01653. It suspends instead. The session keeps its transaction open, keeps every table and row lock it has taken. Then it waits. Nothing fails, so nothing reaches error monitoring. Meanwhile every session that wants one of those locks queues behind a session whose wait event is "statement suspended, wait error to be cleared". The only place the cause is written down is dba_resumable.

This blueprint reads that view. It reports the sessions that have been SUSPENDED longer than a grace window you set, with the space error, the tablespace, how many locks each one is holding and how many sessions it is blocking. Then it either grows the tablespace so the statement carries on. Or it ends the statement with DBMS_RESUMABLE.ABORT so the locks are released, behind a dry-run gate plus a human approval. After either one it reads dba_resumable again and fails the run if a session is still suspended.

This blueprint was created by zkasuran.

Findings

What is read	Column	Why it matters
The frozen statement	`dba_resumable.status = 'SUSPENDED'`	The only record that the statement is waiting rather than failing
How long	`dba_resumable.suspend_time`	A `VARCHAR2` holding `MM/DD/YY HH24:MI:SS`, parsed to get the age
Which space ran out	`dba_resumable.error_number` plus `error_parameter1`	ORA-01653 carries the tablespace name in parameter 1
What it is holding	`v$lock` TM and TX rows for that sid	A suspended session holds its locks for as long as it waits
Who is stuck behind it	`v$session.blocking_session`	The damage the suspension is doing right now

suspend_time is a string, so it is parsed with VALIDATE_CONVERSION first and the flow falls back to v$session.last_call_et on any instance whose format differs. A parallel operation is aborted through coord_session_id where one is set, because DBMS_RESUMABLE.ABORT takes the coordinator.

Safety

An abort is not a cancel. It rolls the suspended transaction back, so everything the statement had written is gone. The application gets its error at that moment instead of hours later. Abort a session that only needed another datafile. You destroyed a load that would have finished on its own. Four things keep that from happening by accident.

auto_remediate is false and dry_run is true by default, so a scheduled run reads the dictionary and tells you. Both have to be flipped before anything runs.
grace_minutes decides what counts as frozen. A statement that pauses for a few seconds while an autoextend fires is normal, so the default 10 minutes keeps it out of the findings.
A Pause holds the run. The task description spells out what an abort costs, the session list is already in the log. An unanswered resume reads as refusal because the gate is approved ?? false.
Every abort is guarded in the database. The statement the flow runs re-reads dba_resumable inside its own block and calls ABORT only if that session id is still SUSPENDED under the same statement name. A session that freed itself in the gap between the check and the approval is left running.

excluded_resumable_names is there for the load that is meant to wait. Name it in the list and it never shows up as a finding.

How it works

detect (io.kestra.plugin.jdbc.oracle.Query, read-only) joins dba_resumable to v$session, dba_users plus dba_tablespaces, keeps the rows whose status is SUSPENDED past grace_minutes, counts the TM and TX locks each session holds and the sessions it blocks. It builds both candidate fix statements per row.
collect (io.kestra.plugin.core.output.OutputValues) deduplicates those statements and keeps the session id list for the re-read. summary (io.kestra.plugin.core.log.Log) logs one line per frozen session.
route (io.kestra.plugin.core.flow.If):
- clean: nothing has been suspended past the window, so it logs and stops.
- findings: alert posts the list to Slack, because a suspended statement raises no error for anything else to pick up.
  - remediate_gate runs only when auto_remediate is true and dry_run false.
  - approve (io.kestra.plugin.core.flow.Pause) waits for a resume carrying approved.
  - pick_mode (io.kestra.plugin.core.flow.Switch) picks the branch. abort_session runs the guarded DBMS_RESUMABLE.ABORT block once per session in a Loop at concurrencyLimit: 1. add_space resizes the first datafile of each named tablespace the same way. It logs a warning instead when the space error names no growable tablespace.
  - settle (io.kestra.plugin.core.flow.Sleep) waits, because Oracle rechecks a suspended statement on a timer.
  - reverify reads dba_resumable again for those session ids. verify_result fails the run through still_suspended if any of them is still SUSPENDED, otherwise cleared logs the before and after counts.
errors posts to Slack on any failure, including a session that survived the remediation.

What you get

A name for an outage that normally has none. Sessions pile up on locks, the application times out, nothing is in the alert log, because the session at the head of the queue is suspended rather than failed.
Two fixes for the same state, picked per run. Grow the tablespace when the load deserves to finish, abort when the locks matter more than the load.
A default posture that only reads. The write needs auto_remediate, a false dry_run plus a human answering the pause.
An abort that checks the session is still suspended at the moment it fires, inside the database, not in the orchestrator.
Proof the frozen session is gone: a re-read of dba_resumable that fails the run when one survives.

Who it's for

DBAs and platform teams running Oracle with RESUMABLE enabled, usually turned on for overnight loads so a full tablespace pauses the job instead of killing it. The pause is the feature. A pause nobody notices, holding locks until the DBA logs in, is the problem this closes.

Why orchestrate this with Kestra

Detecting it needs a dictionary read. Fixing it needs DDL or a package call, a chosen strategy, a human in the loop for something that destroys work. Then a second read to prove it worked. A cron job that calls DBMS_RESUMABLE.ABORT has no gate, no approval record plus no verification, which on a statement this destructive is the wrong tool. Kestra holds the run at a Pause, keeps the input values and the log of what was found next to the approval, then fails loudly when the dictionary disagrees with the remediation.

Tested end to end

Run against Oracle Database 23ai Free, Kestra 2.0.5, with a 8 MB tablespace with AUTOEXTEND OFF and a session that ran ALTER SESSION ENABLE RESUMABLE TIMEOUT 7200 before a bulk insert that overran it.

Path	Result
Healthy instance, no suspended session	0 findings, `clean`
Real ORA-01653 suspension, 0 minute grace	1 finding, holding 3 locks, blocking 1 session
`dry_run=true`, `auto_remediate=false`	reported, dictionary unchanged
`add_space`, approved	datafile 8 MB to 136 MB, statement resumed, 0 suspended
`abort_session`, approved	session aborted, locks released, 0 suspended
Pause resumed with no answer	nothing changed, session still suspended
Tablespace offline before the re-read	`still_suspended` failed the run

Every before and after was read back with sqlplus against dba_resumable, v$lock plus v$session, not from the Kestra log.

Prerequisites

Secrets

Secret	Used for
`ORACLE_PASSWORD`	Default for the `password` input
`SLACK_WEBHOOK_URL`	The findings alert plus the `errors` alert

Inputs

Input	Type	Default	What it does
`jdbc_url`	STRING	`jdbc:oracle:thin:@//oracle-host:1521/FREEPDB1`	The PDB service, not the CDB root
`username`	STRING	`SYSTEM`	Reads the dictionary, runs the abort or the resize
`password`	STRING	`{{ secret('ORACLE_PASSWORD') }}`	Database password
`grace_minutes`	INT	`10`	How long SUSPENDED counts as frozen
`remediation`	SELECT	`abort_session`	`abort_session` or `add_space`
`add_space_mb`	INT	`256`	Megabytes added by `add_space`
`excluded_resumable_names`	ARRAY	`__NO_EXCLUSION__`	Statement names left alone
`verify_delay`	DURATION	`PT20S`	Settle time before the re-read
`auto_remediate`	BOOL	`false`	Allows a change
`dry_run`	BOOL	`true`	Must be false for a change

The reads need SELECT on dba_resumable, v$session, v$lock, dba_users, dba_tablespaces plus dba_data_files, which SELECT_CATALOG_ROLE grants. abort_session needs EXECUTE on DBMS_RESUMABLE, add_space needs ALTER DATABASE. Point jdbc_url at the PDB service: dba_resumable is per container, so a CDB root connection does not see a session suspended inside a PDB.

Quick start

Add the ORACLE_PASSWORD plus SLACK_WEBHOOK_URL secrets.
Set jdbc_url to your PDB service and username to a user with SELECT_CATALOG_ROLE.
Run it with the defaults. It only reads. The log names every session suspended past 10 minutes with the locks it holds.
To clear one, pick remediation, set auto_remediate=true plus dry_run=false, run it, read the session list in the log, then resume the pause with approved=true.
Enable the Schedule trigger once the report looks right. It is shipped disabled and forces report-only inputs.

How to extend

Raise grace_minutes to the length of your longest legitimate space pause so an autoextend that is simply slow never reads as frozen.
Swap the datafile RESIZE for ALTER TABLESPACE ... ADD DATAFILE where you prefer a new file over a bigger one. Use AUTOEXTEND ON MAXSIZE where the mount has room.
Add a branch on error_number so ORA-30036 on the undo tablespace and ORA-01536 on a quota take their own fix instead of falling through to the abort.
Write each finding to a KV pair keyed by session id to count how often the same job freezes, which turns a recurring suspension into a sizing decision.
Point the Slack alert at an incident tool so the sessions queued behind the lock get the same page a failed job would.

Oracle Resumable Space Suspended Session Guard

Findings

Safety

How it works

What you get

Who it's for

Why orchestrate this with Kestra

Tested end to end

Prerequisites

Secrets

Inputs

Quick start

How to extend

Links

Tasks

Orchestrate with Kestra

Share this Blueprint

Create a Blueprint

New to Kestra?

Oracle Resumable Space Suspended Session Guard

Findings

Safety

How it works

What you get

Who it's for

Why orchestrate this with Kestra

Tested end to end

Prerequisites

Secrets

Inputs

Quick start

How to extend

Links

Tasks

Orchestrate with Kestra

Share this Blueprint

Create a Blueprint

More Infrastructure Blueprints

OWASP DefectDojo Vulnerability SLA Escalation Sentinel

PostgreSQL Debezium CDC Backlog Sentinel

Verify an npm dependency upgrade against the project's own tests before it is merged

Org-Wide Dependency Vulnerability Triage with Approval and Expiring Waivers

Hold Production Deploys While a Freeze Window Is Active

DeploymentWatch - Kubernetes stuck rollout watcher

More Data Blueprints

Replicate PostgreSQL inserts, updates and deletes with Debezium CDC

Compact small files in a Delta Lake table and vacuum it safely

Dgraph Alpha Pending Proposals and Raft Stall Sentinel

Dbt Test Failure AI Root Cause and Remediation Advisor

Test debt covenants every quarter and draft the compliance certificate

Monitor MySQL DELETE events in real time with Debezium and send Slack alerts

New to Kestra?