@@ -205,12 +205,12 @@ one event per record to `{logStreamPrefix}YYYY/MM/DD` (IAM: `logs:CreateLogStrea
   `{"timestamp":"<UTC, 3 fraction digits>Z","level":"INFO","message":"<compact record JSON>"}`,
   because the JS readers of this destination filter on `level` and parse `message`. The Node
   runtime adds this envelope around `console.log`; Java `System.out` is not wrapped, and Lambda
-  does not re-wrap a line that is already JSON. `maxRecordSizeBytes` is measured on the record
-  (`render`), not on the printed line. The record is embedded in `message` as a JSON string, so
-  every `"` and `\` in it is escaped again: the line is the record plus 68 bytes plus one byte
-  per quote or backslash in the record, and can be up to about twice the record size
-  (`2 × maxRecordSizeBytes + 68` in the worst case, about 512 KB with the default 256,000). That
-  is within the CloudWatch Logs limit of 1 MB per log event.
+  does not re-wrap a line that is already JSON. `maxRecordSizeBytes` caps the printed line,
+  envelope included. The record is embedded in `message` as a JSON string, so every `"` and `\`
+  in it is escaped again and the line can be up to about twice the record. When the line is over
+  the limit, the exporter truncates the record again, measuring the escaped envelope, until the
+  line fits. With the default 256,000, or any limit up to 1 MB, every line is within the
+  CloudWatch Logs limit of 1 MB per log event.
   `LambdaLogExporter` lines are INFO; an application log level of WARN or above drops them.
   This line shape is a breaking change: 2.3.0 printed the bare record JSON, so a reader that
   parsed each stdout line as a record must now parse `message`.
 
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 package software.amazon.lambda.durable.telemetry.exporters;
 
+import java.nio.charset.StandardCharsets;
 import java.time.Instant;
 import java.time.ZoneOffset;
 import java.time.format.DateTimeFormatter;
@@ -11,6 +12,7 @@
 import software.amazon.lambda.durable.telemetry.DurableExecutionTelemetryRecord;
 import software.amazon.lambda.durable.telemetry.Json;
 import software.amazon.lambda.durable.telemetry.TelemetryExporter;
+import software.amazon.lambda.durable.telemetry.Truncation;
 
 /**
  * Exports workflow telemetry records to CloudWatch Logs via {@code System.out.println} (Lambda captures stdout to the
@@ -22,11 +24,11 @@
  * runtime adds that envelope around {@code console.log}, but Java {@code System.out} is not wrapped, so this exporter
  * writes it itself; Lambda does not re-wrap a line that is already JSON.
  *
- * <p><b>Line size.</b> {@link #maxRecordSizeBytes()} is measured on the record ({@link #render}), not on the printed
- * line. The record is embedded in {@code message} as a JSON string, so every {@code "} and {@code \} in it is escaped
- * again: the line is the record plus 68 bytes of envelope plus one byte per quote or backslash in the record, so it can
- * be up to about twice the record size ({@code 2 × maxRecordSizeBytes + 68} in the worst case). With the default
- * 256,000-byte limit that is about 512 KB, within the CloudWatch Logs limit of 1 MB per log event.
+ * <p><b>Line size.</b> {@link #maxRecordSizeBytes()} caps the printed line, envelope included. The record is embedded
+ * in {@code message} as a JSON string, so every {@code "} and {@code \} in it is escaped again and the line can be up
+ * to about twice the record. When the line is over the limit, {@link #export} truncates the record again, measuring the
+ * escaped envelope, until the line fits. With the default 256,000-byte limit every line stays well within the
+ * CloudWatch Logs limit of 1 MB per log event, and so does any limit up to 1 MB.
  *
  * <p>Lines are written with {@code "level":"INFO"}. With the Lambda JSON log format and an application log level of
  * {@code WARN} or above, Lambda drops them.
@@ -37,10 +39,7 @@ public final class LambdaLogExporter implements TelemetryExporter {
     private static final DateTimeFormatter TIMESTAMP =
             DateTimeFormatter.ofPattern("uuuu-MM-dd'T'HH:mm:ss.SSS'Z'").withZone(ZoneOffset.UTC);
 
-    /**
-     * Budget for the rendered record, not the printed line (see the class documentation). The default 256,000 keeps the
-     * worst-case escaped line (about 512 KB) under the CloudWatch Logs limit of 1 MB per log event.
-     */
+    /** Budget for the printed line, envelope included (see the class documentation). */
     private final Integer maxRecordSizeBytes;
 
     public LambdaLogExporter() {
@@ -63,15 +62,33 @@ public Object render(DurableExecutionTelemetryRecord record) {
 
     @Override
     public void export(DurableExecutionTelemetryRecord record) {
-        System.out.println(logLine(Json.stringify(render(record)), Instant.now()));
+        System.out.println(fittedLine(record, maxRecordSizeBytes, Instant.now()));
+    }
+
+    /**
+     * Returns the envelope line for {@code record}, truncated so that the line, escaping included, is at most
+     * {@code maxBytes} bytes. The record passed in was truncated against {@link #render}, which does not count the
+     * second escaping of {@code message}, so it is truncated again here with the envelope as the measured rendering.
+     */
+    String fittedLine(DurableExecutionTelemetryRecord record, Integer maxBytes, Instant now) {
+        String line = logLine(Json.stringify(render(record)), now);
+        if (maxBytes == null || maxBytes <= 0 || line.getBytes(StandardCharsets.UTF_8).length <= maxBytes) {
+            return line;
+        }
+        var fitted = Truncation.truncateRecord(record, maxBytes, r -> envelope(Json.stringify(render(r)), now));
+        return logLine(Json.stringify(render(fitted)), now);
     }
 
     /** Builds the one-line Lambda JSON log envelope; keys in the shared cross-SDK order. */
     static String logLine(String recordJson, Instant now) {
+        return Json.stringify(envelope(recordJson, now));
+    }
+
+    private static Map<String, Object> envelope(String recordJson, Instant now) {
         Map<String, Object> line = new LinkedHashMap<>();
         line.put("timestamp", TIMESTAMP.format(now));
         line.put("level", "INFO");
         line.put("message", recordJson);
-        return Json.stringify(line);
+        return line;
     }
 }
@@ -33,11 +33,15 @@ class LambdaLogExporterTest {
     private static final Pattern READER_MESSAGE_FILTER = Pattern.compile("DurableExecutionTelemetry");
 
     private static String exportAndCapture(DurableExecutionTelemetryRecord record) {
+        return exportAndCapture(new LambdaLogExporter(), record);
+    }
+
+    private static String exportAndCapture(LambdaLogExporter exporter, DurableExecutionTelemetryRecord record) {
         PrintStream original = System.out;
         ByteArrayOutputStream buffer = new ByteArrayOutputStream();
         try (PrintStream capture = new PrintStream(buffer, true, StandardCharsets.UTF_8)) {
             System.setOut(capture);
-            new LambdaLogExporter().export(record);
+            exporter.export(record);
         } finally {
             System.setOut(original);
         }
@@ -84,21 +88,16 @@ void timestampAlwaysHasThreeFractionDigitsInUtc() {
     }
 
     @Test
-    void truncationIsMeasuredOnTheRecordNotTheEnvelope() {
+    void lineThatFitsIsPrintedWhole() {
         var record = RecordFactory.sample();
         var exporter = new LambdaLogExporter();
-        int recordBytes = Json.byteSize(exporter.render(record));
-
-        // A limit equal to the rendered record keeps it whole, even though the printed envelope line is larger.
-        var shaped = Truncation.truncateRecord(record, recordBytes, exporter::render);
-        assertSame(record, shaped);
-        assertFalse(shaped.toWireMap().containsKey("truncated"));
-        String line = exportAndCapture(shaped).strip();
-        String recordJson = Json.stringify(exporter.render(shaped));
+        String line = exportAndCapture(record).strip();
+        String recordJson = Json.stringify(exporter.render(record));
         assertEquals(
-                recordBytes + ENVELOPE_BYTES + escapedChars(recordJson),
+                Json.byteSize(exporter.render(record)) + ENVELOPE_BYTES + escapedChars(recordJson),
                 line.getBytes(StandardCharsets.UTF_8).length,
                 "line = record + 68-byte envelope + one byte per quote or backslash in the record");
+        assertFalse(line.contains("\\\"truncated\\\""), "not truncated: " + line);
     }
 
     /** Bytes the envelope adds around an empty {@code message}. */
@@ -115,23 +114,31 @@ void envelopeAddsSixtyEightBytes() {
     }
 
     /**
-     * An escape-heavy record just under the default 256,000-byte budget is not truncated, and its printed line is about
-     * twice the record: at most {@code 2 × maxRecordSizeBytes + 68}, and under the 1 MB CloudWatch Logs event limit.
+     * The limit caps the printed line, escaping included. An escape-heavy record that fits the record budget but whose
+     * line does not (300,000 backslashes are about 600 KB of record and 1.2 MB of line) is truncated again until the
+     * line fits; its message still parses and says it was truncated.
      */
     @Test
-    void escapeHeavyRecordNearTheLimitDoublesButStaysUnderOneMegabyte() {
-        var exporter = new LambdaLogExporter();
-        int limit = exporter.maxRecordSizeBytes();
-        for (char ch : new char[] {'"', '\\'}) {
-            var record = RecordFactory.sampleWithInput(String.valueOf(ch).repeat(127_000));
-            int recordBytes = Json.byteSize(exporter.render(record));
-            assertTrue(recordBytes <= limit && recordBytes > limit - 2_000, "record near the limit: " + recordBytes);
-            var shaped = Truncation.truncateRecord(record, limit, exporter::render);
-            assertSame(record, shaped, "not truncated");
-            int lineBytes = exportAndCapture(shaped).strip().getBytes(StandardCharsets.UTF_8).length;
-            assertTrue(lineBytes > 2 * recordBytes - 1_000, "line about twice the record: " + lineBytes);
-            assertTrue(lineBytes <= 2 * limit + ENVELOPE_BYTES, "line within 2 x limit + 68: " + lineBytes);
-            assertTrue(lineBytes < 1_048_576, "line under the 1 MB CloudWatch Logs event limit: " + lineBytes);
+    @SuppressWarnings("unchecked")
+    void escapeHeavyRecordIsTruncatedUntilThePrintedLineFits() throws Exception {
+        for (int limit : new int[] {256_000, 1_000_000}) {
+            var exporter = new LambdaLogExporter(limit);
+            for (char ch : new char[] {'"', '\\'}) {
+                int count = limit == 1_000_000 ? 300_000 : 127_000;
+                var record = RecordFactory.sampleWithInput(String.valueOf(ch).repeat(count));
+                int recordBytes = Json.byteSize(exporter.render(record));
+                assertTrue(recordBytes <= limit, "record fits the record budget: " + recordBytes);
+                var shaped = Truncation.truncateRecord(record, limit, exporter::render);
+                assertSame(record, shaped, "record-level truncation keeps it whole");
+
+                String line = exportAndCapture(exporter, shaped).strip();
+                int lineBytes = line.getBytes(StandardCharsets.UTF_8).length;
+                assertTrue(lineBytes <= limit, limit + ": printed line within the limit: " + lineBytes);
+                Map<String, Object> envelope = MAPPER.readValue(line, Map.class);
+                Map<String, Object> parsed = MAPPER.readValue((String) envelope.get("message"), Map.class);
+                assertEquals(Boolean.TRUE, parsed.get("truncated"), "record says it was truncated");
+                assertEquals(record.executionArn(), parsed.get("executionArn"));
+            }
         }
     }
 }