feat(error-detection): add multiple pattern support

Add support for configuring multiple error detection regex patterns at both
global (ConfigMap) and repository (CR) levels. This allows users to match
different error formats from various linters and tools in a single pipeline.

Global Configuration (ConfigMap):
- Changed error-detection-simple-regexp to support arrays
- Supports 3 formats: single pattern (backward compatible), multi-line YAML,
  and JSON array

Repository CR:
- Added ErrorDetectionSettings with patterns array and max_number_of_lines
- Patterns are additive with global patterns
- Per-repository max_number_of_lines override

Jira: https://issues.redhat.com/browse/SRVKP-7237

Signed-off-by: Akshay Pant <[email protected]>
Assisted-by: Cursor <[email protected]>

Author: theakshaypant

config/300-repositories.yaml

@@ -446,6 +446,43 @@ spec:
                         - roles
                         - secret_ref
                       type: object
+                    error_detection:
+                      description: |-
+                        ErrorDetection configures error detection for this repository. Error detection scans
+                        container logs for error patterns and creates annotations (currently GitHub-only).
+                        The global error-detection-from-container-logs setting must be enabled for this to work.
+                        If not specified, uses only global error detection pattern.
+                      properties:
+                        enabled:
+                          description: |-
+                            Enabled controls whether error detection is active for this repository.
+                            This field is required when error_detection settings are specified.
+                            Set to true to enable or false to disable error detection for this repository.
+                          type: boolean
+                        max_number_of_lines:
+                          description: |-
+                            MaxNumberOfLines specifies how many lines to scan from the end of container logs
+                            when looking for errors. This overrides the global error-detection-max-number-of-lines setting.
+                            Higher values may increase memory usage. Use -1 for unlimited.
+                            If not specified, uses the global setting (default: 50).
+                          minimum: -1
+                          type: integer
+                        patterns:
+                          description: |-
+                            Patterns is an array of regular expressions used to detect errors in container logs.
+                            Each pattern must use named groups to capture: filename, line, and error.
+                            The column group is optional. Example pattern:
+                            ^(?P<filename>[^:]*):(?P<line>[0-9]+):(?P<column>[0-9]+)?([ ]*)?(?P<error>.*)
+
+                            Multiple patterns can be specified to match different error formats.
+                            Repository-specific patterns are tried first, followed by global patterns.
+                            If not specified or empty, only the global error-detection-simple-regexp patterns are used.
+                          items:
+                            type: string
+                          type: array
+                      required:
+                        - enabled
+                      type: object
                     github:
                       properties:
                         comment_strategy:

config/302-pac-configmap.yaml

@@ -101,7 +101,19 @@ data:
   # memory usage.  Use -1 for unlimited lines.
   error-detection-max-number-of-lines: "50"
 
-  # The default regexp used when we use the simple error detection
+  # The default regexp(s) used for simple error detection.
+  # Supports multiple formats for backward compatibility:
+  #
+  # 1. Single pattern (backward compatible):
+  #    error-detection-simple-regexp: '^(?P<filename>[^:]*):(?P<line>[0-9]+):(?P<column>[0-9]+)?([ ]*)?(?P<error>.*)'
+  #
+  # 2. YAML list format (multiple patterns, one per line):
+  #    error-detection-simple-regexp: |-
+  #      ^(?P<filename>[^:]*):(?P<line>[0-9]+):(?P<column>[0-9]+)?([ ]*)?(?P<error>.*)
+  #      ^ERROR: (?P<filename>[^ ]+) line (?P<line>[0-9]+): (?P<error>.*)
+  #      ^\[(?P<filename>[^\]]+)\]:(?P<line>[0-9]+) - (?P<error>.*)
+  #
+  # Each pattern must include named groups: filename, line, and error (column is optional)
   error-detection-simple-regexp: |-
     ^(?P<filename>[^:]*):(?P<line>[0-9]+):(?P<column>[0-9]+)?([ ]*)?(?P<error>.*)
 

docs/content/docs/guide/repositorycrd.md

@@ -185,6 +185,118 @@ spec:
       comment_strategy: "disable_all"
 ```
 
+## Error Detection
+
+Error detection scans container logs for error patterns and creates inline
+annotations on Pull Requests. This feature is currently **only supported for
+GitHub Apps**.
+
+By default, error detection uses the global pattern configured in the
+`pipelines-as-code` ConfigMap via the `error-detection-simple-regexp` setting.
+However, you can customize error detection patterns on a per-repository basis
+using the Repository CR.
+
+### Configuring Error Detection Patterns
+
+You can specify multiple regex patterns to detect different error formats in
+your repository:
+
+```yaml
+apiVersion: "pipelinesascode.tekton.dev/v1alpha1"
+kind: Repository
+metadata:
+  name: my-repo
+spec:
+  url: "https://github.com/owner/repo"
+  settings:
+    error_detection:
+      enabled: true 
+      patterns:
+        - "^(?P<filename>[^:]*):(?P<line>[0-9]+):(?P<column>[0-9]+)?([ ]*)?(?P<error>.*)"
+        - "^ERROR: (?P<filename>[^ ]+) line (?P<line>[0-9]+): (?P<error>.*)"
+      max_number_of_lines: 100
+```
+
+**Pattern Requirements:**
+
+Each pattern must use [named groups](https://www.regular-expressions.info/named.html) to capture:
+
+- `filename`: The file path where the error occurred
+- `line`: The line number
+- `error`: The error message
+- `column`: (optional) The column number
+
+**Configuration Options:**
+
+- `enabled`: **Required** boolean flag to enable or disable error detection for this
+  repository. Set to `true` to enable or `false` to disable error detection.
+  This field must be explicitly specified when configuring error detection settings.
+- `patterns`: Array of regex patterns. Repository-specific patterns are tried
+  first, followed by global patterns. If not specified or empty, only the
+  global patterns are used. **Note:** Providing an empty array does not disable
+  error detection; it falls back to using only the global patterns defined in
+  the `pipelines-as-code` ConfigMap.
+- `max_number_of_lines`: Number of log lines to scan (overrides global
+  setting). Default is 50. Use -1 for unlimited.
+
+### Examples
+
+**Multiple error formats:**
+
+```yaml
+spec:
+  settings:
+    error_detection:
+      enabled: true
+      patterns:
+        # Standard format (make, gcc, eslint, etc.)
+        - "^(?P<filename>[^:]*):(?P<line>[0-9]+):(?P<column>[0-9]+)?([ ]*)?(?P<error>.*)"
+        # Python traceback format
+        - 'File "(?P<filename>[^"]+)", line (?P<line>[0-9]+).*\n.*(?P<error>.*)'
+        # Custom CI format
+        - "^\\[(?P<filename>[^\\]]+)\\]:(?P<line>[0-9]+) - (?P<error>.*)"
+      max_number_of_lines: 200
+```
+
+**Disabling error detection for a repository:**
+
+You can explicitly disable error detection for a specific repository, even if
+it's enabled globally:
+
+```yaml
+spec:
+  settings:
+    error_detection:
+      enabled: false
+```
+
+**Using only global patterns:**
+
+If you want to use only the global patterns defined in the `pipelines-as-code`
+ConfigMap with custom settings, provide an empty `patterns` array:
+
+```yaml
+spec:
+  settings:
+    error_detection:
+      enabled: true
+      patterns: []  # Uses only global patterns
+      max_number_of_lines: 100  # Can still override line count
+```
+
+If you don't need to customize error detection at all, simply omit the
+entire `error_detection` field and the global settings will be used.
+
+{{< hint info >}}
+**Pattern Priority:** When repository-specific patterns are defined, they are
+tried first for each log line. If no repository pattern matches, the global
+patterns are then tried. This allows you to add repository-specific patterns
+while still benefiting from the global patterns as a fallback.
+{{< /hint >}}
+
+For more information about error detection and log snippets, see the
+[Status documentation]({{< relref "/docs/guide/statuses.md" >}}).
+
 ## Concurrency
 
 `concurrency_limit` allows you to define the maximum number of PipelineRuns running at any time for a Repository.

docs/content/docs/guide/statuses.md

@@ -84,8 +84,10 @@ You can customize the regular expression used for detecting errors with the
 `error-detection-simple-regexp` setting. The regular expression uses [named
 groups](https://www.regular-expressions.info/named.html) to provide flexibility
 in specifying the matching criteria. The necessary groups for matching are
-filename, line, and error (the column group is not used). The default regular
-expression is defined in the configuration map.
+filename, line, and error (the column group is optional). The default regular
+expression is defined in the configuration map. Multiple patterns are supported
+using multi-line YAML or JSON array format, allowing you to detect errors from
+different tools with various output formats.
 
 By default, Pipelines-as-Code searches for errors in only the last 50 lines of
 the container logs. However, you can increase this limit by setting the
@@ -94,6 +96,14 @@ system will search through all available lines for errors. Keep in mind that
 increasing this maximum number of lines may increase the memory usage of the
 watcher.
 
+{{< hint info >}}
+**Repository-level configuration:** You can also configure error detection
+patterns on a per-repository basis using the Repository CR. This allows you to
+define multiple patterns and customize settings for individual repositories.
+See the [Repository CR documentation]({{< relref "/docs/guide/repositorycrd.md#error-detection" >}})
+for more details.
+{{< /hint >}}
+
 ![annotations](/images/github-annotation-error-failure-detection.png)
 
 ## Namespace Event stream

docs/content/docs/install/operator_installation.md

@@ -45,6 +45,7 @@ spec:
           hub-url: 'https://artifacthub.io'
           hub-catalog-type: 'artifacthub'
           error-detection-max-number-of-lines: '50'
+          # Single pattern example. For multiple patterns, use multi-line format (see settings docs)
           error-detection-simple-regexp: >-
             ^(?P<filename>[^:]*):(?P<line>[0-9]+):(?P<column>[0-9]+):([
             ]*)?(?P<error>.*)

docs/content/docs/install/settings.md

@@ -279,6 +279,10 @@ A few settings are available to configure this feature:
   and expose them as annotations on Pull Request.
 
   Only GitHub apps is supported.
+  
+  **Note:** Individual repositories can override this setting using the `error_detection.enabled`
+  field in the Repository CR. See the [Repository CRD documentation]({{< relref "/docs/guide/repositorycrd.md#error-detection" >}})
+  for more details.
 
 * `error-detection-max-number-of-lines`
 
@@ -291,6 +295,33 @@ A few settings are available to configure this feature:
    By default the error detection only support a simple output, the way GCC or
    Make will output error, which is supported by most linters and command line tools.
 
+   **Multiple Patterns Support:** You can now specify multiple regex patterns to
+   match different error formats. The setting supports two formats:
+
+   1. **Single pattern** (backward compatible):
+
+      ```yaml
+      error-detection-simple-regexp: '^(?P<filename>[^:]*):(?P<line>[0-9]+):(?P<column>[0-9]+)?([ ]*)?(?P<error>.*)'
+      ```
+
+   2. **Multi-line YAML** (for multiple patterns):
+
+      ```yaml
+      error-detection-simple-regexp: |-
+        ^(?P<filename>[^:]*):(?P<line>[0-9]+):(?P<column>[0-9]+)?([ ]*)?(?P<error>.*)
+        ^ERROR: (?P<filename>[^ ]+) line (?P<line>[0-9]+): (?P<error>.*)
+        ^\[(?P<filename>[^\]]+)\]:(?P<line>[0-9]+) - (?P<error>.*)
+      ```
+
+   Each pattern will be tried in order until one matches. This allows you to detect
+   errors from multiple tools with different output formats.
+
+   **Pattern Requirements:** Each pattern must use regexp named groups to capture:
+  * `(?P<filename>...)` - The file path where the error occurred
+  * `(?P<line>...)` - The line number
+  * `(?P<error>...)` - The error message
+  * `(?P<column>...)` - Column number (optional)
+
    An example of an error that is supported is :
 
    ```console

pkg/apis/pipelinesascode/v1alpha1/types.go

@@ -164,6 +164,13 @@ type Settings struct {
 	// AIAnalysis contains AI/LLM analysis configuration for automated CI/CD pipeline analysis.
 	// +optional
 	AIAnalysis *AIAnalysisConfig `json:"ai,omitempty"`
+
+	// ErrorDetection configures error detection for this repository. Error detection scans
+	// container logs for error patterns and creates annotations (currently GitHub-only).
+	// The global error-detection-from-container-logs setting must be enabled for this to work.
+	// If not specified, uses only global error detection pattern.
+	// +optional
+	ErrorDetection *ErrorDetectionSettings `json:"error_detection,omitempty"`
 }
 
 type GitlabSettings struct {
@@ -184,6 +191,33 @@ type GithubSettings struct {
 	CommentStrategy string `json:"comment_strategy,omitempty"`
 }
 
+// ErrorDetectionSettings configures how errors are detected from container logs and
+// exposed as annotations on Pull Requests. Currently only supported for GitHub Apps.
+type ErrorDetectionSettings struct {
+	// Enabled controls whether error detection is active for this repository.
+	// This field is required when error_detection settings are specified.
+	// Set to true to enable or false to disable error detection for this repository.
+	Enabled bool `json:"enabled"`
+	// Patterns is an array of regular expressions used to detect errors in container logs.
+	// Each pattern must use named groups to capture: filename, line, and error.
+	// The column group is optional. Example pattern:
+	// ^(?P<filename>[^:]*):(?P<line>[0-9]+):(?P<column>[0-9]+)?([ ]*)?(?P<error>.*)
+	//
+	// Multiple patterns can be specified to match different error formats.
+	// Repository-specific patterns are tried first, followed by global patterns.
+	// If not specified or empty, only the global error-detection-simple-regexp patterns are used.
+	// +optional
+	Patterns []string `json:"patterns,omitempty"`
+
+	// MaxNumberOfLines specifies how many lines to scan from the end of container logs
+	// when looking for errors. This overrides the global error-detection-max-number-of-lines setting.
+	// Higher values may increase memory usage. Use -1 for unlimited.
+	// If not specified, uses the global setting (default: 50).
+	// +optional
+	// +kubebuilder:validation:Minimum=-1
+	MaxNumberOfLines *int `json:"max_number_of_lines,omitempty"`
+}
+
 func (s *Settings) Merge(newSettings *Settings) {
 	if newSettings.PipelineRunProvenance != "" && s.PipelineRunProvenance == "" {
 		s.PipelineRunProvenance = newSettings.PipelineRunProvenance
@@ -197,6 +231,9 @@ func (s *Settings) Merge(newSettings *Settings) {
 	if newSettings.AIAnalysis != nil && s.AIAnalysis == nil {
 		s.AIAnalysis = newSettings.AIAnalysis
 	}
+	if newSettings.ErrorDetection != nil && s.ErrorDetection == nil {
+		s.ErrorDetection = newSettings.ErrorDetection
+	}
 }
 
 type Policy struct {