From 9fef82cc31cab07baa7f239c3feef62a618f1c14 Mon Sep 17 00:00:00 2001 From: Bala Kumar Date: Mon, 21 Jul 2025 15:56:09 +0530 Subject: [PATCH 1/3] Initial commit to introduce doc section --- .../adding_elasticsearch_filters.md | 665 ++++++++++++++++++ 1 file changed, 665 insertions(+) create mode 100644 doc/development/vulnerability_management/adding_elasticsearch_filters.md diff --git a/doc/development/vulnerability_management/adding_elasticsearch_filters.md b/doc/development/vulnerability_management/adding_elasticsearch_filters.md new file mode 100644 index 00000000000000..73dd053dbfaa86 --- /dev/null +++ b/doc/development/vulnerability_management/adding_elasticsearch_filters.md @@ -0,0 +1,665 @@ +# Adding New Elasticsearch Filters for Vulnerability Management + +This guide covers how to add new filters using Elasticsearch for advanced vulnerability management features in GitLab. These features are part of the advanced vulnerability management capabilities and require Elasticsearch to be configured. + +## Overview + +Advanced vulnerability management features in GitLab use Elasticsearch to provide enhanced filtering capabilities that go beyond what's possible with PostgreSQL alone. This includes features like: + +- Advanced OWASP Top 10 filtering +- Identifier name searching +- Reachability filtering +- Complex aggregations and analytics + +## Prerequisites + +Before adding a new Elasticsearch filter, ensure you understand: + +- GitLab's Elasticsearch integration architecture +- Vulnerability data model and relationships +- GraphQL resolver patterns +- Database migration patterns +- Feature flag usage + +## Step-by-Step Implementation Guide + +### 1. GraphQL Resolver Updates + +First, add the new filter argument to the appropriate GraphQL resolver. Most vulnerability filters are added to `VulnerabilitiesResolver`. + +**File:** `ee/app/graphql/resolvers/vulnerabilities_resolver.rb` + +```ruby +argument :your_new_filter, GraphQL::Types::String, + required: false, + experiment: { milestone: '18.x' }, + description: 'Filter vulnerabilities by your new criteria. ' \ + 'To use this argument, you must have Elasticsearch configured and the ' \ + '`advanced_vulnerability_management` feature flag enabled. ' \ + 'Not supported on Instance Security Dashboard queries.' +``` + +**Key considerations:** +- Mark experimental features with `experiment: { milestone: 'X.Y' }` +- Include clear documentation about Elasticsearch requirements +- Note any limitations (e.g., Instance Security Dashboard support) + +### 2. Update VulnerabilityFilterable Module + +Add validation logic for your new filter in the `VulnerabilityFilterable` module. + +**File:** `ee/app/graphql/resolvers/vulnerability_filterable.rb` + +```ruby +# Add your filter to the ADVANCED_FILTERS constant if it requires ES +ADVANCED_FILTERS = [:owasp_top_10_2021, :identifier_name, :reachability, :your_new_filter].freeze + +# Add validation logic in the validate_filters method +def validate_filters(filters) + # ... existing validations ... + + validate_your_new_filter!(vulnerable) if filters[:your_new_filter].present? +end + +private + +def validate_your_new_filter!(vulnerable) + # Add any specific validation logic for your filter + # Example: check if required migrations are complete + return if Feature.enabled?(:your_new_filter_feature_flag, vulnerable) && + ::Elastic::DataMigrationService.migration_has_finished?(:add_your_field_to_vulnerability) + + raise ::Gitlab::Graphql::Errors::ArgumentError, + 'The \'your_new_filter\' argument is not currently supported. ' \ + 'This feature requires Elasticsearch and specific migrations to be complete.' +end +``` + +### 3. Use Elasticsearch Finder + +The `VulnerabilityElasticSearchFinder` automatically uses the Elasticsearch query builder. No changes are typically needed here unless you're adding a completely new finder pattern. + +**File:** `ee/app/finders/security/vulnerability_elastic_search_finder.rb` + +The finder delegates to `VulnerabilityQueryBuilder` which handles all filter logic. + +### 4. Elasticsearch Query Builder + +Add your filter logic to the vulnerability query builder. + +**File:** `ee/lib/search/elastic/vulnerability_query_builder.rb` + +```ruby +def build + # ... existing filters ... + + query_hash = ::Search::Elastic::VulnerabilityFilters.by_your_new_filter( + query_hash: query_hash, options: options) + + # ... rest of the method ... +end +``` + +### 5. Elasticsearch Vulnerability Filters + +Implement the actual filter logic in the VulnerabilityFilters module. + +**File:** `ee/lib/search/elastic/vulnerability_filters.rb` + +```ruby +def by_your_new_filter(query_hash:, options:) + your_filter_value = options[:your_new_filter] + return query_hash if your_filter_value.blank? + + # Add validation if needed + return query_hash unless valid_filter_value?(your_filter_value) + + context.name(:filters) do + add_filter(query_hash, :query, :bool, :filter) do + { + terms: { + _name: context.name(:your_new_filter), + your_field_name: your_filter_value + } + } + end + end +end + +private + +def valid_filter_value?(value) + # Add validation logic specific to your filter + # Return true if valid, false otherwise +end +``` + +**Common filter patterns:** + +- **Term filter** (exact match): `{ term: { field: { value: value } } }` +- **Terms filter** (multiple values): `{ terms: { field: values } }` +- **Range filter**: `{ range: { field: { gte: min, lte: max } } }` +- **Boolean filter** (complex logic): `{ bool: { must: [...], should: [...] } }` + +### 6. Elasticsearch Schema and Migrations + +#### Define the Elasticsearch Schema + +Update the vulnerability Elasticsearch type to include your new field. + +**File:** `ee/lib/search/elastic/types/vulnerability.rb` + +```ruby +def base_mappings + { + # ... existing mappings ... + your_field_name: { type: 'keyword' }, # or appropriate type + # ... rest of mappings ... + } +end +``` + +**Common Elasticsearch field types:** +- `keyword`: For exact matching (IDs, enums, short strings) +- `text`: For full-text search +- `short`: For small integers (enums) +- `long`: For large integers +- `boolean`: For true/false values +- `date`: For timestamps + +#### Create Elasticsearch Migration + +Create a new Elasticsearch migration to add the field to existing indices. + +**File:** `ee/elastic/migrate/YYYYMMDDHHMMSS_add_your_field_to_vulnerability.rb` + +```ruby +# frozen_string_literal: true + +class AddYourFieldToVulnerability < Elastic::Migration + include ::Search::Elastic::MigrationUpdateMappingsHelper + + DOCUMENT_TYPE = Vulnerability + + private + + def index_name + ::Search::Elastic::Types::Vulnerability.index_name + end + + def new_mappings + { + your_field_name: { + type: 'keyword' # or appropriate type + } + } + end +end +``` + +#### Create Migration Documentation + +**File:** `ee/elastic/docs/YYYYMMDDHHMMSS_add_your_field_to_vulnerability.yml` + +```yaml +--- +name: AddYourFieldToVulnerability +version: 'YYYYMMDDHHMMSS' +description: Adds your_field_name field to the Vulnerability index for enhanced filtering capabilities. +group: group::security infrastructure +milestone: '18.x' +introduced_by_url: https://gitlab.com/gitlab-org/gitlab/-/merge_requests/XXXXX +obsolete: false +marked_obsolete_by_url: +marked_obsolete_in_milestone: +``` + +### 7. Keep Elasticsearch in Sync + +#### Update Vulnerability Reads Model + +Ensure your new field is tracked for Elasticsearch updates. + +**File:** `ee/app/models/vulnerabilities/read.rb` + +```ruby +# Add your field to the tracked fields constant +ELASTICSEARCH_TRACKED_FIELDS = ::Search::Elastic::References::Vulnerability::DIRECT_FIELDS + + ::Search::Elastic::References::Vulnerability::DIRECT_TYPECAST_FIELDS + + %w[traversal_ids your_field_name] +``` + +#### Manual Bookkeeping for ActiveRecord Models + +For fields that require complex calculations or come from related models, implement manual bookkeeping: + +```ruby +# In the model that changes and affects the vulnerability field +after_commit :update_vulnerability_elasticsearch_field, on: [:create, :update, :destroy] + +private + +def update_vulnerability_elasticsearch_field + return unless vulnerability_read&.use_elasticsearch? + + # Update the field value + vulnerability_read.update_column(:your_field_name, calculate_new_value) + + # Trigger ES update + vulnerability_read.maintain_elasticsearch_update(updated_attributes: ['your_field_name']) +end +``` + +#### Bulk Operations with BulkEsOperationService + +For operations that affect multiple vulnerability records outside of ActiveRecord models, use the `BulkEsOperationService` helper: + +**File:** `ee/app/services/vulnerabilities/bulk_es_operation_service.rb` + +```ruby +# Example usage in a service that updates multiple vulnerabilities +def update_multiple_vulnerabilities(vulnerability_relation) + Vulnerabilities::BulkEsOperationService.new(vulnerability_relation).execute do |relation| + # Perform your database updates here + relation.update_all(your_field_name: new_value) + end +end +``` + +**Key benefits of BulkEsOperationService:** +- Handles preloading of necessary associations +- Filters to only eligible vulnerabilities (those that should be indexed) +- Batches Elasticsearch updates efficiently +- Works with both `Vulnerability` and `Vulnerabilities::Read` relations + +#### Sync During Vulnerability Ingestion Framework + +For bulk operations that don't use ActiveRecord models (like vulnerability ingestion), perform manual sync: + +**Example from Security Ingestion:** + +```ruby +# ee/app/services/security/ingestion/tasks/ingest_remediations.rb +def update_vulnerability_reads + unfound_reads = Vulnerabilities::Read.by_vulnerabilities( + vulnerability_ids_for_remediations(unfound_remediations)) + ::Vulnerabilities::BulkEsOperationService.new(unfound_reads).execute do |relation| + relation.update_all(has_remediations: false) + end + + found_reads = Vulnerabilities::Read.by_vulnerabilities( + vulnerability_ids_for_remediations(found_remediations)) + ::Vulnerabilities::BulkEsOperationService.new(found_reads).execute do |relation| + relation.update_all(has_remediations: true) + end +end +``` + +**Example from SBOM Ingestion:** + +```ruby +# ee/app/services/sbom/ingestion/tasks/ingest_occurrences_vulnerabilities.rb +def after_ingest + return unless return_data.present? + + vulnerabilities_relation = Vulnerability.id_in(return_data.flatten) + sync_elasticsearch(vulnerabilities_relation) if vulnerabilities_relation.present? +end + +def sync_elasticsearch(vulnerabilities) + ::Vulnerabilities::BulkEsOperationService.new(vulnerabilities).execute(&:itself) +end +``` + +#### Sync During Project/Group Operations + +**Project Deletion:** + +```ruby +# ee/app/services/vulnerabilities/removal/remove_from_project_service.rb +def sync_elasticsearch + vulnerabilities_to_delete = Vulnerability.id_in(vulnerability_ids) + Vulnerabilities::BulkEsOperationService.new(vulnerabilities_to_delete).execute(&:itself) +end +``` + +**Project/Group Transfer:** + +When projects or groups are transferred, vulnerability traversal IDs need to be updated: + +```ruby +# Update traversal_ids for vulnerabilities when group structure changes +Vulnerabilities::UpdateTraversalIdsOfVulnerabilityReadsService.new( + group_id: new_group.id +).execute +``` + +#### Future: Change Data Capture (CDC) + +GitLab is planning to move synchronization outside of application logic using Change Data Capture from PostgreSQL. This work is tracked in [Epic 18520](https://gitlab.com/groups/gitlab-org/-/epics/18520). + +**Benefits of CDC approach:** +- Removes sync logic from application code +- Reduces application complexity +- Improves reliability and consistency +- Enables real-time synchronization +- Reduces performance impact on application operations + +**Current Status:** +- In planning/research phase +- Will gradually replace manual sync mechanisms +- Timeline and implementation details are being defined + +### 8. Elasticsearch Backfill Migration + +Create a background migration to populate the new field for existing records. + +**File:** `lib/gitlab/background_migration/backfill_your_field_to_vulnerability_reads.rb` + +```ruby +# frozen_string_literal: true + +module Gitlab + module BackgroundMigration + class BackfillYourFieldToVulnerabilityReads < BatchedMigrationJob + operation_name :backfill_your_field_to_vulnerability_reads + feature_category :vulnerability_management + + def perform + each_sub_batch do |sub_batch| + sub_batch.update_all(your_field_name: calculate_field_value) + end + end + + private + + def calculate_field_value + # Implement logic to calculate the field value + # This might involve joins or complex calculations + end + end + end +end +``` + +**Queue the migration:** + +**File:** `db/post_migrate/YYYYMMDDHHMMSS_queue_backfill_your_field_to_vulnerability_reads.rb` + +```ruby +# frozen_string_literal: true + +class QueueBackfillYourFieldToVulnerabilityReads < Gitlab::Database::Migration[2.2] + milestone '18.x' + + restrict_gitlab_migration gitlab_schema: :gitlab_main + + def up + queue_batched_background_migration( + :backfill_your_field_to_vulnerability_reads, + :vulnerability_reads, + :vulnerability_id, + job_class_name: 'BackfillYourFieldToVulnerabilityReads' + ) + end + + def down + delete_batched_background_migration( + :backfill_your_field_to_vulnerability_reads, + :vulnerability_reads, + :vulnerability_id, + 'BackfillYourFieldToVulnerabilityReads' + ) + end +end +``` + +### 9. Feature Flags + +#### Create Feature Flag + +**File:** `ee/config/feature_flags/beta/your_new_filter.yml` + +```yaml +--- +name: your_new_filter +description: Enable the new filter for vulnerability management +feature_issue_url: https://gitlab.com/groups/gitlab-org/-/epics/XXXXX +introduced_by_url: https://gitlab.com/gitlab-org/gitlab/-/merge_requests/XXXXX +rollout_issue_url: https://gitlab.com/gitlab-org/gitlab/-/issues/XXXXX +milestone: '18.x' +group: group::security infrastructure +type: beta +default_enabled: false +``` + +#### Use Feature Flag in Code + +```ruby +# In validation logic +return unless Feature.enabled?(:your_new_filter, vulnerable) + +# In filter logic +return query_hash unless Feature.enabled?(:your_new_filter, options[:current_user]) +``` + +### 10. UI Access Control + +The UI automatically respects the `access_advanced_vulnerability_management` ability. This ability is granted when: + +1. User has `:read_security_resource` permission +2. Vulnerability indexing is enabled (Elasticsearch configured) +3. `advanced_vulnerability_management` feature flag is enabled +4. Required Elasticsearch migrations are complete + +**File:** `ee/app/policies/vulnerabilities/advanced_vulnerability_management_policy.rb` + +The policy automatically handles access control. No changes needed unless you have specific requirements. + +**Frontend Integration:** + +In Vue components, check the ability: + +```javascript +// The ability is automatically pushed to frontend in vulnerability controllers +computed: { + canUseAdvancedFilters() { + return this.glFeatures.accessAdvancedVulnerabilityManagement; + } +} +``` + +## Testing + +### Unit Tests + +1. **GraphQL Resolver Tests**: Test argument validation and filter application +2. **Finder Tests**: Test Elasticsearch query generation +3. **Filter Tests**: Test individual filter logic +4. **Migration Tests**: Test background migration logic + +### Integration Tests + +1. **End-to-end GraphQL Tests**: Test complete filter functionality +2. **Elasticsearch Integration Tests**: Test actual ES queries +3. **Feature Flag Tests**: Test behavior with flags enabled/disabled + +## Best Practices + +### Performance Considerations + +1. **Index Optimization**: Choose appropriate field types for your use case +2. **Query Efficiency**: Use term filters for exact matches, avoid expensive operations +3. **Pagination**: Always implement proper pagination for large result sets +4. **Caching**: Consider caching expensive calculations + +### Security Considerations + +1. **Input Validation**: Always validate filter inputs +2. **Access Control**: Respect existing permission models +3. **Data Exposure**: Ensure filters don't expose sensitive information + +### Maintainability + +1. **Documentation**: Document complex filter logic +2. **Testing**: Comprehensive test coverage for all scenarios +3. **Monitoring**: Add metrics for filter usage and performance +4. **Backwards Compatibility**: Consider migration paths for existing data + +## Common Patterns + +### Enum-based Filters (Straightforward) + +Enum and boolean field filters are straightforward to implement since they map directly to database values: + +```ruby +def by_enum_field(query_hash:, options:) + enum_values = options[:enum_field] + return query_hash if enum_values.blank? + + # Validate enum values - this is straightforward since enums have fixed values + valid_values = YourModel.enum_field.values + return query_hash unless (enum_values - valid_values).empty? + + context.name(:filters) do + add_filter(query_hash, :query, :bool, :filter) do + { terms: { enum_field: enum_values } } + end + end +end +``` + +### Boolean Filters (Straightforward) + +Boolean filters are also straightforward since they only accept true/false values: + +```ruby +def by_boolean_field(query_hash:, options:) + boolean_value = options[:boolean_field] + return query_hash if boolean_value.nil? + + # Simple validation for boolean values + return query_hash unless boolean_value.in?([true, false]) + + context.name(:filters) do + add_filter(query_hash, :query, :bool, :filter) do + { term: { boolean_field: { value: boolean_value } } } + end + end +end +``` + +### Text Search Filters + +```ruby +def by_text_search(query_hash:, options:) + search_term = options[:text_search] + return query_hash if search_term.blank? + + context.name(:filters) do + add_filter(query_hash, :query, :bool, :filter) do + { + simple_query_string: { + fields: ["field_name", "field_name.ngram"], + query: search_term, + lenient: true, + default_operator: :and + } + } + end + end +end +``` + +## Performance Monitoring + +### Using Performance Bar to Monitor Elasticsearch Queries + +GitLab provides a performance bar that shows Elasticsearch queries executed during GraphQL requests. This is invaluable for debugging and optimizing your filters. + +**Enabling the Performance Bar:** + +1. **For Administrators**: The performance bar is automatically available +2. **For Non-administrators**: Must be enabled in Admin settings + - Go to **Admin Area > Settings > Metrics and profiling** + - Select **Allow non-administrators access to the performance bar** + +**Monitoring Elasticsearch Queries:** + +1. **Enable the performance bar** by pressing `p` + `b` on any GitLab page +2. **Execute your GraphQL query** that uses the new filter +3. **Click on the `es` section** in the performance bar to see: + - Number of Elasticsearch queries executed + - Total duration of all queries + - Individual query details including: + - Query method (GET, POST, etc.) + - Query path and parameters + - Execution time for each query + +**Performance Bar Elasticsearch View:** + +The performance bar shows Elasticsearch metrics with color-coded warnings: +- **Green**: Normal performance +- **Yellow**: Approaching thresholds (5+ calls or 1000ms+ duration) +- **Red**: Exceeding performance thresholds + +**Example Performance Bar Output:** +``` +es: 3 (1.2s) +``` +This indicates 3 Elasticsearch queries taking 1.2 seconds total. + +**Detailed Query Information:** + +Click on the `es` count to see detailed information: +```json +{ + "method": "POST", + "path": "/gitlab-vulnerabilities/_search", + "params": { + "routing": "group_123", + "timeout": "30s" + }, + "duration": 450.2 +} +``` + +**Performance Thresholds:** + +The performance bar uses these default thresholds: +- **Calls**: 5 queries (warning threshold) +- **Duration**: 1000ms total (warning threshold) +- **Individual Call**: 1000ms per query (warning threshold) + +**Best Practices for Performance:** +- Keep the number of ES queries low (ideally 1-2 per request) +- Optimize query complexity to stay under duration thresholds +- Use appropriate field types (keyword vs text) for your use case +- Consider caching for frequently accessed data + +## Troubleshooting + +### Common Issues + +1. **Migration Not Complete**: Ensure Elasticsearch migrations are finished before enabling filters +2. **Permission Denied**: Verify user has required permissions and feature flags are enabled +3. **Query Performance**: Monitor Elasticsearch query performance and optimize as needed +4. **Data Inconsistency**: Ensure proper synchronization between PostgreSQL and Elasticsearch + +### Debugging + +1. **Enable Query Logging**: Use Elasticsearch query logging to debug issues +2. **Check Migration Status**: Verify migration completion status +3. **Test Feature Flags**: Ensure feature flags are properly configured +4. **Validate Data**: Check that data is properly indexed in Elasticsearch + +## Related Documentation + +- [Elasticsearch Integration](../../integration/advanced_search/elasticsearch.md) +- [GraphQL Development](../api_graphql_styleguide.md) +- [Background Migrations](../database/batched_background_migrations.md) +- [Feature Flags](../feature_flags/index.md) +- [Performance Bar](../../administration/monitoring/performance/performance_bar.md) +- [Vulnerability Management](./index.md) +- [SBOM Dependency Graph Ingestion](./sbom_dependency_graph_ingestion_overview.md) +- [Change Data Capture Epic](https://gitlab.com/groups/gitlab-org/-/epics/18520) \ No newline at end of file -- GitLab From 7f1f4f00700b1fba72fbc250653699a4ad1826f0 Mon Sep 17 00:00:00 2001 From: Bala Kumar Date: Mon, 21 Jul 2025 20:03:21 +0530 Subject: [PATCH 2/3] Add additional docs --- .../adding_elasticsearch_filters.md | 665 ++++++++++++++++++ ...lastic_search_integration_architechture.md | 161 +++++ .../img/es_ingestion_high_level_arch.png | Bin 0 -> 188559 bytes .../img/es_ingestion_querying.png | Bin 0 -> 166807 bytes .../img/es_ingestion_high_level_arch.png | Bin 0 -> 188559 bytes .../img/es_ingestion_querying.png | Bin 0 -> 166807 bytes 6 files changed, 826 insertions(+) create mode 100644 doc/development/sec/vulnerability_management/adding_elasticsearch_filters.md create mode 100644 doc/development/sec/vulnerability_management/elastic_search_integration_architechture.md create mode 100644 doc/development/sec/vulnerability_management/img/es_ingestion_high_level_arch.png create mode 100644 doc/development/sec/vulnerability_management/img/es_ingestion_querying.png create mode 100644 doc/development/vulnerability_management/img/es_ingestion_high_level_arch.png create mode 100644 doc/development/vulnerability_management/img/es_ingestion_querying.png diff --git a/doc/development/sec/vulnerability_management/adding_elasticsearch_filters.md b/doc/development/sec/vulnerability_management/adding_elasticsearch_filters.md new file mode 100644 index 00000000000000..73dd053dbfaa86 --- /dev/null +++ b/doc/development/sec/vulnerability_management/adding_elasticsearch_filters.md @@ -0,0 +1,665 @@ +# Adding New Elasticsearch Filters for Vulnerability Management + +This guide covers how to add new filters using Elasticsearch for advanced vulnerability management features in GitLab. These features are part of the advanced vulnerability management capabilities and require Elasticsearch to be configured. + +## Overview + +Advanced vulnerability management features in GitLab use Elasticsearch to provide enhanced filtering capabilities that go beyond what's possible with PostgreSQL alone. This includes features like: + +- Advanced OWASP Top 10 filtering +- Identifier name searching +- Reachability filtering +- Complex aggregations and analytics + +## Prerequisites + +Before adding a new Elasticsearch filter, ensure you understand: + +- GitLab's Elasticsearch integration architecture +- Vulnerability data model and relationships +- GraphQL resolver patterns +- Database migration patterns +- Feature flag usage + +## Step-by-Step Implementation Guide + +### 1. GraphQL Resolver Updates + +First, add the new filter argument to the appropriate GraphQL resolver. Most vulnerability filters are added to `VulnerabilitiesResolver`. + +**File:** `ee/app/graphql/resolvers/vulnerabilities_resolver.rb` + +```ruby +argument :your_new_filter, GraphQL::Types::String, + required: false, + experiment: { milestone: '18.x' }, + description: 'Filter vulnerabilities by your new criteria. ' \ + 'To use this argument, you must have Elasticsearch configured and the ' \ + '`advanced_vulnerability_management` feature flag enabled. ' \ + 'Not supported on Instance Security Dashboard queries.' +``` + +**Key considerations:** +- Mark experimental features with `experiment: { milestone: 'X.Y' }` +- Include clear documentation about Elasticsearch requirements +- Note any limitations (e.g., Instance Security Dashboard support) + +### 2. Update VulnerabilityFilterable Module + +Add validation logic for your new filter in the `VulnerabilityFilterable` module. + +**File:** `ee/app/graphql/resolvers/vulnerability_filterable.rb` + +```ruby +# Add your filter to the ADVANCED_FILTERS constant if it requires ES +ADVANCED_FILTERS = [:owasp_top_10_2021, :identifier_name, :reachability, :your_new_filter].freeze + +# Add validation logic in the validate_filters method +def validate_filters(filters) + # ... existing validations ... + + validate_your_new_filter!(vulnerable) if filters[:your_new_filter].present? +end + +private + +def validate_your_new_filter!(vulnerable) + # Add any specific validation logic for your filter + # Example: check if required migrations are complete + return if Feature.enabled?(:your_new_filter_feature_flag, vulnerable) && + ::Elastic::DataMigrationService.migration_has_finished?(:add_your_field_to_vulnerability) + + raise ::Gitlab::Graphql::Errors::ArgumentError, + 'The \'your_new_filter\' argument is not currently supported. ' \ + 'This feature requires Elasticsearch and specific migrations to be complete.' +end +``` + +### 3. Use Elasticsearch Finder + +The `VulnerabilityElasticSearchFinder` automatically uses the Elasticsearch query builder. No changes are typically needed here unless you're adding a completely new finder pattern. + +**File:** `ee/app/finders/security/vulnerability_elastic_search_finder.rb` + +The finder delegates to `VulnerabilityQueryBuilder` which handles all filter logic. + +### 4. Elasticsearch Query Builder + +Add your filter logic to the vulnerability query builder. + +**File:** `ee/lib/search/elastic/vulnerability_query_builder.rb` + +```ruby +def build + # ... existing filters ... + + query_hash = ::Search::Elastic::VulnerabilityFilters.by_your_new_filter( + query_hash: query_hash, options: options) + + # ... rest of the method ... +end +``` + +### 5. Elasticsearch Vulnerability Filters + +Implement the actual filter logic in the VulnerabilityFilters module. + +**File:** `ee/lib/search/elastic/vulnerability_filters.rb` + +```ruby +def by_your_new_filter(query_hash:, options:) + your_filter_value = options[:your_new_filter] + return query_hash if your_filter_value.blank? + + # Add validation if needed + return query_hash unless valid_filter_value?(your_filter_value) + + context.name(:filters) do + add_filter(query_hash, :query, :bool, :filter) do + { + terms: { + _name: context.name(:your_new_filter), + your_field_name: your_filter_value + } + } + end + end +end + +private + +def valid_filter_value?(value) + # Add validation logic specific to your filter + # Return true if valid, false otherwise +end +``` + +**Common filter patterns:** + +- **Term filter** (exact match): `{ term: { field: { value: value } } }` +- **Terms filter** (multiple values): `{ terms: { field: values } }` +- **Range filter**: `{ range: { field: { gte: min, lte: max } } }` +- **Boolean filter** (complex logic): `{ bool: { must: [...], should: [...] } }` + +### 6. Elasticsearch Schema and Migrations + +#### Define the Elasticsearch Schema + +Update the vulnerability Elasticsearch type to include your new field. + +**File:** `ee/lib/search/elastic/types/vulnerability.rb` + +```ruby +def base_mappings + { + # ... existing mappings ... + your_field_name: { type: 'keyword' }, # or appropriate type + # ... rest of mappings ... + } +end +``` + +**Common Elasticsearch field types:** +- `keyword`: For exact matching (IDs, enums, short strings) +- `text`: For full-text search +- `short`: For small integers (enums) +- `long`: For large integers +- `boolean`: For true/false values +- `date`: For timestamps + +#### Create Elasticsearch Migration + +Create a new Elasticsearch migration to add the field to existing indices. + +**File:** `ee/elastic/migrate/YYYYMMDDHHMMSS_add_your_field_to_vulnerability.rb` + +```ruby +# frozen_string_literal: true + +class AddYourFieldToVulnerability < Elastic::Migration + include ::Search::Elastic::MigrationUpdateMappingsHelper + + DOCUMENT_TYPE = Vulnerability + + private + + def index_name + ::Search::Elastic::Types::Vulnerability.index_name + end + + def new_mappings + { + your_field_name: { + type: 'keyword' # or appropriate type + } + } + end +end +``` + +#### Create Migration Documentation + +**File:** `ee/elastic/docs/YYYYMMDDHHMMSS_add_your_field_to_vulnerability.yml` + +```yaml +--- +name: AddYourFieldToVulnerability +version: 'YYYYMMDDHHMMSS' +description: Adds your_field_name field to the Vulnerability index for enhanced filtering capabilities. +group: group::security infrastructure +milestone: '18.x' +introduced_by_url: https://gitlab.com/gitlab-org/gitlab/-/merge_requests/XXXXX +obsolete: false +marked_obsolete_by_url: +marked_obsolete_in_milestone: +``` + +### 7. Keep Elasticsearch in Sync + +#### Update Vulnerability Reads Model + +Ensure your new field is tracked for Elasticsearch updates. + +**File:** `ee/app/models/vulnerabilities/read.rb` + +```ruby +# Add your field to the tracked fields constant +ELASTICSEARCH_TRACKED_FIELDS = ::Search::Elastic::References::Vulnerability::DIRECT_FIELDS + + ::Search::Elastic::References::Vulnerability::DIRECT_TYPECAST_FIELDS + + %w[traversal_ids your_field_name] +``` + +#### Manual Bookkeeping for ActiveRecord Models + +For fields that require complex calculations or come from related models, implement manual bookkeeping: + +```ruby +# In the model that changes and affects the vulnerability field +after_commit :update_vulnerability_elasticsearch_field, on: [:create, :update, :destroy] + +private + +def update_vulnerability_elasticsearch_field + return unless vulnerability_read&.use_elasticsearch? + + # Update the field value + vulnerability_read.update_column(:your_field_name, calculate_new_value) + + # Trigger ES update + vulnerability_read.maintain_elasticsearch_update(updated_attributes: ['your_field_name']) +end +``` + +#### Bulk Operations with BulkEsOperationService + +For operations that affect multiple vulnerability records outside of ActiveRecord models, use the `BulkEsOperationService` helper: + +**File:** `ee/app/services/vulnerabilities/bulk_es_operation_service.rb` + +```ruby +# Example usage in a service that updates multiple vulnerabilities +def update_multiple_vulnerabilities(vulnerability_relation) + Vulnerabilities::BulkEsOperationService.new(vulnerability_relation).execute do |relation| + # Perform your database updates here + relation.update_all(your_field_name: new_value) + end +end +``` + +**Key benefits of BulkEsOperationService:** +- Handles preloading of necessary associations +- Filters to only eligible vulnerabilities (those that should be indexed) +- Batches Elasticsearch updates efficiently +- Works with both `Vulnerability` and `Vulnerabilities::Read` relations + +#### Sync During Vulnerability Ingestion Framework + +For bulk operations that don't use ActiveRecord models (like vulnerability ingestion), perform manual sync: + +**Example from Security Ingestion:** + +```ruby +# ee/app/services/security/ingestion/tasks/ingest_remediations.rb +def update_vulnerability_reads + unfound_reads = Vulnerabilities::Read.by_vulnerabilities( + vulnerability_ids_for_remediations(unfound_remediations)) + ::Vulnerabilities::BulkEsOperationService.new(unfound_reads).execute do |relation| + relation.update_all(has_remediations: false) + end + + found_reads = Vulnerabilities::Read.by_vulnerabilities( + vulnerability_ids_for_remediations(found_remediations)) + ::Vulnerabilities::BulkEsOperationService.new(found_reads).execute do |relation| + relation.update_all(has_remediations: true) + end +end +``` + +**Example from SBOM Ingestion:** + +```ruby +# ee/app/services/sbom/ingestion/tasks/ingest_occurrences_vulnerabilities.rb +def after_ingest + return unless return_data.present? + + vulnerabilities_relation = Vulnerability.id_in(return_data.flatten) + sync_elasticsearch(vulnerabilities_relation) if vulnerabilities_relation.present? +end + +def sync_elasticsearch(vulnerabilities) + ::Vulnerabilities::BulkEsOperationService.new(vulnerabilities).execute(&:itself) +end +``` + +#### Sync During Project/Group Operations + +**Project Deletion:** + +```ruby +# ee/app/services/vulnerabilities/removal/remove_from_project_service.rb +def sync_elasticsearch + vulnerabilities_to_delete = Vulnerability.id_in(vulnerability_ids) + Vulnerabilities::BulkEsOperationService.new(vulnerabilities_to_delete).execute(&:itself) +end +``` + +**Project/Group Transfer:** + +When projects or groups are transferred, vulnerability traversal IDs need to be updated: + +```ruby +# Update traversal_ids for vulnerabilities when group structure changes +Vulnerabilities::UpdateTraversalIdsOfVulnerabilityReadsService.new( + group_id: new_group.id +).execute +``` + +#### Future: Change Data Capture (CDC) + +GitLab is planning to move synchronization outside of application logic using Change Data Capture from PostgreSQL. This work is tracked in [Epic 18520](https://gitlab.com/groups/gitlab-org/-/epics/18520). + +**Benefits of CDC approach:** +- Removes sync logic from application code +- Reduces application complexity +- Improves reliability and consistency +- Enables real-time synchronization +- Reduces performance impact on application operations + +**Current Status:** +- In planning/research phase +- Will gradually replace manual sync mechanisms +- Timeline and implementation details are being defined + +### 8. Elasticsearch Backfill Migration + +Create a background migration to populate the new field for existing records. + +**File:** `lib/gitlab/background_migration/backfill_your_field_to_vulnerability_reads.rb` + +```ruby +# frozen_string_literal: true + +module Gitlab + module BackgroundMigration + class BackfillYourFieldToVulnerabilityReads < BatchedMigrationJob + operation_name :backfill_your_field_to_vulnerability_reads + feature_category :vulnerability_management + + def perform + each_sub_batch do |sub_batch| + sub_batch.update_all(your_field_name: calculate_field_value) + end + end + + private + + def calculate_field_value + # Implement logic to calculate the field value + # This might involve joins or complex calculations + end + end + end +end +``` + +**Queue the migration:** + +**File:** `db/post_migrate/YYYYMMDDHHMMSS_queue_backfill_your_field_to_vulnerability_reads.rb` + +```ruby +# frozen_string_literal: true + +class QueueBackfillYourFieldToVulnerabilityReads < Gitlab::Database::Migration[2.2] + milestone '18.x' + + restrict_gitlab_migration gitlab_schema: :gitlab_main + + def up + queue_batched_background_migration( + :backfill_your_field_to_vulnerability_reads, + :vulnerability_reads, + :vulnerability_id, + job_class_name: 'BackfillYourFieldToVulnerabilityReads' + ) + end + + def down + delete_batched_background_migration( + :backfill_your_field_to_vulnerability_reads, + :vulnerability_reads, + :vulnerability_id, + 'BackfillYourFieldToVulnerabilityReads' + ) + end +end +``` + +### 9. Feature Flags + +#### Create Feature Flag + +**File:** `ee/config/feature_flags/beta/your_new_filter.yml` + +```yaml +--- +name: your_new_filter +description: Enable the new filter for vulnerability management +feature_issue_url: https://gitlab.com/groups/gitlab-org/-/epics/XXXXX +introduced_by_url: https://gitlab.com/gitlab-org/gitlab/-/merge_requests/XXXXX +rollout_issue_url: https://gitlab.com/gitlab-org/gitlab/-/issues/XXXXX +milestone: '18.x' +group: group::security infrastructure +type: beta +default_enabled: false +``` + +#### Use Feature Flag in Code + +```ruby +# In validation logic +return unless Feature.enabled?(:your_new_filter, vulnerable) + +# In filter logic +return query_hash unless Feature.enabled?(:your_new_filter, options[:current_user]) +``` + +### 10. UI Access Control + +The UI automatically respects the `access_advanced_vulnerability_management` ability. This ability is granted when: + +1. User has `:read_security_resource` permission +2. Vulnerability indexing is enabled (Elasticsearch configured) +3. `advanced_vulnerability_management` feature flag is enabled +4. Required Elasticsearch migrations are complete + +**File:** `ee/app/policies/vulnerabilities/advanced_vulnerability_management_policy.rb` + +The policy automatically handles access control. No changes needed unless you have specific requirements. + +**Frontend Integration:** + +In Vue components, check the ability: + +```javascript +// The ability is automatically pushed to frontend in vulnerability controllers +computed: { + canUseAdvancedFilters() { + return this.glFeatures.accessAdvancedVulnerabilityManagement; + } +} +``` + +## Testing + +### Unit Tests + +1. **GraphQL Resolver Tests**: Test argument validation and filter application +2. **Finder Tests**: Test Elasticsearch query generation +3. **Filter Tests**: Test individual filter logic +4. **Migration Tests**: Test background migration logic + +### Integration Tests + +1. **End-to-end GraphQL Tests**: Test complete filter functionality +2. **Elasticsearch Integration Tests**: Test actual ES queries +3. **Feature Flag Tests**: Test behavior with flags enabled/disabled + +## Best Practices + +### Performance Considerations + +1. **Index Optimization**: Choose appropriate field types for your use case +2. **Query Efficiency**: Use term filters for exact matches, avoid expensive operations +3. **Pagination**: Always implement proper pagination for large result sets +4. **Caching**: Consider caching expensive calculations + +### Security Considerations + +1. **Input Validation**: Always validate filter inputs +2. **Access Control**: Respect existing permission models +3. **Data Exposure**: Ensure filters don't expose sensitive information + +### Maintainability + +1. **Documentation**: Document complex filter logic +2. **Testing**: Comprehensive test coverage for all scenarios +3. **Monitoring**: Add metrics for filter usage and performance +4. **Backwards Compatibility**: Consider migration paths for existing data + +## Common Patterns + +### Enum-based Filters (Straightforward) + +Enum and boolean field filters are straightforward to implement since they map directly to database values: + +```ruby +def by_enum_field(query_hash:, options:) + enum_values = options[:enum_field] + return query_hash if enum_values.blank? + + # Validate enum values - this is straightforward since enums have fixed values + valid_values = YourModel.enum_field.values + return query_hash unless (enum_values - valid_values).empty? + + context.name(:filters) do + add_filter(query_hash, :query, :bool, :filter) do + { terms: { enum_field: enum_values } } + end + end +end +``` + +### Boolean Filters (Straightforward) + +Boolean filters are also straightforward since they only accept true/false values: + +```ruby +def by_boolean_field(query_hash:, options:) + boolean_value = options[:boolean_field] + return query_hash if boolean_value.nil? + + # Simple validation for boolean values + return query_hash unless boolean_value.in?([true, false]) + + context.name(:filters) do + add_filter(query_hash, :query, :bool, :filter) do + { term: { boolean_field: { value: boolean_value } } } + end + end +end +``` + +### Text Search Filters + +```ruby +def by_text_search(query_hash:, options:) + search_term = options[:text_search] + return query_hash if search_term.blank? + + context.name(:filters) do + add_filter(query_hash, :query, :bool, :filter) do + { + simple_query_string: { + fields: ["field_name", "field_name.ngram"], + query: search_term, + lenient: true, + default_operator: :and + } + } + end + end +end +``` + +## Performance Monitoring + +### Using Performance Bar to Monitor Elasticsearch Queries + +GitLab provides a performance bar that shows Elasticsearch queries executed during GraphQL requests. This is invaluable for debugging and optimizing your filters. + +**Enabling the Performance Bar:** + +1. **For Administrators**: The performance bar is automatically available +2. **For Non-administrators**: Must be enabled in Admin settings + - Go to **Admin Area > Settings > Metrics and profiling** + - Select **Allow non-administrators access to the performance bar** + +**Monitoring Elasticsearch Queries:** + +1. **Enable the performance bar** by pressing `p` + `b` on any GitLab page +2. **Execute your GraphQL query** that uses the new filter +3. **Click on the `es` section** in the performance bar to see: + - Number of Elasticsearch queries executed + - Total duration of all queries + - Individual query details including: + - Query method (GET, POST, etc.) + - Query path and parameters + - Execution time for each query + +**Performance Bar Elasticsearch View:** + +The performance bar shows Elasticsearch metrics with color-coded warnings: +- **Green**: Normal performance +- **Yellow**: Approaching thresholds (5+ calls or 1000ms+ duration) +- **Red**: Exceeding performance thresholds + +**Example Performance Bar Output:** +``` +es: 3 (1.2s) +``` +This indicates 3 Elasticsearch queries taking 1.2 seconds total. + +**Detailed Query Information:** + +Click on the `es` count to see detailed information: +```json +{ + "method": "POST", + "path": "/gitlab-vulnerabilities/_search", + "params": { + "routing": "group_123", + "timeout": "30s" + }, + "duration": 450.2 +} +``` + +**Performance Thresholds:** + +The performance bar uses these default thresholds: +- **Calls**: 5 queries (warning threshold) +- **Duration**: 1000ms total (warning threshold) +- **Individual Call**: 1000ms per query (warning threshold) + +**Best Practices for Performance:** +- Keep the number of ES queries low (ideally 1-2 per request) +- Optimize query complexity to stay under duration thresholds +- Use appropriate field types (keyword vs text) for your use case +- Consider caching for frequently accessed data + +## Troubleshooting + +### Common Issues + +1. **Migration Not Complete**: Ensure Elasticsearch migrations are finished before enabling filters +2. **Permission Denied**: Verify user has required permissions and feature flags are enabled +3. **Query Performance**: Monitor Elasticsearch query performance and optimize as needed +4. **Data Inconsistency**: Ensure proper synchronization between PostgreSQL and Elasticsearch + +### Debugging + +1. **Enable Query Logging**: Use Elasticsearch query logging to debug issues +2. **Check Migration Status**: Verify migration completion status +3. **Test Feature Flags**: Ensure feature flags are properly configured +4. **Validate Data**: Check that data is properly indexed in Elasticsearch + +## Related Documentation + +- [Elasticsearch Integration](../../integration/advanced_search/elasticsearch.md) +- [GraphQL Development](../api_graphql_styleguide.md) +- [Background Migrations](../database/batched_background_migrations.md) +- [Feature Flags](../feature_flags/index.md) +- [Performance Bar](../../administration/monitoring/performance/performance_bar.md) +- [Vulnerability Management](./index.md) +- [SBOM Dependency Graph Ingestion](./sbom_dependency_graph_ingestion_overview.md) +- [Change Data Capture Epic](https://gitlab.com/groups/gitlab-org/-/epics/18520) \ No newline at end of file diff --git a/doc/development/sec/vulnerability_management/elastic_search_integration_architechture.md b/doc/development/sec/vulnerability_management/elastic_search_integration_architechture.md new file mode 100644 index 00000000000000..e132ebfec2a5da --- /dev/null +++ b/doc/development/sec/vulnerability_management/elastic_search_integration_architechture.md @@ -0,0 +1,161 @@ +--- +stage: SRM +group: Security Infrastructure +info: Any user with at least the Maintainer role can merge updates to this content. For details, see https://docs.gitlab.com/development/development_processes/#development-guidelines-review. +title: Elasticsearch Integration Architecture for Vulnerability Management +--- + +# Elasticsearch Integration Architecture for Vulnerability Management + +This document describes the architecture and implementation details of GitLab's Elasticsearch integration for advanced vulnerability management features. + +## Overview + +The Elasticsearch integration for vulnerability management provides advanced querying capabilities including: + +- Complex filtering (OWASP Top 10, identifier names, reachability) +- Full-text search across vulnerability identifiers + +## Architecture Diagrams + +### High-Level Ingestion Architecture + +![High-Level Ingestion Architecture diagram](img/es_ingestion_high_level_arch.png) + +```mermaid +graph TB + subgraph "GitLab Application" + A[Security Scanner] --> B[Security Report Artifact] + B --> C[Security Report Ingestion] + C --> D[PostgreSQL Database] + C --> E[Vulnerabilities::Read Model] + end + + subgraph "Elasticsearch Integration" + E --> F[ES Indexing Service] + F --> G[Elasticsearch Cluster] + D --> H[Background Jobs] + H --> F + end + + subgraph "Query Layer" + I[GraphQL API] --> J[VulnerabilityElasticSearchFinder] + J --> K[VulnerabilityQueryBuilder] + K --> G + G --> L[Search Results] + L --> I + end + + subgraph "Data Synchronization" + M[ActiveRecord Callbacks] --> F + N[Background Migrations] --> F + O[Bulk Operations] --> P[BulkEsOperationService] + P --> F + end +``` + +### Detailed Ingestion and Querying Flow + +![Ingestion & Querying](img/es_ingestion_querying.png) + +```mermaid +flowchart TD + A[📥 Data Ingestion] --> B[💾 Backfill] + A --> C[🔄 Continuous Updates] + + B --> D[⬆️ Ingest Existing Data into ES] + + C --> E[⚡ Model Callback CUD Changes] + C --> F[💾 Bulk Updates without ActiveRecord] + + E --> G[⬆️ Update ES with CUD Changes] + F --> H[⬆️ Perform Bulk Updates in ES] + + I[🔍 Querying] --> J[🔍 Filtering/Searching Operations] + J --> K[📋 Fetch Vulnerability IDs from ES] + K --> L[🎯 Presentation Logic from PG with the fetched IDs] +``` + +```mermaid +sequenceDiagram + participant Scanner as Security Scanner + participant Pipeline as CI Pipeline + participant Ingestion as Report Ingestion + participant PG as PostgreSQL + participant ES as Elasticsearch + participant API as GraphQL API + participant UI as Frontend UI + + Note over Scanner, UI: Data Ingestion Flow + Scanner->>Pipeline: Generate Security Report + Pipeline->>Ingestion: Upload Report Artifact + Ingestion->>PG: Store Vulnerability Data + Ingestion->>ES: Index Vulnerability (via callbacks) + + Note over Scanner, UI: Background Synchronization + PG->>ES: Sync via Background Jobs + PG->>ES: Bulk Updates via BulkEsOperationService + + Note over Scanner, UI: Query Flow + UI->>API: GraphQL Query with Filters + API->>ES: Execute Elasticsearch Query + ES->>API: Return Search Results + API->>UI: Formatted Response + + Note over Scanner, UI: Fallback Mechanism + API->>PG: Fallback to PostgreSQL (if ES unavailable) + PG->>API: Basic Query Results +``` + +## Integration Stages + +It involves Data Ingestion and sync to ES. + +#### 1.1 Security Report Processing +- Security scanners generate vulnerability reports in JSON format +- Reports are uploaded as CI/CD job artifacts +- The security report ingestion framework processes these artifacts +- Vulnerability data is stored in PostgreSQL tables + +#### 1.2 Elasticsearch Bookkeeping +- Bookkeeping during the vulnerability ingestion flow. + - Refer code here. +- Also `Vulnerabilities::Read` and `Vulnerability` model acts as the indexing source + - ActiveRecord callbacks trigger Elasticsearch updates on data changes +- From the service classes which processes vulnerabilities we use + - `bulk_es_operation_service`. + +#### 1.3 Elasticsearch indexing +- The bookkeeping sync above adds references in Redis. +- We have the bulk indexer Sidekiq cron which processes the refs and indexes ES. + +**Key Components:** +- `ee/lib/gitlab/elastic/bulk_indexer.rb` - ES bulk_indexer + + + +## Troubleshooting + +### Common Issues +- **Sync Lag**: Check background job queues and ES cluster health +- **Query Failures**: Verify feature flags and migration status +- **Permission Errors**: Validate user permissions and access policies +- **Performance Issues**: Review query patterns and ES cluster resources + +### Debugging Tools +- Performance bar ES query monitoring +- ES query logging and profiling +- Background job monitoring +- Feature flag status checking + +## Related Documentation + +- [Adding New Elasticsearch Filters](adding_elasticsearch_filters.md) +- [Elasticsearch Vulnerability Data Model](elastic_search_vulnerability_data_model.md) +- [Security Report Ingestion Overview](../security_report_ingestion_overview.md) + +## References + +- [POC Issue #514697](https://gitlab.com/gitlab-org/gitlab/-/issues/514697) +- [Vulnerability Management Epic #13510](https://gitlab.com/groups/gitlab-org/-/epics/13510) +- [Change Data Capture Epic #18520](https://gitlab.com/groups/gitlab-org/-/epics/18520) \ No newline at end of file diff --git a/doc/development/sec/vulnerability_management/img/es_ingestion_high_level_arch.png b/doc/development/sec/vulnerability_management/img/es_ingestion_high_level_arch.png new file mode 100644 index 0000000000000000000000000000000000000000..79531b1a37d0add3f5cb0b18fed1a43d0edaa136 GIT binary patch literal 188559 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