From 26336b78d3ff8ee39a0b054d20fc7f16a5f2d944 Mon Sep 17 00:00:00 2001 From: David Tapiador Date: Thu, 17 Sep 2026 15:28:36 +0200 Subject: [PATCH 1/4] Support request compression test step --- src/test/java/com/datadog/api/RecorderSteps.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/test/java/com/datadog/api/RecorderSteps.java b/src/test/java/com/datadog/api/RecorderSteps.java index 620d3abc53b..8bce456f3ee 100644 --- a/src/test/java/com/datadog/api/RecorderSteps.java +++ b/src/test/java/com/datadog/api/RecorderSteps.java @@ -6,6 +6,7 @@ import io.cucumber.java.BeforeAll; import io.cucumber.java.Scenario; import io.cucumber.java.Status; +import io.cucumber.java.en.Given; import io.cucumber.java.en.When; import java.io.File; import java.io.IOException; @@ -197,6 +198,11 @@ public String getCassetteName() { return world.getName() + ".json"; } + @Given("the request uses {string} compression") + public void theRequestUsesCompression(String compression) { + // The generated replay server validates the Content-Encoding header and compressed body. + } + @When("the request is sent") public void theRequestIsSent() throws Exception { TestRunner.applyPlan(world, false); From 1dadf1a8af1c3e2b60a916b216b02c6643817951 Mon Sep 17 00:00:00 2001 From: David Tapiador Date: Thu, 17 Sep 2026 15:39:47 +0200 Subject: [PATCH 2/4] Apply generated request compression --- src/test/java/com/datadog/api/TestRunner.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/test/java/com/datadog/api/TestRunner.java b/src/test/java/com/datadog/api/TestRunner.java index b3213a0473f..e7afee211c4 100644 --- a/src/test/java/com/datadog/api/TestRunner.java +++ b/src/test/java/com/datadog/api/TestRunner.java @@ -167,6 +167,10 @@ public static void applyPlan(World world, boolean pagination) throws Exception { Object value = materialize(body.get("value"), world); world.addMaterializedRequestParameter("body", MAPPER.writeValueAsString(value)); } + if (request.get("compression") != null) { + world.addMaterializedRequestParameter( + "Content-Encoding", MAPPER.writeValueAsString(request.get("compression"))); + } for (Map parameter : parameters) { if (!"path".equals(parameter.get("in")) && !Boolean.TRUE.equals(parameter.get("required"))) { applyParameter(world, parameter); From 897e048b1ab5ac840c7dd2c27f8c049fe55fdf12 Mon Sep 17 00:00:00 2001 From: David Tapiador Date: Fri, 18 Sep 2026 15:35:08 +0200 Subject: [PATCH 3/4] Support explicit compression selection --- src/test/java/com/datadog/api/RecorderSteps.java | 5 +++++ src/test/java/com/datadog/api/TestRunner.java | 4 ++-- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/src/test/java/com/datadog/api/RecorderSteps.java b/src/test/java/com/datadog/api/RecorderSteps.java index 8bce456f3ee..42e7330bb69 100644 --- a/src/test/java/com/datadog/api/RecorderSteps.java +++ b/src/test/java/com/datadog/api/RecorderSteps.java @@ -203,6 +203,11 @@ public void theRequestUsesCompression(String compression) { // The generated replay server validates the Content-Encoding header and compressed body. } + @Given("the user selects {string} compression") + public void theUserSelectsCompression(String compression) { + // The generated request plan passes the selected compression to the client call. + } + @When("the request is sent") public void theRequestIsSent() throws Exception { TestRunner.applyPlan(world, false); diff --git a/src/test/java/com/datadog/api/TestRunner.java b/src/test/java/com/datadog/api/TestRunner.java index e7afee211c4..1ea91b61a52 100644 --- a/src/test/java/com/datadog/api/TestRunner.java +++ b/src/test/java/com/datadog/api/TestRunner.java @@ -167,9 +167,9 @@ public static void applyPlan(World world, boolean pagination) throws Exception { Object value = materialize(body.get("value"), world); world.addMaterializedRequestParameter("body", MAPPER.writeValueAsString(value)); } - if (request.get("compression") != null) { + if (request.get("selected_compression") != null) { world.addMaterializedRequestParameter( - "Content-Encoding", MAPPER.writeValueAsString(request.get("compression"))); + "Content-Encoding", MAPPER.writeValueAsString(request.get("selected_compression"))); } for (Map parameter : parameters) { if (!"path".equals(parameter.get("in")) && !Boolean.TRUE.equals(parameter.get("required"))) { From c1a0ce70ea43f37ca26b6ed29684cd28a785f8a9 Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Fri, 18 Sep 2026 14:26:03 +0000 Subject: [PATCH 4/4] Regenerate client from commit f23e221 of spec repo --- .generator/schemas/v1/openapi.yaml | 1 + .generator/schemas/v2/openapi.yaml | 1 + .../datadog/api/client/v1/api/LogsApi.java | 5 +- .../datadog/api/client/v2/api/LogsApi.java | 5 +- .../datadog/api/client/v1/api/logs.feature | 5 +- .../datadog/api/client/v2/api/logs.feature | 5 +- .../test-runner-data/manifest.json | 14 +++ ...server-always-200-empty-json-response.json | 38 ++++++++ ...server-always-200-empty-json-response.json | 1 + ...essing-always-202-empty-json-response.json | 41 +++++++++ ...essing-always-202-empty-json-response.json | 1 + src/test/resources/generated-test/test-server | 88 +++++++++++++++++-- .../test-server-data/v1/logs.json | 36 ++++++++ .../test-server-data/v2/logs.json | 39 ++++++++ 14 files changed, 265 insertions(+), 15 deletions(-) create mode 100644 src/test/resources/generated-test/test-runner-data/v1/logs/send-deflate-logs-returns-response-from-server-always-200-empty-json-response.json create mode 100644 src/test/resources/generated-test/test-runner-data/v2/logs/send-deflate-logs-returns-request-accepted-for-processing-always-202-empty-json-response.json diff --git a/.generator/schemas/v1/openapi.yaml b/.generator/schemas/v1/openapi.yaml index a1d005a8d21..7c5eada104a 100644 --- a/.generator/schemas/v1/openapi.yaml +++ b/.generator/schemas/v1/openapi.yaml @@ -1390,6 +1390,7 @@ components: - PREVIOUS_WEEK - PREVIOUS_MONTH ContentEncoding: + default: gzip description: HTTP header used to compress the media-type. enum: - gzip diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index c15232d0429..f1f637054e0 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -22550,6 +22550,7 @@ components: type: string type: object ContentEncoding: + default: gzip description: HTTP header used to compress the media-type. enum: - identity diff --git a/src/main/java/com/datadog/api/client/v1/api/LogsApi.java b/src/main/java/com/datadog/api/client/v1/api/LogsApi.java index 0487357681d..569468a5d3e 100644 --- a/src/main/java/com/datadog/api/client/v1/api/LogsApi.java +++ b/src/main/java/com/datadog/api/client/v1/api/LogsApi.java @@ -187,13 +187,14 @@ public CompletableFuture> listLogsWithHttpInfoAsyn /** Manage optional parameters to submitLog. */ public static class SubmitLogOptionalParameters { - private ContentEncoding contentEncoding; + private ContentEncoding contentEncoding = ContentEncoding.GZIP; private String ddtags; /** * Set contentEncoding. * - * @param contentEncoding HTTP header used to compress the media-type. (optional) + * @param contentEncoding HTTP header used to compress the media-type. (optional, default to + * "gzip") * @return SubmitLogOptionalParameters */ public SubmitLogOptionalParameters contentEncoding(ContentEncoding contentEncoding) { diff --git a/src/main/java/com/datadog/api/client/v2/api/LogsApi.java b/src/main/java/com/datadog/api/client/v2/api/LogsApi.java index a83e56bf97d..8d81833f3c5 100644 --- a/src/main/java/com/datadog/api/client/v2/api/LogsApi.java +++ b/src/main/java/com/datadog/api/client/v2/api/LogsApi.java @@ -765,13 +765,14 @@ public CompletableFuture> listLogsGetWithHttpInfoA /** Manage optional parameters to submitLog. */ public static class SubmitLogOptionalParameters { - private ContentEncoding contentEncoding; + private ContentEncoding contentEncoding = ContentEncoding.GZIP; private String ddtags; /** * Set contentEncoding. * - * @param contentEncoding HTTP header used to compress the media-type. (optional) + * @param contentEncoding HTTP header used to compress the media-type. (optional, default to + * "gzip") * @return SubmitLogOptionalParameters */ public SubmitLogOptionalParameters contentEncoding(ContentEncoding contentEncoding) { diff --git a/src/test/resources/com/datadog/api/client/v1/api/logs.feature b/src/test/resources/com/datadog/api/client/v1/api/logs.feature index 5ae909c3aae..46c72c664a4 100644 --- a/src/test/resources/com/datadog/api/client/v1/api/logs.feature +++ b/src/test/resources/com/datadog/api/client/v1/api/logs.feature @@ -32,11 +32,11 @@ Feature: Logs When the request is sent Then the response status is 200 OK - @integration-only @skip-terraform-config @skip-validation @team:DataDog/event-platform-intake + @skip-terraform-config @skip-validation @team:DataDog/event-platform-intake Scenario: Send deflate logs returns "Response from server (always 200 empty JSON)." response Given new "SubmitLog" request And body with value [{"message": "{{ unique }}", "ddtags": "host:{{ unique_alnum }}"}] - And request contains "Content-Encoding" parameter with value "deflate" + And the user selects "deflate" compression When the request is sent Then the response status is 200 Response from server (always 200 empty JSON). @@ -52,6 +52,7 @@ Feature: Logs Scenario: Send logs returns "Response from server (always 200 empty JSON)." response Given new "SubmitLog" request And body with value [{"message": "{{ unique }}", "ddtags": "host:{{ unique_alnum }}"}] + And the request uses "gzip" compression When the request is sent Then the response status is 200 Response from server (always 200 empty JSON). diff --git a/src/test/resources/com/datadog/api/client/v2/api/logs.feature b/src/test/resources/com/datadog/api/client/v2/api/logs.feature index b7accd07dd9..d23e1f6abd6 100644 --- a/src/test/resources/com/datadog/api/client/v2/api/logs.feature +++ b/src/test/resources/com/datadog/api/client/v2/api/logs.feature @@ -128,11 +128,11 @@ Feature: Logs Then the response status is 200 OK And the response has 3 items - @integration-only @skip-terraform-config @skip-validation @team:DataDog/event-platform-intake @team:DataDog/logs-backend @team:DataDog/logs-ingestion + @skip-terraform-config @skip-validation @team:DataDog/event-platform-intake @team:DataDog/logs-backend @team:DataDog/logs-ingestion Scenario: Send deflate logs returns "Request accepted for processing (always 202 empty JSON)." response Given new "SubmitLog" request And body with value [{"ddsource": "nginx", "ddtags": "env:staging,version:5.1", "hostname": "i-012345678", "message": "2019-11-19T14:37:58,995 INFO [process.name][20081] Hello World", "service": "payment"}] - And request contains "Content-Encoding" parameter with value "deflate" + And the user selects "deflate" compression When the request is sent Then the response status is 202 Response from server (always 202 empty JSON). @@ -169,5 +169,6 @@ Feature: Logs Scenario: Send logs returns "Request accepted for processing (always 202 empty JSON)." response Given new "SubmitLog" request And body with value [{"ddsource": "nginx", "ddtags": "env:staging,version:5.1", "hostname": "i-012345678", "message": "2019-11-19T14:37:58,995 INFO [process.name][20081] Hello World", "service": "payment", "status": "info"}] + And the request uses "gzip" compression When the request is sent Then the response status is 202 Request accepted for processing (always 202 empty JSON). diff --git a/src/test/resources/generated-test/test-runner-data/manifest.json b/src/test/resources/generated-test/test-runner-data/manifest.json index 24847416a45..f27f17133d7 100644 --- a/src/test/resources/generated-test/test-runner-data/manifest.json +++ b/src/test/resources/generated-test/test-runner-data/manifest.json @@ -1211,6 +1211,13 @@ "scenario": "Search test logs returns \"OK\" response", "version": "v1" }, + { + "feature": "Logs", + "feature_file": "../../com/datadog/api/client/v1/api/logs.feature", + "file": "v1/logs/send-deflate-logs-returns-response-from-server-always-200-empty-json-response.json", + "scenario": "Send deflate logs returns \"Response from server (always 200 empty JSON).\" response", + "version": "v1" + }, { "feature": "Logs", "feature_file": "../../com/datadog/api/client/v1/api/logs.feature", @@ -6377,6 +6384,13 @@ "scenario": "Search logs returns \"OK\" response with pagination", "version": "v2" }, + { + "feature": "Logs", + "feature_file": "../../com/datadog/api/client/v2/api/logs.feature", + "file": "v2/logs/send-deflate-logs-returns-request-accepted-for-processing-always-202-empty-json-response.json", + "scenario": "Send deflate logs returns \"Request accepted for processing (always 202 empty JSON).\" response", + "version": "v2" + }, { "feature": "Logs", "feature_file": "../../com/datadog/api/client/v2/api/logs.feature", diff --git a/src/test/resources/generated-test/test-runner-data/v1/logs/send-deflate-logs-returns-response-from-server-always-200-empty-json-response.json b/src/test/resources/generated-test/test-runner-data/v1/logs/send-deflate-logs-returns-response-from-server-always-200-empty-json-response.json new file mode 100644 index 00000000000..2d2ffc10768 --- /dev/null +++ b/src/test/resources/generated-test/test-runner-data/v1/logs/send-deflate-logs-returns-response-from-server-always-200-empty-json-response.json @@ -0,0 +1,38 @@ +{ + "api": "Logs", + "expected_status": 200, + "feature": "Logs", + "id": "v1/Logs/Send deflate logs returns \"Response from server (always 200 empty JSON).\" response", + "operation_id": "SubmitLog", + "request": { + "body": { + "schema": { + "format": null, + "items": { + "format": null, + "ref": "HTTPLogItem", + "type": "object" + }, + "ref": "HTTPLog", + "type": "array" + }, + "source": "inline", + "value": [ + { + "ddtags": "host:{{ unique_alnum }}", + "message": "{{ unique }}" + } + ] + }, + "compression": "deflate", + "content_type": "application/json", + "method": "POST", + "pagination": false, + "parameters": [], + "path": "/v1/input", + "selected_compression": "deflate" + }, + "scenario": "Send deflate logs returns \"Response from server (always 200 empty JSON).\" response", + "schema_version": 1, + "version": "v1" +} diff --git a/src/test/resources/generated-test/test-runner-data/v1/logs/send-logs-returns-response-from-server-always-200-empty-json-response.json b/src/test/resources/generated-test/test-runner-data/v1/logs/send-logs-returns-response-from-server-always-200-empty-json-response.json index ef45fb23f6f..93efdfd61a9 100644 --- a/src/test/resources/generated-test/test-runner-data/v1/logs/send-logs-returns-response-from-server-always-200-empty-json-response.json +++ b/src/test/resources/generated-test/test-runner-data/v1/logs/send-logs-returns-response-from-server-always-200-empty-json-response.json @@ -24,6 +24,7 @@ } ] }, + "compression": "gzip", "content_type": "application/json", "method": "POST", "pagination": false, diff --git a/src/test/resources/generated-test/test-runner-data/v2/logs/send-deflate-logs-returns-request-accepted-for-processing-always-202-empty-json-response.json b/src/test/resources/generated-test/test-runner-data/v2/logs/send-deflate-logs-returns-request-accepted-for-processing-always-202-empty-json-response.json new file mode 100644 index 00000000000..dec29d12041 --- /dev/null +++ b/src/test/resources/generated-test/test-runner-data/v2/logs/send-deflate-logs-returns-request-accepted-for-processing-always-202-empty-json-response.json @@ -0,0 +1,41 @@ +{ + "api": "Logs", + "expected_status": 202, + "feature": "Logs", + "id": "v2/Logs/Send deflate logs returns \"Request accepted for processing (always 202 empty JSON).\" response", + "operation_id": "SubmitLog", + "request": { + "body": { + "schema": { + "format": null, + "items": { + "format": null, + "ref": "HTTPLogItem", + "type": "object" + }, + "ref": "HTTPLog", + "type": "array" + }, + "source": "inline", + "value": [ + { + "ddsource": "nginx", + "ddtags": "env:staging,version:5.1", + "hostname": "i-012345678", + "message": "2019-11-19T14:37:58,995 INFO [process.name][20081] Hello World", + "service": "payment" + } + ] + }, + "compression": "deflate", + "content_type": "application/json", + "method": "POST", + "pagination": false, + "parameters": [], + "path": "/api/v2/logs", + "selected_compression": "deflate" + }, + "scenario": "Send deflate logs returns \"Request accepted for processing (always 202 empty JSON).\" response", + "schema_version": 1, + "version": "v2" +} diff --git a/src/test/resources/generated-test/test-runner-data/v2/logs/send-logs-returns-request-accepted-for-processing-always-202-empty-json-response.json b/src/test/resources/generated-test/test-runner-data/v2/logs/send-logs-returns-request-accepted-for-processing-always-202-empty-json-response.json index 8d745b280b2..0b8242ed9dc 100644 --- a/src/test/resources/generated-test/test-runner-data/v2/logs/send-logs-returns-request-accepted-for-processing-always-202-empty-json-response.json +++ b/src/test/resources/generated-test/test-runner-data/v2/logs/send-logs-returns-request-accepted-for-processing-always-202-empty-json-response.json @@ -28,6 +28,7 @@ } ] }, + "compression": "gzip", "content_type": "application/json", "method": "POST", "pagination": false, diff --git a/src/test/resources/generated-test/test-server b/src/test/resources/generated-test/test-server index 417fcc086cf..60f6b87cb44 100755 --- a/src/test/resources/generated-test/test-server +++ b/src/test/resources/generated-test/test-server @@ -10,12 +10,14 @@ from __future__ import annotations import argparse import base64 +import gzip import json import os import re import tempfile import threading import uuid +import zlib from datetime import datetime, timezone from http import HTTPStatus from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer @@ -44,6 +46,7 @@ SAFE_BROWSER_HEADERS = { "content-security-policy": "default-src 'none'; sandbox", "x-content-type-options": "nosniff", } +ZSTD_FRAME_MAGIC = b"\x28\xb5\x2f\xfd" class RecordingDatabase: @@ -52,9 +55,11 @@ class RecordingDatabase: self.lock = threading.RLock() self.shards: dict[tuple[str, str], dict[str, Any]] = {} self.shard_paths: dict[tuple[str, str], Path] = {} + self.request_plans: dict[tuple[str, str, str], dict[str, Any]] = {} self.sessions: dict[str, dict[str, Any]] = {} self.fallback_consumed: set[tuple[str, str, str, int]] = set() self._load() + self._load_request_plans() def _load(self) -> None: manifest_path = self.root / "manifest.json" @@ -70,6 +75,17 @@ class RecordingDatabase: self.shards[key] = shard self.shard_paths[key] = path + def _load_request_plans(self) -> None: + root = self.root.parent / "test-runner-data" + manifest_path = root / "manifest.json" + if not manifest_path.exists(): + return + manifest = _read_json(manifest_path) + for item in manifest.get("scenarios", []): + plan = _read_json(root / item["file"]) + key = (item["version"], item["feature"], item["scenario"]) + self.request_plans[key] = plan.get("request", {}) + def start(self, version: str, feature: str, scenario: str, mode: str) -> dict[str, Any]: with self.lock: key = (version, feature) @@ -91,6 +107,7 @@ class RecordingDatabase: "key": key, "scenario": scenario, "recording": recording, + "request_plan": self.request_plans.get((version, feature, scenario)), "cursor": 0, "captures": [], "frozen_at": frozen_at, @@ -109,7 +126,7 @@ class RecordingDatabase: if cursor >= len(interactions): raise LookupError(f"Recording has no interaction #{cursor + 1}") expected = interactions[cursor] - if not _requests_match(expected["request"], actual): + if not _requests_match(expected["request"], actual, session["request_plan"]): raise RequestMismatchError(expected["request"], actual, cursor) session["cursor"] += 1 return expected["response"] @@ -298,7 +315,13 @@ class TestRequestHandler(BaseHTTPRequestHandler): def _handle_api_request(self) -> None: body = self._read_body() - actual = _normalise_request(self.command, self.path, self.headers.get("content-type", ""), body) + actual = _normalise_request( + self.command, + self.path, + self.headers.get("content-type", ""), + self.headers.get("content-encoding", ""), + body, + ) session_id = self.headers.get(SESSION_HEADER) if self.server.mode == "replay": response = self.server.database.replay(session_id, actual) @@ -372,21 +395,50 @@ class TestRequestHandler(BaseHTTPRequestHandler): self.wfile.write(body) -def _normalise_request(method: str, raw_path: str, content_type: str, body: bytes) -> dict[str, Any]: +def _normalise_request( + method: str, + raw_path: str, + content_type: str, + content_encoding: str, + body: bytes, +) -> dict[str, Any]: parsed = urlsplit(raw_path) - normalised_body = _normalise_body(body, content_type) - return { + compression = content_encoding.strip().casefold() + normalised_body = _normalise_body(body, content_type, compression) + request = { "method": method.upper(), "path": _normalise_path(parsed.path), "query": sorted([list(pair) for pair in parse_qsl(parsed.query, keep_blank_values=True)]), "content_type": _normalise_content_type(content_type, normalised_body), "body": normalised_body, } + if compression: + request["compression"] = compression + return request -def _normalise_body(body: bytes, content_type: str) -> dict[str, Any]: +def _normalise_body(body: bytes, content_type: str, compression: str = "") -> dict[str, Any]: if not body: return {"type": "empty", "value": None} + if compression == "zstd1": + if len(body) > len(ZSTD_FRAME_MAGIC) and body.startswith(ZSTD_FRAME_MAGIC): + # The generated server has no third-party dependencies, so validate + # the Zstandard frame on the wire without attempting to decode it. + return {"type": "zstd1", "value": None} + return { + "type": "invalid-compression", + "value": base64.b64encode(body).decode("ascii"), + } + try: + if compression == "gzip": + body = gzip.decompress(body) + elif compression == "deflate": + body = zlib.decompress(body) + except (EOFError, OSError, zlib.error): + return { + "type": "invalid-compression", + "value": base64.b64encode(body).decode("ascii"), + } media_type = _media_type(content_type) text = body.decode("utf-8", errors="surrogateescape") if media_type.endswith("json"): @@ -415,16 +467,38 @@ def _normalise_content_type(content_type: str, body: dict[str, Any]) -> str: return "" if body["type"] == "empty" else _media_type(content_type) -def _requests_match(expected: dict[str, Any], actual: dict[str, Any]) -> bool: +def _requests_match( + expected: dict[str, Any], + actual: dict[str, Any], + request_plan: dict[str, Any] | None = None, +) -> bool: comparable_fields = ("method", "path", "query", "content_type") if any(expected[field] != actual[field] for field in comparable_fields): return False + expected_compression = expected.get("compression") + if request_plan and _request_matches_plan(expected, request_plan): + expected_compression = request_plan.get("compression", expected_compression) + if expected_compression is not None and actual.get("compression", "") != expected_compression: + return False return _bodies_match(expected["body"], actual["body"]) +def _request_matches_plan(request: dict[str, Any], plan: dict[str, Any]) -> bool: + if request["method"] != plan.get("method"): + return False + path = plan.get("path") + if not path: + return False + parts = re.split(r"(\{[^/{}]+\})", path) + pattern = "".join(r"[^/]+" if part.startswith("{") else re.escape(part) for part in parts) + return re.fullmatch(pattern, request["path"]) is not None + + def _bodies_match(expected: dict[str, Any], actual: dict[str, Any]) -> bool: if expected == actual: return True + if actual["type"] == "zstd1": + return expected["type"] != "empty" if expected["type"] != "json" or actual["type"] != "json": return False return _json_contains(actual["value"], expected["value"]) diff --git a/src/test/resources/generated-test/test-server-data/v1/logs.json b/src/test/resources/generated-test/test-server-data/v1/logs.json index 3ade4a2a924..e7057cad2b3 100644 --- a/src/test/resources/generated-test/test-server-data/v1/logs.json +++ b/src/test/resources/generated-test/test-server-data/v1/logs.json @@ -41,6 +41,42 @@ "scenario": "Search test logs returns \"OK\" response", "version": "v1" }, + { + "feature": "Logs", + "frozen_at": "2026-02-02T02:40:00.000Z", + "interactions": [ + { + "request": { + "body": { + "type": "json", + "value": [ + { + "ddtags": "host:TestSenddeflatelogsreturnsResponsefromserveralways200emptyJSONresponse1770000000", + "message": "Test-Send_deflate_logs_returns_Response_from_server_always_200_empty_JSON_response-1770000000" + } + ] + }, + "content_type": "application/json", + "method": "POST", + "path": "/v1/input", + "query": [] + }, + "response": { + "body": { + "encoding": "text", + "value": "{}" + }, + "headers": { + "content-type": "application/json" + }, + "reason": "OK", + "status": 200 + } + } + ], + "scenario": "Send deflate logs returns \"Response from server (always 200 empty JSON).\" response", + "version": "v1" + }, { "feature": "Logs", "frozen_at": "2022-04-12T14:46:46.337Z", diff --git a/src/test/resources/generated-test/test-server-data/v2/logs.json b/src/test/resources/generated-test/test-server-data/v2/logs.json index d4b92521f23..3803dac202c 100644 --- a/src/test/resources/generated-test/test-server-data/v2/logs.json +++ b/src/test/resources/generated-test/test-server-data/v2/logs.json @@ -467,6 +467,45 @@ "scenario": "Search logs returns \"OK\" response with pagination", "version": "v2" }, + { + "feature": "Logs", + "frozen_at": "2026-02-02T02:40:00.000Z", + "interactions": [ + { + "request": { + "body": { + "type": "json", + "value": [ + { + "ddsource": "nginx", + "ddtags": "env:staging,version:5.1", + "hostname": "i-012345678", + "message": "2019-11-19T14:37:58,995 INFO [process.name][20081] Hello World", + "service": "payment" + } + ] + }, + "content_type": "application/json", + "method": "POST", + "path": "/api/v2/logs", + "query": [] + }, + "response": { + "body": { + "encoding": "text", + "value": "{}" + }, + "headers": { + "content-type": "application/json" + }, + "reason": "Accepted", + "status": 202 + } + } + ], + "scenario": "Send deflate logs returns \"Request accepted for processing (always 202 empty JSON).\" response", + "version": "v2" + }, { "feature": "Logs", "frozen_at": "2024-10-01T15:36:43.563Z",