Logging & Exit Codes

Two log streams per run, a color-coded console mirror, automatic numbered backups, and engine-notice routing that differs by platform. Everything a CI pipeline needs from a deploy tool.

By the SchemaSmith Team · Last reviewed

Logging and Exit Codes

Good logs are the difference between a quick diagnosis and a long night.

Framework

All CLI tools use Apache Log4Net. Each tool ships with an embedded Log4Net configuration that is loaded automatically at startup — there's nothing to configure.

Log Files

Each tool writes two log files per run. SchemaQuench writes a third, SchemaQuench - Failures.log, which stays empty unless a run has failures; see Failure triage roll-up. Every SchemaQuench run also writes a deployment summary report, by default to the same directory, as a matched pair, SchemaQuench - Summary.json and SchemaQuench - Summary.md, carrying the run's outcome, exit code, duration, per-target results, and verified object counts. Read the report format on your platform's SchemaQuench reference: SQL Server, PostgreSQL, MySQL, or MariaDB.

Tool Progress log Error log
SchemaQuench SchemaQuench - Progress.log SchemaQuench - Errors.log
SchemaTongs SchemaTongs - Progress.log SchemaTongs - Errors.log
DataTongs DataTongs - Progress.log DataTongs - Errors.log
SchemaShears SchemaShears - Progress.log SchemaShears - Errors.log

The progress log receives all informational output: the startup banner, active configuration, per-object progress, and completion status. Everything written to the progress log also appears on the console in real time.

The error log receives only error-level entries (such as a refused run, a lost connection or, on SQL Server, the engine's own errors) and does not echo to the console.

Which log carries the fault detail depends on the engine

Most of what reaches the errors log is the same on every engine. Each entry carries its full exception: a run refused before it starts (an unrecognized argument, a missing or unreadable settings file, a package that cannot load, a failed validation or product script, a version check, a refused target); a connection that could not be opened or that dropped mid-run; a database or schema discovery that failed, a Target filter rejection, or a folder ShouldApplyExpression that threw; an unhandled exception; and, with WriteDebugSql on, one line per failed script naming its error and its debug file. What differs is the engine's own error text for a failed statement:

SQL Server: every error the engine raises on the deploy connection — a failed script, a failed quench step — also lands in the errors log with its message and line number (at Line: N), as well as in the progress log. It's the fastest place to read what went wrong.

PostgreSQL, MySQL, and MariaDB: the engine's error text for a failed script or quench step is in the progress log and the failure roll-up, under Unable to quench '<path>': … or FAILED to quench:; on PostgreSQL it leads with the SQLSTATE. It reaches the errors log only through the WriteDebugSql line above. The SQL itself is never in either log.

Both the progress and error logs are overwritten at the start of each run. Previous runs are preserved through the backup rotation described below.

Console Output

The console is a live mirror of the progress log, not a separate channel. Watching the console while a quench runs lets you follow startup, per-object progress, and completion in real time without tailing a file. Log4Net colorizes the console stream by level so trouble catches your eye the moment it appears:

Level Console color
InformationalGreen
WarningYellow
ErrorRed

When a script fails, you see a short error summary on the console and in the progress log (red, so it's hard to miss): Unable to quench '<path>': <engine error>, along with a pointer to the resolved SQL — Resolved SQL written to: with WriteDebugSql on, or a Rerun with --WriteDebugSql hint with it off. That's enough to know what failed and where to look.

The SQL itself never goes to a log: with WriteDebugSql on it is in the debug file, and the error log gets one line per failed script naming the error and that file. The error log also carries, on every engine, the failures that stop a run before or outside a script — a refused argument or setting, a connection that could not be opened or was lost, a database or schema discovery that failed, a validation or version check — each with its full exception. On SQL Server it additionally receives every error the engine raises on the deploy connection with its line number (at Line: N), which the progress log does not carry. See Working a failed deployment to trace one end to end.

On multi-target runs the log stays greppable: every schema-template iteration prefixes its lines with [Schema: <name>], and a many-database fan-out uses [server].[database]. Filter the progress log to one prefix to isolate a single tenant's sequence end to end.

Tip

CI agents that capture stdout get the progress stream for free. If your pipeline step only saves stdout, you still have a readable transcript of successes and error summaries; archive the error log separately to keep each failure's full exception and, on SQL Server, the engine's line-numbered errors.

Log File Location

By default, logs are written to the tool's executable directory. Override this with --LogPath:

SchemaQuench --LogPath:C:\Logs
SchemaTongs --LogPath:C:\Logs\schemasmith
DataTongs --LogPath:D:\BuildLogs
schemaquench --LogPath:/var/log/schemasmith
schematongs --LogPath:/var/log/schemasmith
datatongs --LogPath:/var/log/buildlogs

Startup Configuration Dump

Immediately after loading configuration, every tool logs the resolved command-line switches followed by its complete active configuration to the progress log. This includes the tool name and version number, every switch passed on the command line, and every configuration key and its value (with sensitive values masked). This makes it straightforward to verify both the effective command line and the settings that were in effect for any given run.

Sensitive switches are scrubbed the same way configuration values are — a --Target__Password=... or --ConnectionString=... renders its value as *** while the switch name still prints, honoring the same LogHygiene rules.

Any value whose name matches the built-in sensitive-name set — Password, Pwd, Secret, ApiKey, Token, ConnectionString, Credential (case-insensitive, substring match) — is replaced with *** while its name still prints, so you can confirm the setting exists without exposing it. An embedded Password= / Pwd= inside a connection-string value is stripped even when the surrounding name isn't sensitive. A value shaped like scheme://user:secret@host/path also has its password replaced with ***, regardless of setting name. All other values are logged as-is — both exceptions match on value shape, not the name of the setting.

You can tune what gets scrubbed — add exact names or patterns, or opt a false positive back out — and suppress token logging entirely via the LogHygiene settings block. See Sensitive value masking in the configuration reference.

2026-03-06 09:14:01,234 - SchemaQuench
2026-03-06 09:14:01,235 - Version: 5.2.1.0
2026-03-06 09:14:01,236 - Command line:
2026-03-06 09:14:01,237 -   ConfigFile: production.json
2026-03-06 09:14:01,238 -   Target__Server: sql-prod-01
2026-03-06 09:14:01,239 -   Target__Password: ***
2026-03-06 09:14:01,240 - Configuration:
2026-03-06 09:14:01,241 -   Server: sql-prod-01
2026-03-06 09:14:01,242 -   User: schemasmith
2026-03-06 09:14:01,243 -   Password: ***
2026-03-06 09:14:01,244 -   VerboseLogging: false

Log Backup Rotation

When a tool finishes (whether successfully or after an error), it backs up its log files before the process exits:

  1. Determines the log directory (--LogPath value, or the executable directory if not specified).
  2. Creates a numbered subdirectory: <ToolName>.0001. If that directory already exists, it increments: .0002, .0003, and so on.
  3. Copies all files matching <ToolName> - *.log into the new subdirectory.

The base log files in the log directory are not deleted after backup. Each run overwrites the base files and writes a copy into a new numbered subdirectory. This preserves the history of every run while keeping the base files current with the latest.

Example after three SchemaQuench runs:

C:\Tools\
    SchemaQuench - Progress.log      (latest run)
    SchemaQuench - Errors.log        (latest run)
    SchemaQuench.0001\               (first run backup)
    SchemaQuench.0002\               (second run backup)
    SchemaQuench.0003\               (third run backup)

Failure triage roll-up

When a run finishes with one or more failures, SchemaQuench writes a third log alongside the progress and error logs — SchemaQuench - Failures.log — that answers which targets failed at a glance. A deployment fans out to many (server, database, schema) targets in parallel and shares one interleaved progress log; the roll-up pulls every failure back into one consolidated, phase-grouped list, so a single failure among many parallel targets isn't buried in one stream.

Each entry names the failed scope, along with the engine error, the resolved-SQL artifact path (or, with WriteDebugSql off, the hint to rerun with it), and a captured tail of the lines leading up to it. A scope is one of:

  • a tenant — [server].[database] [Schema: <name>]
  • a per-server Before / After product script — [server]
  • a product-level Validate phase

A loud *** FAILED banner also marks each failure live in the progress stream, so you can grep *** FAILED to jump straight to the failed scopes; the roll-up block echoes to the console at the end of the run.

Failed user scripts

A failed user script reads with the same detail as a mechanical failure. The Error: line carries the specific per-script error — Unable to quench '<path>': <error>, with a (+N more) tail when several scripts in the scope failed — and the Debug SQL: line points at that script's resolved-SQL artifact (with debug SQL off, it carries the rerun hint instead), so the roll-up sends you straight to the offending script and the SQL it produced. From there, working a failed deployment covers reading the artifact and reproducing the error.

FailureContextLines

The roll-up is always on and adds nothing to a clean run — no banner, no roll-up block, an empty Failures.log. FailureContextLines controls how many lines of lead-up context each failure captures. The default is 25; set it to 0 to disable context capture entirely, and the roll-up still lists the failed scopes and their errors.

schemaquench --FailureContextLines=40

Working a failed deployment

A failed quench leaves a log entry telling you what broke, and — with debug SQL on — a .sql artifact file holding the exact SQL that the server rejected. Here's how to move from "deployment failed" to "I know what's wrong and I can fix it."

  1. Find the artifact. Debug SQL is off by default, so the failure line in the progress log (SchemaQuench - Progress.log) first ends Rerun with --WriteDebugSql to write the resolved SQL of this step to <ArtifactPath>. Re-run with --WriteDebugSql (or WriteDebugSql: true in the settings file), then search the log for Resolved SQL written to:. Every script surface — user and migration scripts, generated quench DDL (table, index, foreign-key, view, and table-JSON steps), product-level Before/After scripts, validation scripts, and data-delivery merges — reports its failure the same way, so one search string finds every kind of failure in the log.
    Unable to quench 'Before/01-seed.sql': Invalid column name 'Region'.
        Resolved SQL written to: C:\logs\SchemaQuench - Failed 01-seed prod.App.sql
    Artifacts land in the ArtifactPath directory (default: the working directory you ran SchemaQuench from), not the log directory — deliberately, so zipping your logs for a support ticket doesn't sweep up raw SQL that may contain expanded sensitive values.
  2. Open and read it. The artifact is a plain .sql file. It opens with two comment lines, one naming the product, server, database, schema and the run that wrote it, and one saying it holds real values; then comes every batch the engine received, separated by GO. The batch SchemaQuench attempted last is marked:
    -- >>> FAILING BATCH (#2) >>>
    ALTER TABLE [dbo].[Orders] ADD [Region] NVARCHAR(50) NOT NULL ...
    GO
    The marker is a best-effort hint — the engine marks the last batch it attempted, usually (but not always) the one that caused the error. The values are real and fully expanded (tokens resolved, connection-string parameters substituted), which is exactly what you need to reproduce the failure.
  3. Reproduce and fix. Open the artifact in your query tool, connect to the same target, and run it. You'll see the exact same error the engine returned during deployment. Work the fix there — iterate until it succeeds — then apply the fix back to your schema package.
  4. Recognize the error class. Most deployment failures fall into one of these:
    • Unresolved token. The batch contains a literal {{Token}} instead of the expanded value — a misspelled token, a token out of scope for this script's slot (a {{SchemaName}} token in a product-level script, say), or a token that was never defined.
    • Dependency order. An object references a table, view, or procedure that doesn't exist yet at the point the script runs. SchemaQuench's retry loop resolves many of these across passes — if the same script fails every pass, the dependency may never be created, or it's circular.
    • Permission. The deploy login lacks the right to create or alter the object. Check its rights against the target database and grant what's needed.
    • Delivery constraint. A merge script hit a foreign-key, unique, or check constraint. Look at the values being inserted or the join logic — the delivered data conflicts with existing rows or references a row that doesn't exist.
  5. Keep it local. The artifact holds real, fully expanded values, so it is for local debugging only: don't attach it to a support ticket or a CI build artifact. Share the progress log instead, which masks sensitive values. ScrubArtifacts, which used to mask the SQL, is deprecated and ignored. See Failure artifacts in the configuration reference.

Generated debug SQL

With WriteDebugSql on, each generated step SchemaQuench runs against your target database is written as it runs, one .sql file each — the same artifact the Resolved SQL written to: line points at when that step fails. Generated procedures cover missing tables and columns, modified tables, indexes, foreign keys, materialized views, indexed views, and the table-JSON parse step. Debug files follow the pattern SchemaQuench - <operation> <server>.<database>.sql:

SchemaQuench - Quench Missing Tables And Columns prod.NW.sql
SchemaQuench - Quench Modified Tables prod.NW.sql
SchemaQuench - Quench Indexes prod.NW.sql
SchemaQuench - Quench Foreign Keys prod.NW.sql
SchemaQuench - Quench Materialized Views prod.NW.sql
SchemaQuench - Quench Indexed Views prod.NW.sql
SchemaQuench - Parse Table Json prod.NW.sql

Only the current failure's files are kept. When a run starts on a target, it deletes the files an earlier run wrote for the same product, server, database and schema, and when it finishes cleanly it deletes its own. It reads the owner from each file's first line, so it never deletes a file it did not write. Operations that don't apply to your platform (indexed views on PostgreSQL, materialized views on MySQL) produce no file. Debug files land in the ArtifactPath directory (default: current working directory) — --LogPath controls the progress and error logs, not artifact or debug SQL.

Engine Notices

SchemaSmith surfaces the database engine's informational output — notices, prints, and server-side status messages — into the progress log so you can see what the engine is telling you. The wiring differs per platform because each driver exposes that stream differently.

PRINT output and severity-10-or-lower errors arrive through the InfoMessage event. By default SchemaSmith promotes only severity-above-10 errors and RAISERROR ... WITH STATE 100 notifications to the progress log; set VerboseLogging: true to include every PRINT and informational message.

RAISE NOTICE and RAISE WARNING output arrives through the Npgsql Notice event. SchemaSmith's own routines' notices always land in the progress log; a notice raised by your own script or function lands there only with VerboseLogging: true, as PRINT does on SQL Server. SchemaSmith filters out the "... does not exist, skipping" and "... already exists, skipping" notices that DROP ... IF EXISTS and CREATE ... IF NOT EXISTS produce during normal runs, so your log stays readable.

The MySQL connector doesn't fire info-message events for long-running stored procedures, so SchemaSmith uses a table-based status channel. A SchemaSmith_StatusMessages table in the target database (created automatically during kindling) holds per-session progress rows; the generated quench procedures INSERT into it as they work, and a background poller on a separate connection reads the new rows every 200ms and writes them to the progress log. SessionId is scoped to CONNECTION_ID() so concurrent runs don't cross-talk, and the monitor deletes its rows on shutdown. There's no VerboseLogging dial on MySQL — what you see is whatever the procedures chose to publish.

The MySQL connector, which MariaDB also uses, doesn't fire info-message events for long-running stored procedures, so SchemaSmith uses a table-based status channel. A SchemaSmith_StatusMessages table in the target database (created automatically during kindling) holds per-session progress rows; the generated quench procedures INSERT into it as they work, and a background poller on a separate connection reads the new rows every 200ms and writes them to the progress log. SessionId is scoped to CONNECTION_ID() so concurrent runs don't cross-talk, and the monitor deletes its rows on shutdown. There's no VerboseLogging dial on MariaDB — what you see is whatever the procedures chose to publish.

Note

VerboseLogging is a SchemaQuench setting. It governs informational output from your own scripts: PRINT and low-severity messages on SQL Server, RAISE NOTICE and RAISE WARNING on PostgreSQL. SchemaSmith's own progress messages always appear. MySQL and MariaDB scripts' informational output is not logged, so the setting has no effect there.

Per-platform error codes

The same logical problem — an orphaned foreign key, a duplicate value, a null in a required column — surfaces differently on each engine. The error text differs, the numeric code differs, and even which log file carries the detail differs. Use this table to recognize the same fault across platforms.

SQL Server usually prints the message (the number isn't always shown); PostgreSQL prints the SQLSTATE literally; MySQL and MariaDB print the classic MySQL-family error message.

FailureSQL ServerPostgreSQLMySQLMariaDB
Foreign-key violation (orphan)5472350314521452
NOT NULL violation5152350210481048
Duplicate / unique-key1505 (index build) / 2601 / 26272350510621062
String or binary truncation81522200114061406
Type / conversion mismatch245 / 811522P0213661366
Deadlock (retried automatically)120540P0112131213

MariaDB reports through the same channel as MySQL — the SchemaSmith_StatusMessages sidecar table polled on a second connection — and uses MySQL-compatible error codes.

For the hands-on method — locating the failing phase, reading the artifact it leaves behind, and choosing a recovery — see working a failed deployment.

Deadlocks are retried for you

SchemaSmith recognizes a deadlock by its code on every engine, so a server running in another language is classified the same way, and falls back to the word deadlock in the message only when the code is missing. It re-runs the operation with a jittered backoff, up to 20 attempts, so a transient lock collision resolves itself rather than failing the deploy.

Exit Codes

Code Condition Recommended action
0 Normal completion. Also a run with no arguments on an install nobody has configured: the tool prints which settings file it read and the settings to fill in, and runs nothing None — the operation succeeded. A pipeline step whose settings never arrived passes the same way without deploying anything, so give a pipeline its settings through SmithySettings_ environment variables or --ConfigFile, either of which skips that screen and makes a missing value fail the run.
1 Finished, but did not produce everything asked: SchemaQuench downgraded a feature the target lacks, under UnsupportedFeaturePolicy: warn (listed in the deployment summary); DataTongs skipped a table (it does not exist in the source, has no key columns, or its KeyColumns are malformed), left out a column whose type cannot be delivered, did not write a merge script because the MySQL source is older than 8.0, or could not wire a script's data token; SchemaTongs left an object out of the package (an invalid or skipped script, an encrypted module, an empty definition) The skipped tables or objects and the reason for each are in the progress log (and, for DataTongs, the error log). Fix the cause and re-run.
2 Failed, for a reason you can fix: a command-line argument was not recognized, a required setting is missing (such as the platform), the package cannot be loaded, a validation script, product script or version check failed, a target was refused, or a TemplateTargets rule was broken. Also: SchemaQuench — one or more database quenches failed; SchemaTongs — one or more tables failed to extract; DataTongs — one or more tables failed to extract; SchemaShears — the patch request cannot be built (missing source or manifest, output already exists, unknown drop category). And a run with no arguments, no SmithySettings_ environment variables and no settings file in the current directory or the tool's folder: the tool names both places it looked and runs nothing Check the progress and error logs for what failed and why. Fix the cause and re-run.
3 Unhandled exception — a defect in the tool An unexpected error occurred. The exception is logged to both the progress and error logs before exit. Please report it with the log contents.
4 Log backup failure The tool completed its main work but couldn't back up the log files. Check directory permissions and disk space in the log directory. The base log files may still be readable even though the backup failed.

Pre-flight checks that fail before any deployment — a --TestConnection failure, a server below the product's MinimumVersion floor, or a --PreviewTargets run that finds a required template with zero targets — also exit 2, so a readiness gate in CI can treat any non-zero exit the same way.

--ExitNonZeroOnWarning (or the ExitNonZeroOnWarning setting) turns a 0 into a 1 when the run logged a warning; every other code is unchanged.

Log messages

A deploy says what it is doing in plain sentences, and the one you are searching for is usually the one that explains why the run did less, or more, than you expected. This is the index: the lines a user is most likely to grep for, the engines that write them, what each means, and where the behavior behind it is documented. The strings are quoted as the tools write them (<…> marks a value), so a search for the fixed part finds the line.

MessageEngineWhat it meansRead more
Not recognized: <argument>. Nothing was run.AllAn argument the tool will never read — a misspelled switch, or a value written with a space instead of : or =. Exit 2.CLI Switch Format
Configuration key '<key>' is not read by <Tool> and will have no effect. Check for a typo.AllA settings key in a section the tool owns that it does not recognize. The run continues.Unrecognized settings are reported
FAILED: <message>AllThe run stopped for a reason you can fix — a failed validation or product script, a version check, a refused target. Exit 2.Exit Codes
EXCEPTION - See the error log:AllAn unhandled exception, a defect in the tool. Exit 3; please report it.Exit Codes
*** FAILED [Template:<name>] ***AllA target failed. Grep for it to find each failed scope; the roll-up lists them together.Failure triage roll-up
Unable to quench '<path>': <error>AllA script failed with the engine's error.Debug SQL files
Resolved SQL written to: <file> / Rerun with --WriteDebugSql to write the resolved SQL of this step to <directory>.AllWhere the failed step's token-expanded SQL is, or how to get it.Debug SQL files
Could not write debug SQL artifact '<name>': <error> / Could not write resolved-SQL artifact for '<path>': <error>AllThe debug file could not be written (usually ArtifactPath is not writable). The step itself is unaffected.ArtifactPath
Lost connection to <server> … — the server stopped responding mid-deployAllThe connection dropped during the run; nothing applied is rolled back.Working a failed deployment
Would APPLY: <path> / Would SKIP (unchanged): <path>AllThe WhatIf plan for a script: it would run, or it is unchanged since its last apply and would be left alone.SchemaQuench reference: WhatIf mode
Unchanged, not re-run: <path>AllThe object script's text and the module the server renders are both as they were after the last apply, so it was not re-run.SchemaQuench reference: Unchanged object scripts
Could not record the script stamp, so object scripts will run again next time: <error>AllThe deploy login cannot write SchemaSmith's ScriptStamp table; the script applied, but every object script runs again on the next deploy. Logged once per target.SchemaQuench reference: Unchanged object scripts
Skipping (previously quenched) <path>AllA run-once migration script already recorded for this database and slot.SchemaQuench reference: Migration script tracking
Skipping (previously quenched per checkpoint) <path>AllA resumed run skipping a script its checkpoint shows as done.SchemaQuench reference: Checkpoint and resume
Skipped (ShouldNotApply): <path>AllThe script raised the SHOULD NOT APPLY sentinel; it is recorded as done and not run again.Runtime sentinel skip
Cannot read which <slot> scripts have already run from <table>. / Cannot read or record which <slot> scripts have already run:AllThe deploy login lacks SELECT (SQL Server: SELECT and INSERT) on CompletedMigrationScripts; nothing in the slot was run.Datafix role grants
The script applied, but could not be recorded as run, so the next deploy would run it again:AllThe script's data change stands, but its tracking row could not be inserted; the script is reported as failed.Datafix role grants
Skipping folder '<folder>' … — ShouldApplyExpression evaluated falseAllA folder gate turned the folder off for this target (or, for a product-level folder, this server).Folder-level gates
Skipping data delivery for <table> — ShouldApplyExpression evaluated falseAllA DataDelivery gate evaluated false for this target.Data Delivery
Invalid baseline for this releaseAllThe template's or product's BaselineValidationScript returned false; the deploy stops.SchemaQuench reference: Database quench sequence
PostgreSQL: Skipping <feature> on <object> (downgraded). SQL Server, MySQL and MariaDB word their own line, naming the feature and the objects, with downgraded in it: Temporal tracking skipped (requires SQL Server 2016 - downgraded): <objects>, Skipping VECTOR index (requires MariaDB 11.7, MySQL unsupported - downgraded): <objects>. MariaDB's two sequence lines leave the word out: Skipping sequence <name>: sequences require MariaDB 10.3 … and Sequence <name> declares type <type>, which requires MariaDB 11.5 …AllUnder UnsupportedFeaturePolicy: warn the object was emitted without a feature the target version lacks. The summary lists each one; exit 1.SchemaQuench reference: Engine version compatibility
Re-baselined <n> recorded expression(s): … / Re-baselined <n> recorded materialized view definition(s) …All; the materialized-view line PostgreSQL onlyAfter an engine upgrade the stored canonical text of recorded expressions was refreshed. No object was changed.SchemaQuench reference: Expression change detection
Handing table <name> to SchemaSmith.CustomTableDrop (no longer in product) (MySQL and MariaDB: SchemaSmith_CustomTableDrop)AllA drop-by-absence was routed to your custom drop hook instead of a plain DROP TABLE.Drop control: recyclebin
Partitioned table(s) skipped by drop-by-absence guard; drop manually or mark PreventDrop.MySQL and MariaDBA table no longer in the package is partitioned. The modified-tables step fails with this error rather than drop it by absence: drop it yourself, or mark it PreventDrop.DropTablesRemovedFromProduct
Drop index not declared for this deploy: <table>.<index>MySQL and MariaDBAn index on a managed table that the package does not declare for this target — removed from the product, or never declared — is being dropped.DropIndexesRemovedFromProduct, DropUnknownIndexes
… (not covered by OnlineApply)SQL Server, PostgreSQLA change OnlineApply has no form for on that engine ran as written, under Prefer or Require too.SchemaQuench reference: OnlineApply
… (online, after this pass)PostgreSQLA CONCURRENTLY statement that runs on its own once the step that needs it has finished.SchemaQuench reference: OnlineApply
PreventDrop is ENABLED — this environment will skip every drop-by-absence …AllThe no-drop protection tier is on; suppressed drops are listed in the summary.PreventDrop
<object> was dropped for a column change and this run did not re-create it, so its grants were not put back.SQL ServerA schema-bound module was dropped under DropSchemaBoundDependents and no script in the run recreated it.DropSchemaBoundDependents
Transient contention from a parallel iteration; retrying (attempt <n> of 20)AllA convergence procedure was a deadlock or lock-timeout victim and is being re-run.Per-platform error codes
Live progress from the database is unavailable (<reason>); its messages are logged after each step instead. / The database's step messages cannot be read (<reason>); this run's log has none of them.MySQL and MariaDBThe status-message poller could not open its second connection, or the status table could not be read at all.Engine notices
Deployment summary written: <path> / Could not write deployment summary: <error>AllWhere the run's Summary.json and Summary.md went, or why they could not be written (the run is unaffected).SchemaQuench reference: Deployment summary report
ScrubArtifacts is deprecated and does nothing …AllA deprecated setting is still in the settings file. Remove it.ScrubArtifacts

Shape. Strengthen. Succeed.

Free schema-as-code for SQL Server, PostgreSQL, MySQL, and MariaDB.

The source is on GitHub for anyone to read.

Get Started on GitHub