Add support for Array Processor in Logs Pipelines (#3183)

Co-authored-by: ci.datadog-api-spec <packages@datadoghq.com>

Author: api-clients-generation-pipeline[bot]

.apigentools-info

@@ -4,13 +4,13 @@
     "spec_versions": {
         "v1": {
             "apigentools_version": "1.6.6",
-            "regenerated": "2025-07-02 20:43:24.266572",
-            "spec_repo_commit": "e327e6df"
+            "regenerated": "2025-07-03 15:49:15.379622",
+            "spec_repo_commit": "d781944f"
         },
         "v2": {
             "apigentools_version": "1.6.6",
-            "regenerated": "2025-07-02 20:43:24.282854",
-            "spec_repo_commit": "e327e6df"
+            "regenerated": "2025-07-03 15:49:15.401262",
+            "spec_repo_commit": "d781944f"
         }
     }
 }

.generator/schemas/v1/openapi.yaml

@@ -5163,6 +5163,143 @@ components:
       type: string
       x-enum-varnames:
       - ARITHMETIC_PROCESSOR
+    LogsArrayProcessor:
+      description: 'A processor for extracting, aggregating, or transforming values
+        from JSON arrays within your logs.
+
+        Supported operations are:
+
+        - Select value from matching element
+
+        - Compute array length
+
+        - Append a value to an array'
+      properties:
+        is_enabled:
+          default: false
+          description: Whether or not the processor is enabled.
+          type: boolean
+        name:
+          description: Name of the processor.
+          type: string
+        operation:
+          $ref: '#/components/schemas/LogsArrayProcessorOperation'
+        type:
+          $ref: '#/components/schemas/LogsArrayProcessorType'
+      required:
+      - operation
+      - type
+      type: object
+    LogsArrayProcessorOperation:
+      description: Configuration of the array processor operation to perform.
+      oneOf:
+      - $ref: '#/components/schemas/LogsArrayProcessorOperationAppend'
+      - $ref: '#/components/schemas/LogsArrayProcessorOperationLength'
+      - $ref: '#/components/schemas/LogsArrayProcessorOperationSelect'
+    LogsArrayProcessorOperationAppend:
+      description: Operation that appends a value to a target array attribute.
+      properties:
+        preserve_source:
+          default: true
+          description: Remove or preserve the remapped source element.
+          type: boolean
+        source:
+          description: Attribute path containing the value to append.
+          example: network.client.ip
+          type: string
+        target:
+          description: Attribute path of the array to append to.
+          example: sourceIps
+          type: string
+        type:
+          $ref: '#/components/schemas/LogsArrayProcessorOperationAppendType'
+      required:
+      - type
+      - source
+      - target
+      type: object
+    LogsArrayProcessorOperationAppendType:
+      description: Operation type.
+      enum:
+      - append
+      example: append
+      type: string
+      x-enum-varnames:
+      - APPEND
+    LogsArrayProcessorOperationLength:
+      description: Operation that computes the length of a `source` array and stores
+        the result in the `target` attribute.
+      properties:
+        source:
+          description: Attribute path of the array to measure.
+          example: tags
+          type: string
+        target:
+          description: Attribute that receives the computed length.
+          example: tagCount
+          type: string
+        type:
+          $ref: '#/components/schemas/LogsArrayProcessorOperationLengthType'
+      required:
+      - type
+      - source
+      - target
+      type: object
+    LogsArrayProcessorOperationLengthType:
+      description: Operation type.
+      enum:
+      - length
+      example: length
+      type: string
+      x-enum-varnames:
+      - LENGTH
+    LogsArrayProcessorOperationSelect:
+      description: Operation that finds an object in a `source` array using a `filter`,
+        and then extracts a specific value into the `target` attribute.
+      properties:
+        filter:
+          description: Filter condition expressed as `key:value` used to find the
+            matching element.
+          example: name:Referrer
+          type: string
+        source:
+          description: Attribute path of the array to search into.
+          example: httpRequest.headers
+          type: string
+        target:
+          description: Attribute that receives the extracted value.
+          example: referrer
+          type: string
+        type:
+          $ref: '#/components/schemas/LogsArrayProcessorOperationSelectType'
+        value_to_extract:
+          description: Key of the value to extract from the matching element.
+          example: value
+          type: string
+      required:
+      - type
+      - source
+      - target
+      - filter
+      - value_to_extract
+      type: object
+    LogsArrayProcessorOperationSelectType:
+      description: Operation type.
+      enum:
+      - select
+      example: select
+      type: string
+      x-enum-varnames:
+      - SELECT
+    LogsArrayProcessorType:
+      default: array-processor
+      description: Type of logs array processor.
+      enum:
+      - array-processor
+      example: array-processor
+      type: string
+      x-enum-varnames:
+      - ARRAY_PROCESSOR
     LogsAttributeRemapper:
       description: 'The remapper processor remaps any source attribute(s) or tag to
         another target attribute or tag.
@@ -6060,6 +6197,7 @@ components:
       - $ref: '#/components/schemas/ReferenceTableLogsLookupProcessor'
       - $ref: '#/components/schemas/LogsTraceRemapper'
       - $ref: '#/components/schemas/LogsSpanRemapper'
+      - $ref: '#/components/schemas/LogsArrayProcessor'
     LogsQueryCompute:
       description: Define computation for a log query.
       properties:

api/datadogV1/model_logs_array_processor.go

@@ -0,0 +1,223 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2019-Present Datadog, Inc.
+
+package datadogV1
+
+import (
+	"fmt"
+
+	"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
+)
+
+// LogsArrayProcessor A processor for extracting, aggregating, or transforming values from JSON arrays within your logs.
+// Supported operations are:
+// - Select value from matching element
+// - Compute array length
+// - Append a value to an array
+type LogsArrayProcessor struct {
+	// Whether or not the processor is enabled.
+	IsEnabled *bool `json:"is_enabled,omitempty"`
+	// Name of the processor.
+	Name *string `json:"name,omitempty"`
+	// Configuration of the array processor operation to perform.
+	Operation LogsArrayProcessorOperation `json:"operation"`
+	// Type of logs array processor.
+	Type LogsArrayProcessorType `json:"type"`
+	// UnparsedObject contains the raw value of the object if there was an error when deserializing into the struct
+	UnparsedObject       map[string]interface{} `json:"-"`
+	AdditionalProperties map[string]interface{} `json:"-"`
+}
+
+// NewLogsArrayProcessor instantiates a new LogsArrayProcessor object.
+// This constructor will assign default values to properties that have it defined,
+// and makes sure properties required by API are set, but the set of arguments
+// will change when the set of required properties is changed.
+func NewLogsArrayProcessor(operation LogsArrayProcessorOperation, typeVar LogsArrayProcessorType) *LogsArrayProcessor {
+	this := LogsArrayProcessor{}
+	var isEnabled bool = false
+	this.IsEnabled = &isEnabled
+	this.Operation = operation
+	this.Type = typeVar
+	return &this
+}
+
+// NewLogsArrayProcessorWithDefaults instantiates a new LogsArrayProcessor object.
+// This constructor will only assign default values to properties that have it defined,
+// but it doesn't guarantee that properties required by API are set.
+func NewLogsArrayProcessorWithDefaults() *LogsArrayProcessor {
+	this := LogsArrayProcessor{}
+	var isEnabled bool = false
+	this.IsEnabled = &isEnabled
+	var typeVar LogsArrayProcessorType = LOGSARRAYPROCESSORTYPE_ARRAY_PROCESSOR
+	this.Type = typeVar
+	return &this
+}
+
+// GetIsEnabled returns the IsEnabled field value if set, zero value otherwise.
+func (o *LogsArrayProcessor) GetIsEnabled() bool {
+	if o == nil || o.IsEnabled == nil {
+		var ret bool
+		return ret
+	}
+	return *o.IsEnabled
+}
+
+// GetIsEnabledOk returns a tuple with the IsEnabled field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *LogsArrayProcessor) GetIsEnabledOk() (*bool, bool) {
+	if o == nil || o.IsEnabled == nil {
+		return nil, false
+	}
+	return o.IsEnabled, true
+}
+
+// HasIsEnabled returns a boolean if a field has been set.
+func (o *LogsArrayProcessor) HasIsEnabled() bool {
+	return o != nil && o.IsEnabled != nil
+}
+
+// SetIsEnabled gets a reference to the given bool and assigns it to the IsEnabled field.
+func (o *LogsArrayProcessor) SetIsEnabled(v bool) {
+	o.IsEnabled = &v
+}
+
+// GetName returns the Name field value if set, zero value otherwise.
+func (o *LogsArrayProcessor) GetName() string {
+	if o == nil || o.Name == nil {
+		var ret string
+		return ret
+	}
+	return *o.Name
+}
+
+// GetNameOk returns a tuple with the Name field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *LogsArrayProcessor) GetNameOk() (*string, bool) {
+	if o == nil || o.Name == nil {
+		return nil, false
+	}
+	return o.Name, true
+}
+
+// HasName returns a boolean if a field has been set.
+func (o *LogsArrayProcessor) HasName() bool {
+	return o != nil && o.Name != nil
+}
+
+// SetName gets a reference to the given string and assigns it to the Name field.
+func (o *LogsArrayProcessor) SetName(v string) {
+	o.Name = &v
+}
+
+// GetOperation returns the Operation field value.
+func (o *LogsArrayProcessor) GetOperation() LogsArrayProcessorOperation {
+	if o == nil {
+		var ret LogsArrayProcessorOperation
+		return ret
+	}
+	return o.Operation
+}
+
+// GetOperationOk returns a tuple with the Operation field value
+// and a boolean to check if the value has been set.
+func (o *LogsArrayProcessor) GetOperationOk() (*LogsArrayProcessorOperation, bool) {
+	if o == nil {
+		return nil, false
+	}
+	return &o.Operation, true
+}
+
+// SetOperation sets field value.
+func (o *LogsArrayProcessor) SetOperation(v LogsArrayProcessorOperation) {
+	o.Operation = v
+}
+
+// GetType returns the Type field value.
+func (o *LogsArrayProcessor) GetType() LogsArrayProcessorType {
+	if o == nil {
+		var ret LogsArrayProcessorType
+		return ret
+	}
+	return o.Type
+}
+
+// GetTypeOk returns a tuple with the Type field value
+// and a boolean to check if the value has been set.
+func (o *LogsArrayProcessor) GetTypeOk() (*LogsArrayProcessorType, bool) {
+	if o == nil {
+		return nil, false
+	}
+	return &o.Type, true
+}
+
+// SetType sets field value.
+func (o *LogsArrayProcessor) SetType(v LogsArrayProcessorType) {
+	o.Type = v
+}
+
+// MarshalJSON serializes the struct using spec logic.
+func (o LogsArrayProcessor) MarshalJSON() ([]byte, error) {
+	toSerialize := map[string]interface{}{}
+	if o.UnparsedObject != nil {
+		return datadog.Marshal(o.UnparsedObject)
+	}
+	if o.IsEnabled != nil {
+		toSerialize["is_enabled"] = o.IsEnabled
+	}
+	if o.Name != nil {
+		toSerialize["name"] = o.Name
+	}
+	toSerialize["operation"] = o.Operation
+	toSerialize["type"] = o.Type
+
+	for key, value := range o.AdditionalProperties {
+		toSerialize[key] = value
+	}
+	return datadog.Marshal(toSerialize)
+}
+
+// UnmarshalJSON deserializes the given payload.
+func (o *LogsArrayProcessor) UnmarshalJSON(bytes []byte) (err error) {
+	all := struct {
+		IsEnabled *bool                        `json:"is_enabled,omitempty"`
+		Name      *string                      `json:"name,omitempty"`
+		Operation *LogsArrayProcessorOperation `json:"operation"`
+		Type      *LogsArrayProcessorType      `json:"type"`
+	}{}
+	if err = datadog.Unmarshal(bytes, &all); err != nil {
+		return datadog.Unmarshal(bytes, &o.UnparsedObject)
+	}
+	if all.Operation == nil {
+		return fmt.Errorf("required field operation missing")
+	}
+	if all.Type == nil {
+		return fmt.Errorf("required field type missing")
+	}
+	additionalProperties := make(map[string]interface{})
+	if err = datadog.Unmarshal(bytes, &additionalProperties); err == nil {
+		datadog.DeleteKeys(additionalProperties, &[]string{"is_enabled", "name", "operation", "type"})
+	} else {
+		return err
+	}
+
+	hasInvalidField := false
+	o.IsEnabled = all.IsEnabled
+	o.Name = all.Name
+	o.Operation = *all.Operation
+	if !all.Type.IsValid() {
+		hasInvalidField = true
+	} else {
+		o.Type = *all.Type
+	}
+
+	if len(additionalProperties) > 0 {
+		o.AdditionalProperties = additionalProperties
+	}
+
+	if hasInvalidField {
+		return datadog.Unmarshal(bytes, &o.UnparsedObject)
+	}
+
+	return nil
+}