From e1be6c982de3272be6c441737f4b14212de372b4 Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Tue, 16 Jun 2026 17:53:39 +0000 Subject: [PATCH] Regenerate client from commit 0e0a8fa of spec repo --- .generator/schemas/v1/openapi.yaml | 185 ++++++++++++++++++ .../frozen.json | 1 + .../recording.har | 110 +++++++++++ .../frozen.json | 1 + .../recording.har | 110 +++++++++++ .../frozen.json | 1 + .../recording.har | 110 +++++++++++ .../frozen.json | 1 + .../recording.har | 110 +++++++++++ features/v1/logs_pipelines.feature | 28 +++ services/logs_pipelines/src/v1/index.ts | 7 + .../LogsArrayMapArithmeticSubProcessor.ts | 82 ++++++++ .../models/LogsArrayMapAttributeRemapper.ts | 102 ++++++++++ .../LogsArrayMapCategorySubProcessor.ts | 75 +++++++ .../src/v1/models/LogsArrayMapProcessor.ts | 109 +++++++++++ .../v1/models/LogsArrayMapProcessorType.ts | 9 + .../LogsArrayMapStringBuilderSubProcessor.ts | 82 ++++++++ .../src/v1/models/LogsArrayMapSubProcessor.ts | 18 ++ .../src/v1/models/LogsProcessor.ts | 2 + .../src/v1/models/TypingInfo.ts | 19 ++ 20 files changed, 1162 insertions(+) create mode 100644 cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-returns-OK-response_1475401785/frozen.json create mode 100644 cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-returns-OK-response_1475401785/recording.har create mode 100644 cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-using-arithmetic-sub-processor-returns-OK-resp_2196581668/frozen.json create mode 100644 cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-using-arithmetic-sub-processor-returns-OK-resp_2196581668/recording.har create mode 100644 cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-using-category-sub-processor-returns-OK-respons_105345364/frozen.json create mode 100644 cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-using-category-sub-processor-returns-OK-respons_105345364/recording.har create mode 100644 cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-with-preserve_source-false-returns-OK-response_4107386760/frozen.json create mode 100644 cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-with-preserve_source-false-returns-OK-response_4107386760/recording.har create mode 100644 services/logs_pipelines/src/v1/models/LogsArrayMapArithmeticSubProcessor.ts create mode 100644 services/logs_pipelines/src/v1/models/LogsArrayMapAttributeRemapper.ts create mode 100644 services/logs_pipelines/src/v1/models/LogsArrayMapCategorySubProcessor.ts create mode 100644 services/logs_pipelines/src/v1/models/LogsArrayMapProcessor.ts create mode 100644 services/logs_pipelines/src/v1/models/LogsArrayMapProcessorType.ts create mode 100644 services/logs_pipelines/src/v1/models/LogsArrayMapStringBuilderSubProcessor.ts create mode 100644 services/logs_pipelines/src/v1/models/LogsArrayMapSubProcessor.ts diff --git a/.generator/schemas/v1/openapi.yaml b/.generator/schemas/v1/openapi.yaml index 1a0f742ff687..dfb47692cb4c 100644 --- a/.generator/schemas/v1/openapi.yaml +++ b/.generator/schemas/v1/openapi.yaml @@ -6182,6 +6182,190 @@ components: type: string x-enum-varnames: - ARITHMETIC_PROCESSOR + LogsArrayMapArithmeticSubProcessor: + description: |- + An arithmetic sub-processor for use inside an array-map processor. + Unlike the top-level arithmetic processor, `is_enabled` is not supported. + properties: + expression: + description: Arithmetic operation to perform. + example: "" + type: string + is_replace_missing: + default: false + description: Replace missing attribute values with 0. + type: boolean + name: + description: Name of the sub-processor. + type: string + target: + description: Target attribute path for the result. + example: "" + type: string + type: + $ref: "#/components/schemas/LogsArithmeticProcessorType" + required: + - expression + - target + - type + type: object + LogsArrayMapAttributeRemapper: + description: |- + An attribute remapper sub-processor for use inside an array-map processor. + Unlike the top-level attribute remapper, `is_enabled`, `source_type`, and + `target_type` are not supported. + properties: + name: + description: Name of the sub-processor. + type: string + override_on_conflict: + default: false + description: Override the target element if already set. + type: boolean + preserve_source: + default: false + description: Remove or preserve the remapped source element. + type: boolean + sources: + description: Array of source attribute paths. + example: + - "" + items: + type: string + type: array + target: + description: Target attribute path. + example: "" + type: string + target_format: + $ref: "#/components/schemas/TargetFormatType" + type: + $ref: "#/components/schemas/LogsAttributeRemapperType" + required: + - sources + - target + - type + type: object + LogsArrayMapCategorySubProcessor: + description: |- + A category sub-processor for use inside an array-map processor. + Unlike the top-level category processor, `is_enabled` is not supported. + properties: + categories: + description: Array of filters to match against a log and the corresponding value to assign. + items: + $ref: "#/components/schemas/LogsCategoryProcessorCategory" + type: array + name: + description: Name of the sub-processor. + type: string + target: + description: Target attribute path for the category value. + example: "" + type: string + type: + $ref: "#/components/schemas/LogsCategoryProcessorType" + required: + - categories + - target + - type + type: object + LogsArrayMapProcessor: + description: |- + The array-map processor transforms each element of a source array by applying + sub-processors in order and collecting the results into a target array. + Results can be written to a new array, to the source array (in-place), or to + an existing target array. Sub-processors can read from `$sourceElem.` + (object element field), bare `$sourceElem` (primitive element), or any parent + log attribute path. Sub-processors write to `$targetElem.` (object + output field) or bare `$targetElem` (primitive output). + properties: + is_enabled: + default: false + description: Whether or not the processor is enabled. + type: boolean + name: + description: Name of the processor. + type: string + preserve_source: + default: true + description: |- + When `false` and `source != target`, the source attribute is removed after + processing. Cannot be `false` when `source == target`. + type: boolean + processors: + description: |- + Sub-processors applied to each element. Allowed types: `attribute-remapper`, + `string-builder-processor`, `arithmetic-processor`, `category-processor`. + items: + $ref: "#/components/schemas/LogsArrayMapSubProcessor" + type: array + source: + description: |- + Attribute path of the source array. Elements are read-only via `$sourceElem` + inside sub-processors. + example: detail.resource.s3BucketDetails + type: string + target: + description: |- + Attribute path of the output array. Sub-processors write to `$targetElem` + (or `$targetElem.`) to build each output element. + example: ocsf.resources + type: string + type: + $ref: "#/components/schemas/LogsArrayMapProcessorType" + required: + - source + - target + - processors + - type + type: object + LogsArrayMapProcessorType: + default: array-map-processor + description: Type of logs array-map processor. + enum: + - array-map-processor + example: array-map-processor + type: string + x-enum-varnames: + - ARRAY_MAP_PROCESSOR + LogsArrayMapStringBuilderSubProcessor: + description: |- + A string builder sub-processor for use inside an array-map processor. + Unlike the top-level string builder processor, `is_enabled` is not supported. + properties: + is_replace_missing: + default: false + description: Replace missing attribute values with an empty string. + type: boolean + name: + description: Name of the sub-processor. + type: string + target: + description: Target attribute path for the result. + example: "" + type: string + template: + description: Formula with one or more attributes and raw text. + example: "" + type: string + type: + $ref: "#/components/schemas/LogsStringBuilderProcessorType" + required: + - template + - target + - type + type: object + LogsArrayMapSubProcessor: + description: |- + A sub-processor used inside an array-map processor. + Allowed types: `attribute-remapper`, `string-builder-processor`, + `arithmetic-processor`, `category-processor`. + oneOf: + - $ref: "#/components/schemas/LogsArrayMapAttributeRemapper" + - $ref: "#/components/schemas/LogsArrayMapArithmeticSubProcessor" + - $ref: "#/components/schemas/LogsArrayMapStringBuilderSubProcessor" + - $ref: "#/components/schemas/LogsArrayMapCategorySubProcessor" LogsArrayProcessor: description: |- A processor for extracting, aggregating, or transforming values from JSON arrays within your logs. @@ -7237,6 +7421,7 @@ components: - $ref: "#/components/schemas/LogsDecoderProcessor" - $ref: "#/components/schemas/LogsSchemaProcessor" - $ref: "#/components/schemas/LogsExcludeAttributeProcessor" + - $ref: "#/components/schemas/LogsArrayMapProcessor" LogsQueryCompute: description: Define computation for a log query. properties: diff --git a/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-returns-OK-response_1475401785/frozen.json b/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-returns-OK-response_1475401785/frozen.json new file mode 100644 index 000000000000..ef169aeaa6e6 --- /dev/null +++ b/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-returns-OK-response_1475401785/frozen.json @@ -0,0 +1 @@ +"2026-06-11T11:21:14.898Z" diff --git a/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-returns-OK-response_1475401785/recording.har b/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-returns-OK-response_1475401785/recording.har new file mode 100644 index 000000000000..a5245137325f --- /dev/null +++ b/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-returns-OK-response_1475401785/recording.har @@ -0,0 +1,110 @@ +{ + "log": { + "_recordingName": "Logs Pipelines/Create a pipeline with Array Map Processor returns \"OK\" response", + "creator": { + "comment": "persister:fs", + "name": "Polly.JS", + "version": "6.0.5" + }, + "entries": [ + { + "_id": "4ca93b6145a04b6dde4c1f4e0cac5b66", + "_order": 0, + "cache": {}, + "request": { + "bodySize": 439, + "cookies": [], + "headers": [ + { + "_fromType": "array", + "name": "accept", + "value": "application/json" + }, + { + "_fromType": "array", + "name": "content-type", + "value": "application/json" + } + ], + "headersSize": 593, + "httpVersion": "HTTP/1.1", + "method": "POST", + "postData": { + "mimeType": "application/json", + "params": [], + "text": "{\"filter\":{\"query\":\"source:python\"},\"name\":\"testPipelineArrayMap\",\"processors\":[{\"is_enabled\":true,\"name\":\"map items\",\"preserve_source\":true,\"processors\":[{\"preserve_source\":true,\"sources\":[\"$sourceElem.id\"],\"target\":\"$targetElem.uid\",\"type\":\"attribute-remapper\"},{\"target\":\"$targetElem.label\",\"template\":\"item-%{$sourceElem.id}\",\"type\":\"string-builder-processor\"}],\"source\":\"items\",\"target\":\"out\",\"type\":\"array-map-processor\"}],\"tags\":[]}" + }, + "queryString": [], + "url": "https://api.datadoghq.com/api/v1/logs/config/pipelines" + }, + "response": { + "bodySize": 646, + "content": { + "mimeType": "application/json", + "size": 646, + "text": "{\"id\":\"hZIWv906QoyQIWpVKqb6pw\",\"type\":\"pipeline\",\"name\":\"testPipelineArrayMap\",\"is_enabled\":false,\"is_read_only\":false,\"filter\":{\"query\":\"source:python\"},\"processors\":[{\"name\":\"map items\",\"is_enabled\":true,\"source\":\"items\",\"target\":\"out\",\"processors\":[{\"is_enabled\":true,\"sources\":[\"$sourceElem.id\"],\"target\":\"$targetElem.uid\",\"target_type\":\"attribute\",\"preserve_source\":true,\"override_on_conflict\":false,\"type\":\"attribute-remapper\"},{\"is_enabled\":true,\"template\":\"item-%{$sourceElem.id}\",\"target\":\"$targetElem.label\",\"is_replace_missing\":false,\"type\":\"string-builder-processor\"}],\"preserve_source\":true,\"type\":\"array-map-processor\"}],\"tags\":[]}\n" + }, + "cookies": [], + "headers": [ + { + "name": "content-type", + "value": "application/json" + } + ], + "headersSize": 701, + "httpVersion": "HTTP/1.1", + "redirectURL": "", + "status": 200, + "statusText": "OK" + }, + "startedDateTime": "2026-06-11T11:21:14.903Z", + "time": 658 + }, + { + "_id": "2b141bcd4dd0431a6e10528df1d56782", + "_order": 0, + "cache": {}, + "request": { + "bodySize": 0, + "cookies": [], + "headers": [ + { + "_fromType": "array", + "name": "accept", + "value": "*/*" + } + ], + "headersSize": 552, + "httpVersion": "HTTP/1.1", + "method": "DELETE", + "queryString": [], + "url": "https://api.datadoghq.com/api/v1/logs/config/pipelines/hZIWv906QoyQIWpVKqb6pw" + }, + "response": { + "bodySize": 3, + "content": { + "mimeType": "application/json", + "size": 3, + "text": "{}\n" + }, + "cookies": [], + "headers": [ + { + "name": "content-type", + "value": "application/json" + } + ], + "headersSize": 676, + "httpVersion": "HTTP/1.1", + "redirectURL": "", + "status": 200, + "statusText": "OK" + }, + "startedDateTime": "2026-06-11T11:21:15.572Z", + "time": 782 + } + ], + "pages": [], + "version": "1.2" + } +} diff --git a/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-using-arithmetic-sub-processor-returns-OK-resp_2196581668/frozen.json b/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-using-arithmetic-sub-processor-returns-OK-resp_2196581668/frozen.json new file mode 100644 index 000000000000..2315d275f264 --- /dev/null +++ b/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-using-arithmetic-sub-processor-returns-OK-resp_2196581668/frozen.json @@ -0,0 +1 @@ +"2026-06-11T11:21:29.886Z" diff --git a/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-using-arithmetic-sub-processor-returns-OK-resp_2196581668/recording.har b/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-using-arithmetic-sub-processor-returns-OK-resp_2196581668/recording.har new file mode 100644 index 000000000000..c322fa3221e2 --- /dev/null +++ b/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-using-arithmetic-sub-processor-returns-OK-resp_2196581668/recording.har @@ -0,0 +1,110 @@ +{ + "log": { + "_recordingName": "Logs Pipelines/Create a pipeline with Array Map Processor using arithmetic sub-processor returns \"OK\" response", + "creator": { + "comment": "persister:fs", + "name": "Polly.JS", + "version": "6.0.5" + }, + "entries": [ + { + "_id": "5b92624fb8edc712d3f5ec45a299c051", + "_order": 0, + "cache": {}, + "request": { + "bodySize": 320, + "cookies": [], + "headers": [ + { + "_fromType": "array", + "name": "accept", + "value": "application/json" + }, + { + "_fromType": "array", + "name": "content-type", + "value": "application/json" + } + ], + "headersSize": 593, + "httpVersion": "HTTP/1.1", + "method": "POST", + "postData": { + "mimeType": "application/json", + "params": [], + "text": "{\"filter\":{\"query\":\"source:python\"},\"name\":\"testPipelineArrayMapArithmetic\",\"processors\":[{\"is_enabled\":true,\"name\":\"double counts\",\"processors\":[{\"expression\":\"$sourceElem.count * 2\",\"target\":\"$targetElem.doubled\",\"type\":\"arithmetic-processor\"}],\"source\":\"items\",\"target\":\"out\",\"type\":\"array-map-processor\"}],\"tags\":[]}" + }, + "queryString": [], + "url": "https://api.datadoghq.com/api/v1/logs/config/pipelines" + }, + "response": { + "bodySize": 477, + "content": { + "mimeType": "application/json", + "size": 477, + "text": "{\"id\":\"oqjvoc0pSh6ZgjsHgiDQCg\",\"type\":\"pipeline\",\"name\":\"testPipelineArrayMapArithmetic\",\"is_enabled\":false,\"is_read_only\":false,\"filter\":{\"query\":\"source:python\"},\"processors\":[{\"name\":\"double counts\",\"is_enabled\":true,\"source\":\"items\",\"target\":\"out\",\"processors\":[{\"is_enabled\":true,\"expression\":\"$sourceElem.count * 2\",\"target\":\"$targetElem.doubled\",\"is_replace_missing\":false,\"type\":\"arithmetic-processor\"}],\"preserve_source\":true,\"type\":\"array-map-processor\"}],\"tags\":[]}\n" + }, + "cookies": [], + "headers": [ + { + "name": "content-type", + "value": "application/json" + } + ], + "headersSize": 701, + "httpVersion": "HTTP/1.1", + "redirectURL": "", + "status": 200, + "statusText": "OK" + }, + "startedDateTime": "2026-06-11T11:21:29.891Z", + "time": 560 + }, + { + "_id": "924a877d4ed7781abbf6a846ef1d0f51", + "_order": 0, + "cache": {}, + "request": { + "bodySize": 0, + "cookies": [], + "headers": [ + { + "_fromType": "array", + "name": "accept", + "value": "*/*" + } + ], + "headersSize": 552, + "httpVersion": "HTTP/1.1", + "method": "DELETE", + "queryString": [], + "url": "https://api.datadoghq.com/api/v1/logs/config/pipelines/oqjvoc0pSh6ZgjsHgiDQCg" + }, + "response": { + "bodySize": 3, + "content": { + "mimeType": "application/json", + "size": 3, + "text": "{}\n" + }, + "cookies": [], + "headers": [ + { + "name": "content-type", + "value": "application/json" + } + ], + "headersSize": 676, + "httpVersion": "HTTP/1.1", + "redirectURL": "", + "status": 200, + "statusText": "OK" + }, + "startedDateTime": "2026-06-11T11:21:30.461Z", + "time": 672 + } + ], + "pages": [], + "version": "1.2" + } +} diff --git a/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-using-category-sub-processor-returns-OK-respons_105345364/frozen.json b/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-using-category-sub-processor-returns-OK-respons_105345364/frozen.json new file mode 100644 index 000000000000..743e0eb9cbce --- /dev/null +++ b/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-using-category-sub-processor-returns-OK-respons_105345364/frozen.json @@ -0,0 +1 @@ +"2026-06-11T11:21:45.245Z" diff --git a/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-using-category-sub-processor-returns-OK-respons_105345364/recording.har b/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-using-category-sub-processor-returns-OK-respons_105345364/recording.har new file mode 100644 index 000000000000..ae04dda67b6d --- /dev/null +++ b/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-using-category-sub-processor-returns-OK-respons_105345364/recording.har @@ -0,0 +1,110 @@ +{ + "log": { + "_recordingName": "Logs Pipelines/Create a pipeline with Array Map Processor using category sub-processor returns \"OK\" response", + "creator": { + "comment": "persister:fs", + "name": "Polly.JS", + "version": "6.0.5" + }, + "entries": [ + { + "_id": "f1b388c47ff7a6754b4a245be0bc7b8f", + "_order": 0, + "cache": {}, + "request": { + "bodySize": 398, + "cookies": [], + "headers": [ + { + "_fromType": "array", + "name": "accept", + "value": "application/json" + }, + { + "_fromType": "array", + "name": "content-type", + "value": "application/json" + } + ], + "headersSize": 593, + "httpVersion": "HTTP/1.1", + "method": "POST", + "postData": { + "mimeType": "application/json", + "params": [], + "text": "{\"filter\":{\"query\":\"source:python\"},\"name\":\"testPipelineArrayMapCategory\",\"processors\":[{\"is_enabled\":true,\"name\":\"categorize items\",\"processors\":[{\"categories\":[{\"filter\":{\"query\":\"@$sourceElem.status:error\"},\"name\":\"error\"},{\"filter\":{\"query\":\"*\"},\"name\":\"info\"}],\"target\":\"$targetElem.level\",\"type\":\"category-processor\"}],\"source\":\"items\",\"target\":\"out\",\"type\":\"array-map-processor\"}],\"tags\":[]}" + }, + "queryString": [], + "url": "https://api.datadoghq.com/api/v1/logs/config/pipelines" + }, + "response": { + "bodySize": 528, + "content": { + "mimeType": "application/json", + "size": 528, + "text": "{\"id\":\"m9rsoJZvRyekemX5ED_r9g\",\"type\":\"pipeline\",\"name\":\"testPipelineArrayMapCategory\",\"is_enabled\":false,\"is_read_only\":false,\"filter\":{\"query\":\"source:python\"},\"processors\":[{\"name\":\"categorize items\",\"is_enabled\":true,\"source\":\"items\",\"target\":\"out\",\"processors\":[{\"is_enabled\":true,\"categories\":[{\"filter\":{\"query\":\"@$sourceElem.status:error\"},\"name\":\"error\"},{\"filter\":{\"query\":\"*\"},\"name\":\"info\"}],\"target\":\"$targetElem.level\",\"type\":\"category-processor\"}],\"preserve_source\":true,\"type\":\"array-map-processor\"}],\"tags\":[]}\n" + }, + "cookies": [], + "headers": [ + { + "name": "content-type", + "value": "application/json" + } + ], + "headersSize": 701, + "httpVersion": "HTTP/1.1", + "redirectURL": "", + "status": 200, + "statusText": "OK" + }, + "startedDateTime": "2026-06-11T11:21:45.250Z", + "time": 721 + }, + { + "_id": "29554513f97a609d4b36c7bbc6f0f042", + "_order": 0, + "cache": {}, + "request": { + "bodySize": 0, + "cookies": [], + "headers": [ + { + "_fromType": "array", + "name": "accept", + "value": "*/*" + } + ], + "headersSize": 552, + "httpVersion": "HTTP/1.1", + "method": "DELETE", + "queryString": [], + "url": "https://api.datadoghq.com/api/v1/logs/config/pipelines/m9rsoJZvRyekemX5ED_r9g" + }, + "response": { + "bodySize": 3, + "content": { + "mimeType": "application/json", + "size": 3, + "text": "{}\n" + }, + "cookies": [], + "headers": [ + { + "name": "content-type", + "value": "application/json" + } + ], + "headersSize": 676, + "httpVersion": "HTTP/1.1", + "redirectURL": "", + "status": 200, + "statusText": "OK" + }, + "startedDateTime": "2026-06-11T11:21:45.984Z", + "time": 643 + } + ], + "pages": [], + "version": "1.2" + } +} diff --git a/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-with-preserve_source-false-returns-OK-response_4107386760/frozen.json b/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-with-preserve_source-false-returns-OK-response_4107386760/frozen.json new file mode 100644 index 000000000000..ba7b40d45a1a --- /dev/null +++ b/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-with-preserve_source-false-returns-OK-response_4107386760/frozen.json @@ -0,0 +1 @@ +"2026-06-11T11:22:14.718Z" diff --git a/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-with-preserve_source-false-returns-OK-response_4107386760/recording.har b/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-with-preserve_source-false-returns-OK-response_4107386760/recording.har new file mode 100644 index 000000000000..bff2a8fa6f09 --- /dev/null +++ b/cassettes/v1/Logs-Pipelines_3794283453/Create-a-pipeline-with-Array-Map-Processor-with-preserve_source-false-returns-OK-response_4107386760/recording.har @@ -0,0 +1,110 @@ +{ + "log": { + "_recordingName": "Logs Pipelines/Create a pipeline with Array Map Processor with preserve_source false returns \"OK\" response", + "creator": { + "comment": "persister:fs", + "name": "Polly.JS", + "version": "6.0.5" + }, + "entries": [ + { + "_id": "b72fdb61bb6553f93cdb9a48060cae20", + "_order": 0, + "cache": {}, + "request": { + "bodySize": 338, + "cookies": [], + "headers": [ + { + "_fromType": "array", + "name": "accept", + "value": "application/json" + }, + { + "_fromType": "array", + "name": "content-type", + "value": "application/json" + } + ], + "headersSize": 593, + "httpVersion": "HTTP/1.1", + "method": "POST", + "postData": { + "mimeType": "application/json", + "params": [], + "text": "{\"filter\":{\"query\":\"source:python\"},\"name\":\"testPipelineArrayMapNoPreserve\",\"processors\":[{\"is_enabled\":true,\"name\":\"map and remove source\",\"preserve_source\":false,\"processors\":[{\"sources\":[\"$sourceElem.id\"],\"target\":\"$targetElem.uid\",\"type\":\"attribute-remapper\"}],\"source\":\"items\",\"target\":\"out\",\"type\":\"array-map-processor\"}],\"tags\":[]}" + }, + "queryString": [], + "url": "https://api.datadoghq.com/api/v1/logs/config/pipelines" + }, + "response": { + "bodySize": 524, + "content": { + "mimeType": "application/json", + "size": 524, + "text": "{\"id\":\"ltWiUpfFRCaNE9L65g2VvQ\",\"type\":\"pipeline\",\"name\":\"testPipelineArrayMapNoPreserve\",\"is_enabled\":false,\"is_read_only\":false,\"filter\":{\"query\":\"source:python\"},\"processors\":[{\"name\":\"map and remove source\",\"is_enabled\":true,\"source\":\"items\",\"target\":\"out\",\"processors\":[{\"is_enabled\":true,\"sources\":[\"$sourceElem.id\"],\"target\":\"$targetElem.uid\",\"target_type\":\"attribute\",\"preserve_source\":false,\"override_on_conflict\":false,\"type\":\"attribute-remapper\"}],\"preserve_source\":false,\"type\":\"array-map-processor\"}],\"tags\":[]}\n" + }, + "cookies": [], + "headers": [ + { + "name": "content-type", + "value": "application/json" + } + ], + "headersSize": 701, + "httpVersion": "HTTP/1.1", + "redirectURL": "", + "status": 200, + "statusText": "OK" + }, + "startedDateTime": "2026-06-11T11:22:14.723Z", + "time": 645 + }, + { + "_id": "0bd739a4e2690a3f5e39572a6ab5355c", + "_order": 0, + "cache": {}, + "request": { + "bodySize": 0, + "cookies": [], + "headers": [ + { + "_fromType": "array", + "name": "accept", + "value": "*/*" + } + ], + "headersSize": 552, + "httpVersion": "HTTP/1.1", + "method": "DELETE", + "queryString": [], + "url": "https://api.datadoghq.com/api/v1/logs/config/pipelines/ltWiUpfFRCaNE9L65g2VvQ" + }, + "response": { + "bodySize": 3, + "content": { + "mimeType": "application/json", + "size": 3, + "text": "{}\n" + }, + "cookies": [], + "headers": [ + { + "name": "content-type", + "value": "application/json" + } + ], + "headersSize": 676, + "httpVersion": "HTTP/1.1", + "redirectURL": "", + "status": 200, + "statusText": "OK" + }, + "startedDateTime": "2026-06-11T11:22:15.375Z", + "time": 786 + } + ], + "pages": [], + "version": "1.2" + } +} diff --git a/features/v1/logs_pipelines.feature b/features/v1/logs_pipelines.feature index 1ab4401b0fdc..ac28f052615b 100644 --- a/features/v1/logs_pipelines.feature +++ b/features/v1/logs_pipelines.feature @@ -35,6 +35,34 @@ Feature: Logs Pipelines When the request is sent Then the response status is 200 OK + @team:DataDog/logs-onboarding + Scenario: Create a pipeline with Array Map Processor returns "OK" response + Given new "CreateLogsPipeline" request + And body with value {"filter": {"query": "source:python"}, "name": "testPipelineArrayMap", "processors": [{"type": "array-map-processor", "is_enabled": true, "name": "map items", "source": "items", "target": "out", "preserve_source": true, "processors": [{"type": "attribute-remapper", "sources": ["$sourceElem.id"], "target": "$targetElem.uid", "preserve_source": true}, {"type": "string-builder-processor", "template": "item-%{$sourceElem.id}", "target": "$targetElem.label"}]}], "tags": []} + When the request is sent + Then the response status is 200 OK + + @team:DataDog/logs-onboarding + Scenario: Create a pipeline with Array Map Processor using arithmetic sub-processor returns "OK" response + Given new "CreateLogsPipeline" request + And body with value {"filter": {"query": "source:python"}, "name": "testPipelineArrayMapArithmetic", "processors": [{"type": "array-map-processor", "is_enabled": true, "name": "double counts", "source": "items", "target": "out", "processors": [{"type": "arithmetic-processor", "expression": "$sourceElem.count * 2", "target": "$targetElem.doubled"}]}], "tags": []} + When the request is sent + Then the response status is 200 OK + + @team:DataDog/logs-onboarding + Scenario: Create a pipeline with Array Map Processor using category sub-processor returns "OK" response + Given new "CreateLogsPipeline" request + And body with value {"filter": {"query": "source:python"}, "name": "testPipelineArrayMapCategory", "processors": [{"type": "array-map-processor", "is_enabled": true, "name": "categorize items", "source": "items", "target": "out", "processors": [{"type": "category-processor", "target": "$targetElem.level", "categories": [{"filter": {"query": "@$sourceElem.status:error"}, "name": "error"}, {"filter": {"query": "*"}, "name": "info"}]}]}], "tags": []} + When the request is sent + Then the response status is 200 OK + + @team:DataDog/logs-onboarding + Scenario: Create a pipeline with Array Map Processor with preserve_source false returns "OK" response + Given new "CreateLogsPipeline" request + And body with value {"filter": {"query": "source:python"}, "name": "testPipelineArrayMapNoPreserve", "processors": [{"type": "array-map-processor", "is_enabled": true, "name": "map and remove source", "source": "items", "target": "out", "preserve_source": false, "processors": [{"type": "attribute-remapper", "sources": ["$sourceElem.id"], "target": "$targetElem.uid"}]}], "tags": []} + When the request is sent + Then the response status is 200 OK + @team:DataDog/logs-onboarding Scenario: Create a pipeline with Array Processor Append Operation returns "OK" response Given new "CreateLogsPipeline" request diff --git a/services/logs_pipelines/src/v1/index.ts b/services/logs_pipelines/src/v1/index.ts index ac2cc55dc245..e386d0506410 100644 --- a/services/logs_pipelines/src/v1/index.ts +++ b/services/logs_pipelines/src/v1/index.ts @@ -12,6 +12,13 @@ export { LogsAPIError } from "./models/LogsAPIError"; export { LogsAPIErrorResponse } from "./models/LogsAPIErrorResponse"; export { LogsArithmeticProcessor } from "./models/LogsArithmeticProcessor"; export { LogsArithmeticProcessorType } from "./models/LogsArithmeticProcessorType"; +export { LogsArrayMapArithmeticSubProcessor } from "./models/LogsArrayMapArithmeticSubProcessor"; +export { LogsArrayMapAttributeRemapper } from "./models/LogsArrayMapAttributeRemapper"; +export { LogsArrayMapCategorySubProcessor } from "./models/LogsArrayMapCategorySubProcessor"; +export { LogsArrayMapProcessor } from "./models/LogsArrayMapProcessor"; +export { LogsArrayMapProcessorType } from "./models/LogsArrayMapProcessorType"; +export { LogsArrayMapStringBuilderSubProcessor } from "./models/LogsArrayMapStringBuilderSubProcessor"; +export { LogsArrayMapSubProcessor } from "./models/LogsArrayMapSubProcessor"; export { LogsArrayProcessor } from "./models/LogsArrayProcessor"; export { LogsArrayProcessorOperation } from "./models/LogsArrayProcessorOperation"; export { LogsArrayProcessorOperationAppend } from "./models/LogsArrayProcessorOperationAppend"; diff --git a/services/logs_pipelines/src/v1/models/LogsArrayMapArithmeticSubProcessor.ts b/services/logs_pipelines/src/v1/models/LogsArrayMapArithmeticSubProcessor.ts new file mode 100644 index 000000000000..7fe68aa19299 --- /dev/null +++ b/services/logs_pipelines/src/v1/models/LogsArrayMapArithmeticSubProcessor.ts @@ -0,0 +1,82 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { LogsArithmeticProcessorType } from "./LogsArithmeticProcessorType"; + +/** + * An arithmetic sub-processor for use inside an array-map processor. + * Unlike the top-level arithmetic processor, `is_enabled` is not supported. + */ +export class LogsArrayMapArithmeticSubProcessor { + /** + * Arithmetic operation to perform. + */ + "expression": string; + /** + * Replace missing attribute values with 0. + */ + "isReplaceMissing"?: boolean; + /** + * Name of the sub-processor. + */ + "name"?: string; + /** + * Target attribute path for the result. + */ + "target": string; + /** + * Type of logs arithmetic processor. + */ + "type": LogsArithmeticProcessorType; + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + expression: { + baseName: "expression", + type: "string", + required: true, + }, + isReplaceMissing: { + baseName: "is_replace_missing", + type: "boolean", + }, + name: { + baseName: "name", + type: "string", + }, + target: { + baseName: "target", + type: "string", + required: true, + }, + type: { + baseName: "type", + type: "LogsArithmeticProcessorType", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return LogsArrayMapArithmeticSubProcessor.attributeTypeMap; + } + + public constructor() {} +} diff --git a/services/logs_pipelines/src/v1/models/LogsArrayMapAttributeRemapper.ts b/services/logs_pipelines/src/v1/models/LogsArrayMapAttributeRemapper.ts new file mode 100644 index 000000000000..ed342e700ad0 --- /dev/null +++ b/services/logs_pipelines/src/v1/models/LogsArrayMapAttributeRemapper.ts @@ -0,0 +1,102 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { LogsAttributeRemapperType } from "./LogsAttributeRemapperType"; +import { TargetFormatType } from "./TargetFormatType"; + +/** + * An attribute remapper sub-processor for use inside an array-map processor. + * Unlike the top-level attribute remapper, `is_enabled`, `source_type`, and + * `target_type` are not supported. + */ +export class LogsArrayMapAttributeRemapper { + /** + * Name of the sub-processor. + */ + "name"?: string; + /** + * Override the target element if already set. + */ + "overrideOnConflict"?: boolean; + /** + * Remove or preserve the remapped source element. + */ + "preserveSource"?: boolean; + /** + * Array of source attribute paths. + */ + "sources": Array; + /** + * Target attribute path. + */ + "target": string; + /** + * If the `target_type` of the remapper is `attribute`, try to cast the value to a new specific type. + * If the cast is not possible, the original type is kept. `string`, `integer`, or `double` are the possible types. + * If the `target_type` is `tag`, this parameter may not be specified. + */ + "targetFormat"?: TargetFormatType; + /** + * Type of logs attribute remapper. + */ + "type": LogsAttributeRemapperType; + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + name: { + baseName: "name", + type: "string", + }, + overrideOnConflict: { + baseName: "override_on_conflict", + type: "boolean", + }, + preserveSource: { + baseName: "preserve_source", + type: "boolean", + }, + sources: { + baseName: "sources", + type: "Array", + required: true, + }, + target: { + baseName: "target", + type: "string", + required: true, + }, + targetFormat: { + baseName: "target_format", + type: "TargetFormatType", + }, + type: { + baseName: "type", + type: "LogsAttributeRemapperType", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return LogsArrayMapAttributeRemapper.attributeTypeMap; + } + + public constructor() {} +} diff --git a/services/logs_pipelines/src/v1/models/LogsArrayMapCategorySubProcessor.ts b/services/logs_pipelines/src/v1/models/LogsArrayMapCategorySubProcessor.ts new file mode 100644 index 000000000000..a7ea813a07bf --- /dev/null +++ b/services/logs_pipelines/src/v1/models/LogsArrayMapCategorySubProcessor.ts @@ -0,0 +1,75 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { LogsCategoryProcessorCategory } from "./LogsCategoryProcessorCategory"; +import { LogsCategoryProcessorType } from "./LogsCategoryProcessorType"; + +/** + * A category sub-processor for use inside an array-map processor. + * Unlike the top-level category processor, `is_enabled` is not supported. + */ +export class LogsArrayMapCategorySubProcessor { + /** + * Array of filters to match against a log and the corresponding value to assign. + */ + "categories": Array; + /** + * Name of the sub-processor. + */ + "name"?: string; + /** + * Target attribute path for the category value. + */ + "target": string; + /** + * Type of logs category processor. + */ + "type": LogsCategoryProcessorType; + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + categories: { + baseName: "categories", + type: "Array", + required: true, + }, + name: { + baseName: "name", + type: "string", + }, + target: { + baseName: "target", + type: "string", + required: true, + }, + type: { + baseName: "type", + type: "LogsCategoryProcessorType", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return LogsArrayMapCategorySubProcessor.attributeTypeMap; + } + + public constructor() {} +} diff --git a/services/logs_pipelines/src/v1/models/LogsArrayMapProcessor.ts b/services/logs_pipelines/src/v1/models/LogsArrayMapProcessor.ts new file mode 100644 index 000000000000..1f1444f99f58 --- /dev/null +++ b/services/logs_pipelines/src/v1/models/LogsArrayMapProcessor.ts @@ -0,0 +1,109 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { LogsArrayMapProcessorType } from "./LogsArrayMapProcessorType"; +import { LogsArrayMapSubProcessor } from "./LogsArrayMapSubProcessor"; + +/** + * The array-map processor transforms each element of a source array by applying + * sub-processors in order and collecting the results into a target array. + * Results can be written to a new array, to the source array (in-place), or to + * an existing target array. Sub-processors can read from `$sourceElem.` + * (object element field), bare `$sourceElem` (primitive element), or any parent + * log attribute path. Sub-processors write to `$targetElem.` (object + * output field) or bare `$targetElem` (primitive output). + */ +export class LogsArrayMapProcessor { + /** + * Whether or not the processor is enabled. + */ + "isEnabled"?: boolean; + /** + * Name of the processor. + */ + "name"?: string; + /** + * When `false` and `source != target`, the source attribute is removed after + * processing. Cannot be `false` when `source == target`. + */ + "preserveSource"?: boolean; + /** + * Sub-processors applied to each element. Allowed types: `attribute-remapper`, + * `string-builder-processor`, `arithmetic-processor`, `category-processor`. + */ + "processors": Array; + /** + * Attribute path of the source array. Elements are read-only via `$sourceElem` + * inside sub-processors. + */ + "source": string; + /** + * Attribute path of the output array. Sub-processors write to `$targetElem` + * (or `$targetElem.`) to build each output element. + */ + "target": string; + /** + * Type of logs array-map processor. + */ + "type": LogsArrayMapProcessorType; + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + isEnabled: { + baseName: "is_enabled", + type: "boolean", + }, + name: { + baseName: "name", + type: "string", + }, + preserveSource: { + baseName: "preserve_source", + type: "boolean", + }, + processors: { + baseName: "processors", + type: "Array", + required: true, + }, + source: { + baseName: "source", + type: "string", + required: true, + }, + target: { + baseName: "target", + type: "string", + required: true, + }, + type: { + baseName: "type", + type: "LogsArrayMapProcessorType", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return LogsArrayMapProcessor.attributeTypeMap; + } + + public constructor() {} +} diff --git a/services/logs_pipelines/src/v1/models/LogsArrayMapProcessorType.ts b/services/logs_pipelines/src/v1/models/LogsArrayMapProcessorType.ts new file mode 100644 index 000000000000..1abd731fc440 --- /dev/null +++ b/services/logs_pipelines/src/v1/models/LogsArrayMapProcessorType.ts @@ -0,0 +1,9 @@ +import { UnparsedObject } from "@datadog/datadog-api-client"; + +/** + * Type of logs array-map processor. + */ +export type LogsArrayMapProcessorType = + | typeof ARRAY_MAP_PROCESSOR + | UnparsedObject; +export const ARRAY_MAP_PROCESSOR = "array-map-processor"; diff --git a/services/logs_pipelines/src/v1/models/LogsArrayMapStringBuilderSubProcessor.ts b/services/logs_pipelines/src/v1/models/LogsArrayMapStringBuilderSubProcessor.ts new file mode 100644 index 000000000000..b1cb27fe2567 --- /dev/null +++ b/services/logs_pipelines/src/v1/models/LogsArrayMapStringBuilderSubProcessor.ts @@ -0,0 +1,82 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { LogsStringBuilderProcessorType } from "./LogsStringBuilderProcessorType"; + +/** + * A string builder sub-processor for use inside an array-map processor. + * Unlike the top-level string builder processor, `is_enabled` is not supported. + */ +export class LogsArrayMapStringBuilderSubProcessor { + /** + * Replace missing attribute values with an empty string. + */ + "isReplaceMissing"?: boolean; + /** + * Name of the sub-processor. + */ + "name"?: string; + /** + * Target attribute path for the result. + */ + "target": string; + /** + * Formula with one or more attributes and raw text. + */ + "template": string; + /** + * Type of logs string builder processor. + */ + "type": LogsStringBuilderProcessorType; + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + isReplaceMissing: { + baseName: "is_replace_missing", + type: "boolean", + }, + name: { + baseName: "name", + type: "string", + }, + target: { + baseName: "target", + type: "string", + required: true, + }, + template: { + baseName: "template", + type: "string", + required: true, + }, + type: { + baseName: "type", + type: "LogsStringBuilderProcessorType", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return LogsArrayMapStringBuilderSubProcessor.attributeTypeMap; + } + + public constructor() {} +} diff --git a/services/logs_pipelines/src/v1/models/LogsArrayMapSubProcessor.ts b/services/logs_pipelines/src/v1/models/LogsArrayMapSubProcessor.ts new file mode 100644 index 000000000000..fddb035df388 --- /dev/null +++ b/services/logs_pipelines/src/v1/models/LogsArrayMapSubProcessor.ts @@ -0,0 +1,18 @@ +import { UnparsedObject } from "@datadog/datadog-api-client"; + +import { LogsArrayMapArithmeticSubProcessor } from "./LogsArrayMapArithmeticSubProcessor"; +import { LogsArrayMapAttributeRemapper } from "./LogsArrayMapAttributeRemapper"; +import { LogsArrayMapCategorySubProcessor } from "./LogsArrayMapCategorySubProcessor"; +import { LogsArrayMapStringBuilderSubProcessor } from "./LogsArrayMapStringBuilderSubProcessor"; + +/** + * A sub-processor used inside an array-map processor. + * Allowed types: `attribute-remapper`, `string-builder-processor`, + * `arithmetic-processor`, `category-processor`. + */ +export type LogsArrayMapSubProcessor = + | LogsArrayMapAttributeRemapper + | LogsArrayMapArithmeticSubProcessor + | LogsArrayMapStringBuilderSubProcessor + | LogsArrayMapCategorySubProcessor + | UnparsedObject; diff --git a/services/logs_pipelines/src/v1/models/LogsProcessor.ts b/services/logs_pipelines/src/v1/models/LogsProcessor.ts index a86465e025be..e0a57f333638 100644 --- a/services/logs_pipelines/src/v1/models/LogsProcessor.ts +++ b/services/logs_pipelines/src/v1/models/LogsProcessor.ts @@ -1,6 +1,7 @@ import { UnparsedObject } from "@datadog/datadog-api-client"; import { LogsArithmeticProcessor } from "./LogsArithmeticProcessor"; +import { LogsArrayMapProcessor } from "./LogsArrayMapProcessor"; import { LogsArrayProcessor } from "./LogsArrayProcessor"; import { LogsAttributeRemapper } from "./LogsAttributeRemapper"; import { LogsCategoryProcessor } from "./LogsCategoryProcessor"; @@ -47,4 +48,5 @@ export type LogsProcessor = | LogsDecoderProcessor | LogsSchemaProcessor | LogsExcludeAttributeProcessor + | LogsArrayMapProcessor | UnparsedObject; diff --git a/services/logs_pipelines/src/v1/models/TypingInfo.ts b/services/logs_pipelines/src/v1/models/TypingInfo.ts index 02923d5c6da2..334ce41e2d05 100644 --- a/services/logs_pipelines/src/v1/models/TypingInfo.ts +++ b/services/logs_pipelines/src/v1/models/TypingInfo.ts @@ -4,6 +4,11 @@ import { APIErrorResponse } from "./APIErrorResponse"; import { LogsAPIError } from "./LogsAPIError"; import { LogsAPIErrorResponse } from "./LogsAPIErrorResponse"; import { LogsArithmeticProcessor } from "./LogsArithmeticProcessor"; +import { LogsArrayMapArithmeticSubProcessor } from "./LogsArrayMapArithmeticSubProcessor"; +import { LogsArrayMapAttributeRemapper } from "./LogsArrayMapAttributeRemapper"; +import { LogsArrayMapCategorySubProcessor } from "./LogsArrayMapCategorySubProcessor"; +import { LogsArrayMapProcessor } from "./LogsArrayMapProcessor"; +import { LogsArrayMapStringBuilderSubProcessor } from "./LogsArrayMapStringBuilderSubProcessor"; import { LogsArrayProcessor } from "./LogsArrayProcessor"; import { LogsArrayProcessorOperationAppend } from "./LogsArrayProcessorOperationAppend"; import { LogsArrayProcessorOperationLength } from "./LogsArrayProcessorOperationLength"; @@ -42,6 +47,7 @@ import { ReferenceTableLogsLookupProcessor } from "./ReferenceTableLogsLookupPro export const TypingInfo: ModelTypingInfo = { enumsMap: { LogsArithmeticProcessorType: ["arithmetic-processor"], + LogsArrayMapProcessorType: ["array-map-processor"], LogsArrayProcessorOperationAppendType: ["append"], LogsArrayProcessorOperationLengthType: ["length"], LogsArrayProcessorOperationSelectType: ["select"], @@ -71,6 +77,12 @@ export const TypingInfo: ModelTypingInfo = { TargetFormatType: ["auto", "string", "integer", "double"], }, oneOfMap: { + LogsArrayMapSubProcessor: [ + "LogsArrayMapAttributeRemapper", + "LogsArrayMapArithmeticSubProcessor", + "LogsArrayMapStringBuilderSubProcessor", + "LogsArrayMapCategorySubProcessor", + ], LogsArrayProcessorOperation: [ "LogsArrayProcessorOperationAppend", "LogsArrayProcessorOperationLength", @@ -98,6 +110,7 @@ export const TypingInfo: ModelTypingInfo = { "LogsDecoderProcessor", "LogsSchemaProcessor", "LogsExcludeAttributeProcessor", + "LogsArrayMapProcessor", ], LogsSchemaMapper: ["LogsSchemaRemapper", "LogsSchemaCategoryMapper"], }, @@ -106,6 +119,12 @@ export const TypingInfo: ModelTypingInfo = { LogsAPIError: LogsAPIError, LogsAPIErrorResponse: LogsAPIErrorResponse, LogsArithmeticProcessor: LogsArithmeticProcessor, + LogsArrayMapArithmeticSubProcessor: LogsArrayMapArithmeticSubProcessor, + LogsArrayMapAttributeRemapper: LogsArrayMapAttributeRemapper, + LogsArrayMapCategorySubProcessor: LogsArrayMapCategorySubProcessor, + LogsArrayMapProcessor: LogsArrayMapProcessor, + LogsArrayMapStringBuilderSubProcessor: + LogsArrayMapStringBuilderSubProcessor, LogsArrayProcessor: LogsArrayProcessor, LogsArrayProcessorOperationAppend: LogsArrayProcessorOperationAppend, LogsArrayProcessorOperationLength: LogsArrayProcessorOperationLength,