構成リファレンス

導入

Qodana は、YAML またはコマンドライン（CLI）オプションを使用して設定できます。

プロジェクトのルートディレクトリに格納された、通常 qodana.yaml という名前の YAML 形式のファイルを使用して Qodana を設定する方法は、長いコマンドを必要とする設定に適しています。例: インスペクションの設定、ブートストラップ、および他の方法では設定しにくいその他の設定。YAML 設定を保存すれば、Qodana の異なるインスタンス間で再利用できます。

CLI オプションは、Docker エンジン、Qodana CLI、IDE、CI/CD ツールなど、Qodana を実行するアプリケーションの即時設定に適しています。ただし、一部の CLI オプションには YAML 形式の同等の記述がありません。

リンターと品質ゲートは、YAML と CLI の両方で設定できます。両方の方法を使用する場合は、CLI オプションが YAML オプションよりも優先されます。

YAML 設定

デフォルトでは、この設定機能は qodana.yaml 設定と呼ばれます。まず、プロジェクトのルートディレクトリに qodana.yaml ファイルを保存してください。

qodana.yaml ファイル名とその場所を変更するには、YAML 設定ファイルを上書きする章の推奨事項に従ってください。

qodana.yaml の JSON スキーマは、IDE での補完と基本的な検証を提供する SchemaStore(英語) プロジェクトで公開されています。

CLI オプション

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

オプション型	サンプル
オプション名とその引数の間に等号 (`=`) が必要です	`--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.2
                      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.2
                  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
        

カスタムコマンドを実行する

分析中に、Qodana リンターは、JVM、.NET、Golang に関連するリンターがビルドシステムとプロジェクト構造を自動的に特定しようと試みるにもかかわらず、一部のインスペクションがクラス、パッケージ、ファイルを見つけられない、参照を解決できないと報告する場合があります。

CI/CD プラットフォーム上で Qodana を実行する場合、プロジェクトの依存関係は通常自動的にインストールされないため、自分で依存関係をインストールする必要がある場合があります。このような場合、Qodana には少し手サポートが必要です。

サードパーティのパッケージまたはライブラリをインストールする
ビルド環境をセットアップするプログラムを実行する

これらの操作は bootstrap キーを使用して実行されます。

version: "1.0"

linter: <linter>

bootstrap: |+
  set -eu
  # For PHP projects that use Laravel:
  #composer require --dev barryvdh/laravel-ide-helper

  # For JavaScript projects that use Node.js:
  #npm install

  # For Python projects
  #pip install -r requirements.txt 

IDE で構文のハイライトと検証を使用できるようにするには、prepare-qodana.sh シェルスクリプトを作成し、プロジェクトのルートディレクトリに保存します。

#! /bin/sh

set -eu

# For PHP projects that use Laravel:
#composer require --dev barryvdh/laravel-ide-helper

# For JavaScript projects that use Node.js:
#npm install

bootstrap キーを使用して、Qodana Docker コンテナーでスクリプトを実行します。

bootstrap: sh ./prepare-qodana.sh

Qodana を root ユーザーとして実行するには、--user=root オプションを呼び出す必要がある場合があります。

GitLab CI/CD のような CI/CD 環境では、分析を開始する前に複雑な環境を準備する必要がある場合があります。以下は、frontend ディレクトリ（Node.js）と backend ディレクトリ（C#）を含むモノレポ構成の例です。

version: "1.0"

linter: qodana-dotnet

bootstrap: |+
  set -eu

  # Install frontend dependencies
  echo "Installing frontend dependencies..."
  cd frontend && npm install && cd ..

  # Build backend C# projects
  echo "Building C# projects..."
  dotnet restore backend/MySolution.sln
  dotnet build backend/MySolution.sln --no-restore

モノレポプロジェクトのセクションもご覧いただけます。

リンターを指定する

linter YAML キーを使用すると、使用するリンターを指定できます。例:

version: "1.0"

linter: qodana-jvm-android

あるいは、以下に示すように、--linter CLI オプションを使用することもできます。

            docker run \
               -v $(pwd):/data/project/ \
               -e QODANA_TOKEN="&lt;cloud-project-token&gt;" \
               jetbrains/qodana-&lt;image&gt; \
               --linter <linter>
        

            qodana scan \
               -e QODANA_TOKEN="&lt;cloud-project-token&gt;" \
               --linter <linter>
        

            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.2
                          with:
                              args: --linter <linter>
                          env:
                              QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
        

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

                include:
                    - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.2
                      inputs:
                          args: |
                              --linter <linter>
            

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

--linter <linter>

ネイティブモードを構成する

ネイティブモードでは、Docker エンジンを使用せずに 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 コミュニティ

リンターを指定することでネイティブモードを構成できます。また、withinDocker 設定を false に設定することもできます。

YAML 形式の設定の場合、以下のような形式になります。

version: "1.0"

linter: <linter-name>

withinDocker: false # Setting Docker mode to false

--linter および --within-docker false の CLI オプションを使用すると、ネイティブモードを設定することもできます。

            qodana scan \
               -e QODANA_TOKEN="<cloud-project-token>" \
               --linter <linter> \
               --within-docker 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.2
                          with:
                              args: |
                                --linter <linter>
                                --within-docker false
                          env:
                              QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
        

YAML 設定ファイルを上書きする

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

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

            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.2
                          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.2
                      inputs:
                          args: |
                              --config relative/path/to/config.yaml
                              --linter <linter>
            

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

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

インスペクションプロファイル:

デフォルトでは、Qodana は qodana.starter プロファイルを使用してコードを解析します。既存の Qodana プロファイルの章で説明されている推奨事項に従って、別の既存のプロファイルに切り替えることができます。独自のプロファイルを設定するには、カスタムプロファイルの章で説明されている利用可能な構成オプションを使用してください。

YAML 設定

profile YAML キーを使用すると、専用ファイルから既存の設定をインポートできるだけでなく、インポート後に設定をカスタマイズすることもできます。

profile.path キーを使用して、名前で既存のプロファイルを呼び出します。例:

        version: "1.0"

        linter: <linter>
    
        profile:
            name: qodana.recommended
            inspections: # Configuring the invoked profile
                — group: "category:Java/Probable bugs"
                  enabled: true # Enabling the inspection category
                — inspection: RedundantIf
                  enabled: false # Disabling the inspection
        
    

インスペクションプロファイルセクションに従って専用ファイルにプロファイルを設定した後、profile.path キーを使用して qodana.yaml ファイルでそれを呼び出すことができます。例:

        version: "1.0"
        
        linter: <linter>
    
        profile:
            path: .qodana/profiles/<custom-profile.yaml>
            inspections: # Configuring the invoked profile
                — group: "category:Java/Probable bugs"
                  enabled: true # Enabling the inspection category
                — inspection: RedundantIf
                  enabled: false # Disabling the inspection
        
    

CLI オプション

以下のプロファイル関連の CLI オプションを使用できます。

オプション	説明	デフォルト設定
`--disable-sanity`	`qodana.sanity` プロファイルによって構成されたインスペクションの実行をスキップします	有効
`-n` , `--profile-name`	既存の Qodana プロファイルのリストからプロファイル名を選択します。あるいは、カスタムプロファイルファイルからプロファイル名を使用することもできます。そのためには、プロファイルファイルを Qodana にマウントする必要があります。	`qodana.starter`
`-p` , `--profile-path`	プロファイルファイルへの絶対パス。	なし
`--run-promo`	`qodana.starter` プロファイルの一部としてプロモーションインスペクションを実行するこのオプションは、.NET 用 Qodana リンターでは使用できません。	Qodana が `qodana.starter` プロファイル用に構成されており、`--run-promo true` オプションが呼び出された場合にのみ有効になります。

以下に、プロファイル名を指定して呼び出すための -profile-name オプションと、専用ファイルからプロファイル設定を呼び出すための --profile-path CLI オプションを含む設定スニペットを示します。

            docker run \
               -v $(pwd):/data/project/ \
               -e QODANA_TOKEN="<cloud-project-token>" \
               jetbrains/qodana-<image> \
               -v <path-to-profile-file> \ # Mount the file containing custom profile
               --profile-name qodana.recommended | <profile-name-from-file> \ # Existing profile name | Name from mounted file 
               --profile-path /data/project/myprofiles/<file-name> # Importing profile file
        

            qodana scan \
               -e QODANA_TOKEN="<cloud-project-token>" \
               -v <path-to-profile-file> \ # Mount the file containing custom profile
               --profile-name qodana.recommended | <profile-name-from-file> \ # Existing profile name | Name from mounted file
               --profile-path /data/project/myprofiles/<file-name> # Importing profile 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.2
                      with:
                          args: |
                            -v <path-to-profile-file> # Mount the file containing custom profile
                            --profile-name qodana.recommended | <profile-name-from-file> # Existing profile name | Name from mounted file
                            --profile-path /data/project/myprofiles/<file-name> # Importing profile file
                      env:
                          QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
    

            pipeline {
                environment {
                    QODANA_TOKEN=credentials('qodana-token')
                }
                agent {
                    docker {
                        args '''
                          -v "${WORKSPACE}":/data/project
                          -v <path-to-profile-file> // Mount the file containing custom profile
                          --entrypoint=""
                          '''
                        image 'jetbrains/qodana-<image>
                    }
                }
                stages {
                    stage('Qodana') {
                        steps {
                            sh '''
                            qodana \
                                --profile-name qodana.recommended | <profile-name-from-file> // Existing profile name | Name from mounted file
                                --profile-path /data/project/myprofiles/<file-name> // Importing profile file
                            '''
                        }
                    }
                }
            }
        

            include:
                - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.2
                  inputs:
                      args: |
                          --linter <linter>
                          -v <path-to-profile-file> \ # Mount the file containing custom profile
                          --profile-name qodana.recommended | <profile-name-from-file> \ # Existing profile name | Name from mounted file
                          --profile-path /data/project/myprofiles/<file-name> # Importing profile file
        

基本構成の章に従って、ランナーを設定してください。

正気度を無効にするインスペクション

健全性の問題とは、プロジェクト構成における問題のことです。デフォルトでは、健全性に関するインスペクションは Qodana で有効になっています。以下のコードスニペットを使用して無効にすることができます。

version: "1.0"

linter: <linter>

disableSanityInspections: true

または、--disable-sanity CLI オプションを使用することもできます。

        docker run \
           -v $(pwd):/data/project/ \
           -e QODANA_TOKEN="<cloud-project-token>" \
           <image-name> \
           --disable-sanity
    

        qodana scan \
           -e QODANA_TOKEN="<cloud-project-token>" \
           --disable-sanity
    

        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.2
                      with:
                          args: |
                              --disable-sanity
                      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 \
                            --disable-sanity
                            '''
                        }
                    }
                }
            }
        

            include:
                - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.2
                  inputs:
                      args: |
                          --disable-sanity
                          --image <image>
        

ランナー設定で、追加の Qodana 引数フィールドを見つけて、--disable-sanity オプションを指定します。

インスペクション

インスペクションを含む

選択したプロファイルに含まれていないインスペクションを使用して、特定のディレクトリのファイルを Qodana に解析するよう指示できます。これは解析ごとに実行できます。プロジェクト内のすべてのパスをインスペクションのスコープに含めるには、paths ノードを省略します。インスペクション ID に関する情報は、Inspectopedia(英語) の Web サイトで入手できます。

この YAML 設定例では、インスペクションを含まない empty プロファイルが指定され、tools ディレクトリの分析範囲に SomeInspectionId インスペクションが明示的に含まれています。その結果、tools ディレクトリの内容に対して SomeInspectionId インスペクションによって実行される分析のみが Qodana の分析範囲に含まれることになります。

version: "1.0"

linter: <linter>

profile:
  name: empty
  
  inspections:
    - inspection: SomeInspectionId
      ignore:
        - "!tools"
      enabled: true

ここでは、各 inspections エントリは、有効または無効のいずれかのアクティブなインスペクションプロファイルに登録されているインスペクションを参照する必要があります。インスペクション ID が登録されていない場合、確認なしで無視され、インスペクションは追加されません。

例: profile.name: empty 設定では、CppClangTidy* のようなプラグインが提供するインスペクションは登録されません。特定のプラグインインスペクションを有効にするには、qodana.starter のような既存のインスペクションプロファイルから開始し、不要なインスペクションを抑制します。また、C / C++ リンターの場合は、.clang-tidy のようなプラグイン固有の設定を使用してインスペクションを追加します。

インスペクションを除く

特定のファイルに対してインスペクションを無効にするには、次の YAML 設定を使用します。

version: "1.0"

linter: <linter>

profile:
  inspections:
    - inspection: SomeInspectionId
      ignore:
        - "!<path/to/the/file/from/project/root>"
      enabled: false

クラスの上に noinspection コメントを追加することで、クラスに対してのみインスペクションを抑制することもできます。

    // noinspection <inspection-name>
    export class WorkflowJobSubject {
        private static subject: Observable<GithubEvent<WorkflowJobEvent>> | null =
            null;
    private static GithubWebhookEventSubject: any;

パスをリンターする

この表には、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`	コードカバレッジファイルをマッピングするためのディレクトリ

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

Maven の設定

Maven では、Java コンパイラーのソースバージョンとターゲット(英語)バージョンを設定できます。Qodana はこれらの値を比較し、最新バージョンを選択します。次に、このバージョンの JDK が利用可能なバージョンのリストから検索されます。見つかった場合は、Qodana がそれをダウンロードして使用します。見つからなかった場合は、Qodana がリストから次のバージョンをダウンロードします。

カスタム Maven 設定ファイルへのパスを指定することで、カスタムリポジトリ、ミラー、認証情報、ローカルリポジトリ設定を使用できます。

    version: "1.0"

    linter: <linter>

    mavenSettingsPath: /path/to/settings.xml

    qodana scan \
       -e QODANA_TOKEN="&lt;cloud-project-token&gt;" \
       --maven-settings-path /path/to/settings.xml

この設定により、Qodana はパスを解析し、プロジェクトルートに対する相対パスを解決し、それを YAML スキーマに公開し、Maven プロジェクトのインポートまたは再インポートの前に、構成済みの settings.xml ファイルを適用します。また、ワークフローの順序も正しく保証されます。Maven の再インポート (要求された場合) は、Maven の設定が構成され、モジュールの依存関係が更新された後にのみ実行されます。

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.2
                      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.2
                  inputs:
                      args: |
                          -v gradle.properties:/data/cache/gradle/gradle.properties
                          --linter <linter>
        

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

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

JDK をマウントする

ローカルファイルシステムから JDK を Qodana Docker イメージの /root/.jdks ディレクトリにマウントできます。

$ docker run \
  -v /path/to/jdk:/root/.jdks/jdk \
  jetbrains/qodana-<linter>

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 では、疑わしい警告を調査できます。

分析ディレクトリ

これらの CLI オプションを使用すると、パスをリンターするセクションで説明されているパスを上書きできます。

オプション	説明	デフォルト設定
`--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.2
                      with:
                          args: --project-dir project
                      env:
                          QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
    

パスを分析範囲から除外する

解析ごとにファイルとパスを除外することも、すべてのインスペクションを一括で除外することもできます。インスペクション ID に関する情報は、Inspectopedia(英語)Web サイトでご覧いただけます。

プロジェクト内のすべてのパスを分析範囲から除外するには、paths ノードを省略します。

以下の YAML 設定を使用して、指定されたプロジェクトパスからすべてのインスペクションを除外します。

version: "1.0"

linter: <linter>

profile:
  inspections:
    - group: ALL
      ignore:
        - "asm-test/src/main/java/org"
        - "asm/Visitor.java"
        - "benchmarks"
        - "vendor/**"
        - "scope#file[*test*]:src/*"

指定されたプロジェクトパスの ID で指定されたインスペクションを除外します。

version: "1.0"

linter: <linter>

profile:      
  inspections:
  - inspection: InspectionId
    ignore:
      - "relative/path"
      - "another/relative/path"
  - group: ALL
    ignore:
      - "asm-test/src/main/java/org"
      - "asm"
      - "benchmarks"
      - "tools"

特定のインスペクション ID は、HTML レポートのプロファイル設定、またはインスペクションプロファイルを含む .xml ファイルで見つけることができます。

プロジェクト内のディレクトリを指定する

分析対象のプロジェクトディレクトリを指定するには、onlyDirectory YAML オプションを使用します。これはプロジェクトルートからの相対パスである必要があります。例:

version: "1.0"

linter: <linter>

onlyDirectory: project-a

または、--only-directory CLI オプションを使用することもできます。例:

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

        qodana scan \
          -e QODANA_TOKEN="<cloud-project-token>" \
          --only-directory project-a
    

        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.2
                      with:
                          args: --only-directory project-a
                      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.2
                      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.2
                  inputs:
                      args: |
                          --cache-dir /data/newcachedir
                          --linter <linter>
        

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

--cache-dir /data/newcachedir

分析レポート

Qodana は、レポート管理のために以下の CLI オプションを提供します。

オプション	説明
`-s` , `--save-report`	HTML 形式のレポートを生成して保存する
`-w` , `--show-report`	HTML 形式のレポートを提供します。デフォルトでは、Qodana はポート `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

--show-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 の機能

高品質のゲート

品質ゲートを構成するには、いくつかのオプションがあります。

YAML 設定ファイルでは、プロジェクト内の問題の総数を制御するための失敗しきい値を追加できます。これはすべてのリンターでサポートされています。

version: "1.0"

linter: <linter>

failThreshold: <number>

.NET の Qodana コミュニティと C/C++ のための Qodana コミュニティを除くすべてのリンターでは、次の構成を使用できます。

version: "1.0"

linter: <linter>

failureConditions:
  severityThresholds:
    any: <number> # Total problems
    critical: <number> # Critical and other severities
    high: <number>
    moderate: <number>
    low: <number>
    info: <number>
  testCoverageThresholds:
    fresh: <number> # Fresh code coverage
    total: <number> # Total code coverage
  dependencyLicenses:
    failOnProhibited: <true|false> # Prohibited licenses
    failOnUnknown: <true|false> # Unknown licenses

この構成では、設定制限を 1 つだけ超えるとビルドが失敗します。

severityThresholds:any キーを使用すると、問題の総数を設定できます。severityThresholds:critical キーを使用すると、問題の深刻度ごとに品質ゲートを設定できます。testCoverageThresholds:fresh キーと testCoverageThresholds:total キーを使用すると、複数のリンターでサポートされているコードの総カバレッジと新規コードカバレッジを設定できます。dependencyLicenses キーを使用すると、禁止されているライセンスまたは不明なライセンスに対して品質ゲートを設定できます。

また、--fail-threshold CLI オプションを使用して、問題の総数に基づいて品質ゲートを設定することもできます。以下は、問題数が 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.2
                          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.2
                      inputs:
                          args: |
                              --fail-threshold 10
                              --linter <linter>
            

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

--fail-threshold 10

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

ベースライン

ベースライン実行モードでは、新しい 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.2
                          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.2
                      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 出力レポートにはベースライン状態に関する問題ごとの情報が含まれます。

ライセンス監査

ライセンス監査機能はデフォルトで有効になっています。 CheckDependencyLicenses (英語) インスペクションを除外することで無効にできます。

version: "1.0"

linter: <linter>

profile:
  inspections:
    - inspection: CheckDependencyLicenses
      enabled: false

依存関係を無視する

依存関係を無視して、関連する問題をレポートから非表示にします。

version: "1.0"

linter: <linter>

dependencyIgnores:
  - name: "enry"

ここで、name は無視する依存関係の名前です。

上の例では、enry 依存関係が分析から完全に除外されています。考えられるライセンス関連の問題は無視されるため、依存関係はレポートにまったく含まれません。これは、レポートでメンションする必要のない内部依存関係をすばやく非表示にできます。

ライセンスを許可または禁止する

事前定義されたライセンス互換性マトリックスをオーバーライドします。

version: "1.0"

linter: <linter>

licenseRules:
  - keys:
      - "PROPRIETARY-LICENSE"
      - "MIT"
    prohibited:
      - "BSD-3-CLAUSE-NO-CHANGE"
    allowed:
      - "ISC"

  - keys: [ "Apache-2.0" ]
    prohibited:
      - "MIT"

この構成では、keys はプロジェクトライセンスであり、依存ライセンスの識別子は allowed または prohibited で指定されます。

依存関係ライセンスをオーバーライドする

依存関係ライセンス識別子をオーバーライドします。

version: "1.0"

linter: <linter>

dependencyOverrides:
  - name: "jaxb-runtime"
    version: "2.3.1"
    url: "https://github.com/javaee/jaxb-v2"
    licenses:
      - key: "CDDL-1.1"
        url: "https://github.com/javaee/jaxb-v2/blob/master/LICENSE"
      - key: "GPL-2.0-with-classpath-exception"
        url: "https://github.com/javaee/jaxb-v2/blob/master/LICENSE"

ここで、name は依存関係の名前、version は依存関係のバージョン、licenses は再定義された依存関係ライセンスのリストです。

上記の例では、Qodana に対して、jaxb-runtime のライセンスとして CDDL-1.1、GPL-2.0-with-classpath-exception を検出し、その他のライセンスは検出しないように指示しています (2.3.1 のみ検出するように指示しています)。これは、依存関係がデュアルライセンスで、特定のライセンスを除外したい場合や、依存関係のソースからライセンスを正しく検出できない場合に役立ちます。

カスタム依存関係

現在、Qodana を使用したライセンス監査は、JPS、Maven、Gradle、npm、yarn、composer プロジェクトでのみ可能です。レポートに記載すべき依存関係のうち、プロジェクトのソースコードから検出できないものを含めるには、customDependencies を使用して指定してください。

version: "1.0"

linter: <linter>

customDependencies:
  - name: ".babelrc JSON Schema (.babelrc-schema.json)"
    version: "JSON schema for Babel 6+ configuration files"
    licenses:
      - key: "Apache-2.0"
        url: "https://github.com/SchemaStore/schemastore/blob/master/LICENSE"

クイックフィックス

この表は、利用可能なクイックフィックス戦略について説明しています。

CLI オプション /YAML キー	説明
`--apply-fixes / apply`	クリーンアップを含む利用可能なすべてのクイックフィックス戦略を適用します。詳細については、クイックフィックスセクションを参照してください。
`--cleanup / cleanup`	`CLEANUP` クイックフィックス戦略を実行します。詳細についてはクイックフィックスを参照してください

fixesStrategy YAML キーを使用すると、利用可能な戦略の中から選択できます。

version: "1.0"

linter: <linter>

fixesStrategy: cleanup/apply

あるいは、--apply-fixes または --cleanup コマンドラインオプションを使用することもできます。

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

            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.2
                          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 \
                                --apply-fixes/cleanup
                                '''
                            }
                        }
                    }
                }
            

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

ランナー設定で、追加の Qodana 引数フィールドを見つけて、次のオプションを指定します。

--apply-fixes

汚染分析

qodana.yaml ファイルにおいて、 PhpVulnerablePathsInspection (英語) インスペクションを解析範囲に含める。

  version: "1.0"

  linter: qodana-php

  profile:
    inspections:
      — inspection: PhpVulnerablePathsInspection
        enabled: true
  

qodana.yaml ファイルで、JvmTaintAnalysis インスペクションを分析範囲に含めます。

  version: "1.0"

  linter: qodana-jvm

  profile:
    inspections:
      — inspection: JvmTaintAnalysis
        enabled: true
  

脆弱性チェッカー

脆弱性チェッカー機能の使用を開始するには、 VulnerableLibrariesGlobal (英語) インスペクションを有効にしてください。

version: "1.0"

linter: <linter>

profile:
  inspections:
    - inspection: VulnerableLibrariesLocal
      enabled: true

コードカバレッジ

Qodana では、デフォルトでコードカバレッジが有効になっています。

coverage.reportProblems キーを使用すると、YAML ファイルで設定できます。codeCoverageLocations キーを使用すると、デフォルトのコードカバレッジディレクトリを上書きできます。例:

version: "1.0"

linter: <linter>

coverage:
  reportProblems: true # Code coverage is enabled
  codeCoverageLocations: # Directories containing coverage reports
    - "custom-directory-1"
    - "custom-directory-2"

コードカバレッジファイルを含むディレクトリを 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.2
                          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.2
                      inputs:
                          args: |
                              -v /my/dir/with/coverage:/data/coverage
                              --linter <linter>
            

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

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

実行シナリオを上書きする

以下の実行シナリオを使用できます。

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

YAML 設定の script を使用すると、実行シナリオを指定できます。

version: "1.0"

linter: <linter>

script:
  name: <script-name>
  parameters:
      <parameter>: <value>

デフォルトでは、Qodana は default シナリオを採用します。これは、通常の Qodana がこの設定と同等に実行されることを意味します。

version: "1.0"

linter: <linter>

script:
  name: default

--script CLI オプションを使用して実行シナリオを設定することもできます。

            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.2
                          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.2
                      inputs:
                          args: |
                              --script default
                              --linter <linter>
            

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

--script default

JDK バージョン

これらのリンターの JDK バージョンを構成できます。

JDK バージョンを指定するには、projectJDK キーを使用します。例:

            version: "1.0"

            linter: <linter>

            projectJDK: 11

または:

            version: "1.0"

            linter: <linter>

            projectJDK: 1.8

JDK を名前で指定することもできます。

            version: "1.0"

            linter: <linter>

            projectJDK: corretto-19

JDK の構成の詳細については、「JDK の設定」セクションを参照してください。

PHP バージョン

PHP 用の Qodana リンターを実行する前に、PHP バージョンを構成できます。

version: "1.0"

linter: qodana-php

php:
  version: "X.x"

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.2
                      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.2
                  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.2
                      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.2
                  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.2
                      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.2
                  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.2
                          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.2
                          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.2
                      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.2
                          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.2
                      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>

ヒープサイズを変更する

デフォルトでは、ヒープサイズはホスト 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.2
                      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.2
                  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.2
                      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.2
                  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.2
                      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.2
                  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" \
               -e QODANA_SKIP_SUBMODULE_UPDATE=true \
               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 操作における厳密なホスト鍵チェックを無効にする
`-e QODANA_SKIP_SUBMODULE_UPDATE=true`	Git サブモジュールのチェックアウトをスキップします。サブモジュールのチェックアウトが失敗した場合に役立ちます
`--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_SKIP_SUBMODULE_UPDATE=true \
               -e QODANA_TOKEN="<cloud-project-token>" \
               --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 操作における厳密なホスト鍵チェックを無効にする
`-e QODANA_SKIP_SUBMODULE_UPDATE=true`	Git サブモジュールのチェックアウトをスキップします。サブモジュールのチェックアウトが失敗した場合に役立ちます
`--diff-start=<GIT_START_HASH>`	コミットハッシュについては、プルリクエストとマージリクエストを分析する章を参照してください。

        jobs:
            qodana-job:
                runs-on: ubuntu-latest
                steps:
                    - name: Checkout Repository
                      uses: actions/checkout@v4
                      with:
                          submodules: recursive  # clones submodules recursively

                    - name: Setup SSH Agent
                      uses: webfactory/ssh-agent@v0.9.0
                      with:
                          ssh-private-key: ${{ secrets.SUBMODULE_SSH_KEY }}
                
                    - name: 'Qodana Scan'
                      uses: JetBrains/qodana-action@v2026.2
                      with:
                          args: |
                              -v ${{ env.SSH_AUTH_SOCK }}:/tmp/ssh_agent.sock
                              -e SSH_AUTH_SOCK=/tmp/ssh_agent.sock
                              -e GIT_SSH_COMMAND=&quot;ssh -o StrictHostKeyChecking=no&quot;
                              -e QODANA_SKIP_SUBMODULE_UPDATE=true
                          upload-result: true
                          pr-mode: 'true'
                      env:
                          QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}
        
    

ここで、args ブロックには以下のオプションが含まれています。

オプション	説明
`-v ${{ env.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 操作における厳密なホスト鍵チェックを無効にする
`-e QODANA_SKIP_SUBMODULE_UPDATE=true`	Git サブモジュールのチェックアウトをスキップします。サブモジュールのチェックアウトが失敗した場合に役立ちます

    include:
        - component: $CI_SERVER_FQDN/qodana/qodana/qodana-gitlab-ci@v2026.2
          inputs:
              image: <image>
              args: |
                  -v ${{ env.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_SKIP_SUBMODULE_UPDATE=true

ここで、args ブロックには以下のオプションが含まれています。

オプション	説明
`-v ${{ env.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 操作における厳密なホスト鍵チェックを無効にする
`-e QODANA_SKIP_SUBMODULE_UPDATE=true`	Git サブモジュールのチェックアウトをスキップします。サブモジュールのチェックアウトが失敗した場合に役立ちます

Qodana CLI のキャッシュ

Qodana CLI(英語) はファイルを <userCacheDir> ディレクトリに保存します。これについては、このセクション全体で何度か説明します。オペレーティングシステムに応じた <userCacheDir> ディレクトリの場所のリストは次のとおりです。

オペレーティングシステム	パス
macOS	`~/Library/Caches/`
Linux	`~/.cache/`
Windows	`%LOCALAPPDATA%\`

プロジェクトディレクトリで qodana init コマンドを実行すると、Qodana CLI により、インスペクション中に実行されるリンターを選択し、選択内容を qodana.yaml に保存できます。完了したら、コマンドでリンターを指定する必要はありません。これについては、このセクション全体で説明します。

qodana init コマンドの詳細な説明は、プロジェクトの構成セクションで参照できます。

プラグインの管理

以下の YAML 設定を使用すると、インスペクションの実行中にダウンロードおよび呼び出されるプラグインを指定できます。

version: "1.0"

linter: <linter>

plugins:
  - id: <plugin.id>

ここで、<plugin-id> は JetBrains マーケットプレイス(英語)のプラグイン ID を表します。例: Grazie Professional(英語) の場合、プラグイン ID は com.intellij.grazie.pro になります。プラグイン ID を見つけるには、プラグインページで概要タブをクリックし、追加情報セクションに移動します。

プラグインキャッシュは /data/cache/plugins ディレクトリに保存されます。

プラグインに必要なサードパーティソフトウェアをインストールするには、次の方法があります。

bootstrap キーを使用します。
FROM jetbrains/qodana... で始まるカスタム Dockerfile を開発します。GitHub(英語) で利用可能な Qodana Dockerfile の例を使用できます。

不適切な書式インスペクション

IncorrectFormatting (英語) インスペクションは、ファイルに含まれる複数のフォーマットエラーを、個別に表示するのではなく、1 つの問題として統合します。ファイルごとに 1 つの問題がサンプルスニペットとともに表示されるため、問題をより迅速に解決できます。

この機能は、C/C++ 用の Qodana、C/C++ 用の Qodana Community、および .NET 用の Qodana Community を除くすべてのリンターで使用できます。

使用を開始するには、Qodana インスペクションプロファイル構成で IncorrectFormatting (英語) インスペクションを有効にします。例:

version: "1.0"

linter: <linter>

profile:
  inspections:
    - inspection: IncorrectFormatting
      enabled: true

CMake プリセットを指定する

CMake プリセットを使用して、Qodana を C/C++ リンター用にカスタマイズします。cpp および cmakePreset オプションを使用してプリセットを呼び出します。

version: "1.0"

linter: <linter>

cpp:
  cmakePreset: my-qodana-preset

モノレポで Java および Kotlin プロジェクトを構成する

rootJavaProjects キーを使用すると、分析に含めるプロジェクトを指定できます。例:

version: "1.0"

linter: <linter>

rootJavaProjects:
- "./gradleProject"
- "./mavenModule/pom.xml"

デフォルトでは、Qodana はサブディレクトリからプロジェクトを再帰的に収集し、分析のためにインポートします。この変更により、分析対象プロジェクトと VCS ルートが異なるプロジェクトに対して、増分分析と修正が可能になります。

包括的な設定例

version: "1.0"

linter: <linter>

failThreshold: 0
profile:
  name: qodana.recommended
  inspections:
    - inspection: SomeInspectionId
      enabled: true
    - inspection: AnotherInspectionId
      enabled: true
      ignore:
        - "relative/path"
        - "another/relative/path"
    - group: ALL
      ignore: 
        - "asm-test/src/main/java/org"
        - "benchmarks"
        - "tools"

上の例

SomeInspectionId インスペクションは、プロファイルでは無効になっていますが、すべてのパスに対して明示的に有効になっています
AnotherInspectionId インスペクションは relative/path および another/relative/path では無効です
これらのパスではインスペクションは実行されません: asm-test/src/main/java/org、benchmarks、tools

次の例では、.NET プロジェクトの設定でよく見られる、品質ゲート、インスペクションプロファイルのカスタマイズ、パスの除外など、複数の設定を組み合わせています。

version: "1.0"

# Run the Qodana for .NET linter in native mode
linter: qodana-dotnet
withinDocker: false

# Set a quality gate: fail if the number of problems exceeds 10
failThreshold: 10

# Use the qodana.recommended profile
profile:
  name: qodana.recommended

# Exclude specific paths from the analysis
  inspections:
    - group: ALL
      ignore:
        - "tests/"
        - "bin/"
        - "obj/"
    # Include an inspection not contained in the qodana.recommended profile
    - inspection: SomeSpecificInspectionId
      enabled: true

# Restore .NET dependencies
bootstrap: |+
  dotnet restore

JVM 用 Qodana リンターを設定する際は、以下の例を参考にしてください。

version: "1.0"

# Run the Qodana for JVM linter
linter: qodana-jvm

# Set the JDK version
jdk:
  version: "17"

# Include Java projects for analysis
rootJavaProjects:
  - "./gradle-project"
  - "./maven-module/pom.xml"

# Quality gate settings
failureConditions:
  severityThresholds:
    any: 50       # Fail if total number of problems exceeds 50
    critical: 1   # Fail if there is at least 1 critical problem
    high: 2       # Fail if there are more than 2 high-severity problems
  testCoverageThresholds:
    fresh: 80     # Fail if fresh code coverage is below 80%
    total: 90     # Fail if total code coverage is below 90%

# Disable specific inspections
profile:
  inspections:
    - inspection: CheckDependencyLicenses 
      enabled: false # Disable license audit if not needed

# Include custom plugins
plugins:
  - id: com.intellij.grazie.pro

2026 年 9 月 18 日

構成リファレンス

導入

YAML 設定

CLI オプション

カスタムコマンドを実行する

リンターを指定する

ネイティブモードを構成する

YAML 設定ファイルを上書きする

インスペクションプロファイル:

YAML 設定

CLI オプション

正気度を無効にするインスペクション

インスペクション

インスペクションを含む

インスペクションを除く

パスをリンターする

Maven の設定

Gradle 設定を上書きする

JDK をマウントする

Qodana ログの表示

分析ディレクトリ

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

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

パスを分析範囲から除外する

プロジェクト内のディレクトリを指定する

キャッシュの依存関係

分析レポート

Qodana の機能

高品質のゲート

ベースライン

ライセンス監査

依存関係を無視する

ライセンスを許可または禁止する

依存関係ライセンスをオーバーライドする

カスタム依存関係

クイックフィックス

汚染分析

脆弱性チェッカー

コードカバレッジ

実行シナリオを上書きする

JDK バージョン

PHP バージョン

Properties

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

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

プラグインの構成

設定タイムアウトの設定

変更されたコードを分析する

ヒープサイズを変更する

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

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

Git サブモジュール

Qodana CLI のキャッシュ

プラグインの管理

不適切な書式インスペクション

CMake プリセットを指定する

モノレポで Java および Kotlin プロジェクトを構成する

包括的な設定例

関連ページ：