Reference

GitLab CI step by step

A numbered path from a token to merge requests blocked by real findings, then every variable, tested recipes and GitLab-specific troubleshooting.

View as Markdown

This guide takes a GitLab project from nothing to ScanSuite scans that gate merge requests and the default branch. Follow the numbered steps the first time; the variables, recipes and troubleshooting after them are reference. Every option of the client is in CI/CD and automation.

ScanSuite Teams

Pipeline scans use the team API, which is part of ScanSuite Teams.

At a glance

If you know GitLab CI already, this is all of it. Add four CI/CD variables (Settings → CI/CD → Variables): SCANSUITE_URL, SCANSUITE_TEAM (the name the Automation and API tokens card shows), SCANSUITE_PRODUCT, and SCANSUITE_TOKEN (Masked, Protect variable cleared). Include the template from your server:

include:
  - remote: '<YOUR_SCANSUITE_URL>/ci/scansuite.gitlab-ci.yml'

Then turn on Settings → Merge requests → Merge checks → Pipelines must succeed.

The screenshots and the tested results at the end come from a run on GitLab CE 19.4 (self-managed) with a self-hosted runner, against a sample Flask application with known problems: SQL injection, command injection, path traversal, vulnerable dependencies and a committed GitHub token.

What you get

A GitLab job runs the ScanSuite CI client from the image appsec4u/scansuite-ci:1. It uploads the files Git tracks, starts a scan on your ScanSuite server and waits for it, so the runner needs no scanners and little memory. When the scan ends, the job passes or fails on the gate (by default: any High or Critical finding, or any secret new to the product).

ResultWhat you get
The job passesNothing blocks. The findings are still in ScanSuite.
The job failsThe log lists every blocking finding and secret; the pipeline's Tests tab and the merge request show them as failed tests.
Reportsscansuite-junit.xml (GitLab test report), scansuite.json (summary) and scansuite.sarif, kept as job artifacts for 30 days.

Before you start

You needHow to check
ScanSuite: the Team admin role in a teamThe Teams page says Your role in this team: Team admin.
A product for the findingsIt is listed on the Products page, or let the pipeline create it (see Monorepo and new products).
For the default merge request job (quick-classic): the static scanner images on the serverOn the ScanSuite server, in the installation directory, grep SCANSUITE_SCANNERS .env prints static or all. A default installation prints none; a system administrator runs ./scansuite update --static-only. Or use quick-ai (step 7).
For the default-branch job (standard-ai) and quick-ai: an AI provider for the teamTeams page, AI tab. After step 2, --list-scanners must not mark mlsast NOT AVAILABLE.
GitLab: the Maintainer role in the projectSettings → CI/CD is in the project menu.
A runnerSettings → CI/CD → Runners lists an Online runner with the Docker executor that runs untagged jobs, can pull appsec4u/scansuite-ci:1 from Docker Hub and reaches your ScanSuite server over HTTPS. Shared runners on GitLab.com qualify when the server is reachable from the Internet.

Set it up

Step 1. Create a token in ScanSuite

The pipeline signs in with the token of a service account, not with a person's password. A service account belongs to the team and keeps working when people leave it.

  1. 01
    Open the Teams page

    Teams in the sidebar, then the People tab. Scroll to Automation and API tokens. The line at the top of the card reads This team's name in pipelines and API addresses (SCANSUITE_TEAM), with the name in bold: that is the value of SCANSUITE_TEAM. The first team of an installation is default, whatever it was renamed to.

  2. 02
    Create a service account

    Under New service account, type a name such as gitlab-ci, set Role to Operator (the default, Reader, cannot start scans) and select Create. Check: the account is listed with the role Operator and the badge Active.

  3. 03
    Issue a token

    Select New token on the new account. Fill in Token name (for example gitlab-backend), Valid for (days) (30 by default, at most 90), keep What can it do? on CI pipeline and select Create token. Check: the Your new token dialog opens.

Automation and API tokens card in ScanSuite
The Automation and API tokens card: the team name for pipelines, service accounts and their tokens
New token dialog in ScanSuite
A new token with the CI pipeline preset

The Your new token dialog shows the token with a Copy button, the row This team's name in pipelines and API addresses (SCANSUITE_TEAM), and Test the connection with two commands that already contain the server, the team and the token: With the pipeline client (Docker) and With curl.

Copy the token. It is shown once; keep it only until step 3 puts it in GitLab, and never paste it into a chat, a ticket or the repository. If you lose it, revoke it on the card and issue another.

The CI pipeline preset gives the token what a pipeline needs and nothing more: start and stop scans, see products, scans, findings and discovered credentials, download reports, and create products. Each token is listed with its expiry date; the job log warns when it expires within 14 days. The permission list is in CI/CD and automation.

Step 2. Test the token

Run these commands in your own terminal: the second one asks you to paste the token.

bash
export SCANSUITE_URL=<YOUR_SCANSUITE_URL> SCANSUITE_TEAM=<YOUR_TEAM>
read -rs SCANSUITE_TOKEN && export SCANSUITE_TOKEN
docker run --rm -e SCANSUITE_URL -e SCANSUITE_TEAM -e SCANSUITE_TOKEN appsec4u/scansuite-ci:1 --check

Expected: Connected to … the server accepts the API token for team … (role operator), the token's permissions and expiry, and The token can run pipeline scans. A refused token ends with exit code 3 and the reason: expired, revoked, service account deactivated, team not active, unknown token, or a token of another team (the message then names the team to set). The fix for each is in CI/CD and automation. Add --list-scanners instead of --check to see which scanners your team can run.

Step 3. Add the CI/CD variables in GitLab

In the GitLab project: Settings → CI/CD → Variables → Add variable, once for each variable:

KeyValueVisibility and flags
SCANSUITE_URLThe address of your ScanSuite server, for example https://scansuite.example.comVisible
SCANSUITE_TEAMThe team name from the Automation and API tokens card (step 1), or from the new-token dialog.Visible
SCANSUITE_PRODUCTThe product's exact name, as on the Products page. Or SCANSUITE_PRODUCT_ID with its number.Visible
SCANSUITE_TOKENThe token from step 1.Masked, Protect variable cleared

Add SCANSUITE_TOKEN yourself, with Masked set and Protect variable cleared.

GitLab Add variable drawer
SCANSUITE_TOKEN: Masked, with Protect variable cleared
Clear Protect variable on SCANSUITE_TOKEN

GitLab ticks Protect variable by default. A protected variable reaches only pipelines on protected branches and tags, so every merge request from an ordinary branch fails with Set SCANSUITE_TOKEN ... and exit code 3. Protect it only if every pipeline that scans runs on a protected branch or tag.

GitLab project CI/CD variables
The four variables; only the token is masked

Check: the project's CI/CD variables list the four keys, and only SCANSUITE_TOKEN shows as masked. Variables set here apply to every job and win over variables written in .gitlab-ci.yml; see Monorepo and new products for what that means when one job reports to another product.

Step 4. Check the runner

Settings → CI/CD → Runners lists the runners the project can use. One of them must be Online, use the Docker executor, and run untagged jobs. If your runners only take tagged jobs, add the tag to the template's hidden job in your .gitlab-ci.yml:

yaml
.scansuite:
  tags: [docker]
GitLab runners settings
An instance runner, online, available to the project

Step 5. Add the pipeline

Your ScanSuite server serves a GitLab CI template that always matches its version. Add this to .gitlab-ci.yml in the root of the repository (create the file if the project has none), with your server's address, and commit it to the default branch. The push starts the first pipeline.

.gitlab-ci.yml
include:
  - remote: '<YOUR_SCANSUITE_URL>/ci/scansuite.gitlab-ci.yml'
Job the template addsRuns onScan
scansuite-merge-requestEvery merge requestquick-classic (rule-based Semgrep, no AI) on the files the merge request changes
scansuite-default-branchEvery push to the default branchstandard-ai (AI SAST with reachability, secrets with AI verification, dependency checks) on the whole repository
Let an agent add the job
Add ScanSuite to this repository's .gitlab-ci.yml by following https://scansuite.eu/documentation/reference/gitlab-ci: include the template from our ScanSuite server, use quick-ai for merge requests if our team has AI set up, and list the CI/CD variables I must add. Stop at every step marked "A person does this step". Never ask me for the token: I will add SCANSUITE_TOKEN myself as a masked, unprotected variable.

Paste it into Claude Code or another coding agent. See Working with AI agents.

Your pipeline already has stages? Keep them and add test if it is missing: the template's jobs run in the test stage. If you would rather not include a remote file, copy the template's content from the same address into your repository; AI SAST reports an unpinned remote include as a Medium finding.

Check: Build → Pipelines shows a new pipeline with the job scansuite-default-branch. The last [scansuite] lines of its log are either Quality gate passed or Quality gate FAILED: N blocking finding(s), M blocking secret(s). Any other ending is in Troubleshooting.

Step 6. Check the result

Open Build → Pipelines, the newest pipeline, then the job. The end of its log says what the scan found and why the job failed:

GitLab pipeline graph
A pipeline with the template's job, a classic scan, and the DAST and image recipes
GitLab job log of the ScanSuite job
The end of the job log: blocking findings, the gate and the exit code
Log lineMeaning
Team default, product shop-api (#8)The team and product the job reports to.
Scan jfzyghvb (#95) Queued … FinishedThe scan's reference; search for it in ScanSuite.
Open findings in this scan: Critical 1, High 2, …Everything the scan reported.
BLOCKING [Critical] OS command injection -- app.py::host (Reachable)One line per finding that fails the gate, with the file, the code location and the reason.
BLOCKING [Secret] github_token -- …/settings.py#L3A secret that blocks, with a link to the file in GitLab.
Quality gate FAILED: 3 blocking finding(s), 1 blocking secret(s)The verdict.
Exit code 1: the quality gate failed …Why the job failed. GitLab always prints exit code 1 below it; this line has the real code.

The pipeline's Tests tab shows each blocking finding as a failed test, per job. Download or Browse under Job artifacts on the job page gives the JSON and SARIF reports.

GitLab pipeline Tests tab
The Tests tab: one failed test per blocking finding

In ScanSuite, the pipeline's scan is an ordinary scan of the product: it appears in Scan History under the name of the project's archive, and its page lists what it found. Findings link to the file and line in GitLab at the scanned commit. Triage there as usual: the gate counts only findings that are Open or In Progress, so a finding you close as a false positive or accepted risk no longer fails the next pipeline.

ScanSuite scan page
The scan a pipeline started, on its own page
ScanSuite vulnerabilities filtered by scan
The findings of that scan

Step 7. Gate merge requests

A failed job blocks merging only when the project asks for it.

In GitLab, turn on Settings → Merge requests → Merge checks → Pipelines must succeed, and save. It changes how every merge request in the project is merged, so the project's maintainers decide it.

GitLab merge checks setting
The merge check that turns a failed scan into a blocked merge

Check: a merge request whose pipeline failed shows the blocking findings as failed tests and cannot be merged until a pipeline passes.

GitLab merge request with a failed ScanSuite test summary
A merge request blocked by the quick-ai gate

If your team has AI set up, make quick-ai the merge request gate: in the test it caught code execution that the rule-based quick-classic missed (see Tested results). Both scan only the changed files; secrets and dependency checks need the whole repository and run on the default branch.

.gitlab-ci.yml
include:
  - remote: '<YOUR_SCANSUITE_URL>/ci/scansuite.gitlab-ci.yml'

scansuite-merge-request:
  variables:
    SCANSUITE_PROFILE: quick-ai

Variables

Set a variable on one job under variables:, or for every job in Settings → CI/CD → Variables (project variables win over job variables). Gate options, bundles and every other option are described in CI/CD and automation.

VariableDefault in the templateWhat it does
SCANSUITE_URL, SCANSUITE_TEAM, SCANSUITE_TOKEN—The server, the team name and the token (step 3).
SCANSUITE_PRODUCT or SCANSUITE_PRODUCT_ID—The product, by exact name or number.
SCANSUITE_CREATE_PRODUCToff1 creates SCANSUITE_PRODUCT on the first run.
SCANSUITE_PROFILEquick-classic on the merge request job, standard-ai on the default-branch jobThe bundle; for DAST quick, standard or deep.
SCANSUITE_CHANGED_ONLY1 on the merge request jobScan only the changed files.
SCANSUITE_BASEthe merge request targetWhat --changed-only compares with.
SCANSUITE_SCAN_TYPEsastdast or infra for the recipes below.
SCANSUITE_TARGETS—DAST URLs, or infrastructure hosts and images.
SCANSUITE_PORTSAll TCPInfrastructure ports, such as Top 1000 TCP/UDP. Use this variable, not SCANSUITE_EXTRA_ARGS, because the value contains spaces.
SCANSUITE_FAIL_ON_SEVERITYhighLowest blocking severity; none turns it off.
SCANSUITE_MAX—Allowed findings per severity, such as high=0,medium=10.
SCANSUITE_BLOCK_CLASS—Classes that block at any severity.
SCANSUITE_MIN_CONFIDENCEanyreachable: only findings confirmed reachable block.
SCANSUITE_FAIL_ON_SECRETSnewnew, all or none.
SCANSUITE_SOURCE, SCANSUITE_GIT_URL, SCANSUITE_BRANCHauto, the project, the pipeline branchLet the server clone instead of uploading (see Large repository).
SCANSUITE_TIMEOUT7200Seconds the client waits for the scan.
SCANSUITE_IDEMPOTENCY_KEYderived from the GitLab jobRarely needed: GitLab jobs are told apart by instance, project and start time.
SCANSUITE_CA_BUNDLE, SCANSUITE_STRICT_TLS—, offA path in the repository to your CA certificate; 1 stops on a certificate the runner cannot verify.
SCANSUITE_EXTRA_ARGSemptyAny other client option, such as --report-zip scansuite-report.zip or --include-unreachable (which has no variable). It is split on spaces with no quoting, so a value that contains spaces needs its own variable.
GIT_DEPTH50Clone depth. The client fetches the merge request target if the clone lacks it. Set "0" for full-ai and other Git history scans.

The template's hidden .scansuite job runs in the test stage with the image appsec4u/scansuite-ci:1, writes scansuite-junit.xml (published as the test report), scansuite.json and scansuite.sarif, and keeps them for 30 days.

Choose what to scan, and when

TriggerWithout AIWith AI
Merge requestquick-classicquick-ai
Default branchstandard-classicstandard-ai
Nightly or releasefull-classicfull-ai (slowest, the highest AI cost)

Set the bundle with SCANSUITE_PROFILE on a job. To tune what fails the job, see When the build fails; for single scanners and AI options, see Static analysis.

The first scan of a product sees every secret as new. A job that creates the product, or the first scan of an existing repository, fails on secrets already committed. Triage them in ScanSuite, or start with SCANSUITE_FAIL_ON_SECRETS: none.

Recipes

Each recipe is a job to add to .gitlab-ci.yml under the include. Jobs extend the template's hidden .scansuite job, which brings the image, the reports and the artifacts.

GoalJobKey variablesRecipe
Scan the deployed application and the built imagescansuite-dast, scansuite-imageSCANSUITE_SCAN_TYPE, SCANSUITE_TARGETSDAST and container image scans
Everything, every nightscansuite-nightlySCANSUITE_PROFILE: full-ai, GIT_DEPTH: "0", SCANSUITE_MAXNightly full scan
A strict gate on release tagsscansuite-releaseSCANSUITE_MIN_CONFIDENCE: reachable, SCANSUITE_FAIL_ON_SECRETS: allRelease gate on tags
One product per service, created on the first runscansuite-servicesSCANSUITE_EXTRA_ARGS with --product-name and --create-productMonorepo and new products
Report without blocking anyonescansuite-default-branchSCANSUITE_FAIL_ON_SEVERITY: noneRoll out without blocking
A large repository the server clonesscansuite-incrementalSCANSUITE_SOURCE: git, --mode incrementalLarge repository
No remote includescansuite—Without the template

DAST and container image scans

When: after the deployment to staging and after the image build, in a later stage. needs: [] lets them start even when a static scan failed the build; without it GitLab skips them.

.gitlab-ci.yml
stages: [test, verify]

scansuite-dast:
  extends: .scansuite
  stage: verify
  needs: []
  variables:
    SCANSUITE_SCAN_TYPE: dast
    SCANSUITE_TARGETS: https://staging.example.com
    SCANSUITE_PROFILE: quick
    SCANSUITE_FAIL_ON_SEVERITY: critical
  rules:
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH && $CI_PIPELINE_SOURCE != "merge_request_event"

scansuite-image:
  extends: .scansuite
  stage: verify
  needs: []
  variables:
    SCANSUITE_SCAN_TYPE: infra
    SCANSUITE_TARGETS: registry.example.com/shop/api:$CI_COMMIT_SHORT_SHA
    SCANSUITE_EXTRA_ARGS: --scanners docker_image_scan
    SCANSUITE_FAIL_ON_SEVERITY: critical
  rules:
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH && $CI_PIPELINE_SOURCE != "merge_request_event"

Expected log line: Quality gate passed, or Quality gate FAILED: … with one BLOCKING line per Critical finding. Caveat: the targets must be allowed for the team (Teams page, Scanning tab, Web targets and Infrastructure targets); otherwise the job stops with exit code 3 before a scan starts, naming the refused target.

Nightly full scan

When: a scheduled pipeline. Create the schedule in Build → Pipeline schedules, then add the job. full-ai analyses Git history, so the job fetches all of it.

.gitlab-ci.yml
scansuite-nightly:
  extends: .scansuite
  timeout: 4h
  variables:
    SCANSUITE_PROFILE: full-ai
    GIT_DEPTH: "0"
    SCANSUITE_MAX: high=0,critical=0,medium=10
    SCANSUITE_TIMEOUT: "14400"
  rules:
    - if: $CI_PIPELINE_SOURCE == "schedule"
GitLab pipeline schedules
A nightly schedule for the default branch

Expected log line: a blocking Medium finding over the budget reads Medium: 12 found, 10 allowed. Caveat: GitLab stops a job at its own timeout (one hour by default, shown as Timeout on the job page) before SCANSUITE_TIMEOUT is reached, hence timeout: 4h on the job; the runner's own limit still applies.

Release gate on tags

When: a tag is pushed. Stricter than the merge request gate, limited to what is reachable, counting every secret the product has, and keeping the full report with the release.

.gitlab-ci.yml
stages: [test, release]

scansuite-release:
  extends: .scansuite
  stage: release
  variables:
    SCANSUITE_PROFILE: standard-ai
    SCANSUITE_FAIL_ON_SEVERITY: medium
    SCANSUITE_MIN_CONFIDENCE: reachable
    SCANSUITE_FAIL_ON_SECRETS: all
    SCANSUITE_EXTRA_ARGS: --report-zip scansuite-report.zip
  artifacts:
    when: always
    paths: [scansuite-report.zip, scansuite.json]
  rules:
    - if: $CI_COMMIT_TAG
GitLab job artifacts with scansuite-report.zip
The release job keeps the full report and the summary

Expected: the job artifacts list scansuite-report.zip. Caveat: all counts secrets earlier scans already knew, so a release fails until every open secret is triaged.

Monorepo and new products

When: one job per service folder, each reporting to its own product, created on the first run. Pass the product as an option: a SCANSUITE_PRODUCT variable in the job would lose to the project's variable from step 3, and every service would report to the same product.

.gitlab-ci.yml
scansuite-services:
  extends: .scansuite
  parallel:
    matrix:
      - SERVICE: [payments, web]
  variables:
    SCANSUITE_PROFILE: quick-classic
    SCANSUITE_CHANGED_ONLY: "1"
    SCANSUITE_EXTRA_ARGS: --source-dir services/$SERVICE --product-name $SERVICE --create-product
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"

For a single new repository, set it once on the hidden job so every job inherits it (or set SCANSUITE_CREATE_PRODUCT to 1 next to SCANSUITE_PRODUCT in the project's variables):

.gitlab-ci.yml
.scansuite:
  variables:
    SCANSUITE_EXTRA_ARGS: --product-name $CI_PROJECT_NAME --create-product

Expected log line: Created product payments (#10) on the first run, then Team default, product payments (#10) on every run. Caveat: a job that sets its own SCANSUITE_EXTRA_ARGS replaces the hidden job's value, so repeat both options there.

Roll out without blocking

When: the team is getting used to the results. Scan and publish the reports, but never fail the pipeline:

.gitlab-ci.yml
scansuite-default-branch:
  variables:
    SCANSUITE_FAIL_ON_SEVERITY: none
    SCANSUITE_FAIL_ON_SECRETS: none

To keep failing on findings but not on a ScanSuite outage, set SCANSUITE_EXTRA_ARGS: --soft-fail instead. Expected log line during an outage: WARNING: --soft-fail: exiting 0 instead of 5.

Large repository: let the server clone it

When: uploading the checkout is slow. The ScanSuite server clones the branch itself; with --mode incremental it then scans only what changed since its last scan of that branch.

  1. 01
    Make a key pair for ScanSuite

    Without a passphrase: ScanSuite refuses a key protected by one. Use it only for this.

    Shell
    ssh-keygen -t ed25519 -N "" -f scansuite-deploy
  2. 02
    Give GitLab the public half

    In the project: Settings → Repository → Deploy keys → Add new key, with the content of scansuite-deploy.pub. Leave write access off.

  3. 03
    Give ScanSuite the private half

    Teams page → Scanning tab → Team SSH key: paste the content of scansuite-deploy into Private key and select Save. Check: the card shows the key's fingerprint. Then delete the file.

  4. 04
    Add the job

    With the SSH address of the project. A GitLab whose SSH port is not 22 needs the ssh:// form with the port, as below.

Pasting the private key into ScanSuite is a step for a team admin or operator.

ScanSuite Team SSH key card
The Team SSH key card on the Scanning tab
.gitlab-ci.yml
scansuite-incremental:
  extends: .scansuite
  variables:
    SCANSUITE_SOURCE: git
    SCANSUITE_GIT_URL: ssh://git@gitlab.example.com:2222/$CI_PROJECT_PATH.git
    SCANSUITE_PROFILE: standard-ai
    SCANSUITE_EXTRA_ARGS: --mode incremental
  rules:
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH

Expected log line: Source: ssh://…/shop-backend.git @ main (the server clones the branch head, not necessarily …); on a run with no new commits, Nothing to scan: … and the job passes. Caveats: pipeline scans always clone with the Team SSH key, never a person's own key. The server scans the branch as it is when the scan starts, which can be newer than the pipeline's commit. It trusts the Git server's SSH host key on the first clone and refuses a changed key afterwards: if GitLab is reinstalled or moved, clones stop with could not resolve the remote revision: @@@@… until a ScanSuite administrator removes the old key from /var/tmp/scansuite/git-auth/known_hosts in the worker container. More on keys in Git repository authentication.

Without the template

When: you cannot include a remote file. Clear the image's entrypoint, because GitLab runs its own shell in the container:

.gitlab-ci.yml
scansuite:
  stage: test
  image:
    name: appsec4u/scansuite-ci:1
    entrypoint: [""]
  variables:
    GIT_DEPTH: "50"
  script:
    - scansuite-ci --profile quick-classic --changed-only --junit scansuite-junit.xml --sarif scansuite.sarif
  artifacts:
    when: always
    reports: { junit: scansuite-junit.xml }
    paths: [scansuite.sarif]
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"

The same recipes are in the GitLab examples of the scansuite-ci repository.

Troubleshooting

GitLab ends every failed job with ERROR: Job failed: exit code 1, whatever went wrong. The client's last [scansuite] line has the real exit code; the codes are explained in CI/CD and automation.

GitLab job log with a ScanSuite configuration error
A configuration error: the client says exit code 3, GitLab says exit code 1
Message or symptomCause and fix
Set SCANSUITE_TOKEN ...The token did not reach the job. It is Protected and the pipeline runs on an unprotected branch (step 3), or the variable is missing.
The server rejected the API token …The message gives the reason: expired, revoked, deactivated, another team, unknown. Run the test in step 2.
Product 'X' was not found in team YSCANSUITE_PRODUCT does not match a product name exactly, or SCANSUITE_TEAM is wrong. Add --create-product to create it.
The API token lacks permission(s): ...The token was issued without the CI pipeline preset, or the service account is a Reader. Issue a new token.
Cannot run on this server: openvas: ...The scanner is not set up for your team; the message says where to set it up.
Findings land in the wrong productA job sets SCANSUITE_PRODUCT, but the project's variable wins. Pass --product-name in SCANSUITE_EXTRA_ARGS.
--changed-only: no base to compare withNot a merge request pipeline, or the clone lacks the target branch. The job then scans everything.
This is a shallow clone, so Git history analysis sees only ...Set GIT_DEPTH: "0" on full-ai and other Git history scans.
A later-stage job was skippedA scan in an earlier stage failed. Give the job needs: [].
The job ends as TimeoutGitLab's job timeout (one hour by default) came first. Add timeout: 4h to the job.

Cancelling a job cancels its scan. When you cancel the pipeline in GitLab, the client stops the scan in ScanSuite before the job ends (Cancelled scan … (pipeline interrupted)). When the client itself stops waiting (SCANSUITE_TIMEOUT, exit code 4), the scan keeps running unless you add --cancel-on-timeout.

Tested results

What each setup did on the sample application in the 2026-10-03 run. Times depend on the code base and the AI provider.

SetupBundleTimeResult
Template default-branch jobstandard-aiAbout 3 minutesFailed on 3 reachable findings (the injections and the path traversal) and 1 verified secret.
Default branch without AIstandard-classic3 to 4 minutesFailed on 15, including the same injections found by several rules and the vulnerable pyyaml, flask, jinja2 and requests versions.
Merge request adding pickle.loads and evalquick-classicAbout a minutePassed: the rule-based rules matched neither line.
The same merge requestquick-aiAbout 30 secondsFailed with two Critical findings: insecure deserialization and code execution through eval.
Gate tuned to critical plus blocked classesstandard-ai—Still failed on the High SQL and command injections, marked blocked class sql_injection.
DAST and container image scansquick; docker_image_scan—DAST passed (High and Medium issues, below its critical threshold); the image failed on 9 Critical CVEs in python:3.8-slim.
Nightly full scanfull-ai7 to 25 minutes2 Critical, 3 High and 2 Medium: the 5 High and Critical failed the job, the Medium stayed within the budget.
Release gatestandard-ai—Failed on six reachable findings down to Medium, including an SSH ingress open to the Internet in main.tf and the unpinned remote include, plus the known GitHub token.
Monorepo, a merge request touching both servicesquick-classic—The payments job failed on a SQL injection, the web job passed: the merge request was blocked by one service.
Soft fail, server unreachable—About a minute of retriesLogged --soft-fail: exiting 0 instead of 5; the job passed.
Server clone, incrementalstandard-ai13 seconds on the second runThe first run scanned the whole branch; the second found no new commits and passed.
AI scanners one at a timemlsast with every optionUnder 4 minutesAI SAST failed on 2 Critical and 3 High; reachable dependencies only: passed (no vulnerable dependency was reachable); verified new secrets only: passed (the secret was already known).

Last reviewed 2026-10-19