構成オプション

このセクションでは、Docker、GitHub アクション、GitLab CI/CD などの実行に使用されるツールの構成を使用して、Qodana リンターを構成する方法について説明します。

多くの場合、このセクションで説明する設定は、このセクションでも説明する qodana.yaml ファイル経由で構成することもできます。

オプションの種類

Qodana は、以下に示す 3 種類のオプションを使用して設定できます。

オプション型	サンプル
オプション名とその引数の間に等号 (`=`) が必要です	`--property=idea.log.config.file=info.xml`
オプション名とその引数の間にスペース文字 ( ) が必要です	`--baseline /path/to/sarif/file`
引数は必要ありません	`--apply-fixes`

これらすべてのオプションを呼び出すコマンドの例を次に示します。

                    docker run \
                       -v $(pwd):/data/project/ \
                       -e QODANA_TOKEN="<cloud-project-token>" \
                       <image-name> \
                       --property=idea.log.config.file=info.xml \
                       --baseline <baseline-path> \
                       --apply-fixes
                

                    qodana scan \
                       -e QODANA_TOKEN="<cloud-project-token>" \
                       --property=idea.log.config.file=info.xml \
                       --baseline <baseline-path> \
                       --apply-fixes
                

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: |
                                          --property=idea.log.config.file=info.xml
                                          --baseline <baseline-path>
                                          --apply-fixes
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana \
                                        --property=idea.log.config.file=info.xml \
                                        --baseline <baseline-path> \
                                        --apply-fixes
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      --property=idea.log.config.file=info.xml
                                      --baseline <baseline-path>
                                      --apply-fixes
                                      --image <image>
                    

ランナー設定で、追加の Qodana 引数フィールドを見つけて、プラグインファイルへのパスを指定します。

                        --property=idea.log.config.file=info.xml --baseline <baseline-path> --apply-fixes
                    

プロジェクトの構成

オプション	説明	デフォルト値
`--config <string>`	`qodana.yaml` の代わりにカスタム構成ファイルを設定します。プロジェクトディレクトリからの相対パスを使用します	なし
`-f, --force`	強制的に初期化し、既存の有効な `qodana.yaml` ファイルを上書きします	なし
`-i, --project-dir <string>`	プロジェクトのルートディレクトリを指定します	`.`

qodana init <options> コマンドを使用して、Qodana CLI でこれらのオプションを呼び出すことができます。

プロジェクトを分析する

オプション

説明

--image <string>

<string> の代わりに、使用する Qodana Docker イメージを指定します。

Docker イメージ	説明
`jetbrains/qodana-jvm-community:2026.1`	JVM の Qodana コミュニティ
`jetbrains/qodana-jvm:2026.1`	JVM 用 Qodana
`jetbrains/qodana-jvm-android:2026.1`	Android のための Qodana コミュニティ
`jetbrains/qodana-android:2026.1`	Android 用 Qodana
`jetbrains/qodana-php:2026.1`	PHP 用の Qodana
`jetbrains/qodana-python:2026.1`	Python 用 Qodana
`jetbrains/qodana-python-community:2026.1`	Python のための Qodana コミュニティ
`jetbrains/qodana-js:2026.1`	JS 用 Qodana
`jetbrains/qodana-go:2026.1`	Go 用 Qodana
`jetbrains/qodana-dotnet:2026.1`	.NET 用 Qodana
`jetbrains/qodana-cdnet:2026.1-eap`	.NET の Qodana コミュニティ
`jetbrains/qodana-cpp:2026.1`	C/C++ 用 Qodana
`jetbrains/qodana-clang:2026.1-eap`	C/C++ のための Qodana コミュニティ
`jetbrains/qodana-ruby:2026.1-eap`	Ruby 用 Qodana

また、Qodana を含む任意の Docker イメージを使用することもできます。

-l, --linter <string>

<string> の代わりに、使用するリンターを指定します。

リンター名	説明
`qodana-jvm-community`	JVM の Qodana コミュニティ
`qodana-jvm`	JVM 用 Qodana
`qodana-jvm-android`	Android のための Qodana コミュニティ
`qodana-android`	Android 用 Qodana
`qodana-php`	PHP 用の Qodana
`qodana-python`	Python 用 Qodana
`qodana-python-community`	Python のための Qodana コミュニティ
`qodana-js`	JS 用 Qodana
`qodana-go`	Go 用 Qodana
`qodana-dotnet`	.NET 用 Qodana
`qodana-cdnet`	.NET の Qodana コミュニティ
`qodana-cpp`	C/C++ 用 Qodana
`qodana-clang`	C/C++ のための Qodana コミュニティ
`qodana-ruby`	Ruby 用 Qodana

--within-docker <true|false>

Docker コンテナー内で分析を実行するかどうかを定義します。

true に設定した場合、Qodana は対応する Docker イメージを使用します。コンテナー作成用のイメージは、--image の値に基づいて自動的に選択されます。例: --linter qodana-jvm の場合は、jetbrains/qodana-jvm イメージが選択されます。

false に設定すると、Qodana は現在の環境を使用してネイティブモードでプロジェクトを分析します。

デフォルト値は、現在の環境とプロジェクトの分析に基づいて動的に定義されます。

ネイティブモードは現在、次の Qodana リンターで利用できます。

リンター名	説明
`qodana-jvm`	JVM 用 Qodana
`qodana-jvm-community`	JVM の Qodana コミュニティ
`qodana-php`	PHP 用の Qodana
`qodana-js`	JS 用 Qodana
`qodana-dotnet`	.NET 用 Qodana
`qodana-go`	Go 用 Qodana
`qodana-python`	Python 用 Qodana
`qodana-python-community`	Python のための Qodana コミュニティ

-i, --project-dir <string>

分析対象プロジェクトのルートディレクトリ。デフォルト値は . です

--repository-root string <string>

Git リポジトリのルートへのパス。このディレクトリは --project-dir と同じであるか、プロジェクトディレクトリを内部に含んでいる必要があります。

-o, --results-dir <string>

Qodana 分析レポートの保存先ディレクトリを上書きします。デフォルト値は <userCacheDir>/JetBrains/Qodana/<linter>/results です

--cache-dir <string>

キャッシュディレクトリを上書きします。デフォルト値は <userCacheDir>/JetBrains/Qodana/<linter>/cache です

-r, --report-dir <string>

Qodana HTML レポートを保存するディレクトリを上書きします。デフォルト値は <userCacheDir>/JetBrains/<linter>/results/report です

--print-problems

Qodana によって発見されたすべての問題を CLI 出力に印刷します

--code-climate

GitLab CI/CD でサポートされている SARIF 形式のコード気候(英語)レポートを生成します。レポートは --results-dir オプションで指定されたディレクトリに保存されます。デフォルトでは、GitLab CI/CD が実行中の場合、このオプションは有効になっています。

--bitbucket-insights

Bitbucket クラウドでサポートされているコードインサイト(英語)レポートを生成します。デフォルトでは、Qodana が Bitbucket パイプラインで実行されている場合、このオプションは有効になっています。

--clear-cache

分析を実行する前にローカル Qodana キャッシュをクリアします

-w, --show-report

--port オプションで指定されたポートで HTML レポートを提供する

--port <int>

レポートを提供するポート。デフォルト値は 8080 です。このオプションは非推奨です。代わりに --show-report-port オプションを使用してください

--show-report-port <int>

報告書を届ける港

--config <string>

qodana.yaml の代わりにカスタム構成ファイルを設定します。プロジェクトのルートディレクトリからの相対パスを使用します

-a, --analysis-id <string>

Qodana Cloud で使用される一意のレポート識別子 (GUID)。デフォルト値は 2c72b6e8-f09d-472a-bb86-8a7d8e374ed1 です

-b, --baseline <string>

ベースライン状態の計算で使用される既存の SARIF レポートへのパスを指定します

--baseline-include-absent

出力レポートに存在しないとマークされたベースラインの問題を含める

--full-history [--commit <commit-hash>]

コミット履歴全体を調べ、各コミットの分析を実行します。--commit と組み合わせると、指定されたコミットから分析が開始されます。

--commit <commit-hash> [--full-history]

Git をリセットし、指定されたコミット以降に変更されたファイルのみの分析を実行します。--full-history オプションと組み合わせると、指定されたコミットから完全な履歴分析が開始されます。

--fail-threshold <string>

品質ゲートとして機能する問題数を設定します。品質ゲートのしきい値に達すると、分析はゼロ以外の終了コードで終了します。

--disable-sanity

qodana.sanity インスペクションプロファイルで構成されたインスペクションをスキップする

-d, --source-directory <string>

分析する必要がある project-dir ディレクトリ内のディレクトリを指定します。指定しない場合は、プロジェクト全体が分析されます。

--repository-root <string>

プロジェクトの VCS ルートディレクトリを指定してください。このオプションは Git 関連の操作に必須です

--only-directory <string>

分析する必要がある project-dir ディレクトリ内のディレクトリを指定します。指定しない場合は、プロジェクト全体が分析されます。

.git や build.gradle などの外部ディレクトリに含まれるファイルとディレクトリは、コードのインスペクション中に Qodana によって使用されます。

-n, --profile-name <string>

プロファイル名を指定

-p, --profile-path <string>

プロファイルファイルへのパスを指定します

--run-promo <true|false>

プロモーションインスペクションを使用する場合はこのオプションを true に設定し、それ以外の場合は false に設定します。デフォルトプロファイルを使用して Qodana を実行する場合、デフォルト値は true です。

--script <string>

Qodana の実行シナリオをオーバーライドします。現在、次の実行シナリオが利用可能です。

シナリオ名	説明
`default`	デフォルトで有効になっているデフォルトの Qodana シナリオ
`php-migration`	PHP バージョンの移行シナリオ
`local-changes`	コミットされていない変更のみを分析します。増分分析の詳細については、増分分析セクションを参照してください。

--coverage-dir <string>

分析用のコードカバレッジデータを含むディレクトリを指定します

--apply-fixes

クリーンアップを含む利用可能なすべてのクイックフィックス戦略を適用します。詳細については、クイックフィックスセクションを参照してください。

--cleanup

CLEANUP クイックフィックス戦略を実行します。詳細についてはクイックフィックスを参照してください

--property <stringArray>

Qodana の実行中に使用する JVM プロパティを設定します。--property property.name=value1,value2,...,valueN 表記を使用します

-s, --save-report

HTML レポートを生成します。このオプションはデフォルトで有効になっています

--timeout int

Qodana 分析時間制限をミリ秒単位で設定します。制限時間に達すると分析は終了し、プロセスは timeout-exit-code コードで終了します。デフォルト設定は 1 です。

--timeout-exit-code <int>

デフォルトの timeout 設定を --timeout オプションで上書きします。timeout オプションで設定されたデフォルト値は 1 です

--diff-start <string>

変更分析で比較の基準となるコミットのハッシュを設定します。

--diff-end <string>

変更分析の終了として機能するコミットのハッシュを設定します。これにより、--diff-start コミットと --diff-end コミットの間で変更されたファイルのみを分析できます。

--reverse

デフォルトの実行シナリオを上書きして、増分分析を逆順に実行します。これにより、増分分析で問題が検出されなかった場合、メインコードベースの分析をスキップできます。

--no-statistics

匿名統計の送信を無効にする

--compile-commands <string>

compile_commands.json ファイルへのパスを指定します。デフォルト値は ./build/compile_commands.json" です

--clang-args <string>

追加の引数を設定します。詳細については C / C++ セクションを参照してください

--solution <string>

ソリューションファイルへの相対パスを設定します。詳細については、.NET セクションを参照してください。

--project <string>

プロジェクトファイルへの相対パスを設定します。詳細については .NET セクションを参照してください

--configuration <string>

ビルド構成を指定します。詳細については .NET セクションを参照してください

--platform <string>

ビルドプラットフォームを指定します。詳細については .NET セクションを参照してください

--no-build

分析の前にプロジェクトの構築をスキップします。詳細については .NET セクションを参照してください

-e, --env <stringArray>

Qodana コンテナーの環境変数を定義します。複数の変数を指定できます。セキュリティ上の理由から、Qodana CLI はホストオペレーティングシステムから環境変数を読み取らないため、Qodana に必要なすべての変数を明示的に指定する必要があります。

-v, --volume <stringArray>

Qodana コンテナーに追加のボリュームを定義します。複数のボリュームを指定できます。例: qodana scan --volume $(pwd)/.qodana/results:/data/results/

-u, --user <string>

Qodana コンテナーを実行するユーザー。ユーザー ID - $UID またはユーザー ID とグループ ID $(id -u):$(id -g) を指定してください。ルートユーザーとして実行するには、root を使用します。デフォルトでは、現在のユーザーに設定されています。

--skip-pull

最新の Qodana コンテナーのプルをスキップする

qodana scan <options> コマンドを使用して、Qodana CLI でこれらのオプションを呼び出すことができます。

分析レポートを Qodana クラウドに送信する

オプション	説明
`-a, --analysis-id <string>`	Qodana Cloud で使用される一意のレポート識別子（GUID）。デフォルト値は `f9d8a78f-f922-452b-8062-a64afc352537` です
`--config <string>`	`qodana.yaml` の代わりにカスタム構成ファイルを設定します。プロジェクトのルートディレクトリからの相対パスを使用します
`-l, --linter <string>`	Qodana Cloud に送信するレポートに使用するリンターをオーバーライドします
`-i, --project-dir <string>`	Qodana Cloud にレポートが送信されるプロジェクトのルートディレクトリ。デフォルト値は `.` です
`-r, --report-dir <string>`	Qodana HTML レポートを保存するディレクトリを上書きします。デフォルト値は `<userCacheDir>/JetBrains/<linter>/results/report` です
`-o, --results-dir <string>`	Qodana レポートの送信元となるディレクトリを上書きします。デフォルト値は `<userCacheDir>/JetBrains/<linter>/results` です

qodana send <options> コマンドを使用して、Qodana CLI でこれらのオプションを呼び出すことができます。

報告の表示

オプション	説明
`--config <string>`	`qodana.yaml` の代わりにカスタム構成ファイルを設定します。プロジェクトのルートディレクトリからの相対パスを使用します
`-d, --dir-only`	レポートディレクトリのみを開き、提供しない
`-l, --linter <string>`	表示するレポートのリンターをオーバーライドする
`-p, --port <int>`	レポートを提供するポートを指定します。デフォルト値は `8080` です
`-i, --project-dir <string>`	レポートを表示するプロジェクトのルートディレクトリ。デフォルト値は `.` です
`-r, --report-dir <string>`	Qodana HTML レポートを保存するディレクトリを上書きします。これは `index.html` ファイルを含むディレクトリです。デフォルト値は `<userCacheDir>/JetBrains/<linter>/results/report` です
`-o, --results-dir <string>`	分析レポートの保存先ディレクトリを上書きします。デフォルト値は `<userCacheDir>/JetBrains/<linter>/results` です

qodana show <options> コマンドを使用して、Qodana CLI でこれらのオプションを呼び出すことができます。

SARIF 形式のファイルを表示する

オプション	説明	デフォルト設定
`-f, --sarif-file <string>`	SARIF 形式のファイルへのパス	`./qodana.sarif.json`

qodana view <options> コマンドを使用して、Qodana CLI でこれらのオプションを呼び出すことができます。

コントリビューターの数を数える

プロジェクトへのコントリビューターに関する情報を収集するには、次のオプションを使用して Qodana を実行できます。

オプション	説明	デフォルト設定
`-d, --days <int>`	アクティブなコントリビューターの数を計算するために使用する過去の日数	90
`-o, --output string`	出力形式。使用可能な値は `tabular` と `json` です	`tabular`
`-i, --project-dir <stringArray>`	複数のプロジェクトをチェックするために複数指定できるプロジェクトのディレクトリ	`.`

qodana contributors <options> コマンドを使用して、Qodana CLI でこれらのオプションを呼び出すことができます。

プロジェクトの統計情報を表示

これらのオプションを使用すると、言語やコード行などのプロジェクトに関する情報を表示できます。

オプション	説明
`-o, --output <string>`	`tabular`、`wide`、`json`、`csv`、`csv-stream`、`cloc-yaml`、`html`、`html-table`、`sql`、`sql-insert`、`openmetrics` 値を受け入れる出力形式。デフォルト設定は `tabular` です
`-i, --project-dir <stringArray>`	プロジェクトディレクトリ。このオプションを複数回指定して、複数のプロジェクトをチェックすることができます。指定しない場合は、現在のディレクトリが使用されます。

qodana cloc <options> コマンドを使用して、Qodana CLI でこれらのオプションを呼び出すことができます。

Qodana イメージをプルする

これらのオプションを使用すると、使用したい Qodana リンターをプルできます。

オプション	説明
`--config <string>`	`qodana.yaml` の代わりにカスタム構成ファイルを設定します。プロジェクトのルートディレクトリからの相対パスを使用します
`--image <string>`	取得したいイメージを指定します
`-l` , `--linter <string>`	取得したいリンターを指定します
`-i` , `--project-dir <string>`	分析対象プロジェクトのルートディレクトリ。指定しない場合は、現在のディレクトリが使用されます。

これらのオプションは、Qodana CLI の qodana pull <options> コマンドを使用して呼び出すことができます。Qodana CLI は、 qodana.yaml ファイル設定または --linter オプションを使用してリンターに関する情報を取得します。

自動補完スクリプトを生成する

これらのオプションを使用すると、特定のシェルの自動補完スクリプトを生成できます。

コマンド	説明
`bash`	bash の自動補完スクリプトを生成する
`fish`	魚の自動補完スクリプトを生成する
`powershell`	PowerShell の自動補完スクリプトを生成する
`zsh`	zsh の自動補完スクリプトを生成する

qodana completion <options> コマンドを使用して、Qodana CLI でこれらのオプションを呼び出すことができます。

更新チェックとログレベルを構成する

オプション	説明
`--disable-update-checks`	Qodana CLI の新しいバージョンに関するチェックと通知を無効にする
`--log-level <string>`	Qodana CLI の出力のログレベルを変更します。例: `--log-level debug` を設定すると、詳細なログレポートを受信できます。デフォルト設定は `error` です。

構成例

リンター内のパス

この表には、Qodana リンターで使用可能なパスがリストされています。

パス	説明
`/data/project`	プロジェクトのルートディレクトリ
`/data/results`	分析レポートを保存するディレクトリ。Qodana を実行する前に空にしておく必要があります
`/opt/idea`	IDE 配布ディレクトリ
`/root/.config/idea`	IDE 構成ディレクトリ
`/data/profile.xml`	`qodana.starter` プロファイル構成を含むデフォルトのプロファイルファイル。このファイルは、プロファイルが CLI または `qodana.yaml` ファイルを通じて以前に設定されていない場合に使用されます。詳細はプロファイルを解決する順序を参照
`/data/project/.idea/inspectionProfiles/`	プロファイルファイルをバインドするディレクトリ
`/data/cache/.m2`	Maven プロジェクトの依存関係
`/root/.m2/`	Maven の `settings.xml` 構成ファイルを上書きするためのディレクトリ
`/data/cache/gradle`	Gradle プロジェクトの依存関係
`/data/cache/nuget`	NuGet プロジェクトの依存関係
`/data/coverage`	コードカバレッジファイルをマッピングするためのディレクトリ

これらのパスを適用する方法の例をいくつか以下に示します。

デフォルトのインスペクションプロファイルをオーバーライドする

デフォルトでは、Qodana は qodana.starter プロファイルを採用しますが、代わりに独自のプロファイルをバインドして使用することもできます。

                        docker run \
                           -v $(pwd):/data/project/ \
                           -v $(pwd)/<profile-file>:/data/profile.xml \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           jetbrains/qodana-<image>
                    

                        qodana scan \
                           -v $(pwd)/<profile-file>:/data/profile.xml \
                           -e QODANA_TOKEN="<cloud-project-token>"
                    

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                     
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: -v <profile-file>:/data/profile.xml
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      -v "${WORKSPACE}"/<profile-file>:/data/profile.xml
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''qodana'''
                                    }
                                }
                            }
                        }
                    

                        include:
                        - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                          inputs:
                             args: |
                                -v <profile-file>:/data/profile.xml
                                --linter <linter>
                    

ランナー設定で、インスペクションプロファイル: ドロップダウンリストからプロファイルパスオプションを選択します。ドロップダウンリストに表示されるフィールドに、プロジェクトルートからの相対パスでプロファイルファイルへのパスを指定します。

プロファイルの詳細については、このドキュメントのプロファイルの解決順序と既存のプロファイルを設定するセクションを参照してください。

Gradle 設定を上書きする

JVM リンターの場合、デフォルトの Gradle 設定をオーバーライドできます。

                        docker run \
                           -v $(pwd):/data/project/ \
                           -v $(pwd)/gradle.properties:/data/cache/gradle/gradle.properties \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           jetbrains/qodana-<image>
                    

                        qodana scan \
                           -v $(pwd)/gradle.properties:/data/cache/gradle/gradle.properties \
                           -e QODANA_TOKEN="<cloud-project-token>"
                    

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: -v gradle.properties:/data/cache/gradle/gradle.properties
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      -v "${WORKSPACE}"/gradle.properties:/data/cache/gradle/gradle.properties
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''qodana'''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      -v gradle.properties:/data/cache/gradle/gradle.properties
                                      --linter <linter>
                    

ランナー設定で、追加の Docker 引数フィールドを見つけて、新しい Gradle 設定を含むファイルへのパスを指定します。

-v gradle.properties:/data/cache/gradle/gradle.properties

Qodana ログの表示

ツールによっては、Qodana によって生成されたログファイルを表示できます。

$(pwd)/.qodana/results/ ディレクトリを Docker イメージの /data/results ディレクトリにマウントできます。

                        docker run \
                           -v $(pwd):/data/project/ \
                           -v $(pwd)/.qodana/results/:/data/results \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           jetbrains/qodana-<image>
                    

Qodana の実行が完了すると、$(pwd)/.qodana/results/ ディレクトリ内のログファイルを表示できます。

Qodana を実行した後、プロジェクトルートで $ qodana show -d コマンドを実行して、ログファイルが含まれるディレクトリを開きます。

/data/results ディレクトリを使用して Qodana の動作を調べるには、いくつかのオプションがあります。

/data/results/projectStructure ディレクトリ。
このディレクトリにある Modules.json ファイルには、Qodana によって検出されたすべてのモジュールのリストが含まれています。これは、IntelliJ IDEA でプロジェクトを開いた際に表示されるリストと一致するはずです。一致しない場合は、Maven の場合は pom.xml ファイル、Gradle 構成の場合は build.gradle ファイルを確認してください。
このディレクトリの SDKs.json ファイルには、Python の場合のインタープリターパスが含まれています。
/data/results/ ディレクトリには、考えられる問題を検出した各インスペクションが ID.json という名前の独自のファイルを作成します。ここで、ID は、qodana.yaml でインスペクションを含めるか除外するために使用できるインスペクション名です。インスペクション ID の完全なリストは、/groups/*/inspections/*/shortName パターンを使用して /data/results/.descriptions.json ファイルで検索できます。
/data/results/log/idea.log では、疑わしい警告を調査できます。

ディレクトリ

これらのオプションを使用すると、Docker イメージパスセクションで説明されているパスをオーバーライドできます。

オプション		デフォルト設定
`--repository-root <string>`	プロジェクトの VCS ルートディレクトリを指定してください。このオプションは Git 関連の操作に必須です	なし
`-i` , `--project-dir`	インスペクション対象プロジェクトのルートディレクトリは、 `--repository-root` のサブディレクトリであるか、 `--repository-root` と同一のディレクトリであるかのいずれかです。外部ディレクトリに含まれるファイルとディレクトリは、Qodana の実行中は使用されません。	`/data/project`
`-o` , `--results-dir`	Qodana インスペクションの結果を保存するディレクトリ	`/data/results`
`-r` , `--report-dir`	生成された HTML レポートを保存するディレクトリ。レポートを開くには、 `--save-report` オプションを追加する必要があります。このオプションは、Qodana CLI では使用できません。	`/data/results/report`
`--cache-dir`	キャッシュを保存するディレクトリ	`/data/cache`
`-d` , `--source-directory`	このオプションは非推奨となり、今後の製品バージョンで削除されます。詳細は `--only-directory` オプションを参照してください。 `--project-dir` 内のディレクトリ。存在しない場合は、プロジェクト全体がインスペクションされます。 `.git` や `build.gradle` などの外部ディレクトリに含まれるファイルとディレクトリは、コードのインスペクション中に Qodana によって使用されます。	なし
`--only-directory <string>`	分析する必要がある `project-dir` ディレクトリ内のディレクトリを指定します。指定しない場合は、プロジェクト全体が分析されます。 `.git` や `build.gradle` などの外部ディレクトリに含まれるファイルとディレクトリは、コードのインスペクション中に Qodana によって使用されます。	なし

レポートディレクトリを上書きする

この Docker コマンドは、--report-dir オプションを使用してデフォルトのレポートディレクトリをオーバーライドし、 --save-report オプションを使用して生成されたレポートをローカルファイルシステムに保存します。

            docker run \
               -v $(pwd):/data/project/ \
               -v <html-report-directory>:/data/results/newreportdir/ \
               -e QODANA_TOKEN="<cloud-project-token>" \
               jetbrains/qodana-<image> \
               --report-dir /data/results/newreportdir/ \
               --save-report
        

生成されたレポートは、このコマンドの -v <html-report-directory>:/data/results/newreportdir/ 行で設定されたとおりにローカルファイルシステムに保存されます。

リポジトリ内の特定のプロジェクトディレクトリを分析する

一般的なプロジェクト構造は、次のようなディレクトリ構造になります。

            repo/
            .git/
            project/
            ...
        

ここで、repo/.git ディレクトリには Qodana がアクセスできる情報が含まれており、repo/project ディレクトリには Qodana がインスペクションする必要があるプロジェクトが含まれています。これらのサンプルはすべて、 --project-dir オプションを使用して repo/project ディレクトリをマウントしますが、QODANA_TOKEN 変数は Qodana クラウドプロジェクトトークンを参照します。

                    docker run \
                    -v repo/:/data/project/ \
                    -e QODANA_TOKEN="<cloud-project-token>" \
                    jetbrains/qodana-<image> \
                    --project-dir=/data/project/project/
                

                    qodana scan \
                    -e QODANA_TOKEN="<cloud-project-token>" \
                    --project-dir=/data/project/project/
                

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches:
                                - main
                                - 'releases/*'

                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: --project-dir project
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

キャッシュの依存関係

解析間でキャッシュを保持することで、Qodana のパフォーマンスを向上させることができます。例: Maven、Gradle、npm、Yarn、NuGet などのパッケージおよび依存関係管理ツールは、ダウンロードした依存関係のローカルキャッシュを保持します。

デフォルトでは、Qodana はコンテナー内の /data/cache ディレクトリにキャッシュを保存します。 --cache-dir オプションを使用して、この場所をオーバーライドできます。このデータはリポジトリごとであるため、branch-a からビルドチェック branch-b にキャッシュを渡すことができます。この場合、新しい依存関係が追加された場合のみダウンロードされます。

GitHub ワークフローでは、依存関係キャッシュ(英語)を使用できます。GitLab CI/CD には、プロジェクトディレクトリ内にのみ(英語)保存できるキャッシュ(英語)もあります。この場合、 qodana.yaml を介してインスペクションからキャッシュディレクトリを除外できます。

このコマンドは、ローカルディレクトリを Docker イメージの /data/cache ディレクトリにマップし、キャッシュをローカルファイルシステムに保存します。

                docker run \
                   -v $(pwd):/data/project/ \
                   -v <local-cache-directory>:/data/cache/ \
                   -e QODANA_TOKEN="<cloud-project-token>" \
                   jetbrains/qodana-<image>
            

--cache-dir オプションを使用すると、キャッシュディレクトリをオーバーライドできます。

                        docker run \
                           -v $(pwd):/data/project/ \
                           -v <local-cache-directory>:/data/newcachedir/ \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           jetbrains/qodana-<image> \
                           --cache-dir /data/newcachedir
                    

                        qodana scan \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           --cache-dir /opt/newcachedir
                    

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: --cache-dir /data/newcachedir
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana \
                                        --cache-dir /data/newcachedir
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      --cache-dir /data/newcachedir
                                      --linter <linter>
                    

ランナー設定で、追加の Qodana 引数フィールドを見つけて、キャッシュディレクトリへのパスを指定します。

--cache-dir /data/newcachedir

プロファイル

デフォルトでは、Qodana は qodana.starter プロファイルを使用してコードをインスペクションします。

Qodana プロファイルは、 qodana.yaml ファイル内、またはこの表のオプションを使用して構成および上書きできます。

オプション	説明	デフォルト設定
`--disable-sanity`	`qodana.sanity` プロファイルによって構成されたインスペクションの実行をスキップします	有効
`-n` , `--profile-name`	定義済み Qodana プロファイルのリストにあるプロファイル名、または XML 形式のプロファイルファイルに `<option name="myName" value="%profileName%"/>` として保存されているカスタムプロファイルのプロファイル名。 `qodana.yaml` ファイルを使用してこのオプションを構成することもできます	`qodana.starter`
`-p` , `--profile-path`	プロファイルファイルへの絶対パス。 `qodana.yaml` ファイルを使用してこのオプションを構成することもできます	なし
`--run-promo`	`qodana.starter` プロファイルの一部としてプロモーションインスペクションを実行するこのオプションは、.NET 用 Qodana リンターでは使用できません。	Qodana が `qodana.starter` プロファイル用に構成されており、`--run-promo true` オプションが呼び出された場合にのみ有効になります。

プロファイル名

--profile-name オプションを使用すると、デフォルトのプロファイルまたはカスタムプロファイルのプロファイル名を使用して Qodana を実行できます。

このコマンドを使用すると、デフォルトのプロファイルをオーバーライドし、 qodana.recommended プロファイルを使用して Qodana を実行できます。

                        docker run \
                           -v $(pwd):/data/project/ \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           jetbrains/qodana-<image> \
                           --profile-name qodana.recommended
                    

                        qodana scan \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           --profile-name qodana.recommended
                    

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: --profile-name qodana.recommended
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana \
                                        --profile-name qodana.recommended
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      --profile-name qodana.recommended
                                      --linter <linter>
                    

ランナー設定で、追加の Qodana 引数フィールドを見つけて、プロファイル名を指定します。

--profile-name qodana.recommended

カスタムプロファイルで Qodana を実行するには、実際のプロファイル名を使用します。

次のようにカスタムプロファイルをバインドできます。

                        docker run \
                           -v $(pwd):/data/project/ \
                           -v <path-to-profile-file>/<file-name>:/data/project/.idea/inspectionProfiles/<file-name> \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           jetbrains/qodana-<image> \
                           --profile-name <profile-name-from-file>
                    

                        qodana scan \
                           -v <path-to-profile-file>/<file-name>:/data/project/.idea/inspectionProfiles/<file-name> \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           --profile-name <profile-name-from-file>
                    

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: --profile-name <profile-name-from-file>
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana \
                                        --profile-name <profile-name-from-file>
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      --profile-name <profile-name-from-file>
                                      --linter <linter>
                    

ランナー設定で、追加の Qodana 引数フィールドを見つけて、カスタムプロファイル名を指定します。

--profile-name <profile-name-from-file>

プロファイルパス

--profile-path オプションを使用すると、プロファイルを含むファイルへのパスをオーバーライドできます。

このコマンドを使用すると、ファイルをプロファイルディレクトリにバインドでき、--profile-path オプションは、どのプロファイルファイルを読み取るかを Qodana に指示します。

                        docker run \
                           -v $(pwd):/data/project/ \
                           -v <path-to-profile-file>/<file-name>:/data/project/myprofiles/<file-name> \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           jetbrains/qodana-<image> \
                           --profile-path /data/project/myprofiles/<file-name>
                    

                        qodana scan \
                           -v <path-to-profile-file>/<file-name>:/data/project/myprofiles/<file-name> \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           --profile-path /data/project/myprofiles/<file-name>
                    

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: --profile-path /data/project/myprofiles/<file-name>
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana \
                                        --profile-path /data/project/myprofiles/<file-name>
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      --profile-path /data/project/myprofiles/<file-name>
                                      --linter <linter>
                    

ランナー設定で、追加の Qodana 引数フィールドを見つけて、カスタムプロファイルのパスを指定します。

--profile-path /data/project/myprofiles/<file-name>

カスタム構成ファイル

プロジェクトには、YAML 形式のファイルに含まれる複数の Qodana 構成を含めることができます。これは、モノレポプロジェクトを分析したり、単一の CI ジョブを実行したりする場合に役立ちます。

--config オプションと、プロジェクトルートからの相対的なファイルへのパスを使用できます。

                    docker run \
                       -v $(pwd):/data/project \
                       -e QODANA_TOKEN="<cloud-project-token>" \
                       jetbrains/qodana-<image> \
                       --config relative/path/to/config.yaml
                

                qodana scan \
                   -e QODANA_TOKEN="<cloud-project-token>" \
                   --config relative/path/to/config.yaml
                

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: --config relative/path/to/config.yaml
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana \
                                        --config relative/path/to/config.yaml
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      --config relative/path/to/config.yaml
                                      --linter <linter>
                    

ランナー設定で、追加の Qodana 引数フィールドを見つけて、カスタム設定ファイルへのパスを指定します。

--config relative/path/to/config.yaml

ベースライン

ベースライン実行モードでは、新しい Qodana 実行がそれぞれ初期実行と比較されます。これは、古い問題を修正する可能性がなく、新しい問題の発生を防ぎたい場合に役立ちます。

ベースライン機能を使用するには、まず Qodana を実行し、レポート UI でベースラインと見なされる問題を選択します。最後に、ベースライン問題を含む SARIF 形式のファイルを保存します。

これはベースライン関連のオプションのリストです。

オプション	説明
`-b` , `--baseline`	Qodana をベースラインモードで実行します。ベースライン状態の計算で使用される既存の SARIF レポートへのパスを指定します
`--baseline-include-absent`	現在の分析では欠落しているベースライン実行の結果を出力レポートに含める

このコマンドは、すべてのベースラインオプションを呼び出します。

                    docker run \
                       -v $(pwd):/data/project/ \
                       -e QODANA_TOKEN="<cloud-project-token>" \
                       jetbrains/qodana-<image> \
                       --baseline <path-to-the-SARIF-file> \
                       --baseline-include-absent
                

                    qodana scan \
                       -e QODANA_TOKEN="<cloud-project-token>" \
                       --baseline <path-to-the-SARIF-file> \
                       --baseline-include-absent
                

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: |
                                          --baseline <path-to-the-SARIF-file>
                                          --baseline-include-absent
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana \
                                        --baseline <path-to-the-SARIF-file> \
                                        --baseline-include-absent
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      --baseline <path-to-the-SARIF-file>
                                      --baseline-include-absent --linter <linter>
                    

ランナー設定で、追加の Qodana 引数フィールドを見つけてベースラインを設定します。

--baseline <path-to-the-SARIF-file> --baseline-include-absent --linter <linter>

ここで、<path-to-the-SARIF-file> はプロジェクトルートを基準とした qodana.sarif.json ファイルへのパスであり、以前の Qodana 実行から取得されます。--baseline-include-absent が呼び出されると、インスペクションの結果には、存在しない問題、またはベースライン実行でのみ検出され、現在の実行では検出されなかった問題が含まれます。

この実行に基づいて、SARIF 出力レポートにはベースライン状態に関する問題ごとの情報が含まれます。

コードカバレッジ

コードカバレッジファイルを含むディレクトリを Qodana リンターイメージの /data/coverage ディレクトリにマッピングすることで、コードカバレッジを実行できます。

                    docker run \
                       -v /my/dir/with/coverage:/data/coverage \
                       -e QODANA_TOKEN="<cloud-project-token>" \
                       jetbrains/qodana-<image>
                

                    qodana scan \
                       -v /my/dir/with/coverage:/data/coverage \
                       -e QODANA_TOKEN="<cloud-project-token>"
                

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: -v /my/dir/with/coverage:/data/coverage
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana \
                                        -v /my/dir/with/coverage:/data/coverage
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      -v /my/dir/with/coverage:/data/coverage
                                      --linter <linter>
                    

ランナー設定で、追加の Docker 引数フィールドを見つけて、コードカバレッジの結果を含むファイルへのパスを指定します。

-v /my/dir/with/coverage:/data/coverage

レポート

この表には、レポートに関連するオプションが含まれています。

オプション	説明
`-s` , `--save-report`	HTML 形式のレポートを生成して保存する
`-w` , `--show-report`	HTML 形式のレポートを提供します。デフォルトでは、ポート `8080` が使用されます

レポートを保存する

Docker コマンドの --save-report オプションを使用すると、生成された HTML レポートをローカルファイルシステムに保存できます。

                docker run \
                   -v $(pwd):/data/project/ \
                   -v <directory-to-save-report-to>:/data/results/report \
                   -e QODANA_TOKEN="<cloud-project-token>" \
                   jetbrains/qodana-<image> \
                   --save-report
            

レポートを表示する

このコマンドはホストマシンのポート 4040 で Web サーバーを実行するため、レポートは http://localhost:4040 で利用できるようになります。

                        docker run \
                           -p 4040:8080 \
                           -v $(pwd):/data/project/ \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           jetbrains/qodana-<image> \
                           --show-report
                    

                        qodana scan \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           --port 4040 \
                           --show-report
                    

あるいは、プロジェクトルートで qodana show コマンドを実行できます。

Web サーバーを停止するには、Docker コンソールで Ctrl-C を押します。

クオリティゲート

Qodana を使用すると、しきい値として機能する品質ゲートまたは問題の数を構成できます。しきい値を超えると、インスペクションの実行は終了します。

オプション	説明
`--fail-threshold`	品質ゲートとして機能する問題数を設定します

以下は、問題の数が 10 を超えた場合にビルドを失敗するように Qodana に指示するコマンドです。

                    docker run \
                       -v $(pwd):/data/project/ \
                       -e QODANA_TOKEN="<cloud-project-token>" \
                       jetbrains/qodana-<image> \
                       --fail-threshold 10
                

                    qodana scan \
                       -e QODANA_TOKEN="<cloud-project-token>" \
                       --fail-threshold 10
                

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: --fail-threshold 10
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana \
                                        --fail-threshold 10
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      --fail-threshold 10
                                      --linter <linter>
                    

ランナー設定で、追加の Qodana 引数フィールドを見つけて品質ゲートを指定します。

--fail-threshold 10

ベースラインモードを有効にして Qodana を実行すると、しきい値は新しい問題と存在しない問題の合計として計算されます。変更されていない結果は無視されます。

クイックフィックス

クイックフィックス戦略をコードベースに適用するには、--fixes-strategy オプションを呼び出します。

                    docker run \
                       -v <source-directory>/:/data/project/ \
                       -e QODANA_TOKEN="<cloud-project-token>" \
                       jetbrains/qodana-<image> \
                       --fixes-strategy <cleanup/apply>
                

                    qodana scan \
                       -e QODANA_TOKEN="<cloud-project-token>" \
                       <--apply-fixes/--cleanup>
                

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: <--apply-fixes/--cleanup>
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana \
                                        --fixes-strategy <--apply-fixes/--cleanup>
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      <--apply-fixes/--cleanup>
                                      --linter <linter>
                    

ランナー設定で、追加の Qodana 引数フィールドを見つけて、優先するクイックフィックス戦略を指定します。

<--apply-fixes/--cleanup>

Properties

--property= オプションを使用すると、さまざまな Qodana パラメーターをオーバーライドできます。

STDOUT へのメッセージのログ記録
ユーザー統計の無効化
プラグインの構成
設定タイムアウトの設定

オプション	説明
`--property=`	次の表記を使用して JVM プロパティを設定します。 --property=property.name=value1,...,valueN このオプションは、複数の JVM プロパティを設定するために複数回繰り返すことができます。

オプション

説明

--property=

次の表記を使用して JVM プロパティを設定します。

--property=property.name=value1,...,valueN

このオプションは、複数の JVM プロパティを設定するために複数回繰り返すことができます。

INFO メッセージを STDOUT に記録する

STDOUT のデフォルトのログレベルは WARN です。idea.log.config.file プロパティを使用してオーバーライドできます。

                        docker run \
                           -v $(pwd):/data/project/ \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           jetbrains/qodana-<image> \
                           --property=idea.log.config.file=info.xml
                    

                        qodana scan \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           --property=idea.log.config.file=info.xml
                    

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: --property=idea.log.config.file=info.xml
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana \
                                        --property=idea.log.config.file=info.xml
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      --property=idea.log.config.file=info.xml
                                      --linter <linter>
                    

ランナー設定で、追加の Qodana 引数フィールドを見つけて、優先するクイックフィックス戦略を指定します。

--property=idea.log.config.file=info.xml

ユーザー統計を無効にする

使用状況統計のレポートを無効にするには、--property オプションの idea.headless.enable.statistics 値を調整します。

                        docker run \
                           -v $(pwd):/data/project/ \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           jetbrains/qodana-<image> \
                           --property=idea.headless.enable.statistics=false
                    

                        qodana scan \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           --property=idea.headless.enable.statistics=false
                    

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: --property idea.headless.enable.statistics=false
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana \
                                        --property=idea.headless.enable.statistics=false
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      --property idea.headless.enable.statistics=false
                                      --image <image>
                    

ランナー設定で、追加の Qodana 引数フィールドを見つけて、必要なプロパティを指定します。

--property=idea.headless.enable.statistics=false

プラグインの構成

idea.required.plugins.id および idea.suppressed.plugins.id プロパティを使用すると、特定の実行に必要なプラグインと、抑制されるプラグインのリストを指定できます。

                        docker run \
                           -v $(pwd):/data/project/ \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           jetbrains/qodana-<image> \
                           --property=idea.required.plugins.id=JavaScript,org.intellij.grails \
                           --property=idea.suppressed.plugins.id=com.intellij.spring.security
                    

                        qodana scan \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           --property=idea.required.plugins.id=JavaScript,org.intellij.grails \
                           --property=idea.suppressed.plugins.id=com.intellij.spring.security
                    

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: |
                                          --property=idea.required.plugins.id=JavaScript,org.intellij.grails
                                          --property=idea.suppressed.plugins.id=com.intellij.spring.security
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana \
                                        --property=idea.required.plugins.id=JavaScript,org.intellij.grails \
                                        --property=idea.suppressed.plugins.id=com.intellij.spring.security
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      --property=idea.required.plugins.id=JavaScript,org.intellij.grails
                                      --property=idea.suppressed.plugins.id=com.intellij.spring.security
                                      --image <image>
                    

ランナー設定で、追加の Qodana 引数フィールドを見つけて、必要なプロパティを指定します。

                           --property=idea.required.plugins.id=JavaScript,org.intellij.grails \
                           --property=idea.suppressed.plugins.id=com.intellij.spring.security
                    

設定タイムアウトの設定

以下のプロパティを使用すると、設定ステージのタイムアウトを設定できます。

プロパティ	リンターで使用可能
`qd.cpp.startup.timeout.minutes`	Qodana は C/C++ 向け、Qodana コミュニティは C/C++ 向けです。
`qd.rust.configuration.timeout.minutes`	Rust 用 Qodana

以下に、プロパティの使用例を示します。

            name: Qodana
            on:
                workflow_dispatch:
                pull_request:
                push:
                    branches: # Specify your branches here
                        - main # The 'main' branch
                        - 'releases/*' # The release branches
            jobs:
                qodana:
                    runs-on: ubuntu-latest
                    permissions:
                        contents: write
                        pull-requests: write
                        checks: write
                    steps:
                        - uses: actions/checkout@v3
                          with:
                              ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                              fetch-depth: 0  # a full history is required for pull request analysis
                        - name: 'Qodana Scan'
                          uses: JetBrains/qodana-action@v2026.1
                          with:
                              args: --property qd.<cpp|rust>.startup.timeout.minutes=10
                          env:
                              QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
        

                      qodana scan \
                         -e QODANA_TOKEN="<cloud-project-token>" \
                         --linter <linter> \
                         --property qd.<cpp|rust>.configuration.timeout.minutes=10
                    

                    docker run \
                       -v $(pwd):/data/project/ \
                       -e QODANA_TOKEN="<cloud-project-token>" \
                       jetbrains/qodana-<image> \
                       --property qd.<cpp|rust>.configuration.timeout.minutes=10
                

変化の分析

オプション	説明
`--diff-start` および `--diff-end`	マージやプルリクエストなどの変更セットに対して増分分析を実行する

作業を終えて変更を分析したい場合は、--diff-start オプションを使用して、比較のベースとなるコミットのハッシュを指定できます。詳細については、増分分析セクションを参照してください。

                    docker run \
                       -v $(pwd):/data/project/ \
                       -e QODANA_TOKEN="<cloud-project-token>" \
                       jetbrains/qodana-<image> \
                       --diff-start=<GIT_START_HASH>
                

                    qodana scan \
                       -e QODANA_TOKEN="<cloud-project-token>" \
                       --diff-start=<GIT_START_HASH>
                

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: --diff-start=<GIT_START_HASH>
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana \
                                        --diff-start=<GIT_START_HASH>
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      --diff-start=<GIT_START_HASH>
                                      --image <image>
                    

ランナー設定で、追加の Qodana 引数フィールドを見つけてコミットハッシュを指定します。

--diff-start=<GIT_START_HASH>

2 つのコミット間の変更セットを分析するには、--diff-start と --diff-end の両方のオプションを使用します。

                    docker run \
                       -v $(pwd):/data/project/ \
                       -e QODANA_TOKEN="<cloud-project-token>" \
                       jetbrains/qodana-<image> \
                       --diff-start=<GIT_START_HASH> \
                       --diff-end=<GIT_END_HASH>
                

                    qodana scan \
                       -e QODANA_TOKEN="<cloud-project-token>" \
                       --diff-start=<GIT_START_HASH> \
                       --diff-end=<GIT_END_HASH>
                

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: |
                                          --diff-start=<GIT_START_HASH>
                                          --diff-end=<GIT_END_HASH>
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana \
                                        --diff-start=<GIT_START_HASH> \
                                        --diff-end=<GIT_END_HASH>
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      --diff-start=<GIT_START_HASH>
                                      --diff-end=<GIT_END_HASH>
                                      --image <image>
                    

ランナー設定で、追加の Qodana 引数フィールドを見つけてコミットハッシュを指定します。

--diff-start=<GIT_START_HASH> --diff-end=<GIT_END_HASH>

シナリオの実行

オプション	説明	デフォルト設定
`--script`	デフォルトの実行シナリオをオーバーライドする	`default`

default 実行シナリオの適用は、次のコマンドを実行することと同じです。

                    docker run \
                       -v $(pwd):/data/project/ \
                       -e QODANA_TOKEN="<cloud-project-token>" \
                       jetbrains/qodana-<image> \
                       --script default
                

                    qodana scan \
                       -e QODANA_TOKEN="<cloud-project-token>" \
                       --script default
                

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: --script default
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana \
                                        --script default
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      --script default
                                      --image <image>
                    

ランナー設定で、追加の Qodana 引数フィールドを見つけて、優先する実行シナリオを指定します。

--script default

PHP バージョンの移行シナリオの場合は、次のコマンドを使用します。

                    docker run \
                       -v $(pwd):/data/project/ \
                       -e QODANA_TOKEN="<cloud-project-token>" \
                       jetbrains/qodana-<image> \
                       --script php-migration:<old-php-version>−to−<upgraded-php-version>
                

                    qodana scan \
                       -e QODANA_TOKEN="<cloud-project-token>" \
                       --script php-migration:<old-php-version>−to−<upgraded-php-version>
                

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: --script php-migration:<old-php-version>−to−<upgraded-php-version>
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana \
                                        --script,php-migration:<old-php-version>−to−<upgraded-php-version>
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      --script php-migration:<old-php-version>−to−<upgraded-php-version>
                                      --image <image>
                    

ランナー設定で、追加の Qodana 引数フィールドを見つけて、PHP バージョン移行実行シナリオを指定します。

--script php-migration:<old-php-version>−to−<upgraded-php-version>

ヒープサイズを変更する

デフォルトでは、ヒープサイズはホスト RAM の 80% に設定されています。この設定は、_JAVA_OPTIONS 変数を使用して構成できます。

                        docker run \
                           -v $(pwd):/data/project/ \
                           -e _JAVA_OPTIONS=-Xmx6g \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           jetbrains/qodana-<image>
                    

                        qodana scan \
                           -e _JAVA_OPTIONS=-Xmx6g \
                           -e QODANA_TOKEN="<cloud-project-token>"
                    

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: -e _JAVA_OPTIONS=-Xmx6g
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      -e _JAVA_OPTIONS=-Xmx6g
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      -e _JAVA_OPTIONS=-Xmx6g
                                      --image <image>
                    

ランナー設定で、追加の Docker 引数フィールドを見つけて、_JAVA_OPTIONS 変数を使用してヒープサイズを設定します。

-e _JAVA_OPTIONS=-Xmx6g

ヒープの構成の詳細については、Oracle ドキュメントのヒープチューニングパラメーター(英語)を参照してください。

idea.properties ファイルをオーバーライドする

idea.properties は、IDE ファイルのデフォルトの場所を構成します。

IDEA_PROPERTIES 変数を使用して idea.properties ファイルをオーバーライドできます。

                        docker run \
                           -v $(pwd):/data/project/ \
                           -e IDEA_PROPERTIES=/data/project/idea.properties \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           jetbrains/qodana-<image>
                    

                        qodana scan \
                           -e IDEA_PROPERTIES=/data/project/idea.properties \
                           -e QODANA_TOKEN="<cloud-project-token>"
                    

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: -e IDEA_PROPERTIES=/data/project/idea.properties
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      -e IDEA_PROPERTIES=/data/project/idea.properties
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      -e IDEA_PROPERTIES=/data/project/idea.properties
                                      --image <image>
                    

ランナー設定で、追加の Docker 引数フィールドを見つけて、IDEA_PROPERTIES 変数を設定します。

-e IDEA_PROPERTIES=/data/project/idea.properties

ルートユーザーと非ルートユーザーを設定する

デフォルトでは、Docker コンテナーは root ユーザーで実行されるため、Qodana はプロジェクト情報を読み取り、インスペクション結果を書き込むことができます。実行後、results/ ディレクトリ内のすべてのファイルは root ユーザーによって所有されます。

これを解決するには、コンテナーを通常のユーザーとして実行します。

                        docker run \
                        -u $(id -u):$(id -g) \
                        -v $(pwd):/data/project/ \
                        -v <results-directory>:/data/results/ \
                        -e QODANA_TOKEN="<cloud-project-token>" \
                        jetbrains/qodana-<image>
                    

この場合、ホスト上の results/ ディレクトリはすでに作成され、所有されている必要があります。そうでない場合、Docker は root ユーザーとしてそれを作成し、Qodana はそれに書き込むことができません。

TeamCity および Qodana CLI(英語) は、現在の非 root ユーザーを使用して Qodana を実行します。 bootstrap セクションで起動した apt ツールを使用して依存関係をインストールする場合、これは不便な場合があります。

TeamCity で Qodana を root ユーザーとして実行するには、Qodana ランナー構成の追加の Docker 引数フィールドに -u root オプションを追加します。

Qodana CLI を root ユーザーとして実行するには、qodana scan コマンドに -u root オプションを追加します。

qodana scan -u root

                    name: Qodana
                    on:
                        workflow_dispatch:
                        pull_request:
                        push:
                            branches: # Specify your branches here
                                - main # The 'main' branch
                                - master # The 'master' branch
                                - 'releases/*' # The release branches
                         
                    jobs:
                        qodana:
                            runs-on: ubuntu-latest
                            permissions:
                                contents: write
                                pull-requests: write
                                checks: write
                            steps:
                                - uses: actions/checkout@v3
                                  with:
                                      ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
                                      fetch-depth: 0  # a full history is required for pull request analysis
                                - name: 'Qodana Scan'
                                  uses: JetBrains/qodana-action@v2026.1
                                  with:
                                      args: -u root
                                  env:
                                      QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
                

                        pipeline {
                            environment {
                                QODANA_TOKEN=credentials('qodana-token')
                            }
                            agent {
                                docker {
                                    args '''
                                      -v "${WORKSPACE}":/data/project
                                      -u root
                                      --entrypoint=""
                                      '''
                                    image 'jetbrains/qodana-<image>'
                                }
                            }
                            stages {
                                stage('Qodana') {
                                    steps {
                                        sh '''
                                        qodana
                                        '''
                                    }
                                }
                            }
                        }
                    

                        include:
                            - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.1
                              inputs:
                                  args: |
                                      -u root
                                      --image <image>
                    

Git サブモジュール

SSH 経由でアクセスされる Git サブモジュールを使用するリポジトリを分析するには、Qodana Docker コンテナー内で Git 操作を認証する必要があります。この場合、以下のコードスニペットに示すように、SSH エージェントを設定し、サブモジュールへのアクセス権を持つ SSH キーをコンテナーに渡す必要があります。

                        docker run \
                           -v $(pwd):/data/project/ \
                           -v "$SSH_AUTH_SOCK:/tmp/ssh_agent.sock" \
                           -e SSH_AUTH_SOCK=/tmp/ssh_agent.sock \
                           -e GIT_SSH_COMMAND="ssh -o StrictHostKeyChecking=no" \
                           jetbrains/qodana-<image> \
                           --diff-start=<GIT_START_HASH>
                    

このコマンドには以下のオプションが含まれています。

オプション	説明
`-v "$SSH_AUTH_SOCK:/tmp/ssh_agent.sock"`	SSH エージェントソケットをコンテナーにマウントします
`-e SSH_AUTH_SOCK=/tmp/ssh_agent.sock`	SSH エージェントソケット環境変数を設定します
`-e GIT_SSH_COMMAND="ssh -o StrictHostKeyChecking=no"`	SSH 操作における厳密なホスト鍵チェックを無効にする
`--diff-start=<GIT_START_HASH>`	コミットハッシュについては、プルリクエストとマージリクエストを分析する章を参照してください。

                        qodana scan \
                           -v "$SSH_AUTH_SOCK:/tmp/ssh_agent.sock" \
                           -e SSH_AUTH_SOCK=/tmp/ssh_agent.sock \
                           -e GIT_SSH_COMMAND="ssh -o StrictHostKeyChecking=no" \
                           -e QODANA_TOKEN="<cloud-project-token>" \
                           --diff-start=<GIT_START_HASH>
                    