:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
feat(logs): port logs ingestion to rust (#127608)
Frank Hamand9d1c30df45fb
diff --git a/rust/Cargo.lock b/rust/Cargo.lockindex e24c58f4de69..0d455a194cb5 100644--- a/rust/Cargo.lock+++ b/rust/Cargo.lock@@ -7735,6 +7735,37 @@ dependencies = ["value-bag",]+[[package]]+name = "logs-ingestion"+version = "0.1.0"+dependencies = [+ "ahash 0.8.12",+ "anyhow",+ "async-trait",+ "base64 0.22.1",+ "chrono",+ "common-alloc",+ "futures",+ "hashbrown 0.15.5",+ "hex",+ "hmac 0.12.1",+ "ingestion-framework",+ "itoa",+ "metrics",+ "rand 0.8.5",+ "redis",+ "regex",+ "regex-automata",+ "serde",+ "serde_json",+ "sha2 0.10.9",+ "thiserror 2.0.18",+ "tokio",+ "tracing",+ "uuid",+ "zstd 0.13.3",+]+[[package]]name = "lru"version = "0.12.5"diff --git a/rust/Cargo.toml b/rust/Cargo.tomlindex 8576a51fb387..7291d2e77514 100644--- a/rust/Cargo.toml+++ b/rust/Cargo.toml@@ -61,6 +61,7 @@ members = ["kafka-assigner-proto","ingestion-consumer","ingestion-framework",+ "logs-ingestion","ingestion-control-plane","ingestion-worker-proto","kafka-deduplicator",diff --git a/rust/affected-services/tests/integration.rs b/rust/affected-services/tests/integration.rsindex af4e9a1c4143..ae6e2c56b96e 100644--- a/rust/affected-services/tests/integration.rs+++ b/rust/affected-services/tests/integration.rs@@ -113,6 +113,7 @@ fn every_deployable_binary_has_an_image_entry() {"stl_dump","run", // hogvm dev/diff CLI, not a service"hermes",+ "logs-ingestion-bench", // logs consumer benchmark CLI, not a service"personhog-stateright", // model-checker explorer CLI, not a service"personhog-test-harness", // e2e load/correctness harness CLI, not a service"reconcile_dispatch", // operator-invoked cohort reconcile dispatcher CLI, not a servicediff --git a/rust/logs-ingestion/Cargo.toml b/rust/logs-ingestion/Cargo.tomlnew file mode 100644index 000000000000..71b353b953f6--- /dev/null+++ b/rust/logs-ingestion/Cargo.toml@@ -0,0 +1,38 @@+[package]+name = "logs-ingestion"+version = "0.1.0"+edition = "2021"+description = "Rust port of the Node logs ingestion consumer (nodejs/src/logs), kept 1:1 with it by the shared parity corpus"++[lib]+path = "src/lib.rs"++[dependencies]+ahash = { workspace = true }+anyhow = { workspace = true }+async-trait = { workspace = true }+base64 = { workspace = true }+chrono = { workspace = true }+common-alloc = { path = "../common/alloc" }+futures = { workspace = true }+hashbrown = { version = "0.15", default-features = false }+hex = "0.4"+hmac = { workspace = true }+itoa = { workspace = true }+ingestion-framework = { path = "../ingestion-framework" }+metrics = { workspace = true }+rand = { workspace = true }+redis = { workspace = true }+regex = { workspace = true }+regex-automata = "0.4"+serde = { workspace = true }+serde_json = { workspace = true }+sha2 = { workspace = true }+thiserror = { workspace = true }+tokio = { workspace = true }+tracing = { workspace = true }+uuid = { workspace = true }+zstd = { workspace = true }++[dev-dependencies]+tokio = { workspace = true, features = ["test-util"] }diff --git a/rust/logs-ingestion/PORTING.md b/rust/logs-ingestion/PORTING.mdnew file mode 100644index 000000000000..db4793a075fc--- /dev/null+++ b/rust/logs-ingestion/PORTING.md@@ -0,0 +1,289 @@+# Porting notes: logs ingestion, Node to Rust++This crate ports the Node logs consumer in `nodejs/src/logs`.++## Parity contract++For the same messages in, the two must give semantically equivalent output: the same records and field values, numbers equal as doubles, the same sampling, retention and rate-limit decisions, the same headers, the same billing and usage counts, and the same DLQ routing.+Byte layout, the spelling of a number (`1706.7781372070312` or `...313`), and error message text may differ.++The contract is the shared corpus in `nodejs/src/logs/parity/fixtures`:++- `scenarios/*.json` hold end-to-end inputs and the outputs that Node produced.+- `modules/*.json` hold per-function vectors, recorded from Node with `LOGS_PARITY_RECORD=1`.++Read the fixtures with `logs_ingestion::js::json_parse`, not serde_json.+Node writes lone surrogates as `\udXXX`, and serde_json rejects them.++## Status++| TypeScript | Rust module | Status |+| --------------------------------------------------------------------------------------------- | ----------------- | ------------------------------------------- |+| JavaScript built-ins (`JSON`, object key order, UTF-16 strings, `Date.parse`, `Number#toString`) | `js` | Done |+| avsc 5.7.9 container codec as `log-record-avro.ts` registers it | `avro` | Done |+| `LogRecord` shape in `log-record-avro.ts` | `record` | Done |+| `attribute-value.ts` | `attribute_value` | Done |+| `log-body-parse.ts` | `body_parse` | Done |+| `log-pii-scrub.ts` | `pii` | Done |+| `log-pattern-mask.ts`, `log-pattern-stage.ts` | `pattern` | Done (stage wiring waits for `pipeline`) |+| `log-record-avro.ts` (normalize, flatten, enrich), `log-record-size.ts` | `normalize` | Done |+| `sampling/filter-group-match.ts` | `filter_group` | Done |+| `sampling/property-filter-match.ts`, node-re2 `new RE2(p, flags).test` | `property_filter` | Done |+| `sampling/compile-rules.ts`, `sampling/evaluate.ts`, `sampling/logs-sampling.service.ts` | `sampling` | Done (rules cache not ported) |+| `retention/*.ts` except the rules and tracing-config caches | `retention` | Done |+| `metrics-rules/*.ts` | `metric_rules` | Done (HTTP POST and Postgres cache: traits) |+| `internal-logs.ts` | `internal_logs` | Done |+| `pipeline/log-processing-pipeline.ts` | `content_weights` | Done |+| `services/logs-rate-limiter.service.ts`, `common/services/keyed-rate-limiter.service.ts` | `rate_limiter` | Done (Redis behind `TokenBucketRedis`) |+| `pipeline/*.ts`, `logs-ingestion-consumer.ts`, `traces-ingestion-consumer.ts`, `processLogMessageBuffer`, `app-metrics-aggregator.ts` | `pipeline` | Done (hog transformations: trait slot only) |++## API++### `js`++- `JsValue`: `Null`, `Bool`, `Number(f64)`, `String(JsString)`, `Array(Vec<JsValue>)`, `Object(JsObject)`. It is what `JSON.parse` returns.+- `JsObject`: an object in own-property key order.+ - `insert(JsString, JsValue)` and `insert_str` are `obj[k] = v` for a data property. A repeated key keeps its position.+ - It also has `get`, `contains_key` (`Object.hasOwn`), `remove` (`delete`), `iter`, `keys` and `len`.+ - Equality includes key order.+ - `entries` lists the keys as `JsKey` (an index or a named key) without allocating them.+- `JsString`: a JavaScript string. It is WTF-8, so it can hold a lone surrogate.+ - `as_str()` gives `Some(&str)` when there is no lone surrogate.+ - `to_utf8_lossy()` gives the bytes `Buffer.from` writes: U+FFFD for each lone surrogate.+ - `utf16_len()` is `str.length`.+ - `utf16_slice(start, end)` is `str.slice`. It can split a surrogate pair.+ - `push_code_unit` joins a low surrogate onto a trailing high one, as concatenation does.+ - `utf8_byte_len()` is `Buffer.byteLength`.+- `json_parse(&str) -> Result<JsValue, JsonError>` is `JSON.parse`. The error text is not part of any output.+- `json_stringify(&JsValue) -> String` is `JSON.stringify`. `quote_js_string` quotes one string.+- `json_parse_shape(&str, keep_value)` accepts exactly what `json_parse` accepts, but only reports the top-level kind, the top-level keys, and the string values of the keys that `keep_value` names. Pattern selection uses it, so it builds no tree.+- `number_to_string(f64)` is `String(n)`. `write_number` appends the same text to a buffer.+- `utf16_len(&str)` is `str.length`.+- `utf16_slice_lossy(&str, start, end) -> String` slices and writes a split pair as U+FFFD. Use it only where the slice goes straight to bytes.+- `date_parse(&str) -> Option<f64>` is `Date.parse` in epoch milliseconds. `None` is NaN.+- `is_array_index(&str) -> Option<u32>`.++### `avro`++- `decode_container(&[u8]) -> Result<Container, AvroError>` is `decodeLogRecords`.+ - `Container` has `schema_json` (the exact header text), `schema`, `codec` and `records: Vec<AvroValue>`.+ - The `AvroError` `Display` text is the DLQ `error_message`.+- `encode_container(&Schema, codec, &[AvroValue]) -> Result<Vec<u8>, AvroError>` is `encodeLogRecords`.+ - It supports `zstandard` (level 1) and `null`.+ - The header schema is `Schema::to_avsc_json()`.+ - The sync marker is random, so the bytes never match Node's. Compare decoded records.+- `Schema::parse_json(&str)` and `Schema::to_avsc_json()`.+ - `decode_container` parses the header schema through `Schema::parse_json_cached`, a process-wide cache keyed by the exact schema text.+ - A record schema computes its `to_avsc_json` text once.+- `AvroValue` covers `Null`, `Boolean`, `Int(i64)`, `Long(i64)`, `Float(f64)`, `Double(f64)`, `Bytes`, `String`, `Record(Vec<(Arc<str>, AvroValue)>)`, `Enum`, `Fixed`, `Array` and `Map(AvroMap)`. Unions are unwrapped: the value carries its own branch.+- `AvroMap` is a map with plain-object semantics.+ - `assign` is `obj[k] = v`, and drops `__proto__`.+ - `define` defines an own property, as spread does.+ - It also has `get`, `contains_key`, `remove`, `iter`, `iter_strings`, `values_mut`, `into_entries` and `len`.++### `record`++`LogRecord::from_value(AvroValue)` wraps a decoded record, and `into_value()` gives it back for encoding.++- `get`, `get_mut` and `set(name, value)` read and write a property.+ - A name outside the writer schema goes to `extra`.+ - Later stages can read it, as in JavaScript.+ - `into_value` drops it, as avsc ignores unknown properties.+- `has_field` checks the writer schema.+- Typed getters return `None` for null or missing:+ - log fields: `body`, `severity_text`, `attributes`, `retention_days`, `pattern`, and the others;+ - span fields: `name`, `kind`, `status_code`, `end_time`.++## JavaScript rules the port reproduces++Each rule has evidence in Node, and a test that pins it.++1. **Object key order.** Canonical array-index keys come first in ascending order. These are integers from 0 to 2^32 - 2 with no leading zero. Other keys follow in insertion order.+ - Evidence: an avsc map decode of `b, 1, __proto__, dup, dup, 0, 4294967295, 01` gives `0, 1, b, dup, 4294967295, 01`.+ - `flattenJson` keeps or evicts attributes by this order (`lastRetainedKey = Object.keys(result)[n - 1]`).+ - Tests: `avro::value::tests`, `js::object::tests`.+2. **avsc map decode assigns keys onto `{}`.**+ - A `__proto__` key is not an own property and disappears.+ - A duplicate key keeps its first position and takes the last value.+ - Evidence: the edge `map-proto-and-dups`.+3. **`JSON.parse`.**+ - Numbers are f64: `12345678901234567890` becomes `12345678901234567000`.+ - A duplicate key gives the last value at the first position.+ - `__proto__` is an ordinary own key.+ - The only whitespace is space, tab, LF and CR. A BOM, a trailing comma, single quotes, NaN and a leading `+` are errors.+ - A `🚀` pair joins. A lone `\uD83D` stays a lone surrogate.+ - V8 accepts any nesting depth, and so does the port. An array or object deeper than `MAX_BUILT_DEPTH` (512) is checked without a stack and kept as an empty array, so a deep body cannot overflow the stack. No reader goes that deep: the flatten stops past depth 128 and a filter group past depth 16. A filter group nested past 512 levels with a `null` below that level throws in Node and is rejected without the throw here.+ - Tests: `js::json::tests`, `module_vectors::body_parse_matches_node`.+4. **`JSON.stringify` numbers** follow ECMAScript `Number::toString`.+ - Examples: `1e+21`, `1e-7`, `0.30000000000000004`, `-0` becomes `0`, `5e-324`, `1.23e+22`, and `9007199254740993` becomes `9007199254740992`.+ - NaN and Infinity become `null`.+5. **`JSON.stringify` strings.**+ - It escapes `" \ \b \f \n \r \t`, and any other character below 0x20 as `\u00xx` in lowercase hex.+ - It does not escape U+2028, U+2029 or U+007F.+ - It writes a lone surrogate as `\udxxx`.+6. **Lone surrogates.** `str.slice` counts UTF-16 units and can split an emoji.+ - `Buffer.from`, and avsc's string encode, write each lone surrogate as `EF BF BD`. Evidence: `'a\ud83d'` round-trips through avsc as `61 ef bf bd`.+ - TypeScript call sites that can split a pair:+ - `log-pattern-mask.ts` input cap (`body.slice(0, maxInputChars)`) and output cap (`pattern.slice(0, maxOutputChars)`). Use `utf16_slice_lossy`: the output goes straight to Avro bytes.+ - `metrics-rules/tally.ts` label truncation (`value.slice(0, MAX_LABEL_VALUE_LENGTH)`). Use `JsString::utf16_slice`: the label reaches `JSON.stringify` in the OTLP payload, which keeps `\udxxx`.+ - `.length` comparisons against caps. Use `utf16_len`.+ - The pattern input cap is not a gap: node-re2's `replace` writes every lone surrogate as U+FFFD (rule 15), so the masker sees the lossy text in Node too.+7. **`Date.parse`.** V8 tries the ES5 ISO format first, then falls back to a legacy parser.+ - The port follows V8's `dateparser-inl.h`: tokenizer, keyword table, day, time and zone composers, and `TimeClip`.+ - Evidence from `date_parse.json`:+ - Leading whitespace before an ISO string gives NaN.+ - `2025-02-30` is March 2.+ - `T25:00` is NaN. `T24:00` is the next day.+ - Fractions keep 3 digits.+ - `2025-1-5` and `15 January 2025` parse through the legacy path.+ - A bare number gives NaN, because its year falls outside V8's small-integer range.+ - `garbage 2025` is 2025-01-01, but `garbage2025` is NaN.+ - Local time is read as UTC, as the pods run with `TZ=UTC`.+8. **avsc decode.** `decodeLogRecords` registers only `zstandard`, which replaces avsc's built-in codecs.+ The Node consumer carries a pnpm patch to avsc 5.7.9: `Tap.prototype.readLong` reads at most 10 varint bytes, and an 11th byte invalidates the tap and returns 0.+ Without it, a long varint gives a NaN or infinite `bytes` length, and avsc's shared buffer pool then empties every later `bytes` value in the process.+ `Tap::read_long` follows the patched code. The errors and silent cases:++ | Input | Result |+ | --- | --- |+ | Under 4 bytes, or a header that runs past the end | "No metadata found" (the stream ends with no metadata) |+ | Bad magic | "invalid magic bytes" |+ | Any other codec | "unknown codec: X", so `null` and `deflate` containers go to the DLQ |+ | A bad sync marker in any complete block | "invalid sync marker" (avsc checks all blocks before it decompresses any) |+ | Bad zstd | "zstandard codec decompression error" |+ | A record past its block, a string or bytes length that is negative or past the end, or a varint longer than 10 bytes | "truncated block" |+ | A block count outside ±(2^53 - 2), also in trailing bytes | "potential precision loss" (Node rejects since `decodeLogRecords` writes to the decoder directly; through a pipe the throw was uncaught and the promise never settled) |+ | A first array count over 2^32 - 1 | "Invalid array length" |+ | Bad union index | "invalid union index: N" |+ | Bad enum index | "invalid NAME enum index: N" |+ | A long outside ±(2^53 - 2) | "potential precision loss" |+ | An incomplete trailing block, or trailing garbage | Ignored, with no error |+ | A block whose count is below its data | Reads only the counted records |+ | A block with count 0 | Skipped |+ | A block count | Taken as `count \| 0`; a negative count reads records until one fails |+ | Invalid UTF-8 | U+FFFD per maximal invalid subpart |++ - `int` is read with the `long` reader and no range check.+ - Evidence: `tests/fixtures/input-decodes.json` (`edges`).+9. **avsc schema export** (`getSchema({ exportAttrs: true })`) is the header of every re-encoded message.+ - Keeps: field `doc`, `default`, a non-ascending `order`, and `aliases`.+ - Moves: the record `doc` goes last.+ - Drops: unregistered `logicalType` (`timestamp-micros` becomes plain `long`) and custom attributes.+ - Names are written in full, and a named type is referenced by name after its first definition.+ - Test: `schema_export_matches_avsc_for_the_production_schemas`.+10. **avsc encode.**+ - Properties that are not schema fields are ignored. A missing nullable field encodes as null.+ - Blocks hold up to 64 KiB of serialized records. A larger record gets its own block and doubles the size.+11. **`parseFloat`** (`metrics-rules/tally.ts` value attributes).+ - It skips ECMAScript whitespace first: Rust's `char::is_whitespace` adds U+0085 and lacks U+FEFF.+ - It reads the longest decimal prefix: `12.5abc` is 12.5, `1e` is 1, `.5` and `5.` parse, `0x10` is 0, `Infinity` is accepted (and then fails `Number.isFinite`).+ - Port: `metric_rules::js_parse_float`. Tests: its unit test, checked against Node.+12. **`Buffer.from(s, 'base64')` and `buf.toString('ascii')`** (`idToHex`).+ - `'ascii'` clears the high bit of each byte, so `0xC1` reads as `A`.+ - The decoder skips characters outside the alphabet, accepts `-` and `_`, and stops at the first `=`. Bytes after a padded id are ignored.+ - Evidence and test: `id_to_hex` in `tests/fixtures/metric-rules-reference.json`.+13. **`Map` order.** Tallies, the service partition and the overflow map iterate in insertion order, and that order is the OTLP payload order. Rules that share an `id` share one tally map: the first such rule serializes all its entries. Port: `metric_rules::InsertionMap`. Test: `payload_bytes_match_node`.+14. **RE2, not JavaScript `RegExp`.** `log-pii-scrub.ts` and `log-pattern-mask.ts` compile their rules with `createTrackedRE2` (node-re2 1.22.1, UTF-8 mode, flags `gu`).+ - `\d`, `\w` and `\b` are ASCII: `\bab\b` on `'éab abé'` gives `'éX Xé'`.+ - `\s` is `[\t\n\f\r ]`. It excludes `\v`, so `'Bearer\vab'` is not redacted. The `regex` crate's ASCII `\s` includes `\v`.+ - `(?i:` uses Unicode simple case folding: `(?i:[-A-Za-z0-9._~+/])` also matches U+017F and U+212A, so `'bearer \u212Aabc'` is redacted. Nothing else outside ASCII matches, by a scan of every code point.+ - Alternation is leftmost-first in both engines.+ - Port: `pii::translate_re2` rewrites `\d`, `\w`, `\s` and `\b`, and keeps `(?i:` in Unicode mode. Tests: `pii::tests`, and two differential runs against Node of 3,000 random inputs each for `pii` and for `pattern`.+15. **node-re2 `replace` writes a lone surrogate as U+FFFD**, also when nothing matches: `'x\ud800'.replace(re, f)` is `'x\ufffd'`. `exec` indexes stay in UTF-16 units.+ - So `maskString` output is always valid UTF-8, and JSON key-set keys that differ only by a lone surrogate merge: `{"\ud800":1,"\ud801":2,"b":3}` gives `<JSON:b,\ufffd>`.+ - Port: `pattern` masks the lossy UTF-8 form of its input. Test: `pattern::tests::lone_surrogate_keys_merge_after_the_mask`.+16. **`flattenJsonWithBudget` eviction.** Past 50 attributes, a new array-index key evicts the last key in object order, unless that key is an index no greater than the new one. Named keys past the cap are dropped.+ - The last key is the last named key, or else the greatest index. `normalize` keeps the two groups apart, so eviction is a pop.+ - A JSON `null` leaf becomes the string `"null"`, stored as `"\"null\""`. In `string` array mode an array leaf is `JSON.stringify`d after a node-count check.+ - Tests: `normalize_matches_node`, and a differential run of 8,000 random records against Node with no difference outside the gap below.+17. **Prototype members as metric labels.** `tally.ts` reads `map?.[key]` for `attributes.*` and `resource_attributes.*` group-by and value keys, so it also finds `Object.prototype` members (`filter_group::lookup_attribute`).+ - A member with `length >= 2` (`__defineGetter__`) makes `decodeLogAttributeValue` throw. `tallyRecords` does not catch it, so `tally_records` returns `Err` and keeps what the earlier records added.+ - Any other method is a function label: `null` in the label key, and `stringValue` is omitted, so the attribute value is `{}`.+ - `__proto__` gives `{}` in the label key and `"stringValue":{}`.+ - As a value attribute, each one gives NaN, so the record counts in `value_skipped`.+ - Port: `metric_rules::LabelValue`. Evidence and test: the `payloads` cases in `tests/fixtures/metric-rules-reference.json`.+18. **`compileMetricRules` throws when `parseFilterGroup` throws**, so `compile_metric_rules` returns `Result`.+19. **RE2 in filter leaves and sampling patterns.** Regex leaves use `createTrackedRE2(p, 'is')`; `scope_path_pattern` and `path_drop` patterns use no flags.+ - node-re2 first rewrites the pattern text: `\uXXXX` and `\u{...}` become `\x{...}` (any ASCII letter counts as a hex digit, so `\uZZZZ` fails), `\cJ` becomes `\x0A`, long `\p{...}` names map to short ones, `/` becomes `\/`, and `(?<` becomes `(?P<`. The rewrite also runs inside classes: `[(?<a]` matches `P`.+ - RE2 then accepts its own syntax only. It rejects look-around, `\1`-`\9`, `\Z`, `(?x)`, `(?#`, stacked repetition (`a**`, `a{1,2}{3}`, `a???`), a count above 1000, and nested counts whose quotient chain from 1000 reaches 0 (`(a{100}){11}`).+ - It reads as literal what the `regex` crate does not: a `{` that does not start a valid count (`a{,5}`, `a{01}`, `{"a"`), `[` inside a class (`[a[b]]`), and `&&`, `--`, `~~` in a class. `\Q...\E` quotes. `\0dd` is octal.+ - A surrogate code point (`\x{D800}`, or a lone surrogate in the pattern, which V8 writes in its 3-byte form) compiles and never matches. A lone surrogate in the input is U+FFFD.+ - `\p{C}` has no unassigned code points. `\p{Cs}` matches nothing.+ - Port: `property_filter::re2` parses RE2 grammar and writes an equivalent `regex::bytes` pattern. Evidence and test: `tests/fixtures/re2-reference.json` (354 pattern and flag cases, 18,060 `test` results) in `re2_parity`.+20. **`String()` of a rule value can throw.** A filter value object with an own `toString` key makes `String(value)` throw, because JSON cannot make it callable and `valueOf` returns the object. Array elements convert in order, so `['x', {toString: 1}]` matches `x` before it reaches the throw. `classifySamplingRecord` and `evaluateRetentionDays` callers catch it and keep the record. Port: `property_filter::coerce::js_to_string`, returning `JsTypeError`.+21. **Prototype members as filter keys.** `decodedAttr` and `getAttribute` read `map[key]`, so `constructor` or `toString` read a function (`is_set` matches, and `String()` gives `function toString() { [native code] }`), `__proto__` reads `[object Object]`, and `__defineGetter__` makes the decode throw. A non-string `key` converts with `String()`: a missing key reads `attributes['undefined']`. Evidence: a Node probe of `matchFilterGroup`. Test: `filter_group::tests`.+22. **Filter group compile throws on a null child.** `filterGroupDepth` reads `.values` of each child, so a null child anywhere in a group throws, and `compileRuleSet` and `compileRetentionRuleSet` throw with it. A null `config` on any sampling row also throws (`parseAlwaysKeep`). Port: both compilers return `Result`.+23. **Rule quirks kept.** An unknown `rule_type` compiles as `path_drop` with no patterns, but its `always_keep` still keeps records. `applyRateLimits` looks a rule up in `new Map(rules.map(r => [r.id, r]))`, so the last rule with an id wins. Comparisons with `<` on strings use UTF-16 order.+24. **Lost Lua scripts.** ioredis 4 sends `SCRIPT EXISTS` and `SCRIPT LOAD` only for a script it has not seen in the last 60 seconds (`maxScriptsCachingTime`). After a `SCRIPT FLUSH`, each call of a pipeline replies `NOSCRIPT` and counts as a missing reply until that cache clears. The port gives the same missing replies, but it forgets the script on the first `NOSCRIPT` and loads it again in the next pipeline. Test: `rate_limiter::redis::tests`.+25. **ioredis integer replies.** redis-parser 3 reads an integer reply one decimal digit at a time in floating point, so `-9223372036854775808` (Lua's overflow for `1e21`) reads as `-9223372036854778000`. Port: `rate_limiter::redis::ioredis_integer`. Evidence: `rate-limiter-reference.json`.+26. **Content weights key on object identity.** A stage that puts a new record object in the batch gets weight 0 for it. Port: `content_weights::StagedRecord::fresh`. Test: `content_weights::tests`.++### `metric_rules` wiring++`compile_metric_rules` parses filter groups through `metric_rules::parse_filter_group`, which calls `sampling::parse_filter_group`.+A parsed `FilterGroupNode` implements `metric_rules::FilterGroupMatcher` with `filter_group::match_filter_group`.+`compile_metric_rules_with` takes another `FilterGroupParser`.++### `pipeline`++- `LogsIngestionConsumer::new(identity, config, deps)` with `LogsConsumerIdentity::logs()` or `::traces()`, and `LogsIngestionConsumerConfig::from_logs_config` or `::from_traces_config` (the overrides `TracesIngestionConsumer` applies).+- `process_kafka_batch(messages) -> ProcessedBatch { messages, background_task }` is `processKafkaBatch`: parse and admission run before it returns, processing and finalize run in the background task.+- The pipelines match the Node shapes: parse is `per_element(settled parse)` then a fail-on-parse-error chunk step; admission is five chunk steps; processing is `per_element(process, 50)` then a fail-pass chunk step. Each is built per batch.+- A `logs` output produce that fails with a `KafkaProduceError` is `rethrowKafkaOutageAsDependency` (`logs-produce-errors.ts`). A code in `PER_MESSAGE_KAFKA_ERROR_CODES` quarantines the message. Any other code becomes `DependencyUnavailableError`, so it retries in place and then fails the batch. node-rdkafka delivery reports lose the code, so Node also matches the librdkafka text; rdkafka keeps the code. Scenario: `faults-kafka-delivery`.+- Dependencies are traits in `pipeline::deps`. The caller passes the token-bucket transport, the Redis key root and the clock, so a test can pin all three.+- `pipeline::scenario` builds a consumer from a parity scenario with the in-memory dependencies of `parity-harness.ts`. `tests/parity_corpus.rs` replays all scenarios with it; `PARITY_SCENARIO=<name>` runs one.+- `src/bin/logs-ingestion-bench.rs` runs a workload in the same format and prints the Node benchmark's result JSON.++## Not reproduced++- **Writer schemas that fail to parse.** avsc's error text comes from `JSON.parse` or `Type.forSchema`. Capture always writes a valid schema.+- **Writer-schema validation.** avsc's `Type.forSchema` checks are not ported, so accept and reject decisions differ, not only error text. A corrupted record `name` key makes an anonymous record, which avsc decodes and this port rejects. A name with invalid characters (`LogRec\u007frd`) is rejected by avsc and decoded here. Ambiguous unions, field defaults and enum symbols are not validated either.+- **Counts that run far past the data.** For an array or map count in the millions whose items run past the end, avsc keeps reading empty items and Node can throw "Invalid array length" or run out of memory; this port stops at the end with "truncated block". Values that read no bytes, records and array items alike, share a cap of 2^20 per container ("too many empty records"); Node holds them all or runs out of memory.+- **An `int` that decodes past i64.** avsc keeps the float; this port stores an `i64`.+- **Decode error precedence across blocks.** When an early block has a bad record and a later block fails to decompress, avsc's async order decides which error comes first. This port reports the first block in order.+- **Encode error text.** It follows avsc's `invalid <schema>: <value>` shape, but the value is printed with Rust `Debug`. Only a hog transformation that writes a wrongly typed value can reach it. Port it with the transformations.+- **The HTTP POST of `LogsMetricsEmitter`.** The crate has no HTTP client. `LogsMetricsEmitter` takes an `OtlpTransport` and keeps the body, the two attempts, the 2xx check and the `logs_metrics_rules_export_failed_total{team_id}` counter.+- **`MetricRulesCache`.** Only its interface is ported, as `MetricRulesSource`.+- **Flattened JSON keys that differ only by a lone surrogate.** A body such as `{"\ud800":1,"\ud801":2}` gives two attribute keys in Node, and avsc writes both as U+FFFD, so the map holds a duplicate key. `AvroMap` keys are Rust strings, so this port keeps one entry. The same holds for such a key next to a sender key `\ufffd`.+- **The OpenTelemetry skip counter** (`recordJsonEnrichmentSkipped`). `normalize` emits only the Prometheus `logs_ingestion_json_enrichment_skipped_total`.+- **`logs_ingestion_pattern_stage_error_total`.** The Rust stamping cannot fail, so it has no catch path.++- **`hash01FromTraceId` with no trace id.** Node uses `Math.random()`; the port uses `rand`. No vector can pin it.+- **RE2 program size limits.** RE2 rejects a program over `max_mem` (8 MiB) and the `regex` crate has its own size and nesting limits (nesting set to 1000; RE2 has none), so a very large pattern can compile in one engine only. The parser stops at the same nesting of 1000 groups or nested counted repetitions, so a deep pattern fails before it can overflow the stack. The Unicode table versions of the vendored RE2 and the `regex` crate can also differ.+- **Hog log transformations.** `LogsTransformer` is the stage slot; no implementation runs hog yet, and no scenario covers transformations.+- **A Kafka header with a null value.** `parseKafkaHeaders` would throw on it in Node; this port reads it as an empty string.+- **The OpenTelemetry usage counters** (`recordLogsReceived` and the others in `ingestion-otel-metrics.ts`). The Prometheus counters are ported.+- **`re2_objects_created_total`.** The tracked-RE2 allocation counter and its LRU cache are not ported; they do not change a result.+- **The sampling and retention rules caches** (`sampling-rules-cache.ts`, `retention-rules-cache.ts`, `tracing-config-cache.ts`). The compilers take rows.++## Regenerating references++`tests/fixtures/input-decodes.json` comes from `scripts/node-decode-reference.js`. Run it from the repository root after a corpus re-record:++```bash+NODE_PATH=nodejs/node_modules node rust/logs-ingestion/scripts/node-decode-reference.js+```++`tests/fixtures/metric-rules-reference.json` comes from `scripts/node-metric-rules-reference.ts`:++```bash+cd nodejs && npx tsx --tsconfig tsconfig.json ../rust/logs-ingestion/scripts/node-metric-rules-reference.ts+```++`tests/fixtures/re2-reference.json` comes from `scripts/node-re2-reference.js`:++```bash+NODE_PATH=nodejs/node_modules node rust/logs-ingestion/scripts/node-re2-reference.js+```++`tests/fixtures/fuzz/` comes from `scripts/fuzz-generate.ts`, a seeded generator over every module. `tests/differential_fuzz.rs` replays it semantically. Inputs that once differed are in `regression-inputs.json`. `FUZZ_SEED`, `FUZZ_N` and `FUZZ_BUDGET=0` (keep every case) with `FUZZ_OUT` write a larger corpus, and `FUZZ_DIR` replays it.++```bash+cd nodejs && FUZZ_UNIQUE_IDS=1 NODE_PATH=node_modules DATABASE_URL=postgres://x:[email protected]:1/x npx tsx --tsconfig tsconfig.json ../rust/logs-ingestion/scripts/fuzz-generate.ts+```++`tests/fixtures/rate-limiter-reference.json` comes from `scripts/node-rate-limiter-reference.ts`. It needs Redis at 127.0.0.1:6379 and deletes only its own keys (`@posthog-test/logs-parity-rl*` and the sampling keys of team 987654321). `tests/rate_limiter_redis.rs` replays it against the same Redis and skips when Redis is down.++```bash+cd nodejs && NODE_ENV=test npx tsx --tsconfig tsconfig.json ../rust/logs-ingestion/scripts/node-rate-limiter-reference.ts+```diff --git a/rust/logs-ingestion/scripts/fuzz-common.ts b/rust/logs-ingestion/scripts/fuzz-common.tsnew file mode 100644index 000000000000..177591a533fa--- /dev/null+++ b/rust/logs-ingestion/scripts/fuzz-common.ts@@ -0,0 +1,319 @@+export class Rng {+ constructor(private state: number) {}+ next(): number {+ this.state = (this.state + 0x6d2b79f5) | 0;+ let t = this.state;+ t = Math.imul(t ^ (t >>> 15), t | 1);+ t ^= t + Math.imul(t ^ (t >>> 7), t | 61);+ return ((t ^ (t >>> 14)) >>> 0) / 4294967296;+ }+ int(n: number): number {+ return Math.floor(this.next() * n);+ }+ bool(p = 0.5): boolean {+ return this.next() < p;+ }+ pick<T>(items: readonly T[]): T {+ return items[this.int(items.length)];+ }+}++export const KEY_POOL = [+ "",+ "0",+ "1",+ "2",+ "10",+ "01",+ "-1",+ "1.5",+ "1e3",+ "4294967294",+ "4294967295",+ "4294967296",+ "9007199254740993",+ "__proto__",+ "constructor",+ "toString",+ "valueOf",+ "hasOwnProperty",+ "__defineGetter__",+ "length",+ "a",+ "b",+ "a.b",+ "a.",+ ".a",+ "..",+ "message",+ "msg",+ "event",+ "level",+ "user.email",+ "http.method",+ "é",+ "日本",+ "🚀",+ "�",+ "",+ "\u{10000}",+ "full",+ "K",+ "k",+ "payload",+ " ",+ "\t",+ "\n",+ '"',+ "\\",+ "uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6",+ "user_123",+ "12345678",+ "deadbeef",+ "192.168.0.1",+ "host.example.com",+];++export const RAW_KEY_ESCAPES = [+ "\\ud800",+ "\\udfff",+ "\\ud83d\\ude80",+ "\\u0000",+ "\\u2028",+ '\\"',+ "\\\\",+ "\\/",+ "\\ud83d",+ "x\\ude80",+];++export const STRING_POOL = [+ "",+ " ",+ "x",+ "null",+ "true",+ "12",+ " 12 ",+ "0x10",+ "1e3",+ "1e400",+ "-1e400",+ "Infinity",+ "-Infinity",+ "NaN",+ "-0",+ "0",+ "00",+ ".5",+ "5.",+ "1_000",+ "12.5abc",+ " 12",+ "12",+ "12",+ "1,5",+ "+5",+ "0b11",+ "0o7",+ "[email protected]",+ "Bearer abc.def-ghi",+ "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123",+ // Built by concatenation so secret scanners do not flag the source.+ "AK" + "IAIOSFODNN7EXAMPLE",+ "sk" + "_live_0123456789abcdefghijkl",+ "gh" + "p_0123456789abcdefghij0123456789abcdef",+ "xo" + "xb-1234567890-abc",+ "3fa85f64-5717-4562-b3fc-2c963f66afa6",+ "192.168.1.1",+ "2001:db8::1",+ "/api/v1/users/123",+ "GET",+ "POST",+ "é",+ "🚀",+ "日本語",+ " ",+ "\u0085",+ "\u000b",+ "\r\n",+ "ERROR",+ "error",+ "warn",+ "INFO",+ "debug",+ "fatal",+ "2025-01-15T10:00:00Z",+ "Wed, 15 Jan 2025 12:00:00 GMT",+ "x".repeat(300),+ "🚀".repeat(130),+ "é".repeat(200),+ "[1,2]",+ '{"a":1}',+ '"quoted"',+ "\\",+ '"',+ "a\\nb",+];++export const NUMBER_POOL = [+ 0,+ -0,+ 1,+ -1,+ 0.1,+ 0.30000000000000004,+ 1e21,+ 1e-7,+ 1e-6,+ 123456789012345680000,+ 5e-324,+ 1.7976931348623157e308,+ 2 ** 53,+ 2 ** 53 + 2,+ -(2 ** 53),+ 4294967295,+ 4294967294,+ 1.5,+ -1.5,+ 12.5,+ 999.9999999,+ 1e100,+ 2.5e-8,+ 100,+ 7,+];++export function randString(rng: Rng, maxParts = 6): string {+ const n = rng.int(maxParts) + 1;+ let s = "";+ for (let i = 0; i < n; i++) {+ const r = rng.int(10);+ if (r < 6) {+ s += rng.pick(STRING_POOL);+ } else if (r < 8) {+ s += rng.pick(KEY_POOL);+ } else if (r < 9) {+ s += String(rng.pick(NUMBER_POOL));+ } else {+ s += String.fromCodePoint(+ rng.pick([+ 0x20 + rng.int(95),+ 0x80 + rng.int(0x780),+ 0x800 + rng.int(0xd000),+ 0xe000 + rng.int(0x2000),+ 0x10000 + rng.int(0x10000),+ ]),+ );+ }+ if (rng.bool(0.3)) {+ s += " ";+ }+ }+ return s;+}++export function randKey(rng: Rng): string {+ return rng.bool(0.8) ? rng.pick(KEY_POOL) : randString(rng, 2);+}++export function randValue(+ rng: Rng,+ depth: number,+ budget: { nodes: number },+): unknown {+ budget.nodes--;+ const r = rng.int(depth > 6 || budget.nodes <= 0 ? 5 : 8);+ switch (r) {+ case 0:+ return null;+ case 1:+ return rng.bool();+ case 2:+ return rng.bool(0.7)+ ? rng.pick(NUMBER_POOL)+ : (rng.next() - 0.5) * 10 ** (rng.int(40) - 20);+ case 3:+ case 4:+ return randString(rng, 3);+ case 5:+ case 6: {+ const o: Record<string, unknown> = {};+ const n = rng.pick([0, 1, 2, 3, 5, 8, 20, 49, 50, 51, 60]);+ for (let i = 0; i < n && budget.nodes > 0; i++) {+ const k = rng.bool(0.3)+ ? String(+ rng.pick([+ 0, 1, 2, 3, 5, 9, 10, 49, 50, 51, 100, 4294967294,+ 4294967295,+ ]),+ )+ : randKey(rng);+ if (k === "__proto__") {+ Object.defineProperty(o, k, {+ value: randValue(rng, depth + 1, budget),+ enumerable: true,+ writable: true,+ configurable: true,+ });+ } else {+ o[k] = randValue(rng, depth + 1, budget);+ }+ }+ return o;+ }+ default: {+ const n = rng.pick([0, 1, 2, 3, 10, 49, 50, 51, 60, 120]);+ return Array.from({ length: n }, () =>+ budget.nodes > 0 ? randValue(rng, depth + 1, budget) : 1,+ );+ }+ }+}++export function sprinkleEscapes(rng: Rng, text: string): string {+ const times = rng.int(3);+ for (let t = 0; t < times; t++) {+ const positions: number[] = [];+ for (let i = 0; i < text.length; i++) {+ if (text[i] === '"' && text[i - 1] !== "\\") {+ positions.push(i);+ }+ }+ if (positions.length === 0) {+ break;+ }+ const p = rng.pick(positions);+ text =+ text.slice(0, p + 1) ++ rng.pick(RAW_KEY_ESCAPES) ++ text.slice(p + 1);+ }+ return text;+}++export function validJsonOrNull(text: string): boolean {+ try {+ JSON.parse(text);+ return true;+ } catch {+ return false;+ }+}++export function deepJson(rng: Rng): string {+ const depth = rng.pick([126, 127, 128, 129, 130, 200]);+ let open = "";+ let close = "";+ for (let i = 0; i < depth; i++) {+ if (rng.bool()) {+ open += "[";+ close = "]" + close;+ } else {+ const k = rng.pick(["a", "0", "", "b.c"]);+ open += `{"${k}":`;+ close = "}" + close;+ }+ }+ return open + JSON.stringify(rng.pick(["v", 1, null, true])) + close;+}diff --git a/rust/logs-ingestion/scripts/fuzz-generate.ts b/rust/logs-ingestion/scripts/fuzz-generate.tsnew file mode 100644index 000000000000..a48a3ee48e26--- /dev/null+++ b/rust/logs-ingestion/scripts/fuzz-generate.ts@@ -0,0 +1,1825 @@+// See "Regenerating references" in PORTING.md for the command.+import avro from "avsc";+import { createHash } from "crypto";+import { existsSync, readFileSync, writeFileSync } from "fs";+import { join } from "path";++import {+ decodeLogAttributeValue,+ encodeLogAttributeValue,+} from "../../../nodejs/src/logs/attribute-value";+import {+ InternalLogsVerifier,+ signInternalLogs,+} from "../../../nodejs/src/logs/internal-logs";+import {+ MESSAGE_KEYS,+ buildLogPattern,+} from "../../../nodejs/src/logs/log-pattern-mask";+import { scrubPlainStringWithStats } from "../../../nodejs/src/logs/log-pii-scrub";+import {+ type LogRecord,+ decodeLogRecords,+ encodeLogRecords,+ transformDecodedLogRecordsInPlace,+} from "../../../nodejs/src/logs/log-record-avro";+import { compileMetricRules } from "../../../nodejs/src/logs/metrics-rules/compile-metric-rules";+import { withDefaultMetricRules } from "../../../nodejs/src/logs/metrics-rules/default-metric-rules";+import { buildMetricRulesOtlpPayload } from "../../../nodejs/src/logs/metrics-rules/otlp-payload";+import {+ createBatchTallies,+ tallyRecords,+} from "../../../nodejs/src/logs/metrics-rules/tally";+import { compileRetentionRuleSet } from "../../../nodejs/src/logs/retention/compile-retention-rules";+import { evaluateRetentionDays } from "../../../nodejs/src/logs/retention/evaluate-retention";+import { compileRuleSet } from "../../../nodejs/src/logs/sampling/compile-rules";+import { evaluateLogRecord } from "../../../nodejs/src/logs/sampling/evaluate";+import {+ NUMBER_POOL,+ Rng,+ STRING_POOL,+ deepJson,+ randKey,+ randString,+ randValue,+ sprinkleEscapes,+ validJsonOrNull,+} from "./fuzz-common";++process.env.TZ = "UTC";++const OUT = process.env.FUZZ_OUT ?? join(__dirname, "../tests/fixtures/fuzz");+const NOW_MS = Date.UTC(2025, 0, 15, 12, 37, 13, 250);+const N = Number(process.env.FUZZ_N ?? "1");+// Bytes kept per section; 0 keeps every case. Cases over 1/50 of the budget are left out.+const BUDGET = Number(process.env.FUZZ_BUDGET ?? "120000");+const REGRESSIONS: { numbers: string[]; dates: string[]; avro: string[] } =+ existsSync(join(OUT, "regression-inputs.json"))+ ? JSON.parse(readFileSync(join(OUT, "regression-inputs.json"), "utf8"))+ : { numbers: [], dates: [], avro: [] };++// Secret scanners reject secret-shaped tokens, so U+E000 breaks each prefix in the file, and tests/common/mod.rs removes it.+const SECRET_PREFIXES = /(sk|rk|pk)(_(?:live|test)_)|(gh)([pousr]_)|(xo)(x[abpr]-)|(AK|AS)(IA)|(AI)(za)|(gl)(pat-)|(-----)(BEGIN)/g++function defuseSecrets(text: string): string {+ return text.replace(SECRET_PREFIXES, (match) => match[0] + '\uE000' + match.slice(1))+}++function write(name: string, cases: unknown[], budget = BUDGET): void {+ let kept = cases;+ if (budget > 0) {+ kept = [];+ let total = 0;+ for (const c of cases) {+ const size = JSON.stringify(c).length;+ if (+ size > budget / 50 &&+ !(c as { regression?: boolean }).regression+ )+ continue;+ if (total + size > budget) break;+ kept.push(c);+ total += size;+ }+ }+ writeFileSync(+ join(OUT, `${name}.json`),+ defuseSecrets(JSON.stringify({ cases: kept })) + "\n",+ );+ console.log(name, kept.length, "of", cases.length);+}++function recordToJson(record: Record<string, unknown>): unknown {+ return Object.fromEntries(+ Object.entries(record).map(([key, value]) => [+ key,+ Buffer.isBuffer(value) ? { $bytes: value.toString("hex") } : value,+ ]),+ );+}++const lossy = (s: string): string => Buffer.from(s).toString();++/** avsc writes strings and map keys lossy. `gap` marks merged keys. */+function recordToLossyJson(record: Record<string, unknown>): {+ json: unknown;+ gap: boolean;+} {+ let gap = false;+ const out: Record<string, unknown> = {};+ for (const [k, v] of Object.entries(record)) {+ if (Buffer.isBuffer(v)) {+ out[k] = { $bytes: v.toString("hex") };+ } else if (typeof v === "string") {+ out[k] = lossy(v);+ } else if (v !== null && typeof v === "object") {+ const m: Record<string, string> = {};+ let n = 0;+ for (const [mk, mv] of Object.entries(+ v as Record<string, string>,+ )) {+ m[lossy(mk)] = lossy(mv);+ n++;+ }+ if (Object.keys(m).length !== n) {+ gap = true;+ }+ out[k] = m;+ } else {+ out[k] = v;+ }+ }+ return { json: out, gap };+}++function randomJsonText(rng: Rng): string {+ const r = rng.int(10);+ if (r < 5) {+ let t = JSON.stringify(randValue(rng, 0, { nodes: 40 }));+ if (rng.bool(0.5)) {+ t = sprinkleEscapes(rng, t);+ }+ return t;+ }+ if (r < 7) {+ const sign = rng.pick(["", "-", "+", "--"]);+ const int = rng.pick([+ "0",+ "1",+ "00",+ "01",+ "123456789012345678901234567890",+ "9007199254740993",+ "",+ "5",+ ]);+ const frac = rng.pick([+ "",+ ".",+ ".0",+ ".5",+ ".000001",+ ".12345678901234567890",+ ]);+ const exp = rng.pick([+ "",+ "e",+ "E5",+ "e+5",+ "e-5",+ "e308",+ "e309",+ "e-324",+ "e-323",+ "e-400",+ "E+0",+ "e21",+ "e-7",+ ]);+ return (+ rng.pick(["", " ", "\t", "\n", "\r", "\u000b", " ", ""]) ++ sign ++ int ++ frac ++ exp ++ rng.pick(["", " ", " "])+ );+ }+ if (r < 8) {+ let t = JSON.stringify(randValue(rng, 0, { nodes: 15 }));+ const ops = rng.int(3) + 1;+ for (let i = 0; i < ops; i++) {+ const p = rng.int(t.length + 1);+ const ins = rng.pick([+ ",",+ "]",+ "}",+ '"',+ "\\",+ "\\u12",+ "\\x41",+ "\\u0041",+ "\n",+ "\u0001",+ " ",+ "nul",+ "tru",+ "1",+ ".",+ "-",+ "[",+ "{",+ ":",+ ]);+ t = rng.bool()+ ? t.slice(0, p) + ins + t.slice(p)+ : t.slice(0, p) + t.slice(p + 1);+ }+ return t;+ }+ if (r < 9) {+ return deepJson(rng);+ }+ const k = rng.pick([+ '"a"',+ '"0"',+ '"__proto__"',+ '"1"',+ '"01"',+ '"\\u0030"',+ '"\\ud800"',+ ]);+ return `{${k}:1,"b":2,${k}:${rng.pick(["3", '{"x":1}', "null", '"s"'])}}`;+}++function sectionJson(rng: Rng): void {+ const cases = [];+ for (let i = 0; i < 6000 * N; i++) {+ const text = randomJsonText(rng);+ let output: unknown;+ try {+ output = { ok: true, s: JSON.stringify(JSON.parse(text)) };+ } catch {+ output = { ok: false };+ }+ cases.push({ input: text, output });+ }+ write("json", cases);++ const buf = Buffer.alloc(8);+ const nums: unknown[] = REGRESSIONS.numbers.map((hex) => {+ const x = Buffer.from(hex, "hex").readDoubleBE(0);+ return { input: hex, output: String(x), regression: true };+ });+ const special = [+ 0, 5e-324, 2.2250738585072014e-308, 2.225073858507201e-308, 1e21, 1e-7,+ 1e-6, 999999999999999900000, 1e20, 0.000001, 123e-20,+ 1.7976931348623157e308,+ ];+ for (let i = 0; i < 20000 * N; i++) {+ let x: number;+ const r = rng.int(6);+ if (r === 0) {+ for (let b = 0; b < 8; b++) buf[b] = rng.int(256);+ x = buf.readDoubleBE(0);+ } else if (r === 1) {+ x = rng.pick(special) * (rng.bool() ? 1 : -1);+ buf.writeDoubleBE(x);+ buf.writeBigUInt64BE(+ BigInt.asUintN(+ 64,+ buf.readBigUInt64BE(0) + BigInt(rng.int(5) - 2),+ ),+ );+ x = buf.readDoubleBE(0);+ } else if (r === 2) {+ x = Number(+ (rng.next() * 10).toFixed(rng.int(17)) ++ "e" ++ (rng.int(60) - 30),+ );+ } else if (r === 3) {+ x = rng.int(2 ** 31) * 2 ** (rng.int(80) - 20);+ } else if (r === 4) {+ x = Number("0." + "0".repeat(rng.int(10)) + String(rng.int(1e9)));+ } else {+ x = 10 ** (rng.int(50) - 25) * (1 + rng.int(9));+ }+ buf.writeDoubleBE(x);+ nums.push({ input: buf.toString("hex"), output: String(x) });+ }+ write("numbers", nums);+}++const DATE_PIECES = [+ "2025",+ "2025-01-15",+ "2025-1-5",+ "+002025",+ "-000001",+ "275760-09-13",+ "+275760-09-13T00:00:00Z",+ "+275760-09-13T00:00:00.001Z",+ "1970",+ "T",+ " ",+ "12:00",+ "12:00:00",+ "12:00:00.123",+ "12:00:00.123456",+ "24:00",+ "24:00:00.001",+ "25:00",+ "23:59:60",+ "Z",+ "z",+ "+02:00",+ "-0800",+ "+2",+ "GMT",+ "UTC",+ "UT",+ "EST",+ "PDT",+ "Jan",+ "January",+ "jan",+ "Feb",+ "Wed,",+ "Wednesday",+ "am",+ "pm",+ "AM",+ "PM",+ "15",+ "1",+ "31",+ "32",+ "99",+ "49",+ "50",+ "(comment)",+ "(",+ ")",+ ",",+ ".",+ "/",+ "-",+ ":",+ "1/15/2025",+ "15/1/2025",+ "2025/01/15",+ "0",+ "00",+ "1736942400",+ "garbage",+ "T12",+ "-",+ "Z12",+ "2025-02-29",+ "2024-02-29",+ "2025-13-01",+ "2025-00-10",+ "2025-01-15T",+ "2025-01-15T12",+ "2025-01-15T12:00Z",+ "\t",+ "\n",+ " ",+ "",+];++function sectionDate(rng: Rng): void {+ const cases: unknown[] = REGRESSIONS.dates.map((s) => {+ const v = Date.parse(s);+ return {+ input: s,+ output: Number.isNaN(v) ? null : v,+ regression: true,+ };+ });+ for (let i = 0; i < 20000 * N; i++) {+ let s = "";+ const n = rng.int(6) + 1;+ for (let j = 0; j < n; j++) {+ s += rng.pick(DATE_PIECES);+ if (rng.bool(0.3)) s += rng.pick([" ", "", "T", ",", "-"]);+ }+ if (rng.bool(0.15)) {+ s = new Date(+ rng.int(2 ** 40) * (rng.bool() ? 1 : -1),+ ).toISOString();+ if (rng.bool()) s = s.slice(0, rng.int(s.length + 1));+ }+ if (rng.bool(0.1)) {+ s = new Date(rng.int(2 ** 41)).toString();+ if (rng.bool()) s = s.replace(/ \(.*\)/, "");+ }+ if (rng.bool(0.05)) s = new Date(rng.int(2 ** 41)).toUTCString();+ const v = Date.parse(s);+ cases.push({ input: s, output: Number.isNaN(v) ? null : v });+ }+ write("date", cases);+}++const ATTR_KEYS = [+ "url.path",+ "http.path",+ "http.route",+ "path",+ "http.status_code",+ "http.response.status_code",+ "http.server.duration_ms",+ "duration_ms",+ "level",+ "severity_text",+ "service.name",+ "payload",+ "k",+ "1",+ "0",+ "01",+ "count",+ "ms",+ "user.email",+ "message",+ "constructor",+ "toString",+ "valueOf",+ "hasOwnProperty",+ "__defineGetter__",+ "name",+ "status_code",+ "kind",+ "a",+ "a.b",+ "payload.x",+ "payload.0",+ "k8s.pod.name",+ "🚀",+ "é",+ "",+];++function randAttrValue(rng: Rng): string {+ const r = rng.int(10);+ if (r < 3) return JSON.stringify(rng.pick(STRING_POOL));+ if (r < 5) return JSON.stringify(rng.pick(NUMBER_POOL));+ if (r < 6) return JSON.stringify(rng.pick([true, false, null]));+ if (r < 7) return rng.pick(STRING_POOL);+ if (r < 8) return JSON.stringify(randValue(rng, 3, { nodes: 8 }));+ if (r < 9)+ return JSON.stringify(JSON.stringify(randValue(rng, 3, { nodes: 8 })));+ return randString(rng, 3);+}++function randAttrs(rng: Rng, keys = ATTR_KEYS): Record<string, string> | null {+ if (rng.bool(0.1)) return null;+ const a: Record<string, string> = {};+ const n = rng.int(8);+ for (let i = 0; i < n; i++) {+ a[rng.bool(0.85) ? rng.pick(keys) : randKey(rng)] = randAttrValue(rng);+ }+ delete (a as any)["__proto__"];+ return a;+}++function bytes(rng: Rng, n: number): Buffer {+ return Buffer.from(Array.from({ length: n }, () => rng.int(256)));+}++function randLogRecord(rng: Rng, i: number, body?: string | null): LogRecord {+ return {+ uuid: `u${i}`,+ trace_id: rng.bool(0.85)+ ? bytes(rng, rng.pick([16, 16, 16, 0, 8]))+ : null,+ span_id: rng.bool(0.7) ? bytes(rng, 8) : null,+ trace_flags: null,+ timestamp: rng.bool(0.2)+ ? null+ : (NOW_MS - rng.int(40 * 60 * 1000)) * 1000,+ observed_timestamp: NOW_MS * 1000,+ body:+ body !== undefined+ ? body+ : rng.bool(0.1)+ ? null+ : randString(rng, 5),+ severity_text: rng.pick([+ "DEBUG",+ "INFO",+ "WARN",+ "ERROR",+ "info",+ "warning",+ "fatal",+ "trace",+ "Warn",+ "ERRor",+ "",+ null,+ "İnfo",+ "debug ",+ ]),+ severity_number: rng.pick([1, 5, 9, 12, 13, 17, 21, 0, -1, null]),+ service_name: rng.pick(["api", "worker", "web", "", "API", null]),+ resource_attributes: randAttrs(rng, [+ "service.name",+ "k8s.pod.name",+ "constructor",+ "a",+ "1",+ "host",+ ]),+ instrumentation_scope: null,+ event_name: rng.pick([null, "request", ""]),+ attributes: randAttrs(rng),+ bytes_uncompressed: rng.bool(0.8) ? rng.int(2000) : null,+ };+}++function randSpanRecord(rng: Rng, i: number): Record<string, unknown> {+ const ts = (NOW_MS - rng.int(40 * 60 * 1000)) * 1000;+ return {+ uuid: `s${i}`,+ trace_id: rng.bool(0.8) ? bytes(rng, 16) : null,+ span_id: rng.bool(0.7) ? bytes(rng, 8) : null,+ timestamp: rng.bool(0.1) ? null : ts,+ end_time: rng.bool(0.1)+ ? null+ : ts ++ rng.pick([+ 0,+ 1,+ 999,+ 1000,+ 1500,+ 7_250_125,+ 12_000_000_001,+ -5000,+ rng.int(1e9),+ ]),+ name: rng.pick([+ "GET /a",+ "db.query",+ "x".repeat(300),+ "",+ null,+ "🚀".repeat(200),+ ]),+ kind: rng.pick([0, 1, 2, 3, 4, 5, 6, 9, -1, null]),+ status_code: rng.pick([0, 1, 2, 3, 7, -1, null]),+ service_name: rng.pick(["api", "worker", null]),+ resource_attributes: randAttrs(rng, [+ "service.name",+ "k8s.pod.name",+ "a",+ ]),+ attributes: randAttrs(rng),+ };+}++function bigBody(rng: Rng): string {+ const r = rng.int(8);+ if (r === 0) {+ const o: Record<string, unknown> = {};+ const n = 40 + rng.int(80);+ for (let i = 0; i < n; i++) {+ const k = rng.bool(0.5)+ ? String(rng.int(200))+ : rng.bool(0.5)+ ? `k${rng.int(100)}`+ : rng.pick([+ "4294967294",+ "4294967295",+ "01",+ "-0",+ "__proto__",+ ]);+ o[k] = rng.bool(0.8)+ ? rng.int(100)+ : { x: rng.int(3), [String(rng.int(60))]: [1, 2] };+ }+ return JSON.stringify(o);+ }+ if (r === 1) {+ const n = rng.pick([9997, 9998, 9999, 10000, 10001, 4999, 5000]);+ return JSON.stringify(+ rng.bool()+ ? Array.from({ length: n }, (_, i) => i % 7)+ : { a: Array.from({ length: n }, () => 0) },+ );+ }+ if (r === 2) {+ const n = rng.pick([9997, 9998, 9999, 10000]);+ return JSON.stringify(+ Object.fromEntries(+ Array.from({ length: n }, (_, i) => [`k${i}`, i]),+ ),+ );+ }+ if (r === 3 && rng.bool(0.3)) {+ const total = 1024 * 1024 - rng.int(200);+ const n = rng.int(3) + 1;+ const o: Record<string, string> = {};+ for (let i = 0; i < n; i++)+ o[`k${i}`] = rng+ .pick(["x", "é", "🚀"])+ .repeat(Math.floor(total / n / 2) - rng.int(30));+ return JSON.stringify(o);+ }+ if (r === 4) {+ const k = "k".repeat(rng.pick([4000, 8000, 9000]));+ let v: unknown = 1;+ for (let i = 0; i < rng.pick([100, 120, 127, 128, 129]); i++)+ v = { [k]: v };+ return JSON.stringify(v);+ }+ if (r === 5) {+ return deepJson(rng);+ }+ if (r === 6) {+ return JSON.stringify(+ Array.from({ length: rng.pick([3, 30, 60]) }, (_, i) => ({+ id: i,+ v: [i, String(i)],+ })),+ );+ }+ const o: Record<string, unknown> = {};+ for (let i = 0; i < 48 + rng.int(6); i++) o[`n${i}`] = i;+ for (let i = 0; i < 6; i++)+ o[String(rng.pick([0, 3, 49, 50, 51, 4294967294, 1000]))] = rng.pick([+ null,+ 1,+ "x",+ [1],+ ]);+ return JSON.stringify(o);+}++function randBody(rng: Rng): string | null {+ const r = rng.int(20);+ if (r === 0) return null;+ if (r < 3) return randString(rng, 5);+ if (r < 4) return JSON.stringify(randString(rng, 3));+ if (r < 5 && rng.bool(0.25)) return bigBody(rng);+ let t = JSON.stringify(+ randValue(rng, 0, { nodes: rng.pick([10, 60, 200]) }),+ );+ if (rng.bool(0.4)) t = sprinkleEscapes(rng, t);+ if (rng.bool(0.1)) t = " " + t + "\n";+ return t;+}++function randSelected(rng: Rng): string {+ const v = randValue(rng, 0, { nodes: rng.pick([10, 60, 300]) });+ const obj =+ typeof v === "object" && v !== null && !Array.isArray(v)+ ? v+ : { a: v, arr: [1, [2, { b: null }]], s: "x" };+ let t = JSON.stringify(obj);+ if (rng.bool(0.3)) t = sprinkleEscapes(rng, t);+ const r = rng.int(5);+ if (r === 0) return JSON.stringify(t);+ if (r === 1) return t;+ if (r === 2) return JSON.stringify(JSON.stringify(t));+ if (r === 3 && rng.bool(0.25))+ return rng.bool() ? bigBody(rng) : JSON.stringify(bigBody(rng));+ return JSON.stringify(t.slice(0, rng.int(t.length)));+}++async function sectionNormalize(rng: Rng): Promise<void> {+ const cases = [];+ const settingsVariants = [+ { json_parse_logs: true },+ { pii_scrub_logs: true, json_parse_logs: true },+ { json_parse_logs_attribute_key: "payload" },+ { json_parse_logs: true, json_parse_logs_attribute_key: "payload" },+ {+ json_parse_logs: true,+ pii_scrub_logs: true,+ json_parse_logs_attribute_key: "payload",+ },+ { json_parse_logs: true, json_parse_logs_attribute_key: "a" },+ { json_parse_logs: true, json_parse_logs_attribute_key: "1" },+ { json_parse_logs: true, json_parse_logs_attribute_key: "constructor" },+ { pii_scrub_logs: true },+ ];+ for (let i = 0; i < 4000 * N; i++) {+ const settings = rng.pick(settingsVariants);+ const record = randLogRecord(rng, i, randBody(rng));+ if (record.attributes && rng.bool(0.6)) {+ const key =+ (settings as any).json_parse_logs_attribute_key ?? "payload";+ record.attributes[key] = randSelected(rng);+ }+ if (record.attributes && rng.bool(0.3)) {+ for (const k of [+ "a",+ "payload.a",+ "0",+ "k1",+ "n3",+ "message",+ "msg",+ ]) {+ if (rng.bool(0.3)) record.attributes[k] = '"sender"';+ }+ }+ const input = { settings, record: recordToJson(record as any) };+ const copy: LogRecord = {+ ...record,+ attributes: record.attributes ? { ...record.attributes } : null,+ };+ const pii = await transformDecodedLogRecordsInPlace([copy], settings);+ const { json, gap } = recordToLossyJson(copy as any);+ cases.push({+ input,+ output: {+ record: json,+ pii_replacements: pii.piiReplacements,+ gap,+ },+ });+ }+ write("normalize", cases);+}++const LOGLIKE = [+ "user [email protected] logged in",+ "Bearer\tabc",+ "bearer x.y-z~+/==",+ "BEARER Kabc",+ "Bearer\u000bab",+ "token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig",+ "eyJabcdefghijk.abcd.",+ "sk" + "_live_" + "a".repeat(24),+ "sk" + "_test_" + "Z".repeat(19),+ "gh" + "p_" + "A1".repeat(18),+ "gho_short",+ "xo" + "xp-1234567890",+ "xo" + "xb-12345-",+ "AK" + "IA" + "A1B2C3D4E5F6G7H8",+ "ASIA" + "0".repeat(16) + "X",+ "é@example.com",+ "[email protected]",+ "[email protected]",+ "[email protected]",+ "[email protected]🚀",+ "4111 1111 1111 1111",+ "192.168.001.001",+ "10.0.0.256",+ "::1",+ "3fa85f64-5717-4562-b3fc-2c963f66afa6",+ "abc3fa85f64-5717-4562-b3fc-2c963f66afa6",+ "_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6",+ "user_A1b2",+ "cus_ABCDEFGHIJKLMN",+ "sub_Abcdefghijklmnopqrstuvwx",+ "aes_128",+ "job_12345",+ "0xDEADbeef",+ "deadbeef12",+ "12345678",+ "api.example.com",+ "libssl.so",+ "deploy.sh",+ "host-1.internal",+ "I0827 11:39:40.307946",+ "E1231 23:59:59",+ "W1301 10:00:00",+ "15/Jan/2025:10:00:00 +0000",+ "Wed Jan 15 10:00:00 UTC 2025",+ "Wed, 15 Jan 2025 10:00:00 GMT",+ "Jan 5 10:00:00",+ "Mon Jan 5 10:00:00 2025",+ "2025-01-15T10:00:00.123Z",+ "2025-01-15 10:00:00,123+0100",+ "/api/users/12345/orders/987",+ "ms=12",+ "é12",+ "١٢٣",+ "123",+ "x_1234",+ "İstanbul",+ "ΣΑΣ",+ "straße",+ "fi",+ "\r\n",+ " ",+ "\t",+ '"',+ "\\",+ "{",+ "}",+ "[",+ "]",+ ":",+ ",",+ "🚀",+ "日本",+ "Dž",+];++function logLike(rng: Rng): string {+ let s = "";+ const n = rng.int(10) + 1;+ for (let i = 0; i < n; i++) {+ s += rng.bool(0.7) ? rng.pick(LOGLIKE) : randString(rng, 2);+ s += rng.pick([+ " ",+ "",+ "=",+ ":",+ "/",+ '"',+ ",",+ ".",+ "\n",+ "_",+ "-",+ "@",+ ]);+ }+ return s;+}++function sectionText(rng: Rng): void {+ const pii = [];+ for (let i = 0; i < 8000 * N; i++) {+ let s = logLike(rng);+ if (rng.bool(0.05)) s = s.repeat(1 + rng.int(200));+ pii.push({ input: s, output: scrubPlainStringWithStats(s) });+ }+ write("pii", pii);++ const pattern = [];+ for (let i = 0; i < 8000 * N; i++) {+ let body: string | null;+ const r = rng.int(10);+ if (r < 4) body = logLike(rng);+ else if (r < 6) {+ const o: Record<string, unknown> = {};+ const nk = rng.pick([0, 1, 3, 31, 32, 33, 40]);+ for (let k = 0; k < nk; k++)+ o[rng.bool() ? logLike(rng).slice(0, 20) : randKey(rng)] =+ rng.bool(0.5) ? logLike(rng) : rng.int(10);+ if (rng.bool(0.5))+ o[rng.pick(["message", "msg", "event", "text"])] = rng.pick([+ logLike(rng),+ 5,+ null,+ { a: 1 },+ ]);+ body = JSON.stringify(o);+ if (rng.bool(0.3)) body = sprinkleEscapes(rng, body);+ } else if (r < 7) body = JSON.stringify(logLike(rng));+ else if (r < 8) {+ const unit = rng.pick([+ "🚀",+ "x",+ "é",+ "12 ",+ "[email protected] ",+ '{"message":"',+ ]);+ body = unit.repeat(+ Math.ceil(+ rng.pick([+ 1023, 1024, 1025, 2048, 4096, 8191, 8192, 8193, 9000,+ ]) / unit.length,+ ),+ );+ if (rng.bool()) body = "x" + body;+ if (rng.bool(0.3))+ body = '{"message":' + JSON.stringify(body) + "}";+ if (rng.bool(0.2)) body = '{"a":1}' + " ".repeat(8190);+ } else if (r < 9)+ body = rng.pick([+ "",+ null,+ "12",+ "null",+ "true",+ '"x"',+ "[]",+ "{}",+ " {} ",+ "[1,2]",+ "1e400",+ ]);+ else body = randString(rng, 6);+ const keys = rng.pick([+ [...MESSAGE_KEYS],+ [...MESSAGE_KEYS],+ ["text", "nope"],+ [],+ ["__proto__"],+ ["constructor", "msg"],+ ]);+ pattern.push({+ input: { body, keys },+ output: buildLogPattern(body, keys),+ });+ }+ write("pattern", pattern);++ const attr = [];+ for (let i = 0; i < 6000 * N; i++) {+ const s = rng.bool(0.5)+ ? randAttrValue(rng)+ : sprinkleEscapes(rng, JSON.stringify(randString(rng, 3)));+ attr.push({+ input: s,+ output: {+ decoded: decodeLogAttributeValue(s),+ encoded: encodeLogAttributeValue(s),+ },+ });+ }+ write("attribute_value", attr);+}++const LEAF_KEYS = [+ "service_name",+ "service.name",+ "severity_text",+ "level",+ "severity_level",+ "message",+ "url.path",+ "http.method",+ "count",+ "ms",+ "status_code",+ "name",+ "kind",+ "k8s.pod.name",+ "constructor",+ "toString",+ "__proto__",+ "__defineGetter__",+ "1",+ "a",+ "payload",+ "missing",+];+const OPERATORS = [+ "exact",+ "is_not",+ "is_set",+ "is_not_set",+ "icontains",+ "not_icontains",+ "starts_with",+ "not_starts_with",+ "ends_with",+ "not_ends_with",+ "regex",+ "not_regex",+ "gt",+ "gte",+ "lt",+ "lte",+ "in",+ "not_in",+ "bogus",+ undefined,+];+const REGEXES = [+ "^/api",+ "GET|POST",+ "(?i)error",+ "\\d+",+ "^$",+ ".*",+ "[a-z]+",+ "(?=x)",+ "a{2,}",+ "a{,5}",+ "\\bfoo\\b",+ "\\w+@\\w+",+ "[[:alpha:]]",+ "\\p{L}+",+ "\\pL",+ "\\x{1F680}",+ "\\u0041",+ "🚀",+ "é",+ "(?s).",+ "^\\s*$",+ "\\Qa.b\\E",+ "a**",+ "(a{100}){11}",+ "[^\\x00-\\x7F]",+ "Dž",+ "k",+ "ſ",+ "(?P<n>x)",+ "(?<n>x)",+ "\\0",+ "\\Z",+ "$",+ "^",+ "\\",+ "[",+ "(",+ "TRUE",+ "true",+];+const TYPES = [+ "log_attribute",+ "log",+ "log_resource_attribute",+ "span_attribute",+ "span_resource_attribute",+ "event",+ undefined,+];++function randLeafValue(rng: Rng, op: string | undefined): unknown {+ if (op === "regex" || op === "not_regex")+ return rng.bool(0.9)+ ? rng.pick(REGEXES)+ : rng.pick([null, 5, ["a", "b"], true]);+ const r = rng.int(10);+ if (r < 4)+ return rng.pick(+ STRING_POOL.concat([+ "true",+ "True",+ "false",+ "FALSE",+ "GET",+ "api",+ "ERROR",+ "İ",+ "i̇",+ "ς",+ "σ",+ "ΣΑΣ",+ ]),+ );+ if (r < 6)+ return rng.pick(NUMBER_POOL.concat([NaN, Infinity, 42, 500, 12.5]));+ if (r < 7) return rng.pick([true, false, null]);+ if (r < 9)+ return Array.from({ length: rng.int(4) }, () =>+ rng.pick<unknown>([+ "true",+ true,+ "x",+ 1,+ "api",+ 1e21,+ null,+ ["n"],+ "GET",+ ]),+ );+ return rng.pick<unknown>([+ { toString: 1 },+ ["x", { toString: 1 }],+ {},+ { a: 1 },+ [[1, 2], 3],+ ]);+}++function randLeaf(rng: Rng): Record<string, unknown> {+ const op = rng.pick(OPERATORS);+ const leaf: Record<string, unknown> = {+ key: rng.bool(0.95) ? rng.pick(LEAF_KEYS) : rng.pick([5, null, true]),+ };+ if (op !== undefined) leaf.operator = op;+ if (rng.bool(0.95)) leaf.value = randLeafValue(rng, op);+ const t = rng.pick(TYPES);+ if (t !== undefined) leaf.type = t;+ return leaf;+}++function randGroup(rng: Rng, depth = 0): unknown {+ if (rng.bool(0.03))+ return rng.pick([+ null,+ { type: "XOR", values: [] },+ { type: "AND", values: "x" },+ { type: "AND", values: [null] },+ ]);+ const n = rng.int(depth > 2 ? 3 : 4);+ const values = Array.from({ length: n }, () =>+ rng.bool(depth > 2 ? 0.95 : 0.7)+ ? randLeaf(rng)+ : randGroup(rng, depth + 1),+ );+ const g = { type: rng.pick(["AND", "OR"]), values };+ return rng.bool(0.5) ? { type: "AND", values: [g] } : g;+}++function samplingRow(rng: Rng, i: number): Record<string, unknown> {+ const ruleType = rng.pick([+ "severity_sampling",+ "path_drop",+ "path_drop",+ "rate_limit",+ "mystery",+ ]);+ const config: Record<string, unknown> = {};+ if (ruleType === "severity_sampling" || rng.bool(0.2)) {+ const actions: Record<string, unknown> = {};+ for (const lvl of ["DEBUG", "INFO", "WARN", "ERROR"]) {+ if (rng.bool(0.6)) {+ actions[lvl] = rng.pick<unknown>([+ { type: "drop" },+ { type: "keep" },+ {+ type: "sample",+ rate: rng.pick([0, 0.5, 1, 1.5, -1, 0.25, "0.5"]),+ },+ { type: 5 },+ null,+ ]);+ }+ }+ config.actions = actions;+ }+ if (ruleType === "path_drop" || ruleType === "mystery") {+ config.patterns = rng.bool(0.9)+ ? Array.from({ length: rng.int(3) }, () =>+ rng.bool(0.9) ? rng.pick(REGEXES) : 5,+ )+ : "notarray";+ if (rng.bool(0.5))+ config.match_attribute_key = rng.pick([+ "url.path",+ " http.method ",+ "",+ " ",+ "constructor",+ "toString",+ "level",+ 5,+ ]);+ if (rng.bool(0.5)) config.filter_group = randGroup(rng);+ }+ if (ruleType === "rate_limit") {+ config.logs_per_second = rng.pick([1, 10, 0, 1.5, 2e6]);+ if (rng.bool(0.5)) config.filter_group = randGroup(rng);+ }+ if (rng.bool(0.3)) {+ config.always_keep = {+ status_gte: rng.pick([500, 400, null, "500"]),+ latency_ms_gt: rng.pick([1000, 0, null, -1]),+ attribute_predicates: Array.from({ length: rng.int(3) }, () => ({+ key: rng.pick(ATTR_KEYS),+ op: rng.pick(["exists", "eq", "ne", "bogus"]),+ value: rng.pick([undefined, '"GET"', "GET", 5, '"x"']),+ })),+ };+ }+ return {+ id: `r${i}`,+ rule_type: ruleType,+ scope_service: rng.pick([null, null, "api", "", "API"]),+ scope_path_pattern: rng.pick([+ null,+ null,+ null,+ "^/api",+ "(?=x)",+ "",+ ".*",+ "\\d",+ '"/api',+ ]),+ scope_attribute_filters: [],+ config,+ };+}++function sectionRules(rng: Rng): void {+ const sampling = [];+ for (let i = 0; i < 4000 * N; i++) {+ const rows = JSON.parse(+ JSON.stringify(+ Array.from({ length: rng.int(4) + 1 }, (_, j) =>+ samplingRow(rng, j),+ ),+ ),+ );+ let ruleSet;+ try {+ ruleSet = compileRuleSet(rows as never);+ } catch (e) {+ sampling.push({+ input: { rules: rows, records: [] },+ output: { compile_error: true },+ });+ continue;+ }+ const records = Array.from({ length: 5 }, (_, j) =>+ randLogRecord(rng, j),+ );+ for (const r of records)+ if (!r.trace_id || r.trace_id.length === 0)+ r.trace_id = bytes(rng, 16);+ const outs = records.map((record) => {+ try {+ return evaluateLogRecord(ruleSet, record);+ } catch (e) {+ return { threw: String(e) };+ }+ });+ sampling.push({+ input: {+ rules: rows,+ records: records.map((r) => recordToJson(r as any)),+ },+ output: outs,+ });+ }+ write("sampling", sampling);++ const retention = [];+ for (let i = 0; i < 4000 * N; i++) {+ const rows = JSON.parse(+ JSON.stringify(+ Array.from({ length: rng.int(3) + 1 }, (_, j) => ({+ id: `r${j}`,+ config: rng.bool(0.97)+ ? {+ retention_days: rng.pick<unknown>([+ 90,+ 30,+ 7,+ 0,+ 1,+ 2580,+ 2581,+ 14.5,+ "30",+ -1,+ null,+ 60,+ ]),+ filter_group: randGroup(rng),+ }+ : rng.pick<unknown>([null, {}, "x"]),+ })),+ ),+ );+ let ruleSet;+ try {+ ruleSet = compileRetentionRuleSet(rows as never);+ } catch (e) {+ retention.push({+ input: { rules: rows, records: [] },+ output: { compile_error: true },+ });+ continue;+ }+ const records = Array.from({ length: 5 }, (_, j) =>+ rng.bool(0.2) ? randSpanRecord(rng, j) : randLogRecord(rng, j),+ );+ const outs = records.map((record) => {+ try {+ return evaluateRetentionDays(ruleSet, record as never);+ } catch (e) {+ return { threw: String(e) };+ }+ });+ retention.push({+ input: { rules: rows, records: records.map(recordToJson) },+ output: outs,+ });+ }+ write("retention", retention);+}++const GROUP_KEYS = [+ "service_name",+ "severity_text",+ "event_name",+ "name",+ "status_code",+ "kind",+ "attributes.ms",+ "attributes.http.method",+ "attributes.level",+ "attributes.payload",+ "attributes.1",+ "attributes.constructor",+ "attributes.__proto__",+ "attributes.toString",+ "resource_attributes.k8s.pod.name",+ "resource_attributes.service.name",+ "attributes.",+ "body",+ "",+ "attributes.🚀",+];+const VALUE_KEYS = [+ "attributes.ms",+ "attributes.count",+ "attributes.duration_ms",+ "duration_ms",+ "attributes.payload",+ "resource_attributes.a",+ "attributes.valueOf",+ "ms",+ null,+ null,+];++const NUMERIC_STRINGS = [+ " 12 ",+ "0x10",+ "1e3",+ "Infinity",+ "-Infinity",+ "",+ "12.5abc",+ ".5",+ "5.",+ "-0",+ "1e400",+ "1e-400",+ " 12",+ "3",+ "\u008512",+ "1",+ "+7",+ "++7",+ "1_0",+ "0b1",+ "1e",+ "1e+",+ "00012",+ "9007199254740993",+ "123456789012345678901234567890",+ "0.1",+ "-.5e-2",+ "NaN",+ "e5",+];++function metricAttrs(rng: Rng): Record<string, string> | null {+ const a = randAttrs(rng);+ if (!a) return a;+ for (const k of ["ms", "count", "duration_ms", "payload"]) {+ if (rng.bool(0.5)) {+ a[k] = rng.pick([+ JSON.stringify(rng.pick(NUMERIC_STRINGS)),+ rng.pick(NUMERIC_STRINGS),+ JSON.stringify(+ rng.pick(+ NUMBER_POOL.concat([+ 1e21, -5, 0.1, 12345.678, 7500, 10000, 10001,+ ]),+ ),+ ),+ JSON.stringify([1, 2]),+ ]);+ }+ }+ if (rng.bool(0.2))+ a["http.method"] = JSON.stringify(+ rng.pick([+ "🚀".repeat(129),+ "x".repeat(257),+ "é".repeat(256),+ "a".repeat(255) + "🚀",+ "deny",+ ]),+ );+ return a;+}++function sectionMetrics(rng: Rng): void {+ const cases = [];+ for (let i = 0; i < 2500 * N; i++) {+ let rows = Array.from({ length: rng.int(4) + 1 }, (_, j) => {+ const row: Record<string, unknown> = {+ id: process.env.FUZZ_UNIQUE_IDS+ ? `m${j}`+ : rng.pick([`m${j}`, "m0", "same"]),+ metric_name: rng.pick([+ "count_all",+ "m." + j,+ "",+ "posthog.log.records",+ "x y",+ ]),+ filter_group: rng.bool(0.6) ? null : randGroup(rng),+ value_attribute: rng.pick(VALUE_KEYS),+ group_by: rng.bool(0.95)+ ? Array.from({ length: rng.int(7) }, () =>+ rng.bool(0.95) ? rng.pick(GROUP_KEYS) : 5,+ )+ : "notarray",+ };+ if (rng.bool(0.4))+ row.source = rng.pick(["spans", "logs", "other"]);+ return row;+ });+ rows = JSON.parse(JSON.stringify(rows));+ const defaults = rng.pick([null, null, "logs", "spans"]);+ const spans = rng.bool(0.3);+ const records = Array.from({ length: rng.int(30) + 1 }, (_, j) => {+ const r = spans+ ? randSpanRecord(rng, j)+ : (randLogRecord(rng, j) as unknown as Record<string, unknown>);+ r.attributes = metricAttrs(rng);+ return r;+ });+ let compiled;+ try {+ compiled = compileMetricRules(rows as never);+ } catch (e) {+ cases.push({+ input: { rules: rows, defaults, now_ms: NOW_MS, records: [] },+ output: { compile_error: String(e) },+ });+ continue;+ }+ if (defaults)+ compiled = withDefaultMetricRules(compiled, defaults as never);+ const tallies = createBatchTallies();+ let threw: string | null = null;+ try {+ tallyRecords(+ compiled,+ records as never[],+ tallies,+ NOW_MS,+ (_r, labelKey) => !labelKey.includes("deny"),+ );+ } catch (e) {+ threw = String(e);+ }+ const payload = buildMetricRulesOtlpPayload(compiled, tallies, NOW_MS);+ cases.push({+ input: {+ rules: rows,+ defaults,+ now_ms: NOW_MS,+ records: records.map(recordToJson),+ },+ output: {+ payload_json: payload === null ? null : JSON.stringify(payload),+ value_skipped: tallies.valueSkipped,+ eval_errors: tallies.evalErrors,+ series_overflow: Object.fromEntries(tallies.seriesOverflow),+ threw,+ },+ });+ }+ write("metrics", cases);+}++function sectionInternal(rng: Rng): void {+ const cases = [];+ const policies = {+ hog_flow: { billed: false, teamRules: false },+ billed_src: { billed: true, teamRules: true },+ };+ for (let i = 0; i < 6000 * N; i++) {+ const keys = rng.pick([+ "k1,k0",+ " k1 , k0 ",+ "",+ ",",+ "k1",+ " ",+ "k0,,k1",+ ]);+ const teams = rng.pick([+ "1,2",+ "*",+ " * ",+ "",+ " ",+ "0x1",+ "1.9",+ " 2,abc",+ "1e3",+ "-1",+ "01",+ "+1",+ "1,",+ " 1",+ "1",+ "2 3",+ ]);+ const teamId = rng.pick([1, 2, 3, 1000, -1, 0]);+ const signedAtMs =+ NOW_MS ++ rng.pick([+ -301_000, -300_000, -299_999, -2000, 0, 299_000, 300_999,+ 301_000, -1, 999,+ ]);+ const source = rng.pick([+ "hog_flow",+ "billed_src",+ "constructor",+ "HOG",+ "a.b",+ "",+ "x".repeat(64),+ "x".repeat(65),+ "__proto__",+ ]);+ let signature: string | undefined;+ const r = rng.int(10);+ if (r < 6) {+ try {+ signature = signInternalLogs(+ rng.pick(["k1", "k0", "k2"]),+ source,+ teamId,+ new Date(signedAtMs),+ );+ } catch {+ signature = `v1.${source}.${Math.floor(signedAtMs / 1000)}.00`;+ }+ if (rng.bool(0.2)) signature += rng.pick([".", "x", ".extra", ""]);+ } else if (r < 8) {+ signature = rng.pick([+ undefined,+ "",+ "garbage",+ "v1..",+ "v1.hog_flow.1736944631",+ "v1.hog_flow.0736944631.ab",+ ".hog_flow.1736944631.ab",+ ]);+ } else {+ signature = `v1.hog_flow.${rng.pick(["1736944631", " 1736944631", "1736944631\n", "17369446310", "1.73694463e9", "1736944631"])}.00`;+ }+ const createdAt = rng.pick<string | undefined>([+ new Date(NOW_MS).toISOString(),+ undefined,+ new Date(NOW_MS + rng.int(700_000) - 350_000).toUTCString(),+ String(NOW_MS),+ "2025-01-15T12:37:13.250+00:00",+ "2025-01-15 12:37:13",+ "Jan 15 2025 12:37:13 GMT+0000",+ "2025-01-15T12:37:13.250",+ "garbage",+ "",+ ]);+ const verifier = new InternalLogsVerifier(keys, teams, policies);+ const out = verifier.verify(signature, teamId, createdAt);+ cases.push({+ input: {+ keys,+ teams,+ signature: signature ?? null,+ team_id: teamId,+ created_at: createdAt ?? null,+ },+ output: out ?? null,+ });+ }+ write("internal", cases);+}++function canonical(value: unknown): unknown {+ if (Buffer.isBuffer(value)) return { $bytes: value.toString("hex") };+ if (Array.isArray(value)) return value.map(canonical);+ if (value !== null && typeof value === "object") {+ const out: Record<string, unknown> = {};+ for (const key of Object.keys(value).sort())+ out[key] = canonical((value as any)[key]);+ return out;+ }+ return value;+}++const SCHEMA_DIR = join(+ __dirname,+ "../../../nodejs/src/logs/parity/fixtures/schemas",+);++function avroMap(rng: Rng): Record<string, string> | null {+ if (rng.bool(0.15)) return null;+ const m: Record<string, string> = {};+ for (let i = 0; i < rng.int(10); i++) {+ const k = rng.pick([+ "",+ "0",+ "1",+ "01",+ "4294967295",+ "4294967294",+ "a",+ "b",+ "__proto__",+ "é",+ "🚀",+ "k".repeat(300),+ String(rng.int(100)),+ ]);+ if (k === "__proto__") continue;+ m[k] = rng.bool(0.1)+ ? "v".repeat(rng.pick([0, 1, 127, 128, 70_000]))+ : randAttrValue(rng);+ }+ return m;+}++function avroLogRecord(rng: Rng, i: number): Record<string, unknown> {+ const opt = <T>(v: T): T | null => (rng.bool(0.2) ? null : v);+ return {+ uuid: opt(`u${i}`),+ trace_id: opt(bytes(rng, rng.pick([0, 16]))),+ span_id: opt(bytes(rng, 8)),+ trace_flags: opt(rng.pick([0, 1, -1, 2147483647, -2147483648])),+ timestamp: opt(+ rng.pick([+ 0,+ -1,+ 2 ** 53 - 2,+ -(2 ** 53 - 2),+ 1736944633250000,+ 63,+ ]),+ ),+ observed_timestamp: opt(1736944633250000),+ body: opt(+ rng.bool(0.05)+ ? "b".repeat(rng.pick([65536, 70000]))+ : randString(rng, 5),+ ),+ severity_text: opt(rng.pick(["INFO", ""])),+ severity_number: opt(rng.int(25)),+ service_name: opt("api"),+ resource_attributes: avroMap(rng),+ instrumentation_scope: opt(""),+ event_name: opt("e"),+ attributes: avroMap(rng),+ bytes_uncompressed: opt(rng.pick([0, 123, 2 ** 40])),+ retention_days: opt(rng.pick([30, 0])),+ pattern: opt("<N>"),+ pattern_version: opt(6),+ };+}++function avroSpanRecord(rng: Rng, i: number): Record<string, unknown> {+ const opt = <T>(v: T): T | null => (rng.bool(0.2) ? null : v);+ return {+ uuid: opt(`s${i}`),+ trace_id: opt(bytes(rng, 16)),+ span_id: opt(bytes(rng, 8)),+ parent_span_id: opt(bytes(rng, rng.pick([0, 8]))),+ trace_state: opt(rng.pick(["", "a=b"])),+ name: opt(randString(rng, 2)),+ kind: opt(rng.int(6)),+ flags: opt(1),+ timestamp: opt(1736944633250000),+ end_time: opt(1736944633250001),+ observed_timestamp: opt(1736944633250000),+ service_name: opt("api"),+ resource_attributes: avroMap(rng),+ instrumentation_scope: opt("s"),+ attributes: avroMap(rng),+ dropped_attributes_count: opt(0),+ events: opt(+ Array.from({ length: rng.pick([0, 1, 3, 200]) }, () =>+ randString(rng, 2),+ ),+ ),+ dropped_events_count: opt(rng.int(3)),+ links: opt(+ Array.from({ length: rng.pick([0, 1, 2]) }, () =>+ JSON.stringify({ trace_id: "x" }),+ ),+ ),+ dropped_links_count: opt(0),+ status_code: opt(rng.int(3)),+ status_message: opt(rng.pick(["", "err"])),+ bytes_uncompressed: opt(77),+ retention_days: opt(14),+ };+}++let lastUncaught: string | null = null;+process.on("uncaughtException", (e) => {+ lastUncaught = (e as Error).message;+});++async function decodeOutcome(buf: Buffer): Promise<unknown> {+ try {+ lastUncaught = null;+ const timeout = new Promise<never>((_, reject) =>+ setTimeout(+ () => reject(new Error(`HANG uncaught=${lastUncaught}`)),+ 200,+ ),+ );+ const [, codec, records] = await Promise.race([+ decodeLogRecords(buf),+ timeout,+ ]);+ return {+ codec,+ count: records.length,+ sha256: createHash("sha256")+ .update(JSON.stringify(records.map(canonical)))+ .digest("hex"),+ };+ } catch (e) {+ return { error: (e as Error).message };+ }+}++async function sectionAvro(rng: Rng): Promise<void> {+ const schemas = {+ logs: JSON.parse(+ readFileSync(join(SCHEMA_DIR, "logs.avsc.json"), "utf8"),+ ),+ traces: JSON.parse(+ readFileSync(join(SCHEMA_DIR, "traces.avsc.json"), "utf8"),+ ),+ };+ const types = {+ logs: avro.Type.forSchema(schemas.logs),+ traces: avro.Type.forSchema(schemas.traces),+ };+ const cases: unknown[] = [];+ for (const b64 of REGRESSIONS.avro) {+ const output = await decodeOutcome(Buffer.from(b64, "base64"));+ cases.push({+ input: {+ b64,+ label: "regression",+ which: "logs",+ schema_intact: true,+ },+ output,+ regression: true,+ });+ }+ for (let i = 0; i < 1500 * N; i++) {+ const which = rng.bool(0.6) ? "logs" : "traces";+ const n = rng.pick([0, 1, 2, 5, 20, 100]);+ const records = Array.from({ length: n }, (_, j) =>+ which === "logs" ? avroLogRecord(rng, j) : avroSpanRecord(rng, j),+ );+ let buf: Buffer;+ try {+ buf = await encodeLogRecords(+ types[which],+ "zstandard",+ records as never,+ );+ } catch {+ continue;+ }+ const mutation = rng.int(10);+ let label = "clean";+ if (mutation >= 6 && buf.length > 0) {+ const b = Buffer.from(buf);+ const m = rng.int(5);+ if (m === 0) {+ label = "truncate";+ buf = b.subarray(0, rng.int(b.length));+ } else if (m === 1) {+ label = "flip";+ for (let k = 0; k < 1 + rng.int(3); k++)+ b[rng.int(b.length)] ^= 1 << rng.int(8);+ buf = b;+ } else if (m === 2) {+ label = "append";+ buf = Buffer.concat([b, bytes(rng, rng.int(40))]);+ } else if (m === 3) {+ label = "flip-tail";+ const p = b.length - 1 - rng.int(Math.min(b.length, 60));+ b[p] ^= 1 << rng.int(8);+ buf = b;+ } else {+ label = "header-flip";+ const p = rng.int(Math.min(b.length, 40));+ b[p] ^= 1 << rng.int(8);+ buf = b;+ }+ }+ const outcome = await decodeOutcome(buf);+ // A changed writer schema hits avsc's schema validation, which the port does not reproduce.+ const schemaIntact = buf.includes(+ Buffer.from(+ JSON.stringify(types[which].schema({ exportAttrs: true })),+ ),+ );+ cases.push({+ input: {+ b64: buf.toString("base64"),+ label,+ which,+ schema_intact: schemaIntact,+ },+ output: outcome,+ });+ }+ write("avro", cases, BUDGET * 3);+}++async function main(): Promise<void> {+ const sections = process.argv.slice(2);+ const want = (s: string): boolean =>+ sections.length === 0 || sections.includes(s);+ const seed = Number(process.env.FUZZ_SEED ?? "1");+ if (want("json")) sectionJson(new Rng(seed * 101));+ if (want("date")) sectionDate(new Rng(seed * 103));+ if (want("normalize")) await sectionNormalize(new Rng(seed * 107));+ if (want("text")) sectionText(new Rng(seed * 109));+ if (want("rules")) sectionRules(new Rng(seed * 113));+ if (want("metrics")) sectionMetrics(new Rng(seed * 127));+ if (want("internal")) sectionInternal(new Rng(seed * 131));+ if (want("avro")) await sectionAvro(new Rng(seed * 137));+ process.exit(0);+}++void main();diff --git a/rust/logs-ingestion/scripts/node-decode-reference.js b/rust/logs-ingestion/scripts/node-decode-reference.jsnew file mode 100644index 000000000000..dd30752bcc6c--- /dev/null+++ b/rust/logs-ingestion/scripts/node-decode-reference.js@@ -0,0 +1,166 @@+// Run from the repository root: NODE_PATH=nodejs/node_modules node rust/logs-ingestion/scripts/node-decode-reference.js+const avro = require('avsc')+const { compress, decompress } = require('@mongodb-js/zstd')+const { Readable } = require('stream')+const { createHash } = require('crypto')+const fs = require('fs')+const path = require('path')++const root = path.resolve(__dirname, '../../..')+const scenarioDir = path.join(root, 'nodejs/src/logs/parity/fixtures/scenarios')+const outFile = path.join(__dirname, '../tests/fixtures/input-decodes.json')++// Same codec registration as `decodeLogRecords` in nodejs/src/logs/log-record-avro.ts.+function decode(buffer) {+ return new Promise((resolve, reject) => {+ const records = []+ const decoder = new avro.streams.BlockDecoder({+ codecs: { zstandard: (buf, cb) => decompress(buf).then((inflated) => cb(null, inflated)).catch(cb) },+ })+ const stream = new Readable()+ stream.on('error', reject)+ stream.push(buffer)+ stream.push(null)+ stream.pipe(decoder)+ let type+ let codec = 'null'+ decoder.on('metadata', (t, c) => {+ type = t+ codec = c || 'null'+ })+ decoder.on('data', (r) => records.push(r))+ decoder.on('end', () => (type === undefined ? reject(new Error('No metadata found')) : resolve([codec, records])))+ decoder.on('error', reject)+ })+}++// Keys sorted by UTF-16 code units (the default JS sort), bytes as { $bytes: hex }.+function canonical(value) {+ if (Buffer.isBuffer(value)) {+ return { $bytes: value.toString('hex') }+ }+ if (Array.isArray(value)) {+ return value.map(canonical)+ }+ if (value !== null && typeof value === 'object') {+ const out = {}+ for (const key of Object.keys(value).sort()) {+ out[key] = canonical(value[key])+ }+ return out+ }+ return value+}++function zigzag(n) {+ const bytes = []+ let z = n >= 0 ? n * 2 : -n * 2 - 1+ while (z >= 0x80) {+ bytes.push((z % 0x80) | 0x80)+ z = Math.floor(z / 0x80)+ }+ bytes.push(z)+ return Buffer.from(bytes)+}++async function container(schema, blocks, { sync = Buffer.alloc(16, 7), badSyncAt = -1, rawData = false } = {}) {+ const schemaText = Buffer.from(JSON.stringify(schema))+ const header = Buffer.concat([+ Buffer.from('Obj\x01', 'latin1'),+ zigzag(2),+ zigzag(11), Buffer.from('avro.schema'), zigzag(schemaText.length), schemaText,+ zigzag(10), Buffer.from('avro.codec'), zigzag(9), Buffer.from('zstandard'),+ Buffer.from([0]),+ sync,+ ])+ const parts = [header]+ for (let i = 0; i < blocks.length; i++) {+ const [count, data] = blocks[i]+ const body = rawData ? data : await compress(data, 1)+ parts.push(zigzag(count), zigzag(body.length), body, i === badSyncAt ? Buffer.alloc(16, 9) : sync)+ }+ return Buffer.concat(parts)+}++async function edgeContainers() {+ const schema = {+ type: 'record',+ name: 'Edge',+ fields: [+ { name: 's', type: ['null', 'string'] },+ { name: 'l', type: ['null', 'long'] },+ { name: 'm', type: ['null', { type: 'map', values: 'string' }] },+ { name: 'a', type: { type: 'array', items: 'int' } },+ { name: 'b', type: 'boolean' },+ { name: 'd', type: 'double' },+ { name: 'f', type: 'float' },+ { name: 'e', type: { type: 'enum', name: 'E', symbols: ['A', 'B'] } },+ { name: 'x', type: { type: 'fixed', name: 'X', size: 2 } },+ ],+ }+ const type = avro.Type.forSchema(schema)+ const good = (i) =>+ type.toBuffer({ s: `row ${i}`, l: 1736942400000000 + i, m: { k: 'v', 1: 'one' }, a: [1, -2, 3], b: true, d: 0.1, f: 1.5, e: 'B', x: Buffer.from([1, 2]) })+ const goodBlock = Buffer.concat([good(0), good(1)])+ const edges = []+ edges.push(['valid', await container(schema, [[2, goodBlock], [1, good(2)]])])+ const valid = edges[0][1]+ edges.push(['truncated-last-block', valid.subarray(0, valid.length - 5)])+ edges.push(['truncated-in-header', valid.subarray(0, 30)])+ edges.push(['three-bytes', Buffer.from('Obj')])+ edges.push(['bad-sync-second-block', await container(schema, [[2, goodBlock], [1, good(2)]], { badSyncAt: 1 })])+ edges.push(['bad-zstd', await container(schema, [[1, Buffer.from('not zstd at all')]], { rawData: true })])+ edges.push(['count-past-data', await container(schema, [[3, goodBlock]])])+ edges.push(['count-below-data', await container(schema, [[1, goodBlock]])])+ edges.push(['zero-count-block', await container(schema, [[0, goodBlock], [1, good(3)]])])+ edges.push(['bad-union-index', await container(schema, [[1, Buffer.concat([zigzag(5), good(0)])]])])+ edges.push(['unsafe-long', await container(schema, [[1, Buffer.concat([zigzag(0), zigzag(1), zigzag(2 ** 60), good(0).subarray(12)])]])])+ edges.push(['bad-enum-index', await container({ type: 'record', name: 'R', fields: [{ name: 'e', type: { type: 'enum', name: 'E', symbols: ['A'] } }] }, [[1, zigzag(3)]])])+ edges.push(['invalid-utf8', await container({ type: 'record', name: 'U', fields: [{ name: 's', type: 'string' }] }, [[1, Buffer.concat([zigzag(6), Buffer.from([0x61, 0xff, 0xe2, 0x82, 0x62, 0xed])])]])])+ edges.push(['map-proto-and-dups', await container({ type: 'record', name: 'M', fields: [{ name: 'm', type: { type: 'map', values: 'string' } }] }, [[1, Buffer.concat([zigzag(-3), zigzag(99), ...[['__proto__', 'p'], ['dup', '1'], ['dup', '2']].flatMap(([k, v]) => [zigzag(k.length), Buffer.from(k), zigzag(v.length), Buffer.from(v)]), zigzag(1), zigzag(2), Buffer.from('10'), zigzag(1), Buffer.from('t'), zigzag(0)])]])])+ edges.push(['trailing-garbage', Buffer.concat([valid, Buffer.from([1, 2, 3])])])+ return edges+}++;(async () => {+ const out = {}+ for (const file of fs.readdirSync(scenarioDir).filter((f) => f.endsWith('.json')).sort()) {+ const fixture = JSON.parse(fs.readFileSync(path.join(scenarioDir, file), 'utf8'))+ out[file] = []+ for (const batch of fixture.scenario.batches) {+ for (const message of batch) {+ if (message.value_b64 === null) {+ out[file].push(null)+ continue+ }+ try {+ const [codec, records] = await decode(Buffer.from(message.value_b64, 'base64'))+ const text = JSON.stringify(records.map(canonical))+ out[file].push({+ codec,+ count: records.length,+ sha256: createHash('sha256').update(text).digest('hex'),+ })+ } catch (e) {+ out[file].push({ error: e.message })+ }+ }+ }+ }+ out['edges'] = []+ for (const [name, buffer] of await edgeContainers()) {+ let result+ try {+ const [codec, records] = await decode(buffer)+ result = {+ codec,+ count: records.length,+ sha256: createHash('sha256').update(JSON.stringify(records.map(canonical))).digest('hex'),+ }+ } catch (e) {+ result = { error: e.message }+ }+ out['edges'].push({ name, value_b64: buffer.toString('base64'), result })+ }+ fs.writeFileSync(outFile, JSON.stringify(out, null, 1) + '\n')+})()diff --git a/rust/logs-ingestion/scripts/node-metric-rules-reference.ts b/rust/logs-ingestion/scripts/node-metric-rules-reference.tsnew file mode 100644index 000000000000..0a9f4896af3d--- /dev/null+++ b/rust/logs-ingestion/scripts/node-metric-rules-reference.ts@@ -0,0 +1,259 @@+// Run from the repository root: cd nodejs && npx tsx --tsconfig tsconfig.json ../rust/logs-ingestion/scripts/node-metric-rules-reference.ts+import { createHmac } from 'crypto'+import { writeFileSync } from 'fs'+import { join } from 'path'++import { type MetricRuleRow, compileMetricRules } from '../../../nodejs/src/logs/metrics-rules/compile-metric-rules'+import { withDefaultMetricRules } from '../../../nodejs/src/logs/metrics-rules/default-metric-rules'+import { buildMetricRulesOtlpPayload } from '../../../nodejs/src/logs/metrics-rules/otlp-payload'+import {+ MetricSeriesAdmission,+ createBatchTallies,+ idToHex,+ tallyRecords,+} from '../../../nodejs/src/logs/metrics-rules/tally'++const NOW_MS = Date.UTC(2025, 0, 15, 12, 37, 13, 250)+const HOUR_MS = 60 * 60 * 1000++const rules = compileMetricRules([+ { id: 'r', metric_name: 'm', filter_group: null, value_attribute: null, group_by: ['attributes.v'] },+])+const rocket = '🚀'+const labelValues: string[] = [+ 'x'.repeat(256),+ 'x'.repeat(257),+ 'x'.repeat(255) + rocket,+ 'x'.repeat(254) + rocket,+ 'x'.repeat(254) + rocket + 'y',+ rocket.repeat(128),+ rocket.repeat(129),+ 'a' + rocket.repeat(200),+ 'é'.repeat(300),+ '日本'.repeat(200),+ '\ud83d'.repeat(300),+ 'x'.repeat(255) + '\udc00z',+]+const labelInputs: string[] = [...labelValues.map((v) => JSON.stringify(v)), 'raw-' + rocket.repeat(200)]+const labels = labelInputs.map((attribute) => {+ const tallies = createBatchTallies()+ const record = { timestamp: null, trace_id: null, span_id: null, attributes: { v: attribute } }+ tallyRecords(rules, [record as never], tallies, NOW_MS)+ const [[labelKey, entry]] = [...tallies.byRule.get('r')!.entries()]+ return { attribute, length: entry.labelValues[0].length, label_key: labelKey }+})++const b64 = (bytes: number[]): string => Buffer.from(bytes).toString('base64')+const trace = Array.from({ length: 16 }, (_, i) => i * 17 + 1)+const span = Array.from({ length: 8 }, (_, i) => 255 - i)+const ascii = (s: string): Buffer => Buffer.from(s, 'latin1')+const idInputs: [Buffer, number][] = [+ [Buffer.from(trace), 16],+ [Buffer.from(span), 8],+ [Buffer.alloc(16), 16],+ [Buffer.alloc(0), 16],+ [ascii(b64(trace)), 16],+ [ascii(b64(trace).replace(/=+$/, '')), 16],+ [ascii(b64(span)), 8],+ [ascii(b64(span).replace(/\+/g, '-').replace(/\//g, '_')), 8],+ [ascii(' ' + b64(trace).slice(0, 10) + '\n*' + b64(trace).slice(10)), 16],+ [ascii(b64(trace).slice(0, 8) + '=' + b64(trace).slice(8)), 16],+ [ascii(b64(Array(16).fill(0))), 16],+ [ascii(b64(trace) + 'AAAA'), 16],+ [Buffer.from(b64(trace), 'latin1').map((b) => b | 0x80), 16],+ [ascii(b64(Array.from({ length: 15 }, (_, i) => i + 1))), 16],+ [ascii('not base64 at all!!'), 16],+ [Buffer.from(trace.slice(0, 15)), 16],+]+const id_to_hex = idInputs.map(([buffer, expectedBytes]) => ({+ input_hex: buffer.toString('hex'),+ expected_bytes: expectedBytes,+ output: idToHex(buffer.length ? buffer : null, expectedBytes),+}))++// hashLabelKey keeps its key private, so this repeats its one line with a fixed key.+const hmacKey = Buffer.from(Array.from({ length: 32 }, (_, i) => (i * 37 + 11) & 0xff))+const label_hashes = ['[]', '[""]', '["api","ERROR"]', JSON.stringify(['\ud83d' + 'x']), JSON.stringify([rocket.repeat(3)])].map(+ (labelKey) => ({+ label_key: labelKey,+ hash: createHmac('sha256', hmacKey).update(labelKey).digest().readUIntBE(0, 6),+ })+)++type Call = [number, string, string, number]+const scenario = (name: string, caps: [number, number, number], calls: Call[]) => {+ const admission = new MetricSeriesAdmission(...caps)+ return { name, caps, calls, results: calls.map((c) => admission.admit(...c)) }+}+const t0 = Math.floor(NOW_MS / HOUR_MS) * HOUR_MS+const admission = [+ scenario('per rule cap', [2, 10, 100], [+ [1, 'r', '["a"]', NOW_MS],+ [1, 'r', '["b"]', NOW_MS],+ [1, 'r', '["c"]', NOW_MS],+ [1, 'r', '["a"]', NOW_MS],+ [1, 'r2', '["c"]', NOW_MS],+ [2, 'r', '["c"]', NOW_MS],+ ]),+ scenario('per team cap survives other rules', [10, 3, 100], [+ [1, 'r1', '["a"]', NOW_MS],+ [1, 'r2', '["a"]', NOW_MS],+ [1, 'r3', '["a"]', NOW_MS],+ [1, 'r4', '["a"]', NOW_MS],+ [1, 'r1', '["a"]', NOW_MS],+ [2, 'r1', '["a"]', NOW_MS],+ ]),+ scenario('total cap', [10, 10, 2], [+ [1, 'r', '["a"]', NOW_MS],+ [2, 'r', '["a"]', NOW_MS],+ [3, 'r', '["a"]', NOW_MS],+ [1, 'r', '["a"]', NOW_MS],+ ]),+ scenario('window rollover', [1, 1, 1], [+ [1, 'r', '["a"]', t0 + HOUR_MS - 1],+ [1, 'r', '["b"]', t0 + HOUR_MS - 1],+ [1, 'r', '["b"]', t0 + HOUR_MS],+ [1, 'r', '["a"]', t0 + HOUR_MS + 1],+ [1, 'r', '["a"]', t0 + 1.5],+ [1, 'r', '["a"]', t0 + 2],+ [1, 'r', '["b"]', t0 + 2 * HOUR_MS + 0.25],+ ]),+ scenario('team and rule ids share a key space', [1, 10, 100], [+ [1, '2:r', '["a"]', NOW_MS],+ [12, 'r', '["a"]', NOW_MS],+ [1, '2:r', '["b"]', NOW_MS],+ ]),+]++// The module vectors cover none of these, because their value attributes never resolve.+const spanRecord = (i: number, extra: Record<string, unknown>): Record<string, unknown> => ({+ uuid: `s${i}`,+ trace_id: i % 3 === 0 ? null : Buffer.from(Array.from({ length: 16 }, (_, j) => (i * 31 + j) & 0xff)),+ span_id: i % 2 === 0 ? null : Buffer.from(Array.from({ length: 8 }, (_, j) => (i + j) & 0xff)),+ timestamp: (NOW_MS - 1000 * i) * 1000,+ end_time: (NOW_MS - 1000 * i) * 1000 + [1500, 0, 7_250_125, 250, 12_000_000_001][i % 5],+ name: ['GET /a', 'db.query', 'x'.repeat(300), ''][i % 4],+ kind: [1, 2, 3, 9, null][i % 5],+ status_code: [0, 1, 2, 7, null][i % 5],+ service_name: ['api', 'worker', null][i % 3],+ resource_attributes: { 'k8s.pod.name': JSON.stringify(`pod-${i % 2}`) },+ attributes: { ms: JSON.stringify([12.5, ' 3e2ms', 'x', -4, 'Infinity', 0.1, '1e400'][i % 7]), 'http.method': '"GET"' },+ ...extra,+})+const logRecord = (i: number, extra: Record<string, unknown>): Record<string, unknown> => ({+ uuid: `l${i}`,+ trace_id: [null, Buffer.from(b64(trace), 'latin1'), Buffer.alloc(16)][i % 3],+ span_id: Buffer.from(span),+ timestamp: [null, (NOW_MS - 60_000) * 1000, (NOW_MS - 21 * 60_000) * 1000][i % 3],+ service_name: ['api', 'web'][i % 2],+ severity_text: ['INFO', 'ERROR', null][i % 3],+ event_name: null,+ attributes: { ms: JSON.stringify(i * 997.5), user: JSON.stringify(i % 4 === 0 ? 'deny' : `u${i % 5}`) },+ resource_attributes: null,+ ...extra,+})+const recordJson = (record: Record<string, unknown>): unknown =>+ Object.fromEntries(+ Object.entries(record).map(([k, v]) => [k, Buffer.isBuffer(v) ? { $bytes: v.toString('hex') } : v])+ )+type PayloadCase = { rows: MetricRuleRow[]; defaults: 'logs' | 'spans' | null; records: Record<string, unknown>[] }+const payloadCases: PayloadCase[] = [+ {+ rows: [+ { id: 'd', metric_name: 'span.ms', source: 'spans', filter_group: null, value_attribute: 'duration_ms', group_by: ['service_name', 'kind', 'name', 'status_code'] },+ { id: 'h', metric_name: 'span.attr', source: 'spans', filter_group: null, value_attribute: 'attributes.ms', group_by: ['resource_attributes.k8s.pod.name', 'attributes.http.method'] },+ { id: 'c', metric_name: 'span.count', source: 'spans', filter_group: null, value_attribute: null, group_by: [] },+ ],+ defaults: null,+ records: Array.from({ length: 20 }, (_, i) => spanRecord(i, {})),+ },+ {+ rows: [+ { id: 'u', metric_name: 'by.user', filter_group: null, value_attribute: null, group_by: ['service_name', 'attributes.user', 'severity_text'] },+ { id: 'v', metric_name: 'posthog.log.records', filter_group: null, value_attribute: 'attributes.ms', group_by: ['attributes.user'] },+ { id: 'u', metric_name: 'same.id', filter_group: null, value_attribute: null, group_by: ['event_name'] },+ ],+ defaults: 'logs',+ records: Array.from({ length: 24 }, (_, i) => logRecord(i, {})),+ },+ {+ rows: [{ id: 'n', metric_name: 'none', filter_group: null, value_attribute: 'attributes.missing', group_by: [] }],+ defaults: null,+ records: Array.from({ length: 3 }, (_, i) => logRecord(i, {})),+ },+ {+ // Attribute maps are plain objects, so these keys read Object.prototype members.+ rows: [+ { id: 'p', metric_name: 'proto', filter_group: null, value_attribute: 'attributes.valueOf', group_by: [] },+ { id: 'q', metric_name: 'proto.labels', filter_group: null, value_attribute: null, group_by: ['attributes.constructor', 'attributes.__proto__', 'attributes.toString', 'resource_attributes.__proto__'] },+ ],+ defaults: null,+ records: Array.from({ length: 4 }, (_, i) => logRecord(i, { resource_attributes: i % 2 ? { a: '"b"' } : null })),+ },+ {+ // `__defineGetter__.length` is 2, so decodeLogAttributeValue calls a missing startsWith and throws.+ rows: [+ { id: 'ok', metric_name: 'ok', filter_group: null, value_attribute: null, group_by: [] },+ { id: 't', metric_name: 'throws', filter_group: null, value_attribute: null, group_by: ['attributes.__defineGetter__'] },+ ],+ defaults: null,+ records: Array.from({ length: 3 }, (_, i) => logRecord(i * 3 + 1, {})),+ },+ {+ rows: [],+ defaults: 'spans',+ records: Array.from({ length: 10 }, (_, i) => spanRecord(i, {})),+ },+]+const payloads = payloadCases.map(({ rows, defaults, records }) => {+ let compiled = compileMetricRules(rows)+ if (defaults) {+ compiled = withDefaultMetricRules(compiled, defaults)+ }+ const tallies = createBatchTallies()+ let threw: string | null = null+ try {+ tallyRecords(compiled, records as never[], tallies, NOW_MS, (_ruleId, labelKey) => !labelKey.includes('deny'))+ } catch (error) {+ threw = String(error)+ }+ const payload = buildMetricRulesOtlpPayload(compiled, tallies, NOW_MS)+ return {+ rows,+ defaults,+ now_ms: NOW_MS,+ records: records.map(recordJson),+ payload_json: payload === null ? null : JSON.stringify(payload),+ value_skipped: tallies.valueSkipped,+ eval_errors: tallies.evalErrors,+ series_overflow: Object.fromEntries(tallies.seriesOverflow),+ threw,+ }+})++const compileRows = [+ { id: 'a', metric_name: '', filter_group: null, value_attribute: null, group_by: [] },+ { id: 'b', metric_name: 5, filter_group: null, value_attribute: null, group_by: [] },+ { id: 'c', filter_group: null, value_attribute: null, group_by: [] },+ { id: 'd', metric_name: 'd', source: 'SPANS', value_attribute: '', group_by: ['severity_text', 1, '', null, 'event_name'] },+ { id: 'e', metric_name: 'e', source: 'spans', value_attribute: 'duration_ms', group_by: ['kind', 'name', 'status_code', 'service_name', 'attributes.a', 'attributes.b'] },+ { id: 'f', metric_name: 'f', source: 'spans', value_attribute: 7, group_by: ['severity_text'] },+ { id: 'g', metric_name: 'g', value_attribute: 'x', group_by: ['name'] },+ { id: 'h', metric_name: 'h', value_attribute: 'duration_ms', group_by: [] },+ { id: 'i', metric_name: 'i', value_attribute: 'attributes.\ud800', group_by: ['resource_attributes.\udc00', 'attributes.'] },+ { id: 'j', metric_name: 'j', filter_group: undefined, value_attribute: null, group_by: 'service_name' },+ { id: 'k', metric_name: 'k', source: 'spans', value_attribute: null, group_by: ['event_name'] },+]+const compile = compileMetricRules(compileRows as unknown as MetricRuleRow[]).map((r) => ({+ id: r.id,+ metric_name: r.metricName,+ source: r.source,+ value_attribute: r.valueAttribute,+ group_by: r.groupBy,+}))++const out = { compile_rows: compileRows, compile, hmac_key_hex: hmacKey.toString('hex'), labels, id_to_hex, label_hashes, admission, payloads }+writeFileSync(+ join(__dirname, '..', 'tests', 'fixtures', 'metric-rules-reference.json'),+ JSON.stringify(out, null, 1) + '\n'+)diff --git a/rust/logs-ingestion/scripts/node-rate-limiter-reference.ts b/rust/logs-ingestion/scripts/node-rate-limiter-reference.tsnew file mode 100644index 000000000000..f1e4d3dd5706--- /dev/null+++ b/rust/logs-ingestion/scripts/node-rate-limiter-reference.ts@@ -0,0 +1,377 @@+// Needs Redis at 127.0.0.1:6379. Run: cd nodejs && NODE_ENV=test npx tsx --tsconfig tsconfig.json ../rust/logs-ingestion/scripts/node-rate-limiter-reference.ts+import { writeFileSync } from 'fs'+import { join } from 'path'++import { createRedisV2PoolFromConfig } from '../../../nodejs/src/common/redis/redis-v2'+import { KeyedRateLimiterService } from '../../../nodejs/src/common/services/keyed-rate-limiter.service'+import { type LogRecord } from '../../../nodejs/src/logs/log-record-avro'+import { runPipelineStages } from '../../../nodejs/src/logs/pipeline/log-processing-pipeline'+import { compileRuleSet } from '../../../nodejs/src/logs/sampling/compile-rules'+import { LogsSamplingService } from '../../../nodejs/src/logs/sampling/logs-sampling.service'+import { LogsRateLimiterService } from '../../../nodejs/src/logs/services/logs-rate-limiter.service'++if (process.env.NODE_ENV !== 'test') {+ throw new Error('Run with NODE_ENV=test so keys use the @posthog-test root')+}++// Every limiter name starts with this, so the run never touches another test's keys.+const PREFIX = 'logs-parity-rl'+// The sampling limiter name is fixed, so its keys are kept apart by a team id no test uses.+const SAMPLING_TEAM = 987654321+const KEY_PATTERNS = [`@posthog-test/${PREFIX}*`, `@posthog-test/logs-sampling-rate/tokens/${SAMPLING_TEAM}/*`]+const T0 = Date.UTC(2025, 0, 15, 12, 0, 0, 0)++let nowMs = T0+Date.now = () => nowMs++const keyedLimiters = {+ v3: { name: `${PREFIX}-keyed-v3`, scriptVersion: 'v3' as const, ttlSeconds: 600 },+ v2: { name: `${PREFIX}-keyed-v2`, scriptVersion: 'v2' as const, ttlSeconds: 600 },+ grouped: { name: `${PREFIX}-grouped`, scriptVersion: 'v3' as const, ttlSeconds: 600 },+}++const logsLimiterConfigs = {+ all: {+ name: `${PREFIX}-logs-all`,+ config: {+ LOGS_LIMITER_ENABLED_TEAMS: '*',+ LOGS_LIMITER_DISABLED_FOR_TEAMS: '3, x',+ LOGS_LIMITER_BUCKET_SIZE_KB: 10,+ LOGS_LIMITER_REFILL_RATE_KB_PER_SECOND: 2,+ LOGS_LIMITER_TTL_SECONDS: 600,+ LOGS_LIMITER_TEAM_BUCKET_SIZE_KB: '2:25, 4 : 3, bad:1',+ LOGS_LIMITER_TEAM_REFILL_RATE_KB_PER_SECOND: '2:5',+ },+ },+ listed: {+ name: `${PREFIX}-logs-listed`,+ config: {+ LOGS_LIMITER_ENABLED_TEAMS: '1,2',+ LOGS_LIMITER_DISABLED_FOR_TEAMS: '',+ LOGS_LIMITER_BUCKET_SIZE_KB: 4,+ LOGS_LIMITER_REFILL_RATE_KB_PER_SECOND: 1,+ LOGS_LIMITER_TTL_SECONDS: 600,+ LOGS_LIMITER_TEAM_BUCKET_SIZE_KB: '',+ LOGS_LIMITER_TEAM_REFILL_RATE_KB_PER_SECOND: '',+ },+ },+}++type Req = { id: string; cost: number; bucketSize?: number; refillRate?: number; ttlSeconds?: number; now?: number }+type Msg = { teamId: number; bytesUncompressed: number; createdAt: string | null }++const sec = (s: number): number => T0 / 1000 + s+const iso = (s: number): string => new Date(T0 + s * 1000).toISOString()++const keyedSteps: { limiter: keyof typeof keyedLimiters; method: 'many' | 'grouped'; nowMs: number; requests: Req[] }[] =+ [+ {+ limiter: 'v3',+ method: 'many',+ nowMs: T0,+ requests: [+ { id: 'a', cost: 3, bucketSize: 10, refillRate: 1, now: sec(0) },+ { id: 'b', cost: 15, bucketSize: 10, refillRate: 1, now: sec(0) },+ { id: 'c', cost: 2.5, bucketSize: 7.5, refillRate: 0.5, now: sec(0) },+ ],+ },+ {+ limiter: 'v3',+ method: 'many',+ nowMs: T0,+ requests: [+ { id: 'a', cost: 8, bucketSize: 10, refillRate: 1, now: sec(1) },+ { id: 'b', cost: 10, bucketSize: 10, refillRate: 1, now: sec(1) },+ { id: 'c', cost: 1, bucketSize: 7.5, refillRate: 0.5, now: sec(3) },+ ],+ },+ {+ limiter: 'v3',+ method: 'many',+ nowMs: T0,+ requests: [+ { id: 'a', cost: 1, bucketSize: 10, refillRate: 1, now: sec(-5) },+ { id: 'a', cost: 1, bucketSize: 10, refillRate: 1, now: sec(100) },+ { id: 'c', cost: 0.25, bucketSize: 7.5, refillRate: 0.5, now: sec(4) },+ ],+ },+ {+ limiter: 'v3',+ method: 'many',+ nowMs: T0 + 200_500,+ requests: [+ { id: 'a', cost: 50, bucketSize: 10, refillRate: 1 },+ { id: 'd', cost: 1e-7, bucketSize: 1e21, refillRate: 3 },+ ],+ },+ {+ limiter: 'v2',+ method: 'many',+ nowMs: T0,+ requests: [+ { id: 'a', cost: 3, bucketSize: 10, refillRate: 1, now: sec(0) },+ { id: 'b', cost: 15, bucketSize: 10, refillRate: 1, now: sec(0) },+ { id: 'c', cost: 2.5, bucketSize: 7.5, refillRate: 0.5, now: sec(0) },+ ],+ },+ {+ limiter: 'v2',+ method: 'many',+ nowMs: T0,+ requests: [+ { id: 'a', cost: 8, bucketSize: 10, refillRate: 1, now: sec(1) },+ { id: 'b', cost: 10, bucketSize: 10, refillRate: 1, now: sec(1) },+ { id: 'c', cost: 6, bucketSize: 7.5, refillRate: 0.5, now: sec(3) },+ { id: 'a', cost: 1, bucketSize: 10, refillRate: 1, now: sec(-5) },+ ],+ },+ {+ limiter: 'grouped',+ method: 'grouped',+ nowMs: T0,+ requests: [+ { id: 'x', cost: 2, bucketSize: 5, refillRate: 1, now: sec(0) },+ { id: 'y', cost: 4, bucketSize: 3, refillRate: 1, now: sec(0) },+ { id: 'x', cost: 3, bucketSize: 99, refillRate: 50, now: sec(50) },+ { id: 'x', cost: 1, now: sec(0) },+ { id: 'y', cost: 1 },+ ],+ },+ {+ limiter: 'grouped',+ method: 'grouped',+ nowMs: T0 + 2000,+ requests: [+ { id: 'x', cost: 1, bucketSize: 5, refillRate: 1 },+ { id: 'x', cost: 1, bucketSize: 5, refillRate: 1 },+ { id: 'y', cost: 0.5, bucketSize: 3, refillRate: 1 },+ { id: 'x', cost: 1, bucketSize: 5, refillRate: 1 },+ ],+ },+ ]++const logsSteps: { limiter: keyof typeof logsLimiterConfigs; nowMs: number; messages: Msg[] }[] = [+ {+ limiter: 'all',+ nowMs: T0,+ messages: [+ { teamId: 1, bytesUncompressed: 4000, createdAt: iso(0) },+ { teamId: 1, bytesUncompressed: 4001, createdAt: iso(0.4) },+ { teamId: 1, bytesUncompressed: 3000, createdAt: iso(-3) },+ { teamId: 2, bytesUncompressed: 20_000, createdAt: iso(0) },+ { teamId: 2, bytesUncompressed: 6000, createdAt: 'Wed, 15 Jan 2025 12:00:01 GMT' },+ { teamId: 3, bytesUncompressed: 99_000, createdAt: null },+ { teamId: 3, bytesUncompressed: 99_000, createdAt: 'not a date' },+ { teamId: 4, bytesUncompressed: 1, createdAt: iso(0.5) },+ { teamId: 4, bytesUncompressed: 2500, createdAt: iso(0.5) },+ { teamId: 1, bytesUncompressed: 1, createdAt: iso(0) },+ ],+ },+ {+ limiter: 'all',+ nowMs: T0,+ messages: [+ { teamId: 1, bytesUncompressed: 3500, createdAt: iso(2) },+ { teamId: 1, bytesUncompressed: 1500, createdAt: iso(1) },+ { teamId: 2, bytesUncompressed: 10_000, createdAt: iso(1) },+ { teamId: 4, bytesUncompressed: 999, createdAt: iso(9) },+ ],+ },+ {+ limiter: 'listed',+ nowMs: T0,+ messages: [+ { teamId: 1, bytesUncompressed: 3000, createdAt: iso(0) },+ { teamId: 1, bytesUncompressed: 1000, createdAt: iso(0) },+ { teamId: 2, bytesUncompressed: 5000, createdAt: iso(0) },+ { teamId: 5, bytesUncompressed: 1e9, createdAt: '' },+ { teamId: 1, bytesUncompressed: 1, createdAt: iso(0) },+ ],+ },+]++const rec = (uuid: string, extra: Partial<LogRecord>): LogRecord =>+ ({+ uuid,+ trace_id: Buffer.from('0102030405060708090a0b0c0d0e0f10', 'hex'),+ span_id: null,+ trace_flags: null,+ timestamp: T0 * 1000,+ observed_timestamp: T0 * 1000,+ body: 'request handled',+ severity_text: 'INFO',+ severity_number: 9,+ service_name: 'api',+ resource_attributes: { 'service.name': '"api"' },+ instrumentation_scope: null,+ event_name: null,+ attributes: { 'url.path': '"/api/items"' },+ bytes_uncompressed: 200,+ ...extra,+ }) as LogRecord++const samplingRules = [+ {+ id: 'drop-health',+ rule_type: 'path_drop',+ scope_service: null,+ scope_path_pattern: null,+ scope_attribute_filters: [],+ config: { patterns: ['healthz'], match_attribute_key: 'url.path' },+ },+ {+ id: 'rl-records',+ rule_type: 'rate_limit',+ scope_service: 'api',+ scope_path_pattern: null,+ scope_attribute_filters: [],+ config: { logs_per_second: 2, burst_logs: 3 },+ },+ {+ id: 'rl-bytes',+ rule_type: 'rate_limit',+ scope_service: null,+ scope_path_pattern: null,+ scope_attribute_filters: [],+ config: { kb_per_second: 1, burst_kb: 1 },+ },+]++const samplingBatches: { nowMs: number; teamId: number; headerBytes: number; records: LogRecord[] }[] = [+ {+ nowMs: T0,+ teamId: SAMPLING_TEAM,+ headerBytes: 0,+ records: [+ rec('r0', {}),+ rec('r1', { attributes: { 'url.path': '"/healthz"' } }),+ rec('r2', {}),+ rec('r3', { service_name: 'worker', bytes_uncompressed: 400 }),+ rec('r4', {}),+ rec('r5', { service_name: 'worker', bytes_uncompressed: 500 }),+ rec('r6', {}),+ rec('r7', { service_name: 'worker', bytes_uncompressed: null }),+ rec('r8', { service_name: 'worker', bytes_uncompressed: 300 }),+ ],+ },+ {+ nowMs: T0 + 1400,+ teamId: SAMPLING_TEAM,+ headerBytes: 2500,+ records: [+ rec('s0', {}),+ rec('s1', { service_name: 'worker', body: 'x'.repeat(300) }),+ rec('s2', { service_name: 'worker', body: 'y'.repeat(100), resource_attributes: null }),+ rec('s3', {}),+ rec('s4', { service_name: 'worker', instrumentation_scope: 'scope@1' }),+ ],+ },+]++const recordJson = (r: LogRecord): unknown =>+ Object.fromEntries(+ Object.entries(r).map(([k, v]) => [k, Buffer.isBuffer(v) ? { $bytes: v.toString('hex') } : v])+ )++async function main(): Promise<void> {+ const redis = createRedisV2PoolFromConfig({+ connection: { url: 'redis://127.0.0.1:6379' },+ poolMinSize: 1,+ poolMaxSize: 1,+ })+ const scan = async (): Promise<string[]> => {+ const keys: string[] = []+ for (const pattern of KEY_PATTERNS) {+ keys.push(...((await redis.useClient({ name: 'scan' }, (c) => c.keys(pattern))) ?? []))+ }+ return keys+ }+ const existing = await scan()+ if (existing.length > 0) {+ await redis.useClient({ name: 'del' }, (c) => c.del(...existing))+ }++ const keyed = Object.fromEntries(+ Object.entries(keyedLimiters).map(([k, cfg]) => [k, new KeyedRateLimiterService(cfg, redis)])+ ) as Record<keyof typeof keyedLimiters, KeyedRateLimiterService>+ const steps: unknown[] = []+ for (const step of keyedSteps) {+ nowMs = step.nowMs+ const limiter = keyed[step.limiter]+ const requests = step.requests.map((r) => ({ ...r }))+ const output =+ step.method === 'many' ? await limiter.rateLimitMany(requests) : await limiter.rateLimitGrouped(requests)+ steps.push({ kind: 'keyed', ...step, output })+ }++ const logsLimiters = Object.fromEntries(+ Object.entries(logsLimiterConfigs).map(([k, { name, config }]) => [+ k,+ new LogsRateLimiterService(config, redis, name),+ ])+ ) as Record<keyof typeof logsLimiterConfigs, LogsRateLimiterService>+ for (const step of logsSteps) {+ nowMs = step.nowMs+ const messages = step.messages.map((m, index) => ({+ index,+ teamId: m.teamId,+ bytesUncompressed: m.bytesUncompressed,+ message: { headers: m.createdAt === null ? [] : [{ created_at: Buffer.from(m.createdAt) }] },+ }))+ const { allowed, dropped } = await logsLimiters[step.limiter].filterMessages(messages as any)+ steps.push({+ kind: 'logs',+ ...step,+ output: { allowed: allowed.map((m: any) => m.index), dropped: dropped.map((m: any) => m.index) },+ })+ }++ const sampling = new LogsSamplingService(redis, 600)+ const ruleSet = compileRuleSet(samplingRules)+ for (const batch of samplingBatches) {+ nowMs = batch.nowMs+ const input = batch.records.map(recordJson)+ const stage = sampling.makeSamplingStage(ruleSet, batch.teamId, batch.headerBytes)+ const { kept, stats } = await runPipelineStages(batch.records, [stage])+ steps.push({+ kind: 'sampling',+ nowMs: batch.nowMs,+ teamId: batch.teamId,+ headerBytes: batch.headerBytes,+ records: input,+ output: {+ kept: kept.map((r) => r.uuid),+ recordsDropped: stats.recordsDropped,+ recordsDroppedByRuleId: [...stats.recordsDroppedByRuleId],+ bytesDropped: stats.bytesDropped,+ bytesDroppedByRuleId: [...stats.bytesDroppedByRuleId],+ contentBytesDropped: stats.contentBytesDropped,+ contentBytesTotal: stats.contentBytesTotal,+ droppedBy: stats.droppedBy ?? null,+ },+ })+ }++ const finalState: Record<string, Record<string, string>> = {}+ for (const key of (await scan()).sort()) {+ finalState[key] = (await redis.useClient({ name: 'state' }, (c) => c.hgetall(key))) ?? {}+ }+ const shas = await redis.useClient({ name: 'shas' }, async (c) => {+ const set = (c as any).scriptsSet+ return { v2: set.checkRateLimitV2.sha, v3: set.checkRateLimitV3.sha }+ })++ const out = {+ keyPatterns: KEY_PATTERNS,+ keyedLimiters,+ logsLimiters: logsLimiterConfigs,+ samplingRules,+ shas,+ steps,+ finalState,+ }+ writeFileSync(join(__dirname, '../tests/fixtures/rate-limiter-reference.json'), JSON.stringify(out, null, 1) + '\n')+ process.exit(0)+}++void main()diff --git a/rust/logs-ingestion/scripts/node-re2-reference.js b/rust/logs-ingestion/scripts/node-re2-reference.jsnew file mode 100644index 000000000000..05daa7be63ad--- /dev/null+++ b/rust/logs-ingestion/scripts/node-re2-reference.js@@ -0,0 +1,48 @@+// Run from the repository root: NODE_PATH=nodejs/node_modules node rust/logs-ingestion/scripts/node-re2-reference.js+const RE2 = require('re2')+const fs = require('fs')+const path = require('path')++const patterns = [+ '', 'a', '^(GET|POST) /api', '(?=lookahead)', '(?!x)', '(?<=x)', '(?<!x)', 'HEALTHZ|token=', 'a{,5}', '{"a"',+ 'a{01}', 'a{1,2}', 'a{2,}', 'a{2,1}', 'a{1000}', 'a{1001}', '(a{100}){10}', '(a{100}){11}', '((a){10}){100}',+ '((a){10}){101}', '(a{2}|b{500}){2}', '(?:a{1000})*', 'a**', 'a+*', 'a*?', 'a??', 'a???', 'a{1,2}{3}',+ 'a{1,2}?', '\\<', '\\>', '[a[b]]', '[a&&b]', '[a--b]', '[--a]', '[a~~b]', '\\0', '\\12', '\\123', '\\1', '\\8',+ '\\Z', '\\z', '\\A', '\\Qa.b\\E', '\\Qa.b', '\\Q\\E*', '(?x)a b', '(?#c)', '(?i)abc', '(?-i)abc', '(?i-s:a.)',+ '(?ii)a', '(?i-)a', '(?-)a', '(?)', '(?:)', '(?U)a+', '(?m)^b$', '(?s).', '\\p{Greek}', '\\p{greek}',+ '\\p{^Greek}', '\\P{^Greek}', '\\pL', '\\PL', '\\p{L}', '\\p{Cn}', '\\p{C}', '\\p{Cs}', '\\P{Cs}', '\\p{Any}',+ '\\p{Lowercase_Letter}', '\\p{Script=Latin}', '\\p{sc=Han}', '\\p{Han}', '[\\p{L}\\d]', '[^\\pL]', '\\pN',+ '\\w', '\\W', '\\s', '\\S', '\\d', '\\D', '\\b', '\\B', '\\bword\\b', '[\\w-]', '[\\d-z]', '[a-\\d]', '[z-a]',+ '[]a]', '[^]a]', '[a-]', '[-a]', '[[:alpha:]]', '[[:^alpha:]]', '[[:word:]]', '[[:space:]]', '[[:punct:]]',+ '[[:foo:]]', '[[:alpha:]', '[a', 'a]', '(', ')', '(a', 'a)', '*', 'a|*', '(*)', '^*', '$*', '\\b+', '\\e',+ '\\y', '\\é', '\\x41', '\\x{41}', '\\x{110000}', '\\x{D800}', '\\x{}', '\\x4', '\\C', '\\uZZZZ', '\\u0041',+ '\\u00411', '\\u{1F600}', '\\cJ', '\\cj', '(?<n>a)', '(?P<n>a)', '(?P<1a>a)', '(?P<a>x)(?P<a>y)', '(?P<a-b>x)',+ '(?P=n)', '(?<n', '[(?<a]', '/path/', '\\/', '\\\\', '\\', 'a(?i)*', '(?i)k', '(?i)\\w', '(?i)\\W', '(?i)[^k]',+ '(?i)ß', '(?i)σ', 'x\ud83d', '[\ud83d]', 'a[^\ud83d]', '😀', '.', '^.$', '^...$', 'é', '(?i)É',+ '^\\s+$', '[\\s]', '\\S+@\\S+', '^/api/v[0-9]+', '/healthz', 'GET', '^$', '.*', '(a|b)*c', '(?i)ERROR|WARN',+ '\\d{3}-\\d{2}-\\d{4}', '[[:^space:]]+', '\\v', '\\a', '\\f', '\\t\\n\\r', '[\\x00-\\x7F]+', '[^\\x00-\\x7F]',+]+const inputs = [+ '', 'a', 'A', 'aa', 'ab', 'abc', 'b', 'x', 'GET /api/v1/items', 'POST /api', '/healthz', 'HEALTHZ', 'token=abc',+ 'a{,5}', '{"a"', 'a{01}', '<', '>', '[]', 'a]', '&', '-', '.', '~', '\0', '\n', 'S', 'a.b', 'axb', 'α', 'π日',+ 'é', 'É', '😀', '٣', 'K', 'k', 'K', 'ſ', 's', 'ß', 'ẞ', 'Σ', 'σ', 'ς', '\u000b', ' ', '\t', '\f',+ '\r\n', 'word', 'a word here', '_', '123-45-6789', '[email protected]', '', '', '', 'x\ud83d',+ '�', 'a�', 'P', '/path/', '/', '\\', 'ab\nb', ' ', 'abcabc', 'ERROR here', 'aaaa',+]+const flagSets = ['is', '']++const cases = []+for (const pattern of patterns) {+ for (const flags of flagSets) {+ let re+ try {+ re = flags ? new RE2(pattern, flags) : new RE2(pattern)+ } catch (e) {+ cases.push({ pattern, flags, compiles: false, results: [] })+ continue+ }+ cases.push({ pattern, flags, compiles: true, results: inputs.map((s) => re.test(s)) })+ }+}+const out = path.join(__dirname, '../tests/fixtures/re2-reference.json')+fs.writeFileSync(out, JSON.stringify({ inputs, cases }, null, 1) + '\n')diff --git a/rust/logs-ingestion/src/attribute_value.rs b/rust/logs-ingestion/src/attribute_value.rsnew file mode 100644index 000000000000..dae64b63e625--- /dev/null+++ b/rust/logs-ingestion/src/attribute_value.rs@@ -0,0 +1,25 @@+//! Capture stores attribute values JSON-encoded (`"error"` with quotes, `123`), so readers decode them first.++use crate::js::{json_parse, json_stringify, JsString, JsValue};++pub fn decode_log_attribute_value(value: &str) -> JsString {+ // `value.length >= 2` in UTF-16 units; both quotes are single units, so the byte check agrees.+ if value.len() >= 2 && value.starts_with('"') && value.ends_with('"') {+ let interior = &value[1..value.len() - 1];+ if !interior.contains('\\') && !interior.contains('"') {+ return JsString::from(interior);+ }+ if let Ok(JsValue::String(parsed)) = json_parse(value) {+ return parsed;+ }+ }+ JsString::from(value)+}++pub fn encode_log_attribute_value(value: &str) -> String {+ if json_parse(value).is_ok() {+ value.to_string()+ } else {+ json_stringify(&JsValue::string(value))+ }+}diff --git a/rust/logs-ingestion/src/avro/decode.rs b/rust/logs-ingestion/src/avro/decode.rsnew file mode 100644index 000000000000..ba94781373f2--- /dev/null+++ b/rust/logs-ingestion/src/avro/decode.rs@@ -0,0 +1,471 @@+//! Container decoding with avsc's results, including its errors and its silent cases.++use std::cell::RefCell;++use super::schema::Schema;+use super::value::{AvroMap, AvroValue};+use super::{AvroError, Container, MAGIC};++/// A read past the end moves the position past the end and does not fail. The caller checks `is_valid`, as avsc does.+pub(crate) struct Tap<'a> {+ pub buf: &'a [u8],+ pub pos: usize,+ /// Values that consumed no bytes. A few bytes can declare any number of them, so they share one budget.+ pub empty_values: u64,+}++/// avsc's `isSafeLong` bound: one less than 2^53 - 1 on each side, for its rounding.+const SAFE_LONG: f64 = 9007199254740990.0;++const MAX_ARRAY_LENGTH: f64 = 4_294_967_295.0;++/// Node runs out of memory on a large count of empty values, and this port stops instead.+const MAX_EMPTY_VALUES: u64 = 1 << 20;++fn precision_loss() -> AvroError {+ AvroError::Decode("potential precision loss".to_string())+}++impl<'a> Tap<'a> {+ pub fn new(buf: &'a [u8]) -> Self {+ Self {+ buf,+ pos: 0,+ empty_values: 0,+ }+ }++ fn count_empty_value(&mut self) -> Result<(), AvroError> {+ self.empty_values += 1;+ if self.empty_values > MAX_EMPTY_VALUES {+ return Err(AvroError::Decode("too many empty records".to_string()));+ }+ Ok(())+ }++ pub fn is_valid(&self) -> bool {+ self.pos <= self.buf.len()+ }++ fn invalidate(&mut self) {+ self.pos = self.buf.len() + 1;+ }++ /// A byte, or 0 past the end as `buf[pos]` gives `undefined` in JavaScript.+ fn byte(&mut self) -> u8 {+ let b = self.buf.get(self.pos).copied().unwrap_or(0);+ self.pos = self.pos.saturating_add(1);+ b+ }++ /// The Node consumer patches avsc 5.7.9 to stop at 10 bytes, so an 11th byte invalidates the tap and every long is finite. See PORTING.md.+ pub fn read_long(&mut self) -> f64 {+ let mut n: i32 = 0;+ let mut k = 0;+ let mut b;+ let mut h;+ loop {+ b = self.byte();+ h = b & 0x80;+ n |= ((b & 0x7f) as i32) << k;+ k += 7;+ if h == 0 || k >= 28 {+ break;+ }+ }+ if h != 0 {+ let mut f = n as f64;+ let mut fk = 268_435_456.0;+ let mut read = 4;+ loop {+ if read == 10 {+ self.invalidate();+ return 0.0;+ }+ read += 1;+ b = self.byte();+ f += (b & 0x7f) as f64 * fk;+ fk *= 128.0;+ if b & 0x80 == 0 {+ break;+ }+ }+ return (if f % 2.0 != 0.0 { -(f + 1.0) } else { f }) / 2.0;+ }+ ((n >> 1) ^ -(n & 1)) as f64+ }++ fn skip_long(&mut self) {+ while self.byte() & 0x80 != 0 {}+ }++ /// avsc moves `pos` by any length, but every later read past the end gives zeros, so the exact position does not matter.+ pub fn read_fixed(&mut self, len: usize) -> Option<&'a [u8]> {+ let start = self.pos;+ match start.checked_add(len) {+ Some(end) if end <= self.buf.len() => {+ self.pos = end;+ Some(&self.buf[start..end])+ }+ _ => {+ self.invalidate();+ None+ }+ }+ }++ /// A negative or oversized length leaves avsc's `pos` past the end, which is invalid too.+ pub fn read_bytes(&mut self) -> Option<&'a [u8]> {+ let len = self.read_long();+ let remaining = self.buf.len().saturating_sub(self.pos) as f64;+ if !(0.0..=remaining).contains(&len) {+ self.invalidate();+ return None;+ }+ self.read_fixed(len as usize)+ }++ /// Invalid UTF-8 decodes with U+FFFD for each maximal invalid subpart, as Node does.+ pub fn read_string(&mut self) -> Option<String> {+ self.read_bytes().map(|b| match std::str::from_utf8(b) {+ Ok(text) => text.to_owned(),+ Err(_) => String::from_utf8_lossy(b).into_owned(),+ })+ }++ fn remaining(&self) -> usize {+ self.buf.len().saturating_sub(self.pos)+ }++ /// A negative count carries a byte size, which avsc skips.+ fn read_array_size(&mut self) -> f64 {+ let n = self.read_long();+ if n < 0.0 {+ self.skip_long();+ return -n;+ }+ n+ }+}++/// Running out of data is not an error here, because the caller sees it through `is_valid`.+pub(crate) fn read_value(tap: &mut Tap<'_>, schema: &Schema) -> Result<AvroValue, AvroError> {+ Ok(match schema {+ Schema::Null => AvroValue::Null,+ Schema::Boolean => AvroValue::Boolean(tap.byte() != 0),+ Schema::Int => AvroValue::Int(tap.read_long() as i64),+ Schema::Long => {+ let n = tap.read_long();+ if !(-SAFE_LONG..=SAFE_LONG).contains(&n) {+ return Err(precision_loss());+ }+ AvroValue::Long(n as i64)+ }+ Schema::Float => {+ let b = tap.read_fixed(4);+ AvroValue::Float(b.map_or(0.0, |b| f32::from_le_bytes(b.try_into().unwrap()) as f64))+ }+ Schema::Double => {+ let b = tap.read_fixed(8);+ AvroValue::Double(b.map_or(0.0, |b| f64::from_le_bytes(b.try_into().unwrap())))+ }+ Schema::Bytes => AvroValue::Bytes(tap.read_bytes().map(<[u8]>::to_vec).unwrap_or_default()),+ Schema::String => AvroValue::String(tap.read_string().unwrap_or_default()),+ Schema::Fixed(f) => AvroValue::Fixed(+ tap.read_fixed(f.size)+ .map(<[u8]>::to_vec)+ .unwrap_or_default(),+ ),+ Schema::Enum(e) => {+ let index = tap.read_long();+ match e.symbols.get(index as usize).filter(|_| index >= 0.0) {+ Some(symbol) => AvroValue::Enum(symbol.clone()),+ None => {+ return Err(AvroError::Decode(format!(+ "invalid {} enum index: {}",+ e.name,+ crate::js::number_to_string(index)+ )))+ }+ }+ }+ Schema::Union(branches) => {+ let index = tap.read_long();+ match branches+ .get(index as usize)+ .filter(|_| index >= 0.0 && index.fract() == 0.0)+ {+ Some(branch) => read_value(tap, branch)?,+ None => {+ return Err(AvroError::Decode(format!(+ "invalid union index: {}",+ crate::js::number_to_string(index)+ )))+ }+ }+ }+ Schema::Array(items) => {+ let mut out = Vec::new();+ let mut first_batch = true;+ loop {+ let mut n = tap.read_long();+ if n == 0.0 || n.is_nan() {+ break;+ }+ if n < 0.0 {+ n = -n;+ tap.skip_long();+ }+ // avsc sizes the array from the first count with `new Array(n)`.+ if first_batch && n > MAX_ARRAY_LENGTH {+ return Err(AvroError::Decode("Invalid array length".to_string()));+ }+ first_batch = false;+ if !tap.is_valid() {+ break;+ }+ // A capacity hint only: a count can claim more items than the data holds.+ out.reserve((n as usize).min(tap.remaining()).min(4096));+ for _ in 0..n as u64 {+ let start = tap.pos;+ out.push(read_value(tap, items)?);+ if tap.pos == start {+ tap.count_empty_value()?;+ }+ if !tap.is_valid() {+ return Ok(AvroValue::Array(out));+ }+ }+ }+ AvroValue::Array(out)+ }+ Schema::Map(values) => {+ let mut out = AvroMap::new();+ loop {+ let n = tap.read_array_size();+ if n == 0.0 || n.is_nan() || !tap.is_valid() {+ break;+ }+ for _ in 0..n as u64 {+ // avsc names an unreadable key `undefined`, and the record fails as a truncated block either way.+ let key = tap.read_string().unwrap_or_else(|| "undefined".to_string());+ let value = read_value(tap, values)?;+ out.assign(key, value);+ if !tap.is_valid() {+ return Ok(AvroValue::Map(out));+ }+ }+ }+ AvroValue::Map(out)+ }+ Schema::Record(record) => {+ let mut fields = Vec::with_capacity(record.fields.len());+ for field in &record.fields {+ fields.push((field.name.clone(), read_value(tap, &field.schema)?));+ }+ AvroValue::Record(fields)+ }+ })+}++struct Header {+ meta: Vec<(String, Vec<u8>)>,+ sync: [u8; 16],+}++/// `None` means it ran out of data, which avsc treats as "wait for more" and ends with no metadata.+fn read_header(tap: &mut Tap<'_>) -> Option<Header> {+ tap.read_fixed(4)?;+ let mut meta = Vec::new();+ loop {+ let n = tap.read_array_size();+ if n == 0.0 || n.is_nan() || !tap.is_valid() {+ break;+ }+ for _ in 0..n as u64 {+ let key = tap.read_string();+ let value = tap.read_bytes().map(<[u8]>::to_vec);+ if !tap.is_valid() {+ return None;+ }+ let key = key.unwrap_or_default();+ // A plain-object assignment: a later duplicate wins.+ match meta+ .iter_mut()+ .find(|(k, _): &&mut (String, Vec<u8>)| *k == key)+ {+ Some(entry) => entry.1 = value.unwrap_or_default(),+ None => meta.push((key, value.unwrap_or_default())),+ }+ }+ }+ let sync = tap.read_fixed(16)?;+ if !tap.is_valid() {+ return None;+ }+ Some(Header {+ meta,+ sync: sync.try_into().expect("16 bytes"),+ })+}++/// A larger stated size goes through the streaming decoder, which grows its buffer instead of trusting the header.+const MAX_PRESIZED_FRAME: u64 = 64 << 20;++const DEFAULT_WINDOW_LOG_MAX: u32 = 27;++/// The one-shot decoder skips zstd's default window limit, which Node enforces, so such frames take the streaming path.+fn declared_window_exceeds_default(data: &[u8]) -> bool {+ let Some(&descriptor) = data.get(4) else {+ return true;+ };+ if descriptor & 0x20 != 0 {+ return false;+ }+ let Some(&window) = data.get(5) else {+ return true;+ };+ let log = u32::from(window >> 3) + 10;+ let base = 1u64 << log;+ base + (base / 8) * u64::from(window & 7) > 1u64 << DEFAULT_WINDOW_LOG_MAX+}++thread_local! {+ /// A zstd context is large to set up, so each thread keeps one.+ static DECOMPRESSOR: RefCell<Option<zstd::bulk::Decompressor<'static>>> = const { RefCell::new(None) };+}++/// Any input other than one sized frame, or a failure there, takes the streaming path, whose result counts.+fn inflate(data: &[u8]) -> std::io::Result<Vec<u8>> {+ use zstd::zstd_safe::{find_frame_compressed_size, get_frame_content_size};+ if let (Ok(len), Ok(Some(size))) = (+ find_frame_compressed_size(data),+ get_frame_content_size(data),+ ) {+ if len == data.len() && size <= MAX_PRESIZED_FRAME && !declared_window_exceeds_default(data)+ {+ let fast = DECOMPRESSOR.with(|cell| {+ let mut slot = cell.borrow_mut();+ let decompressor = match slot.as_mut() {+ Some(d) => d,+ None => slot.insert(zstd::bulk::Decompressor::new()?),+ };+ let inflated = decompressor.decompress(data, size as usize);+ // A failed frame can leave state in the context, so the next frame gets a new one.+ if !matches!(&inflated, Ok(out) if out.len() as u64 == size) {+ *slot = None;+ }+ inflated+ });+ if let Ok(inflated) = fast {+ if inflated.len() as u64 == size {+ return Ok(inflated);+ }+ }+ }+ }+ zstd::stream::decode_all(data)+}++/// Only the zstandard codec is registered, as in `decodeLogRecords`.+pub fn decode_container(buf: &[u8]) -> Result<Container, AvroError> {+ if buf.len() < MAGIC.len() {+ return Err(AvroError::NoMetadata);+ }+ if buf[..4] != MAGIC {+ return Err(AvroError::InvalidMagic);+ }+ let mut tap = Tap::new(buf);+ let header = read_header(&mut tap).ok_or(AvroError::NoMetadata)?;+ let meta = |key: &str| header.meta.iter().find(|(k, _)| k == key).map(|(_, v)| v);+ let text = |v: &Vec<u8>| match std::str::from_utf8(v) {+ Ok(text) => text.to_owned(),+ Err(_) => String::from_utf8_lossy(v).into_owned(),+ };+ let codec = meta("avro.codec")+ .map(text)+ .unwrap_or_else(|| "null".to_string());+ if codec != "zstandard" {+ return Err(AvroError::UnknownCodec(codec));+ }+ let schema_json = meta("avro.schema")+ .map(text)+ .ok_or_else(|| AvroError::Schema("missing avro.schema".to_string()))?;+ let schema = Schema::parse_json_cached(&schema_json)?;++ // avsc checks every complete block's sync marker before any block decompresses, and it never reads an incomplete trailing block.+ let mut blocks = Vec::new();+ loop {+ // avsc reads the count as a `long`, which throws before the rest of the block is read.+ let count = tap.read_long();+ if !(-SAFE_LONG..=SAFE_LONG).contains(&count) {+ return Err(precision_loss());+ }+ let data = tap.read_bytes();+ let sync = tap.read_fixed(16);+ if !tap.is_valid() {+ break;+ }+ if sync != Some(&header.sync[..]) {+ return Err(AvroError::InvalidSyncMarker);+ }+ blocks.push((count, data.unwrap_or_default()));+ if tap.pos >= buf.len() {+ break;+ }+ }++ let mut records = Vec::new();+ let mut empty_values = 0u64;+ for (count, data) in blocks {+ let inflated =+ inflate(data).map_err(|_| AvroError::Decompression("zstandard".to_string()))?;+ // The sender controls `count`, so the reservation is bounded by bytes actually inflated.+ records.reserve(((count as i64).clamp(0, 4096) as usize).min(inflated.len()));+ // avsc keeps `count | 0`, and a negative count reads records until one fails.+ let mut remaining = i64::from((count as i64) as i32);+ let mut block = Tap::new(&inflated);+ block.empty_values = empty_values;+ while remaining != 0 {+ remaining -= 1;+ let start = block.pos;+ let value = read_value(&mut block, &schema)?;+ if !block.is_valid() {+ return Err(AvroError::Decode("truncated block".to_string()));+ }+ if block.pos == start {+ block.count_empty_value()?;+ if remaining < 0 {+ return Err(AvroError::Decode("too many empty records".to_string()));+ }+ }+ records.push(value);+ }+ empty_values = block.empty_values;+ }++ Ok(Container {+ schema_json,+ schema,+ codec,+ records,+ })+}++#[cfg(test)]+mod tests {+ use super::Tap;++ #[test]+ fn read_long_stops_at_ten_bytes_like_the_patched_avsc() {+ let ten = [0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01];+ let mut tap = Tap::new(&ten);+ assert_eq!(tap.read_long(), 9_223_372_036_854_775_807.0);+ assert!(tap.is_valid());++ let eleven = [0xff; 11];+ let mut tap = Tap::new(&eleven);+ assert_eq!(tap.read_long(), 0.0);+ assert!(!tap.is_valid());+ }+}diff --git a/rust/logs-ingestion/src/avro/encode.rs b/rust/logs-ingestion/src/avro/encode.rsnew file mode 100644index 000000000000..300e6aaadd76--- /dev/null+++ b/rust/logs-ingestion/src/avro/encode.rs@@ -0,0 +1,272 @@+//! Container encoding laid out as avsc's `BlockEncoder` lays it out.++use std::cell::RefCell;++use rand::RngCore;++use super::schema::Schema;+use super::value::AvroValue;+use super::{AvroError, MAGIC};++/// avsc's default block size, in bytes of serialized records before compression.+const BLOCK_SIZE: usize = 65_536;++pub(crate) fn write_long(out: &mut Vec<u8>, n: i64) {+ let mut z = ((n << 1) ^ (n >> 63)) as u64;+ loop {+ if z & !0x7f == 0 {+ out.push(z as u8);+ return;+ }+ out.push(((z & 0x7f) | 0x80) as u8);+ z >>= 7;+ }+}++fn write_bytes(out: &mut Vec<u8>, b: &[u8]) {+ write_long(out, b.len() as i64);+ out.extend_from_slice(b);+}++fn invalid(schema: &Schema, value: &AvroValue) -> AvroError {+ AvroError::Encode(format!("invalid {}: {:?}", schema.short_name(), value))+}++fn is_safe_long(n: i64) -> bool {+ (-9_007_199_254_740_990..=9_007_199_254_740_990).contains(&n)+}++/// avsc picks the branch by the value's JavaScript type.+fn union_branch<'s>(branches: &'s [Schema], value: &AvroValue) -> Option<(usize, &'s Schema)> {+ branches.iter().enumerate().find(|(_, b)| {+ matches!(+ (b, value),+ (Schema::Null, AvroValue::Null)+ | (Schema::Boolean, AvroValue::Boolean(_))+ | (+ Schema::Int | Schema::Long | Schema::Float | Schema::Double,+ AvroValue::Int(_)+ | AvroValue::Long(_)+ | AvroValue::Float(_)+ | AvroValue::Double(_)+ )+ | (+ Schema::Bytes | Schema::Fixed(_),+ AvroValue::Bytes(_) | AvroValue::Fixed(_)+ )+ | (+ Schema::String | Schema::Enum(_),+ AvroValue::String(_) | AvroValue::Enum(_)+ )+ | (Schema::Array(_), AvroValue::Array(_))+ | (Schema::Map(_), AvroValue::Map(_))+ | (Schema::Record(_), AvroValue::Record(_))+ )+ })+}++fn as_number(value: &AvroValue) -> Option<f64> {+ match value {+ AvroValue::Int(n) | AvroValue::Long(n) => Some(*n as f64),+ AvroValue::Float(f) | AvroValue::Double(f) => Some(*f),+ _ => None,+ }+}++pub(crate) fn write_value(+ out: &mut Vec<u8>,+ schema: &Schema,+ value: &AvroValue,+) -> Result<(), AvroError> {+ match schema {+ Schema::Null => {+ if !value.is_null() {+ return Err(invalid(schema, value));+ }+ }+ Schema::Boolean => match value {+ AvroValue::Boolean(b) => out.push(*b as u8),+ _ => return Err(invalid(schema, value)),+ },+ Schema::Int => match as_number(value) {+ Some(n) if n.fract() == 0.0 && (i32::MIN as f64..=i32::MAX as f64).contains(&n) => {+ write_long(out, n as i64)+ }+ _ => return Err(invalid(schema, value)),+ },+ Schema::Long => match as_number(value) {+ Some(n) if n.fract() == 0.0 && is_safe_long(n as i64) => write_long(out, n as i64),+ _ => return Err(invalid(schema, value)),+ },+ Schema::Float => match as_number(value) {+ Some(n) => out.extend_from_slice(&(n as f32).to_le_bytes()),+ None => return Err(invalid(schema, value)),+ },+ Schema::Double => match as_number(value) {+ Some(n) => out.extend_from_slice(&n.to_le_bytes()),+ None => return Err(invalid(schema, value)),+ },+ Schema::Bytes => match value.as_bytes() {+ Some(b) => write_bytes(out, b),+ None => return Err(invalid(schema, value)),+ },+ Schema::String => match value {+ AvroValue::String(s) => write_bytes(out, s.as_bytes()),+ _ => return Err(invalid(schema, value)),+ },+ Schema::Fixed(f) => match value.as_bytes() {+ Some(b) if b.len() == f.size => out.extend_from_slice(b),+ _ => return Err(invalid(schema, value)),+ },+ Schema::Enum(e) => {+ let symbol = match value {+ AvroValue::Enum(s) | AvroValue::String(s) => s,+ _ => return Err(invalid(schema, value)),+ };+ match e.symbols.iter().position(|s| s == symbol) {+ Some(i) => write_long(out, i as i64),+ None => return Err(invalid(schema, value)),+ }+ }+ Schema::Union(branches) => match union_branch(branches, value) {+ Some((index, branch)) => {+ write_long(out, index as i64);+ write_value(out, branch, value)?;+ }+ None => return Err(invalid(schema, value)),+ },+ Schema::Array(items) => match value {+ AvroValue::Array(values) => {+ if !values.is_empty() {+ write_long(out, values.len() as i64);+ for v in values {+ write_value(out, items, v)?;+ }+ }+ out.push(0);+ }+ _ => return Err(invalid(schema, value)),+ },+ Schema::Map(values) => match value {+ AvroValue::Map(map) => {+ if !map.is_empty() {+ write_long(out, map.len() as i64);+ for (k, v) in map.iter() {+ write_bytes(out, k.as_bytes());+ write_value(out, values, v)?;+ }+ }+ out.push(0);+ }+ _ => return Err(invalid(schema, value)),+ },+ Schema::Record(record) => match value {+ AvroValue::Record(fields) => {+ // Fields are in schema order, so each lookup tries the same position first. With unique names that match is the first field of the name.+ let mut aligned = record.field_index.len() == record.fields.len();+ for (i, field) in record.fields.iter().enumerate() {+ let positional = match fields.get(i) {+ Some((name, v)) if aligned && name == &field.name => Some(v),+ _ => None,+ };+ // A missing field encodes as `undefined`, which a nullable union writes as null, as avsc does.+ let v = match positional {+ Some(v) => v,+ None => {+ aligned = false;+ fields+ .iter()+ .find(|(name, _)| *name == field.name)+ .map(|(_, v)| v)+ .unwrap_or(&AvroValue::Null)+ }+ };+ write_value(out, &field.schema, v)?;+ }+ }+ _ => return Err(invalid(schema, value)),+ },+ }+ Ok(())+}++thread_local! {+ /// A zstd context is large to set up, so each thread keeps one at level 1.+ static COMPRESSOR: RefCell<Option<zstd::bulk::Compressor<'static>>> = const { RefCell::new(None) };+}++fn zstd_compress(data: &[u8]) -> std::io::Result<Vec<u8>> {+ COMPRESSOR.with(|cell| {+ let mut slot = cell.borrow_mut();+ let compressor = match slot.as_mut() {+ Some(c) => c,+ None => slot.insert(zstd::bulk::Compressor::new(1)?),+ };+ let compressed = compressor.compress(data);+ if compressed.is_err() {+ *slot = None;+ }+ compressed+ })+}++fn compress(codec: &str, data: &[u8]) -> Result<Vec<u8>, AvroError> {+ match codec {+ "zstandard" => zstd_compress(data).map_err(|_| AvroError::Decompression(codec.to_string())),+ "null" => Ok(data.to_vec()),+ other => Err(AvroError::UnknownCodec(other.to_string())),+ }+}++/// A record larger than the block size gets a block of its own and doubles the block size, as in avsc.+pub fn encode_container(+ schema: &Schema,+ codec: &str,+ records: &[AvroValue],+) -> Result<Vec<u8>, AvroError> {+ let mut sync = [0u8; 16];+ rand::thread_rng().fill_bytes(&mut sync);++ let mut out = Vec::new();+ out.extend_from_slice(&MAGIC);+ write_long(&mut out, 2);+ write_bytes(&mut out, b"avro.schema");+ write_bytes(&mut out, schema.avsc_json_str().as_bytes());+ write_bytes(&mut out, b"avro.codec");+ write_bytes(&mut out, codec.as_bytes());+ out.push(0);+ out.extend_from_slice(&sync);++ let mut block_size = BLOCK_SIZE;+ let mut block = Vec::new();+ let mut count = 0i64;+ let mut record = Vec::new();+ let flush =+ |out: &mut Vec<u8>, block: &mut Vec<u8>, count: &mut i64| -> Result<(), AvroError> {+ let compressed = compress(codec, block)?;+ write_long(out, *count);+ write_bytes(out, &compressed);+ out.extend_from_slice(&sync);+ block.clear();+ *count = 0;+ Ok(())+ };+ for value in records {+ record.clear();+ write_value(&mut record, schema, value)?;+ if block.len() + record.len() > block_size {+ if !block.is_empty() {+ flush(&mut out, &mut block, &mut count)?;+ }+ if record.len() > block_size {+ block_size = record.len() * 2;+ }+ }+ block.extend_from_slice(&record);+ count += 1;+ }+ if !block.is_empty() {+ flush(&mut out, &mut block, &mut count)?;+ }+ Ok(out)+}diff --git a/rust/logs-ingestion/src/avro/mod.rs b/rust/logs-ingestion/src/avro/mod.rsnew file mode 100644index 000000000000..4a7650fb6994--- /dev/null+++ b/rust/logs-ingestion/src/avro/mod.rs@@ -0,0 +1,48 @@+//! Decode errors become the DLQ `error_message`, so this codec reproduces avsc's header export, map semantics and error strings.++mod decode;+mod encode;+mod schema;+mod value;++use thiserror::Error;++pub use decode::decode_container;+pub use encode::encode_container;+pub use schema::{EnumSchema, Field, FixedSchema, RecordSchema, Schema};+pub use value::{AvroMap, AvroValue};++pub(crate) const MAGIC: [u8; 4] = *b"Obj\x01";++/// `schema_json` is the header text exactly as the writer wrote it.+#[derive(Debug, Clone)]+pub struct Container {+ pub schema_json: String,+ pub schema: Schema,+ pub codec: String,+ pub records: Vec<AvroValue>,+}++/// The `Display` text goes to the DLQ `error_message` header, so each one matches the Node message.+#[derive(Debug, Error, Clone, PartialEq, Eq)]+pub enum AvroError {+ /// `decodeLogRecords` found no header: under 4 bytes, or a header that runs past the end.+ #[error("No metadata found")]+ NoMetadata,+ #[error("invalid magic bytes")]+ InvalidMagic,+ /// Only zstandard is registered, which hides avsc's built-in null and deflate codecs.+ #[error("unknown codec: {0}")]+ UnknownCodec(String),+ #[error("invalid sync marker")]+ InvalidSyncMarker,+ #[error("{0} codec decompression error")]+ Decompression(String),+ #[error("{0}")]+ Decode(String),+ #[error("{0}")]+ Encode(String),+ /// avsc's text here comes from `JSON.parse` or `Type.forSchema`, which this port does not reproduce.+ #[error("{0}")]+ Schema(String),+}diff --git a/rust/logs-ingestion/src/avro/schema.rs b/rust/logs-ingestion/src/avro/schema.rsnew file mode 100644index 000000000000..3b8336256c42--- /dev/null+++ b/rust/logs-ingestion/src/avro/schema.rs@@ -0,0 +1,436 @@+//! Avro schemas, read from a container header and written back as avsc writes them.++use std::collections::{HashMap, HashSet};+use std::sync::{Arc, LazyLock, Mutex, OnceLock};++use super::AvroError;+use crate::js::{json_parse, json_stringify, JsObject, JsString, JsValue};++#[derive(Debug, Clone, PartialEq)]+pub enum Schema {+ Null,+ Boolean,+ Int,+ Long,+ Float,+ Double,+ Bytes,+ String,+ Record(Arc<RecordSchema>),+ Enum(Arc<EnumSchema>),+ Fixed(Arc<FixedSchema>),+ Array(Box<Schema>),+ Map(Box<Schema>),+ /// avsc's default unwrapped union: the value carries its own branch.+ Union(Vec<Schema>),+}++#[derive(Debug, Clone, PartialEq)]+pub struct RecordSchema {+ pub name: String,+ /// Fixed when the record is built, so a later definition with the same name cannot change it.+ pub(crate) depth: usize,+ pub fields: Vec<Field>,+ pub aliases: Vec<String>,+ pub doc: Option<String>,+ pub field_index: HashMap<Arc<str>, usize>,+ pub(crate) avsc_json: AvscJsonMemo,+}++/// Computed once. It takes no part in equality.+#[derive(Debug, Clone, Default)]+pub(crate) struct AvscJsonMemo(OnceLock<String>);++impl PartialEq for AvscJsonMemo {+ fn eq(&self, _: &Self) -> bool {+ true+ }+}++/// Producers send the same few schemas, so parsed schemas are kept by their exact text.+const SCHEMA_CACHE_CAPACITY: usize = 64;++static SCHEMA_CACHE: LazyLock<Mutex<HashMap<String, Schema, ahash::RandomState>>> =+ LazyLock::new(Default::default);++#[derive(Debug, Clone, PartialEq)]+pub struct Field {+ pub name: Arc<str>,+ pub schema: Schema,+ pub default: Option<JsValue>,+ pub order: Option<String>,+ pub aliases: Vec<String>,+ pub doc: Option<String>,+}++#[derive(Debug, Clone, PartialEq)]+pub struct EnumSchema {+ pub name: String,+ pub symbols: Vec<String>,+ pub default: Option<String>,+ pub aliases: Vec<String>,+ pub doc: Option<String>,+}++#[derive(Debug, Clone, PartialEq)]+pub struct FixedSchema {+ pub name: String,+ pub size: usize,+ pub aliases: Vec<String>,+}++fn schema_error(message: impl Into<String>) -> AvroError {+ AvroError::Schema(message.into())+}++fn get_str<'a>(object: &'a JsObject, key: &str) -> Option<&'a str> {+ object+ .get(key)+ .and_then(|v| v.as_js_string())+ .and_then(JsString::as_str)+}++fn get_strings(object: &JsObject, key: &str) -> Vec<String> {+ match object.get(key) {+ Some(JsValue::Array(items)) => items+ .iter()+ .filter_map(|v| v.as_js_string().map(|s| s.to_string()))+ .collect(),+ _ => Vec::new(),+ }+}++/// A name reference reaches past the JSON nesting limit, so resolved depth needs its own bound before any recursive walk.+const MAX_SCHEMA_DEPTH: usize = crate::js::MAX_BUILT_DEPTH;++/// Anonymous nesting follows the JSON nesting limit, and a record carries its own depth.+fn schema_depth(schema: &Schema) -> usize {+ match schema {+ Schema::Record(record) => record.depth,+ Schema::Union(branches) => 1 + branches.iter().map(schema_depth).max().unwrap_or(0),+ Schema::Array(inner) | Schema::Map(inner) => 1 + schema_depth(inner),+ _ => 1,+ }+}++struct Parser {+ named: HashMap<String, Schema>,+}++fn qualify(name: &str, namespace: Option<&str>) -> String {+ if name.contains('.') {+ return name.to_string();+ }+ match namespace {+ Some(ns) if !ns.is_empty() => format!("{ns}.{name}"),+ _ => name.to_string(),+ }+}++impl Parser {+ fn parse(&mut self, value: &JsValue, namespace: Option<&str>) -> Result<Schema, AvroError> {+ match value {+ JsValue::String(name) => self.parse_name(&name.to_string(), namespace),+ JsValue::Array(branches) => Ok(Schema::Union(+ branches+ .iter()+ .map(|b| self.parse(b, namespace))+ .collect::<Result<_, _>>()?,+ )),+ JsValue::Object(object) => self.parse_object(object, namespace),+ _ => Err(schema_error("invalid schema")),+ }+ }++ fn parse_name(&mut self, name: &str, namespace: Option<&str>) -> Result<Schema, AvroError> {+ Ok(match name {+ "null" => Schema::Null,+ "boolean" => Schema::Boolean,+ "int" => Schema::Int,+ "long" => Schema::Long,+ "float" => Schema::Float,+ "double" => Schema::Double,+ "bytes" => Schema::Bytes,+ "string" => Schema::String,+ other => self+ .named+ .get(&qualify(other, namespace))+ .or_else(|| self.named.get(other))+ .cloned()+ .ok_or_else(|| schema_error(format!("undefined type name: {other}")))?,+ })+ }++ fn parse_object(+ &mut self,+ object: &JsObject,+ namespace: Option<&str>,+ ) -> Result<Schema, AvroError> {+ let type_name = get_str(object, "type").ok_or_else(|| schema_error("missing type"))?;+ match type_name {+ "record" | "error" => {+ let name = qualify(+ get_str(object, "name").ok_or_else(|| schema_error("missing record name"))?,+ get_str(object, "namespace").or(namespace),+ );+ let ns = name.rsplit_once('.').map(|(ns, _)| ns.to_string());+ let mut fields = Vec::new();+ let Some(JsValue::Array(raw_fields)) = object.get("fields") else {+ return Err(schema_error("missing fields"));+ };+ for raw in raw_fields {+ let JsValue::Object(f) = raw else {+ return Err(schema_error("invalid field"));+ };+ let field_type = f+ .get("type")+ .ok_or_else(|| schema_error("missing field type"))?;+ fields.push(Field {+ name: Arc::from(+ get_str(f, "name").ok_or_else(|| schema_error("missing field name"))?,+ ),+ schema: self.parse(field_type, ns.as_deref())?,+ default: f.get("default").cloned(),+ order: get_str(f, "order")+ .filter(|o| *o != "ascending")+ .map(str::to_string),+ aliases: get_strings(f, "aliases"),+ doc: get_str(f, "doc").map(str::to_string),+ });+ }+ let field_index = fields+ .iter()+ .enumerate()+ .map(|(i, f)| (f.name.clone(), i))+ .collect();+ let depth = 1 + fields+ .iter()+ .map(|f| schema_depth(&f.schema))+ .max()+ .unwrap_or(0);+ if depth > MAX_SCHEMA_DEPTH {+ return Err(schema_error("schema nesting too deep"));+ }+ let schema = Schema::Record(Arc::new(RecordSchema {+ name: name.clone(),+ depth,+ fields,+ aliases: get_strings(object, "aliases"),+ doc: get_str(object, "doc").map(str::to_string),+ field_index,+ avsc_json: AvscJsonMemo::default(),+ }));+ self.named.insert(name, schema.clone());+ Ok(schema)+ }+ "enum" => {+ let name = qualify(+ get_str(object, "name").ok_or_else(|| schema_error("missing enum name"))?,+ get_str(object, "namespace").or(namespace),+ );+ let schema = Schema::Enum(Arc::new(EnumSchema {+ name: name.clone(),+ symbols: get_strings(object, "symbols"),+ default: get_str(object, "default").map(str::to_string),+ aliases: get_strings(object, "aliases"),+ doc: get_str(object, "doc").map(str::to_string),+ }));+ self.named.insert(name, schema.clone());+ Ok(schema)+ }+ "fixed" => {+ let name = qualify(+ get_str(object, "name").ok_or_else(|| schema_error("missing fixed name"))?,+ get_str(object, "namespace").or(namespace),+ );+ let size = match object.get("size") {+ Some(JsValue::Number(n)) if *n >= 0.0 => *n as usize,+ _ => return Err(schema_error("invalid fixed size")),+ };+ let schema = Schema::Fixed(Arc::new(FixedSchema {+ name: name.clone(),+ size,+ aliases: get_strings(object, "aliases"),+ }));+ self.named.insert(name, schema.clone());+ Ok(schema)+ }+ "array" => Ok(Schema::Array(Box::new(+ self.parse(+ object+ .get("items")+ .ok_or_else(|| schema_error("missing items"))?,+ namespace,+ )?,+ ))),+ "map" => Ok(Schema::Map(Box::new(+ self.parse(+ object+ .get("values")+ .ok_or_else(|| schema_error("missing values"))?,+ namespace,+ )?,+ ))),+ // avsc reads a primitive written as an object as the plain primitive and drops an unregistered logical type.+ primitive => self.parse_name(primitive, namespace),+ }+ }+}++impl Schema {+ pub fn parse_json(text: &str) -> Result<Schema, AvroError> {+ let value = json_parse(text).map_err(|e| schema_error(e.to_string()))?;+ let mut parser = Parser {+ named: HashMap::new(),+ };+ let schema = parser.parse(&value, None)?;+ if schema_depth(&schema) > MAX_SCHEMA_DEPTH {+ return Err(schema_error("schema nesting too deep"));+ }+ Ok(schema)+ }++ /// A parse is a pure function of the text, so a cached schema is the same value. Errors are not cached.+ pub fn parse_json_cached(text: &str) -> Result<Schema, AvroError> {+ if let Some(schema) = SCHEMA_CACHE.lock().unwrap().get(text) {+ return Ok(schema.clone());+ }+ let schema = Schema::parse_json(text)?;+ let mut cache = SCHEMA_CACHE.lock().unwrap();+ if cache.len() >= SCHEMA_CACHE_CAPACITY {+ cache.clear();+ }+ cache.insert(text.to_string(), schema.clone());+ Ok(schema)+ }++ /// As avsc's `getSchema({ exportAttrs: true })`: it drops unregistered logical types and custom attributes, and names a type after its first definition.+ pub fn to_avsc_json(&self) -> String {+ self.avsc_json_str().to_string()+ }++ pub(crate) fn avsc_json_str(&self) -> std::borrow::Cow<'_, str> {+ match self {+ Schema::Record(record) => std::borrow::Cow::Borrowed(+ record+ .avsc_json+ .0+ .get_or_init(|| json_stringify(&self.export(&mut HashSet::new()))),+ ),+ _ => std::borrow::Cow::Owned(json_stringify(&self.export(&mut HashSet::new()))),+ }+ }++ fn export(&self, seen: &mut HashSet<String>) -> JsValue {+ let s = |v: &str| JsValue::string(v);+ let strings = |items: &[String]| JsValue::Array(items.iter().map(|i| s(i)).collect());+ match self {+ Schema::Null => s("null"),+ Schema::Boolean => s("boolean"),+ Schema::Int => s("int"),+ Schema::Long => s("long"),+ Schema::Float => s("float"),+ Schema::Double => s("double"),+ Schema::Bytes => s("bytes"),+ Schema::String => s("string"),+ Schema::Union(branches) => {+ JsValue::Array(branches.iter().map(|b| b.export(seen)).collect())+ }+ Schema::Array(items) => {+ let mut o = JsObject::new();+ o.insert_str("type", s("array"));+ o.insert_str("items", items.export(seen));+ JsValue::Object(o)+ }+ Schema::Map(values) => {+ let mut o = JsObject::new();+ o.insert_str("type", s("map"));+ o.insert_str("values", values.export(seen));+ JsValue::Object(o)+ }+ Schema::Record(record) => {+ if !seen.insert(record.name.clone()) {+ return s(&record.name);+ }+ let mut o = JsObject::new();+ o.insert_str("name", s(&record.name));+ o.insert_str("type", s("record"));+ let fields = record+ .fields+ .iter()+ .map(|f| {+ let mut fo = JsObject::new();+ fo.insert_str("name", s(&f.name));+ fo.insert_str("type", f.schema.export(seen));+ if let Some(default) = &f.default {+ fo.insert_str("default", default.clone());+ }+ if let Some(order) = &f.order {+ fo.insert_str("order", s(order));+ }+ if !f.aliases.is_empty() {+ fo.insert_str("aliases", strings(&f.aliases));+ }+ if let Some(doc) = &f.doc {+ fo.insert_str("doc", s(doc));+ }+ JsValue::Object(fo)+ })+ .collect();+ o.insert_str("fields", JsValue::Array(fields));+ if !record.aliases.is_empty() {+ o.insert_str("aliases", strings(&record.aliases));+ }+ if let Some(doc) = &record.doc {+ o.insert_str("doc", s(doc));+ }+ JsValue::Object(o)+ }+ Schema::Enum(e) => {+ if !seen.insert(e.name.clone()) {+ return s(&e.name);+ }+ let mut o = JsObject::new();+ o.insert_str("name", s(&e.name));+ o.insert_str("type", s("enum"));+ o.insert_str("symbols", strings(&e.symbols));+ if let Some(default) = &e.default {+ o.insert_str("default", s(default));+ }+ if !e.aliases.is_empty() {+ o.insert_str("aliases", strings(&e.aliases));+ }+ if let Some(doc) = &e.doc {+ o.insert_str("doc", s(doc));+ }+ JsValue::Object(o)+ }+ Schema::Fixed(f) => {+ if !seen.insert(f.name.clone()) {+ return s(&f.name);+ }+ let mut o = JsObject::new();+ o.insert_str("name", s(&f.name));+ o.insert_str("type", s("fixed"));+ o.insert_str("size", JsValue::Number(f.size as f64));+ if !f.aliases.is_empty() {+ o.insert_str("aliases", strings(&f.aliases));+ }+ JsValue::Object(o)+ }+ }+ }++ /// The schema as avsc prints it in an "invalid value" error, for primitives.+ pub(crate) fn short_name(&self) -> String {+ match self {+ Schema::Record(r) => r.name.clone(),+ Schema::Enum(e) => e.name.clone(),+ Schema::Fixed(f) => f.name.clone(),+ other => {+ let exported = other.export(&mut HashSet::new());+ json_stringify(&exported)+ }+ }+ }+}diff --git a/rust/logs-ingestion/src/avro/value.rs b/rust/logs-ingestion/src/avro/value.rsnew file mode 100644index 000000000000..361cbc5bf7db--- /dev/null+++ b/rust/logs-ingestion/src/avro/value.rs@@ -0,0 +1,231 @@+//! Decoded Avro values, shaped like the JavaScript values avsc returns.++use std::collections::btree_map::Entry;+use std::collections::BTreeMap;+use std::sync::Arc;++use hashbrown::HashTable;++use crate::js::is_array_index;+use crate::js::object::hash_str;++#[derive(Debug, Clone, PartialEq)]+pub enum AvroValue {+ Null,+ Boolean(bool),+ /// avsc reads `int` with the `long` varint reader and no range check.+ Int(i64),+ Long(i64),+ Float(f64),+ Double(f64),+ Bytes(Vec<u8>),+ String(String),+ Record(Vec<(Arc<str>, AvroValue)>),+ Enum(String),+ Fixed(Vec<u8>),+ Array(Vec<AvroValue>),+ Map(AvroMap),+}++impl AvroValue {+ pub fn as_str(&self) -> Option<&str> {+ match self {+ AvroValue::String(s) => Some(s),+ _ => None,+ }+ }++ pub fn as_i64(&self) -> Option<i64> {+ match self {+ AvroValue::Int(n) | AvroValue::Long(n) => Some(*n),+ _ => None,+ }+ }++ pub fn as_map(&self) -> Option<&AvroMap> {+ match self {+ AvroValue::Map(m) => Some(m),+ _ => None,+ }+ }++ pub fn as_bytes(&self) -> Option<&[u8]> {+ match self {+ AvroValue::Bytes(b) | AvroValue::Fixed(b) => Some(b),+ _ => None,+ }+ }++ pub fn is_null(&self) -> bool {+ matches!(self, AvroValue::Null)+ }+}++/// As the plain object avsc builds: a repeated key keeps its first position and takes the last value, and `__proto__` is not an own key.+#[derive(Debug, Clone, Default)]+pub struct AvroMap {+ /// Array-index keys. A tree keeps a descending insert order from being quadratic.+ indexed: BTreeMap<u32, (String, AvroValue)>,+ named: Vec<(String, AvroValue)>,+ /// Built only for large maps, where a linear key search would be quadratic.+ named_index: Option<HashTable<usize>>,+}++const INDEX_THRESHOLD: usize = 16;++impl PartialEq for AvroMap {+ fn eq(&self, other: &Self) -> bool {+ self.indexed == other.indexed && self.named == other.named+ }+}++impl AvroMap {+ pub fn new() -> Self {+ Self::default()+ }++ pub fn assign(&mut self, key: String, value: AvroValue) {+ if key == "__proto__" {+ // Assignment sets the prototype instead of adding an own key.+ return;+ }+ self.define(key, value);+ }++ /// Unlike `assign`, this keeps a `__proto__` key, as object spread and `Object.fromEntries` do.+ pub fn define(&mut self, key: String, value: AvroValue) {+ if let Some(n) = is_array_index(&key) {+ match self.indexed.entry(n) {+ Entry::Occupied(mut slot) => slot.get_mut().1 = value,+ Entry::Vacant(slot) => {+ slot.insert((key, value));+ }+ }+ return;+ }+ if let Some(i) = self.named_position(&key) {+ self.named[i].1 = value;+ return;+ }+ if let Some(index) = &mut self.named_index {+ let named = &self.named;+ index.insert_unique(hash_str(&key), named.len(), |&j| hash_str(&named[j].0));+ }+ self.named.push((key, value));+ if self.named_index.is_none() && self.named.len() > INDEX_THRESHOLD {+ self.build_index();+ }+ }++ fn named_position(&self, key: &str) -> Option<usize> {+ match &self.named_index {+ Some(index) => index+ .find(hash_str(key), |&i| self.named[i].0 == key)+ .copied(),+ None => self.named.iter().position(|(k, _)| k == key),+ }+ }++ fn build_index(&mut self) {+ let mut index = HashTable::with_capacity(self.named.len());+ for (i, (k, _)) in self.named.iter().enumerate() {+ index.insert_unique(hash_str(k), i, |&j| hash_str(&self.named[j].0));+ }+ self.named_index = Some(index);+ }++ pub fn get(&self, key: &str) -> Option<&AvroValue> {+ if let Some(n) = is_array_index(key) {+ return self.indexed.get(&n).map(|(_, v)| v);+ }+ self.named_position(key).map(|i| &self.named[i].1)+ }++ pub fn contains_key(&self, key: &str) -> bool {+ self.get(key).is_some()+ }++ pub fn remove(&mut self, key: &str) -> Option<AvroValue> {+ if let Some(n) = is_array_index(key) {+ return self.indexed.remove(&n).map(|(_, v)| v);+ }+ let i = self.named_position(key)?;+ let (_, value) = self.named.remove(i);+ if self.named_index.is_some() {+ self.build_index();+ }+ Some(value)+ }++ pub fn len(&self) -> usize {+ self.indexed.len() + self.named.len()+ }++ pub fn is_empty(&self) -> bool {+ self.len() == 0+ }++ pub fn iter(&self) -> impl Iterator<Item = (&str, &AvroValue)> + '_ {+ self.indexed+ .values()+ .map(|(k, v)| (k.as_str(), v))+ .chain(self.named.iter().map(|(k, v)| (k.as_str(), v)))+ }++ pub fn into_entries(self) -> impl Iterator<Item = (String, AvroValue)> {+ self.indexed.into_values().chain(self.named)+ }++ pub fn values_mut(&mut self) -> impl Iterator<Item = &mut AvroValue> + '_ {+ self.indexed+ .values_mut()+ .map(|(_, v)| v)+ .chain(self.named.iter_mut().map(|(_, v)| v))+ }++ pub fn iter_strings(&self) -> impl Iterator<Item = (&str, &str)> + '_ {+ self.iter().filter_map(|(k, v)| v.as_str().map(|s| (k, s)))+ }++ pub fn from_strings<'a>(entries: impl IntoIterator<Item = (&'a str, &'a str)>) -> Self {+ let mut map = Self::new();+ for (k, v) in entries {+ map.assign(k.to_string(), AvroValue::String(v.to_string()));+ }+ map+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn assignment_semantics_match_a_plain_object() {+ let mut m = AvroMap::new();+ for (k, v) in [+ ("b", "1"),+ ("1", "2"),+ ("__proto__", "3"),+ ("dup", "x"),+ ("dup", "y"),+ ("0", "z"),+ ("4294967295", "big"),+ ("01", "lead"),+ ] {+ m.assign(k.to_string(), AvroValue::String(v.to_string()));+ }+ let entries: Vec<_> = m.iter_strings().collect();+ assert_eq!(+ entries,+ [+ ("0", "z"),+ ("1", "2"),+ ("b", "1"),+ ("dup", "y"),+ ("4294967295", "big"),+ ("01", "lead")+ ]+ );+ }+}diff --git a/rust/logs-ingestion/src/bin/logs-ingestion-bench.rs b/rust/logs-ingestion/src/bin/logs-ingestion-bench.rsnew file mode 100644index 000000000000..8a539d4ca9e3--- /dev/null+++ b/rust/logs-ingestion/src/bin/logs-ingestion-bench.rs@@ -0,0 +1,188 @@+//! A production binary of this consumer must use jemalloc too, because the glibc allocator costs a large share of its CPU.++use std::sync::Arc;+use std::time::Instant;++use logs_ingestion::js::{json_parse, json_stringify, JsObject, JsValue};+use logs_ingestion::pipeline::scenario::{build_scenario_consumer, kafka_message};+use logs_ingestion::rate_limiter::{system_clock, RedisTokenBucket, TokenBucketRedis};++common_alloc::used!();++fn cpu_ms() -> f64 {+ let stat = std::fs::read_to_string("/proc/self/stat").unwrap_or_default();+ let after_comm = stat.rsplit_once(')').map(|(_, rest)| rest).unwrap_or("");+ let fields: Vec<&str> = after_comm.split_whitespace().collect();+ let ticks = |i: usize| {+ fields+ .get(i)+ .and_then(|f| f.parse::<f64>().ok())+ .unwrap_or(0.0)+ };+ // utime and stime are fields 14 and 15; `after_comm` starts at field 3. Linux uses 100 ticks/s.+ (ticks(11) + ticks(12)) * 10.0+}++fn peak_rss_mb() -> f64 {+ std::fs::read_to_string("/proc/self/status")+ .unwrap_or_default()+ .lines()+ .find_map(|l| l.strip_prefix("VmHWM:"))+ .and_then(|v| v.trim().trim_end_matches("kB").trim().parse::<f64>().ok())+ .unwrap_or(0.0)+ / 1024.0+}++fn percentile(sorted: &[f64], p: f64) -> f64 {+ sorted[((p / 100.0) * sorted.len() as f64)+ .floor()+ .min(sorted.len() as f64 - 1.0) as usize]+}++fn main() -> anyhow::Result<()> {+ // The arguments of this local benchmark only select a workload file and pass counts.+ // nosemgrep: rust.lang.security.args.args+ let args: Vec<String> = std::env::args().collect();+ let path = args+ .get(1)+ .expect("usage: logs-ingestion-bench <workload.json> [passes] [warmup]");+ let passes: usize = args.get(2).map_or(10, |p| p.parse().unwrap());+ let warmup: usize = args.get(3).map_or(2, |p| p.parse().unwrap());++ let runtime = tokio::runtime::Builder::new_multi_thread()+ .worker_threads(std::thread::available_parallelism().map_or(4, |n| n.get()))+ .enable_all()+ .build()?;+ runtime.block_on(async move {+ let scenario = json_parse(&std::fs::read_to_string(path)?)?;+ let client = redis::Client::open("redis://127.0.0.1:6379/9")?;+ let mut conn = client.get_multiplexed_async_connection().await?;+ let _: () = redis::cmd("FLUSHDB").query_async(&mut conn).await?;+ let redis: Arc<dyn TokenBucketRedis> = Arc::new(RedisTokenBucket::new(conn));+ let harness = build_scenario_consumer(&scenario, redis, system_clock(), true);++ let batches: Vec<Vec<_>> = match scenario_field(&scenario, "batches") {+ Some(JsValue::Array(batches)) => batches+ .iter()+ .map(|b| match b {+ JsValue::Array(ms) => ms.iter().map(kafka_message).collect(),+ _ => Vec::new(),+ })+ .collect(),+ _ => Vec::new(),+ };+ let messages_per_pass: usize = batches.iter().map(Vec::len).sum();+ let records_per_pass: f64 = batches+ .iter()+ .flatten()+ .map(|m| {+ m.header("record_count")+ .and_then(|v| v.parse::<f64>().ok())+ .unwrap_or(0.0)+ })+ .sum();+ let bytes_per_pass: usize = batches+ .iter()+ .flatten()+ .map(|m| m.value.as_ref().map_or(0, |v| v.len()))+ .sum();++ let run_batch = |batch: Vec<_>| {+ let consumer = &harness.consumer;+ async move {+ let processed = consumer.process_kafka_batch(batch).await?;+ if let Some(task) = processed.background_task {+ task.await?;+ }+ anyhow::Ok(())+ }+ };+ for _ in 0..warmup {+ for batch in &batches {+ run_batch(batch.clone()).await?;+ }+ }+ harness+ .outputs+ .produced_count+ .store(0, std::sync::atomic::Ordering::SeqCst);++ let mut batch_ms = Vec::new();+ let cpu_start = cpu_ms();+ let wall_start = Instant::now();+ for _ in 0..passes {+ for batch in &batches {+ let batch = batch.clone();+ let start = Instant::now();+ run_batch(batch).await?;+ batch_ms.push(start.elapsed().as_secs_f64() * 1000.0);+ }+ }+ let wall_ms = wall_start.elapsed().as_secs_f64() * 1000.0;+ let cpu = cpu_ms() - cpu_start;++ let mut sorted = batch_ms.clone();+ sorted.sort_by(f64::total_cmp);+ let seconds = wall_ms / 1000.0;+ let total = |n: f64| n * passes as f64;+ let mut result = JsObject::new();+ let name = match scenario_field(&scenario, "name") {+ Some(JsValue::String(s)) => s.to_utf8_lossy().into_owned(),+ _ => String::new(),+ };+ for (k, v) in [+ ("implementation", JsValue::string("rust")),+ ("workload", JsValue::string(&name)),+ ("passes", JsValue::Number(passes as f64)),+ ("batches", JsValue::Number(batch_ms.len() as f64)),+ ("messages", JsValue::Number(total(messages_per_pass as f64))),+ ("records", JsValue::Number(total(records_per_pass))),+ ("input_bytes", JsValue::Number(total(bytes_per_pass as f64))),+ (+ "produced",+ JsValue::Number(+ harness+ .outputs+ .produced_count+ .load(std::sync::atomic::Ordering::SeqCst) as f64,+ ),+ ),+ ("wall_ms", JsValue::Number(wall_ms)),+ ("cpu_ms", JsValue::Number(cpu)),+ ("peak_rss_mb", JsValue::Number(peak_rss_mb())),+ (+ "messages_per_s",+ JsValue::Number(total(messages_per_pass as f64) / seconds),+ ),+ (+ "records_per_s",+ JsValue::Number(total(records_per_pass) / seconds),+ ),+ (+ "input_mb_per_s",+ JsValue::Number(total(bytes_per_pass as f64) / 1024.0 / 1024.0 / seconds),+ ),+ ] {+ result.insert_str(k, v);+ }+ let mut stats = JsObject::new();+ stats.insert_str(+ "mean",+ JsValue::Number(batch_ms.iter().sum::<f64>() / batch_ms.len() as f64),+ );+ for (k, p) in [("p50", 50.0), ("p95", 95.0), ("p99", 99.0)] {+ stats.insert_str(k, JsValue::Number(percentile(&sorted, p)));+ }+ stats.insert_str("max", JsValue::Number(*sorted.last().unwrap_or(&0.0)));+ result.insert_str("batch_ms", JsValue::Object(stats));+ println!("{}", json_stringify(&JsValue::Object(result)));+ anyhow::Ok(())+ })+}++fn scenario_field<'a>(scenario: &'a JsValue, key: &str) -> Option<&'a JsValue> {+ match scenario {+ JsValue::Object(o) => o.get(key),+ _ => None,+ }+}diff --git a/rust/logs-ingestion/src/body_parse.rs b/rust/logs-ingestion/src/body_parse.rsnew file mode 100644index 000000000000..09725d8ee9a0--- /dev/null+++ b/rust/logs-ingestion/src/body_parse.rs@@ -0,0 +1,26 @@+use crate::js::{json_parse, JsString, JsValue};++#[derive(Debug, Clone, PartialEq)]+pub enum LogBodyParseResult {+ Empty,+ InvalidJson { raw: String },+ JsonObjectOrArray { value: JsValue },+ JsonString { value: JsString },+ JsonPrimitive { parsed: JsValue },+}++pub fn parse_log_body_for_ingestion(body: Option<&str>) -> LogBodyParseResult {+ let Some(body) = body else {+ return LogBodyParseResult::Empty;+ };+ match json_parse(body) {+ Ok(value @ (JsValue::Object(_) | JsValue::Array(_))) => {+ LogBodyParseResult::JsonObjectOrArray { value }+ }+ Ok(JsValue::String(value)) => LogBodyParseResult::JsonString { value },+ Ok(parsed) => LogBodyParseResult::JsonPrimitive { parsed },+ Err(_) => LogBodyParseResult::InvalidJson {+ raw: body.to_string(),+ },+ }+}diff --git a/rust/logs-ingestion/src/content_weights.rs b/rust/logs-ingestion/src/content_weights.rsnew file mode 100644index 000000000000..2b15e5ac9089--- /dev/null+++ b/rust/logs-ingestion/src/content_weights.rs@@ -0,0 +1,330 @@+//! Node keys content weights by record identity, so `StagedRecord` keeps the decode origin and a stage-made record weighs 0.++use std::collections::HashMap;+use std::sync::Arc;++use async_trait::async_trait;++use crate::avro::AvroMap;+use crate::record::LogRecord;++fn string_bytes(value: Option<&str>) -> f64 {+ value.map_or(0.0, |s| s.len() as f64)+}++fn map_bytes(map: Option<&AvroMap>) -> f64 {+ let mut total = 0.0;+ if let Some(map) = map {+ for (k, v) in map.iter_strings() {+ total += k.len() as f64 + v.len() as f64;+ }+ }+ total+}++/// A map has distinct keys, so the sorted pairs are equal exactly when the TypeScript's sorted `JSON.stringify` texts are.+fn resource_entries(map: Option<&AvroMap>) -> Vec<(&str, &str)> {+ let mut entries: Vec<(&str, &str)> =+ map.map(|m| m.iter_strings().collect()).unwrap_or_default();+ entries.sort_unstable_by(|a, b| a.0.cmp(b.0));+ entries+}++/// Resource and scope bytes are split across the rows that share them, so the weights are fractional.+pub fn measure_content_weights(records: &[LogRecord]) -> Vec<f64> {+ let mut resource_ids: HashMap<Vec<(&str, &str)>, usize, ahash::RandomState> =+ HashMap::default();+ let mut scope_ids: HashMap<(usize, &str), usize, ahash::RandomState> = HashMap::default();+ let mut rows_by_resource: Vec<f64> = Vec::new();+ let mut rows_by_scope: Vec<f64> = Vec::new();+ let mut previous: Option<(Option<&AvroMap>, usize)> = None;+ let keys: Vec<(usize, usize)> = records+ .iter()+ .map(|record| {+ let map = record.resource_attributes();+ // Records of one message usually share their resource, so an equal map skips the sort.+ let resource = match previous {+ Some((previous_map, id)) if previous_map == map => id,+ _ => {+ let next = resource_ids.len();+ let id = *resource_ids.entry(resource_entries(map)).or_insert(next);+ if id == rows_by_resource.len() {+ rows_by_resource.push(0.0);+ }+ id+ }+ };+ previous = Some((map, resource));+ let next = scope_ids.len();+ let scope = *scope_ids+ .entry((resource, record.instrumentation_scope().unwrap_or("")))+ .or_insert(next);+ if scope == rows_by_scope.len() {+ rows_by_scope.push(0.0);+ }+ rows_by_resource[resource] += 1.0;+ rows_by_scope[scope] += 1.0;+ (resource, scope)+ })+ .collect();+ records+ .iter()+ .zip(keys)+ .map(|(record, (resource, scope))| {+ // Summed left to right, as the TypeScript expression is.+ string_bytes(record.body())+ + string_bytes(record.event_name())+ + string_bytes(record.severity_text())+ + map_bytes(record.attributes())+ + map_bytes(record.resource_attributes()) / rows_by_resource[resource]+ + string_bytes(record.instrumentation_scope()) / rows_by_scope[scope]+ })+ .collect()+}++#[derive(Debug, Clone, PartialEq)]+pub struct StagedRecord {+ pub record: LogRecord,+ origin: Option<usize>,+}++impl StagedRecord {+ /// A record that a stage made: it has no content weight, as a new object has none in Node.+ pub fn fresh(record: LogRecord) -> Self {+ StagedRecord {+ record,+ origin: None,+ }+ }+}++/// Counts in insertion order, as a JavaScript `Map` keeps them.+#[derive(Debug, Clone, Default, PartialEq)]+pub struct OrderedCounts(pub Vec<(String, f64)>);++impl OrderedCounts {+ pub fn add(&mut self, key: &str, n: f64) {+ match self.0.iter_mut().find(|(k, _)| k == key) {+ Some(entry) => entry.1 += n,+ None => self.0.push((key.to_string(), n)),+ }+ }++ pub fn get(&self, key: &str) -> Option<f64> {+ self.0.iter().find(|(k, _)| k == key).map(|(_, v)| *v)+ }++ fn merge(&mut self, other: &OrderedCounts) {+ for (k, n) in &other.0 {+ self.add(k, *n);+ }+ }+}++#[derive(Debug, Clone, Default, PartialEq)]+pub struct StageDropStats {+ pub records_dropped: f64,+ pub records_dropped_by_rule_id: OrderedCounts,+ pub bytes_dropped: f64,+ pub bytes_dropped_by_rule_id: OrderedCounts,+ pub content_bytes_dropped: f64,+}++#[derive(Debug, Clone, Default, PartialEq)]+pub struct DropStats {+ pub stage: StageDropStats,+ /// The billing pro-rate denominator, over the whole decoded batch.+ pub content_bytes_total: f64,+ pub records_dropped_by_stage: OrderedCounts,+ pub dropped_by: Option<String>,+}++#[derive(Debug, Clone, Default)]+pub struct BatchContext {+ pub content_bytes_total: f64,+ weights: Arc<Vec<f64>>,+}++impl BatchContext {+ pub fn new(weights: Vec<f64>) -> Self {+ BatchContext {+ content_bytes_total: weights.iter().fold(0.0, |total, w| total + w),+ weights: Arc::new(weights),+ }+ }++ pub fn content_bytes_of(&self, record: &StagedRecord) -> f64 {+ record+ .origin+ .and_then(|i| self.weights.get(i).copied())+ .unwrap_or(0.0)+ }+}++#[derive(Debug, Clone, Default, PartialEq)]+pub struct FilterResult {+ pub kept: Vec<StagedRecord>,+ pub stats: StageDropStats,+}++#[async_trait]+pub trait MutateStage: Send + Sync {+ fn name(&self) -> &str;+ async fn run(&self, records: &mut Vec<StagedRecord>) -> anyhow::Result<()>;+}++#[async_trait]+pub trait FilterStage: Send + Sync {+ fn name(&self) -> &str;+ async fn run(+ &self,+ records: Vec<StagedRecord>,+ batch: &BatchContext,+ ) -> anyhow::Result<FilterResult>;+}++pub enum PipelineStage {+ Mutate(Box<dyn MutateStage>),+ Filter(Box<dyn FilterStage>),+}++pub async fn run_pipeline_stages(+ records: Vec<LogRecord>,+ stages: &[PipelineStage],+) -> anyhow::Result<(Vec<LogRecord>, DropStats)> {+ let mut stats = DropStats::default();+ let has_filter = stages.iter().any(|s| matches!(s, PipelineStage::Filter(_)));+ let batch = BatchContext::new(if has_filter {+ measure_content_weights(&records)+ } else {+ Vec::new()+ });+ stats.content_bytes_total = batch.content_bytes_total;+ let mut working: Vec<StagedRecord> = records+ .into_iter()+ .enumerate()+ .map(|(i, record)| StagedRecord {+ record,+ origin: Some(i),+ })+ .collect();+ for stage in stages {+ let stage = match stage {+ PipelineStage::Mutate(m) => {+ m.run(&mut working).await?;+ continue;+ }+ PipelineStage::Filter(f) => f,+ };+ let before = working.len();+ let FilterResult {+ kept,+ stats: dropped,+ } = stage.run(working, &batch).await?;+ stats.stage.records_dropped += dropped.records_dropped;+ stats.stage.bytes_dropped += dropped.bytes_dropped;+ stats.stage.content_bytes_dropped += dropped.content_bytes_dropped;+ stats+ .stage+ .records_dropped_by_rule_id+ .merge(&dropped.records_dropped_by_rule_id);+ stats+ .stage+ .bytes_dropped_by_rule_id+ .merge(&dropped.bytes_dropped_by_rule_id);+ if kept.len() < before {+ let removed = (before - kept.len()) as f64;+ stats.records_dropped_by_stage.add(stage.name(), removed);+ stats.dropped_by = Some(stage.name().to_string());+ }+ working = kept;+ if working.is_empty() {+ break;+ }+ }+ Ok((working.into_iter().map(|r| r.record).collect(), stats))+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::avro::AvroValue;++ fn record(body: &str) -> LogRecord {+ LogRecord::from_value(AvroValue::Record(vec![(+ Arc::from("body"),+ AvroValue::String(body.into()),+ )]))+ }++ struct DropFirst(&'static str);++ #[async_trait]+ impl FilterStage for DropFirst {+ fn name(&self) -> &str {+ self.0+ }+ async fn run(+ &self,+ mut records: Vec<StagedRecord>,+ batch: &BatchContext,+ ) -> anyhow::Result<FilterResult> {+ let mut stats = StageDropStats::default();+ if !records.is_empty() {+ let gone = records.remove(0);+ stats.records_dropped = 1.0;+ stats.content_bytes_dropped = batch.content_bytes_of(&gone);+ stats.records_dropped_by_rule_id.add("r", 1.0);+ }+ Ok(FilterResult {+ kept: records,+ stats,+ })+ }+ }++ struct Replace;++ #[async_trait]+ impl FilterStage for Replace {+ fn name(&self) -> &str {+ "replace"+ }+ async fn run(+ &self,+ records: Vec<StagedRecord>,+ _: &BatchContext,+ ) -> anyhow::Result<FilterResult> {+ let kept = records+ .into_iter()+ .map(|r| StagedRecord::fresh(r.record))+ .collect();+ Ok(FilterResult {+ kept,+ stats: StageDropStats::default(),+ })+ }+ }++ #[tokio::test]+ async fn accounting_follows_identity_and_stops_when_empty() {+ let stages = vec![+ PipelineStage::Filter(Box::new(DropFirst("a"))),+ PipelineStage::Filter(Box::new(Replace)),+ PipelineStage::Filter(Box::new(DropFirst("b"))),+ PipelineStage::Filter(Box::new(DropFirst("c"))),+ PipelineStage::Filter(Box::new(DropFirst("never"))),+ ];+ let (kept, stats) =+ run_pipeline_stages(vec![record("xx"), record("yyy"), record("z")], &stages)+ .await+ .unwrap();+ assert!(kept.is_empty());+ assert_eq!(stats.content_bytes_total, 6.0);+ // Only the first drop credits weight: later drops are of records the replace stage made.+ assert_eq!(stats.stage.content_bytes_dropped, 2.0);+ assert_eq!(stats.stage.records_dropped_by_rule_id.get("r"), Some(3.0));+ assert_eq!(stats.dropped_by.as_deref(), Some("c"));+ assert_eq!(stats.records_dropped_by_stage.get("never"), None);+ }+}diff --git a/rust/logs-ingestion/src/filter_group.rs b/rust/logs-ingestion/src/filter_group.rsnew file mode 100644index 000000000000..722d7be923e4--- /dev/null+++ b/rust/logs-ingestion/src/filter_group.rs@@ -0,0 +1,279 @@+//! Node attribute maps are plain objects, so `map[key]` also finds `Object.prototype` members, and `lookup_attribute` reproduces this.++use std::borrow::Cow;++use crate::attribute_value::decode_log_attribute_value;+use crate::avro::AvroMap;+use crate::js::{number_to_string, JsString, JsValue};+use crate::property_filter::coerce::{js_to_string_opt, JsTypeError};+use crate::property_filter::{match_property_filter, PropertyFilterLeaf};+use crate::record::LogRecord;++/// Past this depth a group never matches. `parse_filter_group` rejects deeper trees.+pub const MAX_FILTER_GROUP_DEPTH: usize = 16;++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum GroupType {+ And,+ Or,+}++#[derive(Debug, Clone)]+pub struct FilterGroupNode {+ pub group_type: GroupType,+ pub values: Vec<FilterNode>,+}++#[derive(Debug, Clone)]+pub enum FilterNode {+ Group(FilterGroupNode),+ Leaf(Box<PropertyFilterLeaf>),+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub struct InheritedMember {+ pub text: &'static str,+ /// `decodeLogAttributeValue` reads this first. `None` for `__proto__`.+ pub length: Option<u32>,+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum AttrLookup<'a> {+ Own(&'a str),+ Inherited(InheritedMember),+}++impl AttrLookup<'_> {+ pub fn text(&self) -> &str {+ match self {+ AttrLookup::Own(s) => s,+ AttrLookup::Inherited(m) => m.text,+ }+ }+}++/// The members of `Object.prototype` in Node 22.+pub fn inherited_member(key: &str) -> Option<InheritedMember> {+ let (text, length) = match key {+ "constructor" => ("function Object() { [native code] }", Some(1)),+ "__defineGetter__" => ("function __defineGetter__() { [native code] }", Some(2)),+ "__defineSetter__" => ("function __defineSetter__() { [native code] }", Some(2)),+ "hasOwnProperty" => ("function hasOwnProperty() { [native code] }", Some(1)),+ "__lookupGetter__" => ("function __lookupGetter__() { [native code] }", Some(1)),+ "__lookupSetter__" => ("function __lookupSetter__() { [native code] }", Some(1)),+ "isPrototypeOf" => ("function isPrototypeOf() { [native code] }", Some(1)),+ "propertyIsEnumerable" => ("function propertyIsEnumerable() { [native code] }", Some(1)),+ "toString" => ("function toString() { [native code] }", Some(0)),+ "valueOf" => ("function valueOf() { [native code] }", Some(0)),+ "toLocaleString" => ("function toLocaleString() { [native code] }", Some(0)),+ "__proto__" => ("[object Object]", None),+ _ => return None,+ };+ Some(InheritedMember { text, length })+}++pub fn lookup_attribute<'a>(map: &'a AvroMap, key: &str) -> Option<AttrLookup<'a>> {+ if let Some(v) = map.get(key) {+ // The log schemas hold string maps. A non-string value cannot come from a decode.+ return v.as_str().map(AttrLookup::Own);+ }+ inherited_member(key).map(AttrLookup::Inherited)+}++fn decoded_attr(map: Option<&AvroMap>, key: &JsKey) -> Result<Option<JsString>, JsTypeError> {+ let Some(map) = map else {+ return Ok(None);+ };+ let key = key.resolve()?;+ // A key with a lone surrogate cannot equal a decoded map key or a prototype member.+ let Some(key) = key.as_str() else {+ return Ok(None);+ };+ match lookup_attribute(map, key) {+ None => Ok(None),+ Some(AttrLookup::Own(raw)) => Ok(Some(decode_log_attribute_value(raw))),+ Some(AttrLookup::Inherited(member)) => {+ // `value.length >= 2 && value.startsWith(...)`: a function has no `startsWith`.+ if member.length.is_some_and(|n| n >= 2) {+ return Err(JsTypeError("value.startsWith is not a function"));+ }+ Ok(Some(JsString::from(member.text)))+ }+ }+}++/// A property key, converted with `String()` only when a lookup needs it, as `map?.[key]` does.+struct JsKey<'a>(Option<&'a JsValue>);++impl JsKey<'_> {+ fn resolve(&self) -> Result<Cow<'_, JsString>, JsTypeError> {+ match self.0 {+ Some(JsValue::String(s)) => Ok(Cow::Borrowed(s)),+ other => js_to_string_opt(other).map(Cow::Owned),+ }+ }+}++fn str_key<'a>(s: &'a JsValue) -> JsKey<'a> {+ JsKey(Some(s))+}++pub fn match_filter_group(+ group: &FilterGroupNode,+ record: &LogRecord,+) -> Result<bool, JsTypeError> {+ match_group_at(group, record, 0)+}++fn match_group_at(+ group: &FilterGroupNode,+ record: &LogRecord,+ depth: usize,+) -> Result<bool, JsTypeError> {+ if depth >= MAX_FILTER_GROUP_DEPTH || group.values.is_empty() {+ return Ok(false);+ }+ match group.group_type {+ GroupType::Or => {+ for child in &group.values {+ if match_one(child, record, depth + 1)? {+ return Ok(true);+ }+ }+ Ok(false)+ }+ GroupType::And => {+ for child in &group.values {+ if !match_one(child, record, depth + 1)? {+ return Ok(false);+ }+ }+ Ok(true)+ }+ }+}++fn match_one(node: &FilterNode, record: &LogRecord, depth: usize) -> Result<bool, JsTypeError> {+ match node {+ FilterNode::Group(g) => match_group_at(g, record, depth),+ FilterNode::Leaf(leaf) => {+ let value = lookup_record_value(leaf, record)?;+ match_property_filter(leaf, value.as_ref())+ }+ }+}++fn lookup_record_value(+ filter: &PropertyFilterLeaf,+ record: &LogRecord,+) -> Result<Option<JsString>, JsTypeError> {+ let key = JsKey(filter.key.as_ref());+ if filter.key_is("service_name") || filter.key_is("service.name") {+ if let Some(s) = record.service_name() {+ return Ok(Some(JsString::from(s)));+ }+ return decoded_attr(+ record.resource_attributes(),+ &str_key(&JsValue::string("service.name")),+ );+ }+ if filter.key_is("severity_text") || filter.key_is("level") || filter.key_is("severity_level") {+ if let Some(s) = record.severity_text() {+ return Ok(Some(JsString::from(s)));+ }+ if let Some(v) = decoded_attr(record.attributes(), &str_key(&JsValue::string("level")))? {+ return Ok(Some(v));+ }+ return decoded_attr(+ record.attributes(),+ &str_key(&JsValue::string("severity_text")),+ );+ }+ if filter.key_is("message") || filter.type_is("log") {+ return Ok(record.body().map(JsString::from));+ }+ if filter.type_is("span_attribute") {+ if filter.key_is("status_code") {+ return match record.status_code() {+ Some(code) => Ok(Some(JsString::from(number_to_string(code as f64)))),+ None => decoded_attr(record.attributes(), &key),+ };+ }+ if filter.key_is("name") {+ return match record.name() {+ Some(name) => Ok(Some(JsString::from(name))),+ None => decoded_attr(record.attributes(), &key),+ };+ }+ if filter.key_is("kind") {+ return match record.kind() {+ Some(kind) => Ok(Some(JsString::from(number_to_string(kind as f64)))),+ None => decoded_attr(record.attributes(), &key),+ };+ }+ }+ if filter.type_is("log_resource_attribute") || filter.type_is("span_resource_attribute") {+ return decoded_attr(record.resource_attributes(), &key);+ }+ if filter.type_is("log_attribute") || filter.type_is("span_attribute") {+ return decoded_attr(record.attributes(), &key);+ }+ if let Some(v) = decoded_attr(record.attributes(), &key)? {+ return Ok(Some(v));+ }+ decoded_attr(record.resource_attributes(), &key)+}++#[cfg(test)]+mod tests {+ use std::sync::Arc;++ use super::*;+ use crate::avro::AvroValue;+ use crate::js::json_parse;++ fn record(attrs: &[(&str, &str)]) -> LogRecord {+ LogRecord::from_value(AvroValue::Record(vec![+ (Arc::from("body"), AvroValue::String("hello".into())),+ (Arc::from("severity_text"), AvroValue::Null),+ (+ Arc::from("attributes"),+ AvroValue::Map(AvroMap::from_strings(attrs.iter().copied())),+ ),+ ]))+ }++ fn group(json: &str) -> FilterGroupNode {+ crate::sampling::parse_filter_group(&json_parse(json).unwrap())+ .unwrap()+ .unwrap()+ }++ #[test]+ fn prototype_members_resolve_like_a_plain_object() {+ let r = record(&[("level", "\"warn\"")]);+ let set = group(r#"{"type":"AND","values":[{"key":"constructor","operator":"is_set"}]}"#);+ assert_eq!(match_filter_group(&set, &r), Ok(true));+ let native = group(+ r#"{"type":"AND","values":[{"key":"toString","operator":"icontains","value":"native code"}]}"#,+ );+ assert_eq!(match_filter_group(&native, &r), Ok(true));+ let throws =+ group(r#"{"type":"AND","values":[{"key":"__defineGetter__","operator":"is_set"}]}"#);+ assert!(match_filter_group(&throws, &r).is_err());+ let level = group(+ r#"{"type":"AND","values":[{"key":"severity_level","operator":"exact","value":"WARN"}]}"#,+ );+ assert_eq!(match_filter_group(&level, &r), Ok(true));+ }++ #[test]+ fn a_non_string_key_is_converted_with_string() {+ let r = record(&[("1", "\"one\""), ("undefined", "\"u\"")]);+ let numeric =+ group(r#"{"type":"AND","values":[{"key":1,"operator":"exact","value":"one"}]}"#);+ assert_eq!(match_filter_group(&numeric, &r), Ok(true));+ let missing = group(r#"{"type":"AND","values":[{"operator":"exact","value":"u"}]}"#);+ assert_eq!(match_filter_group(&missing, &r), Ok(true));+ }+}diff --git a/rust/logs-ingestion/src/internal_logs.rs b/rust/logs-ingestion/src/internal_logs.rsnew file mode 100644index 000000000000..13a0888d8a6b--- /dev/null+++ b/rust/logs-ingestion/src/internal_logs.rs@@ -0,0 +1,289 @@+use std::collections::HashMap;++use hmac::{Hmac, Mac};+use metrics::counter;+use sha2::Sha256;++use crate::js::{date_parse, json_stringify, number_to_string, JsValue};+use crate::property_filter::coerce::{js_parse_int, js_trim};++pub const INTERNAL_LOGS_HEADER: &str = "posthog-internal";+/// The HTTP request header that capture-logs forwards as `posthog-internal`.+pub const INTERNAL_LOGS_HTTP_HEADER: &str = "x-posthog-internal";+pub const INTERNAL_SOURCE_HEADER: &str = "internal-source";++const SIGNATURE_VERSION: &str = "v1";+/// Measured against capture's `created_at`, so consumer lag does not expire a signature.+const SIGNATURE_WINDOW_SECONDS: f64 = 5.0 * 60.0;++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub struct InternalSourcePolicy {+ /// Counts toward the team's usage, quota and rate limits.+ pub billed: bool,+ /// Runs the team's sampling, drop, transformation, metric and retention rules.+ pub team_rules: bool,+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub struct InternalLogs {+ pub source: String,+ pub billed: bool,+ pub team_rules: bool,+}++pub fn default_internal_source_policies() -> HashMap<String, InternalSourcePolicy> {+ HashMap::from([+ (+ "hog_flow".to_string(),+ InternalSourcePolicy {+ billed: false,+ team_rules: false,+ },+ ),+ (+ "hog_function".to_string(),+ InternalSourcePolicy {+ billed: false,+ team_rules: false,+ },+ ),+ ])+}++fn is_valid_source(source: &str) -> bool {+ (1..=64).contains(&source.len())+ && source+ .bytes()+ .all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'_')+}++/// `/^[1-9][0-9]{9}$/`: epoch seconds with no sign, padding or fraction.+fn is_valid_signed_at(signed_at: &str) -> bool {+ let b = signed_at.as_bytes();+ b.len() == 10 && (b'1'..=b'9').contains(&b[0]) && b[1..].iter().all(u8::is_ascii_digit)+}++fn parse_keys(comma_separated_keys: &str) -> Vec<String> {+ comma_separated_keys+ .split(',')+ .map(js_trim)+ .filter(|k| !k.is_empty())+ .map(str::to_string)+ .collect()+}++fn compute_signature(key: &str, source: &str, team_id: i64, signed_at: &str) -> String {+ let mut mac =+ Hmac::<Sha256>::new_from_slice(key.as_bytes()).expect("HMAC takes a key of any length");+ mac.update(format!("{SIGNATURE_VERSION}|{source}|{team_id}|{signed_at}").as_bytes());+ let digest = hex::encode(mac.finalize().into_bytes());+ format!("{SIGNATURE_VERSION}.{source}.{signed_at}.{digest}")+}++fn constant_time_eq(a: &[u8], b: &[u8]) -> bool {+ a.len() == b.len() && a.iter().zip(b).fold(0u8, |acc, (x, y)| acc | (x ^ y)) == 0+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub enum SignError {+ NoKey,+ InvalidSource(String),+}++impl std::fmt::Display for SignError {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ match self {+ SignError::NoKey => write!(+ f,+ "Cannot sign posthog-internal batch: no signing key configured"+ ),+ SignError::InvalidSource(source) => write!(+ f,+ "Cannot sign posthog-internal batch: invalid source {}",+ json_stringify(&JsValue::string(source))+ ),+ }+ }+}++impl std::error::Error for SignError {}++/// Signs with the newest (first) key.+pub fn sign_internal_logs(+ comma_separated_keys: &str,+ source: &str,+ team_id: i64,+ signed_at_ms: f64,+) -> Result<String, SignError> {+ let keys = parse_keys(comma_separated_keys);+ let Some(newest) = keys.first() else {+ return Err(SignError::NoKey);+ };+ if !is_valid_source(source) {+ return Err(SignError::InvalidSource(source.to_string()));+ }+ let signed_at = number_to_string((signed_at_ms / 1000.0).floor());+ Ok(compute_signature(newest, source, team_id, &signed_at))+}++pub fn without_internal_logs_headers<I, K, V>(headers: I) -> Vec<(K, V)>+where+ I: IntoIterator<Item = (K, V)>,+ K: AsRef<str>,+{+ headers+ .into_iter()+ .filter(|(k, _)| k.as_ref() != INTERNAL_LOGS_HEADER && k.as_ref() != INTERNAL_SOURCE_HEADER)+ .collect()+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+enum NotInternalReason {+ NotConfigured,+ TeamNotAllowed,+ InvalidSignature,+ StaleSignature,+ UnknownSource,+}++impl NotInternalReason {+ fn as_str(&self) -> &'static str {+ match self {+ NotInternalReason::NotConfigured => "not_configured",+ NotInternalReason::TeamNotAllowed => "team_not_allowed",+ NotInternalReason::InvalidSignature => "invalid_signature",+ NotInternalReason::StaleSignature => "stale_signature",+ NotInternalReason::UnknownSource => "unknown_source",+ }+ }+}++#[derive(Debug, Clone)]+enum TeamMatcher {+ None,+ All,+ Teams(Vec<f64>),+}++impl TeamMatcher {+ fn build(config: &str) -> TeamMatcher {+ if js_trim(config).is_empty() {+ TeamMatcher::None+ } else if config == "*" {+ TeamMatcher::All+ } else {+ // `parseInt(n)` with no radix: it skips leading whitespace and reads `0x` as hex.+ TeamMatcher::Teams(+ config+ .split(',')+ .map(|n| js_parse_int(n, None))+ .filter(|n| !n.is_nan())+ .collect(),+ )+ }+ }++ fn matches(&self, team_id: i64) -> bool {+ match self {+ TeamMatcher::None => false,+ TeamMatcher::All => true,+ TeamMatcher::Teams(ids) => ids.contains(&(team_id as f64)),+ }+ }+}++#[derive(Debug, Clone)]+pub struct InternalLogsVerifier {+ keys: Vec<String>,+ is_team_allowed: TeamMatcher,+ policies: HashMap<String, InternalSourcePolicy>,+}++impl InternalLogsVerifier {+ pub fn new(+ comma_separated_keys: &str,+ enabled_teams: &str,+ policies: HashMap<String, InternalSourcePolicy>,+ ) -> Self {+ InternalLogsVerifier {+ keys: parse_keys(comma_separated_keys),+ is_team_allowed: TeamMatcher::build(enabled_teams),+ policies,+ }+ }++ /// `created_at` is the Kafka header that capture-logs sets.+ pub fn verify(+ &self,+ signature: Option<&str>,+ team_id: i64,+ created_at: Option<&str>,+ ) -> Option<InternalLogs> {+ let signature = signature?;+ let mut parts = signature.split('.');+ parts.next();+ let source = parts.next().unwrap_or("");+ let signed_at = parts.next().unwrap_or("");+ let reason = self.not_internal_reason(signature, source, signed_at, team_id, created_at);+ // Own keys only, so a source like `constructor` has no policy.+ let policy = match reason {+ None => self.policies.get(source),+ Some(_) => None,+ };+ let Some(policy) = policy else {+ let reason = reason.unwrap_or(NotInternalReason::UnknownSource).as_str();+ counter!("logs_ingestion_internal_logs_total", "outcome" => "not_internal", "reason" => reason).increment(1);+ tracing::warn!(+ team_id,+ reason,+ "Internal logs header did not verify, batch billed as normal"+ );+ return None;+ };+ counter!("logs_ingestion_internal_logs_total", "outcome" => "internal", "reason" => "")+ .increment(1);+ Some(InternalLogs {+ source: source.to_string(),+ billed: policy.billed,+ team_rules: policy.team_rules,+ })+ }++ fn not_internal_reason(+ &self,+ signature: &str,+ source: &str,+ signed_at: &str,+ team_id: i64,+ created_at: Option<&str>,+ ) -> Option<NotInternalReason> {+ if self.keys.is_empty() {+ return Some(NotInternalReason::NotConfigured);+ }+ if !self.is_team_allowed.matches(team_id) {+ return Some(NotInternalReason::TeamNotAllowed);+ }+ if !is_valid_source(source) || !is_valid_signed_at(signed_at) {+ return Some(NotInternalReason::InvalidSignature);+ }+ let received = signature.as_bytes();+ // Every key is tried, so a rotation can add a key before producers switch to it.+ let mut matches = false;+ for key in &self.keys {+ let expected = compute_signature(key, source, team_id, signed_at);+ matches |= constant_time_eq(expected.as_bytes(), received);+ }+ if !matches {+ return Some(NotInternalReason::InvalidSignature);+ }+ // A missing or unparseable `created_at` gives NaN, which fails the comparison.+ let created_ms = date_parse(created_at.unwrap_or("")).unwrap_or(f64::NAN);+ let signed_at_seconds: f64 = signed_at.parse().unwrap_or(f64::NAN);+ let skew = (created_ms / 1000.0 - signed_at_seconds).abs();+ if skew <= SIGNATURE_WINDOW_SECONDS {+ None+ } else {+ Some(NotInternalReason::StaleSignature)+ }+ }+}diff --git a/rust/logs-ingestion/src/js/date.rs b/rust/logs-ingestion/src/js/date.rsnew file mode 100644index 000000000000..213c5803c630--- /dev/null+++ b/rust/logs-ingestion/src/js/date.rs@@ -0,0 +1,849 @@+//! V8 tries the ES5 ISO format, then a lenient legacy parser, so both are ported. The consumer runs with `TZ=UTC`, so local time is UTC.++const NONE: i64 = i64::MIN;+/// V8 checks some composed values against the 31-bit small-integer range of a pointer-compressed build.+const SMI_MAX: i64 = (1 << 30) - 1;+const SMI_MIN: i64 = -(1 << 30);++#[derive(Clone, Copy, Debug, PartialEq)]+enum KeywordType {+ Invalid,+ MonthName,+ TimeZoneName,+ TimeSeparator,+ AmPm,+}++#[derive(Clone, Copy, Debug)]+enum Token {+ Invalid,+ Unknown,+ Number {+ value: i64,+ length: usize,+ },+ Symbol(char),+ WhiteSpace,+ Keyword {+ kind: KeywordType,+ value: i64,+ length: usize,+ },+ End,+}++impl Token {+ fn is_number(&self) -> bool {+ matches!(self, Token::Number { .. })+ }+ fn is_fixed_length_number(&self, n: usize) -> bool {+ matches!(self, Token::Number { length, .. } if *length == n)+ }+ fn number(&self) -> i64 {+ match self {+ Token::Number { value, .. } => *value,+ _ => 0,+ }+ }+ fn is_symbol(&self, c: char) -> bool {+ matches!(self, Token::Symbol(s) if *s == c)+ }+ fn is_ascii_sign(&self) -> bool {+ self.is_symbol('+') || self.is_symbol('-')+ }+ fn ascii_sign(&self) -> i64 {+ if self.is_symbol('-') {+ -1+ } else {+ 1+ }+ }+ fn is_end(&self) -> bool {+ matches!(self, Token::End)+ }+ fn is_white_space(&self) -> bool {+ matches!(self, Token::WhiteSpace)+ }+ fn is_keyword_type(&self, kind: KeywordType) -> bool {+ matches!(self, Token::Keyword { kind: k, .. } if *k == kind)+ }+ fn is_keyword_z(&self) -> bool {+ matches!(+ self,+ Token::Keyword {+ kind: KeywordType::TimeZoneName,+ value: 0,+ length: 1+ }+ )+ }+}++/// Words match on their first three lower-cased letters, and a longer word matches only a month name.+const KEYWORDS: &[(&str, KeywordType, i64)] = &[+ ("jan", KeywordType::MonthName, 1),+ ("feb", KeywordType::MonthName, 2),+ ("mar", KeywordType::MonthName, 3),+ ("apr", KeywordType::MonthName, 4),+ ("may", KeywordType::MonthName, 5),+ ("jun", KeywordType::MonthName, 6),+ ("jul", KeywordType::MonthName, 7),+ ("aug", KeywordType::MonthName, 8),+ ("sep", KeywordType::MonthName, 9),+ ("oct", KeywordType::MonthName, 10),+ ("nov", KeywordType::MonthName, 11),+ ("dec", KeywordType::MonthName, 12),+ ("am", KeywordType::AmPm, 0),+ ("pm", KeywordType::AmPm, 12),+ ("ut", KeywordType::TimeZoneName, 0),+ ("utc", KeywordType::TimeZoneName, 0),+ ("z", KeywordType::TimeZoneName, 0),+ ("gmt", KeywordType::TimeZoneName, 0),+ ("cdt", KeywordType::TimeZoneName, -5),+ ("cst", KeywordType::TimeZoneName, -6),+ ("edt", KeywordType::TimeZoneName, -4),+ ("est", KeywordType::TimeZoneName, -5),+ ("mdt", KeywordType::TimeZoneName, -6),+ ("mst", KeywordType::TimeZoneName, -7),+ ("pdt", KeywordType::TimeZoneName, -7),+ ("pst", KeywordType::TimeZoneName, -8),+ ("t", KeywordType::TimeSeparator, 0),+];++fn lookup_keyword(prefix: &[u32; 3], len: usize) -> (KeywordType, i64) {+ for (word, kind, value) in KEYWORDS {+ let mut key = [0u32; 3];+ for (i, c) in word.chars().enumerate() {+ key[i] = c as u32;+ }+ if key == *prefix && (len <= 3 || *kind == KeywordType::MonthName) {+ return (*kind, *value);+ }+ }+ (KeywordType::Invalid, 0)+}++fn is_js_white_space(c: char) -> bool {+ matches!(+ c,+ '\t' | '\u{b}'+ | '\u{c}'+ | ' '+ | '\u{a0}'+ | '\u{feff}'+ | '\n'+ | '\r'+ | '\u{2028}'+ | '\u{2029}'+ ) || (c != '\u{a0}' && c.is_whitespace() && general_category_zs(c))+}++fn general_category_zs(c: char) -> bool {+ matches!(+ c,+ '\u{1680}' | '\u{2000}'..='\u{200a}' | '\u{202f}' | '\u{205f}' | '\u{3000}'+ )+}++struct Tokenizer {+ chars: Vec<char>,+ pos: usize,+ peeked: Option<Token>,+}++impl Tokenizer {+ fn new(input: &str) -> Self {+ Self {+ chars: input.chars().collect(),+ pos: 0,+ peeked: None,+ }+ }++ fn ch(&self) -> Option<char> {+ self.chars.get(self.pos).copied()+ }++ /// Any character from 'A' up, which takes in non-ASCII text.+ fn is_alpha_or_above(c: char) -> bool {+ c >= 'A'+ }++ fn scan(&mut self) -> Token {+ let Some(c) = self.ch() else {+ return Token::End;+ };+ if c.is_ascii_digit() {+ // Skip leading zeros, keep 9 significant digits, and count every digit in the length, as V8 does.+ let start = self.pos;+ while self.ch() == Some('0') {+ self.pos += 1;+ }+ let mut n: i64 = 0;+ let mut significant = 0;+ while let Some(d) = self.ch().filter(char::is_ascii_digit) {+ if significant < 9 {+ n = n * 10 + (d as i64 - '0' as i64);+ }+ significant += 1;+ self.pos += 1;+ }+ return Token::Number {+ value: n,+ length: self.pos - start,+ };+ }+ if matches!(c, ':' | '-' | '+' | '.' | ')') {+ self.pos += 1;+ return Token::Symbol(c);+ }+ if Self::is_alpha_or_above(c) && !is_js_white_space(c) {+ let mut prefix = [0u32; 3];+ let mut len = 0;+ while let Some(w) = self+ .ch()+ .filter(|w| Self::is_alpha_or_above(*w) && !is_js_white_space(*w))+ {+ if len < 3 {+ prefix[len] = (w as u32) | 0x20;+ }+ len += 1;+ self.pos += 1;+ }+ let (kind, value) = lookup_keyword(&prefix, len);+ return Token::Keyword {+ kind,+ value,+ length: len,+ };+ }+ if is_js_white_space(c) {+ while self.ch().is_some_and(is_js_white_space) {+ self.pos += 1;+ }+ return Token::WhiteSpace;+ }+ if c == '(' {+ let mut balance = 0i32;+ loop {+ match self.ch() {+ Some(')') => balance -= 1,+ Some('(') => balance += 1,+ _ => {}+ }+ self.pos += 1;+ if balance <= 0 || self.ch().is_none() {+ break;+ }+ }+ return Token::Unknown;+ }+ self.pos += 1;+ Token::Unknown+ }++ fn next(&mut self) -> Token {+ match self.peeked.take() {+ Some(t) => t,+ None => self.scan(),+ }+ }++ fn peek(&mut self) -> Token {+ if self.peeked.is_none() {+ self.peeked = Some(self.scan());+ }+ self.peeked.unwrap()+ }++ fn skip_symbol(&mut self, c: char) -> bool {+ if self.peek().is_symbol(c) {+ self.next();+ true+ } else {+ false+ }+ }+}++#[derive(Default)]+struct DayComposer {+ comp: [i64; 3],+ index: usize,+ named_month: Option<i64>,+ is_iso_date: bool,+}++impl DayComposer {+ fn is_empty(&self) -> bool {+ self.index == 0+ }+ fn add(&mut self, n: i64) -> bool {+ if self.index < 3 {+ self.comp[self.index] = n;+ self.index += 1;+ true+ } else {+ false+ }+ }+ fn is_month(n: i64) -> bool {+ (1..=12).contains(&n)+ }+ fn is_day(n: i64) -> bool {+ (1..=31).contains(&n)+ }+ fn write(&mut self) -> Option<(i64, i64, i64)> {+ if self.index < 1 {+ return None;+ }+ while self.index < 3 {+ self.comp[self.index] = 1;+ self.index += 1;+ }+ let (mut year, month, day);+ match self.named_month {+ None => {+ if self.is_iso_date || !Self::is_day(self.comp[0]) {+ year = self.comp[0];+ month = self.comp[1];+ day = self.comp[2];+ } else {+ month = self.comp[0];+ day = self.comp[1];+ year = self.comp[2];+ }+ }+ Some(named) => {+ month = named;+ if !Self::is_day(self.comp[0]) {+ year = self.comp[0];+ day = self.comp[1];+ } else {+ day = self.comp[0];+ year = self.comp[1];+ }+ }+ }+ if !self.is_iso_date {+ if (0..=49).contains(&year) {+ year += 2000;+ } else if (50..=99).contains(&year) {+ year += 1900;+ }+ }+ if !(SMI_MIN..=SMI_MAX).contains(&year) || !Self::is_month(month) || !Self::is_day(day) {+ return None;+ }+ Some((year, month - 1, day))+ }+}++#[derive(Default)]+struct TimeComposer {+ comp: [i64; 4],+ index: usize,+ hour_offset: Option<i64>,+}++impl TimeComposer {+ fn is_empty(&self) -> bool {+ self.index == 0+ }+ fn is_expecting(&self, n: i64) -> bool {+ (self.index == 1 && Self::is_minute(n))+ || (self.index == 2 && Self::is_second(n))+ || (self.index == 3 && Self::is_millisecond(n))+ }+ fn add(&mut self, n: i64) -> bool {+ if self.index < 4 {+ self.comp[self.index] = n;+ self.index += 1;+ true+ } else {+ false+ }+ }+ fn add_final(&mut self, n: i64) -> bool {+ if !self.add(n) {+ return false;+ }+ while self.index < 4 {+ self.comp[self.index] = 0;+ self.index += 1;+ }+ true+ }+ fn is_hour(n: i64) -> bool {+ (0..=23).contains(&n)+ }+ fn is_minute(n: i64) -> bool {+ (0..=59).contains(&n)+ }+ fn is_second(n: i64) -> bool {+ (0..=59).contains(&n)+ }+ fn is_hour12(n: i64) -> bool {+ (0..=12).contains(&n)+ }+ fn is_millisecond(n: i64) -> bool {+ (0..=999).contains(&n)+ }+ fn write(&mut self) -> Option<(i64, i64, i64, i64)> {+ while self.index < 4 {+ self.comp[self.index] = 0;+ self.index += 1;+ }+ let [mut hour, minute, second, ms] = self.comp;+ if let Some(offset) = self.hour_offset {+ if !Self::is_hour12(hour) {+ return None;+ }+ hour %= 12;+ hour += offset;+ }+ if !Self::is_hour(hour)+ || !Self::is_minute(minute)+ || !Self::is_second(second)+ || !Self::is_millisecond(ms)+ {+ // A 24th hour is allowed if minutes, seconds, and milliseconds are 0.+ if hour != 24 || minute != 0 || second != 0 || ms != 0 {+ return None;+ }+ }+ Some((hour, minute, second, ms))+ }+}++struct TimeZoneComposer {+ sign: i64,+ hour: i64,+ minute: i64,+}++impl Default for TimeZoneComposer {+ fn default() -> Self {+ Self {+ sign: NONE,+ hour: NONE,+ minute: NONE,+ }+ }+}++impl TimeZoneComposer {+ fn set(&mut self, offset_hours: i64) {+ self.sign = if offset_hours < 0 { -1 } else { 1 };+ self.hour = offset_hours.abs();+ self.minute = 0;+ }+ fn is_expecting(&self, n: i64) -> bool {+ self.hour != NONE && self.minute == NONE && TimeComposer::is_minute(n)+ }+ fn is_utc(&self) -> bool {+ self.hour == 0 && self.minute == 0+ }+ fn is_empty(&self) -> bool {+ self.hour == NONE+ }+ /// Seconds east of UTC, `None` for local time, or `Err` when the offset is out of range.+ fn write(&mut self) -> Result<Option<i64>, ()> {+ if self.sign == NONE {+ return Ok(None);+ }+ if self.hour == NONE {+ self.hour = 0;+ }+ if self.minute == NONE {+ self.minute = 0;+ }+ let total = self.sign * (self.hour * 3600 + self.minute * 60);+ if !(SMI_MIN..=SMI_MAX).contains(&total) {+ return Err(());+ }+ Ok(Some(total))+ }+}++fn read_milliseconds(token: Token) -> i64 {+ let Token::Number { value, length } = token else {+ return 0;+ };+ let mut number = value;+ let mut length = length;+ if length < 3 {+ if length == 1 {+ number *= 100;+ } else if length == 2 {+ number *= 10;+ }+ } else if length > 3 {+ length = length.min(9);+ let mut factor = 1;+ while length > 3 {+ factor *= 10;+ length -= 1;+ }+ number /= factor;+ }+ number+}++/// Returns the first token it did not handle, `End` for a whole ES5 date, or `Invalid` for a strict rejection.+fn parse_es5(+ s: &mut Tokenizer,+ day: &mut DayComposer,+ time: &mut TimeComposer,+ tz: &mut TimeZoneComposer,+) -> Token {+ if s.peek().is_ascii_sign() {+ let sign_token = s.next();+ if !s.peek().is_fixed_length_number(6) {+ return sign_token;+ }+ let sign = sign_token.ascii_sign();+ let year = s.next().number();+ if sign < 0 && year == 0 {+ return sign_token;+ }+ day.add(sign * year);+ } else if s.peek().is_fixed_length_number(4) {+ day.add(s.next().number());+ } else {+ return s.next();+ }+ if s.skip_symbol('-') {+ if !s.peek().is_fixed_length_number(2) || !DayComposer::is_month(s.peek().number()) {+ return s.next();+ }+ day.add(s.next().number());+ if s.skip_symbol('-') {+ if !s.peek().is_fixed_length_number(2) || !DayComposer::is_day(s.peek().number()) {+ return s.next();+ }+ day.add(s.next().number());+ }+ }+ if !s.peek().is_keyword_type(KeywordType::TimeSeparator) {+ if !s.peek().is_end() {+ return s.next();+ }+ } else {+ s.next();+ if !s.peek().is_fixed_length_number(2) || !(0..=24).contains(&s.peek().number()) {+ return Token::Invalid;+ }+ let hour_is_24 = s.peek().number() == 24;+ time.add(s.next().number());+ if !s.skip_symbol(':') {+ return Token::Invalid;+ }+ if !s.peek().is_fixed_length_number(2)+ || !TimeComposer::is_minute(s.peek().number())+ || (hour_is_24 && s.peek().number() > 0)+ {+ return Token::Invalid;+ }+ time.add(s.next().number());+ if s.skip_symbol(':') {+ if !s.peek().is_fixed_length_number(2)+ || !TimeComposer::is_second(s.peek().number())+ || (hour_is_24 && s.peek().number() > 0)+ {+ return Token::Invalid;+ }+ time.add(s.next().number());+ if s.skip_symbol('.') {+ if !s.peek().is_number() || (hour_is_24 && s.peek().number() > 0) {+ return Token::Invalid;+ }+ time.add(read_milliseconds(s.next()));+ }+ }+ if s.peek().is_keyword_z() {+ s.next();+ tz.set(0);+ } else if s.peek().is_ascii_sign() {+ tz.sign = s.next().ascii_sign();+ if s.peek().is_fixed_length_number(4) {+ let hourmin = s.next().number();+ let hour = hourmin / 100;+ let minute = hourmin % 100;+ if !TimeComposer::is_hour(hour) || !TimeComposer::is_minute(minute) {+ return Token::Invalid;+ }+ tz.hour = hour;+ tz.minute = minute;+ } else {+ if !s.peek().is_fixed_length_number(2) || !TimeComposer::is_hour(s.peek().number())+ {+ return Token::Invalid;+ }+ tz.hour = s.next().number();+ if !s.skip_symbol(':') {+ return Token::Invalid;+ }+ if !s.peek().is_fixed_length_number(2)+ || !TimeComposer::is_minute(s.peek().number())+ {+ return Token::Invalid;+ }+ tz.minute = s.next().number();+ }+ }+ if !s.peek().is_end() {+ return Token::Invalid;+ }+ }+ // A date-only form without a zone is UTC; a date-time form is local time.+ if tz.is_empty() && time.is_empty() {+ tz.set(0);+ }+ day.is_iso_date = true;+ Token::End+}++fn parse_components(input: &str) -> Option<f64> {+ let mut s = Tokenizer::new(input);+ let mut day = DayComposer::default();+ let mut time = TimeComposer::default();+ let mut tz = TimeZoneComposer::default();++ let mut token = parse_es5(&mut s, &mut day, &mut time, &mut tz);+ if matches!(token, Token::Invalid) {+ return None;+ }+ let mut has_read_number = !day.is_empty();+ while !token.is_end() {+ match token {+ Token::Number { value: n, .. } => {+ has_read_number = true;+ if s.skip_symbol(':') {+ if s.skip_symbol(':') {+ if !time.is_empty() {+ return None;+ }+ time.add(n);+ time.add(0);+ } else {+ if !time.add(n) {+ return None;+ }+ if s.peek().is_symbol('.') {+ s.next();+ }+ }+ } else if s.skip_symbol('.') && time.is_expecting(n) {+ // V8 consumes the '.' even when the time does not expect this number.+ time.add(n);+ if !s.peek().is_number() {+ return None;+ }+ let ms = read_milliseconds(s.next());+ if ms < 0 {+ return None;+ }+ time.add_final(ms);+ } else if tz.is_expecting(n) {+ tz.minute = n;+ } else if time.is_expecting(n) {+ time.add_final(n);+ let peek = s.peek();+ if !peek.is_end()+ && !peek.is_white_space()+ && !peek.is_keyword_z()+ && !peek.is_ascii_sign()+ {+ return None;+ }+ } else {+ if !day.add(n) {+ return None;+ }+ s.skip_symbol('-');+ }+ }+ Token::Keyword { kind, value, .. } => {+ if kind == KeywordType::AmPm && !time.is_empty() {+ time.hour_offset = Some(value);+ } else if kind == KeywordType::MonthName {+ day.named_month = Some(value);+ s.skip_symbol('-');+ } else if kind == KeywordType::TimeZoneName && has_read_number {+ tz.set(value);+ } else {+ // Garbage words are illegal after a number, and the first number must be separated from them.+ if has_read_number || s.peek().is_number() {+ return None;+ }+ }+ }+ t if t.is_ascii_sign() && (tz.is_utc() || !time.is_empty()) => {+ tz.sign = t.ascii_sign();+ let mut n = 0;+ let mut length = 0;+ if s.peek().is_number() {+ if let Token::Number { value, length: l } = s.next() {+ n = value;+ length = l;+ }+ }+ has_read_number = true;+ if s.peek().is_symbol(':') {+ tz.hour = n;+ tz.minute = NONE;+ } else if length == 1 || length == 2 {+ tz.hour = n;+ tz.minute = 0;+ } else if length == 3 || length == 4 {+ tz.hour = n / 100;+ tz.minute = n % 100;+ } else {+ return None;+ }+ }+ t if (t.is_ascii_sign() || t.is_symbol(')')) && has_read_number => return None,+ _ => {}+ }+ token = s.next();+ }++ let (year, month, day_of_month) = day.write()?;+ let (hour, minute, second, ms) = time.write()?;+ let offset_seconds = tz.write().ok()?;+ let days = make_day(year as f64, month as f64, day_of_month as f64);+ let time_ms = ((hour * 60 + minute) * 60 + second) as f64 * 1000.0 + ms as f64;+ let mut date = days * 86_400_000.0 + time_ms;+ if let Some(offset) = offset_seconds {+ date -= offset as f64 * 1000.0;+ }+ if !date.is_finite() || date.abs() > 8.64e15 {+ return None;+ }+ Some(date)+}++fn make_day(year: f64, month: f64, date: f64) -> f64 {+ let ym = year + (month / 12.0).floor();+ let mn = month.rem_euclid(12.0) as i64;+ days_from_civil(ym as i64, mn + 1, 1) as f64 + date - 1.0+}++fn days_from_civil(y: i64, m: i64, d: i64) -> i64 {+ let y = if m <= 2 { y - 1 } else { y };+ let era = if y >= 0 { y } else { y - 399 } / 400;+ let yoe = y - era * 400;+ let mp = (m + 9) % 12;+ let doy = (153 * mp + 2) / 5 + d - 1;+ let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;+ era * 146_097 + doe - 719_468+}++pub fn date_parse(input: &str) -> Option<f64> {+ parse_utc_iso_millis(input).or_else(|| parse_components(input))+}++/// A fast path for the `toISOString` form that producers send. `None` hands anything else to the full parser.+fn parse_utc_iso_millis(input: &str) -> Option<f64> {+ let b = input.as_bytes();+ if b.len() != 24 {+ return None;+ }+ for (i, &c) in b.iter().enumerate() {+ let ok = match i {+ 4 | 7 => c == b'-',+ 10 => c == b'T',+ 13 | 16 => c == b':',+ 19 => c == b'.',+ 23 => c == b'Z',+ _ => c.is_ascii_digit(),+ };+ if !ok {+ return None;+ }+ }+ let num = |from: usize, to: usize| {+ b[from..to]+ .iter()+ .fold(0i64, |n, &d| n * 10 + i64::from(d - b'0'))+ };+ let (year, month, day) = (num(0, 4), num(5, 7), num(8, 10));+ let (hour, minute, second, ms) = (num(11, 13), num(14, 16), num(17, 19), num(20, 23));+ if !DayComposer::is_month(month)+ || !DayComposer::is_day(day)+ || !TimeComposer::is_minute(minute)+ || !TimeComposer::is_second(second)+ || !(TimeComposer::is_hour(hour) || (hour == 24 && minute == 0 && second == 0 && ms == 0))+ {+ return None;+ }+ let days = make_day(year as f64, (month - 1) as f64, day as f64);+ let time_ms = ((hour * 60 + minute) * 60 + second) as f64 * 1000.0 + ms as f64;+ let date = days * 86_400_000.0 + time_ms;+ if !date.is_finite() || date.abs() > 8.64e15 {+ return None;+ }+ Some(date)+}++#[cfg(test)]+mod tests {+ use super::{date_parse, parse_components};++ #[test]+ fn the_iso_fast_path_agrees_with_the_full_parser() {+ let mut state = 0x2545_f491_4f6c_dd1du64;+ let template = b"0000-00-00T00:00:00.000Z";+ for _ in 0..200_000 {+ let mut text = *template;+ for (i, c) in text.iter_mut().enumerate() {+ state ^= state << 13;+ state ^= state >> 7;+ state ^= state << 17;+ if c.is_ascii_digit() {+ // Mostly the low digits that make valid fields, sometimes any digit.+ let range = if i < 4 || state.is_multiple_of(4) {+ 10+ } else {+ 3+ };+ *c = b'0' + (state >> 8) as u8 % range;+ }+ }+ let text = std::str::from_utf8(&text).unwrap();+ assert_eq!(date_parse(text), parse_components(text), "{text}");+ }+ }++ #[test]+ fn parses_common_forms() {+ assert_eq!(+ date_parse("2025-01-15T12:00:00.000Z"),+ Some(1736942400000.0)+ );+ assert_eq!(+ date_parse("Wed, 15 Jan 2025 12:00:00 GMT"),+ Some(1736942400000.0)+ );+ assert_eq!(+ date_parse("Jan 15 2025 12:00:00 PM GMT+0100"),+ Some(1736938800000.0)+ );+ assert_eq!(date_parse("2025-02-30T00:00:00Z"), Some(1740873600000.0));+ assert_eq!(date_parse("1970-01-01T00:00:00Z"), Some(0.0));+ assert_eq!(date_parse("1969-12-31T23:59:59.999Z"), Some(-1.0));+ assert_eq!(date_parse("2025-01-15T24:00:00Z"), Some(1736985600000.0));+ assert_eq!(date_parse("2025-01-15T24:01:00Z"), None);+ assert_eq!(date_parse("2025-13-01"), None);+ // V8 skips a word before the first number, so this is 2025-01-01.+ assert_eq!(date_parse("garbage 2025"), Some(1735689600000.0));+ assert_eq!(date_parse("garbage2025"), None);+ // Leading zeros are skipped, and only 9 significant digits are kept.+ assert_eq!(+ date_parse("-0800 12:00:00.1234561970"),+ Some(-36921614399877.0)+ );+ assert_eq!(date_parse("Jan 15 0000000000002025"), Some(1736899200000.0));+ }+}diff --git a/rust/logs-ingestion/src/js/json.rs b/rust/logs-ingestion/src/js/json.rsnew file mode 100644index 000000000000..a2a83d201c50--- /dev/null+++ b/rust/logs-ingestion/src/js/json.rs@@ -0,0 +1,624 @@+use thiserror::Error;++use super::number::write_number;+use super::{JsKey, JsObject, JsString, JsValue};++#[derive(Debug, Error, PartialEq, Eq)]+#[error("invalid JSON at byte {0}")]+pub struct JsonError(pub usize);++/// A deeper value would overflow the stack when dropped or walked, so it builds as an empty array. Every reader stops first.+pub const MAX_BUILT_DEPTH: usize = 512;++/// Accepts and rejects exactly what V8 does at any nesting depth.+pub fn json_parse(text: &str) -> Result<JsValue, JsonError> {+ let mut parser = Parser {+ bytes: text.as_bytes(),+ text,+ pos: 0,+ depth: 0,+ };+ parser.skip_ws();+ let value = parser.value()?;+ parser.skip_ws();+ if parser.pos != parser.bytes.len() {+ return Err(JsonError(parser.pos));+ }+ Ok(value)+}++#[derive(Debug, Clone, PartialEq)]+pub enum JsonShape {+ /// A string value is kept only for the keys the caller asked for, and `None` stands for any other value.+ Object(Vec<(JsString, Option<JsString>)>),+ Array,+ String(JsString),+ Primitive,+}++pub fn json_parse_shape(+ text: &str,+ keep_value: impl Fn(&JsString) -> bool,+) -> Result<JsonShape, JsonError> {+ let mut parser = Parser {+ bytes: text.as_bytes(),+ text,+ pos: 0,+ depth: 0,+ };+ parser.skip_ws();+ let shape = match parser.bytes.get(parser.pos) {+ Some(b'{') => JsonShape::Object(parser.object_entries(keep_value)?),+ Some(b'[') => {+ parser.skip_value()?;+ JsonShape::Array+ }+ Some(b'"') => JsonShape::String(parser.string()?),+ _ => {+ parser.skip_value()?;+ JsonShape::Primitive+ }+ };+ parser.skip_ws();+ if parser.pos != parser.bytes.len() {+ return Err(JsonError(parser.pos));+ }+ Ok(shape)+}++struct Parser<'a> {+ bytes: &'a [u8],+ text: &'a str,+ pos: usize,+ depth: usize,+}++impl Parser<'_> {+ fn err<T>(&self) -> Result<T, JsonError> {+ Err(JsonError(self.pos))+ }++ /// JSON whitespace is only space, tab, line feed and carriage return; a BOM is an error.+ fn skip_ws(&mut self) {+ while let Some(b) = self.bytes.get(self.pos) {+ if matches!(b, b' ' | b'\t' | b'\n' | b'\r') {+ self.pos += 1;+ } else {+ break;+ }+ }+ }++ fn eat(&mut self, lit: &str) -> Result<(), JsonError> {+ if self.bytes[self.pos..].starts_with(lit.as_bytes()) {+ self.pos += lit.len();+ Ok(())+ } else {+ self.err()+ }+ }++ fn value(&mut self) -> Result<JsValue, JsonError> {+ match self.bytes.get(self.pos) {+ Some(b'{' | b'[') if self.depth >= MAX_BUILT_DEPTH => {+ self.skip_value()?;+ Ok(JsValue::Array(Vec::new()))+ }+ Some(b'{') => self.nested(Self::object),+ Some(b'[') => self.nested(Self::array),+ Some(b'"') => Ok(JsValue::String(self.string()?)),+ Some(b't') => self.eat("true").map(|_| JsValue::Bool(true)),+ Some(b'f') => self.eat("false").map(|_| JsValue::Bool(false)),+ Some(b'n') => self.eat("null").map(|_| JsValue::Null),+ Some(b'-' | b'0'..=b'9') => self.number(),+ _ => self.err(),+ }+ }++ fn nested(+ &mut self,+ parse: fn(&mut Self) -> Result<JsValue, JsonError>,+ ) -> Result<JsValue, JsonError> {+ self.depth += 1;+ let value = parse(self);+ self.depth -= 1;+ value+ }++ fn object(&mut self) -> Result<JsValue, JsonError> {+ self.pos += 1;+ let mut object = JsObject::new();+ self.skip_ws();+ if self.bytes.get(self.pos) == Some(&b'}') {+ self.pos += 1;+ return Ok(JsValue::Object(object));+ }+ loop {+ self.skip_ws();+ if self.bytes.get(self.pos) != Some(&b'"') {+ return self.err();+ }+ let key = self.string()?;+ self.skip_ws();+ if self.bytes.get(self.pos) != Some(&b':') {+ return self.err();+ }+ self.pos += 1;+ self.skip_ws();+ let value = self.value()?;+ // A repeated key keeps its first position and takes the last value.+ object.insert(key, value);+ self.skip_ws();+ match self.bytes.get(self.pos) {+ Some(b',') => self.pos += 1,+ Some(b'}') => {+ self.pos += 1;+ return Ok(JsValue::Object(object));+ }+ _ => return self.err(),+ }+ }+ }++ fn array(&mut self) -> Result<JsValue, JsonError> {+ self.pos += 1;+ let mut items = Vec::new();+ self.skip_ws();+ if self.bytes.get(self.pos) == Some(&b']') {+ self.pos += 1;+ return Ok(JsValue::Array(items));+ }+ loop {+ self.skip_ws();+ items.push(self.value()?);+ self.skip_ws();+ match self.bytes.get(self.pos) {+ Some(b',') => self.pos += 1,+ Some(b']') => {+ self.pos += 1;+ return Ok(JsValue::Array(items));+ }+ _ => return self.err(),+ }+ }+ }++ fn object_entries(+ &mut self,+ keep_value: impl Fn(&JsString) -> bool,+ ) -> Result<Vec<(JsString, Option<JsString>)>, JsonError> {+ self.pos += 1;+ let mut entries = Vec::new();+ self.skip_ws();+ if self.bytes.get(self.pos) == Some(&b'}') {+ self.pos += 1;+ return Ok(entries);+ }+ loop {+ self.skip_ws();+ if self.bytes.get(self.pos) != Some(&b'"') {+ return self.err();+ }+ let key = self.string()?;+ self.skip_ws();+ if self.bytes.get(self.pos) != Some(&b':') {+ return self.err();+ }+ self.pos += 1;+ self.skip_ws();+ let value = if self.bytes.get(self.pos) == Some(&b'"') && keep_value(&key) {+ Some(self.string()?)+ } else {+ self.skip_value()?;+ None+ };+ entries.push((key, value));+ self.skip_ws();+ match self.bytes.get(self.pos) {+ Some(b',') => self.pos += 1,+ Some(b'}') => {+ self.pos += 1;+ return Ok(entries);+ }+ _ => return self.err(),+ }+ }+ }++ /// The open containers are on a heap stack, so any nesting depth is safe.+ fn skip_value(&mut self) -> Result<(), JsonError> {+ let mut open: Vec<u8> = Vec::new();+ loop {+ match self.bytes.get(self.pos) {+ Some(b'{') => {+ self.pos += 1;+ self.skip_ws();+ if self.bytes.get(self.pos) == Some(&b'}') {+ self.pos += 1;+ } else {+ self.skip_key()?;+ open.push(b'}');+ continue;+ }+ }+ Some(b'[') => {+ self.pos += 1;+ self.skip_ws();+ if self.bytes.get(self.pos) == Some(&b']') {+ self.pos += 1;+ } else {+ open.push(b']');+ continue;+ }+ }+ Some(b'"') => self.skip_string()?,+ Some(b't') => self.eat("true")?,+ Some(b'f') => self.eat("false")?,+ Some(b'n') => self.eat("null")?,+ // Every number the grammar accepts parses to a double, so only the grammar is checked.+ Some(b'-' | b'0'..=b'9') => {+ self.scan_number()?;+ }+ _ => return self.err(),+ }+ loop {+ let Some(&close) = open.last() else {+ return Ok(());+ };+ self.skip_ws();+ match self.bytes.get(self.pos) {+ Some(b',') => {+ self.pos += 1;+ self.skip_ws();+ if close == b'}' {+ self.skip_key()?;+ }+ break;+ }+ Some(&b) if b == close => {+ self.pos += 1;+ open.pop();+ }+ _ => return self.err(),+ }+ }+ }+ }++ fn skip_key(&mut self) -> Result<(), JsonError> {+ if self.bytes.get(self.pos) != Some(&b'"') {+ return self.err();+ }+ self.skip_string()?;+ self.skip_ws();+ if self.bytes.get(self.pos) != Some(&b':') {+ return self.err();+ }+ self.pos += 1;+ self.skip_ws();+ Ok(())+ }++ fn skip_string(&mut self) -> Result<(), JsonError> {+ self.pos += 1;+ loop {+ while let Some(&b) = self.bytes.get(self.pos) {+ if b == b'"' || b == b'\\' || b < 0x20 {+ break;+ }+ self.pos += 1;+ }+ match self.bytes.get(self.pos) {+ Some(b'"') => {+ self.pos += 1;+ return Ok(());+ }+ Some(b'\\') => {+ self.pos += 1;+ let escape = *self.bytes.get(self.pos).ok_or(JsonError(self.pos))?;+ self.pos += 1;+ match escape {+ b'"' | b'\\' | b'/' | b'b' | b'f' | b'n' | b'r' | b't' => {}+ b'u' => {+ self.hex4()?;+ }+ _ => return self.err(),+ }+ }+ _ => return self.err(),+ }+ }+ }++ fn digits(&mut self) -> usize {+ let start = self.pos;+ while matches!(self.bytes.get(self.pos), Some(b'0'..=b'9')) {+ self.pos += 1;+ }+ self.pos - start+ }++ fn scan_number(&mut self) -> Result<usize, JsonError> {+ let start = self.pos;+ if self.bytes[self.pos] == b'-' {+ self.pos += 1;+ }+ match self.bytes.get(self.pos) {+ Some(b'0') => self.pos += 1,+ Some(b'1'..=b'9') => {+ self.digits();+ }+ _ => return self.err(),+ }+ if self.bytes.get(self.pos) == Some(&b'.') {+ self.pos += 1;+ if self.digits() == 0 {+ return self.err();+ }+ }+ if matches!(self.bytes.get(self.pos), Some(b'e' | b'E')) {+ self.pos += 1;+ if matches!(self.bytes.get(self.pos), Some(b'+' | b'-')) {+ self.pos += 1;+ }+ if self.digits() == 0 {+ return self.err();+ }+ }+ Ok(start)+ }++ fn number(&mut self) -> Result<JsValue, JsonError> {+ let start = self.scan_number()?;+ // Rust parses decimal strings to the nearest f64, as V8 does.+ let n: f64 = self.text[start..self.pos]+ .parse()+ .map_err(|_| JsonError(start))?;+ Ok(JsValue::Number(n))+ }++ fn hex4(&mut self) -> Result<u16, JsonError> {+ let slice = self+ .bytes+ .get(self.pos..self.pos + 4)+ .ok_or(JsonError(self.pos))?;+ let s = std::str::from_utf8(slice).map_err(|_| JsonError(self.pos))?;+ if !s.bytes().all(|b| b.is_ascii_hexdigit()) {+ return self.err();+ }+ self.pos += 4;+ Ok(u16::from_str_radix(s, 16).expect("checked hex"))+ }++ fn string(&mut self) -> Result<JsString, JsonError> {+ self.pos += 1;+ let mut out = JsString::new();+ loop {+ let run_start = self.pos;+ while let Some(&b) = self.bytes.get(self.pos) {+ if b == b'"' || b == b'\\' || b < 0x20 {+ break;+ }+ self.pos += 1;+ }+ out.push_str(&self.text[run_start..self.pos]);+ match self.bytes.get(self.pos) {+ Some(b'"') => {+ self.pos += 1;+ return Ok(out);+ }+ Some(b'\\') => {+ self.pos += 1;+ let escape = *self.bytes.get(self.pos).ok_or(JsonError(self.pos))?;+ self.pos += 1;+ match escape {+ b'"' => out.push('"'),+ b'\\' => out.push('\\'),+ b'/' => out.push('/'),+ b'b' => out.push('\u{8}'),+ b'f' => out.push('\u{c}'),+ b'n' => out.push('\n'),+ b'r' => out.push('\r'),+ b't' => out.push('\t'),+ b'u' => {+ let unit = self.hex4()?;+ out.push_code_unit(unit);+ }+ _ => return self.err(),+ }+ }+ _ => return self.err(),+ }+ }+ }+}++pub fn json_stringify(value: &JsValue) -> String {+ let mut out = String::new();+ json_stringify_into(value, &mut out);+ out+}++pub fn json_stringify_into(value: &JsValue, out: &mut String) {+ match value {+ JsValue::Null => out.push_str("null"),+ JsValue::Bool(b) => out.push_str(if *b { "true" } else { "false" }),+ JsValue::Number(n) => {+ if n.is_finite() {+ write_number(*n, out)+ } else {+ out.push_str("null")+ }+ }+ JsValue::String(s) => quote_js_string(s, out),+ JsValue::Array(items) => {+ out.push('[');+ for (i, item) in items.iter().enumerate() {+ if i > 0 {+ out.push(',');+ }+ json_stringify_into(item, out);+ }+ out.push(']');+ }+ JsValue::Object(object) => {+ out.push('{');+ for (i, (key, item)) in object.entries().enumerate() {+ if i > 0 {+ out.push(',');+ }+ match key {+ JsKey::Index(n) => {+ out.push('"');+ out.push_str(itoa::Buffer::new().format(n));+ out.push('"');+ }+ JsKey::Named(key) => quote_js_string(key, out),+ }+ out.push(':');+ json_stringify_into(item, out);+ }+ out.push('}');+ }+ }+}++fn push_escape(c: u32, out: &mut String) {+ use std::fmt::Write;+ match c {+ 0x22 => out.push_str("\\\""),+ 0x5C => out.push_str("\\\\"),+ 0x08 => out.push_str("\\b"),+ 0x0C => out.push_str("\\f"),+ 0x0A => out.push_str("\\n"),+ 0x0D => out.push_str("\\r"),+ 0x09 => out.push_str("\\t"),+ _ => {+ let _ = write!(out, "\\u{c:04x}");+ }+ }+}++/// Lone surrogates are written as `\udXXX`, as in well-formed `JSON.stringify` (ES2019).+pub fn quote_js_string(s: &JsString, out: &mut String) {+ out.push('"');+ match s.as_str() {+ Some(text) => quote_str_body(text, out),+ None => {+ for unit in s.chars_or_surrogates() {+ match unit.as_char() {+ Ok(c) => {+ let mut buf = [0u8; 4];+ quote_str_body(c.encode_utf8(&mut buf), out);+ }+ Err(surrogate) => push_escape(surrogate as u32, out),+ }+ }+ }+ }+ out.push('"');+}++fn quote_str_body(text: &str, out: &mut String) {+ let bytes = text.as_bytes();+ let mut run = 0;+ for (i, &b) in bytes.iter().enumerate() {+ if b < 0x20 || b == b'"' || b == b'\\' {+ out.push_str(&text[run..i]);+ push_escape(b as u32, out);+ run = i + 1;+ }+ }+ out.push_str(&text[run..]);+}++#[cfg(test)]+mod tests {+ use super::*;++ fn roundtrip(text: &str) -> String {+ json_stringify(&json_parse(text).unwrap())+ }++ #[test]+ fn parse_matches_v8() {+ assert_eq!(+ roundtrip(r#"{"dup":1,"b":2,"dup":3}"#),+ r#"{"dup":3,"b":2}"#+ );+ assert_eq!(+ roundtrip(r#"{"b":1,"1":2,"0":3}"#),+ r#"{"0":3,"1":2,"b":1}"#+ );+ assert_eq!(+ roundtrip(r#"{"__proto__":{"x":1}}"#),+ r#"{"__proto__":{"x":1}}"#+ );+ assert_eq!(roundtrip("12345678901234567890"), "12345678901234567000");+ assert_eq!(roundtrip("-0"), "0");+ assert_eq!(roundtrip(" [1 , 2]\n"), "[1,2]");+ assert_eq!(roundtrip(r#""🚀""#), "\"🚀\"");+ assert_eq!(roundtrip(r#""\ud83d""#), r#""\ud83d""#);+ for bad in [+ "\u{feff}{}",+ "{\"a\":1,}",+ "{'a':1}",+ "01",+ "1.",+ ".5",+ "+1",+ "\"\t\"",+ "",+ "nul",+ "[1,]",+ "\u{a0}1",+ "NaN",+ ] {+ assert!(json_parse(bad).is_err(), "{bad:?}");+ }+ }++ // V8 parses any depth. A deep body must not overflow the stack, and the flatten skips it.+ #[test]+ fn deep_nesting_parses_like_v8_without_overflow() {+ let n = 100_000;+ let deep_array = format!("{}{}", "[".repeat(n), "]".repeat(n));+ let deep_object = format!("{}1{}", r#"{"a":"#.repeat(n), "}".repeat(n));+ for text in [&deep_array, &deep_object] {+ assert!(json_parse(text).is_ok());+ assert!(json_parse_shape(text, |_| false).is_ok());+ assert!(crate::normalize::extract_json_attributes_from_body(Some(text)).is_empty());+ }+ let unclosed = "[".repeat(n);+ assert!(json_parse(&unclosed).is_err());+ assert!(json_parse_shape(&unclosed, |_| false).is_err());+ let bad_tail = format!("{}1,]{}", "[".repeat(n), "]".repeat(n - 1));+ assert!(json_parse(&bad_tail).is_err());+ }++ #[test]+ fn stringify_escapes_like_v8() {+ let s = JsValue::string("q\" b\\ \u{8}\u{c}\n\r\t \u{0} \u{1f} \u{7f} \u{2028}\u{2029} é");+ assert_eq!(+ json_stringify(&s),+ "\"q\\\" b\\\\ \\b\\f\\n\\r\\t \\u0000 \\u001f \u{7f} \u{2028}\u{2029} é\""+ );+ }++ #[test]+ fn stringify_numbers_like_v8() {+ for (n, expected) in [+ (1e21, "1e+21"),+ (1e-7, "1e-7"),+ (0.1 + 0.2, "0.30000000000000004"),+ (-0.0, "0"),+ (5e-324, "5e-324"),+ (9007199254740993.0, "9007199254740992"),+ (123e20, "1.23e+22"),+ (f64::NAN, "null"),+ (f64::INFINITY, "null"),+ ] {+ assert_eq!(json_stringify(&JsValue::Number(n)), expected);+ }+ }+}diff --git a/rust/logs-ingestion/src/js/mod.rs b/rust/logs-ingestion/src/js/mod.rsnew file mode 100644index 000000000000..1225be19c6c4--- /dev/null+++ b/rust/logs-ingestion/src/js/mod.rs@@ -0,0 +1,44 @@+//! Rust defaults differ from `JSON.parse`, `JSON.stringify`, JS key order, UTF-16 lengths and `Date.parse`, so outputs go through this module.++mod date;+mod json;+mod number;+pub(crate) mod object;+mod string;++pub use date::date_parse;+pub use json::{+ json_parse, json_parse_shape, json_stringify, json_stringify_into, quote_js_string, JsonError,+ JsonShape, MAX_BUILT_DEPTH,+};+pub use number::{number_to_string, write_number};+pub use object::{is_array_index, JsKey, JsObject};+pub use string::{utf16_len, utf16_prefix_lossy, utf16_slice_lossy, CharOrSurrogate, JsString};++#[derive(Debug, Clone, PartialEq)]+pub enum JsValue {+ Null,+ Bool(bool),+ Number(f64),+ String(JsString),+ Array(Vec<JsValue>),+ Object(JsObject),+}++impl JsValue {+ /// `typeof value === 'object' && value !== null`, which arrays also pass.+ pub fn is_object_like(&self) -> bool {+ matches!(self, JsValue::Array(_) | JsValue::Object(_))+ }++ pub fn as_js_string(&self) -> Option<&JsString> {+ match self {+ JsValue::String(s) => Some(s),+ _ => None,+ }+ }++ pub fn string(s: &str) -> JsValue {+ JsValue::String(JsString::from(s))+ }+}diff --git a/rust/logs-ingestion/src/js/number.rs b/rust/logs-ingestion/src/js/number.rsnew file mode 100644index 000000000000..ca3ff3b4b90d--- /dev/null+++ b/rust/logs-ingestion/src/js/number.rs@@ -0,0 +1,151 @@+//! ECMAScript breaks a tie between two shortest candidates toward even, so an odd last digit is checked against the exactly rounded form.++use std::fmt::Write;++pub fn number_to_string(value: f64) -> String {+ let mut out = String::new();+ write_number(value, &mut out);+ out+}++/// Below 2^53 every integer is exact, and ECMAScript prints an integer under 1e21 in full.+const EXACT_INTEGER_LIMIT: f64 = 9_007_199_254_740_992.0;++pub fn write_number(value: f64, out: &mut String) {+ if value.is_nan() {+ out.push_str("NaN");+ return;+ }+ if value == 0.0 {+ out.push('0');+ return;+ }+ if value.is_infinite() {+ out.push_str(if value > 0.0 { "Infinity" } else { "-Infinity" });+ return;+ }+ if value.fract() == 0.0 && value.abs() < EXACT_INTEGER_LIMIT {+ out.push_str(itoa::Buffer::new().format(value as i64));+ return;+ }+ if value < 0.0 {+ out.push('-');+ }+ let sci = shortest_scientific(value.abs());+ let sci = sci.as_str();+ let (mantissa, exp) = sci.split_once('e').expect("LowerExp has an exponent");+ let exp: i32 = exp.parse().expect("exponent is an integer");+ let mut digit_buf = [0u8; 32];+ let mut k = 0usize;+ for b in mantissa.bytes().filter(|b| *b != b'.') {+ digit_buf[k] = b;+ k += 1;+ }+ let digits = std::str::from_utf8(&digit_buf[..k]).expect("ASCII digits");+ let k = k as i32;+ // n is the position of the decimal point relative to the digit string.+ let n = exp + 1;+ if k <= n && n <= 21 {+ out.push_str(digits);+ out.extend(std::iter::repeat_n('0', (n - k) as usize));+ } else if 0 < n && n <= 21 {+ out.push_str(&digits[..n as usize]);+ out.push('.');+ out.push_str(&digits[n as usize..]);+ } else if -6 < n && n <= 0 {+ out.push_str("0.");+ out.extend(std::iter::repeat_n('0', (-n) as usize));+ out.push_str(digits);+ } else {+ out.push_str(&digits[..1]);+ if k > 1 {+ out.push('.');+ out.push_str(&digits[1..]);+ }+ out.push('e');+ out.push(if n - 1 < 0 { '-' } else { '+' });+ out.push_str(itoa::Buffer::new().format((n - 1).abs()));+ }+}++/// A fixed buffer for one formatted double, so the slow path does not allocate.+struct StackStr {+ buf: [u8; 64],+ len: usize,+}++impl StackStr {+ fn new() -> Self {+ Self {+ buf: [0; 64],+ len: 0,+ }+ }++ fn as_str(&self) -> &str {+ std::str::from_utf8(&self.buf[..self.len]).expect("formatter writes UTF-8")+ }+}++impl Write for StackStr {+ fn write_str(&mut self, s: &str) -> std::fmt::Result {+ let end = self.len + s.len();+ if end > self.buf.len() {+ return Err(std::fmt::Error);+ }+ self.buf[self.len..end].copy_from_slice(s.as_bytes());+ self.len = end;+ Ok(())+ }+}++fn shortest_scientific(value: f64) -> StackStr {+ let mut shortest = StackStr::new();+ write!(shortest, "{value:e}").expect("a double fits the buffer");+ let mantissa = shortest.as_str().split_once('e').map_or("", |(m, _)| m);+ let last_is_odd = mantissa.bytes().last().is_some_and(|d| (d - b'0') % 2 == 1);+ if !last_is_odd {+ return shortest;+ }+ let digits = mantissa.bytes().filter(u8::is_ascii_digit).count();+ let mut exact = StackStr::new();+ write!(exact, "{:.*e}", digits - 1, value).expect("a double fits the buffer");+ // At a power of two the lower gap is narrower, so the nearest candidate can miss.+ if exact.as_str() != shortest.as_str() && exact.as_str().parse::<f64>() == Ok(value) {+ exact+ } else {+ shortest+ }+}++#[cfg(test)]+mod tests {+ use super::number_to_string;++ #[test]+ fn matches_ecmascript_number_to_string() {+ let cases: &[(f64, &str)] = &[+ (1e21, "1e+21"),+ (1e20, "100000000000000000000"),+ (123e20, "1.23e+22"),+ (1e-7, "1e-7"),+ (1.5e-7, "1.5e-7"),+ (0.000001, "0.000001"),+ (0.1 + 0.2, "0.30000000000000004"),+ (-0.0, "0"),+ (5e-324, "5e-324"),+ (9007199254740993.0, "9007199254740992"),+ (12345678901234567890.0, "12345678901234567000"),+ (1.0, "1"),+ (-3.5, "-3.5"),+ (42.0, "42"),+ (f64::MAX, "1.7976931348623157e+308"),+ (f64::from_bits(0x409a_ab1c_d000_0000), "1706.7781372070312"),+ (f64::from_bits(0x40fd_58f9_f100_0000), "120207.62133789062"),+ (-1417389728594571.2, "-1417389728594571.2"),+ ];+ for (value, expected) in cases {+ assert_eq!(number_to_string(*value), *expected, "{value}");+ }+ }+}diff --git a/rust/logs-ingestion/src/js/object.rs b/rust/logs-ingestion/src/js/object.rsnew file mode 100644index 000000000000..c0e5bb1b7210--- /dev/null+++ b/rust/logs-ingestion/src/js/object.rs@@ -0,0 +1,252 @@+//! Own-property key order: array-index keys first in numeric order, then insertion order. The flatten picks survivors from that order.++use std::collections::BTreeMap;+use std::sync::LazyLock;++use hashbrown::HashTable;++use super::{JsString, JsValue};++/// Keys are sender-controlled, so the hash is seeded per process.+static KEY_HASHER: LazyLock<ahash::RandomState> = LazyLock::new(ahash::RandomState::new);++pub(crate) fn hash_key(key: &JsString) -> u64 {+ KEY_HASHER.hash_one(key.bytes_wtf8())+}++pub(crate) fn hash_str(key: &str) -> u64 {+ KEY_HASHER.hash_one(key.as_bytes())+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum JsKey<'a> {+ Index(u32),+ Named(&'a JsString),+}++impl JsKey<'_> {+ pub fn utf8_byte_len(&self) -> usize {+ match self {+ JsKey::Index(n) => itoa::Buffer::new().format(*n).len(),+ JsKey::Named(k) => k.utf8_byte_len(),+ }+ }++ pub fn push_onto(&self, out: &mut JsString) {+ match self {+ JsKey::Index(n) => out.push_str(itoa::Buffer::new().format(*n)),+ JsKey::Named(k) => out.push_js(k),+ }+ }++ pub fn to_js_string(&self) -> JsString {+ let mut out = JsString::new();+ self.push_onto(&mut out);+ out+ }+}++/// A canonical array index: an integer from 0 to 2^32 - 2 written without a sign or leading zero.+pub fn is_array_index(key: &str) -> Option<u32> {+ let bytes = key.as_bytes();+ if bytes.is_empty() || bytes.len() > 10 || !bytes.iter().all(u8::is_ascii_digit) {+ return None;+ }+ if bytes.len() > 1 && bytes[0] == b'0' {+ return None;+ }+ let n: u64 = key.parse().ok()?;+ if n < u32::MAX as u64 {+ Some(n as u32)+ } else {+ None+ }+}++#[derive(Debug, Clone, Default)]+pub struct JsObject {+ /// Array-index keys. A tree keeps a descending insert order from being quadratic.+ indexed: BTreeMap<u32, JsValue>,+ named: Vec<(JsString, JsValue)>,+ /// Built only for large objects, where a linear key search would be quadratic.+ named_index: Option<HashTable<usize>>,+}++const INDEX_THRESHOLD: usize = 16;++impl JsObject {+ pub fn new() -> Self {+ Self::default()+ }++ pub fn len(&self) -> usize {+ self.indexed.len() + self.named.len()+ }++ pub fn is_empty(&self) -> bool {+ self.len() == 0+ }++ fn named_position(&self, key: &JsString) -> Option<usize> {+ match &self.named_index {+ Some(index) => index+ .find(hash_key(key), |&i| self.named[i].0 == *key)+ .copied(),+ None => self.named.iter().position(|(k, _)| k == key),+ }+ }++ fn build_index(&mut self) {+ let mut index = HashTable::with_capacity(self.named.len());+ for (i, (k, _)) in self.named.iter().enumerate() {+ index.insert_unique(hash_key(k), i, |&j| hash_key(&self.named[j].0));+ }+ self.named_index = Some(index);+ }++ fn index_key(key: &JsString) -> Option<u32> {+ key.as_str().and_then(is_array_index)+ }++ /// `obj[key] = value` on an own data property: an existing key keeps its position.+ pub fn insert(&mut self, key: JsString, value: JsValue) {+ if let Some(n) = Self::index_key(&key) {+ self.indexed.insert(n, value);+ return;+ }+ if let Some(i) = self.named_position(&key) {+ self.named[i].1 = value;+ return;+ }+ if let Some(index) = &mut self.named_index {+ let named = &self.named;+ index.insert_unique(hash_key(&key), named.len(), |&j| hash_key(&named[j].0));+ }+ self.named.push((key, value));+ if self.named_index.is_none() && self.named.len() > INDEX_THRESHOLD {+ self.build_index();+ }+ }++ pub fn insert_str(&mut self, key: &str, value: JsValue) {+ self.insert(JsString::from(key), value)+ }++ pub fn get(&self, key: &str) -> Option<&JsValue> {+ if let Some(n) = is_array_index(key) {+ return self.indexed.get(&n);+ }+ let key = JsString::from(key);+ self.named_position(&key).map(|i| &self.named[i].1)+ }++ pub fn contains_key(&self, key: &str) -> bool {+ self.get(key).is_some()+ }++ pub fn remove(&mut self, key: &str) -> Option<JsValue> {+ if let Some(n) = is_array_index(key) {+ return self.indexed.remove(&n);+ }+ let key = JsString::from(key);+ let i = self.named_position(&key)?;+ let (_, value) = self.named.remove(i);+ if self.named_index.is_some() {+ self.build_index();+ }+ Some(value)+ }++ pub fn iter(&self) -> impl Iterator<Item = (JsString, &JsValue)> + '_ {+ self.indexed+ .iter()+ .map(|(k, v)| (JsString::from(k.to_string()), v))+ .chain(self.named.iter().map(|(k, v)| (k.clone(), v)))+ }++ pub fn entries(&self) -> impl Iterator<Item = (JsKey<'_>, &JsValue)> + '_ {+ self.indexed+ .iter()+ .map(|(k, v)| (JsKey::Index(*k), v))+ .chain(self.named.iter().map(|(k, v)| (JsKey::Named(k), v)))+ }++ pub fn keys(&self) -> impl Iterator<Item = JsString> + '_ {+ self.iter().map(|(k, _)| k)+ }+}++impl PartialEq for JsObject {+ fn eq(&self, other: &Self) -> bool {+ self.indexed == other.indexed && self.named == other.named+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ fn keys(o: &JsObject) -> Vec<String> {+ o.keys().map(|k| k.to_string()).collect()+ }++ #[test]+ fn index_keys_come_first_in_numeric_order() {+ let mut o = JsObject::new();+ for k in [+ "b",+ "10",+ "a",+ "2",+ "01",+ "4294967295",+ "4294967294",+ "-1",+ "0",+ ] {+ o.insert_str(k, JsValue::Null);+ }+ assert_eq!(+ keys(&o),+ [+ "0",+ "2",+ "10",+ "4294967294",+ "b",+ "a",+ "01",+ "4294967295",+ "-1"+ ]+ );+ }++ #[test]+ fn reinsert_keeps_position_and_remove_works() {+ let mut o = JsObject::new();+ o.insert_str("x", JsValue::Number(1.0));+ o.insert_str("y", JsValue::Number(2.0));+ o.insert_str("x", JsValue::Number(3.0));+ assert_eq!(keys(&o), ["x", "y"]);+ assert_eq!(o.get("x"), Some(&JsValue::Number(3.0)));+ o.remove("x");+ o.insert_str("x", JsValue::Null);+ assert_eq!(keys(&o), ["y", "x"]);+ }++ #[test]+ fn large_objects_keep_order_with_the_index() {+ let mut o = JsObject::new();+ for i in 0..100 {+ o.insert_str(&format!("k{}", 99 - i), JsValue::Number(i as f64));+ }+ o.insert_str("k50", JsValue::Null);+ assert_eq!(o.len(), 100);+ assert_eq!(keys(&o)[0], "k99");+ assert_eq!(o.get("k50"), Some(&JsValue::Null));+ o.remove("k99");+ assert_eq!(keys(&o)[0], "k98");+ assert!(o.contains_key("k0"));+ }+}diff --git a/rust/logs-ingestion/src/js/string.rs b/rust/logs-ingestion/src/js/string.rsnew file mode 100644index 000000000000..94cace7a9124--- /dev/null+++ b/rust/logs-ingestion/src/js/string.rs@@ -0,0 +1,376 @@+//! A Rust `String` cannot hold a lone surrogate, so `JsString` stores WTF-8, where a lone surrogate takes its 3-byte form.++use std::borrow::Cow;+use std::fmt;++#[derive(Clone, PartialEq, Eq, Hash, Default, PartialOrd, Ord)]+pub struct JsString {+ /// WTF-8. Valid UTF-8 exactly when `lone_surrogates` is 0.+ bytes: Vec<u8>,+ /// The number of lone surrogates in `bytes`, so a joined pair needs no rescan.+ lone_surrogates: usize,+}++impl JsString {+ pub fn new() -> Self {+ Self::default()+ }++ pub fn with_capacity(capacity: usize) -> Self {+ Self {+ bytes: Vec::with_capacity(capacity),+ lone_surrogates: 0,+ }+ }++ pub fn as_str(&self) -> Option<&str> {+ if self.lone_surrogates > 0 {+ None+ } else {+ // SAFETY: without a lone surrogate the bytes are valid UTF-8 by construction, and a checked conversion would rescan.+ // nosemgrep: rust.lang.security.unsafe-usage.unsafe-usage+ Some(unsafe { std::str::from_utf8_unchecked(&self.bytes) })+ }+ }++ /// The text as `Buffer.from(str)` would encode it: each lone surrogate becomes U+FFFD.+ pub fn to_utf8_lossy(&self) -> Cow<'_, str> {+ match self.as_str() {+ Some(s) => Cow::Borrowed(s),+ None => {+ let mut out = String::with_capacity(self.bytes.len());+ for unit in self.chars_or_surrogates() {+ match unit {+ CharOrSurrogate::Char(c) => out.push(c),+ CharOrSurrogate::Surrogate(_) => out.push('\u{FFFD}'),+ }+ }+ Cow::Owned(out)+ }+ }+ }++ pub fn into_string_lossy(self) -> String {+ if self.lone_surrogates > 0 {+ self.to_utf8_lossy().into_owned()+ } else {+ // SAFETY: as in `as_str`.+ // nosemgrep: rust.lang.security.unsafe-usage.unsafe-usage+ unsafe { String::from_utf8_unchecked(self.bytes) }+ }+ }++ pub fn push_str(&mut self, s: &str) {+ self.bytes.extend_from_slice(s.as_bytes());+ }++ pub fn push(&mut self, c: char) {+ let mut buf = [0u8; 4];+ self.bytes+ .extend_from_slice(c.encode_utf8(&mut buf).as_bytes());+ }++ pub fn push_js(&mut self, other: &JsString) {+ // A join can happen only at the seam, so the bytes copy unless the seam joins.+ if other.lone_surrogates == 0+ || !other.starts_with_low_surrogate()+ || self.trailing_high_surrogate().is_none()+ {+ self.bytes.extend_from_slice(&other.bytes);+ self.lone_surrogates += other.lone_surrogates;+ return;+ }+ for unit in other.chars_or_surrogates() {+ match unit {+ CharOrSurrogate::Char(c) => self.push(c),+ CharOrSurrogate::Surrogate(s) => self.push_code_unit(s),+ }+ }+ }++ /// A low surrogate after a lone high surrogate joins it into one code point, as JavaScript concatenation does.+ pub fn push_code_unit(&mut self, unit: u16) {+ if !(0xD800..=0xDFFF).contains(&unit) {+ self.push(char::from_u32(unit as u32).expect("non-surrogate unit is a char"));+ return;+ }+ if (0xDC00..=0xDFFF).contains(&unit) {+ if let Some(high) = self.trailing_high_surrogate() {+ self.bytes.truncate(self.bytes.len() - 3);+ let cp = 0x10000 + (((high as u32) - 0xD800) << 10) + ((unit as u32) - 0xDC00);+ self.push(char::from_u32(cp).expect("surrogate pair is a char"));+ self.lone_surrogates -= 1;+ return;+ }+ }+ self.bytes.push(0xE0 | ((unit >> 12) as u8));+ self.bytes.push(0x80 | (((unit >> 6) & 0x3F) as u8));+ self.bytes.push(0x80 | ((unit & 0x3F) as u8));+ self.lone_surrogates += 1;+ }++ fn trailing_high_surrogate(&self) -> Option<u16> {+ let n = self.bytes.len();+ if self.lone_surrogates == 0 || n < 3 {+ return None;+ }+ let b = &self.bytes[n - 3..];+ if b[0] == 0xED && (0xA0..=0xAF).contains(&b[1]) {+ Some(0xD000 | (((b[1] & 0x3F) as u16) << 6) | ((b[2] & 0x3F) as u16))+ } else {+ None+ }+ }++ fn starts_with_low_surrogate(&self) -> bool {+ matches!(self.bytes.as_slice(), [0xED, 0xB0..=0xBF, ..])+ }++ /// Cuts back to `len` bytes, where `lone_surrogates` is the count that the prefix had.+ pub(crate) fn truncate_to(&mut self, len: usize, lone_surrogates: usize) {+ self.bytes.truncate(len);+ self.lone_surrogates = lone_surrogates;+ }++ pub(crate) fn lone_surrogate_count(&self) -> usize {+ self.lone_surrogates+ }++ pub fn utf16_len(&self) -> usize {+ match self.as_str() {+ Some(s) => utf16_len(s),+ None => self+ .chars_or_surrogates()+ .map(|u| match u {+ CharOrSurrogate::Char(c) => c.len_utf16(),+ CharOrSurrogate::Surrogate(_) => 1,+ })+ .sum(),+ }+ }++ pub fn utf16_slice(&self, start: usize, end: usize) -> JsString {+ let mut out = JsString::new();+ let mut pos = 0usize;+ for unit in self.chars_or_surrogates() {+ if pos >= end {+ break;+ }+ match unit {+ CharOrSurrogate::Char(c) => {+ let mut buf = [0u16; 2];+ for &u in c.encode_utf16(&mut buf).iter() {+ if pos >= start && pos < end {+ out.push_code_unit(u);+ }+ pos += 1;+ }+ }+ CharOrSurrogate::Surrogate(s) => {+ if pos >= start && pos < end {+ out.push_code_unit(s);+ }+ pos += 1;+ }+ }+ }+ out+ }++ pub fn bytes_wtf8(&self) -> &[u8] {+ &self.bytes+ }++ pub fn is_empty(&self) -> bool {+ self.bytes.is_empty()+ }++ pub fn chars_or_surrogates(&self) -> impl Iterator<Item = CharOrSurrogate> + '_ {+ Wtf8Iter {+ bytes: &self.bytes,+ pos: 0,+ }+ }++ pub fn utf8_byte_len(&self) -> usize {+ // WTF-8 encodes a lone surrogate in three bytes, the same as U+FFFD.+ self.bytes.len()+ }+}++pub enum CharOrSurrogate {+ Char(char),+ Surrogate(u16),+}++impl CharOrSurrogate {+ pub fn as_char(&self) -> Result<char, u16> {+ match self {+ CharOrSurrogate::Char(c) => Ok(*c),+ CharOrSurrogate::Surrogate(s) => Err(*s),+ }+ }+}++struct Wtf8Iter<'a> {+ bytes: &'a [u8],+ pos: usize,+}++impl Iterator for Wtf8Iter<'_> {+ type Item = CharOrSurrogate;++ fn next(&mut self) -> Option<CharOrSurrogate> {+ let b = self.bytes;+ let i = self.pos;+ if i >= b.len() {+ return None;+ }+ let first = b[i];+ let (cp, len) = if first < 0x80 {+ (first as u32, 1)+ } else if first < 0xE0 {+ (+ (((first & 0x1F) as u32) << 6) | ((b[i + 1] & 0x3F) as u32),+ 2,+ )+ } else if first < 0xF0 {+ (+ (((first & 0x0F) as u32) << 12)+ | (((b[i + 1] & 0x3F) as u32) << 6)+ | ((b[i + 2] & 0x3F) as u32),+ 3,+ )+ } else {+ (+ (((first & 0x07) as u32) << 18)+ | (((b[i + 1] & 0x3F) as u32) << 12)+ | (((b[i + 2] & 0x3F) as u32) << 6)+ | ((b[i + 3] & 0x3F) as u32),+ 4,+ )+ };+ self.pos += len;+ Some(match char::from_u32(cp) {+ Some(c) => CharOrSurrogate::Char(c),+ None => CharOrSurrogate::Surrogate(cp as u16),+ })+ }+}++impl From<&str> for JsString {+ fn from(s: &str) -> Self {+ Self {+ bytes: s.as_bytes().to_vec(),+ lone_surrogates: 0,+ }+ }+}++impl From<String> for JsString {+ fn from(s: String) -> Self {+ Self {+ bytes: s.into_bytes(),+ lone_surrogates: 0,+ }+ }+}++impl fmt::Debug for JsString {+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+ fmt::Debug::fmt(&self.to_utf8_lossy(), f)+ }+}++impl fmt::Display for JsString {+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+ f.write_str(&self.to_utf8_lossy())+ }+}++impl PartialEq<str> for JsString {+ fn eq(&self, other: &str) -> bool {+ self.as_str() == Some(other)+ }+}++impl PartialEq<&str> for JsString {+ fn eq(&self, other: &&str) -> bool {+ self.as_str() == Some(*other)+ }+}++pub fn utf16_len(s: &str) -> usize {+ if s.is_ascii() {+ return s.len();+ }+ s.chars().map(char::len_utf16).sum()+}++/// Use it only where the slice goes straight to bytes. Use `JsString::utf16_slice` where it can reach `JSON.stringify`.+pub fn utf16_slice_lossy(s: &str, start: usize, end: usize) -> String {+ if s.is_ascii() {+ let end = end.min(s.len());+ let start = start.min(end);+ return s[start..end].to_string();+ }+ JsString::from(s)+ .utf16_slice(start, end)+ .into_string_lossy()+}++/// `None` when `s` has at most `max` UTF-16 units. It reads only `max + 1` units, so a large body costs no more than the cap.+pub fn utf16_prefix_lossy(s: &str, max: usize) -> Option<String> {+ if s.is_ascii() {+ return (s.len() > max).then(|| s[..max].to_string());+ }+ let mut units = 0usize;+ for (at, c) in s.char_indices() {+ let width = c.len_utf16();+ if units + width > max {+ let mut prefix = s[..at].to_string();+ if units < max {+ // The cut falls inside a surrogate pair. The lone high surrogate converts to U+FFFD.+ prefix.push('\u{FFFD}');+ }+ return Some(prefix);+ }+ units += width;+ }+ None+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn slicing_an_emoji_leaves_a_lone_surrogate() {+ let s = JsString::from("a🚀b");+ assert_eq!(s.utf16_len(), 4);+ let cut = s.utf16_slice(0, 2);+ assert_eq!(cut.utf16_len(), 2);+ assert!(cut.as_str().is_none());+ assert_eq!(cut.to_utf8_lossy(), "a\u{FFFD}");+ assert_eq!(utf16_slice_lossy("a🚀b", 0, 2), "a\u{FFFD}");+ assert_eq!(utf16_prefix_lossy("a🚀b", 2).as_deref(), Some("a\u{FFFD}"));+ assert_eq!(utf16_prefix_lossy("a🚀b", 3).as_deref(), Some("a🚀"));+ assert_eq!(utf16_prefix_lossy("a🚀b", 4), None);+ }++ #[test]+ fn a_split_pair_rejoins_on_concatenation() {+ let s = JsString::from("🚀");+ let mut joined = s.utf16_slice(0, 1);+ joined.push_js(&s.utf16_slice(1, 2));+ assert_eq!(joined, JsString::from("🚀"));+ assert!(joined.as_str().is_some());++ let mut mixed = JsString::new();+ mixed.push_code_unit(0xD800);+ mixed.push_code_unit(0xD83D);+ mixed.push_code_unit(0xDE80);+ assert!(mixed.as_str().is_none(), "the first lone surrogate remains");+ assert_eq!(mixed.to_utf8_lossy(), "\u{FFFD}🚀");+ }+}diff --git a/rust/logs-ingestion/src/lib.rs b/rust/logs-ingestion/src/lib.rsnew file mode 100644index 000000000000..726e939766c3--- /dev/null+++ b/rust/logs-ingestion/src/lib.rs@@ -0,0 +1,19 @@+//! Kept 1:1 with `nodejs/src/logs` by the shared parity corpus. `PORTING.md` lists the JavaScript semantics the port reproduces.++pub mod attribute_value;+pub mod avro;+pub mod body_parse;+pub mod content_weights;+pub mod filter_group;+pub mod internal_logs;+pub mod js;+pub mod metric_rules;+pub mod normalize;+pub mod pattern;+pub mod pii;+pub mod pipeline;+pub mod property_filter;+pub mod rate_limiter;+pub mod record;+pub mod retention;+pub mod sampling;diff --git a/rust/logs-ingestion/src/metric_rules/admission.rs b/rust/logs-ingestion/src/metric_rules/admission.rsnew file mode 100644index 000000000000..b17150de3871--- /dev/null+++ b/rust/logs-ingestion/src/metric_rules/admission.rs@@ -0,0 +1,101 @@+use std::collections::{HashMap, HashSet};++use hmac::{Hmac, Mac};+use rand::RngCore;+use sha2::Sha256;++use super::tally::MAX_LABEL_SETS_PER_RULE;++const SERIES_WINDOW_MS: f64 = 60.0 * 60.0 * 1000.0;++pub const MAX_ADMITTED_LABEL_SETS_PER_TEAM: usize = 5_000;+pub const MAX_ADMITTED_LABEL_SETS: usize = 500_000;++/// Batch tallies start empty, so without this bound a rule whose labels change every batch stores new series without limit.+#[derive(Debug, Clone)]+pub struct MetricSeriesAdmission {+ max_per_rule: usize,+ max_per_team: usize,+ max_total: usize,+ /// A random key per process stops a team from making colliding labels offline to pass the cap.+ hash_key: [u8; 32],+ window: f64,+ admitted: HashMap<String, HashSet<u64>>,+ // Counts stay after a rule is deleted until the hour changes, so rule churn cannot reset a budget.+ admitted_by_team: HashMap<i64, usize>,+ admitted_total: usize,+}++impl Default for MetricSeriesAdmission {+ fn default() -> Self {+ Self::new(+ MAX_LABEL_SETS_PER_RULE,+ MAX_ADMITTED_LABEL_SETS_PER_TEAM,+ MAX_ADMITTED_LABEL_SETS,+ )+ }+}++impl MetricSeriesAdmission {+ pub fn new(max_per_rule: usize, max_per_team: usize, max_total: usize) -> Self {+ let mut hash_key = [0u8; 32];+ rand::thread_rng().fill_bytes(&mut hash_key);+ Self::with_hash_key(max_per_rule, max_per_team, max_total, hash_key)+ }++ pub fn with_hash_key(+ max_per_rule: usize,+ max_per_team: usize,+ max_total: usize,+ hash_key: [u8; 32],+ ) -> Self {+ Self {+ max_per_rule,+ max_per_team,+ max_total,+ hash_key,+ window: -1.0,+ admitted: HashMap::new(),+ admitted_by_team: HashMap::new(),+ admitted_total: 0,+ }+ }++ pub fn hash_label_key(&self, label_key: &str) -> u64 {+ let mut mac =+ Hmac::<Sha256>::new_from_slice(&self.hash_key).expect("HMAC takes any key length");+ mac.update(label_key.as_bytes());+ let digest = mac.finalize().into_bytes();+ digest[..6]+ .iter()+ .fold(0u64, |acc, b| (acc << 8) | u64::from(*b))+ }++ pub fn admit(&mut self, team_id: i64, rule_id: &str, label_key: &str, now_ms: f64) -> bool {+ let window = (now_ms / SERIES_WINDOW_MS).floor();+ if window != self.window {+ self.admitted.clear();+ self.admitted_by_team.clear();+ self.admitted_total = 0;+ self.window = window;+ }+ let key = format!("{team_id}:{rule_id}");+ let label_hash = self.hash_label_key(label_key);+ let rule_size = match self.admitted.get(&key) {+ Some(hashes) if hashes.contains(&label_hash) => return true,+ Some(hashes) => hashes.len(),+ None => 0,+ };+ let team_admitted = self.admitted_by_team.get(&team_id).copied().unwrap_or(0);+ if rule_size >= self.max_per_rule+ || team_admitted >= self.max_per_team+ || self.admitted_total >= self.max_total+ {+ return false;+ }+ self.admitted.entry(key).or_default().insert(label_hash);+ self.admitted_by_team.insert(team_id, team_admitted + 1);+ self.admitted_total += 1;+ true+ }+}diff --git a/rust/logs-ingestion/src/metric_rules/compile.rs b/rust/logs-ingestion/src/metric_rules/compile.rsnew file mode 100644index 000000000000..6b066ed53c11--- /dev/null+++ b/rust/logs-ingestion/src/metric_rules/compile.rs@@ -0,0 +1,157 @@+use std::sync::Arc;++use super::filter::{parse_filter_group, FilterGroupMatcher, FilterGroupParser};+use super::tally::SPAN_VALUE_DURATION_MS;+use crate::js::{JsObject, JsString, JsValue};+use crate::property_filter::coerce::JsTypeError;++/// Mirrors `MAX_METRIC_RULE_GROUP_BY_KEYS` in `products/logs/backend/models.py`.+pub const MAX_GROUP_BY_KEYS: usize = 5;++pub const SPAN_GROUP_BY_TOP_LEVEL_KEYS: [&str; 4] = ["service_name", "name", "status_code", "kind"];++pub const LOG_GROUP_BY_TOP_LEVEL_KEYS: [&str; 3] = ["service_name", "severity_text", "event_name"];++#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]+pub enum MetricRuleSource {+ Logs,+ Spans,+}++impl MetricRuleSource {+ pub fn as_str(self) -> &'static str {+ match self {+ MetricRuleSource::Logs => "logs",+ MetricRuleSource::Spans => "spans",+ }+ }+}++/// `JsValue::Null` stands for both null and a missing property, because every TypeScript check treats the two the same.+#[derive(Debug, Clone, PartialEq)]+pub struct MetricRuleRow {+ pub id: String,+ pub metric_name: JsValue,+ pub filter_group: JsValue,+ pub value_attribute: JsValue,+ pub group_by: JsValue,+ pub source: JsValue,+}++impl MetricRuleRow {+ pub fn from_js(row: &JsObject) -> Self {+ let field = |name: &str| row.get(name).cloned().unwrap_or(JsValue::Null);+ let id = match row.get("id") {+ Some(JsValue::String(s)) => s.to_utf8_lossy().into_owned(),+ Some(JsValue::Number(n)) => crate::js::number_to_string(*n),+ _ => String::new(),+ };+ Self {+ id,+ metric_name: field("metric_name"),+ filter_group: field("filter_group"),+ value_attribute: field("value_attribute"),+ group_by: field("group_by"),+ source: field("source"),+ }+ }+}++#[derive(Debug, Clone)]+pub struct CompiledMetricRule {+ pub id: String,+ pub metric_name: JsString,+ pub source: MetricRuleSource,+ /// `None` means every ingested record matches.+ pub filter_group: Option<Arc<dyn FilterGroupMatcher>>,+ /// The key that holds the numeric value to aggregate. `None` counts records.+ pub value_attribute: Option<JsString>,+ pub group_by: Vec<JsString>,+}++pub(crate) fn starts_with(s: &JsString, prefix: &str) -> bool {+ s.bytes_wtf8().starts_with(prefix.as_bytes())+}++fn is_attribute_key(k: &JsString) -> bool {+ starts_with(k, "attributes.") || starts_with(k, "resource_attributes.")+}++fn is_one_of(k: &JsString, keys: &[&str]) -> bool {+ k.as_str().is_some_and(|k| keys.contains(&k))+}++/// `Err` is a throw from `parseFilterGroup`, which rejects the whole call.+pub fn compile_metric_rules(+ rows: &[MetricRuleRow],+) -> Result<Vec<CompiledMetricRule>, JsTypeError> {+ compile_metric_rules_with(rows, parse_filter_group)+}++pub fn compile_metric_rules_with(+ rows: &[MetricRuleRow],+ parse: FilterGroupParser,+) -> Result<Vec<CompiledMetricRule>, JsTypeError> {+ let mut out = Vec::new();+ for row in rows {+ let metric_name = match &row.metric_name {+ JsValue::String(s) if !s.is_empty() => s.clone(),+ _ => continue,+ };+ let source = match &row.source {+ JsValue::String(s) if *s == "spans" => MetricRuleSource::Spans,+ _ => MetricRuleSource::Logs,+ };+ let mut filter_group = None;+ if !matches!(row.filter_group, JsValue::Null) {+ match parse(&row.filter_group)? {+ Some(group) => filter_group = Some(group),+ // A null filter counts everything, so an unparseable filter skips the rule.+ None => continue,+ }+ }+ let group_by: Vec<JsString> = match &row.group_by {+ JsValue::Array(items) => items+ .iter()+ .filter_map(|k| match k {+ JsValue::String(s) if !s.is_empty() => Some(s.clone()),+ _ => None,+ })+ .take(MAX_GROUP_BY_KEYS)+ .collect(),+ _ => Vec::new(),+ };+ let value_attribute = match &row.value_attribute {+ JsValue::String(s) if !s.is_empty() => Some(s.clone()),+ _ => None,+ };+ let allowed_top_level: &[&str] = match source {+ MetricRuleSource::Spans => &SPAN_GROUP_BY_TOP_LEVEL_KEYS,+ MetricRuleSource::Logs => &LOG_GROUP_BY_TOP_LEVEL_KEYS,+ };+ // A key that the source does not have gives an empty label on every series.+ if group_by+ .iter()+ .any(|k| !is_one_of(k, allowed_top_level) && !is_attribute_key(k))+ {+ continue;+ }+ // A log record has no end_time, so the span duration pseudo-key never applies to it.+ if source == MetricRuleSource::Logs+ && value_attribute+ .as_ref()+ .is_some_and(|v| *v == SPAN_VALUE_DURATION_MS)+ {+ continue;+ }+ out.push(CompiledMetricRule {+ id: row.id.clone(),+ metric_name,+ source,+ filter_group,+ value_attribute,+ group_by,+ });+ }+ Ok(out)+}diff --git a/rust/logs-ingestion/src/metric_rules/defaults.rs b/rust/logs-ingestion/src/metric_rules/defaults.rsnew file mode 100644index 000000000000..629f5656825c--- /dev/null+++ b/rust/logs-ingestion/src/metric_rules/defaults.rs@@ -0,0 +1,65 @@+use std::collections::HashSet;+use std::sync::OnceLock;++use super::compile::{compile_metric_rules, CompiledMetricRule, MetricRuleRow, MetricRuleSource};+use super::tally::SPAN_VALUE_DURATION_MS;+use crate::js::{json_parse, JsString, JsValue};++const SPAN_KIND_INTERNAL: &str = "1";++fn default_rows() -> Vec<MetricRuleRow> {+ let filter = format!(+ r#"{{"type":"AND","values":[{{"type":"AND","values":[{{"key":"kind","operator":"is_not","value":"{SPAN_KIND_INTERNAL}","type":"span_attribute"}}]}}]}}"#+ );+ let strings = |keys: &[&str]| JsValue::Array(keys.iter().map(|k| JsValue::string(k)).collect());+ vec![+ // INTERNAL spans are the most numerous, and their names most often carry ids.+ MetricRuleRow {+ id: "default:spans:duration".to_string(),+ metric_name: JsValue::string("posthog.span.duration"),+ source: JsValue::string("spans"),+ filter_group: json_parse(&filter).expect("default filter group is valid JSON"),+ value_attribute: JsValue::string(SPAN_VALUE_DURATION_MS),+ group_by: strings(&["service_name", "kind", "name", "status_code"]),+ },+ MetricRuleRow {+ id: "default:logs:records".to_string(),+ metric_name: JsValue::string("posthog.log.records"),+ source: JsValue::string("logs"),+ filter_group: JsValue::Null,+ value_attribute: JsValue::Null,+ group_by: strings(&["service_name", "severity_text"]),+ },+ ]+}++pub fn default_metric_rules(source: MetricRuleSource) -> &'static [CompiledMetricRule] {+ static COMPILED: OnceLock<(Vec<CompiledMetricRule>, Vec<CompiledMetricRule>)> = OnceLock::new();+ let (logs, spans) = COMPILED.get_or_init(|| {+ let compiled =+ compile_metric_rules(&default_rows()).expect("default rules compile without a throw");+ let (logs, spans): (Vec<_>, Vec<_>) = compiled+ .into_iter()+ .partition(|r| r.source == MetricRuleSource::Logs);+ (logs, spans)+ });+ match source {+ MetricRuleSource::Logs => logs,+ MetricRuleSource::Spans => spans,+ }+}++pub fn with_default_metric_rules(+ team_rules: Vec<CompiledMetricRule>,+ source: MetricRuleSource,+) -> Vec<CompiledMetricRule> {+ let team_names: HashSet<JsString> = team_rules.iter().map(|r| r.metric_name.clone()).collect();+ let mut out = team_rules;+ out.extend(+ default_metric_rules(source)+ .iter()+ .filter(|r| !team_names.contains(&r.metric_name))+ .cloned(),+ );+ out+}diff --git a/rust/logs-ingestion/src/metric_rules/emitter.rs b/rust/logs-ingestion/src/metric_rules/emitter.rsnew file mode 100644index 000000000000..4c5fab431684--- /dev/null+++ b/rust/logs-ingestion/src/metric_rules/emitter.rs@@ -0,0 +1,108 @@+//! The crate has no HTTP client, so the POST is behind `OtlpTransport`. `LogsMetricsEmitter` keeps Node's two attempts and 2xx check.++use std::sync::Arc;++use async_trait::async_trait;++use crate::js::{json_stringify, JsValue};++pub const EXPORT_FAILED_COUNTER: &str = "logs_metrics_rules_export_failed_total";++const EXPORT_ATTEMPTS: u32 = 2;++#[async_trait]+pub trait MetricsEmitter: Send + Sync {+ async fn emit(&self, token: &str, team_id: i64, payload: &JsValue) -> bool;+}++/// The implementation reads the whole response body before it returns, as `response.dump()` does in Node.+#[async_trait]+pub trait OtlpTransport: Send + Sync {+ async fn post(&self, url: &str, headers: &[(&str, String)], body: &str) -> anyhow::Result<u16>;+}++/// Posts with the team's own token, so the series goes through the customer capture pipeline. After one retry the window is dropped.+pub struct LogsMetricsEmitter<T: OtlpTransport> {+ url: String,+ transport: T,+}++impl<T: OtlpTransport> LogsMetricsEmitter<T> {+ pub fn new(url: impl Into<String>, transport: T) -> Self {+ Self {+ url: url.into(),+ transport,+ }+ }+}++#[async_trait]+impl<T: OtlpTransport> MetricsEmitter for LogsMetricsEmitter<T> {+ async fn emit(&self, token: &str, team_id: i64, payload: &JsValue) -> bool {+ let body = json_stringify(payload);+ let headers = [+ ("Authorization", format!("Bearer {token}")),+ ("Content-Type", "application/json".to_string()),+ ];+ for attempt in 1..=EXPORT_ATTEMPTS {+ match self.transport.post(&self.url, &headers, &body).await {+ Ok(status) if (200..300).contains(&status) => return true,+ Ok(status) => tracing::warn!(+ team_id,+ status,+ attempt,+ "[logs-metric-rules] OTLP export rejected"+ ),+ Err(error) => tracing::warn!(+ team_id,+ error = %error,+ attempt,+ "[logs-metric-rules] OTLP export failed"+ ),+ }+ }+ let team_label: Arc<str> = Arc::from(team_id.to_string());+ metrics::counter!(EXPORT_FAILED_COUNTER, "team_id" => team_label).increment(1);+ false+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use std::sync::Mutex;++ struct Scripted(Mutex<Vec<anyhow::Result<u16>>>, Mutex<Vec<String>>);++ #[async_trait]+ impl OtlpTransport for Scripted {+ async fn post(+ &self,+ _url: &str,+ headers: &[(&str, String)],+ body: &str,+ ) -> anyhow::Result<u16> {+ self.1+ .lock()+ .unwrap()+ .push(format!("{}|{body}", headers[0].1));+ self.0.lock().unwrap().remove(0)+ }+ }++ #[tokio::test]+ async fn retries_once_then_gives_up() {+ let payload = crate::js::json_parse(r#"{"a":1e21}"#).unwrap();+ let t = Scripted(+ Mutex::new(vec![Err(anyhow::anyhow!("reset")), Ok(503), Ok(200)]),+ Mutex::new(vec![]),+ );+ let emitter = LogsMetricsEmitter::new("http://x", t);+ assert!(!emitter.emit("tok", 7, &payload).await);+ assert_eq!(+ *emitter.transport.1.lock().unwrap(),+ vec!["Bearer tok|{\"a\":1e+21}", "Bearer tok|{\"a\":1e+21}"]+ );+ assert!(emitter.emit("tok", 7, &payload).await);+ }+}diff --git a/rust/logs-ingestion/src/metric_rules/filter.rs b/rust/logs-ingestion/src/metric_rules/filter.rsnew file mode 100644index 000000000000..c1d6dbfe2cf0--- /dev/null+++ b/rust/logs-ingestion/src/metric_rules/filter.rs@@ -0,0 +1,29 @@+use std::fmt;+use std::sync::Arc;++use crate::filter_group::{match_filter_group, FilterGroupNode};+use crate::js::JsValue;+use crate::property_filter::coerce::JsTypeError;+use crate::record::LogRecord;++pub trait FilterGroupMatcher: Send + Sync + fmt::Debug {+ /// `Err` is a throw, which `tallyRecords` counts.+ fn matches(&self, record: &LogRecord) -> Result<bool, JsTypeError>;+}++/// `Ok(None)` when the value is not a valid filter group, and `Err` when the TypeScript throws.+pub type FilterGroupParser =+ fn(&JsValue) -> Result<Option<Arc<dyn FilterGroupMatcher>>, JsTypeError>;++impl FilterGroupMatcher for FilterGroupNode {+ fn matches(&self, record: &LogRecord) -> Result<bool, JsTypeError> {+ match_filter_group(self, record)+ }+}++pub fn parse_filter_group(+ raw: &JsValue,+) -> Result<Option<Arc<dyn FilterGroupMatcher>>, JsTypeError> {+ Ok(crate::sampling::parse_filter_group(raw)?+ .map(|g| Arc::new(g) as Arc<dyn FilterGroupMatcher>))+}diff --git a/rust/logs-ingestion/src/metric_rules/mod.rs b/rust/logs-ingestion/src/metric_rules/mod.rsnew file mode 100644index 000000000000..40993d2056dc--- /dev/null+++ b/rust/logs-ingestion/src/metric_rules/mod.rs@@ -0,0 +1,30 @@+mod admission;+mod compile;+mod defaults;+mod emitter;+mod filter;+mod ordered;+mod otlp_payload;+mod parse_float;+mod source;+mod tally;++pub use admission::{+ MetricSeriesAdmission, MAX_ADMITTED_LABEL_SETS, MAX_ADMITTED_LABEL_SETS_PER_TEAM,+};+pub use compile::{+ compile_metric_rules, compile_metric_rules_with, CompiledMetricRule, MetricRuleRow,+ MetricRuleSource, LOG_GROUP_BY_TOP_LEVEL_KEYS, MAX_GROUP_BY_KEYS, SPAN_GROUP_BY_TOP_LEVEL_KEYS,+};+pub use defaults::{default_metric_rules, with_default_metric_rules};+pub use emitter::{LogsMetricsEmitter, MetricsEmitter, OtlpTransport, EXPORT_FAILED_COUNTER};+pub use filter::{parse_filter_group, FilterGroupMatcher, FilterGroupParser};+pub use ordered::InsertionMap;+pub use otlp_payload::build_metric_rules_otlp_payload;+pub use parse_float::js_parse_float;+pub use source::MetricRulesSource;+pub use tally::{+ id_to_hex, resolve_label_value, tally_records, AdmitLabelSet, BatchTallies, LabelValue,+ MetricTallyEntry, DEFAULT_HISTOGRAM_BOUNDS, MAX_LABEL_SETS_PER_RULE, MAX_LABEL_VALUE_LENGTH,+ MAX_RECORD_AGE_MS, OVERFLOW_LABEL_KEY, SPAN_VALUE_DURATION_MS,+};diff --git a/rust/logs-ingestion/src/metric_rules/ordered.rs b/rust/logs-ingestion/src/metric_rules/ordered.rsnew file mode 100644index 000000000000..f35aeb38fc5a--- /dev/null+++ b/rust/logs-ingestion/src/metric_rules/ordered.rs@@ -0,0 +1,77 @@+//! A string-keyed map that iterates in insertion order, as a JavaScript `Map` does.++use std::collections::HashMap;++/// Label keys come from log content, so the hash is seeded per process.+#[derive(Debug, Clone)]+pub struct InsertionMap<V> {+ entries: Vec<(String, V)>,+ index: HashMap<String, usize, ahash::RandomState>,+}++impl<V> Default for InsertionMap<V> {+ fn default() -> Self {+ Self {+ entries: Vec::new(),+ index: HashMap::default(),+ }+ }+}++impl<V> InsertionMap<V> {+ pub fn new() -> Self {+ Self::default()+ }++ pub fn len(&self) -> usize {+ self.entries.len()+ }++ pub fn is_empty(&self) -> bool {+ self.entries.is_empty()+ }++ pub fn get(&self, key: &str) -> Option<&V> {+ self.index.get(key).map(|&i| &self.entries[i].1)+ }++ pub fn get_mut(&mut self, key: &str) -> Option<&mut V> {+ self.index.get(key).map(|&i| &mut self.entries[i].1)+ }++ pub fn contains_key(&self, key: &str) -> bool {+ self.index.contains_key(key)+ }++ /// `map.set(key, value)`: a present key keeps its position.+ pub fn insert(&mut self, key: &str, value: V) -> &mut V {+ let i = match self.index.get(key) {+ Some(&i) => {+ self.entries[i].1 = value;+ i+ }+ None => {+ self.entries.push((key.to_string(), value));+ self.index.insert(key.to_string(), self.entries.len() - 1);+ self.entries.len() - 1+ }+ };+ &mut self.entries[i].1+ }++ pub fn get_or_insert_with(&mut self, key: &str, make: impl FnOnce() -> V) -> &mut V {+ if !self.index.contains_key(key) {+ self.insert(key, make());+ }+ let i = self.index[key];+ &mut self.entries[i].1+ }++ pub fn iter(&self) -> impl Iterator<Item = (&str, &V)> + '_ {+ self.entries.iter().map(|(k, v)| (k.as_str(), v))+ }++ pub fn values(&self) -> impl Iterator<Item = &V> + '_ {+ self.entries.iter().map(|(_, v)| v)+ }+}diff --git a/rust/logs-ingestion/src/metric_rules/otlp_payload.rs b/rust/logs-ingestion/src/metric_rules/otlp_payload.rsnew file mode 100644index 000000000000..0e0ad5cd4c0a--- /dev/null+++ b/rust/logs-ingestion/src/metric_rules/otlp_payload.rs@@ -0,0 +1,296 @@+//! The result keeps the TypeScript key order, so `json_stringify` gives the bytes that Node sends.++use super::compile::{starts_with, CompiledMetricRule};+use super::ordered::InsertionMap;+use super::tally::{+ BatchTallies, LabelValue, MetricTallyEntry, DEFAULT_HISTOGRAM_BOUNDS, SPAN_VALUE_DURATION_MS,+};+use crate::js::{JsObject, JsString, JsValue};++const SCOPE_NAME: &str = "posthog/logs-metric-rules";++const TIME_BUCKET_MS: f64 = 10_000.0;++const OTLP_TEMPORALITY_DELTA: f64 = 1.0;++const ATTRIBUTE_PREFIXES: [&str; 2] = ["attributes.", "resource_attributes."];++fn object(entries: Vec<(&str, JsValue)>) -> JsValue {+ let mut o = JsObject::new();+ for (k, v) in entries {+ o.insert_str(k, v);+ }+ JsValue::Object(o)+}++fn string_attribute(key: JsString, value: JsString) -> JsValue {+ let mut o = JsObject::new();+ o.insert_str("key", JsValue::String(key));+ o.insert_str(+ "value",+ object(vec![("stringValue", JsValue::String(value))]),+ );+ JsValue::Object(o)+}++/// `JSON.stringify` omits a function-valued property.+fn label_attribute(key: JsString, value: &LabelValue) -> JsValue {+ let mut inner = JsObject::new();+ if let Some(v) = value.to_json() {+ inner.insert_str("stringValue", v);+ }+ let mut o = JsObject::new();+ o.insert_str("key", JsValue::String(key));+ o.insert_str("value", JsValue::Object(inner));+ JsValue::Object(o)+}++fn overflow_attribute() -> JsValue {+ object(vec![+ ("key", JsValue::string("otel.metric.overflow")),+ ("value", object(vec![("boolValue", JsValue::Bool(true))])),+ ])+}++/// Series identity has no bucket bounds, so each bucket layout gets its own series.+fn bucket_layout_attribute() -> JsValue {+ string_attribute(+ JsString::from("posthog.bucket_layout"),+ JsString::from("otel_default_v1"),+ )+}++fn label_name(group_by_key: &JsString) -> JsString {+ for prefix in ATTRIBUTE_PREFIXES {+ if starts_with(group_by_key, prefix) {+ return group_by_key.utf16_slice(prefix.len(), group_by_key.utf16_len());+ }+ }+ group_by_key.clone()+}++fn snap_to_bucket_nanos(now_ms: f64) -> i128 {+ ((now_ms / TIME_BUCKET_MS).floor() * TIME_BUCKET_MS) as i128 * 1_000_000+}++struct RulePoints<'a> {+ rule: &'a CompiledMetricRule,+ entries: Vec<&'a MetricTallyEntry>,+}++pub fn build_metric_rules_otlp_payload(+ rules: &[CompiledMetricRule],+ tallies: &BatchTallies,+ now_ms: f64,+) -> Option<JsValue> {+ let mut by_service: Vec<(JsString, InsertionMap<RulePoints<'_>>)> = Vec::new();+ for rule in rules {+ let Some(rule_tallies) = tallies.by_rule.get(&rule.id) else {+ continue;+ };+ let service_index = rule.group_by.iter().position(|k| *k == "service_name");+ for entry in rule_tallies.values() {+ let service = match service_index {+ // The service label comes from the `service_name` column, so it is a string.+ Some(i) if !entry.overflow => entry+ .label_values+ .get(i)+ .and_then(LabelValue::as_js_string)+ .cloned()+ .unwrap_or_default(),+ _ => JsString::new(),+ };+ let slot = match by_service.iter().position(|(s, _)| *s == service) {+ Some(i) => i,+ None => {+ by_service.push((service, InsertionMap::new()));+ by_service.len() - 1+ }+ };+ let points = by_service[slot]+ .1+ .get_or_insert_with(&rule.id, || RulePoints {+ rule,+ entries: Vec::new(),+ });+ points.entries.push(entry);+ }+ }+ if by_service.is_empty() {+ return None;+ }++ let time_nanos = snap_to_bucket_nanos(now_ms);+ let time_unix_nano = JsString::from(time_nanos.to_string());+ let start_time_unix_nano =+ JsString::from((time_nanos - TIME_BUCKET_MS as i128 * 1_000_000).to_string());++ let resource_metrics = by_service+ .iter()+ .map(|(service, rule_map)| {+ let attributes = if service.is_empty() {+ vec![]+ } else {+ vec![string_attribute(+ JsString::from("service.name"),+ service.clone(),+ )]+ };+ let metrics = rule_map+ .values()+ .map(|points| {+ serialize_rule_metric(+ points.rule,+ &points.entries,+ &start_time_unix_nano,+ &time_unix_nano,+ )+ })+ .collect();+ object(vec![+ (+ "resource",+ object(vec![("attributes", JsValue::Array(attributes))]),+ ),+ (+ "scopeMetrics",+ JsValue::Array(vec![object(vec![+ ("scope", object(vec![("name", JsValue::string(SCOPE_NAME))])),+ ("metrics", JsValue::Array(metrics)),+ ])]),+ ),+ ])+ })+ .collect();++ Some(object(vec![(+ "resourceMetrics",+ JsValue::Array(resource_metrics),+ )]))+}++fn number(n: f64) -> JsValue {+ JsValue::Number(n)+}++fn serialize_rule_metric(+ rule: &CompiledMetricRule,+ entries: &[&MetricTallyEntry],+ start_time_unix_nano: &JsString,+ time_unix_nano: &JsString,+) -> JsValue {+ let mut metric = JsObject::new();+ metric.insert_str("name", JsValue::String(rule.metric_name.clone()));+ if let Some(value_attribute) = &rule.value_attribute {+ if *value_attribute == SPAN_VALUE_DURATION_MS {+ metric.insert_str("unit", JsValue::string("ms"));+ }+ let data_points = entries+ .iter()+ .map(|entry| {+ let mut point = data_point_base(+ rule,+ entry,+ start_time_unix_nano,+ time_unix_nano,+ Some(bucket_layout_attribute()),+ );+ point.insert_str("count", number(entry.count as f64));+ point.insert_str("sum", number(entry.sum));+ let buckets = match &entry.bucket_counts {+ Some(b) => JsValue::Array(b.iter().map(|c| number(*c as f64)).collect()),+ None => JsValue::Null,+ };+ point.insert_str("bucketCounts", buckets);+ point.insert_str(+ "explicitBounds",+ JsValue::Array(+ DEFAULT_HISTOGRAM_BOUNDS+ .iter()+ .map(|b| number(*b))+ .collect(),+ ),+ );+ JsValue::Object(point)+ })+ .collect();+ metric.insert_str(+ "histogram",+ object(vec![+ ("dataPoints", JsValue::Array(data_points)),+ ("aggregationTemporality", number(OTLP_TEMPORALITY_DELTA)),+ ]),+ );+ } else {+ let data_points = entries+ .iter()+ .map(|entry| {+ let mut point =+ data_point_base(rule, entry, start_time_unix_nano, time_unix_nano, None);+ point.insert_str("asDouble", number(entry.count as f64));+ JsValue::Object(point)+ })+ .collect();+ metric.insert_str(+ "sum",+ object(vec![+ ("dataPoints", JsValue::Array(data_points)),+ ("aggregationTemporality", number(OTLP_TEMPORALITY_DELTA)),+ ("isMonotonic", JsValue::Bool(true)),+ ]),+ );+ }+ JsValue::Object(metric)+}++fn data_point_base(+ rule: &CompiledMetricRule,+ entry: &MetricTallyEntry,+ start_time_unix_nano: &JsString,+ time_unix_nano: &JsString,+ extra_attribute: Option<JsValue>,+) -> JsObject {+ let mut attributes = Vec::new();+ if entry.overflow {+ attributes.push(overflow_attribute());+ }+ attributes.extend(extra_attribute);+ if !entry.overflow {+ for (i, key) in rule.group_by.iter().enumerate() {+ // `service_name` is on the resource block instead.+ if *key == "service_name" {+ continue;+ }+ let value = entry+ .label_values+ .get(i)+ .cloned()+ .unwrap_or_else(LabelValue::empty);+ attributes.push(label_attribute(label_name(key), &value));+ }+ }+ let mut point = JsObject::new();+ point.insert_str("attributes", JsValue::Array(attributes));+ point.insert_str(+ "startTimeUnixNano",+ JsValue::String(start_time_unix_nano.clone()),+ );+ point.insert_str("timeUnixNano", JsValue::String(time_unix_nano.clone()));+ if let Some(trace_id) = &entry.exemplar_trace_id {+ let as_double = if rule.value_attribute.is_some() {+ entry.sum+ } else {+ entry.count as f64+ };+ let mut exemplar = JsObject::new();+ exemplar.insert_str("filteredAttributes", JsValue::Array(vec![]));+ exemplar.insert_str("timeUnixNano", JsValue::String(time_unix_nano.clone()));+ exemplar.insert_str("asDouble", number(as_double));+ exemplar.insert_str("traceId", JsValue::string(trace_id));+ if let Some(span_id) = &entry.exemplar_span_id {+ exemplar.insert_str("spanId", JsValue::string(span_id));+ }+ point.insert_str("exemplars", JsValue::Array(vec![JsValue::Object(exemplar)]));+ }+ point+}diff --git a/rust/logs-ingestion/src/metric_rules/parse_float.rs b/rust/logs-ingestion/src/metric_rules/parse_float.rsnew file mode 100644index 000000000000..e269b63aa58d--- /dev/null+++ b/rust/logs-ingestion/src/metric_rules/parse_float.rs@@ -0,0 +1,138 @@+use crate::js::{CharOrSurrogate, JsString};++/// Rust's `char::is_whitespace` includes U+0085 and excludes U+FEFF, unlike ECMAScript.+fn is_js_whitespace(c: char) -> bool {+ matches!(+ c,+ '\u{0009}'+ | '\u{000A}'+ | '\u{000B}'+ | '\u{000C}'+ | '\u{000D}'+ | '\u{0020}'+ | '\u{00A0}'+ | '\u{1680}'+ | '\u{2000}'+ ..='\u{200A}'+ | '\u{2028}'+ | '\u{2029}'+ | '\u{202F}'+ | '\u{205F}'+ | '\u{3000}'+ | '\u{FEFF}'+ )+}++pub fn js_parse_float(s: &JsString) -> f64 {+ // Only ASCII can be part of the literal, so a lone surrogate ends it like any other char.+ let mut chars = s.chars_or_surrogates().peekable();+ while let Some(CharOrSurrogate::Char(c)) = chars.peek() {+ if !is_js_whitespace(*c) {+ break;+ }+ chars.next();+ }+ let rest: Vec<u8> = chars+ .map_while(|u| match u {+ CharOrSurrogate::Char(c) if c.is_ascii() => Some(c as u8),+ _ => None,+ })+ .collect();+ parse_prefix(&rest)+}++fn parse_prefix(b: &[u8]) -> f64 {+ let mut i = 0;+ let negative = match b.first() {+ Some(b'-') => {+ i += 1;+ true+ }+ Some(b'+') => {+ i += 1;+ false+ }+ _ => false,+ };+ if b[i..].starts_with(b"Infinity") {+ return if negative {+ f64::NEG_INFINITY+ } else {+ f64::INFINITY+ };+ }+ let digits = |from: usize| b[from..].iter().take_while(|c| c.is_ascii_digit()).count();+ let start = i;+ let int_digits = digits(i);+ i += int_digits;+ let mut frac_digits = 0;+ if b.get(i) == Some(&b'.') {+ frac_digits = digits(i + 1);+ if int_digits > 0 || frac_digits > 0 {+ i += 1 + frac_digits;+ }+ }+ if int_digits == 0 && frac_digits == 0 {+ return f64::NAN;+ }+ if matches!(b.get(i), Some(b'e' | b'E')) {+ let mut j = i + 1;+ if matches!(b.get(j), Some(b'+' | b'-')) {+ j += 1;+ }+ let exp_digits = digits(j);+ if exp_digits > 0 {+ i = j + exp_digits;+ }+ }+ let text = std::str::from_utf8(&b[start..i]).expect("ASCII prefix");+ // Rust's parse is correctly rounded, as ECMAScript requires.+ let magnitude: f64 = text.parse().expect("prefix is a decimal literal");+ if negative {+ -magnitude+ } else {+ magnitude+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn matches_javascript_parse_float() {+ let nan = f64::NAN;+ let cases: &[(&str, f64)] = &[+ ("42", 42.0),+ ("-3.5", -3.5),+ ("12.5abc", 12.5),+ (" \u{FEFF}\u{3000}7", 7.0),+ ("\u{0085}7", nan),+ (".5", 0.5),+ ("5.", 5.0),+ ("-.5e1", -5.0),+ ("1e", 1.0),+ ("1e+", 1.0),+ ("1e-2x", 0.01),+ (".", nan),+ ("-", nan),+ ("", nan),+ ("Infinity", f64::INFINITY),+ ("-Infinityx", f64::NEG_INFINITY),+ ("infinity", nan),+ ("0x10", 0.0),+ ("1e999", f64::INFINITY),+ ("true", nan),+ ("1_000", 1.0),+ ];+ for (input, expected) in cases {+ let actual = js_parse_float(&JsString::from(*input));+ if expected.is_nan() {+ assert!(actual.is_nan(), "parseFloat({input:?}) = {actual}");+ } else {+ assert_eq!(actual, *expected, "parseFloat({input:?})");+ }+ }+ assert!(js_parse_float(&JsString::from("-0")).is_sign_negative());+ }+}diff --git a/rust/logs-ingestion/src/metric_rules/source.rs b/rust/logs-ingestion/src/metric_rules/source.rsnew file mode 100644index 000000000000..1dec20bf91cc--- /dev/null+++ b/rust/logs-ingestion/src/metric_rules/source.rs@@ -0,0 +1,16 @@+//! Only the interface of `metric-rules-cache.ts` is ported, not its Postgres-backed cache.++use std::sync::Arc;++use async_trait::async_trait;++use super::compile::CompiledMetricRule;++/// Node reads enabled rows ordered by `created_at` and keeps the compiled rules for 30 seconds.+#[async_trait]+pub trait MetricRulesSource: Send + Sync {+ async fn get_compiled_rules(+ &self,+ team_id: i64,+ ) -> anyhow::Result<Arc<Vec<CompiledMetricRule>>>;+}diff --git a/rust/logs-ingestion/src/metric_rules/tally.rs b/rust/logs-ingestion/src/metric_rules/tally.rsnew file mode 100644index 000000000000..5a2666c09d01--- /dev/null+++ b/rust/logs-ingestion/src/metric_rules/tally.rs@@ -0,0 +1,408 @@+use super::compile::CompiledMetricRule;+use super::ordered::InsertionMap;+use super::parse_float::js_parse_float;+use crate::attribute_value::decode_log_attribute_value;+use crate::avro::AvroMap;+use crate::filter_group::{lookup_attribute, AttrLookup};+use crate::js::{number_to_string, quote_js_string, JsObject, JsString, JsValue};+use crate::property_filter::coerce::JsTypeError;+use crate::record::LogRecord;++pub const MAX_LABEL_SETS_PER_RULE: usize = 1000;++/// Not valid JSON, so no real label set (always a JSON array) can collide with it.+pub const OVERFLOW_LABEL_KEY: &str = "__overflow__";++pub const DEFAULT_HISTOGRAM_BOUNDS: [f64; 15] = [+ 0.0, 5.0, 10.0, 25.0, 50.0, 75.0, 100.0, 250.0, 500.0, 750.0, 1000.0, 2500.0, 5000.0, 7500.0,+ 10000.0,+];++/// In UTF-16 code units, as `str.length` counts.+pub const MAX_LABEL_VALUE_LENGTH: usize = 256;++/// Older records never feed a metric, so a backfill cannot distort the current data point.+pub const MAX_RECORD_AGE_MS: f64 = 20.0 * 60.0 * 1000.0;++pub const SPAN_VALUE_DURATION_MS: &str = "duration_ms";++const ATTRIBUTES_PREFIX: &str = "attributes.";+const RESOURCE_ATTRIBUTES_PREFIX: &str = "resource_attributes.";++fn span_status_code_label(code: i64) -> Option<&'static str> {+ match code {+ 0 => Some("UNSET"),+ 1 => Some("OK"),+ 2 => Some("ERROR"),+ _ => None,+ }+}++fn span_kind_label(kind: i64) -> Option<&'static str> {+ match kind {+ 1 => Some("INTERNAL"),+ 2 => Some("SERVER"),+ 3 => Some("CLIENT"),+ 4 => Some("PRODUCER"),+ 5 => Some("CONSUMER"),+ _ => None,+ }+}++/// Node attribute maps are plain objects, so `attributes.constructor` reads an `Object.prototype` member instead of a string.+#[derive(Debug, Clone, PartialEq, Eq, Hash)]+pub enum LabelValue {+ String(JsString),+ /// A prototype method: `JSON.stringify` writes it as `null` in an array and omits it as a property.+ Function,+ /// `Object.prototype`, from `attributes.__proto__`: `JSON.stringify` writes `{}`.+ PrototypeObject,+}++impl LabelValue {+ pub fn empty() -> Self {+ LabelValue::String(JsString::new())+ }++ pub fn to_json(&self) -> Option<JsValue> {+ match self {+ LabelValue::String(s) => Some(JsValue::String(s.clone())),+ LabelValue::Function => None,+ LabelValue::PrototypeObject => Some(JsValue::Object(JsObject::new())),+ }+ }++ pub fn as_js_string(&self) -> Option<&JsString> {+ match self {+ LabelValue::String(s) => Some(s),+ _ => None,+ }+ }+}++#[derive(Debug, Clone, PartialEq)]+pub struct MetricTallyEntry {+ pub label_values: Vec<LabelValue>,+ pub count: u64,+ pub sum: f64,+ pub bucket_counts: Option<Vec<u64>>,+ pub overflow: bool,+ pub exemplar_trace_id: Option<String>,+ pub exemplar_span_id: Option<String>,+}++#[derive(Debug, Clone, Default)]+pub struct BatchTallies {+ pub by_rule: InsertionMap<InsertionMap<MetricTallyEntry>>,+ pub series_overflow: InsertionMap<u64>,+ pub value_skipped: u64,+ pub eval_errors: u64,+}++impl BatchTallies {+ pub fn new() -> Self {+ Self::default()+ }+}++fn record_string(record: &LogRecord, name: &str) -> Option<LabelValue> {+ record+ .get_str(name)+ .map(|s| LabelValue::String(JsString::from(s)))+}++fn enum_label(value: i64, label: Option<&str>) -> LabelValue {+ LabelValue::String(JsString::from(+ label+ .map(str::to_string)+ .unwrap_or_else(|| number_to_string(value as f64)),+ ))+}++fn lookup_key(key: &JsString, record: &LogRecord) -> Result<Option<LabelValue>, JsTypeError> {+ // Every literal key, map key and prototype member is valid UTF-8, so a lone surrogate matches none.+ let Some(key) = key.as_str() else {+ return Ok(None);+ };+ Ok(match key {+ "service_name" | "severity_text" | "event_name" | "name" => record_string(record, key),+ // Labels use the OTel enum name. Filter matching keeps the number.+ "status_code" => record+ .status_code()+ .map(|code| enum_label(code, span_status_code_label(code))),+ "kind" => record+ .kind()+ .map(|kind| enum_label(kind, span_kind_label(kind))),+ _ => {+ if let Some(attr) = key.strip_prefix(ATTRIBUTES_PREFIX) {+ decoded_attr(record.attributes(), attr)?+ } else if let Some(attr) = key.strip_prefix(RESOURCE_ATTRIBUTES_PREFIX) {+ decoded_attr(record.resource_attributes(), attr)?+ } else {+ None+ }+ }+ })+}++/// Attribute values are JSON-encoded on the wire, so a label reads the decoded value.+fn decoded_attr(map: Option<&AvroMap>, key: &str) -> Result<Option<LabelValue>, JsTypeError> {+ let Some(map) = map else {+ return Ok(None);+ };+ Ok(match lookup_attribute(map, key) {+ None => None,+ Some(AttrLookup::Own(raw)) => Some(LabelValue::String(decode_log_attribute_value(raw))),+ Some(AttrLookup::Inherited(member)) => match member.length {+ // `value.length >= 2 && value.startsWith(...)`: a function has no `startsWith`.+ Some(n) if n >= 2 => return Err(JsTypeError("value.startsWith is not a function")),+ Some(_) => Some(LabelValue::Function),+ None => Some(LabelValue::PrototypeObject),+ },+ })+}++/// The 256-unit cut can split a surrogate pair, and `JSON.stringify` then writes the lone half as `\udxxx`.+pub fn resolve_label_value(key: &JsString, record: &LogRecord) -> Result<LabelValue, JsTypeError> {+ Ok(match lookup_key(key, record)? {+ Some(LabelValue::String(value)) if value.utf16_len() > MAX_LABEL_VALUE_LENGTH => {+ LabelValue::String(value.utf16_slice(0, MAX_LABEL_VALUE_LENGTH))+ }+ // A function's `length` and `Object.prototype.length` never pass the cap.+ Some(value) => value,+ None => LabelValue::empty(),+ })+}++fn label_key(label_values: &[LabelValue]) -> String {+ let mut out = String::from("[");+ for (i, value) in label_values.iter().enumerate() {+ if i > 0 {+ out.push(',');+ }+ match value {+ LabelValue::String(s) => quote_js_string(s, &mut out),+ LabelValue::Function => out.push_str("null"),+ LabelValue::PrototypeObject => out.push_str("{}"),+ }+ }+ out.push(']');+ out+}++fn histogram_bucket_index(value: f64) -> usize {+ DEFAULT_HISTOGRAM_BOUNDS+ .iter()+ .position(|bound| value <= *bound)+ .unwrap_or(DEFAULT_HISTOGRAM_BOUNDS.len())+}++fn new_tally_entry(+ label_values: Vec<LabelValue>,+ with_buckets: bool,+ overflow: bool,+) -> MetricTallyEntry {+ MetricTallyEntry {+ label_values,+ count: 0,+ sum: 0.0,+ bucket_counts: with_buckets.then(|| vec![0; DEFAULT_HISTOGRAM_BOUNDS.len() + 1]),+ overflow,+ exemplar_trace_id: None,+ exemplar_span_id: None,+ }+}++fn resolve_numeric_value(key: &JsString, record: &LogRecord) -> Result<Option<f64>, JsTypeError> {+ if *key == SPAN_VALUE_DURATION_MS {+ let (Some(start), Some(end)) = (record.timestamp(), record.end_time()) else {+ return Ok(None);+ };+ // Both are below 2^53, so the conversions are exact, as the JavaScript numbers are.+ let duration_ms = (end as f64 - start as f64) / 1000.0;+ return Ok((duration_ms.is_finite() && duration_ms >= 0.0).then_some(duration_ms));+ }+ let raw = match lookup_key(key, record)? {+ None => return Ok(None),+ Some(LabelValue::String(raw)) => raw,+ // `String(member)` starts with `function` or `[object`, so `parseFloat` gives NaN.+ Some(_) => return Ok(None),+ };+ if raw.is_empty() {+ return Ok(None);+ }+ let parsed = js_parse_float(&raw);+ Ok(parsed.is_finite().then_some(parsed))+}++/// Node's `Buffer.from(s, 'base64')` skips characters outside the alphabet, accepts URL-safe too, and stops at the first `=`.+fn node_base64_decode(input: &[u8]) -> Vec<u8> {+ fn sextet(c: u8) -> Option<u32> {+ Some(match c {+ b'A'..=b'Z' => c - b'A',+ b'a'..=b'z' => c - b'a' + 26,+ b'0'..=b'9' => c - b'0' + 52,+ b'+' | b'-' => 62,+ b'/' | b'_' => 63,+ _ => return None,+ } as u32)+ }+ let mut out = Vec::with_capacity(input.len() / 4 * 3 + 2);+ let mut acc = 0u32;+ let mut n = 0;+ for &c in input {+ if c == b'=' {+ break;+ }+ let Some(v) = sextet(c) else { continue };+ acc = (acc << 6) | v;+ n += 1;+ if n == 4 {+ out.extend_from_slice(&[(acc >> 16) as u8, (acc >> 8) as u8, acc as u8]);+ acc = 0;+ n = 0;+ }+ }+ match n {+ 2 => out.push((acc >> 4) as u8),+ 3 => out.extend_from_slice(&[(acc >> 10) as u8, (acc >> 2) as u8]),+ _ => {}+ }+ out+}++/// capture-logs writes the ids as base64 text, so a length mismatch decodes it.+pub fn id_to_hex(buffer: Option<&[u8]>, expected_bytes: usize) -> Option<String> {+ let buffer = buffer.filter(|b| !b.is_empty())?;+ let decoded;+ let bytes = if buffer.len() != expected_bytes {+ // `buffer.toString('ascii')` clears the high bit of each byte.+ let ascii: Vec<u8> = buffer.iter().map(|b| b & 0x7f).collect();+ decoded = node_base64_decode(&ascii);+ if decoded.len() != expected_bytes {+ return None;+ }+ &decoded[..]+ } else {+ buffer+ };+ if bytes.iter().all(|b| *b == 0) {+ return None;+ }+ Some(hex::encode(bytes))+}++pub type AdmitLabelSet<'a> = &'a mut dyn FnMut(&str, &str) -> bool;++/// `Err` is a throw that Node does not catch. The tallies keep what earlier records added, as in Node.+pub fn tally_records(+ rules: &[CompiledMetricRule],+ records: &[LogRecord],+ tallies: &mut BatchTallies,+ now_ms: f64,+ mut admit_label_set: Option<AdmitLabelSet<'_>>,+) -> Result<(), JsTypeError> {+ if rules.is_empty() || records.is_empty() {+ return Ok(());+ }+ for record in records {+ // A span's timestamp is its start, so gate on end_time. A null timestamp means "now", so it passes.+ let observed_at_micros = record.end_time().or_else(|| record.timestamp());+ if let Some(micros) = observed_at_micros {+ if now_ms - micros as f64 / 1000.0 > MAX_RECORD_AGE_MS {+ continue;+ }+ }+ for rule in rules {+ if let Some(group) = &rule.filter_group {+ match group.matches(record) {+ Ok(true) => {}+ Ok(false) => continue,+ Err(_) => {+ tallies.eval_errors += 1;+ continue;+ }+ }+ }+ let mut value = 1.0;+ if let Some(key) = &rule.value_attribute {+ match resolve_numeric_value(key, record)? {+ Some(parsed) => value = parsed,+ None => {+ tallies.value_skipped += 1;+ continue;+ }+ }+ }++ let label_values = rule+ .group_by+ .iter()+ .map(|key| resolve_label_value(key, record))+ .collect::<Result<Vec<_>, _>>()?;+ let label_key = label_key(&label_values);++ let rule_tallies = tallies+ .by_rule+ .get_or_insert_with(&rule.id, InsertionMap::new);+ let entry_key = if rule_tallies.contains_key(&label_key) {+ label_key+ } else {+ let has_overflow = rule_tallies.contains_key(OVERFLOW_LABEL_KEY);+ let real_label_sets = rule_tallies.len() - usize::from(has_overflow);+ let admitted = real_label_sets < MAX_LABEL_SETS_PER_RULE+ && admit_label_set+ .as_mut()+ .is_none_or(|admit| admit(&rule.id, &label_key));+ if admitted {+ let entry =+ new_tally_entry(label_values, rule.value_attribute.is_some(), false);+ rule_tallies.insert(&label_key, entry);+ label_key+ } else {+ // Past the cap the record still counts, on one shared series.+ *tallies.series_overflow.get_or_insert_with(&rule.id, || 0) += 1;+ if !has_overflow {+ let entry = new_tally_entry(+ vec![LabelValue::empty(); rule.group_by.len()],+ rule.value_attribute.is_some(),+ true,+ );+ rule_tallies.insert(OVERFLOW_LABEL_KEY, entry);+ }+ OVERFLOW_LABEL_KEY.to_string()+ }+ };+ let entry = rule_tallies+ .get_mut(&entry_key)+ .expect("entry was found or inserted");+ entry.count += 1;+ entry.sum += value;+ if let Some(buckets) = &mut entry.bucket_counts {+ buckets[histogram_bucket_index(value)] += 1;+ }+ if entry.exemplar_trace_id.is_none() {+ if let Some(trace_id) = id_to_hex(record.trace_id(), 16) {+ entry.exemplar_trace_id = Some(trace_id);+ entry.exemplar_span_id = id_to_hex(record.span_id(), 8);+ }+ }+ }+ }+ Ok(())+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn histogram_buckets_are_upper_inclusive() {+ assert_eq!(histogram_bucket_index(-1.0), 0);+ assert_eq!(histogram_bucket_index(0.0), 0);+ assert_eq!(histogram_bucket_index(5.0), 1);+ assert_eq!(histogram_bucket_index(5.5), 2);+ assert_eq!(histogram_bucket_index(10000.0), 14);+ assert_eq!(histogram_bucket_index(10000.1), 15);+ }+}diff --git a/rust/logs-ingestion/src/normalize.rs b/rust/logs-ingestion/src/normalize.rsnew file mode 100644index 000000000000..aaca105a3f28--- /dev/null+++ b/rust/logs-ingestion/src/normalize.rs@@ -0,0 +1,765 @@+//! The flatten keeps or evicts attributes by JavaScript key order: array-index keys first, then insertion order.+//! Only the Prometheus counter counts enrichment skips, where the TypeScript also adds an OpenTelemetry counter.++use std::collections::BTreeMap;+use std::sync::Arc;++use hashbrown::HashTable;++use metrics::counter;+use serde::Deserialize;++use crate::avro::{AvroMap, AvroValue};+use crate::body_parse::{parse_log_body_for_ingestion, LogBodyParseResult};+use crate::js::object::hash_key;+use crate::js::{+ is_array_index, json_parse, json_stringify, json_stringify_into, quote_js_string,+ CharOrSurrogate, JsKey, JsObject, JsString, JsValue,+};+use crate::pii::{scrub_log_record, PiiScrubStats, EMPTY_PII};+use crate::record::LogRecord;++pub const MAX_LOG_RECORD_BYTES: usize = 1024 * 1024;+pub const MAX_JSON_ATTRIBUTES: usize = 50;+pub const MAX_JSON_NODES: usize = 10_000;+pub const MAX_JSON_DEPTH: usize = 128;+// The flatten must stop before it can reach a value that `json_parse` did not build.+const _: () = assert!(MAX_JSON_DEPTH < crate::js::MAX_BUILT_DEPTH);++/// A missing key reads as `undefined`.+#[derive(Debug, Clone, Default, PartialEq, Deserialize)]+pub struct LogsSettings {+ #[serde(default)]+ pub capture_console_logs: Option<bool>,+ #[serde(default)]+ pub json_parse_logs: Option<bool>,+ #[serde(default)]+ pub json_parse_logs_attribute_key: Option<String>,+ #[serde(default)]+ pub pii_scrub_logs: Option<bool>,+ #[serde(default)]+ pub retention_days: Option<f64>,+ #[serde(default)]+ pub retention_last_updated: Option<String>,+}++impl LogsSettings {+ /// An empty key is off, as `Boolean(key)` is.+ pub fn attribute_key(&self) -> Option<&str> {+ self.json_parse_logs_attribute_key+ .as_deref()+ .filter(|k| !k.is_empty())+ }+}++pub fn log_record_size_bytes(record: &LogRecord) -> usize {+ let mut bytes = 0;+ for value in [record.body(), record.severity_text()]+ .into_iter()+ .flatten()+ {+ bytes += value.len();+ }+ for attributes in [record.attributes(), record.resource_attributes()]+ .into_iter()+ .flatten()+ {+ for (key, value) in attributes.iter_strings() {+ bytes += key.len() + value.len();+ }+ }+ bytes+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum JsonEnrichmentSource {+ Body,+ SelectedAttribute,+}++impl JsonEnrichmentSource {+ fn as_str(self) -> &'static str {+ match self {+ JsonEnrichmentSource::Body => "body",+ JsonEnrichmentSource::SelectedAttribute => "selected_attribute",+ }+ }+}++fn record_json_enrichment_skip(reason: &'static str, source: JsonEnrichmentSource) {+ counter!(+ "logs_ingestion_json_enrichment_skipped_total",+ "reason" => reason,+ "source" => source.as_str()+ )+ .increment(1);+}++/// Every character the regex consumes is ASCII, so 64 UTF-16 units are 64 bytes up to where the scan stops.+fn looks_like_json(value: &str) -> bool {+ let bytes = &value.as_bytes()[..value.len().min(64)];+ let is_space = |b: u8| matches!(b, b' ' | b'\t' | b'\r' | b'\n');+ let mut i = 0;+ while i < bytes.len() && is_space(bytes[i]) {+ i += 1;+ }+ if i < bytes.len() && bytes[i] == b'"' {+ i += 1;+ }+ loop {+ match bytes.get(i) {+ Some(&b) if is_space(b) => i += 1,+ Some(b'\\') if matches!(bytes.get(i + 1), Some(b'n' | b'r' | b't')) => i += 2,+ Some(b'{' | b'[') => return true,+ _ => return false,+ }+ }+}++pub fn sniff_json_log_attributes<'a>(+ records: impl IntoIterator<Item = &'a LogRecord>,+ attribute_key: &str,+ team_id: i64,+) {+ let team_id: Arc<str> = Arc::from(team_id.to_string());+ for record in records {+ let outcome = match record.attributes().and_then(|a| a.get(attribute_key)) {+ None => "missing_key",+ Some(value) => match value.as_str() {+ Some(text) if looks_like_json(text) => "looks_like_json",+ _ => "other",+ },+ };+ counter!(+ "logs_ingestion_json_attribute_sniff_total",+ "team_id" => team_id.clone(),+ "outcome" => outcome+ )+ .increment(1);+ }+}++fn count_json_nodes_within_budget(value: &JsValue, depth: usize, budget: usize) -> Option<usize> {+ let mut stack = vec![(value, depth)];+ let mut nodes = 1usize;+ while let Some((value, depth)) = stack.pop() {+ if nodes > budget || depth > MAX_JSON_DEPTH {+ return None;+ }+ let children: Box<dyn Iterator<Item = &JsValue>> = match value {+ JsValue::Array(items) => Box::new(items.iter()),+ JsValue::Object(object) => Box::new(object.iter().map(|(_, v)| v)),+ _ => continue,+ };+ for child in children {+ nodes += 1;+ if nodes > budget {+ return None;+ }+ stack.push((child, depth + 1));+ }+ }+ Some(nodes)+}++pub type FlatAttributes = Vec<(JsString, String)>;++#[derive(Debug, Clone, PartialEq)]+pub struct FlattenResult {+ pub values: JsObject,+ pub attributes: FlatAttributes,+}++/// `result` and `attributes` always hold the same keys, so one entry holds both.+struct FlatEntry {+ key: JsString,+ value: Option<JsValue>,+ serialized: String,+}++#[derive(Clone, Copy)]+enum FlatPos {+ Index(u32),+ Named(Option<usize>),+}++#[derive(Default)]+struct FlatObject {+ indexed: BTreeMap<u32, FlatEntry>,+ named: Vec<FlatEntry>,+ named_position: HashTable<usize>,+}++impl FlatObject {+ fn named_index(&self, key: &JsString) -> Option<usize> {+ self.named_position+ .find(hash_key(key), |&i| self.named[i].key == *key)+ .copied()+ }++ fn get(&self, key: &JsString) -> Option<&FlatEntry> {+ self.at(self.locate(key))+ }++ fn locate(&self, key: &JsString) -> FlatPos {+ match is_index_key(key) {+ Some(n) => FlatPos::Index(n),+ None => FlatPos::Named(self.named_index(key)),+ }+ }++ fn at(&self, pos: FlatPos) -> Option<&FlatEntry> {+ match pos {+ FlatPos::Index(n) => self.indexed.get(&n),+ FlatPos::Named(i) => i.map(|i| &self.named[i]),+ }+ }++ /// Stores `entry` at `pos`, which `locate` gave for its key with no removal since.+ fn set_at(&mut self, pos: FlatPos, entry: FlatEntry) {+ match pos {+ FlatPos::Index(n) => {+ self.indexed.insert(n, entry);+ }+ FlatPos::Named(Some(i)) => self.named[i] = entry,+ FlatPos::Named(None) => {+ let named = &self.named;+ self.named_position+ .insert_unique(hash_key(&entry.key), named.len(), |&j| {+ hash_key(&named[j].key)+ });+ self.named.push(entry);+ }+ }+ }++ fn remove(&mut self, key: &JsString) {+ if let Some(n) = is_index_key(key) {+ self.indexed.remove(&n);+ } else if let Some(i) = self.named_index(key) {+ self.named.remove(i);+ self.named_position.clear();+ let named = &self.named;+ for (j, entry) in named.iter().enumerate() {+ self.named_position+ .insert_unique(hash_key(&entry.key), j, |&k| hash_key(&named[k].key));+ }+ }+ }++ fn last_key(&self) -> Option<&JsString> {+ match self.named.last() {+ Some(entry) => Some(&entry.key),+ None => self.indexed.values().next_back().map(|entry| &entry.key),+ }+ }++ fn into_entries(self) -> impl Iterator<Item = FlatEntry> {+ self.indexed.into_values().chain(self.named)+ }+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum ArrayMode {+ Indexed,+ String,+}++fn is_index_key(key: &JsString) -> Option<u32> {+ key.as_str().and_then(is_array_index)+}++enum Leaf<'a> {+ Value(&'a JsValue),+ Stringified(String),+}++/// Recurses in the TypeScript stack order with the same budget updates per node, so it evicts exactly where the TypeScript does.+struct Flattener {+ max_attributes: usize,+ max_bytes: usize,+ array_mode: ArrayMode,+ keep_values: bool,+ nodes: usize,+ path_bytes: usize,+ attribute_bytes: i64,+ attribute_count: usize,+ last_retained_key: JsString,+ result: FlatObject,+}++impl Flattener {+ /// `None` means a budget ran out.+ fn visit(&mut self, node: &JsValue, path: &mut JsString, depth: usize) -> Option<()> {+ if depth > MAX_JSON_DEPTH || self.path_bytes > self.max_bytes {+ return None;+ }+ match node {+ JsValue::Array(_) if self.array_mode == ArrayMode::String => {+ let array_nodes =+ count_json_nodes_within_budget(node, depth, MAX_JSON_NODES - self.nodes + 1)?;+ self.nodes += array_nodes - 1;+ self.leaf(path, Leaf::Stringified(json_stringify(node)))+ }+ JsValue::Array(items) => {+ if items.len() + self.nodes > MAX_JSON_NODES {+ return None;+ }+ self.nodes += items.len();+ let keys = (0..items.len()).map(|i| JsKey::Index(i as u32));+ self.add_child_paths(path, keys)?;+ self.visit_children(+ path,+ depth,+ items+ .iter()+ .enumerate()+ .map(|(i, v)| (JsKey::Index(i as u32), v)),+ )+ }+ JsValue::Object(object) => {+ let n = object.len();+ if n > 0 && self.nodes + n > MAX_JSON_NODES {+ return None;+ }+ self.nodes += n;+ self.add_child_paths(path, object.entries().map(|(k, _)| k))?;+ self.visit_children(path, depth, object.entries())+ }+ _ => self.leaf(path, Leaf::Value(node)),+ }+ }++ /// Adds the byte length of every child path, as the TypeScript does before it descends.+ fn add_child_paths<'k>(+ &mut self,+ path: &JsString,+ keys: impl Iterator<Item = JsKey<'k>>,+ ) -> Option<()> {+ let base = path.utf8_byte_len();+ for key in keys {+ self.path_bytes += if base == 0 {+ key.utf8_byte_len()+ } else {+ base + 1 + key.utf8_byte_len()+ };+ if self.path_bytes > self.max_bytes {+ return None;+ }+ }+ Some(())+ }++ fn visit_children<'v>(+ &mut self,+ path: &mut JsString,+ depth: usize,+ children: impl Iterator<Item = (JsKey<'v>, &'v JsValue)>,+ ) -> Option<()> {+ let base = path.utf8_byte_len();+ let base_surrogates = path.lone_surrogate_count();+ for (key, child) in children {+ if base > 0 {+ path.push_str(".");+ }+ key.push_onto(path);+ self.visit(child, path, depth + 1)?;+ path.truncate_to(base, base_surrogates);+ }+ Some(())+ }++ fn leaf(&mut self, key: &JsString, leaf: Leaf<'_>) -> Option<()> {+ if key.is_empty() || *key == "__proto__" || self.max_attributes == 0 {+ return Some(());+ }+ let pos = self.result.locate(key);+ let exists = self.result.at(pos).is_some();+ if !exists && self.attribute_count >= self.max_attributes {+ let Some(index) = is_index_key(key) else {+ return Some(());+ };+ let last_key = self.last_retained_key.clone();+ if let Some(last_index) = is_index_key(&last_key) {+ if last_index <= index {+ return Some(());+ }+ }+ if let Some(entry) = self.result.get(&last_key) {+ self.attribute_bytes -= (last_key.utf8_byte_len() + entry.serialized.len()) as i64;+ }+ self.result.remove(&last_key);+ self.attribute_count -= 1;+ }+ let (serialized, value) = match leaf {+ Leaf::Value(JsValue::Null) => (+ "\"null\"".to_string(),+ self.keep_values.then(|| JsValue::string("null")),+ ),+ Leaf::Value(v) => {+ let mut serialized = String::new();+ if let JsValue::String(s) = v {+ serialized.reserve(s.utf8_byte_len() + 2);+ }+ json_stringify_into(v, &mut serialized);+ (serialized, self.keep_values.then(|| v.clone()))+ }+ Leaf::Stringified(text) => {+ let text = JsString::from(text);+ let mut serialized = String::with_capacity(text.utf8_byte_len() + 2);+ quote_js_string(&text, &mut serialized);+ (serialized, self.keep_values.then(|| JsValue::String(text)))+ }+ };+ let value_bytes = serialized.len() as i64;+ // An eviction above removes another key only when this key is absent, so `pos` holds.+ self.attribute_bytes += match self.result.at(pos) {+ Some(previous) => value_bytes - previous.serialized.len() as i64,+ None => (key.utf8_byte_len() as i64) + value_bytes,+ };+ if self.attribute_bytes > self.max_bytes as i64 {+ return None;+ }+ self.result.set_at(+ pos,+ FlatEntry {+ key: key.clone(),+ value,+ serialized,+ },+ );+ if !exists {+ self.attribute_count += 1;+ if self.attribute_count == self.max_attributes {+ self.last_retained_key = self.result.last_key().cloned().unwrap_or_default();+ }+ }+ Some(())+ }+}++fn flatten_entries(+ obj: &JsValue,+ prefix: &JsString,+ max_attributes: usize,+ max_bytes: usize,+ array_mode: ArrayMode,+ keep_values: bool,+) -> Option<FlatObject> {+ let mut flattener = Flattener {+ max_attributes,+ max_bytes,+ array_mode,+ keep_values,+ nodes: 1,+ path_bytes: prefix.utf8_byte_len(),+ attribute_bytes: 0,+ attribute_count: 0,+ last_retained_key: JsString::new(),+ result: FlatObject::default(),+ };+ let mut path = prefix.clone();+ flattener.visit(obj, &mut path, 0)?;+ Some(flattener.result)+}++pub fn flatten_json_with_budget(+ obj: &JsValue,+ prefix: &JsString,+ max_attributes: usize,+ max_bytes: usize,+ array_mode: ArrayMode,+) -> Option<FlattenResult> {+ let result = flatten_entries(obj, prefix, max_attributes, max_bytes, array_mode, true)?;+ let mut values = JsObject::new();+ let mut attributes = Vec::new();+ for entry in result.into_entries() {+ values.insert(entry.key.clone(), entry.value.expect("values are kept"));+ attributes.push((entry.key, entry.serialized));+ }+ Some(FlattenResult { values, attributes })+}++fn flatten_attributes(+ obj: &JsValue,+ prefix: &JsString,+ array_mode: ArrayMode,+) -> Option<FlatAttributes> {+ let result = flatten_entries(+ obj,+ prefix,+ MAX_JSON_ATTRIBUTES,+ MAX_LOG_RECORD_BYTES,+ array_mode,+ false,+ )?;+ Some(+ result+ .into_entries()+ .map(|entry| (entry.key, entry.serialized))+ .collect(),+ )+}++pub fn flatten_json(obj: &JsValue) -> Option<JsObject> {+ flatten_json_with_budget(+ obj,+ &JsString::new(),+ MAX_JSON_ATTRIBUTES,+ MAX_LOG_RECORD_BYTES,+ ArrayMode::Indexed,+ )+ .map(|r| r.values)+}++fn json_attributes_from_body_parse(body_parse: &LogBodyParseResult) -> FlatAttributes {+ let LogBodyParseResult::JsonObjectOrArray { value } = body_parse else {+ return Vec::new();+ };+ match flatten_attributes(value, &JsString::new(), ArrayMode::Indexed) {+ Some(attributes) => attributes,+ None => {+ record_json_enrichment_skip("flatten_budget", JsonEnrichmentSource::Body);+ Vec::new()+ }+ }+}++pub fn extract_json_attributes_from_body(body: Option<&str>) -> FlatAttributes {+ if let Some(body) = body {+ if body.len() > MAX_LOG_RECORD_BYTES {+ record_json_enrichment_skip("input_size", JsonEnrichmentSource::Body);+ return Vec::new();+ }+ }+ json_attributes_from_body_parse(&parse_log_body_for_ingestion(body))+}++/// A key with a lone surrogate merges here with a U+FFFD key, where JavaScript keeps two keys. See PORTING.md.+fn add_json_attributes(+ record: &mut LogRecord,+ json_attributes: FlatAttributes,+ mut record_bytes: usize,+ source: JsonEnrichmentSource,+) {+ if json_attributes.is_empty() {+ return;+ }+ let existing = record.attributes();+ for (key, value) in &json_attributes {+ let present = match (existing, key.as_str()) {+ (Some(attributes), Some(key)) => attributes.contains_key(key),+ _ => false,+ };+ if !present {+ record_bytes += key.utf8_byte_len() + value.len();+ if record_bytes > MAX_LOG_RECORD_BYTES {+ record_json_enrichment_skip("output_size", source);+ return;+ }+ }+ }+ let mut merged = AvroMap::new();+ for (key, value) in json_attributes {+ merged.define(key.into_string_lossy(), AvroValue::String(value));+ }+ if let Some(AvroValue::Map(attributes)) = record.get_mut("attributes") {+ for (key, value) in std::mem::take(attributes).into_entries() {+ merged.define(key, value);+ }+ }+ record.set("attributes", AvroValue::Map(merged));+}++/// Pass `body_parse` to reuse a parse of the same body.+pub fn enrich_log_record_with_json_attributes(+ record: &mut LogRecord,+ body_parse: Option<&LogBodyParseResult>,+) {+ let Some(body) = record.body().filter(|b| !b.is_empty()) else {+ return;+ };+ if body.len() > MAX_LOG_RECORD_BYTES {+ record_json_enrichment_skip("input_size", JsonEnrichmentSource::Body);+ return;+ }+ let owned;+ let parse = match body_parse {+ Some(parse) => parse,+ None => {+ owned = parse_log_body_for_ingestion(Some(body));+ &owned+ }+ };+ if !matches!(parse, LogBodyParseResult::JsonObjectOrArray { .. }) {+ return;+ }+ let record_bytes = log_record_size_bytes(record);+ if record_bytes > MAX_LOG_RECORD_BYTES {+ record_json_enrichment_skip("input_size", JsonEnrichmentSource::Body);+ return;+ }+ let json_attributes = json_attributes_from_body_parse(parse);+ add_json_attributes(+ record,+ json_attributes,+ record_bytes,+ JsonEnrichmentSource::Body,+ );+}++/// A raw lone surrogate inside a string literal means its `\uXXXX` escape, so the text is rewritten with escapes.+fn json_parse_js(text: &JsString) -> Option<JsValue> {+ if let Some(text) = text.as_str() {+ return json_parse(text).ok();+ }+ let mut rewritten = String::new();+ let mut backslashes = 0usize;+ for unit in text.chars_or_surrogates() {+ match unit {+ CharOrSurrogate::Char(c) => {+ backslashes = if c == '\\' { backslashes + 1 } else { 0 };+ rewritten.push(c);+ }+ CharOrSurrogate::Surrogate(s) => {+ if backslashes % 2 == 1 {+ return None;+ }+ backslashes = 0;+ rewritten.push_str(&format!("\\u{s:04x}"));+ }+ }+ }+ json_parse(&rewritten).ok()+}++pub fn enrich_log_record_from_json_attribute(record: &mut LogRecord, key: &str) {+ let Some(raw) = record.attributes().and_then(|a| a.get(key)) else {+ return;+ };+ let Some(raw) = raw.as_str() else {+ return;+ };+ let record_bytes = log_record_size_bytes(record);+ if record_bytes > MAX_LOG_RECORD_BYTES {+ record_json_enrichment_skip("input_size", JsonEnrichmentSource::SelectedAttribute);+ return;+ }+ let mut parsed = match json_parse(raw) {+ Ok(parsed) => parsed,+ Err(_) => return,+ };+ if let JsValue::String(inner) = &parsed {+ parsed = match json_parse_js(inner) {+ Some(parsed) => parsed,+ None => return,+ };+ }+ if !matches!(parsed, JsValue::Object(_)) {+ return;+ }+ match flatten_attributes(&parsed, &JsString::from(key), ArrayMode::String) {+ Some(attributes) => add_json_attributes(+ record,+ attributes,+ record_bytes,+ JsonEnrichmentSource::SelectedAttribute,+ ),+ None => {+ record_json_enrichment_skip("flatten_budget", JsonEnrichmentSource::SelectedAttribute)+ }+ }+}++/// Sender attributes win over selected-attribute fields, and those win over body fields.+pub fn transform_decoded_log_records_in_place(+ records: &mut [LogRecord],+ settings: &LogsSettings,+) -> PiiScrubStats {+ let mut pii = EMPTY_PII;+ if settings.pii_scrub_logs.unwrap_or(false) {+ for record in records.iter_mut() {+ pii.pii_replacements += scrub_log_record(record).pii_replacements;+ }+ }+ if let Some(key) = settings.attribute_key() {+ for record in records.iter_mut() {+ enrich_log_record_from_json_attribute(record, key);+ }+ }+ if settings.json_parse_logs.unwrap_or(false) {+ // No enrichment changes a body, so one parse per record in this loop equals Node's parse-all-first order.+ for record in records.iter_mut() {+ let parse = parse_log_body_for_ingestion(+ record.body().filter(|b| b.len() <= MAX_LOG_RECORD_BYTES),+ );+ enrich_log_record_with_json_attributes(record, Some(&parse));+ }+ }+ pii+}++/// Cheapest first.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum BufferProcessingMode {+ Passthrough,+ DecodeOnly,+ DecodeAndReencode,+}++pub fn buffer_processing_mode(+ settings: &LogsSettings,+ stage_count: usize,+ has_visitor: bool,+) -> BufferProcessingMode {+ let normalize_active = settings.json_parse_logs.unwrap_or(false)+ || settings.pii_scrub_logs.unwrap_or(false)+ || settings.attribute_key().is_some();+ if normalize_active || stage_count > 0 {+ BufferProcessingMode::DecodeAndReencode+ } else if has_visitor {+ BufferProcessingMode::DecodeOnly+ } else {+ BufferProcessingMode::Passthrough+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn sniff_matches_the_regex() {+ for (value, expected) in [+ ("{", true),+ (" \"{", true),+ ("\"\\n\\t [", true),+ ("\\n{", true),+ ("\"\"{", false),+ ("x{", false),+ ("\u{000B}{", false),+ ("\\x{", false),+ ("", false),+ ] {+ assert_eq!(looks_like_json(value), expected, "{value:?}");+ }+ let far = format!("{}{{", " ".repeat(64));+ assert!(!looks_like_json(&far));+ }++ #[test]+ fn a_raw_lone_surrogate_parses_as_its_escape() {+ let mut text = JsString::from("{\"a\":\"");+ text.push_code_unit(0xD800);+ text.push_str("\"}");+ let JsValue::Object(o) = json_parse_js(&text).unwrap() else {+ panic!("not an object");+ };+ assert_eq!(json_stringify(o.get("a").unwrap()), "\"\\ud800\"");++ let mut escaped = JsString::from("\"\\");+ escaped.push_code_unit(0xD800);+ escaped.push_str("\"");+ assert!(json_parse_js(&escaped).is_none());+ }+}diff --git a/rust/logs-ingestion/src/pattern.rs b/rust/logs-ingestion/src/pattern.rsnew file mode 100644index 000000000000..d35c393a6cc0--- /dev/null+++ b/rust/logs-ingestion/src/pattern.rs@@ -0,0 +1,514 @@+//! node-re2's `replace` writes each lone surrogate as U+FFFD, even with no match, so this port masks the lossy UTF-8 form.++use std::borrow::Cow;+use std::sync::LazyLock;+use std::time::Instant;++use metrics::{counter, histogram};++use crate::js::{+ json_parse_shape, utf16_len, utf16_prefix_lossy, utf16_slice_lossy, JsString, JsonShape,+};+use crate::pii::RuleRegex;+use crate::record::LogRecord;++pub const PATTERN_VERSION: i64 = 6;++/// Both caps count UTF-16 units.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub struct PatternCaps {+ pub max_input_chars: usize,+ pub max_output_chars: usize,+}++pub const PATTERN_CAPS: PatternCaps = PatternCaps {+ max_input_chars: 8192,+ max_output_chars: 1024,+};++pub const JSON_ARRAY: &str = "<JSON_ARRAY>";+pub const KEY_SET_MAX_KEYS: usize = 32;+pub const MESSAGE_KEYS: [&str; 3] = ["message", "msg", "event"];++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub struct MaskRule {+ pub name: &'static str,+ /// The pattern text exactly as the TypeScript builds it for RE2.+ pub pattern: &'static str,+ pub replacement: &'static str,+}++// The expansion of the TypeScript's date fragments. A test in this file rebuilds it from the fragments.+#[cfg(test)]+const MONTH: &str = "(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)";+#[cfg(test)]+const WEEKDAY: &str = "(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)";+#[cfg(test)]+const DAY_OF_MONTH: &str = r"(?:0?[1-9]|[12]\d|3[01])";+#[cfg(test)]+const TIME_OF_DAY: &str = r"\d{2}:\d{2}:\d{2}";+#[cfg(test)]+const YEAR: &str = r"(?:19|20)\d{2}";+#[cfg(test)]+const ZONE: &str = "(?:UT|UTC|GMT|Z|E[SD]T|C[SD]T|M[SD]T|P[SD]T|AK[SD]T|H[SD]T|A[SD]T|N[SD]T|CES?T|EES?T|WES?T|BST|IST|MSK|JST|KST|HKT|SGT|ICT|AE[SD]T|AC[SD]T|AWST|NZ[SD]T|SAST|WAT|CAT|EAT|BRT|ART|GST|PKT)";++macro_rules! klog_rule {+ ($letter:literal) => {+ MaskRule {+ name: "klogtime",+ pattern: concat!(+ r"\b",+ $letter,+ r"(?:0[1-9]|1[0-2])(?:0[1-9]|[12]\d|3[01]) \d{2}:\d{2}:\d{2}(?:\.\d+)?"+ ),+ replacement: concat!($letter, "<KLOGTIME>"),+ }+ };+}++pub const MASK_RULES: [MaskRule; 22] = [+ MaskRule {+ name: "timestamp",+ pattern: r"\b\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:[.,]\d+)?(?:Z|[+-]\d{2}:?\d{2})?",+ replacement: "<TIMESTAMP>",+ },+ klog_rule!("I"),+ klog_rule!("W"),+ klog_rule!("E"),+ klog_rule!("F"),+ MaskRule {+ name: "clftime",+ pattern: r"\b\d{2}/(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)/(?:19|20)\d{2}:\d{2}:\d{2}:\d{2}(?: [+-]\d{4})?",+ replacement: "<TIMESTAMP>",+ },+ MaskRule {+ name: "ctime",+ pattern: r"\b(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) {1,2}(?:0?[1-9]|[12]\d|3[01]) \d{2}:\d{2}:\d{2}(?: (?:UT|UTC|GMT|Z|E[SD]T|C[SD]T|M[SD]T|P[SD]T|AK[SD]T|H[SD]T|A[SD]T|N[SD]T|CES?T|EES?T|WES?T|BST|IST|MSK|JST|KST|HKT|SGT|ICT|AE[SD]T|AC[SD]T|AWST|NZ[SD]T|SAST|WAT|CAT|EAT|BRT|ART|GST|PKT))? (?:19|20)\d{2}",+ replacement: "<TIMESTAMP>",+ },+ MaskRule {+ name: "httpdate",+ pattern: r"\b(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (?:0?[1-9]|[12]\d|3[01]) (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (?:19|20)\d{2} \d{2}:\d{2}:\d{2}(?: GMT| UTC| [+-]\d{4})?",+ replacement: "<TIMESTAMP>",+ },+ MaskRule {+ name: "syslogtime",+ pattern: r"\b(?:(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) )?(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) {1,2}(?:0?[1-9]|[12]\d|3[01]) \d{2}:\d{2}:\d{2}",+ replacement: "<TIMESTAMP>",+ },+ MaskRule {+ name: "email",+ pattern: r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}",+ replacement: "<EMAIL>",+ },+ MaskRule {+ name: "id",+ pattern: r"\b[a-z]{2,10}_(?:[A-Za-z0-9]*[A-Z][A-Za-z0-9]*[0-9]|[A-Za-z0-9]*[0-9][A-Za-z0-9]*[A-Z])[A-Za-z0-9]*(?:-[A-Za-z0-9]+)*",+ replacement: "<ID>",+ },+ MaskRule {+ name: "stripeid",+ pattern: r"\b(?:cus|sub)_[A-Z][A-Za-z]{13}(?:[A-Za-z]{10})?\b",+ replacement: "<ID>",+ },+ MaskRule {+ name: "snakeuuid",+ pattern: r"_\d{4,}(?:_\d+)*_[0-9a-fA-F]*[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}",+ replacement: "_<N>_<UUID>",+ },+ MaskRule {+ name: "snakeuuid",+ pattern: r"_[0-9a-fA-F]*[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}",+ replacement: "_<UUID>",+ },+ MaskRule {+ name: "uuid",+ pattern: r"[0-9a-fA-F]*[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}",+ replacement: "<UUID>",+ },+ MaskRule {+ name: "snakenum",+ pattern: r"_\d{4,}(?:_\d+)*\b",+ replacement: "_<N>",+ },+ MaskRule {+ name: "host",+ pattern: r"\b(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.){1,8}(?:ai|app|aws|bot|cloud|co|com|de|dev|eu|fr|gg|internal|io|jp|local|me|net|nl|org|tv|uk|us|xyz)\b",+ replacement: "<HOST>",+ },+ MaskRule {+ name: "hex0x",+ pattern: r"\b0x[0-9a-fA-F]+\b",+ replacement: "<HEX>",+ },+ MaskRule {+ name: "ipv4",+ pattern: r"\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b",+ replacement: "<IP>",+ },+ MaskRule {+ name: "num",+ pattern: r"\b\d+\b",+ replacement: "<N>",+ },+ MaskRule {+ name: "hex",+ pattern: r"\b[0-9a-fA-F]{8,}\b",+ replacement: "<HEX>",+ },+ MaskRule {+ name: "num",+ pattern: r"\b\d+",+ replacement: "<N>",+ },+];++static MASK_RULE_RE: LazyLock<RuleRegex> =+ LazyLock::new(|| RuleRegex::new(MASK_RULES.iter().map(|r| r.pattern)));++pub type RuleFires = [u64; MASK_RULES.len()];++fn mask_into(input: &str, rule_fires: &mut RuleFires) -> String {+ let mut out = String::with_capacity(input.len());+ let mut copied_up_to = 0;+ for (start, end, rule) in MASK_RULE_RE.matches(input) {+ rule_fires[rule] += 1;+ out.push_str(&input[copied_up_to..start]);+ out.push_str(MASK_RULES[rule].replacement);+ copied_up_to = end;+ }+ out.push_str(&input[copied_up_to..]);+ out+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub struct MaskResult {+ pub masked: String,+ pub rule_fires: RuleFires,+}++pub fn mask_string(input: &str) -> MaskResult {+ let mut rule_fires = [0; MASK_RULES.len()];+ let masked = mask_into(input, &mut rule_fires);+ MaskResult { masked, rule_fires }+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum PatternBodyKind {+ Empty,+ Plaintext,+ JsonObjectOrArray,+ JsonString,+ Primitive,+}++impl PatternBodyKind {+ pub fn as_str(self) -> &'static str {+ match self {+ PatternBodyKind::Empty => "empty",+ PatternBodyKind::Plaintext => "plaintext",+ PatternBodyKind::JsonObjectOrArray => "json_object_or_array",+ PatternBodyKind::JsonString => "json_string",+ PatternBodyKind::Primitive => "primitive",+ }+ }+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub struct LogPatternResult {+ pub pattern: String,+ pub body_kind: PatternBodyKind,+ pub input_capped: bool,+ pub masked_length: usize,+ pub json_key_count: Option<usize>,+ pub rule_fires: RuleFires,+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub enum PatternInputSelection {+ Empty {+ body_kind: PatternBodyKind,+ input_capped: bool,+ },+ Mask {+ input: String,+ body_kind: PatternBodyKind,+ input_capped: bool,+ },+ Pattern {+ pattern: String,+ body_kind: PatternBodyKind,+ input_capped: bool,+ rule_fires: RuleFires,+ json_key_count: Option<usize>,+ },+}++fn cap_output(pattern: &str) -> String {+ if utf16_len(pattern) > PATTERN_CAPS.max_output_chars {+ utf16_slice_lossy(pattern, 0, PATTERN_CAPS.max_output_chars)+ } else {+ pattern.to_string()+ }+}++fn utf16_order(a: &str, b: &str) -> std::cmp::Ordering {+ if a.is_ascii() && b.is_ascii() {+ a.cmp(b)+ } else {+ a.encode_utf16().cmp(b.encode_utf16())+ }+}++/// Sorting first and then dropping repeats gives the same list as the TypeScript's dedupe in insertion order.+fn json_key_set_pattern(raw_keys: impl Iterator<Item = String>) -> (String, RuleFires) {+ let mut rule_fires = [0; MASK_RULES.len()];+ let mut keys: Vec<String> = raw_keys+ .map(|key| mask_into(&key, &mut rule_fires))+ .collect();+ keys.sort_by(|a, b| utf16_order(a, b));+ keys.dedup();+ let kept = keys.len().min(KEY_SET_MAX_KEYS);+ let overflow = keys.len() - kept;+ let mut pattern = format!("<JSON:{}", keys[..kept].join(","));+ if overflow > 0 {+ pattern.push_str(&format!(",+{overflow}"));+ }+ pattern.push('>');+ (pattern, rule_fires)+}++pub fn select_pattern_input(body: Option<&str>, message_keys: &[&str]) -> PatternInputSelection {+ let body = match body {+ None | Some("") => {+ return PatternInputSelection::Empty {+ body_kind: PatternBodyKind::Empty,+ input_capped: false,+ }+ }+ Some(body) => body,+ };++ // A cut pair leaves a lone high surrogate, which is never valid JSON and masks as U+FFFD, so the lossy slice agrees.+ let prefix = utf16_prefix_lossy(body, PATTERN_CAPS.max_input_chars);+ let input_capped = prefix.is_some();+ let capped_body: Cow<'_, str> = match prefix {+ Some(prefix) => Cow::Owned(prefix),+ None => Cow::Borrowed(body),+ };+ let shape = json_parse_shape(&capped_body, |key| message_keys.iter().any(|m| *key == *m));+ let mask = |input: String, body_kind| PatternInputSelection::Mask {+ input,+ body_kind,+ input_capped,+ };++ match shape {+ Err(_) => mask(capped_body.into_owned(), PatternBodyKind::Plaintext),+ Ok(JsonShape::Primitive) => mask(capped_body.into_owned(), PatternBodyKind::Primitive),+ Ok(JsonShape::String(value)) => mask(+ value.to_utf8_lossy().into_owned(),+ PatternBodyKind::JsonString,+ ),+ Ok(JsonShape::Array) => PatternInputSelection::Pattern {+ pattern: JSON_ARRAY.to_string(),+ body_kind: PatternBodyKind::JsonObjectOrArray,+ input_capped,+ rule_fires: [0; MASK_RULES.len()],+ json_key_count: None,+ },+ Ok(JsonShape::Object(entries)) => {+ // A repeated key holds its last value. No inherited `Object.prototype` property is a string, so the lookup ignores them.+ let message = message_keys.iter().find_map(|key| {+ match entries.iter().rev().find(|(k, _)| *k == **key) {+ Some((_, Some(value))) => Some(value.to_utf8_lossy().into_owned()),+ _ => None,+ }+ });+ if let Some(message) = message {+ return mask(message, PatternBodyKind::JsonObjectOrArray);+ }+ let mut keys: Vec<&JsString> = entries.iter().map(|(k, _)| k).collect();+ keys.sort_unstable_by(|a, b| a.bytes_wtf8().cmp(b.bytes_wtf8()));+ keys.dedup();+ let (pattern, rule_fires) =+ json_key_set_pattern(keys.iter().map(|k| k.to_utf8_lossy().into_owned()));+ PatternInputSelection::Pattern {+ pattern,+ body_kind: PatternBodyKind::JsonObjectOrArray,+ input_capped,+ rule_fires,+ json_key_count: Some(keys.len()),+ }+ }+ }+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub struct MaskedPattern {+ pub pattern: String,+ pub masked_length: usize,+ pub rule_fires: RuleFires,+}++pub fn compute_log_pattern(input: &str) -> MaskedPattern {+ let MaskResult { masked, rule_fires } = mask_string(input);+ MaskedPattern {+ pattern: cap_output(&masked),+ masked_length: utf16_len(&masked),+ rule_fires,+ }+}++pub fn build_log_pattern(body: Option<&str>, message_keys: &[&str]) -> LogPatternResult {+ match select_pattern_input(body, message_keys) {+ PatternInputSelection::Empty {+ body_kind,+ input_capped,+ } => LogPatternResult {+ pattern: String::new(),+ body_kind,+ input_capped,+ masked_length: 0,+ json_key_count: None,+ rule_fires: [0; MASK_RULES.len()],+ },+ PatternInputSelection::Pattern {+ pattern,+ body_kind,+ input_capped,+ rule_fires,+ json_key_count,+ } => LogPatternResult {+ masked_length: utf16_len(&pattern),+ pattern: cap_output(&pattern),+ body_kind,+ input_capped,+ json_key_count,+ rule_fires,+ },+ PatternInputSelection::Mask {+ input,+ body_kind,+ input_capped,+ } => {+ let masked = compute_log_pattern(&input);+ LogPatternResult {+ pattern: masked.pattern,+ body_kind,+ input_capped,+ masked_length: masked.masked_length,+ json_key_count: None,+ rule_fires: masked.rule_fires,+ }+ }+ }+}++/// The TypeScript catches a throw here, but nothing here can fail.+pub fn stamp_pattern_batch(records: &mut [LogRecord], message_keys: &[&str]) {+ let mut kind_counts: Vec<(PatternBodyKind, u64)> = Vec::new();+ let mut rule_fires = [0u64; MASK_RULES.len()];+ let mut input_capped = 0u64;++ for record in records.iter_mut() {+ let start = Instant::now();+ let result = build_log_pattern(record.body(), message_keys);+ record.set_pattern(result.pattern, PATTERN_VERSION);+ histogram!("logs_ingestion_pattern_masking_duration_seconds")+ .record(start.elapsed().as_secs_f64());++ histogram!("logs_ingestion_pattern_masked_length_chars")+ .record(result.masked_length as f64);+ if let Some(count) = result.json_key_count {+ histogram!("logs_ingestion_pattern_keyset_keys").record(count as f64);+ }+ match kind_counts.iter_mut().find(|(k, _)| *k == result.body_kind) {+ Some((_, n)) => *n += 1,+ None => kind_counts.push((result.body_kind, 1)),+ }+ for (total, fires) in rule_fires.iter_mut().zip(result.rule_fires) {+ *total += fires;+ }+ if result.input_capped {+ input_capped += 1;+ }+ }++ for (kind, count) in kind_counts {+ counter!("logs_ingestion_pattern_body_kind_total", "kind" => kind.as_str())+ .increment(count);+ }+ for (rule, fires) in MASK_RULES.iter().zip(rule_fires) {+ if fires > 0 {+ counter!("logs_ingestion_pattern_rule_fired_total", "rule" => rule.name)+ .increment(fires);+ }+ }+ if input_capped > 0 {+ counter!("logs_ingestion_pattern_input_capped_total").increment(input_capped);+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn rule_text_matches_the_typescript_fragments() {+ let klog = |l: &str| {+ format!(r"\b{l}(?:0[1-9]|1[0-2])(?:0[1-9]|[12]\d|3[01]) {TIME_OF_DAY}(?:\.\d+)?")+ };+ let expected = [+ (+ 0,+ format!(+ r"\b\d{{4}}-\d{{2}}-\d{{2}}[T ]{TIME_OF_DAY}(?:[.,]\d+)?(?:Z|[+-]\d{{2}}:?\d{{2}})?"+ ),+ ),+ (1, klog("I")),+ (2, klog("W")),+ (3, klog("E")),+ (4, klog("F")),+ (+ 5,+ format!(r"\b\d{{2}}/{MONTH}/{YEAR}:{TIME_OF_DAY}(?: [+-]\d{{4}})?"),+ ),+ (+ 6,+ format!(+ r"\b{WEEKDAY} {MONTH} {{1,2}}{DAY_OF_MONTH} {TIME_OF_DAY}(?: {ZONE})? {YEAR}"+ ),+ ),+ (+ 7,+ format!(+ r"\b{WEEKDAY}, {DAY_OF_MONTH} {MONTH} {YEAR} {TIME_OF_DAY}(?: GMT| UTC| [+-]\d{{4}})?"+ ),+ ),+ (+ 8,+ format!(r"\b(?:{WEEKDAY} )?{MONTH} {{1,2}}{DAY_OF_MONTH} {TIME_OF_DAY}"),+ ),+ ];+ for (i, text) in expected {+ assert_eq!(MASK_RULES[i].pattern, text, "rule {i}");+ }+ }++ #[test]+ fn a_split_pair_at_the_output_cap_becomes_replacement_character() {+ let body = format!("{}{}", "z".repeat(1023), "🚀");+ let result = build_log_pattern(Some(&body), &MESSAGE_KEYS);+ assert_eq!(result.masked_length, 1025);+ assert_eq!(result.pattern, format!("{}\u{FFFD}", "z".repeat(1023)));+ }++ /// Keys that differ only by a lone surrogate merge after the mask, because node-re2 writes U+FFFD.+ #[test]+ fn lone_surrogate_keys_merge_after_the_mask() {+ let result = build_log_pattern(Some(r#"{"\ud800":1,"\ud801":2,"b":3}"#), &MESSAGE_KEYS);+ assert_eq!(result.pattern, "<JSON:b,\u{FFFD}>");+ assert_eq!(result.json_key_count, Some(3));+ }+}diff --git a/rust/logs-ingestion/src/pii.rs b/rust/logs-ingestion/src/pii.rsnew file mode 100644index 000000000000..1c14ea72873d--- /dev/null+++ b/rust/logs-ingestion/src/pii.rs@@ -0,0 +1,305 @@+//! Node runs these rules with RE2, so `translate_re2` gives the `regex` crate the same semantics.++use std::sync::LazyLock;++use regex::Regex;++use crate::avro::AvroValue;+use crate::js::{json_stringify, JsValue};+use crate::record::LogRecord;++pub const PII_REDACTED: &str = "{{REDACTED}}";++#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]+pub struct PiiScrubStats {+ pub pii_replacements: u64,+}++pub const EMPTY_PII: PiiScrubStats = PiiScrubStats {+ pii_replacements: 0,+};++pub fn encode_attribute_cell(semantic: &str) -> String {+ json_stringify(&JsValue::string(semantic))+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub struct PiiRule {+ pub name: &'static str,+ /// The pattern text exactly as the TypeScript gives it to RE2.+ pub pattern: &'static str,+ pub replacement: &'static str,+}++/// The scrub reads the fired rule from the group index, and the earlier alternative wins a tie at one offset.+pub const PII_RULES: [PiiRule; 7] = [+ PiiRule {+ name: "bearer",+ pattern: r"(?i:Bearer\s+[-A-Za-z0-9._~+/]+=*)",+ replacement: "Bearer {{REDACTED}}",+ },+ PiiRule {+ name: "stripe",+ pattern: r"\bsk_(?:live|test)_[a-zA-Z0-9]{20,}\b",+ replacement: PII_REDACTED,+ },+ PiiRule {+ name: "github",+ pattern: r"\bgh[pousr]_[A-Za-z0-9]{20,}\b",+ replacement: PII_REDACTED,+ },+ PiiRule {+ name: "slack",+ pattern: r"\bxox[abeprs]-[A-Za-z0-9-]{10,}\b",+ replacement: PII_REDACTED,+ },+ PiiRule {+ name: "aws_access_key_id",+ pattern: r"\b(?:AKIA|ASIA)[0-9A-Z]{16}\b",+ replacement: PII_REDACTED,+ },+ PiiRule {+ name: "jwt",+ pattern: r"\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]*",+ replacement: PII_REDACTED,+ },+ PiiRule {+ name: "email",+ pattern: r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b",+ replacement: PII_REDACTED,+ },+];++/// RE2 keeps `\d`, `\w`, `\s` and `\b` ASCII in UTF-8 mode, and its `\s` excludes `\v`, so these become explicit classes.+/// The rules use none of these escapes inside a bracket class, so the rewrite does not track classes.+pub fn translate_re2(pattern: &str) -> String {+ let mut out = String::with_capacity(pattern.len() + 16);+ let mut chars = pattern.chars();+ while let Some(c) = chars.next() {+ if c != '\\' {+ out.push(c);+ continue;+ }+ match chars.next() {+ Some('d') => out.push_str("[0-9]"),+ Some('w') => out.push_str("[0-9A-Za-z_]"),+ Some('s') => out.push_str(r"[\t\n\f\r ]"),+ Some('b') => out.push_str(r"(?-u:\b)"),+ Some(other) => {+ out.push('\\');+ out.push(other);+ }+ None => out.push('\\'),+ }+ }+ out+}++pub fn combined_regex(patterns: impl IntoIterator<Item = &'static str>) -> Regex {+ let joined = patterns+ .into_iter()+ .map(|p| format!("({})", translate_re2(p)))+ .collect::<Vec<_>>()+ .join("|");+ regex::RegexBuilder::new(&joined)+ .size_limit(64 << 20)+ .dfa_size_limit(64 << 20)+ .build()+ .expect("combined rule regex compiles")+}++/// The DFA reports the matching rule with the alternation's priority, so no capture search runs.+pub struct RuleRegex(regex_automata::meta::Regex);++impl RuleRegex {+ pub fn new(patterns: impl IntoIterator<Item = &'static str>) -> Self {+ let translated: Vec<String> = patterns.into_iter().map(translate_re2).collect();+ let regex = regex_automata::meta::Regex::builder()+ .configure(+ regex_automata::meta::Config::new()+ .nfa_size_limit(Some(64 << 20))+ .dfa_size_limit(Some(64 << 20))+ .hybrid_cache_capacity(64 << 20),+ )+ .build_many(&translated)+ .expect("rule regex compiles");+ Self(regex)+ }++ pub fn matches<'h>(+ &'h self,+ haystack: &'h str,+ ) -> impl Iterator<Item = (usize, usize, usize)> + 'h {+ self.0+ .find_iter(haystack)+ .map(|m| (m.start(), m.end(), m.pattern().as_usize()))+ }+}++static PII_RULE_RE: LazyLock<RuleRegex> =+ LazyLock::new(|| RuleRegex::new(PII_RULES.iter().map(|r| r.pattern)));++fn scrub_str(input: &str) -> (Option<String>, u64) {+ let mut replacements = 0u64;+ let mut out: Option<String> = None;+ let mut copied_up_to = 0;+ for (start, end, rule) in PII_RULE_RE.matches(input) {+ if start == end {+ continue;+ }+ replacements += 1;+ let buf = out.get_or_insert_with(|| String::with_capacity(input.len()));+ buf.push_str(&input[copied_up_to..start]);+ buf.push_str(PII_RULES[rule].replacement);+ copied_up_to = end;+ }+ if let Some(buf) = &mut out {+ buf.push_str(&input[copied_up_to..]);+ }+ (out, replacements)+}++/// The count includes only matches that a rule group claims. No rule can match an empty string.+pub fn scrub_plain_string_with_stats(input: &str) -> (String, u64) {+ let (out, replacements) = scrub_str(input);+ (out.unwrap_or_else(|| input.to_string()), replacements)+}++pub fn scrub_plain_string(input: &str) -> String {+ scrub_plain_string_with_stats(input).0+}++/// The Avro decoder writes U+FFFD for invalid bytes, so no lone-surrogate handling is needed here.+pub fn scrub_log_record(record: &mut LogRecord) -> PiiScrubStats {+ let mut total = 0u64;++ if let Some(body) = record.body() {+ let (output, n) = scrub_str(body);+ total += n;+ if let Some(output) = output {+ record.set("body", AvroValue::String(output));+ }+ }++ // Keys and their order do not change, so each value is replaced in place.+ if let Some(attributes) = record.attributes_mut() {+ for value in attributes.values_mut() {+ if let AvroValue::String(s) = value {+ let (output, n) = scrub_str(s);+ total += n;+ if let Some(output) = output {+ *s = output;+ }+ }+ }+ }++ PiiScrubStats {+ pii_replacements: total,+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ fn members(pattern: &str, range: std::ops::Range<u32>) -> Vec<u32> {+ let re = Regex::new(&format!("^(?:{})$", translate_re2(pattern))).unwrap();+ let mut buf = [0u8; 4];+ range+ .filter_map(char::from_u32)+ .filter(|c| re.is_match(c.encode_utf8(&mut buf)))+ .map(|c| c as u32)+ .collect()+ }++ fn non_ascii_members(pattern: &str) -> Vec<u32> {+ members(pattern, 0x80..0x110000)+ }++ /// Memberships recorded from node-re2 1.22.1 over every code point.+ #[test]+ fn class_membership_matches_node_re2() {+ assert_eq!(non_ascii_members("(?i:[-A-Za-z0-9._~+/])"), [0x17F, 0x212A]);+ assert!(non_ascii_members(r"(?i:[Bbear])").is_empty());+ assert!(non_ascii_members(r"\d").is_empty());+ assert!(non_ascii_members(r"\w").is_empty());+ assert!(non_ascii_members(r"\s").is_empty());+ let ascii_space = members(r"\s", 0..0x80);+ assert_eq!(ascii_space, [0x09, 0x0A, 0x0C, 0x0D, 0x20]);+ }++ #[test]+ fn rule_regex_matches_the_alternation() {+ const PARTS: &[&str] = &[+ "2025-01-15T12:00:00.123Z",+ "I0115 12:00:00.5",+ "Mon Jan 5 12:00:00 UTC 2025",+ "[email protected]",+ "usr_AbC123",+ "cus_ABcdefghijklmn",+ "_1234_5",+ "_3fa85f64-5717-4562-b3fc-2c963f66afa6",+ "ip-10-0-0-1.internal",+ "0xBEEF",+ "192.168.1.20",+ "deadbeefcafe",+ "Bearer a.b~c==",+ "bearer \u{212A}x",+ "sk_live_ABCDEFGHIJKLMNOPQRSTUV",+ "ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZ",+ "xoxb-1234567890-a",+ "AKIAABCDEFGHIJKLMNOP",+ "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.s",+ "é",+ "_",+ "-",+ ".",+ " ",+ "x",+ "12",+ ];+ let rule_sets: [&[&str]; 2] = [+ &PII_RULES.map(|r| r.pattern),+ &crate::pattern::MASK_RULES.map(|r| r.pattern),+ ];+ for patterns in rule_sets {+ let alternation = combined_regex(patterns.iter().copied());+ let rules = RuleRegex::new(patterns.iter().copied());+ let mut state = 0x9e37_79b9_7f4a_7c15u64;+ for _ in 0..20_000 {+ let mut input = String::new();+ for _ in 0..state % 8 {+ state ^= state << 13;+ state ^= state >> 7;+ state ^= state << 17;+ input.push_str(PARTS[(state % PARTS.len() as u64) as usize]);+ }+ let expected: Vec<_> = alternation+ .captures_iter(&input)+ .map(|c| {+ let whole = c.get(0).unwrap();+ let rule = (0..patterns.len()).find(|&i| c.get(i + 1).is_some());+ (whole.start(), whole.end(), rule.unwrap())+ })+ .collect();+ assert_eq!(+ rules.matches(&input).collect::<Vec<_>>(),+ expected,+ "{input:?}"+ );+ }+ }+ }++ #[test]+ fn re2_edge_cases_match_node() {+ assert_eq!(+ scrub_plain_string("bearer \u{212A}abc").as_str(),+ "Bearer {{REDACTED}}"+ );+ assert_eq!(scrub_plain_string("Bearer\u{000B}ab"), "Bearer\u{000B}ab");+ let re = Regex::new(&translate_re2(r"\bab\b")).unwrap();+ assert_eq!(re.replace_all("éab abé", "X"), "éX Xé");+ }+}diff --git a/rust/logs-ingestion/src/pipeline/admission.rs b/rust/logs-ingestion/src/pipeline/admission.rsnew file mode 100644index 000000000000..6ce93f294657--- /dev/null+++ b/rust/logs-ingestion/src/pipeline/admission.rs@@ -0,0 +1,248 @@+use std::collections::HashSet;+use std::sync::{Arc, Mutex};++use ingestion_framework::{drop, ok, ChunkProcessingStep, PipelineResult};+use metrics::counter;++use crate::rate_limiter::RateLimitedMessage;++use super::context::{is_unbilled_internal, team_id_matches_csv, LogsPipelineContext};+use super::types::{LogsIngestionMessage, UsageStatsByTeam};++/// Only billed messages reach it.+pub type LogsBatchUsage = Arc<Mutex<UsageStatsByTeam>>;++pub struct LogsAdmissionInput {+ pub message: LogsIngestionMessage,+ pub usage: LogsBatchUsage,+}++fn record_allowed(usage: &LogsBatchUsage, m: &LogsIngestionMessage) {+ let mut usage = usage.lock().unwrap();+ let stats = usage.row(m.team_id);+ stats.bytes_received += m.bytes_uncompressed;+ stats.records_received += m.record_count;+ stats.bytes_allowed += m.bytes_uncompressed;+ stats.records_allowed += m.record_count;+ stats.bytes_allowed_records += m.bytes_uncompressed_records;+}++fn record_dropped(usage: &LogsBatchUsage, m: &LogsIngestionMessage) {+ let mut usage = usage.lock().unwrap();+ let stats = usage.row(m.team_id);+ stats.bytes_received += m.bytes_uncompressed;+ stats.records_received += m.record_count;+ stats.bytes_dropped += m.bytes_uncompressed;+ stats.records_dropped += m.record_count;+}++/// Counts in first-seen order, like a `Map`.+#[derive(Default)]+struct TeamCounts(Vec<(i64, u64)>);++impl TeamCounts {+ fn add(&mut self, team_id: i64) {+ match self.0.iter_mut().find(|(t, _)| *t == team_id) {+ Some(entry) => entry.1 += 1,+ None => self.0.push((team_id, 1)),+ }+ }++ fn report(&self, reason: &'static str) {+ for (team_id, count) in &self.0 {+ counter!("logs_ingestion_message_dropped_count", "reason" => reason, "team_id" => team_id.to_string())+ .increment(*count);+ }+ }+}++type AdmissionStep = ChunkProcessingStep<LogsAdmissionInput, LogsAdmissionInput>;++/// Verified internal logs are never quota or rate limited, so counting them would show as drops.+pub fn create_track_incoming_traffic_step() -> AdmissionStep {+ ChunkProcessingStep::sync(+ "trackIncomingTrafficStep",+ |values: Vec<LogsAdmissionInput>| {+ let (bytes, records) = values+ .iter()+ .filter(|v| !is_unbilled_internal(&v.message))+ .fold((0.0, 0.0), |(b, r), v| {+ (b + v.message.bytes_uncompressed, r + v.message.record_count)+ });+ counter!("logs_ingestion_bytes_received_total").increment(bytes as u64);+ counter!("logs_ingestion_records_received_total").increment(records as u64);+ Ok(values.into_iter().map(ok).collect())+ },+ )+}++pub fn create_backfill_gate_step(context: Arc<LogsPipelineContext>) -> AdmissionStep {+ ChunkProcessingStep::sync(+ "backfillGateStep",+ move |values: Vec<LogsAdmissionInput>| {+ // (team, messages, records, billed) in first-seen order.+ let mut dropped: Vec<(i64, u64, f64, bool)> = Vec::new();+ let results = values+ .into_iter()+ .map(|v| {+ let m = &v.message;+ if !m.backfill_requested+ || team_id_matches_csv(&context.gates.backfill_enabled_teams, m.team_id)+ {+ return ok(v);+ }+ let i = match dropped.iter().position(|d| d.0 == m.team_id) {+ Some(i) => i,+ None => {+ dropped.push((m.team_id, 0, 0.0, false));+ dropped.len() - 1+ }+ };+ dropped[i].1 += 1;+ if !is_unbilled_internal(m) {+ dropped[i].2 += m.record_count;+ dropped[i].3 = true;+ record_dropped(&v.usage, m);+ }+ drop("backfill_not_enabled")+ })+ .collect();+ for (team_id, messages, records, billed) in dropped {+ counter!("logs_ingestion_message_dropped_count", "reason" => "backfill_not_enabled", "team_id" => team_id.to_string())+ .increment(messages);+ if billed {+ context.usage_metrics.queue_usage_metric(+ team_id,+ "records_dropped_backfill_not_enabled",+ records,+ );+ }+ }+ Ok(results)+ },+ )+}++pub fn create_quota_limit_step(context: Arc<LogsPipelineContext>) -> AdmissionStep {+ ChunkProcessingStep::new("quotaLimitStep", move |values: Vec<LogsAdmissionInput>| {+ let context = context.clone();+ async move {+ let mut tokens: Vec<String> = Vec::new();+ for v in values.iter().filter(|v| !is_unbilled_internal(&v.message)) {+ if !tokens.contains(&v.message.token) {+ tokens.push(v.message.token.clone());+ }+ }+ let resource = context.identity.quota_resource.clone();+ let checks = futures::future::join_all(tokens.iter().map(|t| {+ context+ .deps+ .quota_limiting+ .is_team_token_quota_limited(t, &resource)+ }))+ .await;+ let mut limited = Vec::new();+ for (token, check) in tokens.iter().zip(checks) {+ if check? {+ limited.push(token.clone());+ }+ }+ let mut counts = TeamCounts::default();+ let results: Vec<PipelineResult<LogsAdmissionInput>> = values+ .into_iter()+ .map(|v| {+ if is_unbilled_internal(&v.message) || !limited.contains(&v.message.token) {+ return ok(v);+ }+ counts.add(v.message.team_id);+ record_dropped(&v.usage, &v.message);+ drop("quota_limited")+ })+ .collect();+ counts.report("quota_limited");+ Ok(results)+ }+ })+}++struct Indexed<'a>(usize, &'a LogsIngestionMessage);++impl RateLimitedMessage for Indexed<'_> {+ fn team_id(&self) -> i64 {+ self.1.team_id+ }+ fn bytes_uncompressed(&self) -> f64 {+ self.1.bytes_uncompressed+ }+ fn created_at_header(&self) -> Option<&[u8]> {+ self.1.created_at_header()+ }+}++pub fn create_rate_limit_step(context: Arc<LogsPipelineContext>) -> AdmissionStep {+ ChunkProcessingStep::new("rateLimitStep", move |values: Vec<LogsAdmissionInput>| {+ let context = context.clone();+ async move {+ let dropped_indexes: HashSet<usize> = {+ let billed: Vec<Indexed<'_>> = values+ .iter()+ .enumerate()+ .filter(|(_, v)| !is_unbilled_internal(&v.message))+ .map(|(i, v)| Indexed(i, &v.message))+ .collect();+ let filtered = context.rate_limiter.filter_messages(billed).await?;+ filtered.dropped.iter().map(|m| m.0).collect()+ };+ let mut counts = TeamCounts::default();+ let results: Vec<PipelineResult<LogsAdmissionInput>> = values+ .into_iter()+ .enumerate()+ .map(|(i, v)| {+ if !dropped_indexes.contains(&i) {+ return ok(v);+ }+ counts.add(v.message.team_id);+ record_dropped(&v.usage, &v.message);+ drop("rate_limited")+ })+ .collect();+ counts.report("rate_limited");+ Ok(results)+ }+ })+}++/// Allowed is gross here, because processing takes off the drop-rule credit.+pub fn create_record_allowed_usage_step() -> AdmissionStep {+ ChunkProcessingStep::sync(+ "recordAllowedUsageStep",+ |values: Vec<LogsAdmissionInput>| {+ let (mut bytes, mut records, mut bytes_records) = (0.0, 0.0, 0.0);+ for v in values.iter().filter(|v| !is_unbilled_internal(&v.message)) {+ record_allowed(&v.usage, &v.message);+ bytes += v.message.bytes_uncompressed;+ bytes_records += v.message.bytes_uncompressed_records;+ records += v.message.record_count;+ }+ counter!("logs_ingestion_bytes_allowed_records_total").increment(bytes_records as u64);+ counter!("logs_ingestion_bytes_allowed_total").increment(bytes as u64);+ counter!("logs_ingestion_records_allowed_total").increment(records as u64);+ Ok(values.into_iter().map(ok).collect())+ },+ )+}++/// Runs after admission even when every message was dropped, which no chunk step does.+pub fn report_dropped_usage(usage: &LogsBatchUsage) {+ for (team_id, stats) in &usage.lock().unwrap().0 {+ let team = team_id.to_string();+ if stats.bytes_dropped > 0.0 {+ counter!("logs_ingestion_bytes_dropped_total", "team_id" => team.clone())+ .increment(stats.bytes_dropped as u64);+ }+ if stats.records_dropped > 0.0 {+ counter!("logs_ingestion_records_dropped_total", "team_id" => team)+ .increment(stats.records_dropped as u64);+ }+ }+}diff --git a/rust/logs-ingestion/src/pipeline/app_metrics.rs b/rust/logs-ingestion/src/pipeline/app_metrics.rsnew file mode 100644index 000000000000..c3d557fdcbac--- /dev/null+++ b/rust/logs-ingestion/src/pipeline/app_metrics.rs@@ -0,0 +1,257 @@+use std::collections::hash_map::Entry;+use std::collections::HashMap;+use std::sync::{Arc, Mutex};++use chrono::{DateTime, Duration, Timelike, Utc};+use ingestion_framework::{IngestionOutputs, OutputMessage};+use metrics::counter;++use crate::js::{json_stringify, JsObject, JsValue};+use crate::rate_limiter::Clock;+use crate::retention::evaluate::RETENTION_MONTH_DAYS;++pub const APP_METRICS_OUTPUT: &str = "app_metrics";++pub fn datetime_from_ms(ms: f64) -> DateTime<Utc> {+ DateTime::from_timestamp_millis(ms as i64).unwrap_or_default()+}++/// Luxon `yyyy-MM-dd HH:mm:ss.u`.+pub fn clickhouse_timestamp(at: DateTime<Utc>) -> String {+ at.format("%Y-%m-%d %H:%M:%S%.3f").to_string()+}++pub fn iso_timestamp(ms: f64) -> String {+ datetime_from_ms(ms)+ .format("%Y-%m-%dT%H:%M:%S%.3fZ")+ .to_string()+}++#[derive(Debug, Clone)]+struct BufferedAppMetric {+ team_id: i64,+ app_source: String,+ app_source_id: String,+ instance_id: String,+ metric_kind: String,+ metric_name: String,+ count: f64,+ timestamp: Option<String>,+}++#[derive(Debug, Clone)]+pub struct AppMetricInput {+ pub team_id: i64,+ pub app_source: String,+ pub app_source_id: String,+ pub instance_id: String,+ pub metric_kind: String,+ pub metric_name: String,+ pub count: f64,+ pub timestamp: Option<DateTime<Utc>>,+}++/// Rows in first-queued order, as a Node `Map` keeps them, with a key index for the merge.+#[derive(Default)]+struct AppMetricBuffer {+ rows: Vec<BufferedAppMetric>,+ index: HashMap<String, usize>,+}++pub struct AppMetricsAggregator {+ buffer: Mutex<AppMetricBuffer>,+ outputs: Arc<dyn IngestionOutputs>,+ clock: Clock,+}++impl AppMetricsAggregator {+ pub fn new(outputs: Arc<dyn IngestionOutputs>, clock: Clock) -> Self {+ Self {+ buffer: Mutex::new(AppMetricBuffer::default()),+ outputs,+ clock,+ }+ }++ pub fn queue(&self, metric: AppMetricInput) {+ counter!("app_metrics_aggregator_queued_total", "app_source" => metric.app_source.clone())+ .increment(1);+ let timestamp = metric.timestamp.map(|t| {+ let hour = t+ .with_minute(0)+ .and_then(|t| t.with_second(0))+ .and_then(|t| t.with_nanosecond(0))+ .unwrap_or(t);+ clickhouse_timestamp(hour)+ });+ let row = BufferedAppMetric {+ team_id: metric.team_id,+ app_source: metric.app_source,+ app_source_id: metric.app_source_id,+ instance_id: metric.instance_id,+ metric_kind: metric.metric_kind,+ metric_name: metric.metric_name,+ count: metric.count,+ timestamp,+ };+ let key = format!(+ "{}:{}:{}:{}:{}:{}:{}",+ row.team_id,+ row.app_source,+ row.app_source_id,+ row.instance_id,+ row.metric_kind,+ row.metric_name,+ row.timestamp.as_deref().unwrap_or("")+ );+ let mut buffer = self.buffer.lock().unwrap();+ let AppMetricBuffer { rows, index } = &mut *buffer;+ match index.entry(key) {+ Entry::Occupied(slot) => rows[*slot.get()].count += row.count,+ Entry::Vacant(slot) => {+ slot.insert(rows.len());+ rows.push(row);+ }+ }+ }++ pub async fn flush(&self) -> anyhow::Result<()> {+ let drained = std::mem::take(&mut *self.buffer.lock().unwrap()).rows;+ if drained.is_empty() {+ return Ok(());+ }+ let flush_timestamp = clickhouse_timestamp(datetime_from_ms((self.clock)()));+ let messages = drained+ .iter()+ .map(|m| {+ let mut row = JsObject::new();+ row.insert_str("team_id", JsValue::Number(m.team_id as f64));+ row.insert_str(+ "timestamp",+ JsValue::string(m.timestamp.as_deref().unwrap_or(&flush_timestamp)),+ );+ row.insert_str("app_source", JsValue::string(&m.app_source));+ row.insert_str("app_source_id", JsValue::string(&m.app_source_id));+ row.insert_str("instance_id", JsValue::string(&m.instance_id));+ row.insert_str("metric_kind", JsValue::string(&m.metric_kind));+ row.insert_str("metric_name", JsValue::string(&m.metric_name));+ row.insert_str("count", JsValue::Number(m.count));+ OutputMessage {+ value: Some(json_stringify(&JsValue::Object(row)).into_bytes().into()),+ key: None,+ headers: Default::default(),+ }+ })+ .collect();+ self.outputs+ .queue_messages(APP_METRICS_OUTPUT, messages)+ .await?;+ for m in &drained {+ counter!("app_metrics_aggregator_flushed_total", "app_source" => m.app_source.clone())+ .increment(1);+ }+ Ok(())+ }+}++/// Lives as long as the consumer, so rows a failed batch queued flush with the next batch that succeeds.+pub struct LogsUsageMetricsQueue {+ aggregator: AppMetricsAggregator,+ app_source: String,+ clock: Clock,+}++impl LogsUsageMetricsQueue {+ pub fn new(aggregator: AppMetricsAggregator, app_source: &str, clock: Clock) -> Self {+ Self {+ aggregator,+ app_source: app_source.to_string(),+ clock,+ }+ }++ fn input(+ &self,+ team_id: i64,+ instance_id: &str,+ metric_name: &str,+ count: f64,+ ) -> AppMetricInput {+ AppMetricInput {+ team_id,+ app_source: self.app_source.clone(),+ app_source_id: String::new(),+ instance_id: instance_id.to_string(),+ metric_kind: "usage".to_string(),+ metric_name: metric_name.to_string(),+ count,+ timestamp: None,+ }+ }++ pub fn queue_usage_metric(&self, team_id: i64, metric_name: &str, count: f64) {+ self.queue_usage_metric_at(team_id, metric_name, count, None);+ }++ pub fn queue_usage_metric_at(+ &self,+ team_id: i64,+ metric_name: &str,+ count: f64,+ at: Option<DateTime<Utc>>,+ ) {+ if count == 0.0 {+ return;+ }+ let mut input = self.input(team_id, "", metric_name, count);+ input.timestamp = at;+ self.aggregator.queue(input);+ }++ /// One `retention_byte_days` row per 30-day month of retention, dated at the start of its month.+ pub fn queue_retention_byte_days(&self, team_id: i64, bytes: f64, retention_days: f64) {+ let now = datetime_from_ms((self.clock)());+ let month = RETENTION_MONTH_DAYS as f64;+ let mut offset = 0.0;+ while offset < retention_days {+ let days = month.min(retention_days - offset);+ let at = now + Duration::days(offset as i64);+ self.queue_usage_metric_at(team_id, "retention_byte_days", bytes * days, Some(at));+ offset += month;+ }+ }++ pub fn queue_by_rule(+ &self,+ team_id: i64,+ metric_name: &str,+ by_rule: &crate::content_weights::OrderedCounts,+ ) {+ for (rule_id, count) in &by_rule.0 {+ if *count <= 0.0 {+ continue;+ }+ self.aggregator+ .queue(self.input(team_id, rule_id, metric_name, *count));+ }+ }++ pub async fn flush(&self) -> anyhow::Result<()> {+ self.aggregator.flush().await+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn timestamps_format_like_luxon_and_date() {+ let at = datetime_from_ms(1_736_944_633_250.0);+ assert_eq!(clickhouse_timestamp(at), "2025-01-15 12:37:13.250");+ assert_eq!(+ iso_timestamp(1_736_944_633_250.0),+ "2025-01-15T12:37:13.250Z"+ );+ }+}diff --git a/rust/logs-ingestion/src/pipeline/buffer.rs b/rust/logs-ingestion/src/pipeline/buffer.rsnew file mode 100644index 000000000000..bd5445371abc--- /dev/null+++ b/rust/logs-ingestion/src/pipeline/buffer.rs@@ -0,0 +1,92 @@+use std::time::Instant;++use metrics::histogram;++use crate::avro::{decode_container, encode_container};+use crate::content_weights::{run_pipeline_stages, DropStats, PipelineStage};+use crate::normalize::{+ buffer_processing_mode, transform_decoded_log_records_in_place, BufferProcessingMode,+ LogsSettings,+};+use crate::pii::{PiiScrubStats, EMPTY_PII};+use crate::record::LogRecord;++/// Runs after normalize and before the stages: it sees every record post-scrub and pre-drop.+pub type RecordsVisitor<'a> = Box<dyn FnMut(&[LogRecord]) -> anyhow::Result<()> + Send + 'a>;++#[derive(Debug)]+pub enum BufferValue {+ Original,+ Encoded(Vec<u8>),+ Dropped,+}++pub struct ProcessedBuffer {+ pub value: BufferValue,+ pub pii: PiiScrubStats,+ pub drops: DropStats,+}++pub async fn process_log_message_buffer(+ buffer: &[u8],+ settings: &LogsSettings,+ mut visitor: Option<RecordsVisitor<'_>>,+ stages: &[PipelineStage],+) -> anyhow::Result<ProcessedBuffer> {+ let mode = buffer_processing_mode(settings, stages.len(), visitor.is_some());+ if mode == BufferProcessingMode::Passthrough {+ return Ok(ProcessedBuffer {+ value: BufferValue::Original,+ pii: EMPTY_PII,+ drops: DropStats::default(),+ });+ }++ let start = Instant::now();+ let mut codec = "unknown".to_string();+ let result = async {+ let container = decode_container(buffer)?;+ codec = container.codec.clone();+ let mut records: Vec<LogRecord> = container+ .records+ .into_iter()+ .map(LogRecord::from_value)+ .collect();+ let pii = transform_decoded_log_records_in_place(&mut records, settings);+ if let Some(visit) = visitor.as_mut() {+ visit(&records)?;+ }+ let (kept, drops) = run_pipeline_stages(records, stages).await?;+ if kept.is_empty() {+ return Ok(ProcessedBuffer {+ value: BufferValue::Dropped,+ pii,+ drops,+ });+ }+ if mode == BufferProcessingMode::DecodeOnly {+ return Ok(ProcessedBuffer {+ value: BufferValue::Original,+ pii,+ drops,+ });+ }+ let values: Vec<_> = kept.into_iter().map(LogRecord::into_value).collect();+ let encoded = encode_container(&container.schema, &container.codec, &values)?;+ Ok(ProcessedBuffer {+ value: BufferValue::Encoded(encoded),+ pii,+ drops,+ })+ }+ .await;+ histogram!(+ "logs_ingestion_processing_duration_seconds",+ "json_parse_enabled" => settings.json_parse_logs.unwrap_or(false).to_string(),+ "pii_scrub_enabled" => settings.pii_scrub_logs.unwrap_or(false).to_string(),+ "attribute_extraction_enabled" => settings.attribute_key().is_some().to_string(),+ "compression_codec" => codec+ )+ .record(start.elapsed().as_secs_f64());+ result+}diff --git a/rust/logs-ingestion/src/pipeline/config.rs b/rust/logs-ingestion/src/pipeline/config.rsnew file mode 100644index 000000000000..76ff4f5d62be--- /dev/null+++ b/rust/logs-ingestion/src/pipeline/config.rs@@ -0,0 +1,119 @@+use crate::js::{JsObject, JsValue};++#[derive(Debug, Clone, Default, PartialEq)]+pub struct LogsIngestionConsumerConfig {+ pub limiter_enabled_teams: String,+ pub limiter_disabled_for_teams: String,+ pub limiter_bucket_size_kb: f64,+ pub limiter_refill_rate_kb_per_second: f64,+ pub limiter_ttl_seconds: f64,+ pub limiter_team_bucket_size_kb: String,+ pub limiter_team_refill_rate_kb_per_second: String,+ pub sampling_enabled_teams: String,+ pub sampling_killswitch: bool,+ pub metrics_rules_enabled_teams: String,+ pub metrics_rules_killswitch: bool,+ pub default_metric_rules_enabled_teams: String,+ pub retention_enabled_teams: String,+ pub retention_killswitch: bool,+ pub backfill_enabled_teams: String,+ pub internal_ingestion_enabled_teams: String,+ pub internal_ingestion_signing_keys: String,+ pub pattern_masking_enabled_teams: String,+ pub json_attribute_parsing_enabled_teams: String,+ pub json_attribute_extraction_enabled_teams: String,+ pub billing_prorate_enabled: bool,+ pub transformations_enabled_teams: String,+ pub transformations_killswitch: bool,+}++fn string(config: &JsObject, key: &str) -> String {+ match config.get(key) {+ Some(JsValue::String(s)) => s.to_utf8_lossy().into_owned(),+ Some(JsValue::Number(n)) => crate::js::number_to_string(*n),+ _ => String::new(),+ }+}++fn number(config: &JsObject, key: &str) -> f64 {+ match config.get(key) {+ Some(JsValue::Number(n)) => *n,+ _ => 0.0,+ }+}++fn boolean(config: &JsObject, key: &str) -> bool {+ matches!(config.get(key), Some(JsValue::Bool(true)))+}++impl LogsIngestionConsumerConfig {+ pub fn from_logs_config(c: &JsObject) -> Self {+ Self {+ limiter_enabled_teams: string(c, "LOGS_LIMITER_ENABLED_TEAMS"),+ limiter_disabled_for_teams: string(c, "LOGS_LIMITER_DISABLED_FOR_TEAMS"),+ limiter_bucket_size_kb: number(c, "LOGS_LIMITER_BUCKET_SIZE_KB"),+ limiter_refill_rate_kb_per_second: number(c, "LOGS_LIMITER_REFILL_RATE_KB_PER_SECOND"),+ limiter_ttl_seconds: number(c, "LOGS_LIMITER_TTL_SECONDS"),+ limiter_team_bucket_size_kb: string(c, "LOGS_LIMITER_TEAM_BUCKET_SIZE_KB"),+ limiter_team_refill_rate_kb_per_second: string(+ c,+ "LOGS_LIMITER_TEAM_REFILL_RATE_KB_PER_SECOND",+ ),+ sampling_enabled_teams: string(c, "LOGS_SAMPLING_ENABLED_TEAMS"),+ sampling_killswitch: boolean(c, "LOGS_SAMPLING_KILLSWITCH"),+ metrics_rules_enabled_teams: string(c, "LOGS_METRICS_RULES_ENABLED_TEAMS"),+ metrics_rules_killswitch: boolean(c, "LOGS_METRICS_RULES_KILLSWITCH"),+ default_metric_rules_enabled_teams: string(+ c,+ "LOGS_DEFAULT_METRIC_RULES_ENABLED_TEAMS",+ ),+ retention_enabled_teams: string(c, "LOGS_RETENTION_ENABLED_TEAMS"),+ retention_killswitch: boolean(c, "LOGS_RETENTION_KILLSWITCH"),+ backfill_enabled_teams: string(c, "LOGS_BACKFILL_ENABLED_TEAMS"),+ internal_ingestion_enabled_teams: string(c, "LOGS_INTERNAL_INGESTION_ENABLED_TEAMS"),+ internal_ingestion_signing_keys: string(c, "LOGS_INTERNAL_INGESTION_SIGNING_KEYS"),+ pattern_masking_enabled_teams: string(c, "LOGS_PATTERN_MASKING_ENABLED_TEAMS"),+ json_attribute_parsing_enabled_teams: string(+ c,+ "LOGS_JSON_ATTRIBUTE_PARSING_ENABLED_TEAMS",+ ),+ json_attribute_extraction_enabled_teams: string(+ c,+ "LOGS_JSON_ATTRIBUTE_EXTRACTION_ENABLED_TEAMS",+ ),+ billing_prorate_enabled: boolean(c, "LOGS_BILLING_PRORATE_ENABLED"),+ transformations_enabled_teams: string(c, "LOGS_TRANSFORMATIONS_ENABLED_TEAMS"),+ transformations_killswitch: boolean(c, "LOGS_TRANSFORMATIONS_KILLSWITCH"),+ }+ }++ pub fn from_traces_config(c: &JsObject) -> Self {+ Self {+ limiter_enabled_teams: string(c, "TRACES_LIMITER_ENABLED_TEAMS"),+ limiter_disabled_for_teams: string(c, "TRACES_LIMITER_DISABLED_FOR_TEAMS"),+ limiter_bucket_size_kb: number(c, "TRACES_LIMITER_BUCKET_SIZE_KB"),+ limiter_refill_rate_kb_per_second: number(+ c,+ "TRACES_LIMITER_REFILL_RATE_KB_PER_SECOND",+ ),+ limiter_ttl_seconds: number(c, "TRACES_LIMITER_TTL_SECONDS"),+ limiter_team_bucket_size_kb: string(c, "TRACES_LIMITER_TEAM_BUCKET_SIZE_KB"),+ limiter_team_refill_rate_kb_per_second: string(+ c,+ "TRACES_LIMITER_TEAM_REFILL_RATE_KB_PER_SECOND",+ ),+ metrics_rules_enabled_teams: string(c, "TRACES_METRICS_RULES_ENABLED_TEAMS"),+ metrics_rules_killswitch: boolean(c, "TRACES_METRICS_RULES_KILLSWITCH"),+ default_metric_rules_enabled_teams: string(+ c,+ "TRACES_DEFAULT_METRIC_RULES_ENABLED_TEAMS",+ ),+ retention_enabled_teams: string(c, "TRACES_RETENTION_ENABLED_TEAMS"),+ retention_killswitch: boolean(c, "TRACES_RETENTION_KILLSWITCH"),+ // Internal batches are logs only, so a signed traces batch is still billed.+ internal_ingestion_signing_keys: String::new(),+ internal_ingestion_enabled_teams: String::new(),+ ..Self::from_logs_config(c)+ }+ }+}diff --git a/rust/logs-ingestion/src/pipeline/consumer.rs b/rust/logs-ingestion/src/pipeline/consumer.rsnew file mode 100644index 000000000000..1664e5fcbab3--- /dev/null+++ b/rust/logs-ingestion/src/pipeline/consumer.rs@@ -0,0 +1,258 @@+use std::sync::{Arc, Mutex};++use futures::future::BoxFuture;+use futures::FutureExt;+use ingestion_framework::KafkaMessage;++use crate::internal_logs::{default_internal_source_policies, InternalLogsVerifier};+use crate::metric_rules::{+ MetricSeriesAdmission, MAX_ADMITTED_LABEL_SETS, MAX_ADMITTED_LABEL_SETS_PER_TEAM,+ MAX_LABEL_SETS_PER_RULE,+};+use crate::rate_limiter::{LogsRateLimiter, LogsRateLimiterConfig};+use crate::sampling::LogsSamplingService;++use super::admission::{report_dropped_usage, LogsAdmissionInput, LogsBatchUsage};+use super::app_metrics::{AppMetricsAggregator, LogsUsageMetricsQueue};+use super::config::LogsIngestionConsumerConfig;+use super::context::{+ is_unbilled_internal, LogsConsumerIdentity, LogsFeatureGates, LogsPipelineContext,+};+use super::deps::LogsIngestionConsumerDeps;+use super::finalize::{emit_metric_rule_tallies, emit_usage_metrics, queue_internal_logs_usage};+use super::pipelines::{+ create_logs_admission_pipeline, create_logs_parse_pipeline, create_logs_processing_pipeline,+ run_chunk_pipeline,+};+use super::process::{LogsProcessingInput, LogsProcessingPass};+use super::types::{describe_batch_position, LogsIngestionMessage, UsageStatsByTeam};++pub type BackgroundTask = BoxFuture<'static, anyhow::Result<()>>;++pub struct ProcessedBatch {+ pub messages: Vec<LogsIngestionMessage>,+ pub background_task: Option<BackgroundTask>,+}++pub struct LogsIngestionConsumer {+ context: Arc<LogsPipelineContext>,+}++impl LogsIngestionConsumer {+ pub fn new(+ identity: LogsConsumerIdentity,+ config: LogsIngestionConsumerConfig,+ deps: LogsIngestionConsumerDeps,+ ) -> Self {+ let limiter_name = match identity.app_source {+ super::context::AppSource::Logs => "logs-rate-limiter",+ super::context::AppSource::Traces => "traces-rate-limiter",+ };+ let rate_limiter = LogsRateLimiter::new(+ LogsRateLimiterConfig {+ team_bucket_size_kb: config.limiter_team_bucket_size_kb.clone(),+ team_refill_rate_kb_per_second: config+ .limiter_team_refill_rate_kb_per_second+ .clone(),+ disabled_for_teams: config.limiter_disabled_for_teams.clone(),+ enabled_teams: config.limiter_enabled_teams.clone(),+ bucket_size_kb: config.limiter_bucket_size_kb,+ refill_rate_kb_per_second: config.limiter_refill_rate_kb_per_second,+ ttl_seconds: config.limiter_ttl_seconds,+ },+ deps.token_bucket_redis.clone(),+ limiter_name,+ deps.key_root,+ deps.clock.clone(),+ );+ let sampling_service = Arc::new(LogsSamplingService::new(+ deps.token_bucket_redis.clone(),+ config.limiter_ttl_seconds,+ deps.key_root,+ deps.clock.clone(),+ ));+ let internal_logs_verifier = InternalLogsVerifier::new(+ &config.internal_ingestion_signing_keys,+ &config.internal_ingestion_enabled_teams,+ deps.internal_source_policies+ .clone()+ .unwrap_or_else(default_internal_source_policies),+ );+ let usage_metrics = LogsUsageMetricsQueue::new(+ AppMetricsAggregator::new(deps.outputs.clone(), deps.clock.clone()),+ identity.app_source.as_str(),+ deps.clock.clone(),+ );+ let gates = LogsFeatureGates {+ backfill_enabled_teams: config.backfill_enabled_teams,+ sampling_enabled_teams: config.sampling_enabled_teams,+ sampling_killswitch: config.sampling_killswitch,+ billing_prorate_enabled: config.billing_prorate_enabled,+ metric_rules_enabled_teams: config.metrics_rules_enabled_teams,+ metric_rules_killswitch: config.metrics_rules_killswitch,+ default_metric_rules_enabled_teams: config.default_metric_rules_enabled_teams,+ transformations_enabled_teams: config.transformations_enabled_teams,+ transformations_killswitch: config.transformations_killswitch,+ retention_enabled_teams: config.retention_enabled_teams,+ retention_killswitch: config.retention_killswitch,+ pattern_masking_enabled_teams: config.pattern_masking_enabled_teams,+ json_attribute_parsing_enabled_teams: config.json_attribute_parsing_enabled_teams,+ json_attribute_extraction_enabled_teams: config.json_attribute_extraction_enabled_teams,+ };+ let context = LogsPipelineContext {+ identity,+ gates,+ deps,+ usage_metrics,+ rate_limiter,+ sampling_service,+ internal_logs_verifier,+ metric_series_admission: Mutex::new(MetricSeriesAdmission::new(+ MAX_LABEL_SETS_PER_RULE,+ MAX_ADMITTED_LABEL_SETS_PER_TEAM,+ MAX_ADMITTED_LABEL_SETS,+ )),+ };+ Self {+ context: Arc::new(context),+ }+ }++ pub fn context(&self) -> &Arc<LogsPipelineContext> {+ &self.context+ }++ pub async fn parse_kafka_batch(+ &self,+ messages: Vec<KafkaMessage>,+ ) -> anyhow::Result<Vec<LogsIngestionMessage>> {+ run_chunk_pipeline(+ create_logs_parse_pipeline(self.context.clone()),+ messages.into_iter().map(Arc::new).collect(),+ )+ .await+ }++ pub async fn process_batch(+ &self,+ messages: Vec<LogsIngestionMessage>,+ ) -> anyhow::Result<ProcessedBatch> {+ if messages.is_empty() {+ return Ok(ProcessedBatch {+ messages: Vec::new(),+ background_task: None,+ });+ }+ let usage: LogsBatchUsage = Arc::new(Mutex::new(UsageStatsByTeam::default()));+ let admitted = run_chunk_pipeline(+ create_logs_admission_pipeline(self.context.clone()),+ messages+ .into_iter()+ .map(|message| LogsAdmissionInput {+ message,+ usage: usage.clone(),+ })+ .collect(),+ )+ .await?;+ report_dropped_usage(&usage);++ let mut billed = Vec::with_capacity(admitted.len());+ let mut internal = Vec::new();+ for message in admitted.into_iter().map(|a| a.message) {+ if is_unbilled_internal(&message) {+ internal.push(message);+ } else {+ billed.push(message);+ }+ }+ let context = self.context.clone();+ let task_billed = billed.clone();+ let task_internal = internal.clone();+ let background_task =+ async move { process_admitted(context, task_billed, task_internal, usage).await }+ .boxed();+ billed.extend(internal);+ Ok(ProcessedBatch {+ messages: billed,+ background_task: Some(background_task),+ })+ }++ /// A batch failure is returned, not quarantined, because everything on this path is infrastructure-scoped.+ pub async fn process_kafka_batch(+ &self,+ messages: Vec<KafkaMessage>,+ ) -> anyhow::Result<ProcessedBatch> {+ let size = messages.len();+ let offsets = describe_batch_position(&messages);+ let result = async {+ let events = self.parse_kafka_batch(messages).await?;+ self.process_batch(events).await+ }+ .await;+ if let Err(error) = &result {+ tracing::error!(error = %error, size, offsets = ?offsets, "{} - batch failed", self.context.identity.name);+ }+ result+ }+}++async fn run_processing_pass(+ context: &Arc<LogsPipelineContext>,+ messages: Vec<LogsIngestionMessage>,+ pass: LogsProcessingPass,+) -> anyhow::Result<()> {+ run_chunk_pipeline(+ create_logs_processing_pipeline(context.clone()),+ messages+ .into_iter()+ .map(|message| LogsProcessingInput {+ message,+ pass: pass.clone(),+ })+ .collect(),+ )+ .await?;+ Ok(())+}++async fn process_admitted(+ context: Arc<LogsPipelineContext>,+ billed: Vec<LogsIngestionMessage>,+ internal: Vec<LogsIngestionMessage>,+ usage: LogsBatchUsage,+) -> anyhow::Result<()> {+ let team_ids: Vec<i64> = billed.iter().map(|m| m.team_id).collect();+ let billed_pass = LogsProcessingPass {+ usage: usage.clone(),+ metric_tallies: Default::default(),+ };+ run_processing_pass(&context, billed, billed_pass.clone()).await?;+ // Rows that are never emitted keep internal stats off the team's billed usage.+ run_processing_pass(+ &context,+ internal.clone(),+ LogsProcessingPass {+ usage: Default::default(),+ metric_tallies: Default::default(),+ },+ )+ .await?;+ // Metric rules and internal usage emit deltas, so they wait until no pass can fail.+ queue_internal_logs_usage(&context, &internal);+ emit_metric_rule_tallies(&context, &billed_pass.metric_tallies).await;+ context+ .deps+ .team_manager+ .set_teams_ingested_data(&team_ids)+ .await?;+ let usage = usage.lock().unwrap().clone();+ emit_usage_metrics(&context, &usage).await;+ if let Some(transformer) = &context.deps.logs_transformer {+ if let Err(error) = transformer.flush().await {+ tracing::error!(error = %error, "Failed to flush logs transformer monitoring");+ }+ }+ Ok(())+}diff --git a/rust/logs-ingestion/src/pipeline/context.rs b/rust/logs-ingestion/src/pipeline/context.rsnew file mode 100644index 000000000000..9f691a21f0e7--- /dev/null+++ b/rust/logs-ingestion/src/pipeline/context.rs@@ -0,0 +1,246 @@+use std::borrow::Cow;+use std::sync::{Arc, Mutex};++use ingestion_framework::{Headers, KafkaMessage, OutputMessage};+use metrics::counter;++use crate::internal_logs::InternalLogsVerifier;+use crate::metric_rules::{MetricRuleSource, MetricSeriesAdmission};+use crate::normalize::LogsSettings;+use crate::property_filter::coerce::{js_parse_int, js_trim};+use crate::rate_limiter::{Clock, LogsRateLimiter};+use crate::sampling::LogsSamplingService;++use super::app_metrics::{iso_timestamp, LogsUsageMetricsQueue};+use super::deps::LogsIngestionConsumerDeps;+use super::errors::{error_message, error_name, retry_on_dependency_unavailable};+use super::types::{+ LogsIngestionMessage, DEFAULT_LOGS_RETENTION_DAYS, DEFAULT_TRACES_RETENTION_DAYS,+};++pub const LOGS_OUTPUT: &str = "logs";+pub const LOGS_DLQ_OUTPUT: &str = "logs_dlq";++pub fn team_id_matches_csv(raw: &str, team_id: i64) -> bool {+ let trimmed = raw.trim();+ if trimmed.is_empty() {+ return false;+ }+ if trimmed == "*" {+ return true;+ }+ trimmed+ .split(',')+ .map(|s| js_parse_int(js_trim(s), Some(10)))+ .any(|n| n == team_id as f64)+}++/// Assigned onto a plain object, so a repeated key keeps its first position and takes the last value, and `__proto__` is lost.+pub fn parse_kafka_headers(message: &KafkaMessage) -> Headers {+ parse_kafka_headers_except(message, &[], 0)+}++/// The last value wins, without building the map.+pub fn kafka_header<'a>(message: &'a KafkaMessage, name: &str) -> Option<Cow<'a, str>> {+ if name == "__proto__" {+ return None;+ }+ message+ .headers+ .iter()+ .rev()+ .find(|(key, _)| key == name)+ .map(|(_, value)| utf8_lossy(value.as_deref().unwrap_or_default()))+}++pub fn utf8_lossy(bytes: &[u8]) -> Cow<'_, str> {+ match std::str::from_utf8(bytes) {+ Ok(text) => Cow::Borrowed(text),+ Err(_) => String::from_utf8_lossy(bytes),+ }+}++pub fn parse_kafka_headers_except(message: &KafkaMessage, skip: &[&str], extra: usize) -> Headers {+ let mut headers = Headers(Vec::with_capacity(message.headers.len() + extra));+ for (key, value) in &message.headers {+ if key == "__proto__" || skip.contains(&key.as_str()) {+ continue;+ }+ let value = value.as_deref().unwrap_or_default();+ headers.set(key.clone(), utf8_lossy(value).into_owned());+ }+ headers+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum AppSource {+ Logs,+ Traces,+}++impl AppSource {+ pub fn as_str(self) -> &'static str {+ match self {+ AppSource::Logs => "logs",+ AppSource::Traces => "traces",+ }+ }+}++/// Both consumers bill against `logs_mb_ingested`.+#[derive(Debug, Clone)]+pub struct LogsConsumerIdentity {+ pub name: String,+ pub app_source: AppSource,+ pub quota_resource: String,+ pub metric_rule_source: MetricRuleSource,+ pub retention_rule_source: String,+}++impl LogsConsumerIdentity {+ pub fn logs() -> Self {+ Self {+ name: "LogsIngestionConsumer".to_string(),+ app_source: AppSource::Logs,+ quota_resource: "logs_mb_ingested".to_string(),+ metric_rule_source: MetricRuleSource::Logs,+ retention_rule_source: "logs".to_string(),+ }+ }++ pub fn traces() -> Self {+ Self {+ name: "TracesIngestionConsumer".to_string(),+ app_source: AppSource::Traces,+ quota_resource: "logs_mb_ingested".to_string(),+ metric_rule_source: MetricRuleSource::Spans,+ retention_rule_source: "spans".to_string(),+ }+ }+}++#[derive(Debug, Clone, Default)]+pub struct LogsFeatureGates {+ pub backfill_enabled_teams: String,+ pub sampling_enabled_teams: String,+ pub sampling_killswitch: bool,+ pub billing_prorate_enabled: bool,+ pub metric_rules_enabled_teams: String,+ pub metric_rules_killswitch: bool,+ pub default_metric_rules_enabled_teams: String,+ pub transformations_enabled_teams: String,+ pub transformations_killswitch: bool,+ pub retention_enabled_teams: String,+ pub retention_killswitch: bool,+ pub pattern_masking_enabled_teams: String,+ pub json_attribute_parsing_enabled_teams: String,+ pub json_attribute_extraction_enabled_teams: String,+}++pub struct LogsPipelineContext {+ pub identity: LogsConsumerIdentity,+ pub gates: LogsFeatureGates,+ pub deps: LogsIngestionConsumerDeps,+ pub usage_metrics: LogsUsageMetricsQueue,+ pub rate_limiter: LogsRateLimiter,+ pub sampling_service: Arc<LogsSamplingService>,+ pub internal_logs_verifier: InternalLogsVerifier,+ pub metric_series_admission: Mutex<MetricSeriesAdmission>,+}++impl LogsPipelineContext {+ pub fn now_ms(&self) -> f64 {+ (self.deps.clock)()+ }++ pub fn clock(&self) -> &Clock {+ &self.deps.clock+ }++ pub async fn retry<T, F, Fut>(&self, f: F) -> anyhow::Result<T>+ where+ F: FnMut() -> Fut,+ Fut: std::future::Future<Output = anyhow::Result<T>>,+ {+ retry_on_dependency_unavailable(self.deps.dependency_retry, f).await+ }++ pub async fn default_retention_days(+ &self,+ team_id: i64,+ settings: &LogsSettings,+ ) -> anyhow::Result<f64> {+ match self.identity.app_source {+ AppSource::Logs => Ok(settings+ .retention_days+ .unwrap_or(DEFAULT_LOGS_RETENTION_DAYS)),+ AppSource::Traces => match &self.deps.tracing_config {+ Some(cache) => cache.get_retention_days(team_id).await,+ None => Ok(DEFAULT_TRACES_RETENTION_DAYS),+ },+ }+ }+}++/// Transformations write hog_function logs, which could come back here as internal logs and loop.+pub fn applies_team_log_rules(message: &LogsIngestionMessage) -> bool {+ message+ .internal_logs+ .as_ref()+ .map(|i| i.team_rules)+ .unwrap_or(true)+}++pub fn is_unbilled_internal(message: &LogsIngestionMessage) -> bool {+ message.internal_logs.as_ref().is_some_and(|i| !i.billed)+}++/// The DLQ headers are the replay contract. A failed DLQ write fails.+pub async fn quarantine_log_message(+ context: &LogsPipelineContext,+ message: &KafkaMessage,+ error: &anyhow::Error,+ token: Option<&str>,+ team_id: Option<i64>,+) -> anyhow::Result<()> {+ let message_text = error_message(error);+ let name = error_name(error);+ let team_label = team_id+ .map(|t| t.to_string())+ .unwrap_or_else(|| "unknown".to_string());+ counter!("logs_ingestion_message_dlq_count", "reason" => name.clone(), "team_id" => team_label.clone())+ .increment(1);++ let mut headers = parse_kafka_headers(message);+ if let Some(token) = token {+ headers.set("token", token);+ }+ headers.set("team_id", team_label);+ headers.set("error_message", message_text.clone());+ headers.set("error_name", name);+ headers.set("failed_at", iso_timestamp(context.now_ms()));+ headers.set("source_topic", message.topic.clone());+ headers.set("source_partition", message.partition.to_string());+ headers.set("source_offset", message.offset.to_string());+ let out = OutputMessage {+ value: message.value.clone(),+ key: None,+ headers,+ };+ let result = context+ .retry(|| {+ let out = out.clone();+ async move {+ context+ .deps+ .outputs+ .queue_messages(LOGS_DLQ_OUTPUT, vec![out])+ .await+ }+ })+ .await;+ if let Err(dlq_error) = &result {+ tracing::error!(error = %dlq_error, original_error = %message_text, partition = message.partition, offset = message.offset, "Failed to produce message to DLQ");+ }+ result+}diff --git a/rust/logs-ingestion/src/pipeline/deps.rs b/rust/logs-ingestion/src/pipeline/deps.rsnew file mode 100644index 000000000000..c8f1b0bce9ce--- /dev/null+++ b/rust/logs-ingestion/src/pipeline/deps.rs@@ -0,0 +1,103 @@+use std::collections::HashMap;+use std::sync::Arc;++use async_trait::async_trait;+use ingestion_framework::IngestionOutputs;++use crate::content_weights::StagedRecord;+use crate::internal_logs::InternalSourcePolicy;+use crate::metric_rules::{MetricRulesSource, MetricsEmitter};+use crate::normalize::LogsSettings;+use crate::rate_limiter::{Clock, KeyRoot, TokenBucketRedis};+use crate::retention::CompiledRetentionRuleSet;+use crate::sampling::CompiledRuleSet;++use super::errors::DependencyRetry;++#[derive(Debug, Clone, Default, PartialEq)]+pub struct Team {+ pub id: i64,+ pub api_token: String,+ pub logs_settings: Option<LogsSettings>,+}++#[async_trait]+pub trait TeamManager: Send + Sync {+ async fn get_team(&self, team_id: i64) -> anyhow::Result<Option<Team>>;+ async fn get_team_by_token(&self, token: &str) -> anyhow::Result<Option<Team>>;+ async fn set_teams_ingested_data(&self, team_ids: &[i64]) -> anyhow::Result<()>;+}++#[async_trait]+pub trait QuotaLimiting: Send + Sync {+ async fn is_team_token_quota_limited(+ &self,+ token: &str,+ resource: &str,+ ) -> anyhow::Result<bool>;+}++#[async_trait]+pub trait UsageRecordBatch: Send + Sync {+ fn add(&self, team_id: i64, usage_key: &str, record_id: &str, quantity: f64, unit: &str);+ async fn flush(&self) -> anyhow::Result<()>;+}++/// `Err` is a throw, including one from `compileRuleSet`.+#[async_trait]+pub trait SamplingRulesSource: Send + Sync {+ async fn get_compiled_rule_set(&self, team_id: i64) -> anyhow::Result<Arc<CompiledRuleSet>>;+}++#[async_trait]+pub trait RetentionRulesSource: Send + Sync {+ async fn get_compiled_rule_set(+ &self,+ team_id: i64,+ source: &str,+ ) -> anyhow::Result<Arc<CompiledRetentionRuleSet>>;+}++#[async_trait]+pub trait PatternMessageKeysSource: Send + Sync {+ async fn get_message_keys(&self, team_id: i64) -> anyhow::Result<Vec<String>>;+}++#[async_trait]+pub trait TracingConfigSource: Send + Sync {+ async fn get_retention_days(&self, team_id: i64) -> anyhow::Result<f64>;+}++/// The Rust port does not run hog, so no implementation exists, and the consumer runs the stage only when one is given.+#[async_trait]+pub trait LogsTransformer: Send + Sync {+ async fn team_has_transformations(&self, team_id: i64) -> anyhow::Result<bool>;+ async fn transform_records(+ &self,+ team_id: i64,+ records: &mut Vec<StagedRecord>,+ ) -> anyhow::Result<()>;+ async fn flush(&self) -> anyhow::Result<()>;+}++/// The caller passes the token-bucket transport, the key root and the clock, so tests can pin all three.+#[derive(Clone)]+pub struct LogsIngestionConsumerDeps {+ pub team_manager: Arc<dyn TeamManager>,+ pub quota_limiting: Arc<dyn QuotaLimiting>,+ pub outputs: Arc<dyn IngestionOutputs>,+ pub usage_batch: Arc<dyn UsageRecordBatch>,+ pub sampling_rules: Option<Arc<dyn SamplingRulesSource>>,+ pub metric_rules: Option<Arc<dyn MetricRulesSource>>,+ pub metrics_emitter: Option<Arc<dyn MetricsEmitter>>,+ pub logs_transformer: Option<Arc<dyn LogsTransformer>>,+ pub retention_rules: Option<Arc<dyn RetentionRulesSource>>,+ pub pattern_message_keys: Option<Arc<dyn PatternMessageKeysSource>>,+ pub tracing_config: Option<Arc<dyn TracingConfigSource>>,+ pub dependency_retry: DependencyRetry,+ pub internal_source_policies: Option<HashMap<String, InternalSourcePolicy>>,+ pub token_bucket_redis: Arc<dyn TokenBucketRedis>,+ pub key_root: KeyRoot,+ /// Epoch milliseconds. Everything that reads `Date.now()` in Node reads this.+ pub clock: Clock,+}diff --git a/rust/logs-ingestion/src/pipeline/errors.rs b/rust/logs-ingestion/src/pipeline/errors.rsnew file mode 100644index 000000000000..7c643a6cb934--- /dev/null+++ b/rust/logs-ingestion/src/pipeline/errors.rs@@ -0,0 +1,138 @@+use std::future::Future;+use std::time::Duration;++use crate::avro::AvroError;+use crate::property_filter::coerce::JsTypeError;++#[derive(Debug, Clone, thiserror::Error)]+#[error("{message}")]+pub struct NamedError {+ pub name: String,+ pub message: String,+}++impl NamedError {+ pub fn new(name: impl Into<String>, message: impl Into<String>) -> Self {+ Self {+ name: name.into(),+ message: message.into(),+ }+ }+}++/// An infrastructure outage, which fails the batch instead of quarantining the message.+#[derive(Debug, Clone, thiserror::Error)]+#[error("{message}")]+pub struct DependencyUnavailableError {+ pub message: String,+ pub dependency_name: String,+}++#[derive(Debug, Clone, thiserror::Error)]+#[error("{message}")]+pub struct KafkaProduceError {+ pub code: i32,+ pub name: String,+ pub message: String,+}++pub const ERR_INVALID_MSG: i32 = 2;+pub const ERR_INVALID_MSG_SIZE: i32 = 4;+pub const ERR_MSG_SIZE_TOO_LARGE: i32 = 10;+pub const ERR_RECORD_LIST_TOO_LARGE: i32 = 18;+pub const ERR_INVALID_RECORD: i32 = 87;+pub const ERR_BAD_MSG: i32 = -199;+pub const ERR_INVALID_ARG: i32 = -186;+pub const ERR_INVALID_TYPE: i32 = -154;++pub const PER_MESSAGE_KAFKA_ERROR_CODES: [i32; 8] = [+ ERR_INVALID_MSG,+ ERR_INVALID_MSG_SIZE,+ ERR_MSG_SIZE_TOO_LARGE,+ ERR_RECORD_LIST_TOO_LARGE,+ ERR_INVALID_RECORD,+ ERR_BAD_MSG,+ ERR_INVALID_ARG,+ ERR_INVALID_TYPE,+];++/// A Kafka outage on the logs produce replays the batch.+pub fn kafka_outage_as_dependency(error: anyhow::Error) -> anyhow::Error {+ match error.downcast_ref::<KafkaProduceError>() {+ Some(e) if !PER_MESSAGE_KAFKA_ERROR_CODES.contains(&e.code) => {+ anyhow::Error::new(DependencyUnavailableError {+ message: e.message.clone(),+ dependency_name: "Kafka".to_string(),+ })+ }+ _ => error,+ }+}++pub fn is_dependency_unavailable(error: &anyhow::Error) -> bool {+ error.downcast_ref::<DependencyUnavailableError>().is_some()+}++pub fn error_name(error: &anyhow::Error) -> String {+ if let Some(e) = error.downcast_ref::<NamedError>() {+ return e.name.clone();+ }+ if let Some(e) = error.downcast_ref::<KafkaProduceError>() {+ return e.name.clone();+ }+ if error.downcast_ref::<DependencyUnavailableError>().is_some() {+ return "DependencyUnavailableError".to_string();+ }+ if error.downcast_ref::<JsTypeError>().is_some() {+ return "TypeError".to_string();+ }+ if error.downcast_ref::<AvroError>().is_some() {+ return "Error".to_string();+ }+ "Error".to_string()+}++pub fn error_message(error: &anyhow::Error) -> String {+ if let Some(e) = error.downcast_ref::<JsTypeError>() {+ return e.0.to_string();+ }+ error.to_string()+}++#[derive(Debug, Clone, Copy)]+pub struct DependencyRetry {+ pub retry_count: u32,+ pub initial_retry_delay_ms: u64,+}++impl Default for DependencyRetry {+ fn default() -> Self {+ Self {+ retry_count: 5,+ initial_retry_delay_ms: 1000,+ }+ }+}++pub async fn retry_on_dependency_unavailable<T, F, Fut>(+ policy: DependencyRetry,+ mut f: F,+) -> anyhow::Result<T>+where+ F: FnMut() -> Fut,+ Fut: Future<Output = anyhow::Result<T>>,+{+ let mut attempt = 0;+ let mut delay = policy.initial_retry_delay_ms;+ loop {+ match f().await {+ Ok(value) => return Ok(value),+ Err(error) if is_dependency_unavailable(&error) && attempt + 1 < policy.retry_count => {+ tokio::time::sleep(Duration::from_millis(delay)).await;+ delay *= 2;+ attempt += 1;+ }+ Err(error) => return Err(error),+ }+ }+}diff --git a/rust/logs-ingestion/src/pipeline/finalize.rs b/rust/logs-ingestion/src/pipeline/finalize.rsnew file mode 100644index 000000000000..219c9e97e4ff--- /dev/null+++ b/rust/logs-ingestion/src/pipeline/finalize.rs@@ -0,0 +1,135 @@+use metrics::counter;+use uuid::Uuid;++use crate::metric_rules::build_metric_rules_otlp_payload;++use super::context::{AppSource, LogsPipelineContext};+use super::process::MetricTalliesByTeam;+use super::types::{+ retention_bytes_metric_name, LogsIngestionMessage, UsageStatsByTeam,+ DEFAULT_LOGS_RETENTION_DAYS,+};++/// The usage report matches `bytes_ingested` exactly, so these names never reach billing.+pub fn queue_internal_logs_usage(context: &LogsPipelineContext, internal: &[LogsIngestionMessage]) {+ for m in internal {+ context.usage_metrics.queue_usage_metric(+ m.team_id,+ "bytes_ingested_internal",+ m.bytes_uncompressed,+ );+ context.usage_metrics.queue_usage_metric(+ m.team_id,+ "records_ingested_internal",+ m.record_count,+ );+ let team = m.team_id.to_string();+ counter!("logs_ingestion_internal_bytes_total", "team_id" => team.clone())+ .increment(m.bytes_uncompressed as u64);+ counter!("logs_ingestion_internal_records_total", "team_id" => team)+ .increment(m.record_count as u64);+ }+}++pub async fn emit_metric_rule_tallies(+ context: &LogsPipelineContext,+ by_team: &MetricTalliesByTeam,+) {+ let states: Vec<_> = by_team.lock().unwrap().clone();+ for (team_id, state) in states {+ let (token, payload) = {+ let state = state.lock().unwrap();+ let team = team_id.to_string();+ let tallies = &state.tallies;+ if tallies.value_skipped > 0 {+ counter!("logs_metrics_rules_value_skipped_total", "team_id" => team.clone())+ .increment(tallies.value_skipped);+ }+ if tallies.eval_errors > 0 {+ counter!("logs_metrics_rules_eval_error_total", "team_id" => team.clone())+ .increment(tallies.eval_errors);+ }+ let overflow: u64 = tallies.series_overflow.values().sum();+ if overflow > 0 {+ counter!("logs_metrics_rules_series_overflow_total", "team_id" => team.clone())+ .increment(overflow);+ }+ let matched: u64 = tallies+ .by_rule+ .values()+ .flat_map(|m| m.values())+ .map(|e| e.count)+ .sum();+ if matched > 0 {+ counter!("logs_metrics_rules_records_matched_total", "team_id" => team)+ .increment(matched);+ }+ (+ state.token.clone(),+ build_metric_rules_otlp_payload(&state.rules, tallies, context.now_ms()),+ )+ };+ let Some(payload) = payload else {+ continue;+ };+ if let Some(emitter) = &context.deps.metrics_emitter {+ emitter.emit(&token, team_id, &payload).await;+ }+ }+}++pub async fn emit_usage_metrics(context: &LogsPipelineContext, usage: &UsageStatsByTeam) {+ let metrics = &context.usage_metrics;+ for (team_id, stats) in &usage.0 {+ let team_id = *team_id;+ metrics.queue_usage_metric(team_id, "bytes_received", stats.bytes_received);+ metrics.queue_usage_metric(team_id, "records_received", stats.records_received);+ metrics.queue_usage_metric(team_id, "bytes_ingested", stats.bytes_allowed);+ metrics.queue_usage_metric(+ team_id,+ "bytes_ingested_records",+ stats.bytes_allowed_records,+ );+ metrics.queue_usage_metric(team_id, "records_ingested", stats.records_allowed);+ metrics.queue_usage_metric(team_id, "bytes_dropped", stats.bytes_dropped);+ metrics.queue_usage_metric(team_id, "records_dropped", stats.records_dropped);+ metrics.queue_usage_metric(team_id, "pii_replacements", stats.pii_replacements);+ if let Some(name) = retention_bytes_metric_name(stats.retention_days) {+ metrics.queue_usage_metric(team_id, &name, stats.bytes_allowed);+ }+ if stats.retention_days != DEFAULT_LOGS_RETENTION_DAYS {+ metrics.queue_retention_byte_days(team_id, stats.bytes_allowed, stats.retention_days);+ }+ let traces = context.identity.app_source == AppSource::Traces;+ let source = if traces { "apm_traces" } else { "logs" };+ // A fresh id per flush keeps two pods flushing the same team from collapsing rows.+ let flush_id = Uuid::now_v7().to_string();+ let batch = &context.deps.usage_batch;+ batch.add(+ team_id,+ &format!("{source}_bytes"),+ &flush_id,+ stats.bytes_allowed,+ "bytes",+ );+ let records_key = if traces {+ "apm_traces_spans"+ } else {+ "logs_records"+ };+ batch.add(+ team_id,+ records_key,+ &flush_id,+ stats.records_allowed,+ "records",+ );+ }+ let (a, b) = futures::join!(metrics.flush(), context.deps.usage_batch.flush());+ if let Err(error) = a {+ tracing::error!(error = %error, "Failed to emit usage metrics - billing data may be lost");+ }+ if let Err(error) = b {+ tracing::error!(error = %error, "Failed to emit usage records - billing data may be lost");+ }+}diff --git a/rust/logs-ingestion/src/pipeline/mod.rs b/rust/logs-ingestion/src/pipeline/mod.rsnew file mode 100644index 000000000000..da0e9b1ad692--- /dev/null+++ b/rust/logs-ingestion/src/pipeline/mod.rs@@ -0,0 +1,22 @@+pub mod admission;+pub mod app_metrics;+pub mod buffer;+pub mod config;+pub mod consumer;+pub mod context;+pub mod deps;+pub mod errors;+pub mod finalize;+pub mod parse;+pub mod pipelines;+pub mod process;+pub mod resolve;+pub mod scenario;+pub mod types;++pub use config::LogsIngestionConsumerConfig;+pub use consumer::{BackgroundTask, LogsIngestionConsumer, ProcessedBatch};+pub use context::{AppSource, LogsConsumerIdentity, LOGS_DLQ_OUTPUT, LOGS_OUTPUT};+pub use deps::*;+pub use errors::{DependencyRetry, DependencyUnavailableError, KafkaProduceError, NamedError};+pub use types::LogsIngestionMessage;diff --git a/rust/logs-ingestion/src/pipeline/parse.rs b/rust/logs-ingestion/src/pipeline/parse.rsnew file mode 100644index 000000000000..664e6d7d0974--- /dev/null+++ b/rust/logs-ingestion/src/pipeline/parse.rs@@ -0,0 +1,135 @@+use std::sync::Arc;++use ingestion_framework::{drop, ok, KafkaMessage, Outcome, PipelineResult, ProcessingStep};+use metrics::counter;++use crate::internal_logs::INTERNAL_LOGS_HEADER;++use super::context::{kafka_header, quarantine_log_message, LogsPipelineContext};+use super::deps::Team;+use super::errors::NamedError;+use super::types::{parse_min_timestamp_header, parse_size_header, LogsIngestionMessage};++pub struct ParseOutcome {+ pub parsed: Option<LogsIngestionMessage>,+ pub failure: Option<anyhow::Error>,+}++fn count_dropped(reason: &'static str) {+ counter!("logs_ingestion_message_dropped_count", "reason" => reason, "team_id" => "unknown")+ .increment(1);+}++async fn parse(+ context: &LogsPipelineContext,+ message: Arc<KafkaMessage>,+) -> anyhow::Result<PipelineResult<LogsIngestionMessage>> {+ let header = |name: &str| kafka_header(&message, name);+ let token = match header("token").as_deref() {+ Some(t) if !t.is_empty() => t.to_string(),+ _ => {+ tracing::warn!("missing_token");+ count_dropped("missing_token");+ return Ok(drop("missing_token"));+ }+ };++ let team: Option<Team> = match context.deps.team_manager.get_team_by_token(&token).await {+ Ok(team) => team,+ Err(error) => {+ tracing::error!(error = %error, "team_lookup_error");+ count_dropped("team_lookup_error");+ return Ok(drop("team_lookup_error"));+ }+ };+ let Some(team) = team else {+ tracing::warn!(token_with_no_team = %token, "team_not_found");+ count_dropped("team_not_found");+ return Ok(drop("team_not_found"));+ };++ let bytes_uncompressed = parse_size_header(header("bytes_uncompressed").as_deref());+ let bytes_uncompressed_records =+ parse_size_header(header("bytes_uncompressed_records").as_deref());+ let bytes_compressed = parse_size_header(header("bytes_compressed").as_deref());+ let record_count = parse_size_header(header("record_count").as_deref());+ let (+ Some(bytes_uncompressed),+ Some(bytes_uncompressed_records),+ Some(bytes_compressed),+ Some(record_count),+ ) = (+ bytes_uncompressed,+ bytes_uncompressed_records,+ bytes_compressed,+ record_count,+ )+ else {+ tracing::error!(+ team_id = team.id,+ partition = message.partition,+ offset = message.offset,+ "logs_ingestion_invalid_size_headers"+ );+ let error = anyhow::Error::new(NamedError::new("Error", "invalid_size_headers"));+ quarantine_log_message(context, &message, &error, Some(&token), Some(team.id)).await?;+ return Ok(drop("invalid_size_headers"));+ };++ if bytes_uncompressed_records > bytes_uncompressed {+ counter!("logs_ingestion_records_bytes_exceed_payload_total", "team_id" => team.id.to_string()).increment(1);+ }++ let internal_logs = context.internal_logs_verifier.verify(+ header(INTERNAL_LOGS_HEADER).as_deref(),+ team.id,+ header("created_at").as_deref(),+ );+ Ok(ok(LogsIngestionMessage {+ token,+ message: message.clone(),+ team_id: team.id,+ bytes_uncompressed,+ bytes_uncompressed_records,+ bytes_compressed,+ record_count,+ min_timestamp_micros: parse_min_timestamp_header(header("min_timestamp").as_deref()),+ backfill_requested: header("backfill_days").is_some(),+ internal_logs,+ }))+}++/// A failed quarantine is carried as a result, so the batch fails only once every message has settled.+pub fn create_settled_parse_step(+ context: Arc<LogsPipelineContext>,+) -> ProcessingStep<Arc<KafkaMessage>, ParseOutcome> {+ ProcessingStep::new("parseLogsMessageStep", move |message: Arc<KafkaMessage>| {+ let context = context.clone();+ async move {+ let result = match parse(&context, message.clone()).await {+ Ok(result) => result,+ Err(e) => {+ // A failed quarantine of bad size headers: the second attempt names the DLQ error.+ tracing::error!(error = %e, partition = message.partition, offset = message.offset, "logs_ingestion_parse_error");+ count_dropped("parse_error");+ if let Err(failure) =+ quarantine_log_message(&context, &message, &e, None, None).await+ {+ return Ok(ok(ParseOutcome {+ parsed: None,+ failure: Some(failure),+ }));+ }+ drop("parse_error")+ }+ };+ Ok(match result.outcome {+ Outcome::Ok(parsed) => ok(ParseOutcome {+ parsed: Some(parsed),+ failure: None,+ }),+ Outcome::NonOk(non_ok) => PipelineResult::new(Outcome::NonOk(non_ok)),+ })+ }+ })+}diff --git a/rust/logs-ingestion/src/pipeline/pipelines.rs b/rust/logs-ingestion/src/pipeline/pipelines.rsnew file mode 100644index 000000000000..44bf5fb8b7a5--- /dev/null+++ b/rust/logs-ingestion/src/pipeline/pipelines.rs@@ -0,0 +1,111 @@+//! Every pipeline is built per batch, because background passes overlap and a chunk pipeline must not have concurrent callers.++use std::sync::Arc;++use ingestion_framework::{+ create_ok_context, new_chunk_pipeline, ok, per_element, ChunkProcessingStep, DynChunkPipeline,+ KafkaMessage,+};++use super::admission::{+ create_backfill_gate_step, create_quota_limit_step, create_rate_limit_step,+ create_record_allowed_usage_step, create_track_incoming_traffic_step, LogsAdmissionInput,+};+use super::context::LogsPipelineContext;+use super::parse::{create_settled_parse_step, ParseOutcome};+use super::process::{create_process_log_message_step, LogsProcessingInput, LogsProcessingOutcome};+use super::types::LogsIngestionMessage;++pub const MAX_CONCURRENT_MESSAGE_PROCESSES: usize = 50;++fn create_fail_parse_on_error_step() -> ChunkProcessingStep<ParseOutcome, LogsIngestionMessage> {+ ChunkProcessingStep::sync("failParseOnErrorStep", |values: Vec<ParseOutcome>| {+ let mut parsed = Vec::with_capacity(values.len());+ for value in values {+ if let Some(failure) = value.failure {+ return Err(failure);+ }+ parsed.push(ok(value+ .parsed+ .expect("an outcome without a failure holds a message")));+ }+ Ok(parsed)+ })+}++pub fn create_logs_parse_pipeline(+ context: Arc<LogsPipelineContext>,+) -> DynChunkPipeline<Arc<KafkaMessage>, LogsIngestionMessage, (), ()> {+ new_chunk_pipeline::<Arc<KafkaMessage>, ()>()+ .pipe_chunk(per_element(create_settled_parse_step(context), None))+ .pipe_chunk(create_fail_parse_on_error_step())+ .build()+}++/// The gates, in the order billing depends on.+pub fn create_logs_admission_pipeline(+ context: Arc<LogsPipelineContext>,+) -> DynChunkPipeline<LogsAdmissionInput, LogsAdmissionInput, (), ()> {+ new_chunk_pipeline::<LogsAdmissionInput, ()>()+ .pipe_chunk(create_track_incoming_traffic_step())+ .pipe_chunk(create_backfill_gate_step(context.clone()))+ .pipe_chunk(create_quota_limit_step(context.clone()))+ .pipe_chunk(create_rate_limit_step(context))+ .pipe_chunk(create_record_allowed_usage_step())+ .build()+}++fn create_fail_pass_on_error_step(+) -> ChunkProcessingStep<LogsProcessingOutcome, LogsProcessingOutcome> {+ ChunkProcessingStep::sync(+ "failPassOnErrorStep",+ |mut values: Vec<LogsProcessingOutcome>| {+ let failures = values.iter().filter(|v| v.failure.is_some()).count();+ let quarantined = values.iter().filter(|v| v.quarantined).count();+ if failures > 0 || quarantined > 0 {+ tracing::error!(+ quarantined,+ failures,+ total = values.len(),+ "Failed to process some log messages"+ );+ }+ if let Some(i) = values.iter().position(|v| v.failure.is_some()) {+ return Err(values.swap_remove(i).failure.unwrap());+ }+ Ok(values.into_iter().map(ok).collect())+ },+ )+}++pub fn create_logs_processing_pipeline(+ context: Arc<LogsPipelineContext>,+) -> DynChunkPipeline<LogsProcessingInput, LogsProcessingOutcome, (), ()> {+ new_chunk_pipeline::<LogsProcessingInput, ()>()+ .pipe_chunk(per_element(+ create_process_log_message_step(context),+ Some(MAX_CONCURRENT_MESSAGE_PROCESSES),+ ))+ .pipe_chunk(create_fail_pass_on_error_step())+ .build()+}++pub async fn run_chunk_pipeline<I: Send + 'static, O: Send + 'static>(+ pipeline: DynChunkPipeline<I, O, (), ()>,+ values: Vec<I>,+) -> anyhow::Result<Vec<O>> {+ if values.is_empty() {+ return Ok(Vec::new());+ }+ pipeline.feed(+ values+ .into_iter()+ .map(|v| create_ok_context(v, ()))+ .collect(),+ );+ let mut out = Vec::new();+ while let Some(chunk) = pipeline.next().await? {+ out.extend(chunk.into_iter().filter_map(|r| r.result.into_value()));+ }+ Ok(out)+}diff --git a/rust/logs-ingestion/src/pipeline/process.rs b/rust/logs-ingestion/src/pipeline/process.rsnew file mode 100644index 000000000000..6dc4316664ca--- /dev/null+++ b/rust/logs-ingestion/src/pipeline/process.rs@@ -0,0 +1,375 @@+use std::sync::{Arc, Mutex};++use ingestion_framework::{ok, OutputMessage, ProcessingStep};+use metrics::{counter, histogram};++use crate::internal_logs::{INTERNAL_LOGS_HEADER, INTERNAL_SOURCE_HEADER};+use crate::js::number_to_string;+use crate::metric_rules::{+ tally_records, with_default_metric_rules, BatchTallies, CompiledMetricRule,+};+use crate::normalize::{sniff_json_log_attributes, LogsSettings};+use crate::record::LogRecord;+use crate::retention::RETENTION_EXPIRED_STAGE_NAME;++use super::buffer::{BufferValue, RecordsVisitor};+use super::context::{+ applies_team_log_rules, is_unbilled_internal, parse_kafka_headers_except,+ quarantine_log_message, team_id_matches_csv, AppSource, LogsPipelineContext, LOGS_OUTPUT,+};+use super::errors::{is_dependency_unavailable, kafka_outage_as_dependency};+use super::resolve::resolve_log_buffer;+use super::types::{billing_byte_reduction_for_drops, LogsIngestionMessage, UsageStatsByTeam};++pub struct MetricRuleBatchState {+ pub token: String,+ pub rules: Vec<CompiledMetricRule>,+ pub tallies: BatchTallies,+}++/// A `Map` keyed by team, in insertion order.+pub type MetricTalliesByTeam = Arc<Mutex<Vec<(i64, Arc<Mutex<MetricRuleBatchState>>)>>>;++#[derive(Clone)]+pub struct LogsProcessingPass {+ pub usage: Arc<Mutex<UsageStatsByTeam>>,+ pub metric_tallies: MetricTalliesByTeam,+}++pub struct LogsProcessingInput {+ pub message: LogsIngestionMessage,+ pub pass: LogsProcessingPass,+}++/// A message never fails its pass on its own: `failure` fails the pass once every message has settled.+pub struct LogsProcessingOutcome {+ pub message: LogsIngestionMessage,+ pub quarantined: bool,+ pub failure: Option<anyhow::Error>,+}++fn can_emit_metric_rules(context: &LogsPipelineContext) -> bool {+ !context.gates.metric_rules_killswitch+ && context.deps.metric_rules.is_some()+ && context.deps.metrics_emitter.is_some()+}++async fn get_metric_rule_batch_state(+ context: &LogsPipelineContext,+ by_team: &MetricTalliesByTeam,+ message: &LogsIngestionMessage,+) -> Option<Arc<Mutex<MetricRuleBatchState>>> {+ if !applies_team_log_rules(message) {+ return None;+ }+ let team_rules_enabled = can_emit_metric_rules(context)+ && team_id_matches_csv(&context.gates.metric_rules_enabled_teams, message.team_id);+ let default_rules_enabled = can_emit_metric_rules(context)+ && team_id_matches_csv(+ &context.gates.default_metric_rules_enabled_teams,+ message.team_id,+ );+ if !team_rules_enabled && !default_rules_enabled {+ return None;+ }+ let existing = by_team+ .lock()+ .unwrap()+ .iter()+ .find(|(t, _)| *t == message.team_id)+ .map(|(_, s)| s.clone());+ let state = match existing {+ Some(state) => state,+ None => {+ let mut rules: Vec<CompiledMetricRule> = Vec::new();+ if team_rules_enabled {+ match context+ .deps+ .metric_rules+ .as_ref()+ .unwrap()+ .get_compiled_rules(message.team_id)+ .await+ {+ Ok(all) => {+ rules = all+ .iter()+ .filter(|r| r.source == context.identity.metric_rule_source)+ .cloned()+ .collect()+ }+ Err(error) => {+ // Fail open: metric rules must never DLQ or block the log records.+ tracing::warn!(team_id = message.team_id, error = %error, "[logs-metric-rules] rules fetch failed — skipping metric rules for batch");+ return None;+ }+ }+ }+ if default_rules_enabled {+ rules = with_default_metric_rules(rules, context.identity.metric_rule_source);+ }+ // Concurrent messages for the same team race here; keep the first state.+ let mut by_team = by_team.lock().unwrap();+ match by_team.iter().find(|(t, _)| *t == message.team_id) {+ Some((_, state)) => state.clone(),+ None => {+ let state = Arc::new(Mutex::new(MetricRuleBatchState {+ token: message.token.clone(),+ rules,+ tallies: BatchTallies::new(),+ }));+ by_team.push((message.team_id, state.clone()));+ state+ }+ }+ }+ };+ let has_rules = !state.lock().unwrap().rules.is_empty();+ has_rules.then_some(state)+}++fn settings_of(team: Option<&super::deps::Team>) -> LogsSettings {+ team.and_then(|t| t.logs_settings.clone())+ .unwrap_or_default()+}++async fn process_log_message(+ context: &LogsPipelineContext,+ input: &LogsProcessingInput,+) -> anyhow::Result<()> {+ let message = &input.message;+ let pass = &input.pass;+ let team_id = message.team_id;+ let team = context+ .retry(|| context.deps.team_manager.get_team(team_id))+ .await?;+ let settings = settings_of(team.as_ref());+ let json_parse = settings.json_parse_logs.unwrap_or(false);+ let retention_days = context+ .retry(|| context.default_retention_days(team_id, &settings))+ .await?;++ if let Some(stats) = pass.usage.lock().unwrap().get_mut(team_id) {+ stats.retention_days = retention_days;+ }++ if message.message.value.is_none() {+ return Ok(());+ }++ let metric_state = get_metric_rule_batch_state(context, &pass.metric_tallies, message).await;+ let is_logs = context.identity.app_source == AppSource::Logs;+ let json_attribute_key = settings.json_parse_logs_attribute_key.clone().filter(|_| {+ is_logs && team_id_matches_csv(&context.gates.json_attribute_parsing_enabled_teams, team_id)+ });+ let visitor: Option<RecordsVisitor<'_>> =+ if metric_state.is_some() || json_attribute_key.is_some() {+ Some(Box::new(move |records: &[LogRecord]| {+ if let Some(state) = &metric_state {+ let now_ms = context.now_ms();+ let mut state = state.lock().unwrap();+ let MetricRuleBatchState { rules, tallies, .. } = &mut *state;+ let mut admission = context.metric_series_admission.lock().unwrap();+ let mut admit = |rule_id: &str, label_key: &str| {+ admission.admit(team_id, rule_id, label_key, now_ms)+ };+ tally_records(rules, records, tallies, now_ms, Some(&mut admit))?;+ }+ if let Some(key) = &json_attribute_key {+ sniff_json_log_attributes(records.iter(), key, team_id);+ }+ Ok(())+ }))+ } else {+ None+ };++ let mut buffer_settings = settings.clone();+ if !(is_logs+ && team_id_matches_csv(+ &context.gates.json_attribute_extraction_enabled_teams,+ team_id,+ ))+ {+ buffer_settings.json_parse_logs_attribute_key = None;+ }+ let resolved =+ resolve_log_buffer(context, message, &buffer_settings, retention_days, visitor).await?;++ context.usage_metrics.queue_usage_metric(+ team_id,+ "records_dropped_retention_expired",+ resolved.records_dropped_by_stage(RETENTION_EXPIRED_STAGE_NAME),+ );++ let mut override_uncompressed = None;+ let mut override_compressed = None;+ let mut override_record_count = None;+ let drops = &resolved.drops;+ let records_dropped = drops.stage.records_dropped;+ if records_dropped > 0.0 {+ let header = message.bytes_uncompressed;+ let content_credit = billing_byte_reduction_for_drops(+ header,+ drops.stage.content_bytes_dropped,+ drops.content_bytes_total,+ );+ let record_credit =+ billing_byte_reduction_for_drops(header, records_dropped, message.record_count);+ let team_label = team_id.to_string();+ if !is_unbilled_internal(message) {+ if content_credit > 0.0 {+ counter!("logs_ingestion_billing_bytes_credited_total", "team_id" => team_label.clone())+ .increment(content_credit as u64);+ }+ counter!("logs_ingestion_billing_records_credited_total", "team_id" => team_label)+ .increment(records_dropped as u64);+ }+ if message.record_count > 0.0 {+ histogram!("logs_ingestion_drop_batch_rows").record(message.record_count);+ }+ if drops.content_bytes_total > 0.0 {+ histogram!("logs_ingestion_drop_fraction")+ .record((drops.stage.content_bytes_dropped / drops.content_bytes_total).min(1.0));+ }+ if header > 0.0 {+ histogram!("logs_ingestion_billing_prorate_divergence")+ .record((content_credit - record_credit).abs() / header);+ }+ if context.gates.billing_prorate_enabled {+ if let Some(row) = pass.usage.lock().unwrap().get_mut(team_id) {+ row.bytes_allowed = (row.bytes_allowed - content_credit).max(0.0);+ row.records_allowed = (row.records_allowed - records_dropped).max(0.0);+ }+ let compressed_credit = billing_byte_reduction_for_drops(+ message.bytes_compressed,+ drops.stage.content_bytes_dropped,+ drops.content_bytes_total,+ );+ override_uncompressed = Some((header - content_credit).max(0.0));+ override_compressed = Some((message.bytes_compressed - compressed_credit).max(0.0));+ override_record_count = Some((message.record_count - records_dropped).max(0.0));+ }+ }++ if resolved.pii.pii_replacements > 0 {+ let mut usage = pass.usage.lock().unwrap();+ usage.row(team_id).pii_replacements += resolved.pii.pii_replacements as f64;+ }+ let usage_metrics = &context.usage_metrics;+ usage_metrics.queue_by_rule(+ team_id,+ "sampling_records_dropped_by_rule",+ &drops.stage.records_dropped_by_rule_id,+ );+ usage_metrics.queue_by_rule(+ team_id,+ "bytes_dropped_by_rule",+ &drops.stage.bytes_dropped_by_rule_id,+ );++ let value = match resolved.value {+ None => {+ let reason = resolved.dropped_reason.unwrap_or_default();+ counter!("logs_ingestion_message_dropped_count", "reason" => reason, "team_id" => team_id.to_string())+ .increment(1);+ return Ok(());+ }+ Some(BufferValue::Encoded(bytes)) => Some(bytes.into()),+ Some(_) => message.message.value.clone(),+ };++ // Built per attempt, so the first attempt needs no copy of the message.+ let output = || {+ let mut headers = parse_kafka_headers_except(+ &message.message,+ &[INTERNAL_LOGS_HEADER, INTERNAL_SOURCE_HEADER],+ 10,+ );+ if let Some(internal) = &message.internal_logs {+ headers.set(INTERNAL_SOURCE_HEADER, internal.source.clone());+ }+ headers.set("token", message.token.clone());+ headers.set("team_id", team_id.to_string());+ headers.set("json-parse", json_parse.to_string());+ headers.set("retention-days", number_to_string(retention_days));+ headers.set("source_topic", message.message.topic.clone());+ headers.set("source_partition", message.message.partition.to_string());+ if let Some(n) = override_uncompressed {+ headers.set("bytes_uncompressed", number_to_string(n));+ }+ if let Some(n) = override_compressed {+ headers.set("bytes_compressed", number_to_string(n));+ }+ if let Some(n) = override_record_count {+ headers.set("record_count", number_to_string(n));+ }+ OutputMessage {+ value: value.clone(),+ key: None,+ headers,+ }+ };+ context+ .retry(|| {+ let out = output();+ async move {+ context+ .deps+ .outputs+ .queue_messages(LOGS_OUTPUT, vec![out])+ .await+ .map_err(kafka_outage_as_dependency)+ }+ })+ .await+}++pub fn create_process_log_message_step(+ context: Arc<LogsPipelineContext>,+) -> ProcessingStep<LogsProcessingInput, LogsProcessingOutcome> {+ ProcessingStep::new(+ "processLogMessageStep",+ move |input: LogsProcessingInput| {+ let context = context.clone();+ async move {+ let outcome = match process_log_message(&context, &input).await {+ Ok(()) => LogsProcessingOutcome {+ message: input.message,+ quarantined: false,+ failure: None,+ },+ Err(error) if is_dependency_unavailable(&error) => LogsProcessingOutcome {+ message: input.message,+ quarantined: false,+ failure: Some(error),+ },+ Err(error) => {+ let m = &input.message;+ match quarantine_log_message(+ &context,+ &m.message,+ &error,+ Some(&m.token),+ Some(m.team_id),+ )+ .await+ {+ Ok(()) => LogsProcessingOutcome {+ message: input.message,+ quarantined: true,+ failure: None,+ },+ Err(dlq_error) => LogsProcessingOutcome {+ message: input.message,+ quarantined: false,+ failure: Some(dlq_error),+ },+ }+ }+ };+ Ok(ok(outcome))+ }+ },+ )+}diff --git a/rust/logs-ingestion/src/pipeline/resolve.rs b/rust/logs-ingestion/src/pipeline/resolve.rsnew file mode 100644index 000000000000..c3618385cb3b--- /dev/null+++ b/rust/logs-ingestion/src/pipeline/resolve.rs@@ -0,0 +1,262 @@+use std::sync::Arc;++use async_trait::async_trait;+use metrics::counter;++use crate::content_weights::{+ BatchContext, DropStats, FilterResult, FilterStage, MutateStage, PipelineStage, StageDropStats,+ StagedRecord,+};+use crate::normalize::{buffer_processing_mode, BufferProcessingMode, LogsSettings};+use crate::pattern::{stamp_pattern_batch, MESSAGE_KEYS};+use crate::pii::PiiScrubStats;+use crate::retention::{can_hold_expired_row, make_retention_expired_stage, make_retention_stage};+use crate::sampling::SAMPLING_STAGE_NAME;++use super::buffer::{process_log_message_buffer, BufferValue, RecordsVisitor};+use super::context::{applies_team_log_rules, team_id_matches_csv, AppSource, LogsPipelineContext};+use super::deps::LogsTransformer;+use super::types::{LogsIngestionMessage, INTERNAL_LOGS_MIN_RETENTION_DAYS};++pub struct ResolvedLogBuffer {+ pub value: Option<BufferValue>,+ pub dropped_reason: Option<String>,+ pub pii: PiiScrubStats,+ pub drops: DropStats,+}++impl ResolvedLogBuffer {+ pub fn records_dropped_by_stage(&self, stage: &str) -> f64 {+ self.drops+ .records_dropped_by_stage+ .get(stage)+ .unwrap_or(0.0)+ }+}++pub fn is_sampling_eval_enabled_for_team(context: &LogsPipelineContext, team_id: i64) -> bool {+ !context.gates.sampling_killswitch+ && team_id_matches_csv(&context.gates.sampling_enabled_teams, team_id)+}++pub fn is_retention_eval_enabled_for_team(context: &LogsPipelineContext, team_id: i64) -> bool {+ !context.gates.retention_killswitch+ && team_id_matches_csv(&context.gates.retention_enabled_teams, team_id)+}++fn is_transformations_enabled_for_team(context: &LogsPipelineContext, team_id: i64) -> bool {+ !context.gates.transformations_killswitch+ && context.deps.logs_transformer.is_some()+ && team_id_matches_csv(&context.gates.transformations_enabled_teams, team_id)+}++/// Logs only: a trace record has no `body`, so masking one measures nothing.+pub fn is_pattern_masking_enabled_for_team(context: &LogsPipelineContext, team_id: i64) -> bool {+ context.identity.app_source == AppSource::Logs+ && team_id_matches_csv(&context.gates.pattern_masking_enabled_teams, team_id)+}++/// Hog transforms mutate the survivors in place and may drop. Partial drops are not credited.+struct TransformStage {+ transformer: Arc<dyn LogsTransformer>,+ team_id: i64,+}++#[async_trait]+impl FilterStage for TransformStage {+ fn name(&self) -> &str {+ "transformations"+ }++ async fn run(+ &self,+ mut records: Vec<StagedRecord>,+ _batch: &BatchContext,+ ) -> anyhow::Result<FilterResult> {+ self.transformer+ .transform_records(self.team_id, &mut records)+ .await?;+ Ok(FilterResult {+ kept: records,+ stats: StageDropStats::default(),+ })+ }+}++struct PatternMaskingStage {+ message_keys: Vec<String>,+}++#[async_trait]+impl MutateStage for PatternMaskingStage {+ fn name(&self) -> &str {+ "pattern_masking"+ }++ async fn run(&self, records: &mut Vec<StagedRecord>) -> anyhow::Result<()> {+ let keys: Vec<&str> = self.message_keys.iter().map(String::as_str).collect();+ for staged in records.iter_mut() {+ stamp_pattern_batch(std::slice::from_mut(&mut staged.record), &keys);+ }+ Ok(())+ }+}++async fn build_transform_stage(+ context: &LogsPipelineContext,+ message: &LogsIngestionMessage,+) -> anyhow::Result<Option<PipelineStage>> {+ let Some(transformer) = context.deps.logs_transformer.clone() else {+ return Ok(None);+ };+ if !applies_team_log_rules(message)+ || !is_transformations_enabled_for_team(context, message.team_id)+ {+ return Ok(None);+ }+ if !transformer+ .team_has_transformations(message.team_id)+ .await?+ {+ return Ok(None);+ }+ Ok(Some(PipelineStage::Filter(Box::new(TransformStage {+ transformer,+ team_id: message.team_id,+ }))))+}++pub async fn resolve_log_buffer(+ context: &LogsPipelineContext,+ message: &LogsIngestionMessage,+ settings: &LogsSettings,+ default_retention_days: f64,+ visitor: Option<RecordsVisitor<'_>>,+) -> anyhow::Result<ResolvedLogBuffer> {+ let deps = &context.deps;+ let team_id = message.team_id;++ let mut rule_set = None;+ if let Some(cache) = &deps.sampling_rules {+ if is_sampling_eval_enabled_for_team(context, team_id) && applies_team_log_rules(message) {+ rule_set = Some(cache.get_compiled_rule_set(team_id).await?);+ }+ }+ let use_sampling = rule_set.as_ref().is_some_and(|r| !r.rules.is_empty());+ let transform_stage = build_transform_stage(context, message).await?;++ let mut retention_rules = None;+ if let Some(cache) = &deps.retention_rules {+ if is_retention_eval_enabled_for_team(context, team_id) && applies_team_log_rules(message) {+ retention_rules = Some(+ cache+ .get_compiled_rule_set(team_id, &context.identity.retention_rule_source)+ .await?,+ );+ }+ }+ let use_retention = retention_rules+ .as_ref()+ .is_some_and(|r| !r.rules.is_empty());++ let mut stages: Vec<PipelineStage> = Vec::new();+ if use_sampling {+ stages.push(context.sampling_service.make_sampling_stage(+ rule_set.clone().unwrap(),+ Some(team_id),+ message.bytes_uncompressed,+ ));+ }+ if let Some(stage) = transform_stage {+ stages.push(stage);+ }+ let mut shortest_retention_days = if message.internal_logs.is_some() {+ INTERNAL_LOGS_MIN_RETENTION_DAYS+ } else {+ default_retention_days+ };+ if let Some(rules) = retention_rules.filter(|_| use_retention) {+ shortest_retention_days = rules+ .rules+ .iter()+ .map(|r| r.retention_days as f64)+ .fold(default_retention_days, f64::min);+ stages.push(make_retention_stage(+ rules,+ team_id,+ default_retention_days as i64,+ ));+ }++ // Checking rows for expiry needs a decode, which only backdated imports need.+ let now_micros = context.now_ms() * 1000.0;+ if can_hold_expired_row(+ message.min_timestamp_micros,+ shortest_retention_days,+ now_micros,+ ) {+ stages.push(make_retention_expired_stage(+ team_id,+ default_retention_days,+ now_micros,+ ));+ }++ if is_pattern_masking_enabled_for_team(context, team_id) {+ let mode_without_masking =+ buffer_processing_mode(settings, stages.len(), visitor.is_some());+ if mode_without_masking != BufferProcessingMode::DecodeAndReencode {+ let from = match mode_without_masking {+ BufferProcessingMode::Passthrough => "passthrough",+ _ => "decode_only",+ };+ counter!("logs_ingestion_pattern_forced_decode_total", "from" => from).increment(1);+ }+ let message_keys = match &deps.pattern_message_keys {+ Some(cache) => context.retry(|| cache.get_message_keys(team_id)).await?,+ None => MESSAGE_KEYS.iter().map(|k| k.to_string()).collect(),+ };+ stages.push(PipelineStage::Mutate(Box::new(PatternMaskingStage {+ message_keys,+ })));+ }++ let buffer = message.message.value.as_deref().unwrap_or_default();+ let processed = process_log_message_buffer(buffer, settings, visitor, &stages).await?;++ let team_label = team_id.to_string();+ let by_sampling = processed+ .drops+ .records_dropped_by_stage+ .get(SAMPLING_STAGE_NAME)+ .unwrap_or(0.0);+ if by_sampling > 0.0 {+ counter!("logs_ingestion_sampling_records_dropped_total", "team_id" => team_label.clone())+ .increment(by_sampling as u64);+ }+ if processed.drops.stage.bytes_dropped > 0.0 {+ counter!("logs_ingestion_bytes_dropped_by_rule_total", "team_id" => team_label)+ .increment(processed.drops.stage.bytes_dropped as u64);+ }++ match processed.value {+ BufferValue::Dropped => {+ let reason = match &processed.drops.dropped_by {+ Some(stage) => format!("{stage}_all_dropped"),+ None => "empty_batch".to_string(),+ };+ Ok(ResolvedLogBuffer {+ value: None,+ dropped_reason: Some(reason),+ pii: processed.pii,+ drops: processed.drops,+ })+ }+ value => Ok(ResolvedLogBuffer {+ value: Some(value),+ dropped_reason: None,+ pii: processed.pii,+ drops: processed.drops,+ }),+ }+}diff --git a/rust/logs-ingestion/src/pipeline/scenario.rs b/rust/logs-ingestion/src/pipeline/scenario.rsnew file mode 100644index 000000000000..110991f16f7a--- /dev/null+++ b/rust/logs-ingestion/src/pipeline/scenario.rs@@ -0,0 +1,676 @@+//! Mirrors `parity-harness.ts`. The parity test and the benchmark binary both use it.++use std::collections::HashMap;+use std::sync::atomic::{AtomicU64, Ordering};+use std::sync::{Arc, Mutex};++use async_trait::async_trait;+use base64::Engine;+use ingestion_framework::{IngestionOutputs, KafkaMessage, OutputMessage};++use crate::internal_logs::InternalSourcePolicy;+use crate::js::{JsObject, JsValue};+use crate::metric_rules::{+ compile_metric_rules, CompiledMetricRule, MetricRuleRow, MetricRulesSource, MetricsEmitter,+};+use crate::normalize::LogsSettings;+use crate::pattern::MESSAGE_KEYS;+use crate::rate_limiter::{Clock, KeyRoot, TokenBucketRedis};+use crate::retention::{compile_retention_rule_set, CompiledRetentionRuleSet, RetentionRuleRow};+use crate::sampling::{compile_rule_set, CompiledRuleSet, SamplingRuleRow};++use super::config::LogsIngestionConsumerConfig;+use super::consumer::LogsIngestionConsumer;+use super::context::LogsConsumerIdentity;+use super::deps::*;+use super::errors::{DependencyRetry, DependencyUnavailableError, KafkaProduceError, NamedError};++fn get<'a>(v: &'a JsValue, key: &str) -> Option<&'a JsValue> {+ match v {+ JsValue::Object(o) => o.get(key),+ _ => None,+ }+}++fn s(v: Option<&JsValue>) -> Option<String> {+ match v {+ Some(JsValue::String(s)) => Some(s.to_utf8_lossy().into_owned()),+ _ => None,+ }+}++fn n(v: Option<&JsValue>) -> Option<f64> {+ match v {+ Some(JsValue::Number(n)) => Some(*n),+ _ => None,+ }+}++fn arr(v: Option<&JsValue>) -> &[JsValue] {+ match v {+ Some(JsValue::Array(a)) => a,+ _ => &[],+ }+}++fn entries(v: Option<&JsValue>) -> Vec<(String, &JsValue)> {+ match v {+ Some(JsValue::Object(o)) => o+ .iter()+ .map(|(k, v)| (k.to_utf8_lossy().into_owned(), v))+ .collect(),+ _ => Vec::new(),+ }+}++fn to_error(spec: &JsValue) -> anyhow::Error {+ let name = s(get(spec, "name")).unwrap_or_default();+ let message = s(get(spec, "message")).unwrap_or_default();+ if matches!(+ get(spec, "dependency_unavailable"),+ Some(JsValue::Bool(true))+ ) {+ return anyhow::Error::new(DependencyUnavailableError {+ message,+ dependency_name: "parity".to_string(),+ });+ }+ if let Some(code) = n(get(spec, "kafka_code")) {+ return anyhow::Error::new(KafkaProduceError {+ code: code as i32,+ name,+ message,+ });+ }+ anyhow::Error::new(NamedError::new(name, message))+}++pub fn logs_settings(value: Option<&JsValue>) -> Option<LogsSettings> {+ let value = value.filter(|v| matches!(v, JsValue::Object(_)))?;+ Some(LogsSettings {+ capture_console_logs: match get(value, "capture_console_logs") {+ Some(JsValue::Bool(b)) => Some(*b),+ _ => None,+ },+ json_parse_logs: match get(value, "json_parse_logs") {+ Some(JsValue::Bool(b)) => Some(*b),+ _ => None,+ },+ json_parse_logs_attribute_key: s(get(value, "json_parse_logs_attribute_key")),+ pii_scrub_logs: match get(value, "pii_scrub_logs") {+ Some(JsValue::Bool(b)) => Some(*b),+ _ => None,+ },+ retention_days: n(get(value, "retention_days")),+ retention_last_updated: s(get(value, "retention_last_updated")),+ })+}++pub fn kafka_message(m: &JsValue) -> KafkaMessage {+ KafkaMessage {+ topic: s(get(m, "topic")).unwrap_or_default(),+ partition: n(get(m, "partition")).unwrap_or(0.0) as i32,+ offset: n(get(m, "offset")).unwrap_or(0.0) as i64,+ key: s(get(m, "key")).map(String::into_bytes),+ value: s(get(m, "value_b64")).map(|b| {+ base64::engine::general_purpose::STANDARD+ .decode(b)+ .unwrap()+ .into()+ }),+ headers: arr(get(m, "headers"))+ .iter()+ .map(|h| {+ let pair = arr(Some(h));+ (+ s(pair.first()).unwrap_or_default(),+ Some(s(pair.get(1)).unwrap_or_default().into_bytes()),+ )+ })+ .collect(),+ timestamp: n(get(m, "timestamp")).map(|t| t as i64),+ }+}++#[derive(Clone)]+pub struct PinnedClock(Arc<AtomicU64>);++impl PinnedClock {+ pub fn new(ms: f64) -> Self {+ Self(Arc::new(AtomicU64::new(ms.to_bits())))+ }+ pub fn set(&self, ms: f64) {+ self.0.store(ms.to_bits(), Ordering::SeqCst);+ }+ pub fn clock(&self) -> Clock {+ let bits = self.0.clone();+ Arc::new(move || f64::from_bits(bits.load(Ordering::SeqCst)))+ }+}++#[derive(Debug, Clone)]+pub struct CapturedMessage {+ pub batch: usize,+ pub output: String,+ pub message: OutputMessage,+}++pub struct CapturingOutputs {+ faults: Vec<(String, Option<String>, JsValue)>,+ remaining: Mutex<Vec<u64>>,+ pub captured: Mutex<Vec<CapturedMessage>>,+ pub produced_count: AtomicU64,+ pub current_batch: AtomicU64,+ discard: bool,+}++#[async_trait]+impl IngestionOutputs for CapturingOutputs {+ async fn produce(&self, output: &str, message: OutputMessage) -> anyhow::Result<()> {+ self.queue_messages(output, vec![message]).await+ }++ async fn queue_messages(+ &self,+ output: &str,+ messages: Vec<OutputMessage>,+ ) -> anyhow::Result<()> {+ {+ let mut remaining = self.remaining.lock().unwrap();+ for message in &messages {+ for (i, (fault_output, team, error)) in self.faults.iter().enumerate() {+ if fault_output != output || remaining[i] == 0 {+ continue;+ }+ if team+ .as_ref()+ .is_some_and(|t| message.headers.get("team_id") != Some(t))+ {+ continue;+ }+ remaining[i] -= 1;+ return Err(to_error(error));+ }+ }+ }+ self.produced_count+ .fetch_add(messages.len() as u64, Ordering::SeqCst);+ if !self.discard {+ let batch = self.current_batch.load(Ordering::SeqCst) as usize;+ let mut captured = self.captured.lock().unwrap();+ for message in messages {+ captured.push(CapturedMessage {+ batch,+ output: output.to_string(),+ message,+ });+ }+ }+ Ok(())+ }+}++#[derive(Debug, Clone)]+pub struct UsageRow {+ pub batch: usize,+ pub team_id: i64,+ pub metric: String,+ pub quantity: f64,+ pub unit: String,+ pub record_id: String,+}++#[derive(Default)]+pub struct Recorded {+ pub teams_ingested: Mutex<Vec<Vec<i64>>>,+ pub metric_emits: Mutex<Vec<(String, i64, JsValue)>>,+ pub usage_rows: Mutex<Vec<UsageRow>>,+ pub quota_checks: Mutex<Vec<(String, String)>>,+}++struct ScenarioTeams {+ by_id: HashMap<i64, Team>,+ by_token: HashMap<String, Team>,+ lookup_faults: HashMap<String, JsValue>,+ by_id_faults: Mutex<HashMap<i64, (u64, JsValue)>>,+ missing: Vec<i64>,+ recorded: Arc<Recorded>,+}++#[async_trait]+impl TeamManager for ScenarioTeams {+ async fn get_team(&self, team_id: i64) -> anyhow::Result<Option<Team>> {+ if let Some((left, spec)) = self.by_id_faults.lock().unwrap().get_mut(&team_id) {+ if *left > 0 {+ *left -= 1;+ return Err(to_error(spec));+ }+ }+ if self.missing.contains(&team_id) {+ return Ok(None);+ }+ Ok(self.by_id.get(&team_id).cloned())+ }++ async fn get_team_by_token(&self, token: &str) -> anyhow::Result<Option<Team>> {+ if let Some(spec) = self.lookup_faults.get(token) {+ return Err(to_error(spec));+ }+ Ok(self.by_token.get(token).cloned())+ }++ async fn set_teams_ingested_data(&self, team_ids: &[i64]) -> anyhow::Result<()> {+ self.recorded+ .teams_ingested+ .lock()+ .unwrap()+ .push(team_ids.to_vec());+ Ok(())+ }+}++struct ScenarioQuota {+ limited: Vec<String>,+ recorded: Arc<Recorded>,+}++#[async_trait]+impl QuotaLimiting for ScenarioQuota {+ async fn is_team_token_quota_limited(+ &self,+ token: &str,+ resource: &str,+ ) -> anyhow::Result<bool> {+ let pair = (token.to_string(), resource.to_string());+ let mut checks = self.recorded.quota_checks.lock().unwrap();+ if !checks.contains(&pair) {+ checks.push(pair);+ }+ Ok(self.limited.iter().any(|t| t == token))+ }+}++struct ScenarioUsage {+ outputs: Arc<CapturingOutputs>,+ recorded: Arc<Recorded>,+ discard: bool,+}++#[async_trait]+impl UsageRecordBatch for ScenarioUsage {+ fn add(&self, team_id: i64, usage_key: &str, record_id: &str, quantity: f64, unit: &str) {+ if self.discard {+ return;+ }+ self.recorded.usage_rows.lock().unwrap().push(UsageRow {+ batch: self.outputs.current_batch.load(Ordering::SeqCst) as usize,+ team_id,+ metric: usage_key.to_string(),+ quantity,+ unit: unit.to_string(),+ record_id: record_id.to_string(),+ });+ }+ async fn flush(&self) -> anyhow::Result<()> {+ Ok(())+ }+}++fn team_rows(v: Option<&JsValue>, team_id: i64) -> Vec<JsValue> {+ entries(v)+ .into_iter()+ .find(|(k, _)| k.parse::<i64>().ok() == Some(team_id))+ .map(|(_, rows)| arr(Some(rows)).to_vec())+ .unwrap_or_default()+}++/// Production reads compiled rules from a cache, so the harness compiles each set once.+struct Compiled<K, V>(Mutex<HashMap<K, Arc<V>>>);++impl<K: std::hash::Hash + Eq, V> Default for Compiled<K, V> {+ fn default() -> Self {+ Self(Mutex::new(HashMap::new()))+ }+}++impl<K: std::hash::Hash + Eq, V> Compiled<K, V> {+ fn get_or_compile(+ &self,+ key: K,+ compile: impl FnOnce() -> anyhow::Result<V>,+ ) -> anyhow::Result<Arc<V>> {+ if let Some(v) = self.0.lock().unwrap().get(&key) {+ return Ok(v.clone());+ }+ let v = Arc::new(compile()?);+ Ok(self.0.lock().unwrap().entry(key).or_insert(v).clone())+ }+}++struct ScenarioSampling(JsValue, Compiled<i64, CompiledRuleSet>);++#[async_trait]+impl SamplingRulesSource for ScenarioSampling {+ async fn get_compiled_rule_set(&self, team_id: i64) -> anyhow::Result<Arc<CompiledRuleSet>> {+ self.1.get_or_compile(team_id, || self.compile(team_id))+ }+}++impl ScenarioSampling {+ fn compile(&self, team_id: i64) -> anyhow::Result<CompiledRuleSet> {+ let rows: Vec<SamplingRuleRow> = team_rows(Some(&self.0), team_id)+ .iter()+ .map(|r| SamplingRuleRow {+ id: s(get(r, "id")).unwrap_or_default(),+ rule_type: s(get(r, "rule_type")).unwrap_or_default(),+ scope_service: s(get(r, "scope_service")),+ scope_path_pattern: s(get(r, "scope_path_pattern")),+ scope_attribute_filters: get(r, "scope_attribute_filters")+ .cloned()+ .unwrap_or(JsValue::Null),+ config: get(r, "config").cloned().unwrap_or(JsValue::Null),+ version: None,+ })+ .collect();+ compile_rule_set(&rows).map_err(anyhow::Error::new)+ }+}++struct ScenarioRetention(JsValue, Compiled<(i64, String), CompiledRetentionRuleSet>);++#[async_trait]+impl RetentionRulesSource for ScenarioRetention {+ async fn get_compiled_rule_set(+ &self,+ team_id: i64,+ source: &str,+ ) -> anyhow::Result<Arc<CompiledRetentionRuleSet>> {+ self.1.get_or_compile((team_id, source.to_string()), || {+ self.compile(team_id, source)+ })+ }+}++impl ScenarioRetention {+ fn compile(&self, team_id: i64, source: &str) -> anyhow::Result<CompiledRetentionRuleSet> {+ let by_source = entries(Some(&self.0))+ .into_iter()+ .find(|(k, _)| k.parse::<i64>().ok() == Some(team_id))+ .map(|(_, v)| v.clone());+ let rows: Vec<RetentionRuleRow> = arr(by_source.as_ref().and_then(|v| get(v, source)))+ .iter()+ .map(|r| RetentionRuleRow {+ id: s(get(r, "id")).unwrap_or_default(),+ config: get(r, "config").cloned().unwrap_or(JsValue::Null),+ version: None,+ })+ .collect();+ compile_retention_rule_set(&rows).map_err(anyhow::Error::new)+ }+}++struct ScenarioMetricRules {+ rows: JsValue,+ faults: JsValue,+ compiled: Compiled<i64, Vec<CompiledMetricRule>>,+}++#[async_trait]+impl MetricRulesSource for ScenarioMetricRules {+ async fn get_compiled_rules(+ &self,+ team_id: i64,+ ) -> anyhow::Result<Arc<Vec<CompiledMetricRule>>> {+ if let Some((_, spec)) = entries(Some(&self.faults))+ .into_iter()+ .find(|(k, _)| k.parse::<i64>().ok() == Some(team_id))+ {+ return Err(to_error(spec));+ }+ self.compiled.get_or_compile(team_id, || {+ let rows: Vec<MetricRuleRow> = team_rows(Some(&self.rows), team_id)+ .iter()+ .filter_map(|r| match r {+ JsValue::Object(o) => Some(MetricRuleRow::from_js(o)),+ _ => None,+ })+ .collect();+ compile_metric_rules(&rows).map_err(anyhow::Error::new)+ })+ }+}++struct ScenarioEmitter {+ faults: Vec<i64>,+ recorded: Arc<Recorded>,+}++#[async_trait]+impl MetricsEmitter for ScenarioEmitter {+ async fn emit(&self, token: &str, team_id: i64, payload: &JsValue) -> bool {+ if self.faults.contains(&team_id) {+ return false;+ }+ self.recorded.metric_emits.lock().unwrap().push((+ token.to_string(),+ team_id,+ payload.clone(),+ ));+ true+ }+}++struct ScenarioPatternKeys {+ keys: JsValue,+ faults: Mutex<HashMap<i64, (u64, JsValue)>>,+}++#[async_trait]+impl PatternMessageKeysSource for ScenarioPatternKeys {+ async fn get_message_keys(&self, team_id: i64) -> anyhow::Result<Vec<String>> {+ if let Some((left, spec)) = self.faults.lock().unwrap().get_mut(&team_id) {+ if *left > 0 {+ *left -= 1;+ return Err(to_error(spec));+ }+ }+ match entries(Some(&self.keys))+ .into_iter()+ .find(|(k, _)| k.parse::<i64>().ok() == Some(team_id))+ {+ Some((_, keys)) => Ok(arr(Some(keys)).iter().filter_map(|k| s(Some(k))).collect()),+ None => Ok(MESSAGE_KEYS.iter().map(|k| k.to_string()).collect()),+ }+ }+}++struct ScenarioTracing(JsValue);++#[async_trait]+impl TracingConfigSource for ScenarioTracing {+ async fn get_retention_days(&self, team_id: i64) -> anyhow::Result<f64> {+ Ok(entries(Some(&self.0))+ .into_iter()+ .find(|(k, _)| k.parse::<i64>().ok() == Some(team_id))+ .and_then(|(_, v)| n(Some(v)))+ .unwrap_or(30.0))+ }+}++fn faults_with_times(v: Option<&JsValue>) -> HashMap<i64, (u64, JsValue)> {+ entries(v)+ .into_iter()+ .filter_map(|(k, spec)| {+ Some((+ k.parse().ok()?,+ (n(get(spec, "times")).unwrap_or(0.0) as u64, spec.clone()),+ ))+ })+ .collect()+}++pub struct ScenarioConsumer {+ pub consumer: LogsIngestionConsumer,+ pub outputs: Arc<CapturingOutputs>,+ pub recorded: Arc<Recorded>,+}++/// `discard` counts produced messages instead of keeping them.+pub fn build_scenario_consumer(+ scenario: &JsValue,+ redis: Arc<dyn TokenBucketRedis>,+ clock: Clock,+ discard: bool,+) -> ScenarioConsumer {+ let recorded = Arc::new(Recorded::default());+ let outputs = Arc::new(CapturingOutputs {+ faults: arr(get(scenario, "produce_faults"))+ .iter()+ .map(|f| {+ (+ s(get(f, "output")).unwrap_or_default(),+ s(get(f, "team_id")),+ get(f, "error").cloned().unwrap_or(JsValue::Null),+ )+ })+ .collect(),+ remaining: Mutex::new(+ arr(get(scenario, "produce_faults"))+ .iter()+ .map(|f| n(get(f, "times")).unwrap_or(0.0) as u64)+ .collect(),+ ),+ captured: Mutex::new(Vec::new()),+ produced_count: AtomicU64::new(0),+ current_batch: AtomicU64::new(0),+ discard,+ });+ let teams: Vec<Team> = arr(get(scenario, "teams"))+ .iter()+ .map(|t| Team {+ id: n(get(t, "id")).unwrap_or(0.0) as i64,+ api_token: s(get(t, "api_token")).unwrap_or_default(),+ logs_settings: logs_settings(get(t, "logs_settings")),+ })+ .collect();+ let team_manager = ScenarioTeams {+ by_id: teams.iter().map(|t| (t.id, t.clone())).collect(),+ by_token: teams+ .iter()+ .map(|t| (t.api_token.clone(), t.clone()))+ .collect(),+ lookup_faults: entries(get(scenario, "team_lookup_faults"))+ .into_iter()+ .map(|(k, v)| (k, v.clone()))+ .collect(),+ by_id_faults: Mutex::new(faults_with_times(get(scenario, "team_by_id_faults"))),+ missing: arr(get(scenario, "team_by_id_missing"))+ .iter()+ .filter_map(|v| n(Some(v)).map(|n| n as i64))+ .collect(),+ recorded: recorded.clone(),+ };+ let field = |name: &str| get(scenario, name).cloned().unwrap_or(JsValue::Null);+ let omit: Vec<String> = arr(get(scenario, "omit_deps"))+ .iter()+ .filter_map(|v| s(Some(v)))+ .collect();+ let keep = |name: &str| !omit.iter().any(|o| o == name);+ let policies = match get(scenario, "internal_source_policies") {+ Some(JsValue::Object(o)) => Some(+ o.iter()+ .map(|(k, v)| {+ let flag = |f: &str| matches!(get(v, f), Some(JsValue::Bool(true)));+ (+ k.to_utf8_lossy().into_owned(),+ InternalSourcePolicy {+ billed: flag("billed"),+ team_rules: flag("teamRules"),+ },+ )+ })+ .collect(),+ ),+ _ => None,+ };+ let deps = LogsIngestionConsumerDeps {+ team_manager: Arc::new(team_manager),+ quota_limiting: Arc::new(ScenarioQuota {+ limited: arr(get(scenario, "quota_limited_tokens"))+ .iter()+ .filter_map(|v| s(Some(v)))+ .collect(),+ recorded: recorded.clone(),+ }),+ outputs: outputs.clone(),+ usage_batch: Arc::new(ScenarioUsage {+ outputs: outputs.clone(),+ recorded: recorded.clone(),+ discard,+ }),+ sampling_rules: keep("samplingRulesCache").then(|| {+ Arc::new(ScenarioSampling(+ field("sampling_rules"),+ Compiled::default(),+ )) as _+ }),+ metric_rules: Some(Arc::new(ScenarioMetricRules {+ rows: field("metric_rules"),+ faults: field("metric_rules_faults"),+ compiled: Compiled::default(),+ })),+ metrics_emitter: keep("metricsEmitter").then(|| {+ Arc::new(ScenarioEmitter {+ faults: arr(get(scenario, "metric_emit_faults"))+ .iter()+ .filter_map(|v| n(Some(v)).map(|n| n as i64))+ .collect(),+ recorded: recorded.clone(),+ }) as _+ }),+ logs_transformer: None,+ retention_rules: Some(Arc::new(ScenarioRetention(+ field("retention_rules"),+ Compiled::default(),+ ))),+ pattern_message_keys: keep("patternMessageKeysCache").then(|| {+ Arc::new(ScenarioPatternKeys {+ keys: field("pattern_message_keys"),+ faults: Mutex::new(faults_with_times(get(scenario, "pattern_keys_faults"))),+ }) as _+ }),+ tracing_config: keep("tracingConfigCache")+ .then(|| Arc::new(ScenarioTracing(field("traces_retention_days"))) as _),+ dependency_retry: DependencyRetry {+ retry_count: 2,+ initial_retry_delay_ms: 1,+ },+ internal_source_policies: policies,+ token_bucket_redis: redis,+ key_root: KeyRoot::Test,+ clock,+ };+ let config = match get(scenario, "config") {+ Some(JsValue::Object(o)) => o.clone(),+ _ => JsObject::new(),+ };+ let traces = s(get(scenario, "consumer")).as_deref() == Some("traces");+ let consumer = if traces {+ LogsIngestionConsumer::new(+ LogsConsumerIdentity::traces(),+ LogsIngestionConsumerConfig::from_traces_config(&config),+ deps,+ )+ } else {+ LogsIngestionConsumer::new(+ LogsConsumerIdentity::logs(),+ LogsIngestionConsumerConfig::from_logs_config(&config),+ deps,+ )+ };+ ScenarioConsumer {+ consumer,+ outputs,+ recorded,+ }+}diff --git a/rust/logs-ingestion/src/pipeline/types.rs b/rust/logs-ingestion/src/pipeline/types.rsnew file mode 100644index 000000000000..eab40fb88df4--- /dev/null+++ b/rust/logs-ingestion/src/pipeline/types.rs@@ -0,0 +1,232 @@+use std::collections::BTreeMap;+use std::sync::Arc;++use ingestion_framework::KafkaMessage;++use crate::internal_logs::InternalLogs;+use crate::property_filter::coerce::{is_js_whitespace, js_parse_int};+use crate::rate_limiter::RateLimitedMessage;++/// Must match `DEFAULT_LOGS_RETENTION_DAYS` in `posthog/models/team/logs_retention.py`.+pub const DEFAULT_LOGS_RETENTION_DAYS: f64 = 14.0;+pub const DEFAULT_TRACES_RETENTION_DAYS: f64 = 14.0;+/// A producer can stamp internal rows with less retention than the team default.+pub const INTERNAL_LOGS_MIN_RETENTION_DAYS: f64 = 1.0;++#[derive(Debug, Clone)]+pub struct LogsIngestionMessage {+ pub token: String,+ pub message: Arc<KafkaMessage>,+ pub team_id: i64,+ pub bytes_uncompressed: f64,+ pub bytes_uncompressed_records: f64,+ pub bytes_compressed: f64,+ pub record_count: f64,+ pub min_timestamp_micros: Option<f64>,+ pub backfill_requested: bool,+ pub internal_logs: Option<InternalLogs>,+}++impl RateLimitedMessage for LogsIngestionMessage {+ fn team_id(&self) -> i64 {+ self.team_id+ }+ fn bytes_uncompressed(&self) -> f64 {+ self.bytes_uncompressed+ }+ fn created_at_header(&self) -> Option<&[u8]> {+ self.message+ .headers+ .iter()+ .find(|(k, _)| k == "created_at")+ .and_then(|(_, v)| v.as_deref())+ }+}++#[derive(Debug, Clone, Copy, PartialEq)]+pub struct UsageStats {+ pub bytes_received: f64,+ pub records_received: f64,+ pub bytes_allowed: f64,+ pub records_allowed: f64,+ pub bytes_allowed_records: f64,+ pub bytes_dropped: f64,+ pub records_dropped: f64,+ pub pii_replacements: f64,+ pub retention_days: f64,+}++pub const DEFAULT_USAGE_STATS: UsageStats = UsageStats {+ bytes_received: 0.0,+ records_received: 0.0,+ bytes_allowed: 0.0,+ records_allowed: 0.0,+ bytes_allowed_records: 0.0,+ bytes_dropped: 0.0,+ records_dropped: 0.0,+ pii_replacements: 0.0,+ retention_days: DEFAULT_LOGS_RETENTION_DAYS,+};++/// A `Map`, so iteration follows insertion order.+#[derive(Debug, Clone, Default)]+pub struct UsageStatsByTeam(pub Vec<(i64, UsageStats)>);++impl UsageStatsByTeam {+ pub fn get_mut(&mut self, team_id: i64) -> Option<&mut UsageStats> {+ self.0+ .iter_mut()+ .find(|(t, _)| *t == team_id)+ .map(|(_, s)| s)+ }++ pub fn row(&mut self, team_id: i64) -> &mut UsageStats {+ if let Some(i) = self.0.iter().position(|(t, _)| *t == team_id) {+ return &mut self.0[i].1;+ }+ self.0.push((team_id, DEFAULT_USAGE_STATS));+ &mut self.0.last_mut().unwrap().1+ }+}++pub fn retention_bytes_metric_name(retention_days: f64) -> Option<String> {+ [14.0, 30.0, 90.0]+ .contains(&retention_days)+ .then(|| format!("bytes_ingested_retention_{}d", retention_days as i64))+}++pub fn describe_batch_position(messages: &[KafkaMessage]) -> BTreeMap<String, String> {+ let mut spans: BTreeMap<i32, (i64, i64)> = BTreeMap::new();+ for m in messages {+ let span = spans.entry(m.partition).or_insert((m.offset, m.offset));+ span.0 = span.0.min(m.offset);+ span.1 = span.1.max(m.offset);+ }+ spans+ .into_iter()+ .map(|(p, (min, max))| {+ let span = if min == max {+ min.to_string()+ } else {+ format!("{min}-{max}")+ };+ (p.to_string(), span)+ })+ .collect()+}++/// `parseSizeHeader`: `parseInt(raw ?? '0', 10)`, rejecting NaN and negatives.+pub fn parse_size_header(raw: Option<&str>) -> Option<f64> {+ let parsed = js_parse_int(raw.unwrap_or("0"), Some(10));+ (parsed.is_finite() && parsed >= 0.0).then_some(parsed)+}++/// `parseMinTimestampHeader`: `Number(raw)` when it is a safe integer.+pub fn parse_min_timestamp_header(raw: Option<&str>) -> Option<f64> {+ let raw = raw?;+ if raw.trim_matches(is_js_whitespace).is_empty() {+ return None;+ }+ let n = js_string_to_number(raw);+ (n.fract() == 0.0 && n.abs() <= 9_007_199_254_740_991.0).then_some(n)+}++pub fn js_string_to_number(raw: &str) -> f64 {+ let s = raw.trim_matches(is_js_whitespace);+ if s.is_empty() {+ return 0.0;+ }+ for (prefix, radix) in [+ ("0x", 16),+ ("0X", 16),+ ("0o", 8),+ ("0O", 8),+ ("0b", 2),+ ("0B", 2),+ ] {+ if let Some(digits) = s.strip_prefix(prefix) {+ if digits.is_empty() || !digits.chars().all(|c| c.is_digit(radix)) {+ return f64::NAN;+ }+ return digits.chars().fold(0.0, |acc, c| {+ acc * radix as f64 + c.to_digit(radix).unwrap() as f64+ });+ }+ }+ let unsigned = s.strip_prefix(['+', '-']).unwrap_or(s);+ if unsigned == "Infinity" {+ return if s.starts_with('-') {+ f64::NEG_INFINITY+ } else {+ f64::INFINITY+ };+ }+ let valid = {+ let b = unsigned.as_bytes();+ let mut i = 0;+ let int_start = i;+ while i < b.len() && b[i].is_ascii_digit() {+ i += 1;+ }+ let mut digits = i - int_start;+ if i < b.len() && b[i] == b'.' {+ i += 1;+ let frac_start = i;+ while i < b.len() && b[i].is_ascii_digit() {+ i += 1;+ }+ digits += i - frac_start;+ }+ if digits > 0 && i < b.len() && (b[i] == b'e' || b[i] == b'E') {+ i += 1;+ if i < b.len() && (b[i] == b'+' || b[i] == b'-') {+ i += 1;+ }+ let exp_start = i;+ while i < b.len() && b[i].is_ascii_digit() {+ i += 1;+ }+ if i == exp_start {+ return f64::NAN;+ }+ }+ digits > 0 && i == b.len()+ };+ if !valid {+ return f64::NAN;+ }+ s.parse::<f64>().unwrap_or(f64::NAN)+}++pub fn billing_byte_reduction_for_drops(+ header_bytes: f64,+ bytes_dropped: f64,+ bytes_total: f64,+) -> f64 {+ if header_bytes <= 0.0 || bytes_dropped <= 0.0 || bytes_total <= 0.0 {+ return 0.0;+ }+ let fraction = (bytes_dropped / bytes_total).min(1.0);+ crate::property_filter::coerce::js_math_round(header_bytes * fraction)+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn size_and_timestamp_headers_parse_like_node() {+ assert_eq!(parse_size_header(Some("12abc")), Some(12.0));+ assert_eq!(parse_size_header(Some("1e3")), Some(1.0));+ assert_eq!(parse_size_header(Some(" 7")), Some(7.0));+ assert_eq!(parse_size_header(Some("-5")), None);+ assert_eq!(parse_size_header(Some("abc")), None);+ assert_eq!(parse_size_header(None), Some(0.0));+ assert_eq!(parse_min_timestamp_header(Some("1.5")), None);+ assert_eq!(parse_min_timestamp_header(Some("garbage")), None);+ assert_eq!(parse_min_timestamp_header(Some(" 12 ")), Some(12.0));+ assert_eq!(parse_min_timestamp_header(Some("0x10")), Some(16.0));+ assert_eq!(parse_min_timestamp_header(Some("1e3")), Some(1000.0));+ assert_eq!(parse_min_timestamp_header(Some("")), None);+ }+}diff --git a/rust/logs-ingestion/src/property_filter/coerce.rs b/rust/logs-ingestion/src/property_filter/coerce.rsnew file mode 100644index 000000000000..aae0e46fa16a--- /dev/null+++ b/rust/logs-ingestion/src/property_filter/coerce.rs@@ -0,0 +1,400 @@+//! Rule JSON can hold any value, so each coercion follows the ECMAScript algorithm for every JSON shape, including the ones that throw.++use std::cmp::Ordering;++use crate::js::{number_to_string, CharOrSurrogate, JsString, JsValue};++/// The callers catch this and fail open, as the TypeScript does.+#[derive(Debug, Clone, PartialEq, Eq)]+pub struct JsTypeError(pub &'static str);++impl std::fmt::Display for JsTypeError {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ write!(f, "TypeError: {}", self.0)+ }+}++impl std::error::Error for JsTypeError {}++/// JSON cannot make an own `toString` callable, so `OrdinaryToPrimitive` reaches `valueOf` and throws.+pub fn js_to_string(value: &JsValue) -> Result<JsString, JsTypeError> {+ match value {+ JsValue::Null => Ok(JsString::from("null")),+ JsValue::Bool(b) => Ok(JsString::from(if *b { "true" } else { "false" })),+ JsValue::Number(n) => Ok(JsString::from(number_to_string(*n))),+ JsValue::String(s) => Ok(s.clone()),+ JsValue::Array(items) => {+ // `Array.prototype.join(',')`: null and undefined elements become ''.+ let mut out = JsString::new();+ for (i, item) in items.iter().enumerate() {+ if i > 0 {+ out.push_str(",");+ }+ if !matches!(item, JsValue::Null) {+ out.push_js(&js_to_string(item)?);+ }+ }+ Ok(out)+ }+ JsValue::Object(o) => {+ if o.contains_key("toString") {+ Err(JsTypeError("Cannot convert object to primitive value"))+ } else {+ Ok(JsString::from("[object Object]"))+ }+ }+ }+}++pub fn js_to_string_opt(value: Option<&JsValue>) -> Result<JsString, JsTypeError> {+ match value {+ None => Ok(JsString::from("undefined")),+ Some(v) => js_to_string(v),+ }+}++pub fn is_js_whitespace(c: char) -> bool {+ matches!(+ c,+ '\u{0009}'+ | '\u{000A}'+ | '\u{000B}'+ | '\u{000C}'+ | '\u{000D}'+ | '\u{0020}'+ | '\u{00A0}'+ | '\u{1680}'+ | '\u{2000}'+ ..='\u{200A}'+ | '\u{2028}'+ | '\u{2029}'+ | '\u{202F}'+ | '\u{205F}'+ | '\u{3000}'+ | '\u{FEFF}'+ )+}++pub fn js_trim(s: &str) -> &str {+ s.trim_matches(is_js_whitespace)+}++fn trim_start_js(s: &JsString) -> String {+ // The numeric parsers only read ASCII after the whitespace, so a lone surrogate ends the number.+ let text = s.to_utf8_lossy();+ text.trim_start_matches(is_js_whitespace).to_string()+}++pub fn js_parse_float(s: &JsString) -> f64 {+ parse_float_str(&trim_start_js(s))+}++fn parse_float_str(t: &str) -> f64 {+ let b = t.as_bytes();+ let mut i = 0;+ let mut negative = false;+ if i < b.len() && (b[i] == b'+' || b[i] == b'-') {+ negative = b[i] == b'-';+ i += 1;+ }+ if t[i..].starts_with("Infinity") {+ return if negative {+ f64::NEG_INFINITY+ } else {+ f64::INFINITY+ };+ }+ let digits_start = i;+ let int_start = i;+ while i < b.len() && b[i].is_ascii_digit() {+ i += 1;+ }+ let int_digits = i - int_start;+ let mut frac_digits = 0;+ if i < b.len() && b[i] == b'.' {+ let mut j = i + 1;+ while j < b.len() && b[j].is_ascii_digit() {+ j += 1;+ }+ frac_digits = j - i - 1;+ if int_digits > 0 || frac_digits > 0 {+ i = j;+ }+ }+ if int_digits == 0 && frac_digits == 0 {+ return f64::NAN;+ }+ if i < b.len() && (b[i] == b'e' || b[i] == b'E') {+ let mut j = i + 1;+ if j < b.len() && (b[j] == b'+' || b[j] == b'-') {+ j += 1;+ }+ let exp_start = j;+ while j < b.len() && b[j].is_ascii_digit() {+ j += 1;+ }+ if j > exp_start {+ i = j;+ }+ }+ let mut literal = String::with_capacity(i - digits_start + 2);+ if negative {+ literal.push('-');+ }+ let body = &t[digits_start..i];+ // A leading zero keeps ".5" valid for every Rust version of the float parser.+ if body.starts_with('.') {+ literal.push('0');+ }+ literal.push_str(body);+ literal.parse::<f64>().unwrap_or(f64::NAN)+}++pub fn js_parse_int(s: &str, radix: Option<u32>) -> f64 {+ let t = if s.as_bytes().first().is_some_and(u8::is_ascii_alphanumeric) {+ s+ } else {+ s.trim_start_matches(is_js_whitespace)+ };+ let b = t.as_bytes();+ let mut i = 0;+ let mut negative = false;+ if i < b.len() && (b[i] == b'+' || b[i] == b'-') {+ negative = b[i] == b'-';+ i += 1;+ }+ let mut radix = radix.unwrap_or(0);+ let has_hex_prefix = b.len() >= i + 2 && b[i] == b'0' && (b[i + 1] == b'x' || b[i + 1] == b'X');+ if (radix == 0 || radix == 16) && has_hex_prefix {+ i += 2;+ radix = 16;+ }+ if radix == 0 {+ radix = 10;+ }+ let start = i;+ while i < b.len() && (b[i] as char).is_digit(radix) {+ i += 1;+ }+ if i == start {+ return f64::NAN;+ }+ let digits = &t[start..i];+ let magnitude = if radix == 10 && digits.len() <= 15 {+ // Under 10^15, so the integer is exact as a double.+ digits+ .bytes()+ .fold(0u64, |acc, d| acc * 10 + u64::from(d - b'0')) as f64+ } else if radix == 10 {+ // V8 converts decimal digits with correct rounding, as Rust's parser does.+ digits.parse::<f64>().unwrap_or(f64::NAN)+ } else {+ digits.chars().fold(0f64, |acc, c| {+ acc * radix as f64 + c.to_digit(radix).unwrap_or(0) as f64+ })+ };+ if negative {+ -magnitude+ } else {+ magnitude+ }+}++/// A lone surrogate breaks the final-sigma context, so each valid run lowercases on its own.+pub fn js_to_lower(s: &JsString) -> JsString {+ if let Some(text) = s.as_str() {+ return JsString::from(text.to_lowercase());+ }+ let mut out = JsString::new();+ let mut run = String::new();+ for unit in s.chars_or_surrogates() {+ match unit {+ CharOrSurrogate::Char(c) => run.push(c),+ CharOrSurrogate::Surrogate(u) => {+ out.push_str(&run.to_lowercase());+ run.clear();+ out.push_code_unit(u);+ }+ }+ }+ out.push_str(&run.to_lowercase());+ out+}++pub fn utf16_units(s: &JsString) -> Vec<u16> {+ let mut out = Vec::new();+ for unit in s.chars_or_surrogates() {+ match unit {+ CharOrSurrogate::Char(c) => {+ let mut buf = [0u16; 2];+ out.extend_from_slice(c.encode_utf16(&mut buf));+ }+ CharOrSurrogate::Surrogate(u) => out.push(u),+ }+ }+ out+}++/// UTF-16 code unit order, which differs from UTF-8 byte order above U+FFFF.+pub fn js_compare(a: &JsString, b: &JsString) -> Ordering {+ match (a.as_str(), b.as_str()) {+ (Some(x), Some(y)) => x.encode_utf16().cmp(y.encode_utf16()),+ _ => utf16_units(a).cmp(&utf16_units(b)),+ }+}++/// A needle with a lone surrogate can match half of a pair, so it needs the UTF-16 search.+pub fn js_includes(haystack: &JsString, needle: &JsString) -> bool {+ match (haystack.as_str(), needle.as_str()) {+ (Some(h), Some(n)) => h.contains(n),+ _ => {+ let h = utf16_units(haystack);+ let n = utf16_units(needle);+ n.is_empty() || h.windows(n.len()).any(|w| w == n.as_slice())+ }+ }+}++pub fn js_starts_with(haystack: &JsString, needle: &JsString) -> bool {+ match (haystack.as_str(), needle.as_str()) {+ (Some(h), Some(n)) => h.starts_with(n),+ _ => utf16_units(haystack).starts_with(&utf16_units(needle)),+ }+}++pub fn js_ends_with(haystack: &JsString, needle: &JsString) -> bool {+ match (haystack.as_str(), needle.as_str()) {+ (Some(h), Some(n)) => h.ends_with(n),+ _ => utf16_units(haystack).ends_with(&utf16_units(needle)),+ }+}++/// `Math.round`: halves round toward +Infinity.+pub fn js_math_round(x: f64) -> f64 {+ if !x.is_finite() {+ return x;+ }+ let floor = x.floor();+ let rounded = if x - floor >= 0.5 { floor + 1.0 } else { floor };+ // Math.round(-0.4) is -0; String(-0) is "0", so the sign only matters to division.+ if rounded == 0.0 && x < 0.0 {+ -0.0+ } else {+ rounded+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::js::json_parse;++ fn s(v: &str) -> JsString {+ JsString::from(v)+ }++ #[test]+ fn string_coercion_matches_javascript() {+ let cases = [+ ("null", Some("null")),+ ("true", Some("true")),+ ("1e21", Some("1e+21")),+ ("-0", Some("0")),+ (r#"[1,null,[2,[3]],"a",true]"#, Some("1,,2,3,a,true")),+ (r#"{"a":1}"#, Some("[object Object]")),+ (r#"{"valueOf":1}"#, Some("[object Object]")),+ (r#"{"toString":1}"#, None),+ (r#"[{"toString":"x"}]"#, None),+ ];+ for (json, expected) in cases {+ let value = json_parse(json).unwrap();+ assert_eq!(+ js_to_string(&value).ok().map(|s| s.to_string()),+ expected.map(str::to_string),+ "{json}"+ );+ }+ }++ #[test]+ fn parse_float_matches_javascript() {+ let cases: [(&str, f64); 16] = [+ (" 12.5abc", 12.5),+ ("\u{3000}\u{FEFF}-.5", -0.5),+ ("1.e3", 1000.0),+ ("1e", 1.0),+ ("1e+", 1.0),+ ("1e-2x", 0.01),+ (".e5", f64::NAN),+ ("-Infinityx", f64::NEG_INFINITY),+ ("+Infinity", f64::INFINITY),+ ("infinity", f64::NAN),+ ("0x10", 0.0),+ ("\"42\"", f64::NAN),+ ("", f64::NAN),+ ("1_000", 1.0),+ ("9007199254740993", 9007199254740992.0),+ ("1e400", f64::INFINITY),+ ];+ for (input, expected) in cases {+ let got = js_parse_float(&s(input));+ assert!(+ got == expected || (got.is_nan() && expected.is_nan()),+ "parseFloat({input:?}) = {got}"+ );+ }+ assert!(js_parse_float(&s("-0")).is_sign_negative());+ }++ #[test]+ fn parse_int_matches_javascript() {+ let cases: [(&str, Option<u32>, f64); 9] = [+ (" 42px", Some(10), 42.0),+ ("-17", Some(10), -17.0),+ ("0x1A", None, 26.0),+ ("0x1A", Some(10), 0.0),+ ("1.9", Some(10), 1.0),+ ("abc", Some(10), f64::NAN),+ ("\u{00A0}7", None, 7.0),+ ("+0x", None, f64::NAN),+ ("08", None, 8.0),+ ];+ for (input, radix, expected) in cases {+ let got = js_parse_int(input, radix);+ assert!(+ got == expected || (got.is_nan() && expected.is_nan()),+ "parseInt({input:?}, {radix:?}) = {got}"+ );+ }+ }++ #[test]+ fn string_order_is_utf16() {+ // U+FF61 is above the surrogate range in UTF-16 but below U+1F600 in UTF-8.+ assert_eq!(js_compare(&s("\u{1F600}"), &s("\u{FF61}")), Ordering::Less);+ assert_eq!(+ s("\u{1F600}").as_str().unwrap().cmp("\u{FF61}"),+ Ordering::Greater+ );+ }++ #[test]+ fn a_lone_surrogate_needle_can_match_half_a_pair() {+ let rocket = s("a\u{1F680}");+ let lone = match json_parse(r#""\ude80""#).unwrap() {+ JsValue::String(s) => s,+ _ => unreachable!(),+ };+ assert!(js_includes(&rocket, &lone));+ assert!(js_ends_with(&rocket, &lone));+ assert!(!js_starts_with(&rocket, &lone));+ }++ #[test]+ fn math_round_rounds_halves_up() {+ assert_eq!(js_math_round(2.5), 3.0);+ assert_eq!(js_math_round(-2.5), -2.0);+ assert_eq!(js_math_round(0.49999999999999994), 0.0);+ assert!(js_math_round(-0.4).is_sign_negative());+ }+}diff --git a/rust/logs-ingestion/src/property_filter/mod.rs b/rust/logs-ingestion/src/property_filter/mod.rsnew file mode 100644index 000000000000..a72c43e8c2fc--- /dev/null+++ b/rust/logs-ingestion/src/property_filter/mod.rs@@ -0,0 +1,351 @@+//! Operators coerce with `String()` and `parseFloat` in the TypeScript order, because `String()` can throw and the caller then fails open.++pub mod coerce;+pub mod re2;++use std::sync::Arc;++use crate::js::{JsString, JsValue};++use self::coerce::{+ js_compare, js_ends_with, js_includes, js_parse_float, js_starts_with, js_to_lower,+ js_to_string, JsTypeError,+};+use self::re2::Re2;++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+enum Operator {+ Exact,+ IsNot,+ IsSet,+ IsNotSet,+ Icontains,+ NotIcontains,+ StartsWith,+ NotStartsWith,+ EndsWith,+ NotEndsWith,+ Regex,+ NotRegex,+ Gt,+ Gte,+ Lt,+ Lte,+ In,+ NotIn,+ /// Includes a non-string operator. It never matches.+ Unknown,+}++impl Operator {+ fn from_json(value: Option<&JsValue>) -> Operator {+ let name = match value {+ None | Some(JsValue::Null) => return Operator::Exact,+ Some(JsValue::String(s)) => s.as_str().unwrap_or(""),+ Some(_) => return Operator::Unknown,+ };+ match name {+ "exact" => Operator::Exact,+ "is_not" => Operator::IsNot,+ "is_set" => Operator::IsSet,+ "is_not_set" => Operator::IsNotSet,+ "icontains" => Operator::Icontains,+ "not_icontains" => Operator::NotIcontains,+ "starts_with" => Operator::StartsWith,+ "not_starts_with" => Operator::NotStartsWith,+ "ends_with" => Operator::EndsWith,+ "not_ends_with" => Operator::NotEndsWith,+ "regex" => Operator::Regex,+ "not_regex" => Operator::NotRegex,+ "gt" => Operator::Gt,+ "gte" => Operator::Gte,+ "lt" => Operator::Lt,+ "lte" => Operator::Lte,+ "in" => Operator::In,+ "not_in" => Operator::NotIn,+ _ => Operator::Unknown,+ }+ }+}++/// A leaf filter. Each field is `None` when the JavaScript property is `undefined`.+#[derive(Debug, Clone)]+pub struct PropertyFilterLeaf {+ pub key: Option<JsValue>,+ pub operator: Option<JsValue>,+ pub value: Option<JsValue>,+ pub filter_type: Option<JsValue>,+ op: Operator,+ /// `Some(None)` when the pattern failed to compile, so the leaf never matches.+ compiled_regex: Option<Option<Arc<Re2>>>,+}++impl PropertyFilterLeaf {+ pub fn from_json(node: &JsValue) -> PropertyFilterLeaf {+ let field = |name: &str| match node {+ JsValue::Object(o) => o.get(name).cloned(),+ _ => None,+ };+ let operator = field("operator");+ let value = field("value");+ let op = Operator::from_json(operator.as_ref());+ // `parseFilterGroup` compiles every leaf whose operator is literally 'regex' or 'not_regex', which equals compiling at match time.+ let compiled_regex = match operator.as_ref() {+ Some(JsValue::String(s)) if s == "regex" || s == "not_regex" => Some(match &value {+ None | Some(JsValue::Null) => None,+ Some(v) => compile_leaf_regex(v),+ }),+ _ => None,+ };+ PropertyFilterLeaf {+ key: field("key"),+ operator,+ value,+ filter_type: field("type"),+ op,+ compiled_regex,+ }+ }++ pub fn type_is(&self, name: &str) -> bool {+ matches!(&self.filter_type, Some(JsValue::String(s)) if s == name)+ }++ pub fn key_is(&self, name: &str) -> bool {+ matches!(&self.key, Some(JsValue::String(s)) if s == name)+ }++ pub fn value_count(&self) -> usize {+ match &self.value {+ None | Some(JsValue::Null) => 0,+ Some(JsValue::Array(items)) => items.len(),+ Some(_) => 1,+ }+ }+}++pub fn compile_leaf_regex(pattern: &JsValue) -> Option<Arc<Re2>> {+ let text = js_to_string(pattern).ok()?;+ Re2::new(text.bytes_wtf8(), "is").ok().map(Arc::new)+}++/// `override_value` is `String()` of the record value, or `None` for `undefined` and `null`.+pub fn match_property_filter(+ filter: &PropertyFilterLeaf,+ override_value: Option<&JsString>,+) -> Result<bool, JsTypeError> {+ let op = filter.op;+ if op == Operator::IsSet {+ return Ok(override_value.is_some_and(|v| !v.is_empty()));+ }+ if op == Operator::IsNotSet {+ return Ok(override_value.is_none_or(|v| v.is_empty()));+ }+ let Some(override_value) = override_value else {+ return Ok(false);+ };+ let value = match &filter.value {+ None | Some(JsValue::Null) => return Ok(false),+ Some(v) => v,+ };+ match op {+ Operator::Exact | Operator::In => match_exact(value, override_value),+ Operator::IsNot | Operator::NotIn => Ok(!match_exact(value, override_value)?),+ Operator::Icontains | Operator::NotIcontains => {+ let haystack = js_to_lower(override_value);+ let needle = js_to_lower(&js_to_string(value)?);+ let found = js_includes(&haystack, &needle);+ Ok(if op == Operator::Icontains {+ found+ } else {+ !found+ })+ }+ Operator::StartsWith | Operator::NotStartsWith => {+ let found = js_starts_with(+ &js_to_lower(override_value),+ &js_to_lower(&js_to_string(value)?),+ );+ Ok(if op == Operator::StartsWith {+ found+ } else {+ !found+ })+ }+ Operator::EndsWith | Operator::NotEndsWith => {+ let found = js_ends_with(+ &js_to_lower(override_value),+ &js_to_lower(&js_to_string(value)?),+ );+ Ok(if op == Operator::EndsWith {+ found+ } else {+ !found+ })+ }+ Operator::Regex | Operator::NotRegex => {+ let regex = match &filter.compiled_regex {+ Some(compiled) => compiled.clone(),+ None => compile_leaf_regex(value),+ };+ let Some(regex) = regex else {+ return Ok(false);+ };+ let found = regex.test(&override_value.to_utf8_lossy());+ Ok(if op == Operator::Regex { found } else { !found })+ }+ Operator::Gt | Operator::Gte | Operator::Lt | Operator::Lte => {+ compare_numeric(value, override_value, op)+ }+ Operator::IsSet | Operator::IsNotSet | Operator::Unknown => Ok(false),+ }+}++fn match_exact(value: &JsValue, override_value: &JsString) -> Result<bool, JsTypeError> {+ if is_truthy_or_falsy_value(value) {+ let expected = if is_true_value(value) {+ "true"+ } else {+ "false"+ };+ return Ok(js_to_lower(override_value) == expected);+ }+ if let JsValue::Array(items) = value {+ let wanted = js_to_lower(override_value);+ for item in items {+ if js_to_lower(&js_to_string(item)?) == wanted {+ return Ok(true);+ }+ }+ return Ok(false);+ }+ let value_text = js_to_lower(&js_to_string(value)?);+ Ok(value_text == js_to_lower(override_value))+}++fn is_boolean_word(v: &JsValue) -> bool {+ match v {+ JsValue::Bool(_) => true,+ JsValue::String(s) => matches!(s.as_str(), Some("true" | "True" | "false" | "False")),+ _ => false,+ }+}++fn is_truthy_or_falsy_value(v: &JsValue) -> bool {+ match v {+ JsValue::Array(items) if items.len() == 1 => is_boolean_word(&items[0]),+ other => is_boolean_word(other),+ }+}++fn is_true_value(v: &JsValue) -> bool {+ match v {+ JsValue::Bool(b) => *b,+ JsValue::String(s) => matches!(s.as_str(), Some("true" | "True")),+ JsValue::Array(items) if items.len() == 1 => is_true_value(&items[0]),+ _ => false,+ }+}++fn compare_numeric(+ value: &JsValue,+ override_value: &JsString,+ op: Operator,+) -> Result<bool, JsTypeError> {+ let parsed_value = match value {+ JsValue::Number(n) => *n,+ other => js_parse_float(&js_to_string(other)?),+ };+ if parsed_value.is_finite() {+ let override_num = js_parse_float(override_value);+ if override_num.is_finite() {+ return Ok(match op {+ Operator::Gt => override_num > parsed_value,+ Operator::Gte => override_num >= parsed_value,+ Operator::Lt => override_num < parsed_value,+ _ => override_num <= parsed_value,+ });+ }+ }+ let ord = js_compare(override_value, &js_to_string(value)?);+ Ok(match op {+ Operator::Gt => ord.is_gt(),+ Operator::Gte => ord.is_ge(),+ Operator::Lt => ord.is_lt(),+ _ => ord.is_le(),+ })+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::js::json_parse;++ fn leaf(json: &str) -> PropertyFilterLeaf {+ PropertyFilterLeaf::from_json(&json_parse(json).unwrap())+ }++ fn m(json: &str, value: Option<&str>) -> Result<bool, JsTypeError> {+ let v = value.map(JsString::from);+ match_property_filter(&leaf(json), v.as_ref())+ }++ #[test]+ fn operators_follow_javascript_coercion() {+ let cases: &[(&str, Option<&str>, bool)] = &[+ (r#"{"operator":"is_set"}"#, Some(""), false),+ (r#"{"operator":"is_not_set"}"#, Some(""), true),+ (r#"{"value":"x"}"#, None, false),+ (r#"{"operator":"exact"}"#, Some("x"), false),+ (r#"{"value":"TRUE"}"#, Some("true"), true),+ (r#"{"value":"True"}"#, Some("TRUE"), true),+ (r#"{"value":[false]}"#, Some("False"), true),+ (r#"{"value":[null,"A"]}"#, Some("a"), true),+ (r#"{"value":[null]}"#, Some("null"), true),+ (r#"{"value":1e21}"#, Some("1E+21"), true),+ (+ r#"{"operator":"is_not","value":["a","b"]}"#,+ Some("c"),+ true,+ ),+ (+ r#"{"operator":"icontains","value":"ΣΑ"}"#,+ Some("xσα"),+ true,+ ),+ (r#"{"operator":"gt","value":"10"}"#, Some("9"), false),+ (r#"{"operator":"gt","value":"abc"}"#, Some("abd"), true),+ (r#"{"operator":"gt","value":"10"}"#, Some("9x"), false),+ (r#"{"operator":"gt","value":"10"}"#, Some("x"), true),+ (r#"{"operator":"lte","value":["5"]}"#, Some("5.0"), true),+ (r#"{"operator":"gte","value":true}"#, Some("true"), true),+ (r#"{"operator":"regex","value":"^A"}"#, Some("abc"), true),+ (+ r#"{"operator":"not_regex","value":"(?=a)"}"#,+ Some("abc"),+ false,+ ),+ (+ r#"{"operator":"regex","value":"(?=a)"}"#,+ Some("abc"),+ false,+ ),+ (r#"{"operator":5,"value":"x"}"#, Some("x"), false),+ (r#"{"operator":null,"value":"x"}"#, Some("X"), true),+ ];+ for (json, value, expected) in cases {+ assert_eq!(m(json, *value), Ok(*expected), "{json} on {value:?}");+ }+ }++ #[test]+ fn an_object_with_own_to_string_throws_where_javascript_throws() {+ assert!(m(r#"{"value":{"toString":1}}"#, Some("x")).is_err());+ assert!(m(r#"{"value":["x",{"toString":1}]}"#, Some("x")) == Ok(true));+ assert!(m(r#"{"value":[{"toString":1},"x"]}"#, Some("x")).is_err());+ assert_eq!(+ m(r#"{"operator":"regex","value":{"toString":1}}"#, Some("x")),+ Ok(false)+ );+ }+}diff --git a/rust/logs-ingestion/src/property_filter/re2.rs b/rust/logs-ingestion/src/property_filter/re2.rsnew file mode 100644index 000000000000..22010d827734--- /dev/null+++ b/rust/logs-ingestion/src/property_filter/re2.rs@@ -0,0 +1,1369 @@+//! Ports node-re2's pattern rewrite and RE2's parser onto the `regex` crate, so a pattern that RE2 rejects fails to compile here too.+//! Not reproduced: RE2's program size limit and its Unicode table version, so a very large pattern can compile in one engine only.++use std::collections::HashSet;+use std::sync::OnceLock;++use regex::bytes::{Regex, RegexBuilder};++#[derive(Debug, Clone)]+pub struct Re2 {+ regex: Regex,+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub struct Re2Error(pub String);++impl std::fmt::Display for Re2Error {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ f.write_str(&self.0)+ }+}++impl std::error::Error for Re2Error {}++impl Re2 {+ /// `pattern` is V8's WTF-8, where a lone surrogate takes its 3-byte form. Only the `i`, `m` and `s` flags change `test`.+ pub fn new(pattern: &[u8], flags: &str) -> Result<Re2, Re2Error> {+ let ignore_case = flags.contains('i');+ let multiline = flags.contains('m');+ let dot_all = flags.contains('s');+ let translated = node_translate(pattern, multiline);+ let body = Parser::new(&translated).parse()?;+ let mut rust = String::with_capacity(body.len() + 8);+ if ignore_case || dot_all {+ rust.push_str("(?");+ if ignore_case {+ rust.push('i');+ }+ if dot_all {+ rust.push('s');+ }+ rust.push(')');+ }+ rust.push_str(&body);+ let regex = RegexBuilder::new(&rust)+ .nest_limit(MAX_NESTING as u32)+ .build()+ .map_err(|e| Re2Error(e.to_string()))?;+ Ok(Re2 { regex })+ }++ pub fn without_flags(pattern: &str) -> Result<Re2, Re2Error> {+ Re2::new(pattern.as_bytes(), "")+ }++ /// node-re2 writes the input with U+FFFD for a lone surrogate, so callers pass the lossy UTF-8 form.+ pub fn test(&self, input: &str) -> bool {+ self.regex.is_match(input.as_bytes())+ }+}++fn is_node_hexadecimal(ch: u8) -> bool {+ // node-re2's own check accepts every ASCII letter, not only a-f.+ ch.is_ascii_digit() || ch.is_ascii_alphabetic()+}++fn utf8_char_size(ch: u8) -> usize {+ // The same lookup as node-re2's `getUtf8CharSize`.+ (((0xE500_0000u32 >> ((ch >> 3) & 0x1E)) & 3) + 1) as usize+}++fn unicode_class_alias(name: &[u8]) -> Option<&'static str> {+ Some(match name {+ b"Uppercase_Letter" => "Lu",+ b"Lowercase_Letter" => "Ll",+ b"Titlecase_Letter" => "Lt",+ b"Cased_Letter" => "LC",+ b"Modifier_Letter" => "Lm",+ b"Other_Letter" => "Lo",+ b"Letter" => "L",+ b"Nonspacing_Mark" => "Mn",+ b"Spacing_Mark" => "Mc",+ b"Enclosing_Mark" => "Me",+ b"Mark" => "M",+ b"Decimal_Number" => "Nd",+ b"Letter_Number" => "Nl",+ b"Other_Number" => "No",+ b"Number" => "N",+ b"Connector_Punctuation" => "Pc",+ b"Dash_Punctuation" => "Pd",+ b"Open_Punctuation" => "Ps",+ b"Close_Punctuation" => "Pe",+ b"Initial_Punctuation" => "Pi",+ b"Final_Punctuation" => "Pf",+ b"Other_Punctuation" => "Po",+ b"Punctuation" => "P",+ b"Math_Symbol" => "Sm",+ b"Currency_Symbol" => "Sc",+ b"Modifier_Symbol" => "Sk",+ b"Other_Symbol" => "So",+ b"Symbol" => "S",+ b"Space_Separator" => "Zs",+ b"Line_Separator" => "Zl",+ b"Paragraph_Separator" => "Zp",+ b"Separator" => "Z",+ b"Control" => "Cc",+ b"Format" => "Cf",+ b"Surrogate" => "Cs",+ b"Private_Use" => "Co",+ b"Unassigned" => "Cn",+ b"Other" => "C",+ _ => return None,+ })+}++/// It runs on the raw text, so it also rewrites inside character classes (`[(?<a]` gains a `P`).+fn node_translate(data: &[u8], multiline: bool) -> Vec<u8> {+ let size = data.len();+ let mut out: Vec<u8> = Vec::with_capacity(size + 8);+ if size == 0 {+ out.extend_from_slice(b"(?:)");+ } else if multiline {+ out.extend_from_slice(b"(?m)");+ }+ let hex = b"0123456789ABCDEF";+ let mut i = 0;+ while i < size {+ let ch = data[i];+ if ch == b'\\' && i + 1 < size {+ let next = data[i + 1];+ match next {+ b'\\' => {+ out.extend_from_slice(b"\\\\");+ i += 2;+ continue;+ }+ b'c' => {+ if i + 2 < size && data[i + 2].is_ascii_uppercase() {+ let code = data[i + 2] - b'@';+ out.extend_from_slice(b"\\x");+ out.push(hex[((code / 16) & 15) as usize]);+ out.push(hex[(code & 15) as usize]);+ i += 3;+ continue;+ }+ out.extend_from_slice(b"\\c");+ i += 2;+ continue;+ }+ b'u' => {+ if i + 2 < size {+ let first = data[i + 2];+ if is_node_hexadecimal(first) {+ out.extend_from_slice(b"\\x{");+ out.push(first);+ i += 3;+ let mut j = 0;+ while j < 3 && i < size {+ if !is_node_hexadecimal(data[i]) {+ break;+ }+ out.push(data[i]);+ i += 1;+ j += 1;+ }+ out.push(b'}');+ continue;+ } else if first == b'{' {+ out.extend_from_slice(b"\\x");+ i += 2;+ continue;+ }+ }+ out.extend_from_slice(b"\\u");+ i += 2;+ continue;+ }+ b'p' | b'P' => {+ if i + 2 < size && data[i + 2] == b'{' {+ let mut j = i + 3;+ while j < size && data[j] != b'}' {+ j += 1;+ }+ if j < size {+ out.push(b'\\');+ out.push(next);+ let raw = &data[i + 3..j];+ let name: &[u8] = if let Some(alias) = unicode_class_alias(raw) {+ alias.as_bytes()+ } else if raw.len() > 7 && raw.starts_with(b"Script=") {+ &raw[7..]+ } else if raw.len() > 3 && raw.starts_with(b"sc=") {+ &raw[3..]+ } else {+ raw+ };+ if name.len() == 1 {+ out.extend_from_slice(name);+ } else {+ out.push(b'{');+ out.extend_from_slice(name);+ out.push(b'}');+ }+ i = j + 1;+ continue;+ }+ }+ out.push(b'\\');+ out.push(next);+ i += 2;+ continue;+ }+ _ => {+ out.push(b'\\');+ let n = utf8_char_size(next);+ let end = (i + 1 + n).min(size);+ out.extend_from_slice(&data[i + 1..end]);+ i += n + 1;+ continue;+ }+ }+ } else if ch == b'/' {+ out.extend_from_slice(b"\\/");+ i += 1;+ continue;+ } else if ch == b'('+ && i + 2 < size+ && data[i + 1] == b'?'+ && data[i + 2] == b'<'+ && (i + 3 >= size || (data[i + 3] != b'=' && data[i + 3] != b'!'))+ {+ out.extend_from_slice(b"(?P<");+ i += 3;+ continue;+ }+ let n = utf8_char_size(ch);+ let end = (i + n).min(size);+ out.extend_from_slice(&data[i..end]);+ i += n;+ }+ out+}++const RUNE_MAX: u32 = 0x10FFFF;+const MAX_REPEAT: u32 = 1000;+/// A class that matches nothing: what a surrogate code point matches in valid UTF-8.+const NEVER: &str = r"[^\x{0}-\x{10FFFF}]";+const ANY: &str = r"[\x{0}-\x{10FFFF}]";++/// Decodes one rune the way RE2's `chartorune` does. Surrogates decode as themselves.+fn decode_rune(b: &[u8], pos: usize) -> Option<(u32, usize)> {+ let first = *b.get(pos)?;+ let cont = |k: usize| -> Option<u32> {+ let c = *b.get(pos + k)?;+ (c & 0xC0 == 0x80).then_some((c & 0x3F) as u32)+ };+ if first < 0x80 {+ Some((first as u32, 1))+ } else if first & 0xE0 == 0xC0 {+ Some(((((first & 0x1F) as u32) << 6) | cont(1)?, 2))+ } else if first & 0xF0 == 0xE0 {+ Some((+ (((first & 0x0F) as u32) << 12) | (cont(1)? << 6) | cont(2)?,+ 3,+ ))+ } else if first & 0xF8 == 0xF0 {+ let r = (((first & 0x07) as u32) << 18) | (cont(1)? << 12) | (cont(2)? << 6) | cont(3)?;+ (r <= RUNE_MAX).then_some((r, 4))+ } else {+ None+ }+}++fn is_surrogate(r: u32) -> bool {+ (0xD800..=0xDFFF).contains(&r)+}++fn literal(r: u32) -> String {+ if is_surrogate(r) {+ return NEVER.to_string();+ }+ match char::from_u32(r) {+ Some(c) if c.is_ascii_alphanumeric() || (!c.is_ascii() && !c.is_whitespace()) => {+ c.to_string()+ }+ _ => format!("\\x{{{r:X}}}"),+ }+}++enum ClassItem {+ Range(u32, u32),+ Nested(String),+}++fn push_range(out: &mut String, lo: u32, hi: u32) {+ let mut emit = |a: u32, b: u32| {+ if a == b {+ out.push_str(&format!("\\x{{{a:X}}}"));+ } else {+ out.push_str(&format!("\\x{{{a:X}}}-\\x{{{b:X}}}"));+ }+ };+ if lo <= 0xD7FF {+ emit(lo, hi.min(0xD7FF));+ }+ if hi >= 0xE000 {+ emit(lo.max(0xE000), hi);+ }+}++fn class_text(negated: bool, items: &[ClassItem]) -> String {+ let mut body = String::new();+ for item in items {+ match item {+ ClassItem::Range(lo, hi) => push_range(&mut body, *lo, *hi),+ ClassItem::Nested(text) => body.push_str(text),+ }+ }+ if body.is_empty() {+ return if negated { ANY } else { NEVER }.to_string();+ }+ format!("[{}{}]", if negated { "^" } else { "" }, body)+}++/// RE2's `\s` has no `\v`.+fn perl_class(c: u8) -> Option<(bool, &'static str)> {+ Some(match c {+ b'd' => (false, r"0-9"),+ b'D' => (true, r"0-9"),+ b's' => (false, r"\t\n\x0C\r "),+ b'S' => (true, r"\t\n\x0C\r "),+ b'w' => (false, r"0-9A-Za-z_"),+ b'W' => (true, r"0-9A-Za-z_"),+ _ => return None,+ })+}++fn posix_class(name: &[u8]) -> Option<&'static str> {+ Some(match name {+ b"alnum" => r"0-9A-Za-z",+ b"alpha" => r"A-Za-z",+ b"ascii" => r"\x00-\x7F",+ b"blank" => r"\t ",+ b"cntrl" => r"\x00-\x1F\x7F",+ b"digit" => r"0-9",+ b"graph" => r"!-~",+ b"lower" => r"a-z",+ b"print" => r" -~",+ b"punct" => r"!-/:-@\[-`\{-~",+ b"space" => r"\t-\r ",+ b"upper" => r"A-Z",+ b"word" => r"0-9A-Za-z_",+ b"xdigit" => r"0-9A-Fa-f",+ _ => return None,+ })+}++const UNICODE_GROUPS: &[&str] = &[+ "Adlam",+ "Ahom",+ "Anatolian_Hieroglyphs",+ "Arabic",+ "Armenian",+ "Avestan",+ "Balinese",+ "Bamum",+ "Bassa_Vah",+ "Batak",+ "Bengali",+ "Bhaiksuki",+ "Bopomofo",+ "Brahmi",+ "Braille",+ "Buginese",+ "Buhid",+ "C",+ "Canadian_Aboriginal",+ "Carian",+ "Caucasian_Albanian",+ "Cc",+ "Cf",+ "Chakma",+ "Cham",+ "Cherokee",+ "Chorasmian",+ "Co",+ "Common",+ "Coptic",+ "Cs",+ "Cuneiform",+ "Cypriot",+ "Cypro_Minoan",+ "Cyrillic",+ "Deseret",+ "Devanagari",+ "Dives_Akuru",+ "Dogra",+ "Duployan",+ "Egyptian_Hieroglyphs",+ "Elbasan",+ "Elymaic",+ "Ethiopic",+ "Georgian",+ "Glagolitic",+ "Gothic",+ "Grantha",+ "Greek",+ "Gujarati",+ "Gunjala_Gondi",+ "Gurmukhi",+ "Han",+ "Hangul",+ "Hanifi_Rohingya",+ "Hanunoo",+ "Hatran",+ "Hebrew",+ "Hiragana",+ "Imperial_Aramaic",+ "Inherited",+ "Inscriptional_Pahlavi",+ "Inscriptional_Parthian",+ "Javanese",+ "Kaithi",+ "Kannada",+ "Katakana",+ "Kawi",+ "Kayah_Li",+ "Kharoshthi",+ "Khitan_Small_Script",+ "Khmer",+ "Khojki",+ "Khudawadi",+ "L",+ "Lao",+ "Latin",+ "Lepcha",+ "Limbu",+ "Linear_A",+ "Linear_B",+ "Lisu",+ "Ll",+ "Lm",+ "Lo",+ "Lt",+ "Lu",+ "Lycian",+ "Lydian",+ "M",+ "Mahajani",+ "Makasar",+ "Malayalam",+ "Mandaic",+ "Manichaean",+ "Marchen",+ "Masaram_Gondi",+ "Mc",+ "Me",+ "Medefaidrin",+ "Meetei_Mayek",+ "Mende_Kikakui",+ "Meroitic_Cursive",+ "Meroitic_Hieroglyphs",+ "Miao",+ "Mn",+ "Modi",+ "Mongolian",+ "Mro",+ "Multani",+ "Myanmar",+ "N",+ "Nabataean",+ "Nag_Mundari",+ "Nandinagari",+ "Nd",+ "New_Tai_Lue",+ "Newa",+ "Nko",+ "Nl",+ "No",+ "Nushu",+ "Nyiakeng_Puachue_Hmong",+ "Ogham",+ "Ol_Chiki",+ "Old_Hungarian",+ "Old_Italic",+ "Old_North_Arabian",+ "Old_Permic",+ "Old_Persian",+ "Old_Sogdian",+ "Old_South_Arabian",+ "Old_Turkic",+ "Old_Uyghur",+ "Oriya",+ "Osage",+ "Osmanya",+ "P",+ "Pahawh_Hmong",+ "Palmyrene",+ "Pau_Cin_Hau",+ "Pc",+ "Pd",+ "Pe",+ "Pf",+ "Phags_Pa",+ "Phoenician",+ "Pi",+ "Po",+ "Ps",+ "Psalter_Pahlavi",+ "Rejang",+ "Runic",+ "S",+ "Samaritan",+ "Saurashtra",+ "Sc",+ "Sharada",+ "Shavian",+ "Siddham",+ "SignWriting",+ "Sinhala",+ "Sk",+ "Sm",+ "So",+ "Sogdian",+ "Sora_Sompeng",+ "Soyombo",+ "Sundanese",+ "Syloti_Nagri",+ "Syriac",+ "Tagalog",+ "Tagbanwa",+ "Tai_Le",+ "Tai_Tham",+ "Tai_Viet",+ "Takri",+ "Tamil",+ "Tangsa",+ "Tangut",+ "Telugu",+ "Thaana",+ "Thai",+ "Tibetan",+ "Tifinagh",+ "Tirhuta",+ "Toto",+ "Ugaritic",+ "Vai",+ "Vithkuqi",+ "Wancho",+ "Warang_Citi",+ "Yezidi",+ "Yi",+ "Z",+ "Zanabazar_Square",+ "Zl",+ "Zp",+ "Zs",+ "Any",+];++/// `Cs` is empty in valid UTF-8, so it matches nothing.+fn unicode_group_item(name: &str, negated: bool) -> ClassItem {+ let positive = match name {+ // RE2's C has no unassigned code points; Rust's does.+ "C" => r"[\p{Cc}\p{Cf}\p{Co}]".to_string(),+ "Cs" => NEVER.to_string(),+ other => format!("\\p{{{other}}}"),+ };+ if !negated {+ return ClassItem::Nested(positive);+ }+ ClassItem::Nested(match name {+ "C" => r"[^\p{Cc}\p{Cf}\p{Co}]".to_string(),+ "Cs" => ANY.to_string(),+ other => format!("\\P{{{other}}}"),+ })+}++fn capture_name_regex() -> &'static Regex {+ static RE: OnceLock<Regex> = OnceLock::new();+ RE.get_or_init(|| {+ Regex::new(r"^[\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Lo}\p{Nl}\p{Mn}\p{Mc}\p{Nd}\p{Pc}]+$")+ .expect("static pattern")+ })+}++#[derive(Clone, Copy, PartialEq, Eq)]+enum PieceKind {+ Atom,+ /// An empty-width assertion. Rust needs a group around it before a repetition.+ Assertion,+ Flags,+}++#[derive(Clone)]+struct RepNode {+ divisor: u32,+ depth: usize,+ children: Vec<RepNode>,+}++/// The parser stops at the regex builder's nest limit first, so deep input cannot overflow the stack.+const MAX_NESTING: usize = 1000;++fn walk(node: &RepNode, arg: u32) -> u32 {+ let arg = arg.checked_div(node.divisor).unwrap_or(arg);+ node.children+ .iter()+ .map(|c| walk(c, arg))+ .fold(arg, u32::min)+}++struct Piece {+ text: String,+ kind: PieceKind,+ repeated: bool,+ /// Repetition groups around this piece. A flag group between operators lets them stack.+ wraps: usize,+ reps: Vec<RepNode>,+}++struct Frame {+ open: String,+ alternatives: Vec<String>,+ reps: Vec<RepNode>,+ current: Vec<Piece>,+}++impl Frame {+ fn new(open: String) -> Self {+ Frame {+ open,+ alternatives: Vec::new(),+ reps: Vec::new(),+ current: Vec::new(),+ }+ }++ fn finish_alternative(&mut self) {+ let mut text = String::new();+ for piece in self.current.drain(..) {+ text.push_str(&piece.text);+ self.reps.extend(piece.reps);+ }+ self.alternatives.push(text);+ }+}++struct Parser<'a> {+ s: &'a [u8],+ pos: usize,+ stack: Vec<Frame>,+ names: HashSet<String>,+}++fn err<T>(message: &str) -> Result<T, Re2Error> {+ Err(Re2Error(message.to_string()))+}++impl<'a> Parser<'a> {+ fn new(s: &'a [u8]) -> Self {+ Parser {+ s,+ pos: 0,+ stack: vec![Frame::new(String::new())],+ names: HashSet::new(),+ }+ }++ fn rest(&self) -> &'a [u8] {+ &self.s[self.pos..]+ }++ fn peek(&self, k: usize) -> Option<u8> {+ self.s.get(self.pos + k).copied()+ }++ fn next_rune(&mut self) -> Result<u32, Re2Error> {+ match decode_rune(self.s, self.pos) {+ Some((r, n)) => {+ self.pos += n;+ Ok(r)+ }+ None => err("invalid UTF-8"),+ }+ }++ /// The root frame is not a group, so the stack holds one frame more than the group depth.+ fn open_group(&mut self, open: String) -> Result<(), Re2Error> {+ if self.stack.len() > MAX_NESTING {+ return err("bad nesting depth");+ }+ self.stack.push(Frame::new(open));+ Ok(())+ }++ fn frame(&mut self) -> &mut Frame {+ self.stack.last_mut().expect("root frame")+ }++ fn push(&mut self, text: String, kind: PieceKind) {+ self.frame().current.push(Piece {+ text,+ kind,+ repeated: false,+ wraps: 0,+ reps: Vec::new(),+ });+ }++ fn parse(mut self) -> Result<String, Re2Error> {+ let mut last_was_repeat = false;+ while self.pos < self.s.len() {+ let mut is_repeat = false;+ match self.s[self.pos] {+ b'(' => {+ if self.peek(1) == Some(b'?') {+ self.parse_perl_flags()?;+ } else {+ self.pos += 1;+ self.open_group("(?:".to_string())?;+ }+ }+ b'|' => {+ self.pos += 1;+ self.frame().finish_alternative();+ }+ b')' => {+ self.pos += 1;+ if self.stack.len() == 1 {+ return err("unexpected )");+ }+ let mut frame = self.stack.pop().expect("checked above");+ frame.finish_alternative();+ let text = format!("{}{})", frame.open, frame.alternatives.join("|"));+ self.frame().current.push(Piece {+ text,+ kind: PieceKind::Atom,+ repeated: false,+ wraps: 0,+ reps: frame.reps,+ });+ }+ b'^' => {+ self.pos += 1;+ self.push("^".into(), PieceKind::Assertion);+ }+ b'$' => {+ self.pos += 1;+ self.push("$".into(), PieceKind::Assertion);+ }+ b'.' => {+ self.pos += 1;+ self.push(".".into(), PieceKind::Atom);+ }+ b'[' => {+ let text = self.parse_char_class()?;+ self.push(text, PieceKind::Atom);+ }+ op @ (b'*' | b'+' | b'?') => {+ self.pos += 1;+ let mut text = (op as char).to_string();+ if self.peek(0) == Some(b'?') {+ self.pos += 1;+ text.push('?');+ }+ if last_was_repeat {+ return err("bad repetition operator");+ }+ self.apply_repeat(&text, None)?;+ is_repeat = true;+ }+ b'{' => match self.maybe_parse_repetition() {+ None => {+ self.pos += 1;+ self.push(literal('{' as u32), PieceKind::Atom);+ }+ Some((lo, hi)) => {+ let mut text = match hi {+ Some(h) if h == lo => format!("{{{lo}}}"),+ Some(h) => format!("{{{lo},{h}}}"),+ None => format!("{{{lo},}}"),+ };+ if self.peek(0) == Some(b'?') {+ self.pos += 1;+ text.push('?');+ }+ if last_was_repeat {+ return err("bad repetition operator");+ }+ if hi.is_some_and(|h| h < lo)+ || lo > MAX_REPEAT+ || hi.unwrap_or(0) > MAX_REPEAT+ {+ return err("invalid repetition size");+ }+ self.apply_repeat(&text, Some((lo, hi)))?;+ is_repeat = true;+ }+ },+ b'\\' => self.parse_backslash()?,+ _ => {+ let r = self.next_rune()?;+ self.push(literal(r), PieceKind::Atom);+ }+ }+ last_was_repeat = is_repeat;+ }+ if self.stack.len() != 1 {+ return err("missing )");+ }+ let mut root = self.stack.pop().expect("root frame");+ root.finish_alternative();+ Ok(root.alternatives.join("|"))+ }++ fn apply_repeat(+ &mut self,+ op: &str,+ counted: Option<(u32, Option<u32>)>,+ ) -> Result<(), Re2Error> {+ let frame = self.frame();+ let Some(piece) = frame+ .current+ .iter_mut()+ .rev()+ .find(|p| p.kind != PieceKind::Flags)+ else {+ return err("missing argument to repetition operator");+ };+ if piece.repeated || piece.kind == PieceKind::Assertion {+ piece.wraps += 1;+ if piece.wraps > MAX_NESTING {+ return err("bad nesting depth");+ }+ piece.text = format!("(?:{})", piece.text);+ piece.kind = PieceKind::Atom;+ }+ piece.text.push_str(op);+ piece.repeated = true;+ if let Some((lo, hi)) = counted {+ let divisor = hi.unwrap_or(lo);+ let children = std::mem::take(&mut piece.reps);+ let depth = 1 + children.iter().map(|c| c.depth).max().unwrap_or(0);+ if depth > MAX_NESTING {+ return err("bad nesting depth");+ }+ let node = RepNode {+ divisor,+ depth,+ children,+ };+ if (lo >= 2 || hi.unwrap_or(0) >= 2) && walk(&node, MAX_REPEAT) == 0 {+ return err("invalid repetition size");+ }+ piece.reps = vec![node];+ }+ Ok(())+ }++ /// RE2's `ParseInteger`: no leading zeros, and no value at or above 10^8 mid-parse.+ fn parse_integer(&self, at: &mut usize) -> Option<u32> {+ let s = self.s;+ if *at >= s.len() || !s[*at].is_ascii_digit() {+ return None;+ }+ if *at + 1 < s.len() && s[*at] == b'0' && s[*at + 1].is_ascii_digit() {+ return None;+ }+ let mut n: u32 = 0;+ while *at < s.len() && s[*at].is_ascii_digit() {+ if n >= 100_000_000 {+ return None;+ }+ n = n * 10 + (s[*at] - b'0') as u32;+ *at += 1;+ }+ Some(n)+ }++ /// `None` means the `{` is a literal.+ fn maybe_parse_repetition(&mut self) -> Option<(u32, Option<u32>)> {+ let s = self.s;+ let mut at = self.pos + 1;+ let lo = self.parse_integer(&mut at)?;+ if at >= s.len() {+ return None;+ }+ let hi = if s[at] == b',' {+ at += 1;+ if at >= s.len() {+ return None;+ }+ if s[at] == b'}' {+ None+ } else {+ Some(self.parse_integer(&mut at)?)+ }+ } else {+ Some(lo)+ };+ if at >= s.len() || s[at] != b'}' {+ return None;+ }+ self.pos = at + 1;+ Some((lo, hi))+ }++ fn parse_perl_flags(&mut self) -> Result<(), Re2Error> {+ let t = self.rest();+ if (t.len() > 3 && (t[2] == b'=' || t[2] == b'!'))+ || (t.len() > 4 && t[2] == b'<' && (t[3] == b'=' || t[3] == b'!'))+ {+ return err("invalid perl operator");+ }+ if (t.len() > 4 && t[2] == b'P' && t[3] == b'<') || (t.len() > 3 && t[2] == b'<') {+ let begin = if t[2] == b'P' { 4 } else { 3 };+ let Some(end) = t[begin..]+ .iter()+ .position(|&c| c == b'>')+ .map(|p| p + begin)+ else {+ return err("invalid named capture group");+ };+ let name = std::str::from_utf8(&t[begin..end])+ .map_err(|_| Re2Error("invalid named capture group".into()))?;+ if !capture_name_regex().is_match(name.as_bytes()) {+ return err("invalid named capture group");+ }+ if !self.names.insert(name.to_string()) {+ return err("duplicate capture group name");+ }+ self.pos += end + 1;+ return self.open_group("(?:".to_string());+ }+ self.pos += 2;+ let mut negated = false;+ let mut saw_flags = false;+ let mut set: [Option<bool>; 4] = [None; 4];+ loop {+ if self.pos >= self.s.len() {+ return err("invalid perl operator");+ }+ let c = self.next_rune()?;+ let slot = match c {+ 0x69 => Some(0), // i+ 0x6D => Some(1), // m+ 0x73 => Some(2), // s+ 0x55 => Some(3), // U+ _ => None,+ };+ if let Some(slot) = slot {+ saw_flags = true;+ set[slot] = Some(!negated);+ continue;+ }+ match c {+ 0x2D => {+ if negated {+ return err("invalid perl operator");+ }+ negated = true;+ saw_flags = false;+ }+ 0x3A | 0x29 => {+ if negated && !saw_flags {+ return err("invalid perl operator");+ }+ let letters = ['i', 'm', 's', 'U'];+ let on: String = (0..4)+ .filter(|&k| set[k] == Some(true))+ .map(|k| letters[k])+ .collect();+ let off: String = (0..4)+ .filter(|&k| set[k] == Some(false))+ .map(|k| letters[k])+ .collect();+ let mut flags = on;+ if !off.is_empty() {+ flags.push('-');+ flags.push_str(&off);+ }+ if c == 0x3A {+ self.open_group(format!("(?{flags}:"))?;+ } else if !flags.is_empty() {+ self.push(format!("(?{flags})"), PieceKind::Flags);+ } else {+ self.push(String::new(), PieceKind::Flags);+ }+ return Ok(());+ }+ _ => return err("invalid perl operator"),+ }+ }+ }++ fn parse_backslash(&mut self) -> Result<(), Re2Error> {+ let next = self.peek(1);+ match next {+ Some(b'b') => {+ self.pos += 2;+ self.push(r"(?-u:\b)".into(), PieceKind::Assertion);+ return Ok(());+ }+ Some(b'B') => {+ self.pos += 2;+ self.push(r"(?-u:\B)".into(), PieceKind::Assertion);+ return Ok(());+ }+ Some(b'A') => {+ self.pos += 2;+ self.push(r"\A".into(), PieceKind::Assertion);+ return Ok(());+ }+ Some(b'z') => {+ self.pos += 2;+ self.push(r"\z".into(), PieceKind::Assertion);+ return Ok(());+ }+ Some(b'C') => {+ self.pos += 2;+ self.push(r"(?s-u:.)".into(), PieceKind::Atom);+ return Ok(());+ }+ Some(b'Q') => {+ self.pos += 2;+ while self.pos < self.s.len() {+ if self.peek(0) == Some(b'\\') && self.peek(1) == Some(b'E') {+ self.pos += 2;+ break;+ }+ let r = self.next_rune()?;+ self.push(literal(r), PieceKind::Atom);+ }+ return Ok(());+ }+ Some(b'p' | b'P') => {+ let item = self.parse_unicode_group()?;+ let text = match item {+ ClassItem::Nested(t) => t,+ ClassItem::Range(..) => unreachable!("unicode groups are nested items"),+ };+ self.push(text, PieceKind::Atom);+ return Ok(());+ }+ Some(c) => {+ if let Some((negated, body)) = perl_class(c) {+ self.pos += 2;+ let text = format!("[{}{body}]", if negated { "^" } else { "" });+ self.push(text, PieceKind::Atom);+ return Ok(());+ }+ }+ None => {}+ }+ let r = self.parse_escape()?;+ self.push(literal(r), PieceKind::Atom);+ Ok(())+ }++ fn parse_unicode_group(&mut self) -> Result<ClassItem, Re2Error> {+ let mut negated = self.peek(1) == Some(b'P');+ self.pos += 2;+ let name_bytes: &[u8] = if self.peek(0) == Some(b'{') {+ let rest = &self.s[self.pos + 1..];+ let Some(end) = rest.iter().position(|&c| c == b'}') else {+ return err("invalid character class range");+ };+ self.pos += end + 2;+ &rest[..end]+ } else {+ let start = self.pos;+ if start >= self.s.len() {+ return err("invalid character class range");+ }+ self.next_rune()?;+ &self.s[start..self.pos]+ };+ let mut name =+ std::str::from_utf8(name_bytes).map_err(|_| Re2Error("invalid UTF-8".into()))?;+ if let Some(stripped) = name.strip_prefix('^') {+ negated = !negated;+ name = stripped;+ }+ if !UNICODE_GROUPS.contains(&name) {+ return err("invalid character class range");+ }+ Ok(unicode_group_item(name, negated))+ }++ fn parse_escape(&mut self) -> Result<u32, Re2Error> {+ self.pos += 1;+ if self.pos >= self.s.len() {+ return err("trailing \\");+ }+ let c = self.next_rune()?;+ let is_octal = |b: Option<u8>| b.is_some_and(|b| (b'0'..=b'7').contains(&b));+ match c {+ 0x30..=0x37 => {+ if c != 0x30 && !is_octal(self.peek(0)) {+ return err("invalid escape sequence");+ }+ let mut code = c - 0x30;+ if is_octal(self.peek(0)) {+ code = code * 8 + (self.s[self.pos] - b'0') as u32;+ self.pos += 1;+ if is_octal(self.peek(0)) {+ code = code * 8 + (self.s[self.pos] - b'0') as u32;+ self.pos += 1;+ }+ }+ Ok(code)+ }+ 0x78 => {+ if self.pos >= self.s.len() {+ return err("invalid escape sequence");+ }+ let c = self.next_rune()?;+ let hex = |r: u32| char::from_u32(r).and_then(|c| c.to_digit(16));+ if c == '{' as u32 {+ if self.pos >= self.s.len() {+ return err("invalid escape sequence");+ }+ let mut c = self.next_rune()?;+ let mut nhex = 0;+ let mut code: u32 = 0;+ while let Some(d) = hex(c) {+ nhex += 1;+ code = code * 16 + d;+ if code > RUNE_MAX || self.pos >= self.s.len() {+ return err("invalid escape sequence");+ }+ c = self.next_rune()?;+ }+ if c != '}' as u32 || nhex == 0 {+ return err("invalid escape sequence");+ }+ return Ok(code);+ }+ if self.pos >= self.s.len() {+ return err("invalid escape sequence");+ }+ let c1 = self.next_rune()?;+ match (hex(c), hex(c1)) {+ (Some(a), Some(b)) => Ok(a * 16 + b),+ _ => err("invalid escape sequence"),+ }+ }+ 0x6E => Ok(0x0A), // n+ 0x72 => Ok(0x0D), // r+ 0x74 => Ok(0x09), // t+ 0x61 => Ok(0x07), // a+ 0x66 => Ok(0x0C), // f+ 0x76 => Ok(0x0B), // v+ c if c < 0x80 && !(c as u8).is_ascii_alphanumeric() => Ok(c),+ _ => err("invalid escape sequence"),+ }+ }++ fn parse_char_class(&mut self) -> Result<String, Re2Error> {+ self.pos += 1;+ let mut negated = false;+ if self.peek(0) == Some(b'^') {+ self.pos += 1;+ negated = true;+ }+ let mut items: Vec<ClassItem> = Vec::new();+ let mut first = true;+ while self.pos < self.s.len() && (self.s[self.pos] != b']' || first) {+ first = false;+ let rest = self.rest();+ if rest.len() > 2 && rest[0] == b'[' && rest[1] == b':' {+ // `[:name:]` when a closing `:]` exists, else a literal `[`.+ if let Some(q) = (2..rest.len().saturating_sub(1))+ .find(|&q| rest[q] == b':' && rest[q + 1] == b']')+ {+ let full = &rest[2..q];+ let (posix_negated, name) = match full.strip_prefix(b"^") {+ Some(n) => (true, n),+ None => (false, full),+ };+ let Some(body) = posix_class(name) else {+ return err("invalid character class range");+ };+ self.pos += q + 2;+ items.push(ClassItem::Nested(format!(+ "[{}{body}]",+ if posix_negated { "^" } else { "" }+ )));+ continue;+ }+ }+ if rest.len() > 2 && rest[0] == b'\\' && (rest[1] == b'p' || rest[1] == b'P') {+ items.push(self.parse_unicode_group()?);+ continue;+ }+ if rest.len() >= 2 && rest[0] == b'\\' {+ if let Some((perl_negated, body)) = perl_class(rest[1]) {+ self.pos += 2;+ items.push(ClassItem::Nested(format!(+ "[{}{body}]",+ if perl_negated { "^" } else { "" }+ )));+ continue;+ }+ }+ let lo = self.parse_cc_character()?;+ let rest = self.rest();+ let hi = if rest.len() >= 2 && rest[0] == b'-' && rest[1] != b']' {+ self.pos += 1;+ let hi = self.parse_cc_character()?;+ if hi < lo {+ return err("invalid character class range");+ }+ hi+ } else {+ lo+ };+ items.push(ClassItem::Range(lo, hi));+ }+ if self.pos >= self.s.len() {+ return err("missing ]");+ }+ self.pos += 1;+ Ok(class_text(negated, &items))+ }++ fn parse_cc_character(&mut self) -> Result<u32, Re2Error> {+ if self.pos >= self.s.len() {+ return err("missing ]");+ }+ if self.s[self.pos] == b'\\' {+ return self.parse_escape();+ }+ self.next_rune()+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ fn t(pattern: &str, input: &str) -> Option<bool> {+ Re2::new(pattern.as_bytes(), "is")+ .ok()+ .map(|r| r.test(input))+ }++ // RE2 accepts these, and the Rust nest limit rejects them; see the module doc.+ #[test]+ fn deep_nesting_fails_to_compile_without_overflow() {+ let n = 100_000;+ let repetitions = format!("(?:{}a{}){{2}}", "(?:".repeat(n), "){1}".repeat(n));+ let groups = format!("{}a{}", "(".repeat(n), ")".repeat(n));+ let stacked_flags = format!("a{}", "(?i){1}".repeat(n));+ let stacked_stars = format!("a{}", "(?i)*".repeat(n));+ for p in [repetitions, groups, stacked_flags, stacked_stars] {+ assert!(Re2::new(p.as_bytes(), "").is_err());+ }+ }++ #[test]+ fn rejects_what_re2_rejects() {+ for p in [+ "(?=x)",+ "(?!x)",+ "(?<=x)",+ "(?<!x)",+ r"\1",+ r"\8",+ r"\Z",+ "a**",+ "a+*",+ "a???",+ "a{1,2}{3}",+ "a{1001}",+ "(a{100}){11}",+ "((a){10}){101}",+ "a{2,1}",+ "(?x)a",+ "(?#c)",+ "(?i-)",+ "(?-)",+ r"\e",+ r"\y",+ r"\é",+ r"\x{110000}",+ r"\p{greek}",+ r"\p{Cn}",+ "[[:foo:]]",+ "(",+ ")",+ "[",+ "[z-a]",+ "*",+ "a|*",+ "(*)",+ r"\uZZZZ",+ r"[a-\d]",+ r"\",+ "(?P<a>x)(?P<a>y)",+ "(?P<>x)",+ "(?P<a-b>x)",+ ] {+ assert_eq!(t(p, "a"), None, "{p} should fail to compile");+ }+ }++ #[test]+ fn reads_syntax_the_way_re2_does() {+ let cases: &[(&str, &str, bool)] = &[+ ("a{,5}", "a{,5}", true),+ ("{\"a\"", "{\"a\"", true),+ ("a{01}", "a{01}", true),+ (r"\<", "<", true),+ ("[a[b]]", "[]", true),+ ("[a[b]]", "a]", true),+ ("[a&&b]", "&", true),+ ("[--a]", ".", true),+ (r"\0", "\0", true),+ (r"\12", "\n", true),+ (r"\Qa.b\E", "a.b", true),+ (r"\Qa.b", "axb", false),+ (r"\p{^Greek}", "a", true),+ (r"\p{Lowercase_Letter}", "a", true),+ (r"\w", "\u{212A}", true),+ (r"\W", "\u{212A}", false),+ (r"\s", "\u{0B}", false),+ (r"\b", "é", false),+ (r"\d", "٣", false),+ ("^*", "a", true),+ ("(?<n>a)", "a", true),+ ("(?P<1a>a)", "a", true),+ (r"\C", "a", true),+ ("[]a]", "]", true),+ ("[^]a]", "b", true),+ (r"[\d-z]", "-", true),+ ("(?)", "a", true),+ ("$", "\n", true),+ ("a(?i)*", "", true),+ (r"\x{D800}", "\u{FFFD}", false),+ (r"\u{1F600}", "😀", true),+ ("(a{2}|b{500}){2}", "aaaa", true),+ ("[(?<a]", "P", true),+ (r"\cJ", "\n", true),+ (r"\p{C}", "\u{0378}", false),+ ];+ for (p, input, expected) in cases {+ assert_eq!(t(p, input), Some(*expected), "{p:?} on {input:?}");+ }+ }++ #[test]+ fn a_lone_surrogate_in_the_pattern_never_matches() {+ // WTF-8 for "a" followed by U+D83D.+ let pattern = [b'a', 0xED, 0xA0, 0xBD];+ let re = Re2::new(&pattern, "is").unwrap();+ assert!(!re.test("a\u{FFFD}"));+ let optional = [b'a', 0xED, 0xA0, 0xBD, b'?'];+ assert!(Re2::new(&optional, "is").unwrap().test("a"));+ }++ #[test]+ fn flags_change_case_and_dot() {+ assert!(Re2::new(b"^A.$", "is").unwrap().test("a\n"));+ assert!(!Re2::without_flags("^A.$").unwrap().test("a\n"));+ assert!(Re2::without_flags("(?m)^b").unwrap().test("a\nb"));+ }+}diff --git a/rust/logs-ingestion/src/rate_limiter/keyed.rs b/rust/logs-ingestion/src/rate_limiter/keyed.rsnew file mode 100644index 000000000000..80fc154aef84--- /dev/null+++ b/rust/logs-ingestion/src/rate_limiter/keyed.rs@@ -0,0 +1,396 @@+use std::collections::HashMap;+use std::sync::Arc;++use metrics::counter;++use crate::js::number_to_string;+use crate::property_filter::coerce::js_math_round;++use super::redis::{+ ioredis_integer, token_bucket_v2, token_bucket_v3, LuaScript, ScriptCall, TokenBucketRedis,+};++/// The root of every key: `@posthog-test` under `NODE_ENV=test`, else `@posthog`.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum KeyRoot {+ Production,+ Test,+}++impl KeyRoot {+ pub fn from_env() -> KeyRoot {+ if std::env::var("NODE_ENV").as_deref() == Ok("test") {+ KeyRoot::Test+ } else {+ KeyRoot::Production+ }+ }++ pub fn as_str(&self) -> &'static str {+ match self {+ KeyRoot::Production => "@posthog",+ KeyRoot::Test => "@posthog-test",+ }+ }+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum ScriptVersion {+ V2,+ V3,+}++#[derive(Debug, Clone)]+pub struct KeyedRateLimiterConfig {+ pub name: String,+ pub key_root: KeyRoot,+ pub bucket_size: Option<f64>,+ pub refill_rate: Option<f64>,+ pub ttl_seconds: Option<f64>,+ /// `Some(false)` makes a failed pipeline an error; anything else allows every request.+ pub fail_open: Option<bool>,+ /// `scriptVersion`: anything but `'v3'` runs the v2 script in `rate_limit_many`.+ pub script_version: ScriptVersion,+}++impl KeyedRateLimiterConfig {+ pub fn new(name: &str, key_root: KeyRoot) -> Self {+ KeyedRateLimiterConfig {+ name: name.to_string(),+ key_root,+ bucket_size: None,+ refill_rate: None,+ ttl_seconds: None,+ fail_open: None,+ script_version: ScriptVersion::V2,+ }+ }+}++#[derive(Debug, Clone, Default, PartialEq)]+pub struct KeyedRateLimitRequest {+ pub id: String,+ pub cost: f64,+ pub bucket_size: Option<f64>,+ pub refill_rate: Option<f64>,+ pub ttl_seconds: Option<f64>,+ /// Default: `Math.round(Date.now() / 1000)`.+ pub now: Option<f64>,+}++#[derive(Debug, Clone, Copy, PartialEq)]+pub struct KeyedRateLimit {+ /// The token count before the deduction, uncapped.+ pub tokens_before: f64,+ /// The token count after the deduction; -1 when the cost exceeded the budget.+ pub tokens: f64,+ pub is_rate_limited: bool,+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub enum RateLimiterError {+ /// A request had no bucket size. Node throws this before it calls Redis.+ MissingBucketSize {+ limiter: String,+ id: String,+ },+ PipelineFailed {+ limiter: String,+ },+}++impl std::fmt::Display for RateLimiterError {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ match self {+ RateLimiterError::MissingBucketSize { limiter, id } => {+ write!(+ f,+ "KeyedRateLimiterService({limiter}): missing bucketSize for {id}"+ )+ }+ RateLimiterError::PipelineFailed { limiter } => {+ write!(+ f,+ "KeyedRateLimiterService({limiter}): rate-limit pipeline failed"+ )+ }+ }+ }+}++impl std::error::Error for RateLimiterError {}++pub type Clock = Arc<dyn Fn() -> f64 + Send + Sync>;++pub fn system_clock() -> Clock {+ Arc::new(|| {+ std::time::SystemTime::now()+ .duration_since(std::time::UNIX_EPOCH)+ .map(|d| d.as_millis() as f64)+ .unwrap_or(0.0)+ })+}++pub struct KeyedRateLimiter {+ config: KeyedRateLimiterConfig,+ key_prefix: String,+ redis: Arc<dyn TokenBucketRedis>,+ clock: Clock,+ name_label: Arc<str>,+}++impl KeyedRateLimiter {+ pub fn new(config: KeyedRateLimiterConfig, redis: Arc<dyn TokenBucketRedis>) -> Self {+ Self::with_clock(config, redis, system_clock())+ }++ pub fn with_clock(+ config: KeyedRateLimiterConfig,+ redis: Arc<dyn TokenBucketRedis>,+ clock: Clock,+ ) -> Self {+ let key_prefix = format!("{}/{}/tokens", config.key_root.as_str(), config.name);+ let name_label = Arc::from(config.name.as_str());+ KeyedRateLimiter {+ config,+ key_prefix,+ redis,+ clock,+ name_label,+ }+ }++ pub fn key_prefix(&self) -> &str {+ &self.key_prefix+ }++ pub fn clock(&self) -> &Clock {+ &self.clock+ }++ fn bucket_size(&self, req: &KeyedRateLimitRequest) -> Result<f64, RateLimiterError> {+ req.bucket_size.or(self.config.bucket_size).ok_or_else(|| {+ RateLimiterError::MissingBucketSize {+ limiter: self.config.name.clone(),+ id: req.id.clone(),+ }+ })+ }++ /// `None` is the throw inside the pipeline callback, which `usePipeline` reports as a failed pipeline.+ fn call(&self, req: &KeyedRateLimitRequest) -> Option<ScriptCall> {+ let now = req+ .now+ .unwrap_or_else(|| js_math_round((self.clock)() / 1000.0));+ let bucket_size = req.bucket_size.or(self.config.bucket_size)?;+ let refill_rate = req.refill_rate.or(self.config.refill_rate)?;+ let ttl_seconds = req.ttl_seconds.or(self.config.ttl_seconds)?;+ Some(ScriptCall {+ key: format!("{}/{}", self.key_prefix, req.id),+ args: [now, req.cost, bucket_size, refill_rate, ttl_seconds]+ .into_iter()+ .map(number_to_string)+ .collect(),+ })+ }++ /// `None` when the pipeline or its callback fails, as `usePipeline` with `failOpen: true` gives.+ async fn run(+ &self,+ script: &LuaScript,+ requests: &[KeyedRateLimitRequest],+ ) -> Option<Vec<Option<Vec<i64>>>> {+ let calls: Option<Vec<ScriptCall>> = requests.iter().map(|r| self.call(r)).collect();+ let Some(calls) = calls else {+ tracing::error!(limiter = %self.config.name, "rate-limit arguments missing");+ return None;+ };+ match self.redis.eval_pipeline(script, &calls).await {+ Ok(replies) => Some(replies.into_iter().map(Result::ok).collect()),+ Err(error) => {+ tracing::error!(limiter = %self.config.name, %error, "Redis rate-limit pipeline failed");+ None+ }+ }+ }++ fn count_requests(&self, method: &'static str, outcome: &'static str, n: usize) {+ if n > 0 {+ counter!("keyed_rate_limiter_requests_total", "name" => self.name_label.clone(), "method" => method, "outcome" => outcome)+ .increment(n as u64);+ }+ }++ pub async fn rate_limit_many(+ &self,+ requests: &[KeyedRateLimitRequest],+ ) -> Result<Vec<(String, KeyedRateLimit)>, RateLimiterError> {+ if requests.is_empty() {+ return Ok(Vec::new());+ }+ let bucket_sizes = requests+ .iter()+ .map(|r| self.bucket_size(r))+ .collect::<Result<Vec<_>, _>>()?;+ let script = match self.config.script_version {+ ScriptVersion::V3 => token_bucket_v3(),+ ScriptVersion::V2 => token_bucket_v2(),+ };+ let res = self.run(script, requests).await;+ counter!("keyed_rate_limiter_redis_calls_total", "name" => self.name_label.clone(), "method" => "rateLimitMany")+ .increment(requests.len() as u64);+ let Some(replies) = res else {+ if self.config.fail_open == Some(false) {+ return Err(RateLimiterError::PipelineFailed {+ limiter: self.config.name.clone(),+ });+ }+ self.count_requests("rateLimitMany", "allowed", requests.len());+ return Ok(requests+ .iter()+ .zip(bucket_sizes)+ .map(|(req, size)| {+ (+ req.id.clone(),+ KeyedRateLimit {+ tokens_before: size,+ tokens: size,+ is_rate_limited: false,+ },+ )+ })+ .collect());+ };+ let mut allowed = 0;+ let mut limited = 0;+ let out = requests+ .iter()+ .enumerate()+ .map(|(i, req)| {+ let reply = replies.get(i).cloned().flatten();+ let at = |k: usize| {+ reply+ .as_ref()+ .and_then(|r| r.get(k))+ .map(|n| ioredis_integer(*n))+ };+ let tokens_before = at(0).unwrap_or(bucket_sizes[i]);+ let tokens = at(1).unwrap_or(bucket_sizes[i]);+ let is_rate_limited = tokens <= 0.0;+ if is_rate_limited {+ limited += 1;+ } else {+ allowed += 1;+ }+ (+ req.id.clone(),+ KeyedRateLimit {+ tokens_before,+ tokens,+ is_rate_limited,+ },+ )+ })+ .collect();+ self.count_requests("rateLimitMany", "allowed", allowed);+ self.count_requests("rateLimitMany", "limited", limited);+ Ok(out)+ }++ /// Bucket parameters come from the first request for each id.+ pub async fn rate_limit_grouped(+ &self,+ requests: &[KeyedRateLimitRequest],+ ) -> Result<Vec<(String, KeyedRateLimit)>, RateLimiterError> {+ if requests.is_empty() {+ return Ok(Vec::new());+ }+ let mut items: Vec<KeyedRateLimitRequest> = Vec::new();+ let mut index_by_id: HashMap<&str, usize> = HashMap::new();+ for req in requests {+ match index_by_id.get(req.id.as_str()) {+ Some(&i) => items[i].cost += req.cost,+ None => {+ index_by_id.insert(req.id.as_str(), items.len());+ items.push(req.clone());+ }+ }+ }+ let bucket_sizes = items+ .iter()+ .map(|r| self.bucket_size(r))+ .collect::<Result<Vec<_>, _>>()?;+ let res = self.run(token_bucket_v3(), &items).await;+ counter!("keyed_rate_limiter_redis_calls_total", "name" => self.name_label.clone(), "method" => "rateLimitGrouped")+ .increment(items.len() as u64);+ let Some(replies) = res else {+ if self.config.fail_open == Some(false) {+ return Err(RateLimiterError::PipelineFailed {+ limiter: self.config.name.clone(),+ });+ }+ self.count_requests("rateLimitGrouped", "allowed", requests.len());+ return Ok(requests+ .iter()+ .map(|req| {+ let size = bucket_sizes[index_by_id[req.id.as_str()]];+ (+ req.id.clone(),+ KeyedRateLimit {+ tokens_before: size,+ tokens: size,+ is_rate_limited: false,+ },+ )+ })+ .collect());+ };+ let mut budget: Vec<f64> = items+ .iter()+ .enumerate()+ .map(|(i, _)| {+ replies+ .get(i)+ .cloned()+ .flatten()+ .and_then(|r| r.first().map(|n| ioredis_integer(*n)))+ .unwrap_or(bucket_sizes[i])+ })+ .collect();+ let mut allowed = 0;+ let mut limited = 0;+ let out = requests+ .iter()+ .map(|req| {+ let i = index_by_id[req.id.as_str()];+ let tokens_before = budget[i];+ if tokens_before >= req.cost {+ let next = tokens_before - req.cost;+ budget[i] = next;+ allowed += 1;+ (+ req.id.clone(),+ KeyedRateLimit {+ tokens_before,+ tokens: next,+ is_rate_limited: false,+ },+ )+ } else {+ limited += 1;+ (+ req.id.clone(),+ KeyedRateLimit {+ tokens_before,+ tokens: -1.0,+ is_rate_limited: true,+ },+ )+ }+ })+ .collect();+ self.count_requests("rateLimitGrouped", "allowed", allowed);+ self.count_requests("rateLimitGrouped", "limited", limited);+ Ok(out)+ }+}diff --git a/rust/logs-ingestion/src/rate_limiter/logs.rs b/rust/logs-ingestion/src/rate_limiter/logs.rsnew file mode 100644index 000000000000..9714851dfea6--- /dev/null+++ b/rust/logs-ingestion/src/rate_limiter/logs.rs@@ -0,0 +1,319 @@+//! A partial batch is let through up to the bucket's pre-call balance, as in Node.++use std::collections::hash_map::Entry;+use std::collections::HashMap;+use std::sync::Arc;++use metrics::histogram;++use crate::js::date_parse;+use crate::property_filter::coerce::{js_math_round, js_parse_int, js_trim};++use super::keyed::{+ Clock, KeyRoot, KeyedRateLimitRequest, KeyedRateLimiter, KeyedRateLimiterConfig,+ RateLimiterError, ScriptVersion,+};+use super::redis::TokenBucketRedis;++pub const DEFAULT_LIMITER_NAME: &str = "logs-rate-limiter";++pub fn build_base_redis_key(key_root: KeyRoot, limiter_name: &str) -> String {+ format!("{}/{limiter_name}", key_root.as_str())+}++#[derive(Debug, Clone)]+pub struct LogsRateLimiterConfig {+ pub team_bucket_size_kb: String,+ pub team_refill_rate_kb_per_second: String,+ pub disabled_for_teams: String,+ pub enabled_teams: String,+ pub bucket_size_kb: f64,+ pub refill_rate_kb_per_second: f64,+ pub ttl_seconds: f64,+}++pub trait RateLimitedMessage {+ fn team_id(&self) -> i64;+ fn bytes_uncompressed(&self) -> f64;+ /// The value of the first Kafka header named `created_at`.+ fn created_at_header(&self) -> Option<&[u8]>;+}++#[derive(Debug, Clone, Copy, PartialEq)]+pub struct LogsRateLimit {+ pub tokens_before: f64,+ pub tokens_after: f64,+ pub is_rate_limited: bool,+}++#[derive(Debug)]+pub struct FilteredMessages<M> {+ pub allowed: Vec<M>,+ pub dropped: Vec<M>,+}++#[derive(Debug, Clone, PartialEq)]+enum TeamList {+ All,+ Teams(Vec<f64>),+}++fn parse_team_id_list(config: &str) -> Option<TeamList> {+ if config == "*" {+ return Some(TeamList::All);+ }+ if config.is_empty() {+ return None;+ }+ Some(TeamList::Teams(+ config+ .split(',')+ .map(|id| js_parse_int(js_trim(id), Some(10)))+ .filter(|n| !n.is_nan())+ .collect(),+ ))+}++/// A later pair for a team replaces the earlier value.+fn parse_team_config(config: &str) -> Vec<(f64, f64)> {+ let mut result: Vec<(f64, f64)> = Vec::new();+ if config.is_empty() {+ return result;+ }+ for entry in config.split(',') {+ let mut parts = entry.split(':').map(|s| js_parse_int(js_trim(s), Some(10)));+ let team = parts.next().unwrap_or(f64::NAN);+ let value = parts.next().unwrap_or(f64::NAN);+ if team.is_nan() || value.is_nan() {+ continue;+ }+ match result.iter_mut().find(|(t, _)| *t == team) {+ Some(slot) => slot.1 = value,+ None => result.push((team, value)),+ }+ }+ result+}++fn lookup(pairs: &[(f64, f64)], team: f64) -> Option<f64> {+ pairs.iter().find(|(t, _)| *t == team).map(|(_, v)| *v)+}++fn bytes_to_kb(bytes: f64) -> f64 {+ (bytes / 1000.0).ceil()+}++pub struct LogsRateLimiter {+ config: LogsRateLimiterConfig,+ team_bucket_sizes: Vec<(f64, f64)>,+ team_refill_rates: Vec<(f64, f64)>,+ disabled_team_ids: Option<TeamList>,+ enabled_team_ids: Option<TeamList>,+ rate_limiter: KeyedRateLimiter,+}++impl LogsRateLimiter {+ pub fn new(+ config: LogsRateLimiterConfig,+ redis: Arc<dyn TokenBucketRedis>,+ limiter_name: &str,+ key_root: KeyRoot,+ clock: Clock,+ ) -> Self {+ let mut keyed = KeyedRateLimiterConfig::new(limiter_name, key_root);+ // Throws when Redis fails, as the legacy limiter did.+ keyed.fail_open = Some(false);+ keyed.script_version = ScriptVersion::V2;+ LogsRateLimiter {+ team_bucket_sizes: parse_team_config(&config.team_bucket_size_kb),+ team_refill_rates: parse_team_config(&config.team_refill_rate_kb_per_second),+ disabled_team_ids: parse_team_id_list(&config.disabled_for_teams),+ enabled_team_ids: parse_team_id_list(&config.enabled_teams),+ config,+ rate_limiter: KeyedRateLimiter::with_clock(keyed, redis, clock),+ }+ }++ fn now_seconds(&self) -> f64 {+ js_math_round((self.rate_limiter.clock())() / 1000.0)+ }++ fn timestamp_from_message<M: RateLimitedMessage>(&self, message: &M) -> f64 {+ if let Some(raw) = message.created_at_header() {+ let text = match std::str::from_utf8(raw) {+ Ok(text) => std::borrow::Cow::Borrowed(text),+ Err(_) => String::from_utf8_lossy(raw),+ };+ if !text.is_empty() {+ if let Some(ms) = date_parse(&text) {+ return js_math_round(ms / 1000.0);+ }+ }+ }+ self.now_seconds()+ }++ pub async fn rate_limit_many(+ &self,+ id_costs: &[(String, f64, f64)],+ ) -> Result<Vec<(String, LogsRateLimit)>, RateLimiterError> {+ let requests: Vec<KeyedRateLimitRequest> = id_costs+ .iter()+ .map(|(id, cost, now)| {+ let team = js_parse_int(id, Some(10));+ KeyedRateLimitRequest {+ id: id.clone(),+ cost: *cost,+ now: Some(*now),+ bucket_size: Some(+ lookup(&self.team_bucket_sizes, team).unwrap_or(self.config.bucket_size_kb),+ ),+ refill_rate: Some(+ lookup(&self.team_refill_rates, team)+ .unwrap_or(self.config.refill_rate_kb_per_second),+ ),+ ttl_seconds: Some(self.config.ttl_seconds),+ }+ })+ .collect();+ let results = self.rate_limiter.rate_limit_many(&requests).await?;+ Ok(results+ .into_iter()+ .map(|(id, r)| {+ (+ id,+ LogsRateLimit {+ tokens_before: r.tokens_before,+ tokens_after: r.tokens,+ is_rate_limited: r.is_rate_limited,+ },+ )+ })+ .collect())+ }++ fn is_enabled_for_team(&self, team_id: i64) -> bool {+ let team = team_id as f64;+ match &self.disabled_team_ids {+ Some(TeamList::All) => return false,+ Some(TeamList::Teams(ids)) if ids.contains(&team) => return false,+ _ => {}+ }+ match &self.enabled_team_ids {+ Some(TeamList::All) => true,+ None => false,+ Some(TeamList::Teams(ids)) => ids.contains(&team),+ }+ }++ pub async fn filter_messages<M: RateLimitedMessage>(+ &self,+ messages: Vec<M>,+ ) -> Result<FilteredMessages<M>, RateLimiterError> {+ // Node `Map`s: a vector keeps the insertion order, and a hash index finds a team.+ let mut team_costs: Vec<(i64, f64)> = Vec::new();+ let mut cost_index: HashMap<i64, usize> = HashMap::new();+ let mut team_span: Vec<(i64, f64, f64)> = Vec::new();+ let mut span_index: HashMap<i64, usize> = HashMap::new();+ for message in &messages {+ let ts = self.timestamp_from_message(message);+ let team = message.team_id();+ match span_index.entry(team) {+ Entry::Occupied(slot) => {+ let (_, oldest, newest) = &mut team_span[*slot.get()];+ if ts < *oldest {+ *oldest = ts;+ }+ if ts > *newest {+ *newest = ts;+ }+ }+ Entry::Vacant(slot) => {+ slot.insert(team_span.len());+ team_span.push((team, ts, ts));+ }+ }+ if !self.is_enabled_for_team(team) {+ continue;+ }+ let cost = bytes_to_kb(message.bytes_uncompressed());+ match cost_index.entry(team) {+ Entry::Occupied(slot) => team_costs[*slot.get()].1 += cost,+ Entry::Vacant(slot) => {+ slot.insert(team_costs.len());+ team_costs.push((team, cost));+ }+ }+ }++ let now = self.now_seconds();+ for (_, oldest, _) in &team_span {+ histogram!("logs_rate_limiter_message_lag_seconds").record(now - oldest);+ }++ let id_costs: Vec<(String, f64, f64)> = team_costs+ .iter()+ .map(|(team, cost)| {+ let newest = span_index+ .get(team)+ .map(|&i| team_span[i].2)+ .unwrap_or_else(|| self.now_seconds());+ (team.to_string(), *cost, newest)+ })+ .collect();+ let results = self.rate_limit_many(&id_costs).await?;+ // Keyed by the number `parseInt` gives, as Node's `Map<number, ...>`; a later entry wins.+ let limits: HashMap<u64, LogsRateLimit> = results+ .into_iter()+ .map(|(id, r)| (number_key(js_parse_int(&id, Some(10))), r))+ .collect();++ let mut allowed = Vec::new();+ let mut dropped = Vec::new();+ let mut used: HashMap<i64, f64> = HashMap::new();+ for message in messages {+ let team = message.team_id();+ let Some(limit) = limits.get(&number_key(team as f64)).copied() else {+ allowed.push(message);+ continue;+ };+ let kb_used = used.get(&team).copied().unwrap_or(0.0);+ let message_kb = bytes_to_kb(message.bytes_uncompressed());+ if kb_used + message_kb <= limit.tokens_before {+ used.insert(team, kb_used + message_kb);+ allowed.push(message);+ } else {+ dropped.push(message);+ }+ }+ Ok(FilteredMessages { allowed, dropped })+ }+}++/// A `Map` key for a number: `-0` and `0` are one key, as SameValueZero treats them.+fn number_key(n: f64) -> u64 {+ if n == 0.0 {+ 0+ } else {+ n.to_bits()+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn team_settings_parse_like_parse_int() {+ assert_eq!(parse_team_id_list(""), None);+ assert_eq!(parse_team_id_list("*"), Some(TeamList::All));+ assert_eq!(+ parse_team_id_list(" 1, 2x,abc, *,-0"),+ Some(TeamList::Teams(vec![1.0, 2.0, -0.0]))+ );+ assert_eq!(+ parse_team_config("1:10, 2 : 20x,3,4:,1:11"),+ vec![(1.0, 11.0), (2.0, 20.0)]+ );+ }+}diff --git a/rust/logs-ingestion/src/rate_limiter/mod.rs b/rust/logs-ingestion/src/rate_limiter/mod.rsnew file mode 100644index 000000000000..a74ec1f1c404--- /dev/null+++ b/rust/logs-ingestion/src/rate_limiter/mod.rs@@ -0,0 +1,18 @@+//! Both implementations use the same keys, script text, argument order and time source, so consumers that share a Redis share bucket state.++pub mod keyed;+pub mod logs;+pub mod redis;++pub use keyed::{+ system_clock, Clock, KeyRoot, KeyedRateLimit, KeyedRateLimitRequest, KeyedRateLimiter,+ KeyedRateLimiterConfig, RateLimiterError, ScriptVersion,+};+pub use logs::{+ build_base_redis_key, FilteredMessages, LogsRateLimit, LogsRateLimiter, LogsRateLimiterConfig,+ RateLimitedMessage, DEFAULT_LIMITER_NAME,+};+pub use redis::{+ token_bucket_v2, token_bucket_v3, LuaScript, RedisTokenBucket, ScriptCall, ScriptReply,+ TokenBucketRedis,+};diff --git a/rust/logs-ingestion/src/rate_limiter/redis.rs b/rust/logs-ingestion/src/rate_limiter/redis.rsnew file mode 100644index 000000000000..165d28f1b5c4--- /dev/null+++ b/rust/logs-ingestion/src/rate_limiter/redis.rs@@ -0,0 +1,231 @@+//! The script text is byte-identical to the TypeScript, so both consumers load the same SHA and share bucket state.++use std::collections::HashSet;+use std::sync::{Mutex, OnceLock};++use async_trait::async_trait;+use redis::aio::ConnectionLike;+use redis::Value;++#[derive(Debug)]+pub struct LuaScript {+ pub name: &'static str,+ pub source: &'static str,+ pub sha: String,+}++pub fn token_bucket_v2() -> &'static LuaScript {+ static SCRIPT: OnceLock<LuaScript> = OnceLock::new();+ SCRIPT.get_or_init(|| script("checkRateLimitV2", include_str!("token_bucket_v2.lua")))+}++pub fn token_bucket_v3() -> &'static LuaScript {+ static SCRIPT: OnceLock<LuaScript> = OnceLock::new();+ SCRIPT.get_or_init(|| script("checkRateLimitV3", include_str!("token_bucket_v3.lua")))+}++fn script(name: &'static str, source: &'static str) -> LuaScript {+ LuaScript {+ name,+ source,+ sha: redis::Script::new(source).get_hash().to_string(),+ }+}++/// ioredis adds one decimal digit at a time in floating point, so a reply above 2^53 can round differently from a direct conversion.+pub fn ioredis_integer(n: i64) -> f64 {+ let mut number = 0f64;+ for digit in n.unsigned_abs().to_string().bytes() {+ number = number * 10.0 + (digit - b'0') as f64;+ }+ if n < 0 {+ -number+ } else {+ number+ }+}++/// `ARGV` is already written as ioredis writes numbers (`String(n)`).+#[derive(Debug, Clone, PartialEq, Eq)]+pub struct ScriptCall {+ pub key: String,+ pub args: Vec<String>,+}++pub type ScriptReply = Result<Vec<i64>, String>;++#[async_trait]+pub trait TokenBucketRedis: Send + Sync {+ /// `Err` means the whole pipeline failed, which `usePipeline({ failOpen: true })` turns into `null`.+ async fn eval_pipeline(+ &self,+ script: &LuaScript,+ calls: &[ScriptCall],+ ) -> Result<Vec<ScriptReply>, String>;+}++/// A lost script makes each call of that pipeline reply `NOSCRIPT`, a missing reply as in Node, and the next pipeline reloads it. See PORTING.md.+pub struct RedisTokenBucket<C> {+ conn: C,+ loaded: Mutex<HashSet<String>>,+}++impl<C> RedisTokenBucket<C> {+ pub fn new(conn: C) -> Self {+ RedisTokenBucket {+ conn,+ loaded: Mutex::new(HashSet::new()),+ }+ }+}++fn reply_from_value(value: Value) -> ScriptReply {+ match value {+ Value::Array(items) => items+ .into_iter()+ .map(|item| match item {+ Value::Int(n) => Ok(n),+ other => Err(format!("unexpected script reply item: {other:?}")),+ })+ .collect(),+ Value::ServerError(e) => Err(format!("{e:?}")),+ other => Err(format!("unexpected script reply: {other:?}")),+ }+}++#[async_trait]+impl<C> TokenBucketRedis for RedisTokenBucket<C>+where+ C: ConnectionLike + Clone + Send + Sync + 'static,+{+ async fn eval_pipeline(+ &self,+ script: &LuaScript,+ calls: &[ScriptCall],+ ) -> Result<Vec<ScriptReply>, String> {+ let mut conn = self.conn.clone();+ let is_loaded = self+ .loaded+ .lock()+ .map_err(|e| e.to_string())?+ .contains(&script.sha);+ if !is_loaded {+ let exists: Vec<bool> = redis::cmd("SCRIPT")+ .arg("EXISTS")+ .arg(&script.sha)+ .query_async(&mut conn)+ .await+ .map_err(|e| e.to_string())?;+ if !exists.first().copied().unwrap_or(false) {+ let _: String = redis::cmd("SCRIPT")+ .arg("LOAD")+ .arg(script.source)+ .query_async(&mut conn)+ .await+ .map_err(|e| e.to_string())?;+ }+ self.loaded+ .lock()+ .map_err(|e| e.to_string())?+ .insert(script.sha.clone());+ }+ let mut pipe = redis::pipe();+ for call in calls {+ pipe.cmd("EVALSHA")+ .arg(&script.sha)+ .arg(1)+ .arg(&call.key)+ .arg(&call.args);+ }+ let values = conn+ .req_packed_commands(&pipe, 0, calls.len())+ .await+ .map_err(|e| e.to_string())?;+ let lost_script = values+ .iter()+ .any(|value| matches!(value, Value::ServerError(e) if e.code() == "NOSCRIPT"));+ if lost_script {+ self.loaded+ .lock()+ .map_err(|e| e.to_string())?+ .remove(&script.sha);+ }+ Ok(values.into_iter().map(reply_from_value).collect())+ }+}++#[cfg(test)]+mod tests {+ use std::sync::Arc;++ use redis::{Cmd, Pipeline, RedisFuture};++ use super::*;++ #[derive(Clone, Default)]+ struct FakeRedis {+ state: Arc<Mutex<(bool, usize)>>,+ }++ impl ConnectionLike for FakeRedis {+ fn req_packed_command<'a>(&'a mut self, cmd: &'a Cmd) -> RedisFuture<'a, Value> {+ let mut state = self.state.lock().unwrap();+ let load = cmd+ .args_iter()+ .any(|arg| matches!(arg, redis::Arg::Simple(b"LOAD")));+ let reply = if load {+ *state = (true, state.1 + 1);+ Value::BulkString(token_bucket_v2().sha.clone().into_bytes())+ } else {+ Value::Array(vec![Value::Int(state.0.into())])+ };+ Box::pin(async move { Ok(reply) })+ }++ fn req_packed_commands<'a>(+ &'a mut self,+ _pipe: &'a Pipeline,+ _offset: usize,+ count: usize,+ ) -> RedisFuture<'a, Vec<Value>> {+ let loaded = self.state.lock().unwrap().0;+ let reply = if loaded {+ Value::Array(vec![Value::Int(1), Value::Int(2)])+ } else {+ redis::parse_redis_value(b"-NOSCRIPT No matching script.\r\n").unwrap()+ };+ Box::pin(async move { Ok(vec![reply; count]) })+ }++ fn get_db(&self) -> i64 {+ 0+ }+ }++ #[tokio::test]+ async fn a_lost_script_is_loaded_again_by_the_next_pipeline() {+ let redis = FakeRedis::default();+ let bucket = RedisTokenBucket::new(redis.clone());+ let calls = [ScriptCall {+ key: "k".into(),+ args: vec![],+ }];+ let ok = |replies: Vec<ScriptReply>| replies == vec![Ok(vec![1, 2])];+ assert!(ok(bucket+ .eval_pipeline(token_bucket_v2(), &calls)+ .await+ .unwrap()));+ // SCRIPT FLUSH: the pipeline that meets it gets NOSCRIPT, as the Node pipeline does.+ redis.state.lock().unwrap().0 = false;+ let lost = bucket+ .eval_pipeline(token_bucket_v2(), &calls)+ .await+ .unwrap();+ assert!(lost[0].is_err());+ assert!(ok(bucket+ .eval_pipeline(token_bucket_v2(), &calls)+ .await+ .unwrap()));+ assert_eq!(redis.state.lock().unwrap().1, 2);+ }+}diff --git a/rust/logs-ingestion/src/rate_limiter/token_bucket_v2.lua b/rust/logs-ingestion/src/rate_limiter/token_bucket_v2.luanew file mode 100644index 000000000000..277981488eaa--- /dev/null+++ b/rust/logs-ingestion/src/rate_limiter/token_bucket_v2.lua@@ -0,0 +1,72 @@++local key = KEYS[1]+local now = tonumber(ARGV[1])+local cost = tonumber(ARGV[2])+local poolMax = tonumber(ARGV[3])+local fillRate = tonumber(ARGV[4])+local expiry = ARGV[5]+local before = redis.call('hget', key, 'ts')++-- If we don't have a timestamp then we set it to now and fill up the bucket+if before == false then+ local tokensBefore = poolMax+ local tokensAfter+ local poolToStore+ if poolMax - cost >= 0 then+ tokensAfter = poolMax - cost+ poolToStore = tokensAfter+ else+ -- Don't deduct cost we couldn't afford. Public return stays -1 so+ -- callers' tokensAfter <= 0 denial check is unchanged, but we store the+ -- full bucket so an impossible-cost first call doesn't burn the credit.+ tokensAfter = -1+ poolToStore = poolMax+ end+ redis.call('hset', key, 'ts', now)+ redis.call('hset', key, 'pool', poolToStore)+ redis.call('expire', key, expiry)+ return {tokensBefore, tokensAfter}+end++-- We update the timestamp if it has changed+local timeDiffSeconds = now - before++if timeDiffSeconds > 0 then+ redis.call('hset', key, 'ts', now)+else+ timeDiffSeconds = 0+end++-- Calculate how much should be refilled in the bucket and add it+local owedTokens = timeDiffSeconds * fillRate+local currentTokens = redis.call('hget', key, 'pool')++if currentTokens == false then+ currentTokens = poolMax+end++currentTokens = currentTokens + owedTokens++-- Store tokens before cost deduction+local tokensBefore = currentTokens++-- Remove the cost and calculate tokens after; cap stored pool at poolMax so silent+-- periods do not let saved credit grow unbounded across many calls. On denial we+-- still return -1 (preserves caller-side tokensAfter <= 0 contract) but persist the+-- un-deducted balance so partial refills accumulate across calls — without this,+-- sub-2 fractional fillRates wedge at -1 forever under sustained 1 req/s traffic.+local tokensAfter+local poolToStore+if currentTokens - cost >= 0 then+ tokensAfter = math.min(currentTokens - cost, poolMax)+ poolToStore = tokensAfter+else+ tokensAfter = -1+ poolToStore = math.min(currentTokens, poolMax)+end++redis.call('hset', key, 'pool', poolToStore)+redis.call('expire', key, expiry)++-- Return both values for partial allowance calculation+return {tokensBefore, tokensAfter}diff --git a/rust/logs-ingestion/src/rate_limiter/token_bucket_v3.lua b/rust/logs-ingestion/src/rate_limiter/token_bucket_v3.luanew file mode 100644index 000000000000..dfed798a02ef--- /dev/null+++ b/rust/logs-ingestion/src/rate_limiter/token_bucket_v3.lua@@ -0,0 +1,69 @@++local key = KEYS[1]+local now = tonumber(ARGV[1])+local cost = tonumber(ARGV[2])+local poolMax = tonumber(ARGV[3])+local fillRate = tonumber(ARGV[4])+local expiry = tonumber(ARGV[5])++local existing = redis.call('hmget', key, 'ts', 'pool')+local rawBefore = existing[1]+local rawPool = existing[2]++local tokensBefore+local before+if rawBefore == false then+ before = false+ tokensBefore = poolMax+else+ before = tonumber(rawBefore)+ local timeDiffSeconds = now - before+ if timeDiffSeconds < 0 then+ timeDiffSeconds = 0+ end+ local currentTokens+ if rawPool == false then+ currentTokens = poolMax+ else+ currentTokens = tonumber(rawPool)+ end+ -- tokensBefore is the uncapped accrued credit. A catch-up call after a long+ -- silent period can therefore spend more than poolMax in one go. The cap is+ -- applied below on tokensAfter so the *stored* pool can never exceed poolMax.+ tokensBefore = currentTokens + (timeDiffSeconds * fillRate)+end++-- On overdraft, drain floor(max(0, tokensBefore)) and keep the fractional remainder+-- in the pool. Assumes per-input cost is an integer (≥1) — the fraction can never+-- satisfy one input, so we let it accumulate cross-batch instead of getting wiped+-- each call (which would starve everything under sustained overload).+local tokensAfter+local poolToStore+if tokensBefore - cost >= 0 then+ tokensAfter = math.min(tokensBefore - cost, poolMax)+ poolToStore = tokensAfter+else+ tokensAfter = -1+ local available = math.max(0, tokensBefore)+ poolToStore = math.min(tokensBefore - math.floor(available), poolMax)+end++-- Don't regress ts when now < before; otherwise advance to now.+local tsToWrite+if before ~= false and now < before then+ tsToWrite = before+else+ tsToWrite = now+end++redis.call('hset', key, 'ts', tsToWrite, 'pool', poolToStore)++-- Set TTL ceiling at (expiry * 2) on creation, then refresh when remaining+-- TTL drops below expiry/2. PTTL returns -1 (no TTL) and -2 (missing key)+-- which are both < any positive threshold, so the refresh fires defensively+-- if the TTL is ever lost.+if before == false or redis.call('pttl', key) < (expiry * 500) then+ redis.call('expire', key, expiry * 2)+end++return {tokensBefore, tokensAfter}diff --git a/rust/logs-ingestion/src/record.rs b/rust/logs-ingestion/src/record.rsnew file mode 100644index 000000000000..a0fe8cd11631--- /dev/null+++ b/rust/logs-ingestion/src/record.rs@@ -0,0 +1,182 @@+//! A stage can set a property the writer schema lacks, which later stages read and the encoder ignores, so `LogRecord` keeps it in `extra`.++use std::sync::Arc;++use crate::avro::{AvroMap, AvroValue};++#[derive(Debug, Clone, PartialEq)]+pub struct LogRecord {+ pub fields: Vec<(Arc<str>, AvroValue)>,+ pub extra: Vec<(Arc<str>, AvroValue)>,+}++impl LogRecord {+ pub fn from_value(value: AvroValue) -> Self {+ let fields = match value {+ AvroValue::Record(fields) => fields,+ _ => Vec::new(),+ };+ Self {+ fields,+ extra: Vec::new(),+ }+ }++ /// The value to encode. Extra properties are dropped, as avsc ignores them.+ pub fn into_value(self) -> AvroValue {+ AvroValue::Record(self.fields)+ }++ pub fn to_value(&self) -> AvroValue {+ AvroValue::Record(self.fields.clone())+ }++ /// `None` for a missing property (JavaScript `undefined`).+ pub fn get(&self, name: &str) -> Option<&AvroValue> {+ self.fields+ .iter()+ .chain(self.extra.iter())+ .find(|(k, _)| &**k == name)+ .map(|(_, v)| v)+ }++ pub fn get_mut(&mut self, name: &str) -> Option<&mut AvroValue> {+ if let Some(i) = self.fields.iter().position(|(k, _)| &**k == name) {+ return Some(&mut self.fields[i].1);+ }+ self.extra+ .iter_mut()+ .find(|(k, _)| &**k == name)+ .map(|(_, v)| v)+ }++ pub fn has_field(&self, name: &str) -> bool {+ self.fields.iter().any(|(k, _)| &**k == name)+ }++ pub fn set(&mut self, name: &str, value: AvroValue) {+ match self.get_mut(name) {+ Some(slot) => *slot = value,+ None => self.extra.push((Arc::from(name), value)),+ }+ }++ pub fn get_str(&self, name: &str) -> Option<&str> {+ self.get(name).and_then(AvroValue::as_str)+ }++ pub fn get_i64(&self, name: &str) -> Option<i64> {+ self.get(name).and_then(AvroValue::as_i64)+ }++ pub fn get_map(&self, name: &str) -> Option<&AvroMap> {+ self.get(name).and_then(AvroValue::as_map)+ }++ pub fn get_map_mut(&mut self, name: &str) -> Option<&mut AvroMap> {+ match self.get_mut(name) {+ Some(AvroValue::Map(m)) => Some(m),+ _ => None,+ }+ }++ pub fn get_bytes(&self, name: &str) -> Option<&[u8]> {+ self.get(name).and_then(AvroValue::as_bytes)+ }++ pub fn uuid(&self) -> Option<&str> {+ self.get_str("uuid")+ }+ pub fn trace_id(&self) -> Option<&[u8]> {+ self.get_bytes("trace_id")+ }+ pub fn span_id(&self) -> Option<&[u8]> {+ self.get_bytes("span_id")+ }+ pub fn timestamp(&self) -> Option<i64> {+ self.get_i64("timestamp")+ }+ pub fn observed_timestamp(&self) -> Option<i64> {+ self.get_i64("observed_timestamp")+ }+ pub fn body(&self) -> Option<&str> {+ self.get_str("body")+ }+ pub fn severity_text(&self) -> Option<&str> {+ self.get_str("severity_text")+ }+ pub fn severity_number(&self) -> Option<i64> {+ self.get_i64("severity_number")+ }+ pub fn service_name(&self) -> Option<&str> {+ self.get_str("service_name")+ }+ pub fn resource_attributes(&self) -> Option<&AvroMap> {+ self.get_map("resource_attributes")+ }+ pub fn instrumentation_scope(&self) -> Option<&str> {+ self.get_str("instrumentation_scope")+ }+ pub fn event_name(&self) -> Option<&str> {+ self.get_str("event_name")+ }+ pub fn attributes(&self) -> Option<&AvroMap> {+ self.get_map("attributes")+ }+ pub fn attributes_mut(&mut self) -> Option<&mut AvroMap> {+ self.get_map_mut("attributes")+ }+ pub fn bytes_uncompressed(&self) -> Option<i64> {+ self.get_i64("bytes_uncompressed")+ }+ pub fn retention_days(&self) -> Option<i64> {+ self.get_i64("retention_days")+ }+ pub fn pattern(&self) -> Option<&str> {+ self.get_str("pattern")+ }+ pub fn pattern_version(&self) -> Option<i64> {+ self.get_i64("pattern_version")+ }+ pub fn name(&self) -> Option<&str> {+ self.get_str("name")+ }+ pub fn kind(&self) -> Option<i64> {+ self.get_i64("kind")+ }+ pub fn status_code(&self) -> Option<i64> {+ self.get_i64("status_code")+ }+ /// Span end time, in microseconds.+ pub fn end_time(&self) -> Option<i64> {+ self.get_i64("end_time")+ }++ pub fn set_retention_days(&mut self, days: i64) {+ self.set("retention_days", AvroValue::Int(days));+ }+ pub fn set_pattern(&mut self, pattern: String, version: i64) {+ self.set("pattern", AvroValue::String(pattern));+ self.set("pattern_version", AvroValue::Int(version));+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn a_property_outside_the_schema_is_readable_but_not_encoded() {+ let mut record = LogRecord::from_value(AvroValue::Record(vec![(+ Arc::from("body"),+ AvroValue::String("b".into()),+ )]));+ record.set("pattern", AvroValue::String("p".into()));+ assert_eq!(record.pattern(), Some("p"));+ assert!(!record.has_field("pattern"));+ assert_eq!(+ record.into_value(),+ AvroValue::Record(vec![(Arc::from("body"), AvroValue::String("b".into()))])+ );+ }+}diff --git a/rust/logs-ingestion/src/retention/compile.rs b/rust/logs-ingestion/src/retention/compile.rsnew file mode 100644index 000000000000..d3013347c54c--- /dev/null+++ b/rust/logs-ingestion/src/retention/compile.rs@@ -0,0 +1,41 @@+use crate::js::JsValue;+use crate::property_filter::coerce::JsTypeError;+use crate::sampling::parse_filter_group;++use super::evaluate::{is_valid_retention_days, CompiledRetentionRule, CompiledRetentionRuleSet};++/// The most enabled rules compiled for one team; the fetch is ordered by priority first.+pub const MAX_ENABLED_RETENTION_RULES: usize = 100;++#[derive(Debug, Clone)]+pub struct RetentionRuleRow {+ pub id: String,+ pub config: JsValue,+ pub version: Option<i64>,+}++/// A `filter_group` with a null child makes the TypeScript throw.+pub fn compile_retention_rule_set(+ rows: &[RetentionRuleRow],+) -> Result<CompiledRetentionRuleSet, JsTypeError> {+ let mut rules = Vec::new();+ for row in rows.iter().take(MAX_ENABLED_RETENTION_RULES) {+ let JsValue::Object(config) = &row.config else {+ continue;+ };+ let Some(JsValue::Number(days)) = config.get("retention_days") else {+ continue;+ };+ if !is_valid_retention_days(*days) {+ continue;+ }+ let filter_group =+ parse_filter_group(config.get("filter_group").unwrap_or(&JsValue::Null))?;+ rules.push(CompiledRetentionRule {+ id: row.id.clone(),+ filter_group,+ retention_days: *days as i64,+ });+ }+ Ok(CompiledRetentionRuleSet { rules })+}diff --git a/rust/logs-ingestion/src/retention/evaluate.rs b/rust/logs-ingestion/src/retention/evaluate.rsnew file mode 100644index 000000000000..d35009865d2e--- /dev/null+++ b/rust/logs-ingestion/src/retention/evaluate.rs@@ -0,0 +1,63 @@+use std::sync::Arc;++use metrics::counter;++use crate::filter_group::{match_filter_group, FilterGroupNode};+use crate::property_filter::coerce::JsTypeError;+use crate::record::LogRecord;++pub const DEFAULT_RETENTION_DAYS: i64 = 14;+pub const RETENTION_MONTH_DAYS: i64 = 30;+pub const MAX_RETENTION_DAYS: i64 = RETENTION_MONTH_DAYS * 86;++pub fn is_valid_retention_days(days: f64) -> bool {+ if !days.is_finite() || days.fract() != 0.0 {+ return false;+ }+ if days == DEFAULT_RETENTION_DAYS as f64 {+ return true;+ }+ days > 0.0 && days <= MAX_RETENTION_DAYS as f64 && days % RETENTION_MONTH_DAYS as f64 == 0.0+}++#[derive(Debug, Clone)]+pub struct CompiledRetentionRule {+ pub id: String,+ pub filter_group: Option<FilterGroupNode>,+ pub retention_days: i64,+}++#[derive(Debug, Clone, Default)]+pub struct CompiledRetentionRuleSet {+ pub rules: Vec<CompiledRetentionRule>,+}++pub fn evaluate_retention_days(+ rule_set: Option<&CompiledRetentionRuleSet>,+ record: &LogRecord,+) -> Result<Option<i64>, JsTypeError> {+ let Some(rule_set) = rule_set else {+ return Ok(None);+ };+ for rule in &rule_set.rules {+ if let Some(group) = &rule.filter_group {+ if match_filter_group(group, record)? {+ return Ok(Some(rule.retention_days));+ }+ }+ }+ Ok(None)+}++pub fn safe_evaluate_retention_days(+ rule_set: Option<&CompiledRetentionRuleSet>,+ record: &LogRecord,+ team_id: i64,+) -> Option<i64> {+ evaluate_retention_days(rule_set, record).unwrap_or_else(|error| {+ let team: Arc<str> = Arc::from(team_id.to_string());+ counter!("logs_ingestion_retention_eval_error_total", "team_id" => team).increment(1);+ tracing::warn!(team_id, %error, "[logs-retention] rule evaluation threw, using the team default");+ None+ })+}diff --git a/rust/logs-ingestion/src/retention/expired.rs b/rust/logs-ingestion/src/retention/expired.rsnew file mode 100644index 000000000000..adba7592e750--- /dev/null+++ b/rust/logs-ingestion/src/retention/expired.rs@@ -0,0 +1,88 @@+use std::sync::Arc;++use async_trait::async_trait;+use metrics::counter;++use crate::content_weights::{+ BatchContext, FilterResult, FilterStage, PipelineStage, StageDropStats, StagedRecord,+};+use crate::record::LogRecord;++const MICROS_PER_DAY: f64 = 86_400_000_000.0;++pub const RETENTION_EXPIRED_STAGE_NAME: &str = "retention_expired";++fn is_past_retention(timestamp_micros: f64, retention_days: f64, now_micros: f64) -> bool {+ timestamp_micros + retention_days * MICROS_PER_DAY <= now_micros+}++pub fn can_hold_expired_row(+ min_timestamp_micros: Option<f64>,+ shortest_retention_days: f64,+ now_micros: f64,+) -> bool {+ min_timestamp_micros+ .is_some_and(|ts| is_past_retention(ts, shortest_retention_days, now_micros))+}++/// The row's `retention_days` when above 0, else the team default, as ClickHouse's `original_expiry_timestamp` does.+pub fn is_expired(record: &LogRecord, default_retention_days: f64, now_micros: f64) -> bool {+ let Some(timestamp) = record.timestamp() else {+ return false;+ };+ let row_days = record.retention_days().unwrap_or(0) as f64;+ let days = if row_days > 0.0 {+ row_days+ } else {+ default_retention_days+ };+ is_past_retention(timestamp as f64, days, now_micros)+}++struct RetentionExpiredStage {+ team_id: i64,+ default_retention_days: f64,+ now_micros: f64,+}++#[async_trait]+impl FilterStage for RetentionExpiredStage {+ fn name(&self) -> &str {+ RETENTION_EXPIRED_STAGE_NAME+ }++ async fn run(+ &self,+ records: Vec<StagedRecord>,+ batch: &BatchContext,+ ) -> anyhow::Result<FilterResult> {+ let mut stats = StageDropStats::default();+ let mut kept = Vec::with_capacity(records.len());+ for staged in records {+ if is_expired(&staged.record, self.default_retention_days, self.now_micros) {+ stats.records_dropped += 1.0;+ stats.content_bytes_dropped += batch.content_bytes_of(&staged);+ } else {+ kept.push(staged);+ }+ }+ if stats.records_dropped > 0.0 {+ let team: Arc<str> = Arc::from(self.team_id.to_string());+ counter!("logs_ingestion_retention_expired_rows_dropped_total", "team_id" => team)+ .increment(stats.records_dropped as u64);+ }+ Ok(FilterResult { kept, stats })+ }+}++pub fn make_retention_expired_stage(+ team_id: i64,+ default_retention_days: f64,+ now_micros: f64,+) -> PipelineStage {+ PipelineStage::Filter(Box::new(RetentionExpiredStage {+ team_id,+ default_retention_days,+ now_micros,+ }))+}diff --git a/rust/logs-ingestion/src/retention/mod.rs b/rust/logs-ingestion/src/retention/mod.rsnew file mode 100644index 000000000000..12795282fb98--- /dev/null+++ b/rust/logs-ingestion/src/retention/mod.rs@@ -0,0 +1,15 @@+pub mod compile;+pub mod evaluate;+pub mod expired;+pub mod stage;++pub use compile::{compile_retention_rule_set, RetentionRuleRow, MAX_ENABLED_RETENTION_RULES};+pub use evaluate::{+ evaluate_retention_days, is_valid_retention_days, safe_evaluate_retention_days,+ CompiledRetentionRule, CompiledRetentionRuleSet, DEFAULT_RETENTION_DAYS, MAX_RETENTION_DAYS,+ RETENTION_MONTH_DAYS,+};+pub use expired::{+ can_hold_expired_row, is_expired, make_retention_expired_stage, RETENTION_EXPIRED_STAGE_NAME,+};+pub use stage::{make_retention_stage, RETENTION_STAGE_NAME};diff --git a/rust/logs-ingestion/src/retention/stage.rs b/rust/logs-ingestion/src/retention/stage.rsnew file mode 100644index 000000000000..7fbde220a69f--- /dev/null+++ b/rust/logs-ingestion/src/retention/stage.rs@@ -0,0 +1,60 @@+use std::sync::Arc;++use async_trait::async_trait;+use metrics::counter;++use crate::content_weights::{MutateStage, PipelineStage, StagedRecord};++use super::evaluate::{safe_evaluate_retention_days, CompiledRetentionRuleSet};++pub const RETENTION_STAGE_NAME: &str = "retention";++struct RetentionStage {+ rule_set: Arc<CompiledRetentionRuleSet>,+ team_id: i64,+ default_retention_days: i64,+}++#[async_trait]+impl MutateStage for RetentionStage {+ fn name(&self) -> &str {+ RETENTION_STAGE_NAME+ }++ async fn run(&self, records: &mut Vec<StagedRecord>) -> anyhow::Result<()> {+ let mut matched = 0u64;+ for staged in records.iter_mut() {+ let rule_value =+ safe_evaluate_retention_days(Some(&self.rule_set), &staged.record, self.team_id);+ staged+ .record+ .set_retention_days(rule_value.unwrap_or(self.default_retention_days));+ if rule_value.is_some() {+ matched += 1;+ }+ }+ let team: Arc<str> = Arc::from(self.team_id.to_string());+ if matched > 0 {+ counter!("logs_ingestion_retention_rows_stamped_total", "team_id" => team.clone(), "matched" => "true")+ .increment(matched);+ }+ let defaulted = records.len() as u64 - matched;+ if defaulted > 0 {+ counter!("logs_ingestion_retention_rows_stamped_total", "team_id" => team, "matched" => "false")+ .increment(defaulted);+ }+ Ok(())+ }+}++pub fn make_retention_stage(+ rule_set: Arc<CompiledRetentionRuleSet>,+ team_id: i64,+ default_retention_days: i64,+) -> PipelineStage {+ PipelineStage::Mutate(Box::new(RetentionStage {+ rule_set,+ team_id,+ default_retention_days,+ }))+}diff --git a/rust/logs-ingestion/src/sampling/compile.rs b/rust/logs-ingestion/src/sampling/compile.rsnew file mode 100644index 000000000000..8202c2978d53--- /dev/null+++ b/rust/logs-ingestion/src/sampling/compile.rs@@ -0,0 +1,362 @@+//! The parsers accept any JSON shape. A null `config` or a null `filter_group` child throws in `compileRuleSet`, so both are errors here.++use std::sync::Arc;++use crate::filter_group::{FilterGroupNode, FilterNode, GroupType, MAX_FILTER_GROUP_DEPTH};++// A filter group past this depth is rejected before any value that `json_parse` did not build.+const _: () = assert!(MAX_FILTER_GROUP_DEPTH < crate::js::MAX_BUILT_DEPTH);+use crate::js::{JsString, JsValue};+use crate::property_filter::coerce::{js_trim, JsTypeError};+use crate::property_filter::re2::Re2;+use crate::property_filter::PropertyFilterLeaf;++use super::evaluate::{+ AlwaysKeep, AttributePredicate, CompiledRuleSet, CompiledSamplingRule, CostUnit, RateLimit,+ RuleType, SeverityAction,+};++pub const MAX_FILTER_GROUP_NODES: usize = 256;+/// An array value counts as its length.+pub const MAX_FILTER_GROUP_LEAF_VALUES: usize = 256;++const MAX_LOGS_PER_SECOND: f64 = 1_000_000.0;+const MAX_BURST_LOGS: f64 = 10_000_000.0;+const MAX_KB_PER_SECOND: f64 = 1_000_000.0;+const MAX_BURST_KB: f64 = 10_000_000.0;+/// Decimal KB, the unit of the drop-rule form and the API validator.+const BYTES_PER_KB: f64 = 1000.0;++#[derive(Debug, Clone)]+pub struct SamplingRuleRow {+ pub id: String,+ pub rule_type: String,+ pub scope_service: Option<String>,+ pub scope_path_pattern: Option<String>,+ pub scope_attribute_filters: JsValue,+ pub config: JsValue,+ pub version: Option<i64>,+}++/// Primitives read as `undefined`, because their properties are never these names.+fn prop<'a>(value: &'a JsValue, name: &str) -> Option<&'a JsValue> {+ match value {+ JsValue::Object(o) => o.get(name),+ _ => None,+ }+}++fn number(value: Option<&JsValue>) -> Option<f64> {+ match value {+ Some(JsValue::Number(n)) => Some(*n),+ _ => None,+ }+}++fn is_group(value: &JsValue) -> bool {+ matches!(prop(value, "values"), Some(JsValue::Array(_)))+ && matches!(prop(value, "type"), Some(JsValue::String(t)) if t == "AND" || t == "OR")+}++fn children(value: &JsValue) -> &[JsValue] {+ match prop(value, "values") {+ Some(JsValue::Array(items)) => items,+ _ => &[],+ }+}++/// Reading `.values` of a null child throws at any depth. A heap stack keeps a deep rule off the thread stack.+fn group_depth(node: &JsValue, depth: usize) -> Result<usize, JsTypeError> {+ let mut max_depth = depth;+ let mut stack = vec![(node, depth)];+ while let Some((node, depth)) = stack.pop() {+ if matches!(node, JsValue::Null) {+ return Err(JsTypeError(+ "Cannot read properties of null (reading 'values')",+ ));+ }+ max_depth = max_depth.max(depth);+ if is_group(node) {+ stack.extend(children(node).iter().map(|child| (child, depth + 1)));+ }+ }+ Ok(max_depth)+}++fn node_count(node: &JsValue) -> usize {+ if !is_group(node) {+ return 1;+ }+ 1 + children(node).iter().map(node_count).sum::<usize>()+}++fn leaf_value_count(node: &JsValue) -> usize {+ if !is_group(node) {+ return match prop(node, "value") {+ Some(JsValue::Array(items)) => items.len(),+ None | Some(JsValue::Null) => 0,+ Some(_) => 1,+ };+ }+ children(node).iter().map(leaf_value_count).sum()+}++fn to_node(node: &JsValue) -> FilterNode {+ if is_group(node) {+ FilterNode::Group(to_group(node))+ } else {+ FilterNode::Leaf(Box::new(PropertyFilterLeaf::from_json(node)))+ }+}++fn to_group(node: &JsValue) -> FilterGroupNode {+ let group_type = match prop(node, "type") {+ Some(JsValue::String(t)) if t == "OR" => GroupType::Or,+ _ => GroupType::And,+ };+ FilterGroupNode {+ group_type,+ values: children(node).iter().map(to_node).collect(),+ }+}++/// `Ok(None)` for a missing or malformed group, or one past the bounds. Pass `JsValue::Null` for `undefined`.+pub fn parse_filter_group(raw: &JsValue) -> Result<Option<FilterGroupNode>, JsTypeError> {+ if !matches!(raw, JsValue::Object(_)) || !is_group(raw) {+ return Ok(None);+ }+ let mut parsed = raw;+ if let [inner] = children(raw) {+ if matches!(inner, JsValue::Object(_)) && is_group(inner) {+ parsed = inner;+ }+ }+ if group_depth(parsed, 0)? > MAX_FILTER_GROUP_DEPTH {+ return Ok(None);+ }+ if node_count(parsed) > MAX_FILTER_GROUP_NODES {+ return Ok(None);+ }+ if leaf_value_count(parsed) > MAX_FILTER_GROUP_LEAF_VALUES {+ return Ok(None);+ }+ Ok(Some(to_group(parsed)))+}++fn parse_severity_actions(raw: &JsValue) -> [SeverityAction; 4] {+ let mut out = [SeverityAction::Keep; 4];+ if !raw.is_object_like() {+ return out;+ }+ let Some(actions) = prop(raw, "actions") else {+ return out;+ };+ if !actions.is_object_like() {+ return out;+ }+ for (i, level) in ["DEBUG", "INFO", "WARN", "ERROR"].iter().enumerate() {+ let Some(action) = prop(actions, level) else {+ continue;+ };+ let Some(JsValue::String(kind)) = prop(action, "type") else {+ continue;+ };+ out[i] = if kind == "drop" {+ SeverityAction::Drop+ } else if let (true, Some(rate)) = (kind == "sample", number(prop(action, "rate"))) {+ SeverityAction::Sample(rate.clamp(0.0, 1.0))+ } else {+ SeverityAction::Keep+ };+ }+ out+}++fn parse_rate_limit(config: &JsValue) -> Option<RateLimit> {+ let finite = |v: Option<f64>| v.filter(|n| n.is_finite());+ if let Some(kbps) = finite(number(prop(config, "kb_per_second"))) {+ if (1.0..=MAX_KB_PER_SECOND).contains(&kbps) {+ let refill_kb = kbps.floor();+ let burst_kb = match finite(number(prop(config, "burst_kb"))) {+ Some(b) if b >= refill_kb => b.floor().min(MAX_BURST_KB),+ _ => (refill_kb * 3.0).min(MAX_BURST_KB),+ };+ return Some(RateLimit {+ refill_per_second: refill_kb * BYTES_PER_KB,+ pool_max: burst_kb * BYTES_PER_KB,+ cost_unit: CostUnit::Bytes,+ });+ }+ }+ let lps = finite(number(prop(config, "logs_per_second")))?;+ if !(1.0..=MAX_LOGS_PER_SECOND).contains(&lps) {+ return None;+ }+ let refill = lps.floor();+ let pool_max = match finite(number(prop(config, "burst_logs"))) {+ Some(b) if b >= refill => b.floor().min(MAX_BURST_LOGS),+ _ => (refill * 3.0).min(MAX_BURST_LOGS),+ };+ Some(RateLimit {+ refill_per_second: refill,+ pool_max,+ cost_unit: CostUnit::Records,+ })+}++fn parse_always_keep(config: &JsValue) -> Result<Option<AlwaysKeep>, JsTypeError> {+ if matches!(config, JsValue::Null) {+ return Err(JsTypeError(+ "Cannot read properties of null (reading 'always_keep')",+ ));+ }+ let Some(ak) = prop(config, "always_keep") else {+ return Ok(None);+ };+ if !ak.is_object_like() {+ return Ok(None);+ }+ let status_gte = number(prop(ak, "status_gte"));+ let latency_ms_gt = number(prop(ak, "latency_ms_gt"));+ let mut attribute_predicates = Vec::new();+ if let Some(JsValue::Array(preds)) = prop(ak, "attribute_predicates") {+ for p in preds {+ let (Some(JsValue::String(key)), Some(JsValue::String(op))) =+ (prop(p, "key"), prop(p, "op"))+ else {+ continue;+ };+ let value = match prop(p, "value") {+ Some(JsValue::String(v)) => Some(v.clone()),+ _ => None,+ };+ attribute_predicates.push(AttributePredicate {+ key: key.clone(),+ op: op.clone(),+ value,+ });+ }+ }+ if status_gte.is_none() && latency_ms_gt.is_none() && attribute_predicates.is_empty() {+ return Ok(None);+ }+ Ok(Some(AlwaysKeep {+ status_gte,+ latency_ms_gt,+ attribute_predicates,+ }))+}++pub fn compile_rule_set(rows: &[SamplingRuleRow]) -> Result<CompiledRuleSet, JsTypeError> {+ let mut rules = Vec::with_capacity(rows.len());+ let mut has_rate_limit_rules = false;+ for row in rows {+ let path_regex = match row.scope_path_pattern.as_deref() {+ Some(p) if !p.is_empty() => {+ Some(Arc::new(Re2::without_flags(p).unwrap_or_else(|_| {+ // An invalid pattern scopes the rule to empty paths only, so it never over-scopes.+ Re2::without_flags("^$").expect("static pattern")+ })))+ }+ _ => None,+ };+ let config = &row.config;+ let mut path_drop_patterns = None;+ let mut path_drop_match_attribute_key = None;+ let mut filter_group = None;+ if row.rule_type == "path_drop" {+ if matches!(config, JsValue::Null) {+ return Err(JsTypeError(+ "Cannot read properties of null (reading 'patterns')",+ ));+ }+ let mut patterns = Vec::new();+ if let Some(JsValue::Array(items)) = prop(config, "patterns") {+ for p in items {+ if let JsValue::String(text) = p {+ if let Ok(rx) = Re2::new(text.bytes_wtf8(), "") {+ patterns.push(Arc::new(rx));+ }+ }+ }+ }+ path_drop_patterns = Some(patterns);+ if let Some(JsValue::String(key)) = prop(config, "match_attribute_key") {+ let text = key.to_utf8_lossy();+ let trimmed = js_trim(&text);+ if !trimmed.is_empty() {+ path_drop_match_attribute_key = Some(trimmed_js(key, trimmed));+ }+ }+ filter_group =+ parse_filter_group(prop(config, "filter_group").unwrap_or(&JsValue::Null))?;+ }+ let rule_type = match row.rule_type.as_str() {+ "rate_limit" => RuleType::RateLimit,+ "severity_sampling" => RuleType::SeveritySampling,+ _ => RuleType::PathDrop,+ };+ let mut rate_limit = None;+ if rule_type == RuleType::RateLimit {+ rate_limit = parse_rate_limit(config);+ if rate_limit.is_some() {+ has_rate_limit_rules = true;+ }+ filter_group =+ parse_filter_group(prop(config, "filter_group").unwrap_or(&JsValue::Null))?;+ }+ let severity_actions = parse_severity_actions(config);+ let always_keep = parse_always_keep(config)?;+ rules.push(CompiledSamplingRule {+ id: row.id.clone(),+ rule_type,+ scope_service: row.scope_service.clone(),+ path_regex,+ path_drop_patterns,+ path_drop_match_attribute_key,+ filter_group,+ severity_actions,+ always_keep,+ rate_limit,+ });+ }+ Ok(CompiledRuleSet {+ rules,+ has_rate_limit_rules,+ })+}++/// A key with a lone surrogate keeps it, so it can never equal a map key.+fn trimmed_js(original: &JsString, trimmed: &str) -> JsString {+ if original.as_str().is_some() {+ JsString::from(trimmed)+ } else {+ original.clone()+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::js::json_parse;++ // Node walks the whole tree: a deep group is rejected, and a null child at any depth throws.+ #[test]+ fn a_deep_filter_group_is_rejected_without_overflow() {+ let n = 50_000;+ let deep = |leaf: &str| {+ let open = r#"{"type":"AND","values":["#.repeat(n);+ let close = "]}".repeat(n);+ json_parse(&format!(+ r#"{{"type":"AND","values":[{open}{leaf}{close}]}}"#+ ))+ .unwrap()+ };+ assert!(matches!(+ parse_filter_group(&deep(r#"{"key":"a"}"#)),+ Ok(None)+ ));+ let shallow_null = json_parse(r#"{"type":"AND","values":[{"type":"OR","values":[null]}]}"#);+ assert!(parse_filter_group(&shallow_null.unwrap()).is_err());+ }+}diff --git a/rust/logs-ingestion/src/sampling/evaluate.rs b/rust/logs-ingestion/src/sampling/evaluate.rsnew file mode 100644index 000000000000..3ef40c2fa2a2--- /dev/null+++ b/rust/logs-ingestion/src/sampling/evaluate.rs@@ -0,0 +1,374 @@+//! `getAttribute` reads the raw JSON-encoded value, unlike the filter-group lookup, and a key that names an `Object.prototype` member reads it.++use std::sync::Arc;++use sha2::{Digest, Sha256};++use crate::filter_group::{lookup_attribute, match_filter_group, AttrLookup, FilterGroupNode};+use crate::js::JsString;+use crate::property_filter::coerce::{js_parse_float, js_parse_int, JsTypeError};+use crate::property_filter::re2::Re2;+use crate::record::LogRecord;++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum SamplingDecision {+ Keep,+ Drop,+ SampleKept,+ SampleDropped,+}++impl SamplingDecision {+ pub fn as_str(&self) -> &'static str {+ match self {+ SamplingDecision::Keep => "keep",+ SamplingDecision::Drop => "drop",+ SamplingDecision::SampleKept => "sample_kept",+ SamplingDecision::SampleDropped => "sample_dropped",+ }+ }++ pub fn drops(&self) -> bool {+ matches!(+ self,+ SamplingDecision::Drop | SamplingDecision::SampleDropped+ )+ }+}++#[derive(Debug, Clone, Copy, PartialEq)]+pub enum SeverityAction {+ Keep,+ Drop,+ Sample(f64),+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum RuleType {+ SeveritySampling,+ PathDrop,+ RateLimit,+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum CostUnit {+ Records,+ Bytes,+}++#[derive(Debug, Clone, Copy, PartialEq)]+pub struct RateLimit {+ pub refill_per_second: f64,+ pub pool_max: f64,+ pub cost_unit: CostUnit,+}++#[derive(Debug, Clone, PartialEq)]+pub struct AttributePredicate {+ pub key: JsString,+ pub op: JsString,+ pub value: Option<JsString>,+}++#[derive(Debug, Clone, PartialEq)]+pub struct AlwaysKeep {+ pub status_gte: Option<f64>,+ pub latency_ms_gt: Option<f64>,+ pub attribute_predicates: Vec<AttributePredicate>,+}++#[derive(Debug, Clone)]+pub struct CompiledSamplingRule {+ pub id: String,+ pub rule_type: RuleType,+ pub scope_service: Option<String>,+ pub path_regex: Option<Arc<Re2>>,+ pub path_drop_patterns: Option<Vec<Arc<Re2>>>,+ pub path_drop_match_attribute_key: Option<JsString>,+ pub filter_group: Option<FilterGroupNode>,+ pub severity_actions: [SeverityAction; 4],+ pub always_keep: Option<AlwaysKeep>,+ pub rate_limit: Option<RateLimit>,+}++#[derive(Debug, Clone, Default)]+pub struct CompiledRuleSet {+ pub rules: Vec<CompiledSamplingRule>,+ pub has_rate_limit_rules: bool,+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub struct EvaluateResult {+ pub decision: SamplingDecision,+ pub rule_id: Option<String>,+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub enum SamplingClassifyResult {+ Resolved {+ decision: SamplingDecision,+ rule_id: Option<String>,+ },+ RateLimit {+ rule_id: String,+ },+}++const SEV_ORD_DEBUG: usize = 0;+const SEV_ORD_INFO: usize = 1;+const SEV_ORD_WARN: usize = 2;+const SEV_ORD_ERROR: usize = 3;++pub fn severity_ordinal_from_record(record: &LogRecord) -> usize {+ let text = record.severity_text().unwrap_or("").to_lowercase();+ match text.as_str() {+ "trace" | "debug" => return SEV_ORD_DEBUG,+ "info" => return SEV_ORD_INFO,+ "warn" | "warning" => return SEV_ORD_WARN,+ "error" | "fatal" => return SEV_ORD_ERROR,+ _ => {}+ }+ match record.severity_number() {+ None => SEV_ORD_INFO,+ Some(n) if n >= 17 => SEV_ORD_ERROR,+ Some(n) if n >= 13 => SEV_ORD_WARN,+ Some(n) if n >= 9 => SEV_ORD_INFO,+ Some(_) => SEV_ORD_DEBUG,+ }+}++/// With no trace id Node uses `Math.random()`, which no vector can pin, so this uses `rand` and tests check only its range.+pub fn hash01_from_trace_id(trace_id: Option<&[u8]>) -> f64 {+ match trace_id {+ Some(id) if !id.is_empty() => {+ let digest = Sha256::digest(id);+ let n = u32::from_be_bytes([digest[0], digest[1], digest[2], digest[3]]);+ n as f64 / 0xffff_ffffu32 as f64+ }+ _ => rand::random::<f64>(),+ }+}++fn get_attribute<'a>(record: &'a LogRecord, key: &str) -> Option<AttrLookup<'a>> {+ lookup_attribute(record.attributes()?, key)+}++/// A key with a lone surrogate finds nothing.+fn get_attribute_js<'a>(record: &'a LogRecord, key: &JsString) -> Option<AttrLookup<'a>> {+ get_attribute(record, key.as_str()?)+}++fn truthy<'a>(v: Option<AttrLookup<'a>>) -> Option<AttrLookup<'a>> {+ v.filter(|a| !matches!(a, AttrLookup::Own("")))+}++fn path_for_matching(record: &LogRecord) -> &str {+ for key in ["url.path", "http.path", "http.route", "path"] {+ if let Some(v) = truthy(get_attribute(record, key)) {+ return match v {+ AttrLookup::Own(s) => s,+ AttrLookup::Inherited(m) => m.text,+ };+ }+ }+ ""+}++fn always_keep_matches(rule: &CompiledSamplingRule, record: &LogRecord) -> bool {+ let Some(ak) = &rule.always_keep else {+ return false;+ };+ if let Some(status_gte) = ak.status_gte {+ let code_str = truthy(get_attribute(record, "http.status_code"))+ .or_else(|| truthy(get_attribute(record, "http.response.status_code")));+ let code = code_str.map_or(f64::NAN, |s| js_parse_int(s.text(), Some(10)));+ if !code.is_nan() && code >= status_gte {+ return true;+ }+ }+ if let Some(latency_ms_gt) = ak.latency_ms_gt {+ let lat_str = truthy(get_attribute(record, "http.server.duration_ms"))+ .or_else(|| truthy(get_attribute(record, "duration_ms")));+ let lat = lat_str.map_or(f64::NAN, |s| js_parse_float(&JsString::from(s.text())));+ if !lat.is_nan() && lat > latency_ms_gt {+ return true;+ }+ }+ for p in &ak.attribute_predicates {+ let v = get_attribute_js(record, &p.key);+ let op = p.op.as_str();+ if op == Some("exists") && v.is_some() {+ return true;+ }+ if let Some(value) = &p.value {+ let equals = matches!(v, Some(AttrLookup::Own(s)) if value == s);+ if op == Some("eq") && equals {+ return true;+ }+ if op == Some("ne") && v.is_some() && !equals {+ return true;+ }+ }+ }+ false+}++fn path_drop_matches(rule: &CompiledSamplingRule, record: &LogRecord) -> Result<bool, JsTypeError> {+ if let Some(patterns) = rule.path_drop_patterns.as_ref().filter(|p| !p.is_empty()) {+ let path = match &rule.path_drop_match_attribute_key {+ Some(key) => get_attribute_js(record, key).map_or("", |v| match v {+ AttrLookup::Own(s) => s,+ AttrLookup::Inherited(m) => m.text,+ }),+ None => path_for_matching(record),+ };+ if patterns.iter().any(|rx| rx.test(path)) {+ return Ok(true);+ }+ }+ if let Some(group) = &rule.filter_group {+ if match_filter_group(group, record)? {+ return Ok(true);+ }+ }+ Ok(false)+}++fn matches_scope(rule: &CompiledSamplingRule, record: &LogRecord) -> bool {+ if let Some(scope) = rule.scope_service.as_deref().filter(|s| !s.is_empty()) {+ if record.service_name().unwrap_or("") != scope {+ return false;+ }+ }+ if let Some(rx) = &rule.path_regex {+ if !rx.test(path_for_matching(record)) {+ return false;+ }+ }+ true+}++fn severity_decision(action: SeverityAction, record: &LogRecord) -> SamplingDecision {+ match action {+ SeverityAction::Keep => SamplingDecision::Keep,+ SeverityAction::Drop => SamplingDecision::Drop,+ SeverityAction::Sample(rate) => {+ if hash01_from_trace_id(record.trace_id()) < rate {+ SamplingDecision::SampleKept+ } else {+ SamplingDecision::SampleDropped+ }+ }+ }+}++/// Deterministic rules win over `rate_limit` in any order. The first applicable `rate_limit` applies only when none resolves the record.+pub fn classify_sampling_record(+ rule_set: Option<&CompiledRuleSet>,+ record: &LogRecord,+) -> Result<SamplingClassifyResult, JsTypeError> {+ let resolved = |decision, rule_id: Option<&str>| SamplingClassifyResult::Resolved {+ decision,+ rule_id: rule_id.map(str::to_string),+ };+ let Some(rule_set) = rule_set.filter(|r| !r.rules.is_empty()) else {+ return Ok(resolved(SamplingDecision::Keep, None));+ };+ let ord = severity_ordinal_from_record(record);+ let mut pending_rate_limit: Option<&str> = None;+ for rule in &rule_set.rules {+ if !matches_scope(rule, record) {+ continue;+ }+ if always_keep_matches(rule, record) {+ return Ok(resolved(SamplingDecision::Keep, Some(&rule.id)));+ }+ match rule.rule_type {+ RuleType::PathDrop => {+ if path_drop_matches(rule, record)? {+ return Ok(resolved(SamplingDecision::Drop, Some(&rule.id)));+ }+ }+ RuleType::SeveritySampling => {+ let decision = severity_decision(rule.severity_actions[ord], record);+ return Ok(resolved(decision, Some(&rule.id)));+ }+ RuleType::RateLimit => {+ if rule.rate_limit.is_none() {+ continue;+ }+ if let Some(group) = &rule.filter_group {+ if !match_filter_group(group, record)? {+ continue;+ }+ }+ if pending_rate_limit.is_none() {+ pending_rate_limit = Some(&rule.id);+ }+ }+ }+ }+ Ok(match pending_rate_limit {+ Some(id) => SamplingClassifyResult::RateLimit {+ rule_id: id.to_string(),+ },+ None => resolved(SamplingDecision::Keep, None),+ })+}++pub fn evaluate_log_record(+ rule_set: Option<&CompiledRuleSet>,+ record: &LogRecord,+) -> Result<EvaluateResult, JsTypeError> {+ let result = |decision, rule_id: Option<&str>| EvaluateResult {+ decision,+ rule_id: rule_id.map(str::to_string),+ };+ let Some(rule_set) = rule_set.filter(|r| !r.rules.is_empty()) else {+ return Ok(result(SamplingDecision::Keep, None));+ };+ let ord = severity_ordinal_from_record(record);+ for rule in &rule_set.rules {+ if !matches_scope(rule, record) {+ continue;+ }+ if always_keep_matches(rule, record) {+ return Ok(result(SamplingDecision::Keep, Some(&rule.id)));+ }+ match rule.rule_type {+ RuleType::PathDrop => {+ if path_drop_matches(rule, record)? {+ return Ok(result(SamplingDecision::Drop, Some(&rule.id)));+ }+ }+ RuleType::SeveritySampling => {+ let decision = severity_decision(rule.severity_actions[ord], record);+ return Ok(result(decision, Some(&rule.id)));+ }+ RuleType::RateLimit => {}+ }+ }+ Ok(result(SamplingDecision::Keep, None))+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn hash_without_a_trace_id_is_random_in_range() {+ for _ in 0..100 {+ let u = hash01_from_trace_id(None);+ assert!((0.0..1.0).contains(&u));+ }+ assert!(hash01_from_trace_id(Some(&[])) >= 0.0);+ }++ #[test]+ fn hash_of_a_trace_id_reads_the_digest_prefix() {+ let digest = Sha256::digest(b"x");+ let expected =+ u32::from_be_bytes([digest[0], digest[1], digest[2], digest[3]]) as f64 / 4294967295.0;+ assert_eq!(hash01_from_trace_id(Some(b"x")), expected);+ }+}diff --git a/rust/logs-ingestion/src/sampling/mod.rs b/rust/logs-ingestion/src/sampling/mod.rsnew file mode 100644index 000000000000..a8d48b907ee5--- /dev/null+++ b/rust/logs-ingestion/src/sampling/mod.rs@@ -0,0 +1,15 @@+pub mod compile;+pub mod evaluate;+pub mod service;++pub use compile::{+ compile_rule_set, parse_filter_group, SamplingRuleRow, MAX_FILTER_GROUP_LEAF_VALUES,+ MAX_FILTER_GROUP_NODES,+};+pub use evaluate::{+ classify_sampling_record, evaluate_log_record, hash01_from_trace_id,+ severity_ordinal_from_record, AlwaysKeep, AttributePredicate, CompiledRuleSet,+ CompiledSamplingRule, CostUnit, EvaluateResult, RateLimit, RuleType, SamplingClassifyResult,+ SamplingDecision, SeverityAction,+};+pub use service::{LogsSamplingService, SAMPLING_RATE_LIMITER_NAME, SAMPLING_STAGE_NAME};diff --git a/rust/logs-ingestion/src/sampling/service.rs b/rust/logs-ingestion/src/sampling/service.rsnew file mode 100644index 000000000000..0a2492bb6d07--- /dev/null+++ b/rust/logs-ingestion/src/sampling/service.rs@@ -0,0 +1,280 @@+use std::sync::Arc;++use async_trait::async_trait;+use metrics::counter;++use crate::content_weights::{+ BatchContext, FilterResult, FilterStage, PipelineStage, StageDropStats, StagedRecord,+};+use crate::rate_limiter::{+ Clock, KeyRoot, KeyedRateLimitRequest, KeyedRateLimiter, KeyedRateLimiterConfig, ScriptVersion,+ TokenBucketRedis,+};+use crate::record::LogRecord;++use super::evaluate::{+ classify_sampling_record, evaluate_log_record, CompiledRuleSet, CostUnit, EvaluateResult,+ SamplingClassifyResult, SamplingDecision,+};++pub const SAMPLING_STAGE_NAME: &str = "sampling";+pub const SAMPLING_RATE_LIMITER_NAME: &str = "logs-sampling-rate";++fn record_bytes(record: &LogRecord) -> f64 {+ record.bytes_uncompressed().map_or(0.0, |n| n as f64)+}++fn count_eval_error(team_id: i64, phase: &'static str, error: &dyn std::fmt::Display) {+ let team: Arc<str> = Arc::from(team_id.to_string());+ counter!("logs_ingestion_sampling_eval_error_total", "team_id" => team, "phase" => phase)+ .increment(1);+ tracing::warn!(team_id, %error, "[logs-sampling] rule evaluation threw, keeping record");+}++/// An evaluation error keeps the record.+fn safe_classify(+ rule_set: &CompiledRuleSet,+ record: &LogRecord,+ team_id: i64,+) -> SamplingClassifyResult {+ classify_sampling_record(Some(rule_set), record).unwrap_or_else(|e| {+ count_eval_error(team_id, "classify", &e);+ SamplingClassifyResult::Resolved {+ decision: SamplingDecision::Keep,+ rule_id: None,+ }+ })+}++fn safe_evaluate(rule_set: &CompiledRuleSet, record: &LogRecord, team_id: i64) -> EvaluateResult {+ evaluate_log_record(Some(rule_set), record).unwrap_or_else(|e| {+ count_eval_error(team_id, "evaluate", &e);+ EvaluateResult {+ decision: SamplingDecision::Keep,+ rule_id: None,+ }+ })+}++pub struct LogsSamplingService {+ rate_limiter: KeyedRateLimiter,+}++impl LogsSamplingService {+ pub fn new(+ redis: Arc<dyn TokenBucketRedis>,+ ttl_seconds: f64,+ key_root: KeyRoot,+ clock: Clock,+ ) -> Self {+ let mut config = KeyedRateLimiterConfig::new(SAMPLING_RATE_LIMITER_NAME, key_root);+ config.ttl_seconds = Some(ttl_seconds);+ config.script_version = ScriptVersion::V3;+ LogsSamplingService {+ rate_limiter: KeyedRateLimiter::with_clock(config, redis, clock),+ }+ }++ pub async fn sample_records(+ &self,+ records: Vec<StagedRecord>,+ rule_set: &CompiledRuleSet,+ batch: &BatchContext,+ team_id: Option<i64>,+ header_bytes_uncompressed: f64,+ ) -> anyhow::Result<FilterResult> {+ let mut kept = Vec::with_capacity(records.len());+ let mut stats = StageDropStats::default();+ let drop = |stats: &mut StageDropStats, staged: &StagedRecord, rule_id: Option<&str>| {+ let rb = record_bytes(&staged.record);+ stats.records_dropped += 1.0;+ stats.bytes_dropped += rb;+ stats.content_bytes_dropped += batch.content_bytes_of(staged);+ if let Some(id) = rule_id {+ stats.records_dropped_by_rule_id.add(id, 1.0);+ stats.bytes_dropped_by_rule_id.add(id, rb);+ }+ };++ match team_id.filter(|_| rule_set.has_rate_limit_rules) {+ Some(team_id) => {+ let classifications: Vec<SamplingClassifyResult> = records+ .iter()+ .map(|r| safe_classify(rule_set, &r.record, team_id))+ .collect();+ let mut pending: Vec<(String, Vec<usize>)> = Vec::new();+ for (i, c) in classifications.iter().enumerate() {+ if let SamplingClassifyResult::RateLimit { rule_id } = c {+ match pending.iter_mut().find(|(id, _)| id == rule_id) {+ Some((_, list)) => list.push(i),+ None => pending.push((rule_id.clone(), vec![i])),+ }+ }+ }+ let rate_keep = self+ .apply_rate_limits(+ team_id,+ rule_set,+ &pending,+ &records,+ header_bytes_uncompressed,+ batch,+ )+ .await?;+ for (i, (staged, c)) in records.into_iter().zip(classifications).enumerate() {+ match c {+ SamplingClassifyResult::RateLimit { rule_id } => {+ if rate_keep[i] == Some(false) {+ drop(&mut stats, &staged, Some(&rule_id));+ continue;+ }+ kept.push(staged);+ }+ SamplingClassifyResult::Resolved { decision, rule_id } => {+ if decision.drops() {+ drop(&mut stats, &staged, rule_id.as_deref());+ continue;+ }+ kept.push(staged);+ }+ }+ }+ }+ None => {+ for staged in records {+ let result = safe_evaluate(rule_set, &staged.record, team_id.unwrap_or(0));+ if result.decision.drops() {+ drop(&mut stats, &staged, result.rule_id.as_deref());+ continue;+ }+ kept.push(staged);+ }+ }+ }+ Ok(FilterResult { kept, stats })+ }++ /// `None` means no decision, and the record is kept.+ async fn apply_rate_limits(+ &self,+ team_id: i64,+ rule_set: &CompiledRuleSet,+ pending: &[(String, Vec<usize>)],+ records: &[StagedRecord],+ header_bytes_uncompressed: f64,+ batch: &BatchContext,+ ) -> anyhow::Result<Vec<Option<bool>>> {+ let mut keep: Vec<Option<bool>> = vec![None; records.len()];+ if pending.is_empty() {+ return Ok(keep);+ }+ let pro_rata_scale = if header_bytes_uncompressed > 0.0 && batch.content_bytes_total > 0.0 {+ header_bytes_uncompressed / batch.content_bytes_total+ } else {+ 0.0+ };+ let byte_cost = |idx: usize| -> f64 {+ if pro_rata_scale > 0.0 {+ batch.content_bytes_of(&records[idx]) * pro_rata_scale+ } else {+ record_bytes(&records[idx].record)+ }+ };+ // `new Map(rules.map(r => [r.id, r]))`: the last rule with an id wins.+ let rule_by_id = |id: &str| rule_set.rules.iter().rev().find(|r| r.id == id);++ let mut entries: Vec<(&[usize], Vec<f64>)> = Vec::new();+ let mut requests: Vec<KeyedRateLimitRequest> = Vec::new();+ for (rule_id, indices) in pending {+ let Some(rl) = rule_by_id(rule_id).and_then(|r| r.rate_limit) else {+ continue;+ };+ if indices.is_empty() {+ continue;+ }+ let costs: Vec<f64> = match rl.cost_unit {+ CostUnit::Bytes => indices.iter().map(|&i| byte_cost(i)).collect(),+ CostUnit::Records => vec![1.0; indices.len()],+ };+ let total_cost = costs.iter().fold(0.0, |a, b| a + b);+ requests.push(KeyedRateLimitRequest {+ id: format!("{team_id}/{rule_id}"),+ cost: total_cost,+ bucket_size: Some(rl.pool_max),+ refill_rate: Some(rl.refill_per_second),+ ttl_seconds: None,+ now: None,+ });+ entries.push((indices, costs));+ }++ if entries.is_empty() {+ for (_, indices) in pending {+ for &i in indices {+ keep[i] = Some(true);+ }+ }+ return Ok(keep);+ }++ let results = self.rate_limiter.rate_limit_many(&requests).await?;+ for (i, (indices, costs)) in entries.iter().enumerate() {+ let tokens_before = results.get(i).map_or(0.0, |(_, r)| r.tokens_before);+ let budget = tokens_before.floor().max(0.0);+ let mut spent = 0.0;+ for (j, &idx) in indices.iter().enumerate() {+ let next = spent + costs[j];+ let admit = next <= budget;+ keep[idx] = Some(admit);+ if admit {+ spent = next;+ }+ }+ }+ Ok(keep)+ }++ pub fn make_sampling_stage(+ self: &Arc<Self>,+ rule_set: Arc<CompiledRuleSet>,+ team_id: Option<i64>,+ header_bytes_uncompressed: f64,+ ) -> PipelineStage {+ PipelineStage::Filter(Box::new(SamplingStage {+ service: self.clone(),+ rule_set,+ team_id,+ header_bytes_uncompressed,+ }))+ }+}++struct SamplingStage {+ service: Arc<LogsSamplingService>,+ rule_set: Arc<CompiledRuleSet>,+ team_id: Option<i64>,+ header_bytes_uncompressed: f64,+}++#[async_trait]+impl FilterStage for SamplingStage {+ fn name(&self) -> &str {+ SAMPLING_STAGE_NAME+ }++ async fn run(+ &self,+ records: Vec<StagedRecord>,+ batch: &BatchContext,+ ) -> anyhow::Result<FilterResult> {+ self.service+ .sample_records(+ records,+ &self.rule_set,+ batch,+ self.team_id,+ self.header_bytes_uncompressed,+ )+ .await+ }+}diff --git a/rust/logs-ingestion/tests/avro_parity.rs b/rust/logs-ingestion/tests/avro_parity.rsnew file mode 100644index 000000000000..f3443aee6fad--- /dev/null+++ b/rust/logs-ingestion/tests/avro_parity.rs@@ -0,0 +1,306 @@+//! Compares with avsc's decodes in `tests/fixtures/input-decodes.json`, from `scripts/node-decode-reference.js`.++mod common;++use base64::Engine;+use common::{array, canonical_text, get, load_json, repo_path, scenarios_dir, string, try_get};+use logs_ingestion::avro::{decode_container, encode_container, Schema};+use logs_ingestion::js::{json_parse, json_stringify, JsValue};+use sha2::{Digest, Sha256};++fn sha256_hex(text: &str) -> String {+ Sha256::digest(text.as_bytes())+ .iter()+ .map(|b| format!("{b:02x}"))+ .collect()+}++fn check(label: &str, bytes: &[u8], expected: &JsValue) {+ let result = decode_container(bytes);+ match try_get(expected, "error") {+ Some(error) => {+ let err = result+ .err()+ .unwrap_or_else(|| panic!("{label}: expected error {error:?}"));+ assert_eq!(err.to_string(), string(error), "{label}");+ }+ None => {+ let container = result.unwrap_or_else(|e| panic!("{label}: {e}"));+ assert_eq!(container.codec, string(get(expected, "codec")), "{label}");+ assert_eq!(+ container.records.len() as f64,+ match get(expected, "count") {+ JsValue::Number(n) => *n,+ _ => panic!(),+ },+ "{label}"+ );+ assert_eq!(+ sha256_hex(&canonical_text(&container.records)),+ string(get(expected, "sha256")),+ "{label}: canonical records differ"+ );+ let encoded =+ encode_container(&container.schema, "zstandard", &container.records).unwrap();+ let again = decode_container(&encoded).unwrap();+ assert_eq!(again.records, container.records, "{label}: round trip");+ }+ }+}++fn reference() -> JsValue {+ load_json(&repo_path(+ "rust/logs-ingestion/tests/fixtures/input-decodes.json",+ ))+}++#[test]+fn corpus_inputs_decode_like_avsc() {+ let reference = reference();+ let mut checked = 0;+ for entry in std::fs::read_dir(scenarios_dir()).unwrap() {+ let path = entry.unwrap().path();+ let file = path.file_name().unwrap().to_string_lossy().to_string();+ let fixture = load_json(&path);+ let expected = array(get(&reference, &file));+ let messages: Vec<&JsValue> = array(get(get(&fixture, "scenario"), "batches"))+ .iter()+ .flat_map(|b| array(b).iter())+ .collect();+ assert_eq!(+ messages.len(),+ expected.len(),+ "{file}: rerun the reference script"+ );+ for (i, (message, expected)) in messages.iter().zip(expected).enumerate() {+ let JsValue::String(b64) = get(message, "value_b64") else {+ continue;+ };+ let bytes = base64::engine::general_purpose::STANDARD+ .decode(b64.to_string())+ .unwrap();+ check(&format!("{file}[{i}]"), &bytes, expected);+ checked += 1;+ }+ }+ assert!(checked > 300, "only {checked} inputs");+}++#[test]+fn edge_containers_decode_like_avsc() {+ let reference = reference();+ let edges = array(get(&reference, "edges"));+ assert!(edges.len() >= 15);+ for edge in edges {+ let name = string(get(edge, "name"));+ let bytes = base64::engine::general_purpose::STANDARD+ .decode(string(get(edge, "value_b64")))+ .unwrap();+ check(&name, &bytes, get(edge, "result"));+ }+}++fn as_serde(value: &JsValue) -> serde_json::Value {+ serde_json::from_str(&json_stringify(value)).unwrap()+}++/// The production schema files have the logical types and the record doc first, as capture-logs writes them.+#[test]+fn schema_export_matches_avsc_for_the_production_schemas() {+ let mut expected_by_name = std::collections::HashMap::new();+ for entry in std::fs::read_dir(scenarios_dir()).unwrap() {+ let fixture = load_json(&entry.unwrap().path());+ for output in array(get(get(&fixture, "expected"), "outputs")) {+ let value = get(output, "value");+ if string(get(value, "kind")) == "avro" {+ let schema = get(value, "schema");+ expected_by_name.insert(string(get(schema, "name")), as_serde(schema));+ }+ }+ }+ for name in ["logs", "traces"] {+ let path = repo_path(&format!(+ "nodejs/src/logs/parity/fixtures/schemas/{name}.avsc.json"+ ));+ let text = std::fs::read_to_string(path).unwrap();+ let schema = Schema::parse_json(&text).unwrap();+ let exported: serde_json::Value = serde_json::from_str(&schema.to_avsc_json()).unwrap();+ let record_name = exported["name"].as_str().unwrap().to_string();+ assert_eq!(+ Some(&exported),+ expected_by_name.get(&record_name),+ "{name}: exported schema differs from what avsc wrote"+ );+ let again = Schema::parse_json(&schema.to_avsc_json())+ .unwrap()+ .to_avsc_json();+ assert_eq!(again, schema.to_avsc_json());+ let _ = json_parse(&again).unwrap();+ }+}++#[test]+fn a_deep_chain_of_named_records_is_rejected_without_overflow() {+ let mut branches =+ vec![r#"{"type":"record","name":"R0","fields":[{"name":"f","type":"int"}]}"#.to_string()];+ for i in 1..20_000 {+ branches.push(format!(+ r#"{{"type":"record","name":"R{i}","fields":[{{"name":"f","type":"R{}"}}]}}"#,+ i - 1+ ));+ }+ assert!(Schema::parse_json(&format!("[{}]", branches.join(","))).is_err());++ // Each redefinition of `R` refers to the previous one, so the chain still grows.+ let mut redefined = vec![r#"{"type":"record","name":"R","fields":[]}"#.to_string()];+ redefined.extend(std::iter::repeat_n(+ r#"{"type":"record","name":"R","fields":[{"name":"a","type":"R"},{"name":"b","type":{"type":"record","name":"R","fields":[]}}]}"#.to_string(),+ 20_000,+ ));+ assert!(Schema::parse_json(&format!("[{}]", redefined.join(","))).is_err());+}++#[test]+fn decode_never_panics_on_corrupt_containers() {+ let schema = Schema::parse_json(+ r#"{"type":"record","name":"R","fields":[+ {"name":"s","type":["null","string"]},{"name":"b","type":"bytes"},+ {"name":"l","type":"long"},{"name":"i","type":"int"},+ {"name":"m","type":{"type":"map","values":"string"}},+ {"name":"a","type":{"type":"array","items":"long"}},+ {"name":"e","type":{"type":"enum","name":"E","symbols":["x","y"]}},+ {"name":"f","type":{"type":"fixed","name":"F","size":4}},+ {"name":"d","type":"double"},{"name":"g","type":"float"}]}"#,+ )+ .unwrap();+ let mut state = 0x9e37_79b9_7f4a_7c15u64;+ let mut next = move || {+ state ^= state << 13;+ state ^= state >> 7;+ state ^= state << 17;+ state+ };+ let valid = encode_container(&schema, "zstandard", &[]).unwrap();+ // Varints that overflow 2^53 and 2^64, and two past the 10 bytes that avsc reads.+ let huge: [&[u8]; 4] = [+ &[0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x20],+ &[0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f],+ &[0xff; 160],+ &[[0x80; 150].as_slice(), &[0]].concat(),+ ];+ for i in 0..4000 {+ let mut payload = Vec::new();+ for _ in 0..next() % 64 {+ match next() % 4 {+ 0 => payload.extend_from_slice(huge[(next() % 4) as usize]),+ 1 => payload.push((next() % 256) as u8),+ _ => payload.extend_from_slice(&[0x02, (next() % 4) as u8 * 2]),+ }+ }+ let block = zstd::stream::encode_all(payload.as_slice(), 1).unwrap();+ let mut bytes = valid.clone();+ let sync = valid[valid.len() - 16..].to_vec();+ let count = huge[(next() % 4) as usize];+ bytes.extend_from_slice(if i % 3 == 0 { count } else { &[0x02] });+ bytes.extend_from_slice(&encode_long(block.len() as i64));+ bytes.extend_from_slice(&block);+ bytes.extend_from_slice(&sync);+ for _ in 0..next() % 3 {+ let at = (next() as usize) % bytes.len();+ bytes[at] ^= 1 << (next() % 8);+ }+ if i % 5 == 0 {+ bytes.truncate((next() as usize) % (bytes.len() + 1));+ }+ let result = std::panic::catch_unwind(|| decode_container(&bytes));+ assert!(result.is_ok(), "panic on case {i}");+ }+}++fn encode_long(n: i64) -> Vec<u8> {+ let mut z = ((n << 1) ^ (n >> 63)) as u64;+ let mut out = Vec::new();+ while z >= 0x80 {+ out.push((z as u8) | 0x80);+ z >>= 7;+ }+ out.push(z as u8);+ out+}++fn zstd_container(schema: &[u8], blocks: &[(i64, Vec<u8>)]) -> Vec<u8> {+ let sync = [7u8; 16];+ let mut buf = b"Obj\x01".to_vec();+ buf.extend(encode_long(2));+ for (key, value) in [(&b"avro.schema"[..], schema), (b"avro.codec", b"zstandard")] {+ buf.extend(encode_long(key.len() as i64));+ buf.extend_from_slice(key);+ buf.extend(encode_long(value.len() as i64));+ buf.extend_from_slice(value);+ }+ buf.push(0);+ buf.extend_from_slice(&sync);+ for (count, data) in blocks {+ buf.extend(encode_long(*count));+ buf.extend(encode_long(data.len() as i64));+ buf.extend_from_slice(data);+ buf.extend_from_slice(&sync);+ }+ buf+}++const STRING_RECORD: &[u8] =+ br#"{"type":"record","name":"R","fields":[{"name":"a","type":"string"}]}"#;++#[test]+fn block_counts_do_not_drive_allocation_before_decompression() {+ // About 1 MB of blocks that each claim 4096 records would reserve ~20 GB if counts were trusted.+ let blocks = vec![(4096, Vec::new()); 60_000];+ assert!(decode_container(&zstd_container(STRING_RECORD, &blocks)).is_err());+}++#[test]+fn empty_array_items_share_one_budget_per_container() {+ let schema = br#"{"type":"record","name":"R","fields":[{"name":"a","type":{"type":"array","items":"null"}}]}"#;+ let record = |items: i64| [encode_long(items), encode_long(0)].concat();+ let block = |items: i64| (1, zstd::bulk::compress(&record(items), 1).unwrap());+ assert!(decode_container(&zstd_container(schema, &[block(1000)])).is_ok());+ // Four bytes declare four billion items.+ assert!(decode_container(&zstd_container(schema, &[block(4_000_000_000)])).is_err());+ // Each block stays under the cap, and the two together pass it.+ assert!(decode_container(&zstd_container(schema, &[block(600_000), block(600_000)])).is_err());+}++#[test]+fn zstd_frames_above_the_default_window_limit_are_rejected() {+ let mut records = Vec::new();+ for i in 0..300 {+ let value = format!("{i:04}").repeat(250);+ records.extend(encode_long(value.len() as i64));+ records.extend_from_slice(value.as_bytes());+ }+ let frame = zstd::bulk::compress(&records, 1).unwrap();+ // Rewrite the single-segment header as a windowed one that declares a 2^28 window.+ let descriptor = frame[4];+ assert_eq!(+ descriptor & 0x23,+ 0x20,+ "expected a single-segment frame without a dictionary"+ );+ let content_size: u64 = match descriptor >> 6 {+ 1 => u64::from(u16::from_le_bytes([frame[5], frame[6]])) + 256,+ 2 => u64::from(u32::from_le_bytes(frame[5..9].try_into().unwrap())),+ other => panic!("unexpected content size flag {other}"),+ };+ let header_len = 5 + if descriptor >> 6 == 1 { 2 } else { 4 };+ let mut windowed = frame[..4].to_vec();+ windowed.push((2 << 6) | (descriptor & 0x04));+ windowed.push((28 - 10) << 3);+ windowed.extend_from_slice(&(content_size as u32).to_le_bytes());+ windowed.extend_from_slice(&frame[header_len..]);++ let accepted = zstd_container(STRING_RECORD, &[(300, frame)]);+ assert_eq!(decode_container(&accepted).unwrap().records.len(), 300);+ let rejected = zstd_container(STRING_RECORD, &[(300, windowed)]);+ assert!(decode_container(&rejected).is_err());+}diff --git a/rust/logs-ingestion/tests/common/mod.rs b/rust/logs-ingestion/tests/common/mod.rsnew file mode 100644index 000000000000..0d7cdf1b27c7--- /dev/null+++ b/rust/logs-ingestion/tests/common/mod.rs@@ -0,0 +1,110 @@+//! Fixtures are read with the crate's `json_parse`, because Node writes lone surrogates as `\udXXX`, which serde_json rejects.+#![allow(dead_code)]++use std::cmp::Ordering;+use std::path::PathBuf;++use logs_ingestion::avro::AvroValue;+use logs_ingestion::js::{json_parse, json_stringify, JsObject, JsString, JsValue};++pub fn repo_path(relative: &str) -> PathBuf {+ PathBuf::from(env!("CARGO_MANIFEST_DIR"))+ .join("../..")+ .join(relative)+}++pub fn modules_dir() -> PathBuf {+ repo_path("nodejs/src/logs/parity/fixtures/modules")+}++pub fn scenarios_dir() -> PathBuf {+ repo_path("nodejs/src/logs/parity/fixtures/scenarios")+}++pub fn load_json(path: &PathBuf) -> JsValue {+ let text = std::fs::read_to_string(path).unwrap_or_else(|e| panic!("read {path:?}: {e}"));+ // Fixtures split secret-shaped test tokens with U+E000 so secret scanners skip them.+ json_parse(&text.replace('\u{E000}', "")).unwrap_or_else(|e| panic!("parse {path:?}: {e}"))+}++pub fn get<'a>(value: &'a JsValue, key: &str) -> &'a JsValue {+ match value {+ JsValue::Object(o) => o.get(key).unwrap_or_else(|| panic!("missing key {key}")),+ _ => panic!("not an object looking up {key}"),+ }+}++pub fn try_get<'a>(value: &'a JsValue, key: &str) -> Option<&'a JsValue> {+ match value {+ JsValue::Object(o) => o.get(key),+ _ => None,+ }+}++pub fn array(value: &JsValue) -> &[JsValue] {+ match value {+ JsValue::Array(items) => items,+ other => panic!("not an array: {other:?}"),+ }+}++pub fn string(value: &JsValue) -> String {+ match value {+ JsValue::String(s) => s.to_string(),+ other => panic!("not a string: {other:?}"),+ }+}++pub fn cases(name: &str) -> Vec<(JsValue, JsValue)> {+ let file = load_json(&modules_dir().join(format!("{name}.json")));+ array(get(&file, "cases"))+ .iter()+ .map(|c| (get(c, "input").clone(), get(c, "output").clone()))+ .collect()+}++/// The default JavaScript sort: by UTF-16 code units.+pub fn js_sort_cmp(a: &str, b: &str) -> Ordering {+ a.encode_utf16().cmp(b.encode_utf16())+}++/// Keys sorted, then assigned to a plain object, which lists array-index keys first again, as `canonicalizeAvroValue` does.+pub fn canonical(value: &AvroValue) -> JsValue {+ let object = |entries: Vec<(String, JsValue)>| {+ let mut entries = entries;+ entries.sort_by(|(a, _), (b, _)| js_sort_cmp(a, b));+ let mut o = JsObject::new();+ for (k, v) in entries {+ o.insert(JsString::from(k), v);+ }+ JsValue::Object(o)+ };+ let bytes = |b: &[u8]| {+ let hex: String = b.iter().map(|x| format!("{x:02x}")).collect();+ object(vec![("$bytes".to_string(), JsValue::string(&hex))])+ };+ match value {+ AvroValue::Null => JsValue::Null,+ AvroValue::Boolean(b) => JsValue::Bool(*b),+ AvroValue::Int(n) | AvroValue::Long(n) => JsValue::Number(*n as f64),+ AvroValue::Float(f) | AvroValue::Double(f) => JsValue::Number(*f),+ AvroValue::Bytes(b) | AvroValue::Fixed(b) => bytes(b),+ AvroValue::String(s) | AvroValue::Enum(s) => JsValue::string(s),+ AvroValue::Array(items) => JsValue::Array(items.iter().map(canonical).collect()),+ AvroValue::Map(m) => object(+ m.iter()+ .map(|(k, v)| (k.to_string(), canonical(v)))+ .collect(),+ ),+ AvroValue::Record(fields) => object(+ fields+ .iter()+ .map(|(k, v)| (k.to_string(), canonical(v)))+ .collect(),+ ),+ }+}++pub fn canonical_text(records: &[AvroValue]) -> String {+ json_stringify(&JsValue::Array(records.iter().map(canonical).collect()))+}diff --git a/rust/logs-ingestion/tests/differential_fuzz.rs b/rust/logs-ingestion/tests/differential_fuzz.rsnew file mode 100644index 000000000000..fb4a033db40b--- /dev/null+++ b/rust/logs-ingestion/tests/differential_fuzz.rs@@ -0,0 +1,499 @@+//! Numbers compare as doubles, also inside JSON text, and two errors match whatever their text, as the parity contract in PORTING.md states.++mod common;++use std::collections::HashMap;+use std::sync::Arc;++use base64::Engine;+use common::{array, canonical_text, get, load_json, string, try_get};+use logs_ingestion::attribute_value::{decode_log_attribute_value, encode_log_attribute_value};+use logs_ingestion::avro::{decode_container, AvroMap, AvroValue};+use logs_ingestion::internal_logs::{InternalLogsVerifier, InternalSourcePolicy};+use logs_ingestion::js::{+ date_parse, json_parse, json_stringify, number_to_string, JsObject, JsString, JsValue,+};+use logs_ingestion::metric_rules::{+ build_metric_rules_otlp_payload, compile_metric_rules, tally_records,+ with_default_metric_rules, BatchTallies, MetricRuleRow, MetricRuleSource,+};+use logs_ingestion::normalize::{transform_decoded_log_records_in_place, LogsSettings};+use logs_ingestion::pattern::build_log_pattern;+use logs_ingestion::pii::scrub_plain_string_with_stats;+use logs_ingestion::record::LogRecord;+use logs_ingestion::retention::{+ compile_retention_rule_set, evaluate_retention_days, RetentionRuleRow,+};+use logs_ingestion::sampling::{compile_rule_set, evaluate_log_record, SamplingRuleRow};+use sha2::{Digest, Sha256};++fn cases(name: &str) -> Vec<(JsValue, JsValue)> {+ // `FUZZ_DIR` replays a larger corpus written with `FUZZ_BUDGET=0`.+ let dir = std::env::var("FUZZ_DIR").map_or_else(+ |_| common::repo_path("rust/logs-ingestion/tests/fixtures/fuzz"),+ std::path::PathBuf::from,+ );+ let path = dir.join(format!("{name}.json"));+ let file = load_json(&path);+ let cases: Vec<_> = array(get(&file, "cases"))+ .iter()+ .map(|c| (get(c, "input").clone(), get(c, "output").clone()))+ .collect();+ assert!(!cases.is_empty(), "{name}: no cases");+ cases+}++fn assert_none(area: &str, mismatches: Vec<String>) {+ assert!(+ mismatches.is_empty(),+ "{area}: {} mismatches\n{}",+ mismatches.len(),+ mismatches+ .iter()+ .take(5)+ .cloned()+ .collect::<Vec<_>>()+ .join("\n")+ );+}++fn num(v: &JsValue) -> f64 {+ match v {+ JsValue::Number(n) => *n,+ other => panic!("not a number: {other:?}"),+ }+}++fn opt_string(v: &JsValue) -> Option<String> {+ (*v != JsValue::Null).then(|| string(v))+}++fn same(a: &JsValue, b: &JsValue) -> bool {+ match (a, b) {+ (JsValue::String(x), JsValue::String(y)) => same_text(x, y),+ (JsValue::Array(x), JsValue::Array(y)) => {+ x.len() == y.len() && x.iter().zip(y).all(|(p, q)| same(p, q))+ }+ (JsValue::Object(x), JsValue::Object(y)) => {+ x.len() == y.len()+ && x.iter()+ .zip(y.iter())+ .all(|((k1, v1), (k2, v2))| k1 == k2 && same(v1, v2))+ }+ // `JSON.stringify` writes NaN and Infinity as null.+ (JsValue::Number(x), JsValue::Null) | (JsValue::Null, JsValue::Number(x)) => !x.is_finite(),+ _ => a == b,+ }+}++fn same_text(a: &JsString, b: &JsString) -> bool {+ if a == b {+ return true;+ }+ match (a.as_str().map(json_parse), b.as_str().map(json_parse)) {+ (Some(Ok(x)), Some(Ok(y))) => !matches!(x, JsValue::String(_)) && same(&x, &y),+ _ => false,+ }+}++fn same_str(a: &str, b: &str) -> bool {+ same_text(&JsString::from(a), &JsString::from(b))+}++fn avro_from_json(v: &JsValue) -> AvroValue {+ match v {+ JsValue::Null => AvroValue::Null,+ JsValue::Bool(b) => AvroValue::Boolean(*b),+ JsValue::Number(x) if x.fract() == 0.0 => AvroValue::Long(*x as i64),+ JsValue::Number(x) => AvroValue::Double(*x),+ JsValue::String(x) => AvroValue::String(x.to_utf8_lossy().into_owned()),+ JsValue::Object(o) => {+ if let Some(JsValue::String(hex)) = o.get("$bytes") {+ return AvroValue::Bytes(hex::decode(hex.to_string()).unwrap());+ }+ let mut map = AvroMap::new();+ for (k, v) in o.iter() {+ map.assign(k.to_utf8_lossy().into_owned(), avro_from_json(v));+ }+ AvroValue::Map(map)+ }+ JsValue::Array(items) => AvroValue::Array(items.iter().map(avro_from_json).collect()),+ }+}++fn record_from_json(v: &JsValue) -> LogRecord {+ let JsValue::Object(o) = v else {+ panic!("record")+ };+ let fields = o+ .iter()+ .map(|(k, v)| (Arc::from(&*k.to_utf8_lossy()), avro_from_json(v)))+ .collect();+ LogRecord::from_value(AvroValue::Record(fields))+}++fn avro_to_js(value: &AvroValue) -> JsValue {+ match value {+ AvroValue::Null => JsValue::Null,+ AvroValue::Boolean(b) => JsValue::Bool(*b),+ AvroValue::Int(n) | AvroValue::Long(n) => JsValue::Number(*n as f64),+ AvroValue::Float(f) | AvroValue::Double(f) => JsValue::Number(*f),+ AvroValue::String(s) | AvroValue::Enum(s) => JsValue::string(s),+ AvroValue::Bytes(b) | AvroValue::Fixed(b) => {+ let mut o = JsObject::new();+ o.insert_str("$bytes", JsValue::string(&hex::encode(b)));+ JsValue::Object(o)+ }+ AvroValue::Map(m) => {+ let mut o = JsObject::new();+ for (k, v) in m.iter() {+ o.insert_str(k, avro_to_js(v));+ }+ JsValue::Object(o)+ }+ AvroValue::Array(a) => JsValue::Array(a.iter().map(avro_to_js).collect()),+ AvroValue::Record(_) => panic!("nested record"),+ }+}++fn record_to_js(record: &LogRecord) -> JsValue {+ let mut o = JsObject::new();+ for (k, v) in record.fields.iter().chain(record.extra.iter()) {+ o.insert_str(k, avro_to_js(v));+ }+ JsValue::Object(o)+}++#[test]+fn json_numbers_and_dates() {+ let mut bad = Vec::new();+ for (input, output) in cases("json") {+ let Some(text) = input.as_js_string().and_then(JsString::as_str) else {+ continue;+ };+ let actual = json_parse(text)+ .ok()+ .map(|v| JsString::from(json_stringify(&v)));+ let ok = match (&actual, get(&output, "ok")) {+ (Some(a), JsValue::Bool(true)) => {+ same_text(a, get(&output, "s").as_js_string().unwrap())+ }+ (None, JsValue::Bool(false)) => true,+ _ => false,+ };+ if !ok {+ bad.push(format!("JSON {text:?}: rust {actual:?}"));+ }+ }+ for (input, output) in cases("numbers") {+ let x = f64::from_bits(u64::from_str_radix(&string(&input), 16).unwrap());+ let actual = number_to_string(x);+ if !(same_str(&actual, &string(&output)) || (x.is_nan() && actual == "NaN")) {+ bad.push(format!(+ "String({x:e}): node {} rust {actual}",+ string(&output)+ ));+ }+ }+ for (input, output) in cases("date") {+ let expected = match output {+ JsValue::Number(n) => Some(n),+ _ => None,+ };+ let actual = date_parse(&string(&input));+ if actual != expected {+ bad.push(format!(+ "Date.parse({:?}): node {expected:?} rust {actual:?}",+ string(&input)+ ));+ }+ }+ assert_none("json/numbers/date", bad);+}++#[test]+fn text_stages() {+ let mut bad = Vec::new();+ for (input, output) in cases("pii") {+ let (out, n) = scrub_plain_string_with_stats(&string(&input));+ if out != string(get(&output, "output")) || n as f64 != num(get(&output, "piiReplacements"))+ {+ bad.push(format!("pii {:?}", string(&input)));+ }+ }+ for (input, output) in cases("pattern") {+ let body = opt_string(get(&input, "body"));+ let keys: Vec<String> = array(get(&input, "keys")).iter().map(string).collect();+ let keys: Vec<&str> = keys.iter().map(String::as_str).collect();+ let res = build_log_pattern(body.as_deref(), &keys);+ let fires: Vec<f64> = array(get(&output, "ruleFires")).iter().map(num).collect();+ let ok = res.pattern+ == get(&output, "pattern")+ .as_js_string()+ .unwrap()+ .to_utf8_lossy()+ && res.body_kind.as_str() == string(get(&output, "bodyKind"))+ && JsValue::Bool(res.input_capped) == *get(&output, "inputCapped")+ && res.masked_length as f64 == num(get(&output, "maskedLength"))+ && res.json_key_count.map(|n| n as f64) == try_get(&output, "jsonKeyCount").map(num)+ && res.rule_fires.iter().map(|&n| n as f64).collect::<Vec<_>>() == fires;+ if !ok {+ bad.push(format!("pattern {body:?}"));+ }+ }+ for (input, output) in cases("attribute_value") {+ let text = string(&input);+ let decoded = decode_log_attribute_value(&text);+ let encoded = encode_log_attribute_value(&text);+ if !same_text(&decoded, get(&output, "decoded").as_js_string().unwrap())+ || !same_str(&encoded, &string(get(&output, "encoded")))+ {+ bad.push(format!("attribute value {text:?}"));+ }+ }+ let policies = HashMap::from([+ (+ "hog_flow".to_string(),+ InternalSourcePolicy {+ billed: false,+ team_rules: false,+ },+ ),+ (+ "billed_src".to_string(),+ InternalSourcePolicy {+ billed: true,+ team_rules: true,+ },+ ),+ ]);+ for (input, output) in cases("internal") {+ let verifier = InternalLogsVerifier::new(+ &string(get(&input, "keys")),+ &string(get(&input, "teams")),+ policies.clone(),+ );+ let actual = verifier+ .verify(+ opt_string(get(&input, "signature")).as_deref(),+ num(get(&input, "team_id")) as i64,+ opt_string(get(&input, "created_at")).as_deref(),+ )+ .map(|a| (a.source, a.billed, a.team_rules));+ let expected = (output != JsValue::Null).then(|| {+ (+ string(get(&output, "source")),+ *get(&output, "billed") == JsValue::Bool(true),+ *get(&output, "teamRules") == JsValue::Bool(true),+ )+ });+ if actual != expected {+ bad.push(format!(+ "internal {}: node {expected:?} rust {actual:?}",+ json_stringify(&input)+ ));+ }+ }+ assert_none("text stages", bad);+}++#[test]+fn normalize() {+ let mut bad = Vec::new();+ for (i, (input, output)) in cases("normalize").into_iter().enumerate() {+ // Keys that merge once lossy are a documented gap.+ if *get(&output, "gap") == JsValue::Bool(true) {+ continue;+ }+ let settings = get(&input, "settings");+ let flag = |key: &str| match try_get(settings, key) {+ Some(JsValue::Bool(b)) => Some(*b),+ _ => None,+ };+ let settings = LogsSettings {+ json_parse_logs: flag("json_parse_logs"),+ pii_scrub_logs: flag("pii_scrub_logs"),+ json_parse_logs_attribute_key: try_get(settings, "json_parse_logs_attribute_key")+ .map(string),+ ..LogsSettings::default()+ };+ let mut records = vec![record_from_json(get(&input, "record"))];+ let pii = transform_decoded_log_records_in_place(&mut records, &settings);+ if !same(&record_to_js(&records[0]), get(&output, "record"))+ || pii.pii_replacements as f64 != num(get(&output, "pii_replacements"))+ {+ bad.push(format!("normalize case {i}"));+ }+ }+ assert_none("normalize", bad);+}++#[test]+fn sampling_and_retention() {+ let mut bad = Vec::new();+ for (i, (input, output)) in cases("sampling").into_iter().enumerate() {+ let rows: Vec<SamplingRuleRow> = array(get(&input, "rules"))+ .iter()+ .map(|v| SamplingRuleRow {+ id: string(get(v, "id")),+ rule_type: string(get(v, "rule_type")),+ scope_service: opt_string(get(v, "scope_service")),+ scope_path_pattern: opt_string(get(v, "scope_path_pattern")),+ scope_attribute_filters: get(v, "scope_attribute_filters").clone(),+ config: get(v, "config").clone(),+ version: None,+ })+ .collect();+ let compiled = compile_rule_set(&rows);+ let Ok(compiled) = compiled else {+ if try_get(&output, "compile_error").is_none() {+ bad.push(format!("sampling case {i}: rust compile error"));+ }+ continue;+ };+ if try_get(&output, "compile_error").is_some() {+ bad.push(format!("sampling case {i}: node compile error"));+ continue;+ }+ for (rec, out) in array(get(&input, "records")).iter().zip(array(&output)) {+ let actual = match evaluate_log_record(Some(&compiled), &record_from_json(rec)) {+ Ok(res) => format!("{}/{:?}", res.decision.as_str(), res.rule_id),+ Err(_) => "threw".to_string(),+ };+ let expected = match try_get(out, "threw") {+ Some(_) => "threw".to_string(),+ None => format!(+ "{}/{:?}",+ string(get(out, "decision")),+ opt_string(get(out, "ruleId"))+ ),+ };+ if actual != expected {+ bad.push(format!("sampling case {i}: node {expected} rust {actual}"));+ }+ }+ }+ for (i, (input, output)) in cases("retention").into_iter().enumerate() {+ let rows: Vec<RetentionRuleRow> = array(get(&input, "rules"))+ .iter()+ .map(|v| RetentionRuleRow {+ id: string(get(v, "id")),+ config: get(v, "config").clone(),+ version: None,+ })+ .collect();+ let compiled = compile_retention_rule_set(&rows);+ let Ok(compiled) = compiled else {+ if try_get(&output, "compile_error").is_none() {+ bad.push(format!("retention case {i}: rust compile error"));+ }+ continue;+ };+ if try_get(&output, "compile_error").is_some() {+ bad.push(format!("retention case {i}: node compile error"));+ continue;+ }+ for (rec, out) in array(get(&input, "records")).iter().zip(array(&output)) {+ let actual = match evaluate_retention_days(Some(&compiled), &record_from_json(rec)) {+ Ok(d) => format!("{d:?}"),+ Err(_) => "threw".to_string(),+ };+ let expected = match out {+ JsValue::Null => "None".to_string(),+ JsValue::Number(n) => format!("Some({n})"),+ _ => "threw".to_string(),+ };+ if actual != expected {+ bad.push(format!("retention case {i}: node {expected} rust {actual}"));+ }+ }+ }+ assert_none("sampling/retention", bad);+}++#[test]+fn metric_rules() {+ let mut bad = Vec::new();+ for (i, (input, output)) in cases("metrics").into_iter().enumerate() {+ let rows: Vec<MetricRuleRow> = array(get(&input, "rules"))+ .iter()+ .map(|v| match v {+ JsValue::Object(o) => MetricRuleRow::from_js(o),+ _ => panic!("rule row"),+ })+ .collect();+ let Ok(mut rules) = compile_metric_rules(&rows) else {+ if try_get(&output, "compile_error").is_none() {+ bad.push(format!("metrics case {i}: rust compile error"));+ }+ continue;+ };+ if try_get(&output, "compile_error").is_some() {+ bad.push(format!("metrics case {i}: node compile error"));+ continue;+ }+ match get(&input, "defaults") {+ JsValue::String(d) if *d == "logs" => {+ rules = with_default_metric_rules(rules, MetricRuleSource::Logs)+ }+ JsValue::String(_) => rules = with_default_metric_rules(rules, MetricRuleSource::Spans),+ _ => {}+ }+ let records: Vec<LogRecord> = array(get(&input, "records"))+ .iter()+ .map(record_from_json)+ .collect();+ let now = num(get(&input, "now_ms"));+ let mut tallies = BatchTallies::new();+ let mut admit = |_: &str, label_key: &str| !label_key.contains("deny");+ let threw = tally_records(&rules, &records, &mut tallies, now, Some(&mut admit)).is_err();+ let payload = build_metric_rules_otlp_payload(&rules, &tallies, now);+ let payload_ok = match (payload, get(&output, "payload_json")) {+ (None, JsValue::Null) => true,+ (Some(p), JsValue::String(text)) => text+ .as_str()+ .and_then(|t| json_parse(t).ok())+ .is_some_and(|n| same(&p, &n)),+ _ => false,+ };+ let mut overflow = JsObject::new();+ for (rule_id, count) in tallies.series_overflow.iter() {+ overflow.insert_str(rule_id, JsValue::Number(*count as f64));+ }+ if !payload_ok+ || threw != (*get(&output, "threw") != JsValue::Null)+ || tallies.value_skipped as f64 != num(get(&output, "value_skipped"))+ || tallies.eval_errors as f64 != num(get(&output, "eval_errors"))+ || JsValue::Object(overflow) != *get(&output, "series_overflow")+ {+ bad.push(format!("metrics case {i}"));+ }+ }+ assert_none("metrics", bad);+}++#[test]+fn avro_decode() {+ let mut bad = Vec::new();+ for (i, (input, output)) in cases("avro").into_iter().enumerate() {+ let bytes = base64::engine::general_purpose::STANDARD+ .decode(string(get(&input, "b64")))+ .unwrap();+ let schema_intact = *get(&input, "schema_intact") == JsValue::Bool(true);+ let ok = match (decode_container(&bytes), try_get(&output, "error")) {+ (Err(_), Some(_)) => true,+ (Ok(c), None) => {+ c.codec == string(get(&output, "codec"))+ && c.records.len() as f64 == num(get(&output, "count"))+ && hex::encode(Sha256::digest(canonical_text(&c.records).as_bytes()))+ == string(get(&output, "sha256"))+ }+ // avsc's writer-schema validation is a documented gap.+ _ => !schema_intact,+ };+ if !ok {+ bad.push(format!("avro case {i} ({})", string(get(&input, "label"))));+ }+ }+ assert_none("avro", bad);+}diff --git a/rust/logs-ingestion/tests/fixtures/fuzz/attribute_value.json b/rust/logs-ingestion/tests/fixtures/fuzz/attribute_value.jsonnew file mode 100644index 000000000000..7d54b9c5f447--- /dev/null+++ b/rust/logs-ingestion/tests/fixtures/fuzz/attribute_value.json@@ -0,0 +1 @@+{"cases":[{"input":"é","output":{"decoded":"é","encoded":"\"é\""}},{"input":"false","output":{"decoded":"false","encoded":"false"}},{"input":"\"hasOwnProperty xoxb-1234567890-abcWed, 15 Jan 2025 12:00:00 GMT\"\\ud83d","output":{"decoded":"\"hasOwnProperty xoxb-1234567890-abcWed, 15 Jan 2025 12:00:00 GMT\"\\ud83d","encoded":"\"\\\"hasOwnProperty xoxb-1234567890-abcWed, 15 Jan 2025 12:00:00 GMT\\\"\\\\ud83d\""}},{"input":"2025-01-15T10:00:00Z ","output":{"decoded":"2025-01-15T10:00:00Z ","encoded":"\"2025-01-15T10:00:00Z \""}},{"input":"ghp_0123456789abcdefghij0123456789abcdef","output":{"decoded":"ghp_0123456789abcdefghij0123456789abcdef","encoded":"\"ghp_0123456789abcdefghij0123456789abcdef\""}},{"input":"\"4294967295𛰾 \"","output":{"decoded":"4294967295𛰾 ","encoded":"\"4294967295𛰾 \""}},{"input":"\"0 3fa85f64-5717-4562-b3fc-2c963f66afa6INFO \"","output":{"decoded":"0 3fa85f64-5717-4562-b3fc-2c963f66afa6INFO ","encoded":"\"0 3fa85f64-5717-4562-b3fc-2c963f66afa6INFO \""}},{"input":"\"[email protected] \"\\u2028\\ud83d\\ude80","output":{"decoded":"\"[email protected] \"\\u2028\\ud83d\\ude80","encoded":"\"\\\"[email protected] \\\"\\\\u2028\\\\ud83d\\\\ude80\""}},{"input":"\"AKIAIOSFODNN7EXAMPLE\"x\\ude80\\ud83d\\ude80","output":{"decoded":"\"AKIAIOSFODNN7EXAMPLE\"x\\ude80\\ud83d\\ude80","encoded":"\"\\\"AKIAIOSFODNN7EXAMPLE\\\"x\\\\ude80\\\\ud83d\\\\ude80\""}},{"input":"\"\\u0000Kxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxéééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"","output":{"decoded":"\u0000Kxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxéééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé","encoded":"\"\\u0000Kxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxéééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\""}},{"input":"\"\\\\\\ud800valueOf\"","output":{"decoded":"\\\ud800valueOf","encoded":"\"\\\\\\ud800valueOf\""}},{"input":"1.7976931348623157e+308","output":{"decoded":"1.7976931348623157e+308","encoded":"1.7976931348623157e+308"}},{"input":"\"3fa85f64-5717-4562-b3fc-2c963f66afa62001:db8::1 \"\\\\","output":{"decoded":"\"3fa85f64-5717-4562-b3fc-2c963f66afa62001:db8::1 \"\\\\","encoded":"\"\\\"3fa85f64-5717-4562-b3fc-2c963f66afa62001:db8::1 \\\"\\\\\\\\\""}},{"input":"\"\\/ level\"\\udfff","output":{"decoded":"\"\\/ level\"\\udfff","encoded":"\"\\\"\\\\/ level\\\"\\\\udfff\""}},{"input":"\"\\ud83d2.5e-8éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"","output":{"decoded":"\ud83d2.5e-8éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé","encoded":"\"\\ud83d2.5e-8éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\""}},{"input":"\"\\ud83d\\ud83d12 \"","output":{"decoded":"\ud83d\ud83d12 ","encoded":"\"\\ud83d\\ud83d12 \""}},{"input":"\" 12\"","output":{"decoded":" 12","encoded":"\" 12\""}},{"input":"\"🚀 \"\\ud800\\udfff","output":{"decoded":"\"🚀 \"\\ud800\\udfff","encoded":"\"\\\"🚀 \\\"\\\\ud800\\\\udfff\""}},{"input":"\"\\\" 12\"","output":{"decoded":"\" 12","encoded":"\"\\\" 12\""}},{"input":"\"xoxb-1234567890-abc瞌1e3\"\\u0000","output":{"decoded":"\"xoxb-1234567890-abc瞌1e3\"\\u0000","encoded":"\"\\\"xoxb-1234567890-abc瞌1e3\\\"\\\\u0000\""}},{"input":"\"0x10 挹 \"\\/","output":{"decoded":"\"0x10 挹 \"\\/","encoded":"\"\\\"0x10 挹 \\\"\\\\/\""}},{"input":"\"\\\"\"\\\"","output":{"decoded":"\"\\\"\"\\\"","encoded":"\"\\\"\\\\\\\"\\\"\\\\\\\"\""}},{"input":"\" AKIAIOSFODNN7EXAMPLEhttp.method\"\\\\\\ud83d","output":{"decoded":"\" AKIAIOSFODNN7EXAMPLEhttp.method\"\\\\\\ud83d","encoded":"\"\\\" AKIAIOSFODNN7EXAMPLEhttp.method\\\"\\\\\\\\\\\\ud83d\""}},{"input":"\"12345678 \"","output":{"decoded":"12345678 ","encoded":"\"12345678 \""}},{"input":"\"2.5e-8\"","output":{"decoded":"2.5e-8","encoded":"\"2.5e-8\""}},{"input":"9007199254740994","output":{"decoded":"9007199254740994","encoded":"9007199254740994"}},{"input":"\"warn\"","output":{"decoded":"warn","encoded":"\"warn\""}},{"input":"\"x\"","output":{"decoded":"x","encoded":"\"x\""}},{"input":"\"sk_live_0123456789abcdefghijkl\"","output":{"decoded":"sk_live_0123456789abcdefghijkl","encoded":"\"sk_live_0123456789abcdefghijkl\""}},{"input":"\"[9007199254740992,true,\\\"12.. \\\",[[{\\\"user.email\\\":1.5},1,1],1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\"","output":{"decoded":"[9007199254740992,true,\"12.. \",[[{\"user.email\":1.5},1,1],1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","encoded":"\"[9007199254740992,true,\\\"12.. \\\",[[{\\\"user.email\\\":1.5},1,1],1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\""}},{"input":"\"\\u202800o\"\\/","output":{"decoded":"\"\\u202800o\"\\/","encoded":"\"\\\"\\\\u202800o\\\"\\\\/\""}},{"input":"\"true\"","output":{"decoded":"true","encoded":"\"true\""}},{"input":"\"{\\\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\\\":{\\\"0\\\":1e+100,\\\"1\\\":[\\\"..event \\\",null,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\\\"12\\\":\\\"lengtha. \\\",\\\"constructor\\\":null}}\"","output":{"decoded":"{\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":{\"0\":1e+100,\"1\":[\"..event \",null,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\"12\":\"lengtha. \",\"constructor\":null}}","encoded":"\"{\\\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\\\":{\\\"0\\\":1e+100,\\\"1\\\":[\\\"..event \\\",null,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\\\"12\\\":\\\"lengtha. \\\",\\\"constructor\\\":null}}\""}},{"input":"null","output":{"decoded":"null","encoded":"null"}},{"input":"\"12🐮\"\\ud800","output":{"decoded":"\"12🐮\"\\ud800","encoded":"\"\\\"12🐮\\\"\\\\ud800\""}},{"input":"\"{\\\"a\\\":1}\"","output":{"decoded":"{\"a\":1}","encoded":"\"{\\\"a\\\":1}\""}},{"input":"\"\"","output":{"decoded":"","encoded":"\"\""}},{"input":"\" \\\"POST\"","output":{"decoded":" \"POST","encoded":"\" \\\"POST\""}},{"input":"\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀message \"x\\ude80\\u2028","output":{"decoded":"\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀message \"x\\ude80\\u2028","encoded":"\"\\\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀message \\\"x\\\\ude80\\\\u2028\""}},{"input":"\"[沆 \"\\/\\u0000","output":{"decoded":"\"[沆 \"\\/\\u0000","encoded":"\"\\\"[沆 \\\"\\\\/\\\\u0000\""}},{"input":"-Infinity","output":{"decoded":"-Infinity","encoded":"\"-Infinity\""}},{"input":"\"null\"","output":{"decoded":"null","encoded":"\"null\""}},{"input":"__proto__","output":{"decoded":"__proto__","encoded":"\"__proto__\""}},{"input":"\"192.168.1.1null봽\"","output":{"decoded":"192.168.1.1null봽","encoded":"\"192.168.1.1null봽\""}},{"input":"\"\\\"9007199254740992 g軕\\\"\"","output":{"decoded":"\"9007199254740992 g軕\"","encoded":"\"\\\"9007199254740992 g軕\\\"\""}},{"input":"\"12\"","output":{"decoded":"12","encoded":"\"12\""}},{"input":"\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééésk_live_0123456789abcdefghijkl\"","output":{"decoded":"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééésk_live_0123456789abcdefghijkl","encoded":"\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééésk_live_0123456789abcdefghijkl\""}},{"input":"\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6true event\"","output":{"decoded":"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6true event","encoded":"\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6true event\""}},{"input":"\"true\"","output":{"decoded":"true","encoded":"\"true\""}},{"input":"\"🚀1e3event \"\\\\","output":{"decoded":"\"🚀1e3event \"\\\\","encoded":"\"\\\"🚀1e3event \\\"\\\\\\\\\""}},{"input":"\"POST\"","output":{"decoded":"POST","encoded":"\"POST\""}},{"input":"\"\\/L \"\\ud83d","output":{"decoded":"\"\\/L \"\\ud83d","encoded":"\"\\\"\\\\/L \\\"\\\\ud83d\""}},{"input":"\"true\"","output":{"decoded":"true","encoded":"\"true\""}},{"input":"\"\\ud83d Ė \"\\\\","output":{"decoded":"\"\\ud83d Ė \"\\\\","encoded":"\"\\\"\\\\ud83d Ė \\\"\\\\\\\\\""}},{"input":"\"1e400message0.30000000000000004\"","output":{"decoded":"1e400message0.30000000000000004","encoded":"\"1e400message0.30000000000000004\""}},{"input":"\"\\udfff 12 \"","output":{"decoded":"\udfff 12 ","encoded":"\"\\udfff 12 \""}},{"input":"\"[\\\" =\\\",\\\"host.example.com\\\",{\\\"a\\\":\\\"INFO🅑 \\\"},\\\"POST é\\\",\\\"a\\\\\\\\nbݸ\\\",null,1,1,1,1]\"","output":{"decoded":"[\" =\",\"host.example.com\",{\"a\":\"INFO🅑 \"},\"POST é\",\"a\\\\nbݸ\",null,1,1,1,1]","encoded":"\"[\\\" =\\\",\\\"host.example.com\\\",{\\\"a\\\":\\\"INFO🅑 \\\"},\\\"POST é\\\",\\\"a\\\\\\\\nbݸ\\\",null,1,1,1,1]\""}},{"input":"\"Ʈ .5\"\\/","output":{"decoded":"\"Ʈ .5\"\\/","encoded":"\"\\\"Ʈ .5\\\"\\\\/\""}},{"input":"\"1_000\"\\\\\\ud83d\\ude80","output":{"decoded":"\"1_000\"\\\\\\ud83d\\ude80","encoded":"\"\\\"1_000\\\"\\\\\\\\\\\\ud83d\\\\ude80\""}},{"input":"1e+100","output":{"decoded":"1e+100","encoded":"1e+100"}},{"input":"\"5. \"\\/","output":{"decoded":"\"5. \"\\/","encoded":"\"\\\"5. \\\"\\\\/\""}},{"input":"\"null\"","output":{"decoded":"null","encoded":"\"null\""}},{"input":"\"\\r\\n\\u000b 0b11 \"","output":{"decoded":"\r\n\u000b 0b11 ","encoded":"\"\\r\\n\\u000b 0b11 \""}},{"input":"\"\\/\\\"sk_live_0123456789abcdefghijkl \"x\\ude80","output":{"decoded":"\"\\/\\\"sk_live_0123456789abcdefghijkl \"x\\ude80","encoded":"\"\\\"\\\\/\\\\\\\"sk_live_0123456789abcdefghijkl \\\"x\\\\ude80\""}},{"input":"\"🚀null\"\\\\","output":{"decoded":"\"🚀null\"\\\\","encoded":"\"\\\"🚀null\\\"\\\\\\\\\""}},{"input":"\"4294967296\\\\ \"","output":{"decoded":"4294967296\\ ","encoded":"\"4294967296\\\\ \""}},{"input":"..","output":{"decoded":"..","encoded":"\"..\""}},{"input":"9007199254740994","output":{"decoded":"9007199254740994","encoded":"9007199254740994"}},{"input":"\"🚀𐀀 1e3\"\\udfff","output":{"decoded":"\"🚀𐀀 1e3\"\\udfff","encoded":"\"\\\"🚀𐀀 1e3\\\"\\\\udfff\""}},{"input":"100full 12 ","output":{"decoded":"100full 12 ","encoded":"\"100full 12 \""}},{"input":"\"-0 fatal\"\\ud83dx\\ude80","output":{"decoded":"\"-0 fatal\"\\ud83dx\\ude80","encoded":"\"\\\"-0 fatal\\\"\\\\ud83dx\\\\ude80\""}},{"input":"\"\\u000b\"","output":{"decoded":"\u000b","encoded":"\"\\u000b\""}},{"input":"null","output":{"decoded":"null","encoded":"null"}},{"input":"\"5.\"","output":{"decoded":"5.","encoded":"\"5.\""}},{"input":"false","output":{"decoded":"false","encoded":"false"}},{"input":"\"x\\ude80 éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé \"\\\"","output":{"decoded":"\"x\\ude80 éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé \"\\\"","encoded":"\"\\\"x\\\\ude80 éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé \\\"\\\\\\\"\""}},{"input":"\"1,5\"","output":{"decoded":"1,5","encoded":"\"1,5\""}},{"input":"1e400","output":{"decoded":"1e400","encoded":"1e400"}},{"input":"\"ᚭ🚀5. \"","output":{"decoded":"ᚭ🚀5. ","encoded":"\"ᚭ🚀5. \""}},{"input":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"","output":{"decoded":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","encoded":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\""}},{"input":"true","output":{"decoded":"true","encoded":"true"}},{"input":"warn\"quoted\"","output":{"decoded":"warn\"quoted\"","encoded":"\"warn\\\"quoted\\\"\""}},{"input":"\"\\ud83d\\ude80\\r\\nwarn \"\\u2028","output":{"decoded":"\"\\ud83d\\ude80\\r\\nwarn \"\\u2028","encoded":"\"\\\"\\\\ud83d\\\\ude80\\\\r\\\\nwarn \\\"\\\\u2028\""}},{"input":"\"\\/욆 ➩\"","output":{"decoded":"/욆 ➩","encoded":"\"\\/욆 ➩\""}},{"input":"false","output":{"decoded":"false","encoded":"false"}},{"input":"\"\\ud83d\\ude80host.example.com\"\\ud83d","output":{"decoded":"\"\\ud83d\\ude80host.example.com\"\\ud83d","encoded":"\"\\\"\\\\ud83d\\\\ude80host.example.com\\\"\\\\ud83d\""}},{"input":"\"01 msg1e400\"\\/","output":{"decoded":"\"01 msg1e400\"\\/","encoded":"\"\\\"01 msg1e400\\\"\\\\/\""}},{"input":"12","output":{"decoded":"12","encoded":"\"12\""}},{"input":"12.5","output":{"decoded":"12.5","encoded":"12.5"}},{"input":"\"\\ud83d\\ude800x10\"","output":{"decoded":"🚀0x10","encoded":"\"\\ud83d\\ude800x10\""}},{"input":"[email protected]","output":{"decoded":"[email protected]","encoded":"\"[email protected]\""}},{"input":"\"\\u0000eventtrue \"\\/","output":{"decoded":"\"\\u0000eventtrue \"\\/","encoded":"\"\\\"\\\\u0000eventtrue \\\"\\\\/\""}},{"input":"\"+5 +5\"","output":{"decoded":"+5 +5","encoded":"\"+5 +5\""}},{"input":"5e-324","output":{"decoded":"5e-324","encoded":"5e-324"}},{"input":"\"full\"\\ud800\\u0000","output":{"decoded":"\"full\"\\ud800\\u0000","encoded":"\"\\\"full\\\"\\\\ud800\\\\u0000\""}},{"input":"\"3fa85f64-5717-4562-b3fc-2c963f66afa6\"","output":{"decoded":"3fa85f64-5717-4562-b3fc-2c963f66afa6","encoded":"\"3fa85f64-5717-4562-b3fc-2c963f66afa6\""}},{"input":"\" \"\\u2028","output":{"decoded":"\" \"\\u2028","encoded":"\"\\\" \\\"\\\\u2028\""}},{"input":"\"2025-01-15T10:00:00Zéééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé1.5\"","output":{"decoded":"2025-01-15T10:00:00Zéééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé1.5","encoded":"\"2025-01-15T10:00:00Zéééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé1.5\""}},{"input":"2.5e-8","output":{"decoded":"2.5e-8","encoded":"2.5e-8"}},{"input":"\"{\\\"12345678\\\":{\\\" \\\":{\\\"b\\\":[\\\"0.1 eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 \\\",\\\"0.30000000000000004 \\\\u000bInfinity\\\",\\\"1 10 ghp_0123456789abcdefghij0123456789abcdef\\\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}},\\\" \\\":\\\"0.000001 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \\\"}\"","output":{"decoded":"{\"12345678\":{\" \":{\"b\":[\"0.1 eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 \",\"0.30000000000000004 \\u000bInfinity\",\"1 10 ghp_0123456789abcdefghij0123456789abcdef\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}},\" \":\"0.000001 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \"}","encoded":"\"{\\\"12345678\\\":{\\\" \\\":{\\\"b\\\":[\\\"0.1 eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 \\\",\\\"0.30000000000000004 \\\\u000bInfinity\\\",\\\"1 10 ghp_0123456789abcdefghij0123456789abcdef\\\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}},\\\" \\\":\\\"0.000001 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \\\"}\""}},{"input":"false","output":{"decoded":"false","encoded":"false"}},{"input":"null","output":{"decoded":"null","encoded":"null"}},{"input":"\" 0x10Ճ\"\\u0000","output":{"decoded":"\" 0x10Ճ\"\\u0000","encoded":"\"\\\" 0x10Ճ\\\"\\\\u0000\""}},{"input":"\"[{\\\"9\\\":{\\\"1.5\\\":{\\\"4\\\":\\\"0.a \\\",\\\"4294967295\\\":\\\"fatal Bearer abc.def-ghi \\\\\\\\\\\",\\\"warn \\\":null}},\\\"͊ 4294967295\\\":true},1,1,1,1,1,1,1,1,1]\"","output":{"decoded":"[{\"9\":{\"1.5\":{\"4\":\"0.a \",\"4294967295\":\"fatal Bearer abc.def-ghi \\\\\",\"warn \":null}},\"͊ 4294967295\":true},1,1,1,1,1,1,1,1,1]","encoded":"\"[{\\\"9\\\":{\\\"1.5\\\":{\\\"4\\\":\\\"0.a \\\",\\\"4294967295\\\":\\\"fatal Bearer abc.def-ghi \\\\\\\\\\\",\\\"warn \\\":null}},\\\"͊ 4294967295\\\":true},1,1,1,1,1,1,1,1,1]\""}},{"input":"\"debug\"","output":{"decoded":"debug","encoded":"\"debug\""}},{"input":"\"192.168.1.1\"","output":{"decoded":"192.168.1.1","encoded":"\"192.168.1.1\""}},{"input":"\"[1,2]a\\\\nb\"","output":{"decoded":"[1,2]a\\nb","encoded":"\"[1,2]a\\\\nb\""}},{"input":"\"ghp_0123456789abcdefghij0123456789abcdefERRORxoxb-1234567890-abc \"\\u0000","output":{"decoded":"\"ghp_0123456789abcdefghij0123456789abcdefERRORxoxb-1234567890-abc \"\\u0000","encoded":"\"\\\"ghp_0123456789abcdefghij0123456789abcdefERRORxoxb-1234567890-abc \\\"\\\\u0000\""}},{"input":"\"/api/v1/users/123\"","output":{"decoded":"/api/v1/users/123","encoded":"\"/api/v1/users/123\""}},{"input":"12","output":{"decoded":"12","encoded":"12"}},{"input":"\"__proto__+5 deadbeef \"\\\\","output":{"decoded":"\"__proto__+5 deadbeef \"\\\\","encoded":"\"\\\"__proto__+5 deadbeef \\\"\\\\\\\\\""}},{"input":"\"x\\ude80 \"\\/","output":{"decoded":"\"x\\ude80 \"\\/","encoded":"\"\\\"x\\\\ude80 \\\"\\\\/\""}},{"input":"12.5","output":{"decoded":"12.5","encoded":"12.5"}},{"input":"\"12 \"\\\\","output":{"decoded":"\"12 \"\\\\","encoded":"\"\\\"12 \\\"\\\\\\\\\""}},{"input":"0o7","output":{"decoded":"0o7","encoded":"\"0o7\""}},{"input":"\"\\/0.30000000000000004\"x\\ude80","output":{"decoded":"\"\\/0.30000000000000004\"x\\ude80","encoded":"\"\\\"\\\\/0.30000000000000004\\\"x\\\\ude80\""}},{"input":"1_000","output":{"decoded":"1_000","encoded":"\"1_000\""}},{"input":"\"ٜ\\n \"","output":{"decoded":"ٜ\n ","encoded":"\"ٜ\\n \""}},{"input":"2025-01-15T10:00:00Z","output":{"decoded":"2025-01-15T10:00:00Z","encoded":"\"2025-01-15T10:00:00Z\""}},{"input":"\"truexxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\\\\\"","output":{"decoded":"truexxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\\","encoded":"\"truexxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\\\\\""}},{"input":"\"\\\\\\/𐀀𝕰 \"","output":{"decoded":"\\/𐀀𝕰 ","encoded":"\"\\\\\\/𐀀𝕰 \""}},{"input":"\"\\/2025-01-15T10:00:00Z \"","output":{"decoded":"/2025-01-15T10:00:00Z ","encoded":"\"\\/2025-01-15T10:00:00Z \""}},{"input":"sk_live_0123456789abcdefghijkl","output":{"decoded":"sk_live_0123456789abcdefghijkl","encoded":"\"sk_live_0123456789abcdefghijkl\""}},{"input":"\"\\udfff4294967295\"","output":{"decoded":"\udfff4294967295","encoded":"\"\\udfff4294967295\""}},{"input":"null","output":{"decoded":"null","encoded":"null"}},{"input":"\"__defineGetter__\"","output":{"decoded":"__defineGetter__","encoded":"\"__defineGetter__\""}},{"input":"\"\\ud83d 12 0o7 \\\"\"","output":{"decoded":"\ud83d 12 0o7 \"","encoded":"\"\\ud83d 12 0o7 \\\"\""}},{"input":"\"\\\\ a日本語\"","output":{"decoded":"\\ a日本語","encoded":"\"\\\\ a日本語\""}},{"input":"null","output":{"decoded":"null","encoded":"null"}},{"input":"-1e400","output":{"decoded":"-1e400","encoded":"-1e400"}},{"input":"\"1.5 1e3日本語\"","output":{"decoded":"1.5 1e3日本語","encoded":"\"1.5 1e3日本語\""}},{"input":"false","output":{"decoded":"false","encoded":"false"}},{"input":"\"1e400\"","output":{"decoded":"1e400","encoded":"\"1e400\""}},{"input":"0.30000000000000004","output":{"decoded":"0.30000000000000004","encoded":"0.30000000000000004"}},{"input":" 12","output":{"decoded":" 12","encoded":"\" 12\""}},{"input":"\"\\\"12 \\t 0\"\\ud83d\\ude80","output":{"decoded":"\"\\\"12 \\t 0\"\\ud83d\\ude80","encoded":"\"\\\"\\\\\\\"12 \\\\t 0\\\"\\\\ud83d\\\\ude80\""}},{"input":" ǐ","output":{"decoded":" ǐ","encoded":"\" ǐ\""}},{"input":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 1e400","output":{"decoded":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 1e400","encoded":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 1e400\""}},{"input":"\"\\ud83d\\/[email protected]\"","output":{"decoded":"\ud83d/[email protected]","encoded":"\"\\ud83d\\/[email protected]\""}},{"input":"\"\\ud83d\\ude80eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 Bearer abc.def-ghi \"","output":{"decoded":"🚀eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 Bearer abc.def-ghi ","encoded":"\"\\ud83d\\ude80eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 Bearer abc.def-ghi \""}},{"input":"true","output":{"decoded":"true","encoded":"true"}},{"input":"2.5e-8","output":{"decoded":"2.5e-8","encoded":"2.5e-8"}},{"input":"sk_live_0123456789abcdefghijkl","output":{"decoded":"sk_live_0123456789abcdefghijkl","encoded":"\"sk_live_0123456789abcdefghijkl\""}},{"input":"\"GEThttp.method1e3 \"","output":{"decoded":"GEThttp.method1e3 ","encoded":"\"GEThttp.method1e3 \""}},{"input":"0.30000000000000004","output":{"decoded":"0.30000000000000004","encoded":"0.30000000000000004"}},{"input":"\"999.9999999\"","output":{"decoded":"999.9999999","encoded":"\"999.9999999\""}},{"input":"\"1,5\"","output":{"decoded":"1,5","encoded":"\"1,5\""}},{"input":"\"42949672951,5[1,2]\"","output":{"decoded":"42949672951,5[1,2]","encoded":"\"42949672951,5[1,2]\""}},{"input":"\" \"\\ud800","output":{"decoded":"\" \"\\ud800","encoded":"\"\\\" \\\"\\\\ud800\""}},{"input":"\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"","output":{"decoded":"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé","encoded":"\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\""}},{"input":"\"\\u0000\\ud83dٌ \"","output":{"decoded":"\u0000\ud83dٌ ","encoded":"\"\\u0000\\ud83dٌ \""}},{"input":"\"\\\\xoxb-1234567890-abc12.5abc{\\\"a\\\":1}\"x\\ude80","output":{"decoded":"\"\\\\xoxb-1234567890-abc12.5abc{\\\"a\\\":1}\"x\\ude80","encoded":"\"\\\"\\\\\\\\xoxb-1234567890-abc12.5abc{\\\\\\\"a\\\\\\\":1}\\\"x\\\\ude80\""}},{"input":"null","output":{"decoded":"null","encoded":"null"}},{"input":"\"1 \"","output":{"decoded":"1 ","encoded":"\"1 \""}},{"input":"\"1_000\"","output":{"decoded":"1_000","encoded":"\"1_000\""}},{"input":"-1","output":{"decoded":"-1","encoded":"-1"}},{"input":"\"12\"\\ud800","output":{"decoded":"\"12\"\\ud800","encoded":"\"\\\"12\\\"\\\\ud800\""}},{"input":"\"7\"","output":{"decoded":"7","encoded":"\"7\""}},{"input":"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6 ","output":{"decoded":"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6 ","encoded":"\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6 \""}},{"input":"\"__proto__\"","output":{"decoded":"__proto__","encoded":"\"__proto__\""}},{"input":"\"\\u0000constructor日本ɫ\"\\ud800","output":{"decoded":"\"\\u0000constructor日本ɫ\"\\ud800","encoded":"\"\\\"\\\\u0000constructor日本ɫ\\\"\\\\ud800\""}},{"input":"valueOf","output":{"decoded":"valueOf","encoded":"\"valueOf\""}},{"input":"\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"","output":{"decoded":"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀","encoded":"\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\""}},{"input":"\"2.5e-8 0012.5abc \"\\ud800\\udfff","output":{"decoded":"\"2.5e-8 0012.5abc \"\\ud800\\udfff","encoded":"\"\\\"2.5e-8 0012.5abc \\\"\\\\ud800\\\\udfff\""}},{"input":"\"1,5\"","output":{"decoded":"1,5","encoded":"\"1,5\""}},{"input":"\"1.7976931348623157e+308\"","output":{"decoded":"1.7976931348623157e+308","encoded":"\"1.7976931348623157e+308\""}},{"input":"\"\\/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-0\"","output":{"decoded":"/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-0","encoded":"\"\\/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-0\""}},{"input":"x","output":{"decoded":"x","encoded":"\"x\""}},{"input":"\" fatal϶ \"","output":{"decoded":" fatal϶ ","encoded":"\" fatal϶ \""}},{"input":"\"2025-01-15T10:00:00Z\"","output":{"decoded":"2025-01-15T10:00:00Z","encoded":"\"2025-01-15T10:00:00Z\""}},{"input":"\" \"","output":{"decoded":" ","encoded":"\" \""}},{"input":"\"é \"","output":{"decoded":"é ","encoded":"\"é \""}},{"input":"\"{\\\"length\\\":[-1.5,{\\\"10\\\":[\\\"100\\\",-2201132.078189403,100,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1]}\"","output":{"decoded":"{\"length\":[-1.5,{\"10\":[\"100\",-2201132.078189403,100,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1]}","encoded":"\"{\\\"length\\\":[-1.5,{\\\"10\\\":[\\\"100\\\",-2201132.078189403,100,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1]}\""}},{"input":"\"error \"","output":{"decoded":"error ","encoded":"\"error \""}},{"input":"\"null\"","output":{"decoded":"null","encoded":"\"null\""}},{"input":"\"12.5abc\"\\u0000","output":{"decoded":"\"12.5abc\"\\u0000","encoded":"\"\\\"12.5abc\\\"\\\\u0000\""}},{"input":"\"1_000\"","output":{"decoded":"1_000","encoded":"\"1_000\""}},{"input":"\"x\\ude80event\"\\ud800","output":{"decoded":"\"x\\ude80event\"\\ud800","encoded":"\"\\\"x\\\\ude80event\\\"\\\\ud800\""}},{"input":"\"֎1e+21 -9007199254740992\"","output":{"decoded":"֎1e+21 -9007199254740992","encoded":"\"֎1e+21 -9007199254740992\""}},{"input":"true","output":{"decoded":"true","encoded":"true"}},{"input":"\"{\\\"a\\\":1}\"","output":{"decoded":"{\"a\":1}","encoded":"\"{\\\"a\\\":1}\""}},{"input":"\"\\ud800AKIAIOSFODNN7EXAMPLE 䟛\"","output":{"decoded":"\ud800AKIAIOSFODNN7EXAMPLE 䟛","encoded":"\"\\ud800AKIAIOSFODNN7EXAMPLE 䟛\""}},{"input":"\"GET1_000\"\\udfff","output":{"decoded":"\"GET1_000\"\\udfff","encoded":"\"\\\"GET1_000\\\"\\\\udfff\""}},{"input":"warn [1,2] 12 ","output":{"decoded":"warn [1,2] 12 ","encoded":"\"warn [1,2] 12 \""}},{"input":"\"x\\ude80sk_live_0123456789abcdefghijkl2001:db8::1\\\"quoted\\\"\"\\\"","output":{"decoded":"\"x\\ude80sk_live_0123456789abcdefghijkl2001:db8::1\\\"quoted\\\"\"\\\"","encoded":"\"\\\"x\\\\ude80sk_live_0123456789abcdefghijkl2001:db8::1\\\\\\\"quoted\\\\\\\"\\\"\\\\\\\"\""}},{"input":"\" \"","output":{"decoded":" ","encoded":"\" \""}},{"input":"\"x\\ude8010 \"\\\\","output":{"decoded":"\"x\\ude8010 \"\\\\","encoded":"\"\\\"x\\\\ude8010 \\\"\\\\\\\\\""}},{"input":"\"Infinity\"","output":{"decoded":"Infinity","encoded":"\"Infinity\""}},{"input":"\"\\u0000\\u2028\\r\\nuuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\"","output":{"decoded":"\u0000 \r\nuuid_3fa85f64-5717-4562-b3fc-2c963f66afa6","encoded":"\"\\u0000\\u2028\\r\\nuuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\""}},{"input":"\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"","output":{"decoded":"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé","encoded":"\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\""}},{"input":"-9007199254740992","output":{"decoded":"-9007199254740992","encoded":"-9007199254740992"}},{"input":"[[\"0b11AKIAIOSFODNN7EXAMPLE+5\",null,-3660743986.2564206],\"true [email protected]\",7,\"null\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","output":{"decoded":"[[\"0b11AKIAIOSFODNN7EXAMPLE+5\",null,-3660743986.2564206],\"true [email protected]\",7,\"null\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","encoded":"[[\"0b11AKIAIOSFODNN7EXAMPLE+5\",null,-3660743986.2564206],\"true [email protected]\",7,\"null\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]"}},{"input":"\"3fa85f64-5717-4562-b3fc-2c963f66afa61e+21é\"","output":{"decoded":"3fa85f64-5717-4562-b3fc-2c963f66afa61e+21é","encoded":"\"3fa85f64-5717-4562-b3fc-2c963f66afa61e+21é\""}},{"input":"\"{\\\"4294967295\\\":{},\\\"http.method\\\":{\\\"2\\\":null,\\\"50\\\":\\\"0x10 1212.5abc\\\",\\\"a.\\\":true,\\\"k\\\":\\\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀1,512 \\\",\\\"toString\\\":true}}\"","output":{"decoded":"{\"4294967295\":{},\"http.method\":{\"2\":null,\"50\":\"0x10 1212.5abc\",\"a.\":true,\"k\":\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀1,512 \",\"toString\":true}}","encoded":"\"{\\\"4294967295\\\":{},\\\"http.method\\\":{\\\"2\\\":null,\\\"50\\\":\\\"0x10 1212.5abc\\\",\\\"a.\\\":true,\\\"k\\\":\\\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀1,512 \\\",\\\"toString\\\":true}}\""}},{"input":"\"\\\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 \"\\u0000","output":{"decoded":"\"\\\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 \"\\u0000","encoded":"\"\\\"\\\\\\\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 \\\"\\\\u0000\""}},{"input":"\"1e+100\"","output":{"decoded":"1e+100","encoded":"\"1e+100\""}},{"input":"\"a\\\\ 2001:db8::1\"\\\"","output":{"decoded":"\"a\\\\ 2001:db8::1\"\\\"","encoded":"\"\\\"a\\\\\\\\ 2001:db8::1\\\"\\\\\\\"\""}},{"input":"\"4294967295\"","output":{"decoded":"4294967295","encoded":"\"4294967295\""}},{"input":"\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"","output":{"decoded":"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé","encoded":"\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\""}},{"input":"/api/v1/users/123","output":{"decoded":"/api/v1/users/123","encoded":"\"/api/v1/users/123\""}},{"input":"\"3fa85f64-5717-4562-b3fc-2c963f66afa6Wed, 15 Jan 2025 12:00:00 GMT \"\\\\","output":{"decoded":"\"3fa85f64-5717-4562-b3fc-2c963f66afa6Wed, 15 Jan 2025 12:00:00 GMT \"\\\\","encoded":"\"\\\"3fa85f64-5717-4562-b3fc-2c963f66afa6Wed, 15 Jan 2025 12:00:00 GMT \\\"\\\\\\\\\""}},{"input":"\"\\ud83d\\ude80\\r\\nAKIAIOSFODNN7EXAMPLE\"\\u0000","output":{"decoded":"\"\\ud83d\\ude80\\r\\nAKIAIOSFODNN7EXAMPLE\"\\u0000","encoded":"\"\\\"\\\\ud83d\\\\ude80\\\\r\\\\nAKIAIOSFODNN7EXAMPLE\\\"\\\\u0000\""}},{"input":"\"7\"","output":{"decoded":"7","encoded":"\"7\""}},{"input":"\\","output":{"decoded":"\\","encoded":"\"\\\\\""}},{"input":"\"debug\"","output":{"decoded":"debug","encoded":"\"debug\""}},{"input":"\"\\//api/v1/users/123 5e-324\"\\ud83d\\ude80","output":{"decoded":"\"\\//api/v1/users/123 5e-324\"\\ud83d\\ude80","encoded":"\"\\\"\\\\//api/v1/users/123 5e-324\\\"\\\\ud83d\\\\ude80\""}},{"input":"\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 12 \"","output":{"decoded":"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 12 ","encoded":"\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 12 \""}},{"input":"\"[email protected]\"","output":{"decoded":"[email protected]","encoded":"\"[email protected]\""}},{"input":"\"POST ﳳ\"","output":{"decoded":"POST ﳳ","encoded":"\"POST ﳳ\""}},{"input":"\"x\\ude80debugéééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"\\/","output":{"decoded":"\"x\\ude80debugéééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"\\/","encoded":"\"\\\"x\\\\ude80debugéééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\\\"\\\\/\""}},{"input":"-9007199254740992","output":{"decoded":"-9007199254740992","encoded":"-9007199254740992"}},{"input":"[\"INFO\",[null,-9007199254740992]]","output":{"decoded":"[\"INFO\",[null,-9007199254740992]]","encoded":"[\"INFO\",[null,-9007199254740992]]"}},{"input":"\"quoted\"","output":{"decoded":"quoted","encoded":"\"quoted\""}},{"input":"\"\\ud800日本語NaN9007199254740992\"\\udfff","output":{"decoded":"\"\\ud800日本語NaN9007199254740992\"\\udfff","encoded":"\"\\\"\\\\ud800日本語NaN9007199254740992\\\"\\\\udfff\""}},{"input":"\"xoxb-1234567890-abc\"","output":{"decoded":"xoxb-1234567890-abc","encoded":"\"xoxb-1234567890-abc\""}},{"input":"\"\\ud83d\\ud83dWed, 15 Jan 2025 12:00:00 GMT \"","output":{"decoded":"\ud83d\ud83dWed, 15 Jan 2025 12:00:00 GMT ","encoded":"\"\\ud83d\\ud83dWed, 15 Jan 2025 12:00:00 GMT \""}},{"input":"\"POST\"","output":{"decoded":"POST","encoded":"\"POST\""}},{"input":"\"\\\"toString\\\"\"","output":{"decoded":"\"toString\"","encoded":"\"\\\"toString\\\"\""}},{"input":"4294967294","output":{"decoded":"4294967294","encoded":"4294967294"}},{"input":"9007199254740992","output":{"decoded":"9007199254740992","encoded":"9007199254740992"}},{"input":"null","output":{"decoded":"null","encoded":"null"}},{"input":"\"0x10 \\u000b\\\"quoted\\\"\"\\u0000","output":{"decoded":"\"0x10 \\u000b\\\"quoted\\\"\"\\u0000","encoded":"\"\\\"0x10 \\\\u000b\\\\\\\"quoted\\\\\\\"\\\"\\\\u0000\""}},{"input":"\"POST fatal \"\\\"","output":{"decoded":"\"POST fatal \"\\\"","encoded":"\"\\\"POST fatal \\\"\\\\\\\"\""}},{"input":"5.","output":{"decoded":"5.","encoded":"\"5.\""}},{"input":"1e-7","output":{"decoded":"1e-7","encoded":"1e-7"}},{"input":"\"\\\\12__proto__1e3\"\\ud83d","output":{"decoded":"\"\\\\12__proto__1e3\"\\ud83d","encoded":"\"\\\"\\\\\\\\12__proto__1e3\\\"\\\\ud83d\""}},{"input":"\"🚀\"","output":{"decoded":"🚀","encoded":"\"🚀\""}},{"input":"\"Ӿ11\"\\ud800","output":{"decoded":"\"Ӿ11\"\\ud800","encoded":"\"\\\"Ӿ11\\\"\\\\ud800\""}},{"input":"00 ","output":{"decoded":"00 ","encoded":"\"00 \""}},{"input":"2025-01-15T10:00:00Z","output":{"decoded":"2025-01-15T10:00:00Z","encoded":"\"2025-01-15T10:00:00Z\""}},{"input":"\"日本語 2001:db8::1 \"","output":{"decoded":"日本語 2001:db8::1 ","encoded":"\"日本語 2001:db8::1 \""}},{"input":"true","output":{"decoded":"true","encoded":"true"}},{"input":"\" \"\\udfff","output":{"decoded":"\" \"\\udfff","encoded":"\"\\\" \\\"\\\\udfff\""}},{"input":"\"00\"","output":{"decoded":"00","encoded":"\"00\""}},{"input":"{\"4294967294\":{\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":0.00032134399586357176,\"a.\":1e+21},\" \":null,\"9007199254740993\":1,\"\\n\":\"4294967295é \",\"[email protected]\":999.9999999}","output":{"decoded":"{\"4294967294\":{\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":0.00032134399586357176,\"a.\":1e+21},\" \":null,\"9007199254740993\":1,\"\\n\":\"4294967295é \",\"[email protected]\":999.9999999}","encoded":"{\"4294967294\":{\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":0.00032134399586357176,\"a.\":1e+21},\" \":null,\"9007199254740993\":1,\"\\n\":\"4294967295é \",\"[email protected]\":999.9999999}"}},{"input":"-InfinityAKIAIOSFODNN7EXAMPLEé","output":{"decoded":"-InfinityAKIAIOSFODNN7EXAMPLEé","encoded":"\"-InfinityAKIAIOSFODNN7EXAMPLEé\""}},{"input":"\"error\"","output":{"decoded":"error","encoded":"\"error\""}},{"input":"true","output":{"decoded":"true","encoded":"true"}},{"input":"\"״\\u000b\"","output":{"decoded":"״\u000b","encoded":"\"״\\u000b\""}},{"input":"\"\"","output":{"decoded":"","encoded":"\"\""}},{"input":"\"x\\ude80x\\ude80𐀀 \"","output":{"decoded":"x\ude80x\ude80𐀀 ","encoded":"\"x\\ude80x\\ude80𐀀 \""}},{"input":"\"\\\"/api/v1/users/123\"x\\ude80","output":{"decoded":"\"\\\"/api/v1/users/123\"x\\ude80","encoded":"\"\\\"\\\\\\\"/api/v1/users/123\\\"x\\\\ude80\""}},{"input":"\"NaN \"","output":{"decoded":"NaN ","encoded":"\"NaN \""}},{"input":"\"\\u0000 1290071992547409944294967294\"","output":{"decoded":"\u0000 1290071992547409944294967294","encoded":"\"\\u0000 1290071992547409944294967294\""}},{"input":"[email protected] w","output":{"decoded":"[email protected] w","encoded":"\"[email protected] w\""}},{"input":"\"AKIAIOSFODNN7EXAMPLE \"","output":{"decoded":"AKIAIOSFODNN7EXAMPLE ","encoded":"\"AKIAIOSFODNN7EXAMPLE \""}},{"input":"\"\\u2028http.method🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 \"x\\ude80","output":{"decoded":"\"\\u2028http.method🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 \"x\\ude80","encoded":"\"\\\"\\\\u2028http.method🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 \\\"x\\\\ude80\""}},{"input":"null","output":{"decoded":"null","encoded":"null"}},{"input":"null","output":{"decoded":"null","encoded":"null"}},{"input":"12.5 ","output":{"decoded":"12.5 ","encoded":"12.5 "}},{"input":"日本語","output":{"decoded":"日本語","encoded":"\"日本語\""}},{"input":"\"12\"","output":{"decoded":"12","encoded":"\"12\""}},{"input":"\"\\\\\\\\4294967294ERRORuser_123\"","output":{"decoded":"\\\\4294967294ERRORuser_123","encoded":"\"\\\\\\\\4294967294ERRORuser_123\""}},{"input":"false","output":{"decoded":"false","encoded":"false"}},{"input":"\"\\udfff2.5e-8 {\\\"a\\\":1}éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"\\ud83d","output":{"decoded":"\"\\udfff2.5e-8 {\\\"a\\\":1}éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"\\ud83d","encoded":"\"\\\"\\\\udfff2.5e-8 {\\\\\\\"a\\\\\\\":1}éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\\\"\\\\ud83d\""}},{"input":"\"\\\\é \"","output":{"decoded":"\\é ","encoded":"\"\\\\é \""}},{"input":"INFO msg","output":{"decoded":"INFO msg","encoded":"\"INFO msg\""}},{"input":"false","output":{"decoded":"false","encoded":"false"}},{"input":"-9007199254740992","output":{"decoded":"-9007199254740992","encoded":"-9007199254740992"}},{"input":"\"\\\"\\nsk_live_0123456789abcdefghijkl \"","output":{"decoded":"\"\nsk_live_0123456789abcdefghijkl ","encoded":"\"\\\"\\nsk_live_0123456789abcdefghijkl \""}},{"input":"\"é\\n\"\\\"","output":{"decoded":"\"é\\n\"\\\"","encoded":"\"\\\"é\\\\n\\\"\\\\\\\"\""}},{"input":"-1e400ERROR2.5e-8","output":{"decoded":"-1e400ERROR2.5e-8","encoded":"\"-1e400ERROR2.5e-8\""}},{"input":"\"ERROR\"","output":{"decoded":"ERROR","encoded":"\"ERROR\""}},{"input":"4294967295","output":{"decoded":"4294967295","encoded":"4294967295"}},{"input":"\"[\\\"\\\\\\\" \\\",{\\\"9007199254740993\\\":[\\\"-1e400 \\\",null,{\\\"__defineGetter__\\\":true},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\"","output":{"decoded":"[\"\\\" \",{\"9007199254740993\":[\"-1e400 \",null,{\"__defineGetter__\":true},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","encoded":"\"[\\\"\\\\\\\" \\\",{\\\"9007199254740993\\\":[\\\"-1e400 \\\",null,{\\\"__defineGetter__\\\":true},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\""}},{"input":"\"\\udfff2025-01-15T10:00:00Z\\r\\n 1e+100\"\\\\","output":{"decoded":"\"\\udfff2025-01-15T10:00:00Z\\r\\n 1e+100\"\\\\","encoded":"\"\\\"\\\\udfff2025-01-15T10:00:00Z\\\\r\\\\n 1e+100\\\"\\\\\\\\\""}},{"input":"\"\\r\\n\"","output":{"decoded":"\r\n","encoded":"\"\\r\\n\""}},{"input":"\"123456789012345680000fatal \"","output":{"decoded":"123456789012345680000fatal ","encoded":"\"123456789012345680000fatal \""}},{"input":"5e-324","output":{"decoded":"5e-324","encoded":"5e-324"}},{"input":"\"x\\ude80eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 \"","output":{"decoded":"x\ude80eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 ","encoded":"\"x\\ude80eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 \""}},{"input":"\"AKIAIOSFODNN7EXAMPLE\"","output":{"decoded":"AKIAIOSFODNN7EXAMPLE","encoded":"\"AKIAIOSFODNN7EXAMPLE\""}},{"input":"[\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\",null,-127667045919224.62,[5e-324,null,\" 12🚀\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","output":{"decoded":"[\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\",null,-127667045919224.62,[5e-324,null,\" 12🚀\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","encoded":"[\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\",null,-127667045919224.62,[5e-324,null,\" 12🚀\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]"}},{"input":"{\"level\":{\"4294967296\":{\" \":true,\"\\\\\":\"1_000 true\",\"é\":[null,true,1,1,1,1,1,1,1,1]}}}","output":{"decoded":"{\"level\":{\"4294967296\":{\" \":true,\"\\\\\":\"1_000 true\",\"é\":[null,true,1,1,1,1,1,1,1,1]}}}","encoded":"{\"level\":{\"4294967296\":{\" \":true,\"\\\\\":\"1_000 true\",\"é\":[null,true,1,1,1,1,1,1,1,1]}}}"}},{"input":"\"192.168.0.10x10 \"","output":{"decoded":"192.168.0.10x10 ","encoded":"\"192.168.0.10x10 \""}},{"input":"\"\\\"2.5e-8ERROR \"x\\ude80","output":{"decoded":"\"\\\"2.5e-8ERROR \"x\\ude80","encoded":"\"\\\"\\\\\\\"2.5e-8ERROR \\\"x\\\\ude80\""}},{"input":"{\"a\":1} 4294967296🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀","output":{"decoded":"{\"a\":1} 4294967296🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀","encoded":"\"{\\\"a\\\":1} 4294967296🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\""}},{"input":"\"\\ud83d120.000001\"\\ud83d","output":{"decoded":"\"\\ud83d120.000001\"\\ud83d","encoded":"\"\\\"\\\\ud83d120.000001\\\"\\\\ud83d\""}},{"input":"\"-1.5 \"x\\ude80","output":{"decoded":"\"-1.5 \"x\\ude80","encoded":"\"\\\"-1.5 \\\"x\\\\ude80\""}},{"input":"\"[true,{\\\"1\\\":true,\\\"5\\\":true,\\\"100\\\":\\\"xéééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\\\",\\\"1.5\\\":-1.5,\\\"K\\\":0.30000000000000004},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\"","output":{"decoded":"[true,{\"1\":true,\"5\":true,\"100\":\"xéééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\",\"1.5\":-1.5,\"K\":0.30000000000000004},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","encoded":"\"[true,{\\\"1\\\":true,\\\"5\\\":true,\\\"100\\\":\\\"xéééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\\\",\\\"1.5\\\":-1.5,\\\"K\\\":0.30000000000000004},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\""}},{"input":"\" 12\"","output":{"decoded":" 12","encoded":"\" 12\""}},{"input":"\"\\ud83d999.9999999debug\"","output":{"decoded":"\ud83d999.9999999debug","encoded":"\"\\ud83d999.9999999debug\""}},{"input":"\"\\ud83d܆ 𐀀\"","output":{"decoded":"\ud83d܆ 𐀀","encoded":"\"\\ud83d܆ 𐀀\""}},{"input":"\"0 \"","output":{"decoded":"0 ","encoded":"\"0 \""}},{"input":"\"\\\"0b11\\\"\"","output":{"decoded":"\"0b11\"","encoded":"\"\\\"0b11\\\"\""}},{"input":"\"\\ud83d\\ude80[1,2]\"\\/","output":{"decoded":"\"\\ud83d\\ude80[1,2]\"\\/","encoded":"\"\\\"\\\\ud83d\\\\ude80[1,2]\\\"\\\\/\""}},{"input":"[[null,{\"4294967296\":[1,\"0x10 .a\",true,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1]","output":{"decoded":"[[null,{\"4294967296\":[1,\"0x10 .a\",true,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1]","encoded":"[[null,{\"4294967296\":[1,\"0x10 .a\",true,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1]"}},{"input":"\"null\"","output":{"decoded":"null","encoded":"\"null\""}},{"input":"\"constructor 🚀 a\\\\nb\"\\/","output":{"decoded":"\"constructor 🚀 a\\\\nb\"\\/","encoded":"\"\\\"constructor 🚀 a\\\\\\\\nb\\\"\\\\/\""}},{"input":"2001:db8::1","output":{"decoded":"2001:db8::1","encoded":"\"2001:db8::1\""}},{"input":"\"deadbeef 1e3\"","output":{"decoded":"deadbeef 1e3","encoded":"\"deadbeef 1e3\""}},{"input":"\"\\r\\n\"","output":{"decoded":"\r\n","encoded":"\"\\r\\n\""}},{"input":"\"0b11fatal\"","output":{"decoded":"0b11fatal","encoded":"\"0b11fatal\""}},{"input":"\"\\\"+5.5🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\\\"\"","output":{"decoded":"\"+5.5🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"","encoded":"\"\\\"+5.5🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\\\"\""}},{"input":"\"x\\ude80豯125.\"\\ud83d\\ude80","output":{"decoded":"\"x\\ude80豯125.\"\\ud83d\\ude80","encoded":"\"\\\"x\\\\ude80豯125.\\\"\\\\ud83d\\\\ude80\""}},{"input":"\"\\u0000xoxb-1234567890-abc0b11 \"","output":{"decoded":"\u0000xoxb-1234567890-abc0b11 ","encoded":"\"\\u0000xoxb-1234567890-abc0b11 \""}},{"input":"\"ERROR\"","output":{"decoded":"ERROR","encoded":"\"ERROR\""}},{"input":"\"\\ud83d\\\"e \"","output":{"decoded":"\ud83d\"e ","encoded":"\"\\ud83d\\\"e \""}},{"input":"\"sk_live_0123456789abcdefghijkl\"","output":{"decoded":"sk_live_0123456789abcdefghijkl","encoded":"\"sk_live_0123456789abcdefghijkl\""}},{"input":"\"x\\ude80\\u202842949672950o7\\\\\"","output":{"decoded":"x\ude80 42949672950o7\\","encoded":"\"x\\ude80\\u202842949672950o7\\\\\""}},{"input":"\"\\\"NaN\"\\/","output":{"decoded":"\"\\\"NaN\"\\/","encoded":"\"\\\"\\\\\\\"NaN\\\"\\\\/\""}},{"input":"\"\\udfff 0o7 \"","output":{"decoded":"\udfff 0o7 ","encoded":"\"\\udfff 0o7 \""}},{"input":"\"[null,\\\"Infinity \\\",\\\"+5a\\\\\\\\nb\\\",null,5e-324,4294967295,\\\"4294967294.a\\\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\"","output":{"decoded":"[null,\"Infinity \",\"+5a\\\\nb\",null,5e-324,4294967295,\"4294967294.a\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","encoded":"\"[null,\\\"Infinity \\\",\\\"+5a\\\\\\\\nb\\\",null,5e-324,4294967295,\\\"4294967294.a\\\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\""}},{"input":"false","output":{"decoded":"false","encoded":"false"}},{"input":"\"Bearer abc.def-ghié\"","output":{"decoded":"Bearer abc.def-ghié","encoded":"\"Bearer abc.def-ghié\""}},{"input":"\"/ 日本語\"x\\ude80","output":{"decoded":"\"/ 日本語\"x\\ude80","encoded":"\"\\\"/ 日本語\\\"x\\\\ude80\""}},{"input":"\"xoxb-1234567890-abc1e30\"\\\\","output":{"decoded":"\"xoxb-1234567890-abc1e30\"\\\\","encoded":"\"\\\"xoxb-1234567890-abc1e30\\\"\\\\\\\\\""}},{"input":"\"4294967295 \"\\ud800\\ud83d","output":{"decoded":"\"4294967295 \"\\ud800\\ud83d","encoded":"\"\\\"4294967295 \\\"\\\\ud800\\\\ud83d\""}},{"input":"\"\\ud83dINFOhost.example.com\"","output":{"decoded":"\ud83dINFOhost.example.com","encoded":"\"\\ud83dINFOhost.example.com\""}},{"input":"{}","output":{"decoded":"{}","encoded":"{}"}},{"input":"\" warn0\"","output":{"decoded":" warn0","encoded":"\" warn0\""}},{"input":"[1.5,{\"51\":[[false,\" ghp_0123456789abcdefghij0123456789abcdef level\",false,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","output":{"decoded":"[1.5,{\"51\":[[false,\" ghp_0123456789abcdefghij0123456789abcdef level\",false,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","encoded":"[1.5,{\"51\":[[false,\" ghp_0123456789abcdefghij0123456789abcdef level\",false,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]"}},{"input":"\"\\u0000éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé a\\\\nb \"","output":{"decoded":"\u0000éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé a\\nb ","encoded":"\"\\u0000éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé a\\\\nb \""}},{"input":"\"{\\\"a\\\":1}1_000\"\\ud83d\\ude80\\/","output":{"decoded":"\"{\\\"a\\\":1}1_000\"\\ud83d\\ude80\\/","encoded":"\"\\\"{\\\\\\\"a\\\\\\\":1}1_000\\\"\\\\ud83d\\\\ude80\\\\/\""}},{"input":"\" 12 12\"","output":{"decoded":" 12 12","encoded":"\" 12 12\""}},{"input":"\"sk_live_0123456789abcdefghijkl \"","output":{"decoded":"sk_live_0123456789abcdefghijkl ","encoded":"\"sk_live_0123456789abcdefghijkl \""}},{"input":"null","output":{"decoded":"null","encoded":"null"}},{"input":"\"x\\ude80payload 00 \"x\\ude80","output":{"decoded":"\"x\\ude80payload 00 \"x\\ude80","encoded":"\"\\\"x\\\\ude80payload 00 \\\"x\\\\ude80\""}},{"input":"\"12.5abc\"","output":{"decoded":"12.5abc","encoded":"\"12.5abc\""}},{"input":"\"x\"","output":{"decoded":"x","encoded":"\"x\""}},{"input":" 12 ","output":{"decoded":" 12 ","encoded":" 12 "}},{"input":"1","output":{"decoded":"1","encoded":"1"}},{"input":"\"\\\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123192.168.0.1\"\\ud83d\\ude80","output":{"decoded":"\"\\\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123192.168.0.1\"\\ud83d\\ude80","encoded":"\"\\\"\\\\\\\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123192.168.0.1\\\"\\\\ud83d\\\\ude80\""}},{"input":"\"1_000 [email protected] \\\\\"","output":{"decoded":"1_000 [email protected] \\","encoded":"\"1_000 [email protected] \\\\\""}},{"input":"\"\\\\1_000 \"","output":{"decoded":"\\1_000 ","encoded":"\"\\\\1_000 \""}},{"input":"0","output":{"decoded":"0","encoded":"0"}},{"input":"\"\\r\\n\"","output":{"decoded":"\r\n","encoded":"\"\\r\\n\""}},{"input":"\"123456789012345680000 日本語 12 \"\\\"","output":{"decoded":"\"123456789012345680000 日本語 12 \"\\\"","encoded":"\"\\\"123456789012345680000 日本語 12 \\\"\\\\\\\"\""}},{"input":"\"Bearer abc.def-ghi 12error \"","output":{"decoded":"Bearer abc.def-ghi 12error ","encoded":"\"Bearer abc.def-ghi 12error \""}},{"input":"\"null\"","output":{"decoded":"null","encoded":"\"null\""}},{"input":"\"0.0000012.5e-80o7\"","output":{"decoded":"0.0000012.5e-80o7","encoded":"\"0.0000012.5e-80o7\""}},{"input":"\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\"\\ud800","output":{"decoded":"\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\"\\ud800","encoded":"\"\\\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\\\"\\\\ud800\""}},{"input":" ","output":{"decoded":" ","encoded":"\" \""}},{"input":"k ","output":{"decoded":"k ","encoded":"\"k \""}},{"input":"false","output":{"decoded":"false","encoded":"false"}},{"input":"\"1,5\"","output":{"decoded":"1,5","encoded":"\"1,5\""}},{"input":"12","output":{"decoded":"12","encoded":"\"12\""}},{"input":"\"léAKIAIOSFODNN7EXAMPLE \"","output":{"decoded":"léAKIAIOSFODNN7EXAMPLE ","encoded":"\"léAKIAIOSFODNN7EXAMPLE \""}},{"input":"\"\\ud83d\\ude80\\u0000hasOwnPropertywarn 1e3 \"","output":{"decoded":"🚀\u0000hasOwnPropertywarn 1e3 ","encoded":"\"\\ud83d\\ude80\\u0000hasOwnPropertywarn 1e3 \""}},{"input":"\"\\\"ö🚀 -Infinity\\\"\"","output":{"decoded":"\"ö🚀 -Infinity\"","encoded":"\"\\\"ö🚀 -Infinity\\\"\""}},{"input":"\"\\ud83dsk_live_0123456789abcdefghijkllevel ghp_0123456789abcdefghij0123456789abcdef \"\\/","output":{"decoded":"\"\\ud83dsk_live_0123456789abcdefghijkllevel ghp_0123456789abcdefghij0123456789abcdef \"\\/","encoded":"\"\\\"\\\\ud83dsk_live_0123456789abcdefghijkllevel ghp_0123456789abcdefghij0123456789abcdef \\\"\\\\/\""}},{"input":"\"9007199254740994 \"","output":{"decoded":"9007199254740994 ","encoded":"\"9007199254740994 \""}},{"input":"\"\\u0000ghp_0123456789abcdefghij0123456789abcdef0 \"\\ud800","output":{"decoded":"\"\\u0000ghp_0123456789abcdefghij0123456789abcdef0 \"\\ud800","encoded":"\"\\\"\\\\u0000ghp_0123456789abcdefghij0123456789abcdef0 \\\"\\\\ud800\""}},{"input":"debug","output":{"decoded":"debug","encoded":"\"debug\""}},{"input":"999.9999999","output":{"decoded":"999.9999999","encoded":"999.9999999"}},{"input":"\"日本語\"","output":{"decoded":"日本語","encoded":"\"日本語\""}},{"input":"\"\\ud83d\\ude80K 0.000001 \"","output":{"decoded":"🚀K 0.000001 ","encoded":"\"\\ud83d\\ude80K 0.000001 \""}},{"input":"1e-7","output":{"decoded":"1e-7","encoded":"1e-7"}},{"input":"\"9007199254740993\"","output":{"decoded":"9007199254740993","encoded":"\"9007199254740993\""}},{"input":"-1.5","output":{"decoded":"-1.5","encoded":"-1.5"}},{"input":"\"2.5e-8\"\\u0000","output":{"decoded":"\"2.5e-8\"\\u0000","encoded":"\"\\\"2.5e-8\\\"\\\\u0000\""}},{"input":"\"\\ud83d\\ude8010 \"\\/","output":{"decoded":"\"\\ud83d\\ude8010 \"\\/","encoded":"\"\\\"\\\\ud83d\\\\ude8010 \\\"\\\\/\""}},{"input":"4294967295","output":{"decoded":"4294967295","encoded":"4294967295"}},{"input":"\"Bearer abc.def-ghi\"","output":{"decoded":"Bearer abc.def-ghi","encoded":"\"Bearer abc.def-ghi\""}},{"input":"\"12.5abc\"","output":{"decoded":"12.5abc","encoded":"\"12.5abc\""}},{"input":"\"12\"","output":{"decoded":"12","encoded":"\"12\""}},{"input":"\"12\"","output":{"decoded":"12","encoded":"\"12\""}},{"input":"2.5e-8","output":{"decoded":"2.5e-8","encoded":"2.5e-8"}},{"input":"\"\\\\7\\nevent\"","output":{"decoded":"\\7\nevent","encoded":"\"\\\\7\\nevent\""}},{"input":"\"\\/.a\"\\/","output":{"decoded":"\"\\/.a\"\\/","encoded":"\"\\\"\\\\/.a\\\"\\\\/\""}},{"input":"\"1,5\"\\ud800","output":{"decoded":"\"1,5\"\\ud800","encoded":"\"\\\"1,5\\\"\\\\ud800\""}},{"input":"\"xoxb-1234567890-abc\"","output":{"decoded":"xoxb-1234567890-abc","encoded":"\"xoxb-1234567890-abc\""}},{"input":"[email protected]","output":{"decoded":"[email protected]","encoded":"\"[email protected]\""}},{"input":"3fa85f64-5717-4562-b3fc-2c963f66afa6 뿌 ","output":{"decoded":"3fa85f64-5717-4562-b3fc-2c963f66afa6 뿌 ","encoded":"\"3fa85f64-5717-4562-b3fc-2c963f66afa6 뿌 \""}},{"input":"\"0o7 -1e400 \"","output":{"decoded":"0o7 -1e400 ","encoded":"\"0o7 -1e400 \""}},{"input":"\"3.4983989782631395e-7\"","output":{"decoded":"3.4983989782631395e-7","encoded":"\"3.4983989782631395e-7\""}},{"input":"{\"9007199254740993\":{\"1\":[{\"1\":\"2025-01-15T10:00:00Z🚀12\",\"10\":\"0b11 Bearer abc.def-ghi\",\"AKIAIOSFODNN7EXAMPLEWed, 15 Jan 2025 12:00:00 GMT\":9007199254740994,\"牡\":\"1e400x error\"},1]}}","output":{"decoded":"{\"9007199254740993\":{\"1\":[{\"1\":\"2025-01-15T10:00:00Z🚀12\",\"10\":\"0b11 Bearer abc.def-ghi\",\"AKIAIOSFODNN7EXAMPLEWed, 15 Jan 2025 12:00:00 GMT\":9007199254740994,\"牡\":\"1e400x error\"},1]}}","encoded":"{\"9007199254740993\":{\"1\":[{\"1\":\"2025-01-15T10:00:00Z🚀12\",\"10\":\"0b11 Bearer abc.def-ghi\",\"AKIAIOSFODNN7EXAMPLEWed, 15 Jan 2025 12:00:00 GMT\":9007199254740994,\"牡\":\"1e400x error\"},1]}}"}},{"input":"null","output":{"decoded":"null","encoded":"null"}},{"input":"\"3fa85f64-5717-4562-b3fc-2c963f66afa60\"","output":{"decoded":"3fa85f64-5717-4562-b3fc-2c963f66afa60","encoded":"\"3fa85f64-5717-4562-b3fc-2c963f66afa60\""}},{"input":"\"\\ud83d0.1 192.168.0.1日本語\"\\ud800","output":{"decoded":"\"\\ud83d0.1 192.168.0.1日本語\"\\ud800","encoded":"\"\\\"\\\\ud83d0.1 192.168.0.1日本語\\\"\\\\ud800\""}},{"input":"\"\\\"[1,2]level \"","output":{"decoded":"\"[1,2]level ","encoded":"\"\\\"[1,2]level \""}},{"input":"\"b\"","output":{"decoded":"b","encoded":"\"b\""}},{"input":"[1,2]","output":{"decoded":"[1,2]","encoded":"[1,2]"}},{"input":"\"error\"","output":{"decoded":"error","encoded":"\"error\""}},{"input":"\"{\\\"4294967295\\\":null,\\\"__proto__\\\":\\\"˒ \\\\u000b\\\",\\\"\\\\t\\\":[],\\\"..\\\":-9007199254740992,\\\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-1e400\\\":\\\"xoxb-1234567890-abc \\\",\\\"debugevent\\\":[false,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}\"","output":{"decoded":"{\"4294967295\":null,\"__proto__\":\"˒ \\u000b\",\"\\t\":[],\"..\":-9007199254740992,\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-1e400\":\"xoxb-1234567890-abc \",\"debugevent\":[false,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}","encoded":"\"{\\\"4294967295\\\":null,\\\"__proto__\\\":\\\"˒ \\\\u000b\\\",\\\"\\\\t\\\":[],\\\"..\\\":-9007199254740992,\\\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-1e400\\\":\\\"xoxb-1234567890-abc \\\",\\\"debugevent\\\":[false,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}\""}},{"input":"9007199254740994 ","output":{"decoded":"9007199254740994 ","encoded":"9007199254740994 "}},{"input":"\"+5\"","output":{"decoded":"+5","encoded":"\"+5\""}},{"input":"\"\\ud800null🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀ᴓ\"\\ud83d","output":{"decoded":"\"\\ud800null🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀ᴓ\"\\ud83d","encoded":"\"\\\"\\\\ud800null🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀ᴓ\\\"\\\\ud83d\""}},{"input":"\"\\\"quoted\\\"\"","output":{"decoded":"\"quoted\"","encoded":"\"\\\"quoted\\\"\""}},{"input":"\"x\\ude80\\r\\n4294967296\"\\ud800","output":{"decoded":"\"x\\ude80\\r\\n4294967296\"\\ud800","encoded":"\"\\\"x\\\\ude80\\\\r\\\\n4294967296\\\"\\\\ud800\""}},{"input":"\"\\ud800ghp_0123456789abcdefghij0123456789abcdef 999.9999999\"\\udfff","output":{"decoded":"\"\\ud800ghp_0123456789abcdefghij0123456789abcdef 999.9999999\"\\udfff","encoded":"\"\\\"\\\\ud800ghp_0123456789abcdefghij0123456789abcdef 999.9999999\\\"\\\\udfff\""}},{"input":"\"a -1.5 \"","output":{"decoded":"a -1.5 ","encoded":"\"a -1.5 \""}},{"input":"true","output":{"decoded":"true","encoded":"true"}},{"input":"\"{\\\"50\\\":{\\\"3\\\":{\\\"4294967295\\\":{\\\"3\\\":\\\"a.121,5\\\"},\\\"k\\\":{\\\"__defineGetter__\\\":\\\"INFO.5\\\"}},\\\"deadbeef\\\":null}}\"","output":{"decoded":"{\"50\":{\"3\":{\"4294967295\":{\"3\":\"a.121,5\"},\"k\":{\"__defineGetter__\":\"INFO.5\"}},\"deadbeef\":null}}","encoded":"\"{\\\"50\\\":{\\\"3\\\":{\\\"4294967295\\\":{\\\"3\\\":\\\"a.121,5\\\"},\\\"k\\\":{\\\"__defineGetter__\\\":\\\"INFO.5\\\"}},\\\"deadbeef\\\":null}}\""}},{"input":"12 error ","output":{"decoded":"12 error ","encoded":"\"12 error \""}},{"input":"xoxb-1234567890-abc","output":{"decoded":"xoxb-1234567890-abc","encoded":"\"xoxb-1234567890-abc\""}},{"input":"\"x\\ude80Infinity Bearer abc.def-ghi\"","output":{"decoded":"x\ude80Infinity Bearer abc.def-ghi","encoded":"\"x\\ude80Infinity Bearer abc.def-ghi\""}},{"input":"\"\\\"a\\\\nb192.168.1.1\"\\/","output":{"decoded":"\"\\\"a\\\\nb192.168.1.1\"\\/","encoded":"\"\\\"\\\\\\\"a\\\\\\\\nb192.168.1.1\\\"\\\\/\""}},{"input":"\"{\\\"a\\\":1}\"","output":{"decoded":"{\"a\":1}","encoded":"\"{\\\"a\\\":1}\""}},{"input":"\"{\\\"a\\\":1}\"","output":{"decoded":"{\"a\":1}","encoded":"\"{\\\"a\\\":1}\""}},{"input":"\"1.5 true \"","output":{"decoded":"1.5 true ","encoded":"\"1.5 true \""}},{"input":"\"\\u0000x\\ude804294967295 ERROR\"","output":{"decoded":"\u0000x\ude804294967295 ERROR","encoded":"\"\\u0000x\\ude804294967295 ERROR\""}},{"input":"\"12\"","output":{"decoded":"12","encoded":"\"12\""}},{"input":"\"http.methodlevel\"\\u0000\\u2028","output":{"decoded":"\"http.methodlevel\"\\u0000\\u2028","encoded":"\"\\\"http.methodlevel\\\"\\\\u0000\\\\u2028\""}},{"input":"\"warn\"\\ud83d","output":{"decoded":"\"warn\"\\ud83d","encoded":"\"\\\"warn\\\"\\\\ud83d\""}},{"input":"\"{\\\"1\\\":\\\"a \\\",\\\"sk_live_0123456789abcdefghijkl \\\":[null,1.8291046214289963e-15,\\\"warn0k\\\"],\\\"fataleyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\\\":{\\\"http.method\\\":null}}\"","output":{"decoded":"{\"1\":\"a \",\"sk_live_0123456789abcdefghijkl \":[null,1.8291046214289963e-15,\"warn0k\"],\"fataleyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\":{\"http.method\":null}}","encoded":"\"{\\\"1\\\":\\\"a \\\",\\\"sk_live_0123456789abcdefghijkl \\\":[null,1.8291046214289963e-15,\\\"warn0k\\\"],\\\"fataleyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\\\":{\\\"http.method\\\":null}}\""}},{"input":"\"\\udfffGET \"\\ud83d\\ude80","output":{"decoded":"\"\\udfffGET \"\\ud83d\\ude80","encoded":"\"\\\"\\\\udfffGET \\\"\\\\ud83d\\\\ude80\""}},{"input":"\"00\"","output":{"decoded":"00","encoded":"\"00\""}},{"input":"\"NaN0\"","output":{"decoded":"NaN0","encoded":"\"NaN0\""}},{"input":"0.000001","output":{"decoded":"0.000001","encoded":"0.000001"}},{"input":"\"NaN\"","output":{"decoded":"NaN","encoded":"\"NaN\""}},{"input":"3fa85f64-5717-4562-b3fc-2c963f66afa6","output":{"decoded":"3fa85f64-5717-4562-b3fc-2c963f66afa6","encoded":"\"3fa85f64-5717-4562-b3fc-2c963f66afa6\""}},{"input":"\" \"","output":{"decoded":" ","encoded":"\" \""}},{"input":"\"\\\"xoxb-1234567890-abcBearer abc.def-ghi [email protected]\"","output":{"decoded":"\"xoxb-1234567890-abcBearer abc.def-ghi [email protected]","encoded":"\"\\\"xoxb-1234567890-abcBearer abc.def-ghi [email protected]\""}},{"input":"\"\\\\\\udfff 0 Wed, 15 Jan 2025 12:00:00 GMT \"","output":{"decoded":"\\\udfff 0 Wed, 15 Jan 2025 12:00:00 GMT ","encoded":"\"\\\\\\udfff 0 Wed, 15 Jan 2025 12:00:00 GMT \""}},{"input":"\"x\\ude80 Bearer abc.def-ghi\"\\\"","output":{"decoded":"\"x\\ude80 Bearer abc.def-ghi\"\\\"","encoded":"\"\\\"x\\\\ude80 Bearer abc.def-ghi\\\"\\\\\\\"\""}},{"input":"\"xoxb-1234567890-abc\"","output":{"decoded":"xoxb-1234567890-abc","encoded":"\"xoxb-1234567890-abc\""}},{"input":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"","output":{"decoded":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","encoded":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\""}},{"input":"\"NaN\"","output":{"decoded":"NaN","encoded":"\"NaN\""}},{"input":"\"x\\ude80+5 ߆9007199254740993\"\\ud800","output":{"decoded":"\"x\\ude80+5 ߆9007199254740993\"\\ud800","encoded":"\"\\\"x\\\\ude80+5 ߆9007199254740993\\\"\\\\ud800\""}},{"input":"\"1e400ʹ U\"","output":{"decoded":"1e400ʹ U","encoded":"\"1e400ʹ U\""}},{"input":"\" 12\"","output":{"decoded":" 12","encoded":"\" 12\""}},{"input":"-9007199254740992","output":{"decoded":"-9007199254740992","encoded":"-9007199254740992"}},{"input":"\"\\u00001🚀\"\\\"","output":{"decoded":"\"\\u00001🚀\"\\\"","encoded":"\"\\\"\\\\u00001🚀\\\"\\\\\\\"\""}},{"input":"\r\n","output":{"decoded":"\r\n","encoded":"\"\\r\\n\""}},{"input":"\"\\ud800ݻ \"\\\\","output":{"decoded":"\"\\ud800ݻ \"\\\\","encoded":"\"\\\"\\\\ud800ݻ \\\"\\\\\\\\\""}},{"input":"12","output":{"decoded":"12","encoded":"12"}},{"input":"\"\\u2028.51,5 \"\\u0000","output":{"decoded":"\"\\u2028.51,5 \"\\u0000","encoded":"\"\\\"\\\\u2028.51,5 \\\"\\\\u0000\""}},{"input":"\"false\"","output":{"decoded":"false","encoded":"\"false\""}},{"input":"\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"","output":{"decoded":"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé","encoded":"\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\""}},{"input":"1.5","output":{"decoded":"1.5","encoded":"1.5"}},{"input":"1.5 .adeadbeef ","output":{"decoded":"1.5 .adeadbeef ","encoded":"\"1.5 .adeadbeef \""}},{"input":"\"/api/v1/users/123 -9007199254740992k\"","output":{"decoded":"/api/v1/users/123 -9007199254740992k","encoded":"\"/api/v1/users/123 -9007199254740992k\""}},{"input":"\"2001:db8::1\"","output":{"decoded":"2001:db8::1","encoded":"\"2001:db8::1\""}},{"input":"false","output":{"decoded":"false","encoded":"false"}},{"input":"\"false\"","output":{"decoded":"false","encoded":"\"false\""}},{"input":"\" \"","output":{"decoded":" ","encoded":"\" \""}},{"input":"\"0.1toString �\"\\u2028","output":{"decoded":"\"0.1toString �\"\\u2028","encoded":"\"\\\"0.1toString �\\\"\\\\u2028\""}},{"input":"0.000001 ","output":{"decoded":"0.000001 ","encoded":"0.000001 "}},{"input":"\"GET\"","output":{"decoded":"GET","encoded":"\"GET\""}},{"input":"\"INFOAKIAIOSFODNN7EXAMPLE\"\\u0000","output":{"decoded":"\"INFOAKIAIOSFODNN7EXAMPLE\"\\u0000","encoded":"\"\\\"INFOAKIAIOSFODNN7EXAMPLE\\\"\\\\u0000\""}},{"input":"\"x\\ude80Wed, 15 Jan 2025 12:00:00 GMT 0\"\\u0000","output":{"decoded":"\"x\\ude80Wed, 15 Jan 2025 12:00:00 GMT 0\"\\u0000","encoded":"\"\\\"x\\\\ude80Wed, 15 Jan 2025 12:00:00 GMT 0\\\"\\\\u0000\""}},{"input":"-1.5","output":{"decoded":"-1.5","encoded":"-1.5"}},{"input":"\"1,5/api/v1/users/123 \"","output":{"decoded":"1,5/api/v1/users/123 ","encoded":"\"1,5/api/v1/users/123 \""}},{"input":"host.example.comé ","output":{"decoded":"host.example.comé ","encoded":"\"host.example.comé \""}},{"input":"null","output":{"decoded":"null","encoded":"null"}},{"input":"\"true Bearer abc.def-ghi\"","output":{"decoded":"true Bearer abc.def-ghi","encoded":"\"true Bearer abc.def-ghi\""}},{"input":"\"\\/𞊡\"\\ud83d","output":{"decoded":"\"\\/𞊡\"\\ud83d","encoded":"\"\\\"\\\\/𞊡\\\"\\\\ud83d\""}},{"input":"\"10\"","output":{"decoded":"10","encoded":"\"10\""}},{"input":"\"00 12 \"","output":{"decoded":"00 12 ","encoded":"\"00 12 \""}},{"input":"\"\\u000bۍ7\"\\ud800","output":{"decoded":"\"\\u000bۍ7\"\\ud800","encoded":"\"\\\"\\\\u000bۍ7\\\"\\\\ud800\""}},{"input":"sk_live_0123456789abcdefghijkl/api/v1/users/123 \r\n","output":{"decoded":"sk_live_0123456789abcdefghijkl/api/v1/users/123 \r\n","encoded":"\"sk_live_0123456789abcdefghijkl/api/v1/users/123 \\r\\n\""}},{"input":"\"error\"","output":{"decoded":"error","encoded":"\"error\""}},{"input":"\"1e400\"","output":{"decoded":"1e400","encoded":"\"1e400\""}},{"input":"true","output":{"decoded":"true","encoded":"true"}},{"input":"\"x\\ude80\\\\0o7fatal\"","output":{"decoded":"x\ude80\\0o7fatal","encoded":"\"x\\ude80\\\\0o7fatal\""}},{"input":"\" \\u000b\"","output":{"decoded":" \u000b","encoded":"\" \\u000b\""}},{"input":"\"\\u202812.5/api/v1/users/1231e-7\"\\\"","output":{"decoded":"\"\\u202812.5/api/v1/users/1231e-7\"\\\"","encoded":"\"\\\"\\\\u202812.5/api/v1/users/1231e-7\\\"\\\\\\\"\""}},{"input":"\"🚀\"","output":{"decoded":"🚀","encoded":"\"🚀\""}},{"input":"\"Wed, 15 Jan 2025 12:00:00 GMT\"","output":{"decoded":"Wed, 15 Jan 2025 12:00:00 GMT","encoded":"\"Wed, 15 Jan 2025 12:00:00 GMT\""}},{"input":"-1","output":{"decoded":"-1","encoded":"-1"}},{"input":"\"-1e400INFO\"\\\\\\ud800","output":{"decoded":"\"-1e400INFO\"\\\\\\ud800","encoded":"\"\\\"-1e400INFO\\\"\\\\\\\\\\\\ud800\""}},{"input":"\".5Infinity00\"","output":{"decoded":".5Infinity00","encoded":"\".5Infinity00\""}},{"input":"\"0o74294967296toString\"\\\"","output":{"decoded":"\"0o74294967296toString\"\\\"","encoded":"\"\\\"0o74294967296toString\\\"\\\\\\\"\""}},{"input":"\"🚀 \"\\ud800","output":{"decoded":"\"🚀 \"\\ud800","encoded":"\"\\\"🚀 \\\"\\\\ud800\""}},{"input":"warn","output":{"decoded":"warn","encoded":"\"warn\""}},{"input":"\" \"","output":{"decoded":" ","encoded":"\" \""}},{"input":"\"\\\"debug\\\\t \\\"\"","output":{"decoded":"\"debug\\t \"","encoded":"\"\\\"debug\\\\t \\\"\""}},{"input":"{\"4294967295\":\"level 5e-324\",\"full\":{\"4294967294\":null,\"192.168.0.1\":-0.000003562163049355149,\"..\":0}}","output":{"decoded":"{\"4294967295\":\"level 5e-324\",\"full\":{\"4294967294\":null,\"192.168.0.1\":-0.000003562163049355149,\"..\":0}}","encoded":"{\"4294967295\":\"level 5e-324\",\"full\":{\"4294967294\":null,\"192.168.0.1\":-0.000003562163049355149,\"..\":0}}"}},{"input":"\"\\\\🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 3fa85f64-5717-4562-b3fc-2c963f66afa6\"","output":{"decoded":"\\🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 3fa85f64-5717-4562-b3fc-2c963f66afa6","encoded":"\"\\\\🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 3fa85f64-5717-4562-b3fc-2c963f66afa6\""}},{"input":"\"12\"","output":{"decoded":"12","encoded":"\"12\""}},{"input":"\"-0\"","output":{"decoded":"-0","encoded":"\"-0\""}},{"input":"\"\\\"errorfatal\"\\ud83d","output":{"decoded":"\"\\\"errorfatal\"\\ud83d","encoded":"\"\\\"\\\\\\\"errorfatal\\\"\\\\ud83d\""}},{"input":"\"\\\\eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\"x\\ude80","output":{"decoded":"\"\\\\eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\"x\\ude80","encoded":"\"\\\"\\\\\\\\eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\\\"x\\\\ude80\""}},{"input":"true","output":{"decoded":"true","encoded":"true"}},{"input":"\"1e400\"","output":{"decoded":"1e400","encoded":"\"1e400\""}},{"input":"\"0.100192.168.1.1\"","output":{"decoded":"0.100192.168.1.1","encoded":"\"0.100192.168.1.1\""}},{"input":"\"1e3\"","output":{"decoded":"1e3","encoded":"\"1e3\""}},{"input":"\"\\u20280x10 .a\"\\\"","output":{"decoded":"\"\\u20280x10 .a\"\\\"","encoded":"\"\\\"\\\\u20280x10 .a\\\"\\\\\\\"\""}},{"input":"null","output":{"decoded":"null","encoded":"null"}},{"input":"\"\\\"quoted\\\"192.168.1.1 \"\\ud800","output":{"decoded":"\"\\\"quoted\\\"192.168.1.1 \"\\ud800","encoded":"\"\\\"\\\\\\\"quoted\\\\\\\"192.168.1.1 \\\"\\\\ud800\""}},{"input":"\"12\"","output":{"decoded":"12","encoded":"\"12\""}},{"input":"\"1.5 999.9999999ɔ\"","output":{"decoded":"1.5 999.9999999ɔ","encoded":"\"1.5 999.9999999ɔ\""}},{"input":"\"\\\"日本語\"\\\\","output":{"decoded":"\"\\\"日本語\"\\\\","encoded":"\"\\\"\\\\\\\"日本語\\\"\\\\\\\\\""}},{"input":"\" 12 \"","output":{"decoded":" 12 ","encoded":"\" 12 \""}},{"input":"\"x\\ude80eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\"\\u0000","output":{"decoded":"\"x\\ude80eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\"\\u0000","encoded":"\"\\\"x\\\\ude80eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\\\"\\\\u0000\""}},{"input":"\"NaN\"","output":{"decoded":"NaN","encoded":"\"NaN\""}},{"input":"\"\\ud83d\\\"truea \"","output":{"decoded":"\ud83d\"truea ","encoded":"\"\\ud83d\\\"truea \""}},{"input":"\"true\"","output":{"decoded":"true","encoded":"\"true\""}},{"input":"\"\\r\\n\"","output":{"decoded":"\r\n","encoded":"\"\\r\\n\""}},{"input":"null","output":{"decoded":"null","encoded":"null"}},{"input":"\"\\/0\"","output":{"decoded":"/0","encoded":"\"\\/0\""}},{"input":"\"0x10 🚀\"","output":{"decoded":"0x10 🚀","encoded":"\"0x10 🚀\""}},{"input":"{\"3\":null,\"\":3.582739795092493e-12,\"ERROR \":{\"k\":true,\"�\":[\"00hasOwnPropertyռ\",false,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}}","output":{"decoded":"{\"3\":null,\"\":3.582739795092493e-12,\"ERROR \":{\"k\":true,\"�\":[\"00hasOwnPropertyռ\",false,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}}","encoded":"{\"3\":null,\"\":3.582739795092493e-12,\"ERROR \":{\"k\":true,\"�\":[\"00hasOwnPropertyռ\",false,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}}"}},{"input":"ERROR","output":{"decoded":"ERROR","encoded":"\"ERROR\""}},{"input":"\"0\"","output":{"decoded":"0","encoded":"\"0\""}},{"input":"\" 12\"x\\ude80","output":{"decoded":"\" 12\"x\\ude80","encoded":"\"\\\" 12\\\"x\\\\ude80\""}},{"input":"\"\\/12 \"x\\ude80","output":{"decoded":"\"\\/12 \"x\\ude80","encoded":"\"\\\"\\\\/12 \\\"x\\\\ude80\""}},{"input":"1.7976931348623157e+308","output":{"decoded":"1.7976931348623157e+308","encoded":"1.7976931348623157e+308"}},{"input":"\"12é\"","output":{"decoded":"12é","encoded":"\"12é\""}},{"input":"7","output":{"decoded":"7","encoded":"7"}},{"input":"\"xoxb-1234567890-abc\"\\\"","output":{"decoded":"\"xoxb-1234567890-abc\"\\\"","encoded":"\"\\\"xoxb-1234567890-abc\\\"\\\\\\\"\""}},{"input":"\"\\/.5\"","output":{"decoded":"/.5","encoded":"\"\\/.5\""}},{"input":"\"\\\"0b11 \"\\u2028","output":{"decoded":"\"\\\"0b11 \"\\u2028","encoded":"\"\\\"\\\\\\\"0b11 \\\"\\\\u2028\""}},{"input":"\"{}\"","output":{"decoded":"{}","encoded":"\"{}\""}},{"input":"\"0.000001 2 \"\\\\\\\"","output":{"decoded":"\"0.000001 2 \"\\\\\\\"","encoded":"\"\\\"0.000001 2 \\\"\\\\\\\\\\\\\\\"\""}},{"input":"\"[false]\"","output":{"decoded":"[false]","encoded":"\"[false]\""}},{"input":"\"true\"","output":{"decoded":"true","encoded":"\"true\""}},{"input":"\"{\\\"1\\\":[true,true,true,null,null,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\\\"9007199254740993\\\":[]}\"","output":{"decoded":"{\"1\":[true,true,true,null,null,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\"9007199254740993\":[]}","encoded":"\"{\\\"1\\\":[true,true,true,null,null,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\\\"9007199254740993\\\":[]}\""}},{"input":"\"\\u2028\\ud83d\\ude80\\\\user_123[1,2] \"","output":{"decoded":" 🚀\\user_123[1,2] ","encoded":"\"\\u2028\\ud83d\\ude80\\\\user_123[1,2] \""}},{"input":"Wed, 15 Jan 2025 12:00:00 GMT","output":{"decoded":"Wed, 15 Jan 2025 12:00:00 GMT","encoded":"\"Wed, 15 Jan 2025 12:00:00 GMT\""}},{"input":"\"null\"","output":{"decoded":"null","encoded":"\"null\""}},{"input":"100","output":{"decoded":"100","encoded":"100"}},{"input":"\"1,5\"","output":{"decoded":"1,5","encoded":"\"1,5\""}},{"input":"[1,2]xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ","output":{"decoded":"[1,2]xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ","encoded":"\"[1,2]xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \""}},{"input":"\"1e3\"","output":{"decoded":"1e3","encoded":"\"1e3\""}},{"input":"2.5e-8","output":{"decoded":"2.5e-8","encoded":"2.5e-8"}},{"input":"㍻POST","output":{"decoded":"㍻POST","encoded":"\"㍻POST\""}},{"input":"true10000","output":{"decoded":"true10000","encoded":"\"true10000\""}},{"input":"true","output":{"decoded":"true","encoded":"true"}},{"input":"\"b\\\"[email protected]\"","output":{"decoded":"b\"[email protected]","encoded":"\"b\\\"[email protected]\""}},{"input":"\"12.5\"","output":{"decoded":"12.5","encoded":"\"12.5\""}},{"input":"\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\"x\\ude80","output":{"decoded":"\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\"x\\ude80","encoded":"\"\\\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\\\"x\\\\ude80\""}},{"input":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"","output":{"decoded":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","encoded":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\""}},{"input":"\"true\\\\ \"","output":{"decoded":"true\\ ","encoded":"\"true\\\\ \""}},{"input":"\"�0o7\"\\udfff","output":{"decoded":"\"�0o7\"\\udfff","encoded":"\"\\\"�0o7\\\"\\\\udfff\""}},{"input":"\"\\r\\n7 user_123\"","output":{"decoded":"\r\n7 user_123","encoded":"\"\\r\\n7 user_123\""}},{"input":"\"\\udfffx\\ude80\\\" .5\"","output":{"decoded":"\udfffx\ude80\" .5","encoded":"\"\\udfffx\\ude80\\\" .5\""}},{"input":"\"5.\"","output":{"decoded":"5.","encoded":"\"5.\""}},{"input":"\"x\\ude80xNaN \"\\ud83d\\ude80","output":{"decoded":"\"x\\ude80xNaN \"\\ud83d\\ude80","encoded":"\"\\\"x\\\\ude80xNaN \\\"\\\\ud83d\\\\ude80\""}},{"input":"\"\\\"Infinity.a \"","output":{"decoded":"\"Infinity.a ","encoded":"\"\\\"Infinity.a \""}},{"input":"\"\\ud83d\\ude80日本1e-7 -1.5 \"","output":{"decoded":"🚀日本1e-7 -1.5 ","encoded":"\"\\ud83d\\ude80日本1e-7 -1.5 \""}},{"input":"\"\\\\\\\"quoted\\\"2001:db8::1\"\\udfff","output":{"decoded":"\"\\\\\\\"quoted\\\"2001:db8::1\"\\udfff","encoded":"\"\\\"\\\\\\\\\\\\\\\"quoted\\\\\\\"2001:db8::1\\\"\\\\udfff\""}},{"input":"\"\\ud800\\t\"","output":{"decoded":"\ud800\t","encoded":"\"\\ud800\\t\""}},{"input":"\"0o7\"","output":{"decoded":"0o7","encoded":"\"0o7\""}},{"input":"\"AKIAIOSFODNN7EXAMPLE\"","output":{"decoded":"AKIAIOSFODNN7EXAMPLE","encoded":"\"AKIAIOSFODNN7EXAMPLE\""}},{"input":"1e-7","output":{"decoded":"1e-7","encoded":"1e-7"}},{"input":"\"12\"","output":{"decoded":"12","encoded":"\"12\""}},{"input":"\"1_000\"","output":{"decoded":"1_000","encoded":"\"1_000\""}},{"input":"\"0.1\"","output":{"decoded":"0.1","encoded":"\"0.1\""}},{"input":"\"2025-01-15T10:00:00Z\"","output":{"decoded":"2025-01-15T10:00:00Z","encoded":"\"2025-01-15T10:00:00Z\""}},{"input":"123456789012345680000","output":{"decoded":"123456789012345680000","encoded":"123456789012345680000"}},{"input":"\"ќ \"\\ud83d\\ud83d","output":{"decoded":"\"ќ \"\\ud83d\\ud83d","encoded":"\"\\\"ќ \\\"\\\\ud83d\\\\ud83d\""}},{"input":"\"0.1http.method\"","output":{"decoded":"0.1http.method","encoded":"\"0.1http.method\""}},{"input":"\"0.1k POST \"\\/","output":{"decoded":"\"0.1k POST \"\\/","encoded":"\"\\\"0.1k POST \\\"\\\\/\""}},{"input":"\"\\\\\"","output":{"decoded":"\\","encoded":"\"\\\\\""}},{"input":"\" 12\"","output":{"decoded":" 12","encoded":"\" 12\""}},{"input":"\"-1e400\"","output":{"decoded":"-1e400","encoded":"\"-1e400\""}},{"input":"\" 12\"","output":{"decoded":" 12","encoded":"\" 12\""}},{"input":"109007199254740992","output":{"decoded":"109007199254740992","encoded":"109007199254740992"}},{"input":"\"2.7496845182031395e-14\"","output":{"decoded":"2.7496845182031395e-14","encoded":"\"2.7496845182031395e-14\""}},{"input":"\"\\udfff1_000\\\"\"","output":{"decoded":"\udfff1_000\"","encoded":"\"\\udfff1_000\\\"\""}},{"input":"\"\\r\\n 1.5🚀\"x\\ude80","output":{"decoded":"\"\\r\\n 1.5🚀\"x\\ude80","encoded":"\"\\\"\\\\r\\\\n 1.5🚀\\\"x\\\\ude80\""}},{"input":"\"\\\"9007199254740993[1,2] message\"","output":{"decoded":"\"9007199254740993[1,2] message","encoded":"\"\\\"9007199254740993[1,2] message\""}},{"input":"GET","output":{"decoded":"GET","encoded":"\"GET\""}},{"input":"\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 0x10 \"\\ud800\\u2028","output":{"decoded":"\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 0x10 \"\\ud800\\u2028","encoded":"\"\\\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 0x10 \\\"\\\\ud800\\\\u2028\""}},{"input":"5e-324","output":{"decoded":"5e-324","encoded":"5e-324"}},{"input":"\"fatal\"","output":{"decoded":"fatal","encoded":"\"fatal\""}},{"input":"false","output":{"decoded":"false","encoded":"false"}},{"input":"\"true\"","output":{"decoded":"true","encoded":"\"true\""}},{"input":"\"null\"","output":{"decoded":"null","encoded":"\"null\""}},{"input":"\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"","output":{"decoded":"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀","encoded":"\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\""}},{"input":"7","output":{"decoded":"7","encoded":"7"}},{"input":"\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\"","output":{"decoded":"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123","encoded":"\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\""}},{"input":"POST","output":{"decoded":"POST","encoded":"\"POST\""}},{"input":"null","output":{"decoded":"null","encoded":"null"}},{"input":"\"__defineGetter__\"\\ud83d","output":{"decoded":"\"__defineGetter__\"\\ud83d","encoded":"\"\\\"__defineGetter__\\\"\\\\ud83d\""}},{"input":"\"\\ud8001.5\"\\/","output":{"decoded":"\"\\ud8001.5\"\\/","encoded":"\"\\\"\\\\ud8001.5\\\"\\\\/\""}},{"input":"\"x \"","output":{"decoded":"x ","encoded":"\"x \""}},{"input":"\"0.000001a. eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\"","output":{"decoded":"0.000001a. eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123","encoded":"\"0.000001a. eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\""}},{"input":"\"a\\\\nb12\"\\u2028\\ud83d","output":{"decoded":"\"a\\\\nb12\"\\u2028\\ud83d","encoded":"\"\\\"a\\\\\\\\nb12\\\"\\\\u2028\\\\ud83d\""}},{"input":"\"NaN\"","output":{"decoded":"NaN","encoded":"\"NaN\""}},{"input":"0o7 ","output":{"decoded":"0o7 ","encoded":"\"0o7 \""}},{"input":"\"x\\ude80-0 {\\\"a\\\":1}true\"","output":{"decoded":"x\ude80-0 {\"a\":1}true","encoded":"\"x\\ude80-0 {\\\"a\\\":1}true\""}},{"input":"\" 12 12.5abcInfinity \"","output":{"decoded":" 12 12.5abcInfinity ","encoded":"\" 12 12.5abcInfinity \""}},{"input":"\"\\\"1e3\\\\r\\\\nBearer abc.def-ghi\\\"\"","output":{"decoded":"\"1e3\\r\\nBearer abc.def-ghi\"","encoded":"\"\\\"1e3\\\\r\\\\nBearer abc.def-ghi\\\"\""}},{"input":"\"\\udfff日本語b \"","output":{"decoded":"\udfff日本語b ","encoded":"\"\\udfff日本語b \""}},{"input":"\"\\\"-9007199254740992129007199254740992\"\\ud800","output":{"decoded":"\"\\\"-9007199254740992129007199254740992\"\\ud800","encoded":"\"\\\"\\\\\\\"-9007199254740992129007199254740992\\\"\\\\ud800\""}},{"input":"true","output":{"decoded":"true","encoded":"true"}},{"input":"\"2025-01-15T10:00:00Z1e400\"\\u0000\\ud83d\\ude80","output":{"decoded":"\"2025-01-15T10:00:00Z1e400\"\\u0000\\ud83d\\ude80","encoded":"\"\\\"2025-01-15T10:00:00Z1e400\\\"\\\\u0000\\\\ud83d\\\\ude80\""}},{"input":"\"-0\"","output":{"decoded":"-0","encoded":"\"-0\""}},{"input":"0.000001","output":{"decoded":"0.000001","encoded":"0.000001"}},{"input":"{\"0/api/v1/users/123 \":{\"2\":null,\"host.example.com \":\"90071992547409920x10.a\",\"4294967295\":{}},\"1e3\":{\"1\":-4.975626631639898e-11,\"\\\" 12 \":false}}","output":{"decoded":"{\"0/api/v1/users/123 \":{\"2\":null,\"host.example.com \":\"90071992547409920x10.a\",\"4294967295\":{}},\"1e3\":{\"1\":-4.975626631639898e-11,\"\\\" 12 \":false}}","encoded":"{\"0/api/v1/users/123 \":{\"2\":null,\"host.example.com \":\"90071992547409920x10.a\",\"4294967295\":{}},\"1e3\":{\"1\":-4.975626631639898e-11,\"\\\" 12 \":false}}"}},{"input":"\"\\\\eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\"","output":{"decoded":"\\eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123","encoded":"\"\\\\eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\""}},{"input":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"","output":{"decoded":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","encoded":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\""}},{"input":"\"level 12\"\\\\","output":{"decoded":"\"level 12\"\\\\","encoded":"\"\\\"level 12\\\"\\\\\\\\\""}},{"input":"Ⴋ ","output":{"decoded":"Ⴋ ","encoded":"\"Ⴋ \""}},{"input":"\"fatal\"","output":{"decoded":"fatal","encoded":"\"fatal\""}},{"input":"\"日本語 POST 12 \"","output":{"decoded":"日本語 POST 12 ","encoded":"\"日本語 POST 12 \""}},{"input":"\"level \"","output":{"decoded":"level ","encoded":"\"level \""}},{"input":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"","output":{"decoded":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","encoded":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\""}},{"input":"\"\\/\\u0000é00 \"","output":{"decoded":"/\u0000é00 ","encoded":"\"\\/\\u0000é00 \""}},{"input":"0.1","output":{"decoded":"0.1","encoded":"0.1"}},{"input":"\"\\\\ 12NaN \"\\u0000","output":{"decoded":"\"\\\\ 12NaN \"\\u0000","encoded":"\"\\\"\\\\\\\\ 12NaN \\\"\\\\u0000\""}},{"input":"\"\\ud800k\\u000b \"","output":{"decoded":"\ud800k\u000b ","encoded":"\"\\ud800k\\u000b \""}},{"input":"\"x\\ude80123456789012345680000level \"\\u0000","output":{"decoded":"\"x\\ude80123456789012345680000level \"\\u0000","encoded":"\"\\\"x\\\\ude80123456789012345680000level \\\"\\\\u0000\""}},{"input":"\"12k\"\\u0000\\\"","output":{"decoded":"\"12k\"\\u0000\\\"","encoded":"\"\\\"12k\\\"\\\\u0000\\\\\\\"\""}},{"input":"a12.5abc","output":{"decoded":"a12.5abc","encoded":"\"a12.5abc\""}},{"input":"\"-Infinity\"","output":{"decoded":"-Infinity","encoded":"\"-Infinity\""}},{"input":"12","output":{"decoded":"12","encoded":"\"12\""}},{"input":"\"\\ud83d\\ude80 1.51\"\\ud83d\\ude80","output":{"decoded":"\"\\ud83d\\ude80 1.51\"\\ud83d\\ude80","encoded":"\"\\\"\\\\ud83d\\\\ude80 1.51\\\"\\\\ud83d\\\\ude80\""}},{"input":"\"\\u0000payload{\\\"a\\\":1} \"","output":{"decoded":"\u0000payload{\"a\":1} ","encoded":"\"\\u0000payload{\\\"a\\\":1} \""}},{"input":"\"12.5abc\"","output":{"decoded":"12.5abc","encoded":"\"12.5abc\""}},{"input":"\"\\ud800/api/v1/users/123\"","output":{"decoded":"\ud800/api/v1/users/123","encoded":"\"\\ud800/api/v1/users/123\""}},{"input":"\"","output":{"decoded":"\"","encoded":"\"\\\"\""}},{"input":"{\"51\":{\"3\":\"toString -10o7 \",\"\\\\\":\" 12 \",\"[email protected]\":217.59166498668492,\"🚀\":-0.000002439094835426658},\"\\t\":true,\"__defineGetter__\":false}","output":{"decoded":"{\"51\":{\"3\":\"toString -10o7 \",\"\\\\\":\" 12 \",\"[email protected]\":217.59166498668492,\"🚀\":-0.000002439094835426658},\"\\t\":true,\"__defineGetter__\":false}","encoded":"{\"51\":{\"3\":\"toString -10o7 \",\"\\\\\":\" 12 \",\"[email protected]\":217.59166498668492,\"🚀\":-0.000002439094835426658},\"\\t\":true,\"__defineGetter__\":false}"}},{"input":"\"é\"","output":{"decoded":"é","encoded":"\"é\""}},{"input":"\"a\\\\nb1_000 00 \"","output":{"decoded":"a\\nb1_000 00 ","encoded":"\"a\\\\nb1_000 00 \""}},{"input":"\".ahttp.methodBearer abc.def-ghi \"\\ud800","output":{"decoded":"\".ahttp.methodBearer abc.def-ghi \"\\ud800","encoded":"\"\\\".ahttp.methodBearer abc.def-ghi \\\"\\\\ud800\""}},{"input":"\"4294967296\"\\\"\\ud800","output":{"decoded":"\"4294967296\"\\\"\\ud800","encoded":"\"\\\"4294967296\\\"\\\\\\\"\\\\ud800\""}},{"input":"null","output":{"decoded":"null","encoded":"null"}},{"input":"\".5\"","output":{"decoded":".5","encoded":"\".5\""}},{"input":"\"1e400\"\\\\","output":{"decoded":"\"1e400\"\\\\","encoded":"\"\\\"1e400\\\"\\\\\\\\\""}},{"input":"\"\\u2028日本語\"","output":{"decoded":" 日本語","encoded":"\"\\u2028日本語\""}},{"input":"\"\\u2028\\\\ \"","output":{"decoded":" \\ ","encoded":"\"\\u2028\\\\ \""}},{"input":"\"0 true\"","output":{"decoded":"0 true","encoded":"\"0 true\""}},{"input":"\"nullghp_0123456789abcdefghij0123456789abcdef \\\"\"","output":{"decoded":"nullghp_0123456789abcdefghij0123456789abcdef \"","encoded":"\"nullghp_0123456789abcdefghij0123456789abcdef \\\"\""}},{"input":"true","output":{"decoded":"true","encoded":"true"}},{"input":"\"1,5\"","output":{"decoded":"1,5","encoded":"\"1,5\""}},{"input":"\"ᚃWed, 15 Jan 2025 12:00:00 GMT\"","output":{"decoded":"ᚃWed, 15 Jan 2025 12:00:00 GMT","encoded":"\"ᚃWed, 15 Jan 2025 12:00:00 GMT\""}},{"input":"null","output":{"decoded":"null","encoded":"null"}},{"input":"\"日本語\"","output":{"decoded":"日本語","encoded":"\"日本語\""}},{"input":"\"c -1.51e+21\"x\\ude80","output":{"decoded":"\"c -1.51e+21\"x\\ude80","encoded":"\"\\\"c -1.51e+21\\\"x\\\\ude80\""}},{"input":"\"1e3 \"\\u2028\\/","output":{"decoded":"\"1e3 \"\\u2028\\/","encoded":"\"\\\"1e3 \\\"\\\\u2028\\\\/\""}},{"input":"-0 ","output":{"decoded":"-0 ","encoded":"-0 "}},{"input":"\"\\u2028\\\\ghp_0123456789abcdefghij0123456789abcdefdeadbeef\"x\\ude80","output":{"decoded":"\"\\u2028\\\\ghp_0123456789abcdefghij0123456789abcdefdeadbeef\"x\\ude80","encoded":"\"\\\"\\\\u2028\\\\\\\\ghp_0123456789abcdefghij0123456789abcdefdeadbeef\\\"x\\\\ude80\""}},{"input":"true","output":{"decoded":"true","encoded":"true"}},{"input":"\"7\"","output":{"decoded":"7","encoded":"\"7\""}},{"input":"\"length7 \"","output":{"decoded":"length7 ","encoded":"\"length7 \""}},{"input":"\"100🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 \"","output":{"decoded":"100🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 ","encoded":"\"100🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 \""}},{"input":"5.10","output":{"decoded":"5.10","encoded":"5.10"}},{"input":"192.168.1.1","output":{"decoded":"192.168.1.1","encoded":"\"192.168.1.1\""}},{"input":"3fa85f64-5717-4562-b3fc-2c963f66afa6 +5{\"a\":1} ","output":{"decoded":"3fa85f64-5717-4562-b3fc-2c963f66afa6 +5{\"a\":1} ","encoded":"\"3fa85f64-5717-4562-b3fc-2c963f66afa6 +5{\\\"a\\\":1} \""}},{"input":"\"é\"","output":{"decoded":"é","encoded":"\"é\""}},{"input":"\"Bearer abc.def-ghi\"","output":{"decoded":"Bearer abc.def-ghi","encoded":"\"Bearer abc.def-ghi\""}},{"input":"4294967295-1e400","output":{"decoded":"4294967295-1e400","encoded":"\"4294967295-1e400\""}},{"input":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"","output":{"decoded":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","encoded":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\""}},{"input":"\"⟛éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"","output":{"decoded":"⟛éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé","encoded":"\"⟛éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\""}},{"input":"\"\\u2028\\udfff1e3 -1.5\\r\\n\"","output":{"decoded":" \udfff1e3 -1.5\r\n","encoded":"\"\\u2028\\udfff1e3 -1.5\\r\\n\""}},{"input":"\"\\u0000true \"\\udfff","output":{"decoded":"\"\\u0000true \"\\udfff","encoded":"\"\\\"\\\\u0000true \\\"\\\\udfff\""}},{"input":"\"0\"\\ud83d","output":{"decoded":"\"0\"\\ud83d","encoded":"\"\\\"0\\\"\\\\ud83d\""}},{"input":"\"\\u20285. \"","output":{"decoded":" 5. ","encoded":"\"\\u20285. \""}},{"input":"\"xoxb-1234567890-abc\"","output":{"decoded":"xoxb-1234567890-abc","encoded":"\"xoxb-1234567890-abc\""}},{"input":"\"\\ud83d12345678901234568000001\"","output":{"decoded":"\ud83d12345678901234568000001","encoded":"\"\\ud83d12345678901234568000001\""}},{"input":"\"2025-01-15T10:00:00Z\"","output":{"decoded":"2025-01-15T10:00:00Z","encoded":"\"2025-01-15T10:00:00Z\""}},{"input":"\"\\u2028🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 \"","output":{"decoded":" 🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 ","encoded":"\"\\u2028🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 \""}},{"input":"\"1,5\"","output":{"decoded":"1,5","encoded":"\"1,5\""}},{"input":"日本語","output":{"decoded":"日本語","encoded":"\"日本語\""}},{"input":"2.5e-8","output":{"decoded":"2.5e-8","encoded":"2.5e-8"}},{"input":"\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 4294967295\"","output":{"decoded":"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 4294967295","encoded":"\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 4294967295\""}},{"input":"false","output":{"decoded":"false","encoded":"false"}},{"input":"日本語","output":{"decoded":"日本語","encoded":"\"日本語\""}},{"input":"-0","output":{"decoded":"-0","encoded":"-0"}},{"input":"\"0x10\"","output":{"decoded":"0x10","encoded":"\"0x10\""}},{"input":"-1e400","output":{"decoded":"-1e400","encoded":"-1e400"}},{"input":"\"12.5abc\"","output":{"decoded":"12.5abc","encoded":"\"12.5abc\""}},{"input":"\"\\ud83d\\ude80\\u202812 /api/v1/users/12300 \"","output":{"decoded":"🚀 12 /api/v1/users/12300 ","encoded":"\"\\ud83d\\ude80\\u202812 /api/v1/users/12300 \""}},{"input":"\"fatal -1.5 0x10\"\\ud83d\\u2028","output":{"decoded":"\"fatal -1.5 0x10\"\\ud83d\\u2028","encoded":"\"\\\"fatal -1.5 0x10\\\"\\\\ud83d\\\\u2028\""}},{"input":"0","output":{"decoded":"0","encoded":"0"}},{"input":"123456789012345680000","output":{"decoded":"123456789012345680000","encoded":"123456789012345680000"}},{"input":"1","output":{"decoded":"1","encoded":"1"}},{"input":"\"Bearer abc.def-ghi\\u000b \"","output":{"decoded":"Bearer abc.def-ghi\u000b ","encoded":"\"Bearer abc.def-ghi\\u000b \""}},{"input":"\"user.email AKIAIOSFODNN7EXAMPLE \"","output":{"decoded":"user.email AKIAIOSFODNN7EXAMPLE ","encoded":"\"user.email AKIAIOSFODNN7EXAMPLE \""}},{"input":"ghp_0123456789abcdefghij0123456789abcdef","output":{"decoded":"ghp_0123456789abcdefghij0123456789abcdef","encoded":"\"ghp_0123456789abcdefghij0123456789abcdef\""}},{"input":"\"413091596681624.6\"","output":{"decoded":"413091596681624.6","encoded":"\"413091596681624.6\""}},{"input":"-1","output":{"decoded":"-1","encoded":"-1"}},{"input":"\"�\"","output":{"decoded":"�","encoded":"\"�\""}},{"input":"日本語 .a","output":{"decoded":"日本語 .a","encoded":"\"日本語 .a\""}},{"input":"\"error\"","output":{"decoded":"error","encoded":"\"error\""}},{"input":"\"5e-3245.\"\\/\\u2028","output":{"decoded":"\"5e-3245.\"\\/\\u2028","encoded":"\"\\\"5e-3245.\\\"\\\\/\\\\u2028\""}},{"input":"\"é\"","output":{"decoded":"é","encoded":"\"é\""}},{"input":"\"x\\ude80Bearer abc.def-ghi\"","output":{"decoded":"x\ude80Bearer abc.def-ghi","encoded":"\"x\\ude80Bearer abc.def-ghi\""}},{"input":"\"GET \"","output":{"decoded":"GET ","encoded":"\"GET \""}},{"input":"\"\\ud83d2025-01-15T10:00:00Z-1e400 __defineGetter__\"\\\\","output":{"decoded":"\"\\ud83d2025-01-15T10:00:00Z-1e400 __defineGetter__\"\\\\","encoded":"\"\\\"\\\\ud83d2025-01-15T10:00:00Z-1e400 __defineGetter__\\\"\\\\\\\\\""}},{"input":"\"xoxb-1234567890-abcghp_0123456789abcdefghij0123456789abcdef \"\\/\\\"","output":{"decoded":"\"xoxb-1234567890-abcghp_0123456789abcdefghij0123456789abcdef \"\\/\\\"","encoded":"\"\\\"xoxb-1234567890-abcghp_0123456789abcdefghij0123456789abcdef \\\"\\\\/\\\\\\\"\""}},{"input":"\"\\\" __proto__ \"","output":{"decoded":"\" __proto__ ","encoded":"\"\\\" __proto__ \""}},{"input":"\"\\u0000http.method-1e400length\"","output":{"decoded":"\u0000http.method-1e400length","encoded":"\"\\u0000http.method-1e400length\""}},{"input":"\"12\"","output":{"decoded":"12","encoded":"\"12\""}},{"input":"\"12.5abc\"","output":{"decoded":"12.5abc","encoded":"\"12.5abc\""}},{"input":"[]","output":{"decoded":"[]","encoded":"[]"}},{"input":"\"{\\\"1,5\\\":null,\\\"constructor\\\":false,\\\"4294967295\\\":{\\\"4294967295\\\":\\\" \\\",\\\"constructor\\\":{\\\"message\\\":null,\\\"msg\\\":null}}}\"","output":{"decoded":"{\"1,5\":null,\"constructor\":false,\"4294967295\":{\"4294967295\":\" \",\"constructor\":{\"message\":null,\"msg\":null}}}","encoded":"\"{\\\"1,5\\\":null,\\\"constructor\\\":false,\\\"4294967295\\\":{\\\"4294967295\\\":\\\" \\\",\\\"constructor\\\":{\\\"message\\\":null,\\\"msg\\\":null}}}\""}},{"input":"\"INFO00\"","output":{"decoded":"INFO00","encoded":"\"INFO00\""}},{"input":"0.000001","output":{"decoded":"0.000001","encoded":"0.000001"}},{"input":"\"0o7éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé \"","output":{"decoded":"0o7éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé ","encoded":"\"0o7éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé \""}},{"input":"9007199254740992","output":{"decoded":"9007199254740992","encoded":"9007199254740992"}},{"input":"null","output":{"decoded":"null","encoded":"null"}},{"input":"\"full\\\"\"","output":{"decoded":"full\"","encoded":"\"full\\\"\""}},{"input":"\"null\"","output":{"decoded":"null","encoded":"\"null\""}},{"input":"\"\\\"warn192.168.0.112.5abc\"","output":{"decoded":"\"warn192.168.0.112.5abc","encoded":"\"\\\"warn192.168.0.112.5abc\""}},{"input":"\"日本語\"","output":{"decoded":"日本語","encoded":"\"日本語\""}},{"input":"\"deadbeef\"","output":{"decoded":"deadbeef","encoded":"\"deadbeef\""}},{"input":"0","output":{"decoded":"0","encoded":"0"}},{"input":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxconstructorxoxb-1234567890-abc\"\\\\\\\"","output":{"decoded":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxconstructorxoxb-1234567890-abc\"\\\\\\\"","encoded":"\"\\\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxconstructorxoxb-1234567890-abc\\\"\\\\\\\\\\\\\\\"\""}},{"input":"\"é\"","output":{"decoded":"é","encoded":"\"é\""}},{"input":"9007199254740992","output":{"decoded":"9007199254740992","encoded":"9007199254740992"}},{"input":"\"\\ud800true\"","output":{"decoded":"\ud800true","encoded":"\"\\ud800true\""}},{"input":"\"a. 2001:db8::1 \"\\udfff","output":{"decoded":"\"a. 2001:db8::1 \"\\udfff","encoded":"\"\\\"a. 2001:db8::1 \\\"\\\\udfff\""}},{"input":"\"[1,2] 0\"\\ud83d\\ude80","output":{"decoded":"\"[1,2] 0\"\\ud83d\\ude80","encoded":"\"\\\"[1,2] 0\\\"\\\\ud83d\\\\ude80\""}},{"input":"\"1e400\"","output":{"decoded":"1e400","encoded":"\"1e400\""}},{"input":"\"{\\\"a\\\":1}\"","output":{"decoded":"{\"a\":1}","encoded":"\"{\\\"a\\\":1}\""}},{"input":"𖢁 ","output":{"decoded":"𖢁 ","encoded":"\"𖢁 \""}},{"input":"\" 00 \"","output":{"decoded":" 00 ","encoded":"\" 00 \""}},{"input":"\"12 \"","output":{"decoded":"12 ","encoded":"\"12 \""}},{"input":"\"a\\\\nb🚀message \"","output":{"decoded":"a\\nb🚀message ","encoded":"\"a\\\\nb🚀message \""}},{"input":"x","output":{"decoded":"x","encoded":"\"x\""}},{"input":"\"0\"","output":{"decoded":"0","encoded":"\"0\""}},{"input":"\"\\ud83d\\ude80kfatal\"\\ud83d\\ude80","output":{"decoded":"\"\\ud83d\\ude80kfatal\"\\ud83d\\ude80","encoded":"\"\\\"\\\\ud83d\\\\ude80kfatal\\\"\\\\ud83d\\\\ude80\""}},{"input":"\"debug\"\\\\","output":{"decoded":"\"debug\"\\\\","encoded":"\"\\\"debug\\\"\\\\\\\\\""}},{"input":"\"-1e400 é\"","output":{"decoded":"-1e400 é","encoded":"\"-1e400 é\""}},{"input":"\"🚀\"","output":{"decoded":"🚀","encoded":"\"🚀\""}},{"input":"\"𑙫\"\\udfff","output":{"decoded":"\"𑙫\"\\udfff","encoded":"\"\\\"𑙫\\\"\\\\udfff\""}},{"input":"\"Infinity \"\\ud83d\\ude80","output":{"decoded":"\"Infinity \"\\ud83d\\ude80","encoded":"\"\\\"Infinity \\\"\\\\ud83d\\\\ude80\""}},{"input":"\"耔\"\\\"\\udfff","output":{"decoded":"\"耔\"\\\"\\udfff","encoded":"\"\\\"耔\\\"\\\\\\\"\\\\udfff\""}},{"input":"2.5e-8","output":{"decoded":"2.5e-8","encoded":"2.5e-8"}},{"input":"\"+5\"","output":{"decoded":"+5","encoded":"\"+5\""}},{"input":"\"AKIAIOSFODNN7EXAMPLE\"","output":{"decoded":"AKIAIOSFODNN7EXAMPLE","encoded":"\"AKIAIOSFODNN7EXAMPLE\""}},{"input":"\"4294967294 12 \"\\ud83d","output":{"decoded":"\"4294967294 12 \"\\ud83d","encoded":"\"\\\"4294967294 12 \\\"\\\\ud83d\""}},{"input":"\"{\\\"é\\\":false}\"","output":{"decoded":"{\"é\":false}","encoded":"\"{\\\"é\\\":false}\""}}]}diff --git a/rust/logs-ingestion/tests/fixtures/fuzz/avro.json b/rust/logs-ingestion/tests/fixtures/fuzz/avro.jsonnew file mode 100644index 000000000000..3000c2934e6b--- /dev/null+++ b/rust/logs-ingestion/tests/fixtures/fuzz/avro.json@@ -0,0 +1 @@+{"cases":[{"input":{"b64":"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","label":"regression","which":"logs","schema_intact":true},"output":{"error":"truncated block"},"regression":true},{"input":{"b64":"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","label":"regression","which":"logs","schema_intact":true},"output":{"error":"truncated block"},"regression":true},{"input":{"b64":"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","label":"regression","which":"logs","schema_intact":true},"output":{"error":"truncated block"},"regression":true},{"input":{"b64":"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","label":"regression","which":"logs","schema_intact":true},"output":{"error":"truncated block"},"regression":true},{"input":{"b64":"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","label":"regression","which":"logs","schema_intact":true},"output":{"error":"truncated block"},"regression":true},{"input":{"b64":"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","label":"regression","which":"logs","schema_intact":true},"output":{"error":"potential precision loss"},"regression":true},{"input":{"b64":"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","label":"regression","which":"logs","schema_intact":true},"output":{"error":"potential precision loss"},"regression":true},{"input":{"b64":"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","label":"regression","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":1,"sha256":"ec5a8bd709fbdbec6784e852f7ae07c9232bb292450ff0cd3b2f15567dc59655"},"regression":true},{"input":{"b64":"T2JqAQQWYXZyby5zY2hlbWGqL3sibmFtZSI6IlRyYWNlUmVjb3JkIiwidHlwZSI6InJlY29yZCIsImZpZWxkcyI6W3sibmFtZSI6InV1aWQiLCJ0eXBlIjpbIm51bGwiLCJzdHJpbmciXSwiZG9jIjoiVW5pcXVlIGlkZW50aWZpZXIgZm9yIHRoZSBzcGFuIHJlY29yZC4ifSx7Im5hbWUiOiJ0cmFjZV9pZCIsInR5cGUiOlsibnVsbCIsImJ5dGVzIl0sImRvYyI6IklkZW50aWZpZXIgZm9yIHRoZSB0cmFjZSB0aGlzIHNwYW4gYmVsb25ncyB0by4ifSx7Im5hbWUiOiJzcGFuX2lkIiwidHlwZSI6WyJudWxsIiwiYnl0ZXMiXSwiZG9jIjoiSWRlbnRpZmllciBmb3IgdGhpcyBzcGFuIHdpdGhpbiB0aGUgdHJhY2UuIn0seyJuYW1lIjoicGFyZW50X3NwYW5faWQiLCJ0eXBlIjpbIm51bGwiLCJieXRlcyJdLCJkb2MiOiJJZGVudGlmaWVyIGZvciB0aGUgcGFyZW50IHNwYW4sIGlmIGFueS4ifSx7Im5hbWUiOiJ0cmFjZV9zdGF0ZSIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdLCJkb2MiOiJXM0MgdHJhY2Ugc3RhdGUgc3RyaW5nLiJ9LHsibmFtZSI6Im5hbWUiLCJ0eXBlIjpbIm51bGwiLCJzdHJpbmciXSwiZG9jIjoiT3BlcmF0aW9uIG5hbWUgb2YgdGhlIHNwYW4uIn0seyJuYW1lIjoia2luZCIsInR5cGUiOlsibnVsbCIsImludCJdLCJkb2MiOiJTcGFuS2luZDogMD1VTlNQRUNJRklFRCwgMT1JTlRFUk5BTCwgMj1TRVJWRVIsIDM9Qw==","label":"truncate","which":"traces","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"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","label":"truncate","which":"traces","schema_intact":true},"output":{"codec":"zstandard","count":0,"sha256":"4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945"}},{"input":{"b64":"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","label":"append","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":5,"sha256":"c88ed94742024c3a57c61735d5c2a6edcc502f0a95ca23cffcbb0bee0cbb6778"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":5,"sha256":"bb00b6fda30f92e47921097f1c92e980e9de313d7787000408c107abdbcdb083"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":2,"sha256":"aff41bcca85153149ef232c4e129f302739d73d3f198512115c45d8f16273edc"}},{"input":{"b64":"","label":"clean","which":"traces","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":2,"sha256":"841b824c41df53a65e4a3425fff3130bb750376b1ebf5f4d45d19bed1af5ee1b"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":1,"sha256":"2b4d17cca46dd4427d7c2ea08815103d4237bce9f06d7af8d5c07719a98ef448"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":5,"sha256":"f74d62f457c612bb4d0b918dd16c8dfec381bd40a1dd75fe5d180f6da67264ee"}},{"input":{"b64":"","label":"clean","which":"traces","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"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","label":"flip-tail","which":"logs","schema_intact":true},"output":{"error":"zstandard codec decompression error"}},{"input":{"b64":"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","label":"flip","which":"logs","schema_intact":false},"output":{"codec":"zstandard","count":20,"sha256":"234397d71a04a13681dff38b8af7fadd59c2113e1c46d05e2b420c6e52c1a65c"}},{"input":{"b64":"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","label":"append","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":1,"sha256":"6d3a128c2f0d64fd489dca3bbbf0062b12619b20b665135d62ebc8f9e3f77a4f"}},{"input":{"b64":"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","label":"clean","which":"traces","schema_intact":true},"output":{"codec":"zstandard","count":2,"sha256":"dcade13991fb7e527976614e4ece6063a248fb0362e09ce3872f89d93de2a4a0"}},{"input":{"b64":"","label":"clean","which":"logs","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"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","label":"clean","which":"traces","schema_intact":true},"output":{"codec":"zstandard","count":2,"sha256":"46196de0818e3143750ec4237ce291f2fdcc92eeca1ebee24fcaff1979391494"}},{"input":{"b64":"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","label":"clean","which":"traces","schema_intact":true},"output":{"codec":"zstandard","count":1,"sha256":"89b1056e9229a2ea9d21d40f641fce25835c7b5c5ec4839fbabdf7a79fdee38b"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":5,"sha256":"b1a1d251d3278e4365498013a96ec1940a904a5feff579abc13c8eb5b68b6a5e"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":2,"sha256":"25662a3e55bea4ed0bbddafd231b702b7d8aa6d198082001592f9e4932f33a48"}},{"input":{"b64":"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","label":"clean","which":"traces","schema_intact":true},"output":{"codec":"zstandard","count":2,"sha256":"bf9a0601475ed48bd83ece9e1d5d45afca8e4d43e023ed4c1155d37a784c1ec4"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":5,"sha256":"58eb9f157aa1f527b086fe3a79b490513d9188b971476c8625a3fc96dcdbe6ac"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":2,"sha256":"e982e622a9f001fd85fbf72e06a75f5aaf87590e02bfa23a142311068e6de549"}},{"input":{"b64":"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","label":"flip-tail","which":"traces","schema_intact":true},"output":{"error":"zstandard codec decompression error"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":5,"sha256":"8abbe8529a64235d40c0aa46afd9375be231e00d8fbebc58f3b2ea589b031efe"}},{"input":{"b64":"T2JqAQQWYXZyby5zY2hlbWGALHsibmFtZSI6IkxvZ1JlY29yZCIsInR5cGUiOiJyZWNvcmQiLCJmaWVsZHMiOlt7Im5hbWUiOiJ1dWlkIiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6IlVuaXF1ZSBpZGVudGlmaWVyIGZvciB0aGUgbG9nIHJlY29yZC4ifSx7Im5hbWUiOiJ0cmFjZV9pZCIsInR5cGUiOlsibnVsbCIsImJ5dGVzIl0sImRvYyI6IklkZW50aWZpZXIgZm9yIHRoZSB0cmFjZSB0aGlzIGxvZyBpcyBhIHBhcnQgb2YuIn0seyJuYW1lIjoic3Bhbl9pZCIsInR5cGUiOlsibnVsbCIsImJ5dGVzIl0sImRvYyI6IklkZW50aWZpZXIgZm9yIHRoZSBzcGFuIHdpdGhpbiB0aGUgdHJhY2UuIn0seyJuYW1lIjoidHJhY2VfZmxhZ3MiLCJ0eXBlIjpbIm51bGwiLCJpbnQiXSwiZG9jIjoiRmxhZ3MgYXNzb2NpYXRlZCB3aXRoIHRoZSB0cmFjZS4ifSx7Im5hbWUiOiJ0aW1lc3RhbXAiLCJ0eXBlIjpbIm51bGwiLCJsb25nIl0sImRvYyI6IlRoZSBwcmltYXJ5IHRpbWVzdGFtcCBvZiB0aGUgZXZlbnQsIGluIG1pY3Jvc2Vjb25kcyBzaW5jZSBlcG9jaC4ifSx7Im5hbWUiOiJvYnNlcnZlZF90aW1lc3RhbXAiLCJ0eXBlIjpbIm51bGwiLCJsb25nIl0sImRvYyI6IlRoZSB0aW1lc3RhbXAgd2hlbiB0aGUgZXZlbnQgd2FzIG9ic2VydmVkIG9yIGluZ2VzdGVkLCBpbiBtaWNyb3NlY29uZHMgc2luY2UgZXBvY2guIn0seyJuYW1lIjoiYm9keSIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdLCJkb2MiOiJUaGUgbWFpbiBjb250ZW50IG9yIG1lc3NhZ2Ugb2YgdGhlIGxvZy4ifSx7Im5hbWUiOiJzZXZlcml0eV90ZXh0IiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6Ikh1bWFuLXJlYWRhYmxlIHNldmVyaXR5IGxldmVsIChlLmcuLCAnSU5GTycsICdFUlJPUicpLiJ9LHsibmFtZSI6InNldmVyaXR5X251bWJlciIsInR5cGUiOlsibnVsbCIsImludCJdLCJkb2MiOiJOdW1lcmljIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBzZXZlcml0eSBsZXZlbC4ifSx7Im5hbWUiOiJzZXJ2aWNlX25hbWUiLCJ0eXBlIjpbIm51bGwiLCJzdHJpbmciXSwiZG9jIjoiVGhlIG5hbWUgb2YgdGhlIHNlcnZpY2UgdGhhdCBnZW5lcmF0ZWQgdGhlIGV2ZW50LiJ9LHsibmFtZSI6InJlc291cmNlX2F0dHJpYnV0ZXMiLCJ0eXBlIjpbIm51bGwiLHsidHlwZSI6Im1hcCIsInZhbHVlcyI6InN0cmluZyJ9XSwiZG9jIjoiQXR0cmlidXRlcyBkZXNjcmliaW5nIHRoZSByZXNvdXJjZSB0aGF0IHByb2R1Y2VkIHRoZSBsb2cgKGUuZy4sIGhvc3QsIHJlZ2lvbikuIn0seyJuYW1lIjoiaW5zdHJ1bWVudGF0aW9uX3Njb3BlIiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6IlRoZSBuYW1lIG9mIHRoZSBsaWJyYXJ5IG9yIGZyYW1ld29yayB0aGF0IGNhcHR1cmVkIHRoZSBsb2cuIn0seyJuYW1lIjoiZXZlbnRfbmFtZSIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdLCJkb2MiOiJUaGUgbmFtZSBvZiBhIHNwZWNpZmljIGV2ZW50IHRoYXQgb2NjdXJyZWQuIn0seyJuYW1lIjoiYXR0cmlidXRlcyIsInR5cGUiOlsibnVsbCIseyJ0eXBlIjoibWFwIiwidmFsdWVzIjoic3RyaW5nIn1dLCJkb2MiOiJBIG1hcCBvZiBjdXN0b20gc3RyaW5nLXZhbHVlZCBhdHRyaWJ1dGVzIGFzc29jaWF0ZWQgd2l0aCB0aGUgbG9nLiJ9LHsibmFtZSI6ImJ5dGVzX3VuY29tcHJlc3NlZCIsInR5cGUiOlsibnVsbCIsImxvbmciXSwiZG9jIjoiTG9naWNhbCBjb250ZW50IHNpemUgb2YgdGhlIHJvdyAoc3VtIG9mIGJ5dGUgbGVuZ3RocyBvZiBzdHJpbmcvbWFwIGZpZWxkcykuIFVzZWQgYnkgZHJvcC1ydWxlIGFjY291bnRpbmc7IGRvZXMgbm90IGluY2x1ZGUgZml4ZWQtd2lkdGggbnVtZXJpYyBvciB0aW1lc3RhbXAgZmllbGRzLiJ9LHsibmFtZSI6InJldGVudGlvbl9kYXlzIiwidHlwZSI6WyJudWxsIiwiaW50Il0sImRlZmF1bHQiOm51bGwsImRvYyI6IlBlci1yb3cgcmV0ZW50aW9uIGluIGRheXMsIHN0YW1wZWQgYnkgdGhlIE5vZGUgY29uc3VtZXIgZnJvbSB0ZWFtIHJldGVudGlvbiBydWxlcy4gTnVsbCB3aGVuIHVuc2V0IOKAlCBDbGlja0hvdXNlIHRoZW4gZmFsbHMgYmFjayB0byB0aGUgYmF0Y2ggYHJldGVudGlvbi1kYXlzYCBoZWFkZXIuIGNhcHR1cmUtbG9ncyBhbHdheXMgd3JpdGVzIG51bGw7IGl0IGRvZXMgbm90IGV2YWx1YXRlIHRlYW0gcnVsZXMuIn0seyJuYW1lIjoicGF0dGVybiIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdLCJkZWZhdWx0IjpudWxsLCJkb2MiOiJNYXNrZWQgbG9nIGJvZHksIHN0YW1wZWQgYnkgdGhlIE5vZGUgY29uc3VtZXIuIElkZW50aWZpZXJzIGFyZSByZXBsYWNlZCB3aXRoIHBsYWNlaG9sZGVycywgc28gdHdvIGxpbmVzIGRpZmZlcmluZyBvbmx5IGJ5IGEgcmVxdWVzdCBpZCBzaGFyZSBvbmUgcGF0dGVybi4gY2FwdHVyZS1sb2dzIGFsd2F5cyB3cml0ZXMgbnVsbDsgaXQgZG9lcyBub3QgbWFzay4ifSx7Im5hbWUiOiJwYXR0ZXJuX3ZlcnNpb24iLCJ0eXBlIjpbIm51bGwiLCJpbnQiXSwiZGVmYXVsdCI6bnVsbCwiZG9jIjoiTWFza2luZyBydWxlIHNldCB0aGF0IHByb2R1Y2VkIGBwYXR0ZXJuYC4gQSBydWxlIGNoYW5nZSByZS1tYXNrcyBldmVyeSBsaW5lLCBzbyB0aGUgZGV0ZWN0b3IgY29tcGFyZXMgd2l0aGluIGEgdmVyc2lvbiBhbmQgdHJlYXRzIGEgY2hhbmdlIGFzIGEgY29sZCBzdGFydC4gTnVsbCByZWFkcyBhcyB2ZXJzaW9uIDAgaW4gQ2xpY2tIb3VzZSwgbWFya2luZyBhIHJvdyB3cml0dGVuIGJlZm9yZSBtYXNraW5nLiBjYXB0dXJlLWxvZ3MgYWx3YXlzIHdyaXRlcyBudWxsLiJ9XSwiZG9jIjoiU2NoZW1hIGZvciBhIHN0cnVjdHVyZWQgbG9nIG9yIHRyYWNlIGV2ZW50LiJ9FGF2cm8uY29kZWMSenN0YW5kYXJkALsX6el/YeHO1nPNcfAtuTUo9iAotS/9YMEijUEAum1oF0ZwKnEO10jZTkhVFRFAdXTTERdQgapniL/2K7I13/ey3kyvVu8GVGKwKyi2YeBHH0hEaJp1kyyRYJVMN1EdwpoDvEYIpSYDXAFqAWEB67O49Nnhvwq5/vlL7SR+V2stZN/ErxAYhLle+pBj36iFd+enn1TwnTqpgkGpfHt5DWtzzCApPkzHNMdv++mPqa91+u4ncv1V2f4YC5KNk9uqJ7qzJpKlhwEMozicTm2piuJw26Y1Tm8rna/EeHAIXYP85RuY4NheLk/kmI4dFZKOHePv9YS+H2q91xP6YNpJ51G1pS9w7JlA1rW6vM993mr7RHFbzyg4NtDV1dXlsiAdchhplQ5Mx46HPIOuqPQix3hr8onP7tDa2qG1FURry4bW1l7Xm/u0bq1RrCZ5nhS5o2TInWfXZ9+otqrqnXp2+FJYPdENS3GorYZLcWiaoPTXHTu+aZqF16ZuGlq7pbRNw9VsONu5T9dvs1c90aGtyX/WyW1nGnez1dSUhu6Za/WzMh6f/VJN8SqLC1Y6luBKH3Q5mJdQKlHiKOZlkC0tQnJoHHGMHWPXQtIDup2DcSKXxFPiOSG5Ukkv3ldhPJKta/KNx4elVFJRv1Qa6OrqKuRdVAzIWHKHRms6tuEix/it6rVQMeORbJ3U3nqqaaeWsDX5+9Qfw08cPozNxL1++8MD22MSHGN3N2V+SH7Y2UPG9FsFDU0goLRQcEX4cxs02IEje01IOi4iEp8tXmVxZalglO/tqTmr59Z673a/4A9Itds9K6O9+1nZ+qx+dvje462efIPSyC9eZXE9DIj2UvZl9ZLGrDLhjunY1VoL1dZqULQazgmdOUHR3BlaU9OZbdvUWVqDUm8tFA2E6/8iyPPxoHy52S9IXbwKaS/99dZfPdGto0jnDxiPpHruGUw79owlzIY5fjmeQvGM0cGiCADTd6DxguRAxJQvAWS+GwyYQKTZU+JT++u9aKmeZdlnZb2e0Lc+2z4rI6Yobfaq67Pos8P12a2flT3bY7GCJxUF9T45uS1O714XvN6ORdWzslcIDAbAGO6OsdO2sHThrfFIbi/RfQTMgLxnZutlgqmf0/n2qKZaq3fD68TrtRFwgGGfDG2GzjamWxXARx5XJrAE4UhKMuHCkiDZ0S0sHTMp0inxv2xrkthEJK4/XD9HCd336WVNTOv72B8yrX+eL/usnr/+8LWndIzxs+zDtiaNR5LEno9EkBhhlOLIptN5UPpgQilnlAthpJ5bu8eJcKQFwZolmul4vwj317XWu/1ErbsDx8ViDy6Yu9PQAyGMCjlnGpiOXW9h+QLk+De4s1e9iG4vW7ZiNJTUHsMYO871sWz7RCr0XlL3bOuZimr0ZcYjaTySe7sa1rr27SUFx54jSp+82wHfYPBFen08qPdpt4sVkPnLX646mfODK4MVlunYb/lL7a7/0gikrPWq9YrurKIazb42Kas7y55eFFnrbeHdUT4eMGjiF3xWO4yGbie3PbUvZ5XjKfFyKJ5gJL14T1wSL0OeQVdUepF67hL/s5r9Ba2TtHdn9fwYTypqBvU+nU5um4EvsH05RMhLR0j5AlaTPA9qgPmYxwrECpwvd/8VgjN8uWkiYzrGfQPjkXR/HfgDAt8nav1P9WEp8ZdMKJHIVr++/qHWXuptpV8hMAhzkwVHyZY3VawcObA1WQPMw9TchMo2U2Y/45jjjDHGZeqgGQGBDFIK07Hbnt7gT9jiTdy0ZcSmLVNPXdtpqmk1jaqalqI0pvVZ9dmhTOvNtD4bp/Uy5nqWfcyYo/RBl0tQxWWEpOfqIE03czShY80SYQbXA0AQhBjBICR7zXgkiVFVUy9b34uXrR/qjZKkrtWVrf8TkaRjbfvp/GLiGFtY/RTJdSnyMf0LGzSliQUoTJo7N/6wwLRLdoyHXPc04+z62DYXr7K4HtDe/bEUY9RssiRQHTJMAm6mY083FIvFYtHxo/thvjW5XdfqPqb1Ll2HwRx7HoK1lQOAz6jBoFJMEWRIREZkRpKkxSACQggxhM7MAxIoc3GKg1mlDCEiIiISJyKhhBMjFHrlhjKauNhBmkSu9h3Bz4qm762L5OzNtK8SKn6rYaql4B7FFE3bt5N4NyZTfOJEE9JBBWBci7qDG9X3IQsmUgy2c5sofhZ9PmvBGBKrGUwM917DQvsSHkwUbpYbbD1meW5QL9I8BbInZZ2G+kTlD9WyKAiCSPA/mrcV6p7OaGq5GaJ0jYLIFu7cea+K4IUnYImlY7Ivgq3HNfPl8QqVrdFZROjZf6uD2oNCXtazZpiz+F4uG3YNfPHECQsYGXgD42k329YGidzECtPXgQMNkXZFZle69QmuptC24yjGNqeuz7oh3CtgRTCIO6aTHXjxrqSUpRU4oKXxMqkNUIZz98yM1ps+oZ15YWJgg6oltdSCQVpFK8w3GIpWaprhj/UyVw2jq3vZlSAxWNB+bT8phR0CqLIKdGBD6LNWIfUUyJBHgVi1tAw4So/Z0kzkQhmLSKQX/hp9/CGEsN5htE1kbnLG858AjCIGD9mVYQQC5uEUBG0/04yLBTPQIQ69fu6m96WIEa0U6TnxsrlmDP/aeDooo0jwI93WdTAOhTsVbM0hvwkJDlUx6wzAtS6hRV6CaNmjpV/TBcqk7M6GzP5kFK7TBPglP29G3iE+1roOkkojmoVPNudokl8OqDUPctkCXgXPPXGun2UKtux78GlhQyuv5jYlBTAGOB/GhHVLYztZpiMUboMUx4fcF++yQxg7UwWRc4ebl1WiKhsAf8FMq7FY5aoBuxfp6X9h4c7Wc81x8C25NQ==","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":20,"sha256":"7607244aa3cf5565823aa4af269f19e4dcc9c229edbba703ea560ad6d74cef69"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":1,"sha256":"b8c6c40aeb4958dc63226274f2e1d9eadd6c5f98eb8314a8dd0bc0e0efccae8b"}},{"input":{"b64":"","label":"clean","which":"traces","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":2,"sha256":"e37f448ba5f2bb91313d1041370be5c9b88044f8ad0968d432c102823479e6df"}},{"input":{"b64":"","label":"clean","which":"logs","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"T2JqAQQWYXZyby5zY2hlbWGALHsibmFtZSI6IkxvZ1JlY29yZCIsInR5cGUiOiJyZWNvcmQiLCJmaWVsZHMiOlt7Im5hbWUiOiJ1dWlkIiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6IlVuaXF1ZSBpZGVudGlmaWVyIGZvciB0aGUgbG9nIHJlY29yZC4ifSx7Im5hbWUiOiJ0cmFjZV9pZCIsInR5cGUiOlsibnVsbCIsImJ5dGVzIl0sImRvYyI6IklkZW50aWZpZXIgZm9yIHRoZSB0cmFjZSB0aGlzIGxvZyBpcyBhIHBhcnQgb2YuIn0seyJuYW1lIjoic3Bhbl9pZCIsInR5cGUiOlsibnVsbCIsImJ5dGVzIl0sImRvYyI6IklkZW50aWZpZXIgZm9yIHRoZSBzcGFuIHdpdGhpbiB0aGUgdHJhY2UuIn0seyJuYW1lIjoidHJhY2VfZmxhZ3MiLCJ0eXBlIjpbIm51bGwiLCJpbnQiXSwiZG9jIjoiRmxhZ3MgYXNzb2NpYXRlZCB3aXRoIHRoZSB0cmFjZS4ifSx7Im5hbWUiOiJ0aW1lc3RhbXAiLCJ0eXBlIjpbIm51bGwiLCJsb25nIl0sImRvYyI6IlRoZSBwcmltYXJ5IHRpbWVzdGFtcCBvZiB0aGUgZXZlbnQsIGluIG1pY3Jvc2Vjb25kcyBzaW5jZSBlcG9jaC4ifSx7Im5hbWUiOiJvYnNlcnZlZF90aW1lc3RhbXAiLCJ0eXBlIjpbIm51bGwiLCJsb25nIl0sImRvYyI6IlRoZSB0aW1lc3RhbXAgd2hlbiB0aGUgZXZlbnQgd2FzIG9ic2VydmVkIG9yIGluZ2VzdGVkLCBpbiBtaWNyb3NlY29uZHMgc2luY2UgZXBvY2guIn0seyJuYW1lIjoiYm9keSIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdLCJkb2MiOiJUaGUgbWFpbiBjb250ZW50IG9yIG1lc3NhZ2Ugb2YgdGhlIGxvZy4ifSx7Im5hbWUiOiJzZXZlcml0eV90ZXh0IiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6Ikh1bWFuLXJlYWRhYmxlIHNldmVyaXR5IGxldmVsIChlLmcuLCAnSU5GTycsICdFUlJPUicpLiJ9LHsibmFtZSI6InNldmVyaXR5X251bWJlciIsInR5cGUiOlsibnVsbCIsImludCJdLCJkb2MiOiJOdW1lcmljIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBzZXZlcml0eSBsZXZlbC4ifSx7Im5hbWUiOiJzZXJ2aWNlX25hbWUiLCJ0eXBlIjpbIm51bGwiLCJzdHJpbmciXSwiZG9jIjoiVGhlIG5hbWUgb2YgdGhlIHNlcnZpY2UgdGhhdCBnZW5lcmF0ZWQgdGhlIGV2ZW50LiJ9LHsibmFtZSI6InJlc291cmNlX2F0dHJpYnV0ZXMiLCJ0eXBlIjpbIm51bGwiLHsidHlwZSI6Im1hcCIsInZhbHVlcyI6InN0cmluZyJ9XSwiZG9jIjoiQXR0cmlidXRlcyBkZXNjcmliaW5nIHRoZSByZXNvdXJjZSB0aGF0IHByb2R1Y2VkIHRoZSBsb2cgKGUuZy4sIGhvc3QsIHJlZ2lvbikuIn0seyJuYW1lIjoiaW5zdHJ1bWVudGF0aW9uX3Njb3BlIiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6IlRoZSBuYW1lIG9mIHRoZSBsaWJyYXJ5IG9yIGZyYW1ld29yayB0aGF0IGNhcHR1cmVkIHRoZSBsb2cuIn0seyJuYW1lIjoiZXZlbnRfbmFtZSIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdLCJkb2MiOiJUaGUgbmFtZSBvZiBhIHNwZWNpZmljIGV2ZW50IHRoYXQgb2NjdXJyZWQuIn0seyJuYW1lIjoiYXR0cmlidXRlcyIsInR5cGUiOlsibnVsbCIseyJ0eXBlIjoibWFwIiwidmFsdWVzIjoic3RyaW5nIn1dLCJkb2MiOiJBIG1hcCBvZiBjdXN0b20gc3RyaW5nLXZhbHVlZCBhdHRyaWJ1dGVzIGFzc29jaWF0ZWQgd2l0aCB0aGUgbG9nLiJ9LHsibmFtZSI6ImJ5dGVzX3VuY29tcHJlc3NlZCIsInR5cGUiOlsibnVsbCIsImxvbmciXSwiZG9jIjoiTG9naWNhbCBjb250ZW50IHNpemUgb2YgdGhlIHJvdyAoc3VtIG9mIGJ5dGUgbGVuZ3RocyBvZiBzdHJpbmcvbWFwIGZpZWxkcykuIFVzZWQgYnkgZHJvcC1ydWxlIGFjY291bnRpbmc7IGRvZXMgbm90IGluY2x1ZGUgZml4ZWQtd2lkdGggbnVtZXJpYyBvciB0aW1lc3RhbXAgZmllbGRzLiJ9LHsibmFtZSI6InJldGVudGlvbl9kYXlzIiwidHlwZSI6WyJudWxsIiwiaW50Il0sImRlZmF1bHQiOm51bGwsImRvYyI6IlBlci1yb3cgcmV0ZW50aW9uIGluIGRheXMsIHN0YW1wZWQgYnkgdGhlIE5vZGUgY29uc3VtZXIgZnJvbSB0ZWFtIHJldGVudGlvbiBydWxlcy4gTnVsbCB3aGVuIHVuc2V0IOKAlCBDbGlja0hvdXNlIHRoZW4gZmFsbHMgYmFjayB0byB0aGUgYmF0Y2ggYHJldGVudGlvbi1kYXlzYCBoZWFkZXIuIGNhcHR1cmUtbG9ncyBhbHdheXMgd3JpdGVzIG51bGw7IGl0IGRvZXMgbm90IGV2YWx1YXRlIHRlYW0gcnVsZXMuIn0seyJuYW1lIjoicGF0dGVybiIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdLCJkZWZhdWx0IjpudWxsLCJkb2MiOiJNYXNrZWQgbG9nIGJvZHksIHN0YW1wZWQgYnkgdGhlIE5vZGUgY29uc3VtZXIuIElkZW50aWZpZXJzIGFyZSByZXBsYWNlZCB3aXRoIHBsYWNlaG9sZGVycywgc28gdHdvIGxpbmVzIGRpZmZlcmluZyBvbmx5IGJ5IGEgcmVxdWVzdCBpZCBzaGFyZSBvbmUgcGF0dGVybi4gY2FwdHVyZS1sb2dzIGFsd2F5cyB3cml0ZXMgbnVsbDsgaXQgZG9lcyBub3QgbWFzay4ifSx7Im5hbWUiOiJwYXR0ZXJuX3ZlcnNpb24iLCJ0eXBlIjpbIm51bGwiLCJpbnQiXSwiZGVmYXVsdCI6bnVsbCwiZG9jIjoiTWFza2luZyBydWxlIHNldCB0aGF0IHByb2R1Y2VkIGBwYXR0ZXJuYC4gQSBydWxlIGNoYW5nZSByZS1tYXNrcyBldmVyeSBsaW5lLCBzbyB0aGUgZGV0ZWN0b3IgY29tcGFyZXMgd2l0aGluIGEgdmVyc2lvbiBhbmQgdHJlYXRzIGEgY2hhbmdlIGFzIGEgY29sZCBzdGFydC4gTnVsbCByZWFkcyBhcyB2ZXJzaW9uIDAgaW4gQ2xpY2tIb3VzZSwgbWFya2luZyBhIHJvdyB3cml0dGVuIGJlZm9yZSBtYXNraW5nLiBjYXB0dXJlLWxvZ3MgYWx3YXlzIHdyaXRlcyBudWxsLiJ9XSwiZG9jIjoiU2NoZW1hIGZvciBhIHN0cnVjdHVyZWQgbG9nIG9yIHRyYWNlIGV2ZW50LiJ9FGF2cm8uY29kZWMSenN0YW5kYXJkALC9P1YpQoYd2ioGOh6baBcGvAQotS/9oPAFAQCVCADCTjc3QG/TARPLQ1MJPZCNQDQMGe5b8Fic6TbHHm7UZ038mjDFNXVy28itI3obneLlhP64Dbp9k5KIDNQ5Wga/C7XWWr9yThmtPzBoDfGa7s5MsLrOy0wnOCnx6NhWVDB3GMlMLiYOMjguiyPR+HSa0/2upN2BeDKgJ9eQqBQrEJMUNgzwfpyzocWxiwe+X7jhhbikYIxu8LV8+m5zfOocLYPPvt+VYJLcuE+FpPjbv18JkoxiYXRzYRVGqwztkUisIVEp8j0UEfD8fSfW+p0u8H3fyz8QWEpdAOHBfD85fg8Ad2xhXRkkJ8iamjDuMLFZvdguinyhUC1xyUraUtow4SpAwCi46kYrPkQB6pP/rwMnsL0/VilChh3aKgY6HptoFxaqESi1L/2grxwBAE0iABpBBA5IwBhxDsB3eyxiD5YlsYKiEnPY1sWFvKv4HZf3JAzM+CGcJv7WoBXESzeW5qeUYRRRBd854qmJiAgRwR7A04SPe49Vdb3v/aRTxgDQAM0A7s5kLECzokCFBMnbu9vGY7Z4m/iFTfM1mmhLNLVeY2oSzZI0nfcsTaT5Kk/4NWJIXVXX2DdE1P1FoU6pC3WtFR+Bdc+zezdshj0v+cqCKvU56CNrhVmd+WBblpBbMBWP+ZqlBbkv7t5Nrp2PPILKxvN2CTjvTFPxS6ZExdNESVQkB7h3e6uw6n5DRJ2IopY8yVJE0Xtai4J9Hfs1ddY/h82w5+3t6adkinszshgBMyVFDo9xmlwuF8ZbaGmJF7ScM5L3uHYeK4kfxVtD+8m0teaWqIHNcA1Jk8vlcn6gQRUBL3wosSTvLkPxfthfxTX8+pm27nm3t3h1clY4oLUDvN27/dTt1pL5ijdHEjPGUSRIA6xYsgELydvP9uze13buM6fMgqKMFy9EgqBCgrqQfNXBIsQAGwRcbjwNhGguGDQB3bTx9u7r7tm9va+11trQknBBQkXfjxtWdtSwAo7ibaU4tLGULQVbwVIeXCduTOQQvYGpbupEh9QNbAVrXUh5bkxkHjgqI7A3eUPrlWPXDpJ2DK2DDisoOqehGyqkkLzvXT1v78/by1C8JztCyGd5R9E8keMdUfNEz/CCKq7hF/hqJzDCRlKCJIpJ8nZ7Vw8IaAfoRaxpdg1pMaPoUX9DG57MG4ro/ZKqrjHU2/JvJWtv6XuGiB4E6u3fUD/+LYbG6+SscH4kip33rRSbLHo6zZIcxWtKbTLbP+jp6aCU4fVwQUJF3+/s3NKzxJsjCXjts0p5/amVgDJNxS/Us1wynlr2CWe1Gs+zbqVnpTEWi8XCPfZZIEqZpuIXiO+elO/KNVkjj6CyefEeKZLlZ1K3fm0HZO1FPaiqa0zGjCw4/Btpjp13mvL9sH/5BnBBQkXfpzEWC/8MqcKql7H+eQ1kx4MYThwomELy9vGuno/8VXWN/chem/3REFHXiRDylcEOtMNTExHLKni/9DgcjCKQw4oDhwqPevRvqE9D/KW8/tRQn0VgGi37/M2fdOfCMtUEnunkrHBeq7yquAQo3rR4V8/b2gsh31Hqef2pfaez67y7cfS4wgNHpYIGnA0TPlQ4VSoKKws5q9SEVIYJNgA2vDtCIHEECiECyEiVbQYZguFWSI5GzgenLG7DG52DGlSuNGT4JgMcG2HwDkfRcOK+olCLHWh6UvZrpIiakdXBRai50wFNs/U+JiACugQZab9BoAAF+2MXxH63sLChFHJmQRtDXBAHh2PqlNv9eAVlXU0YmCucgAqIcaLiLg/uRRl6WyOU0MgWNiPIZWBdCm1cwGR5+RDMAwjKvHePpRmuHjqgE5eHEENmJaq/Yzq+zfy9K5AgSOoBJEI5j1DIQi7iIJYtIl+fsL0/VilChh3aKgY6HptoFwykCCi1L/2gjwkBADUQAPYdbkfwsKoxGjvB1A+XClhLHBj+YnCx4iKsD6rJF6ntH+u8xhK/zWe2wXIAq+kGKYAlLqsmthZ0OG5hE6LmMe4C3ox/Jdg7sU0kBVkAYABZADRx/rvdeecpVJQAgENS0+LdD9na/OcmfYHtdp1Q0/63bxHIaLtQxPOv0MT530/pbLbPlxwOB06G2/3OTXwsDJhRywXvNx4eEohUNAhuYDUjHFYdauhBtjYf9957b9zHUaF4kIw4wcL7ihgGPoRUZgOKV40ZNm43AvT+vMQizTtmZt5s9ZxUJisTyknEYjFolZy0UqaUAxNoXSsUrXVU6wi0NARWkMrEBjRk6YfK+CCCU2Qvsauft++Vtzvuvfc0XpQgYLAJAfPuj9javE3OSHIELbVQkiNtRprIKrQoiLGP+rtVwkp1d8e9N8ftTs5dq50SPC3+8fftATeFyVbI8mRWCqAuuJwLLveCy2nA5UJ+4Aafl1ikedI7OTd1nVBUZRYrxwkhtLKMUXsbCBgZXa1WwWg/3/eqIN/r88Sz3BYz4wlw+x5rZNmFQlAkEoJCEFSA3vdPQsbGRUkEC413P7S1+e97fZ14z20HFgAr0UWplIk9HJec0tkpiw63iiLSydMSkjF75CZVsFJLit8m3XAwcaLF5uwDajgmNThQcKpACaHXgSiWtJhT8SgArUPAIsP/18EesL0/VilChh3aKgY6HptoFw==","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":20,"sha256":"55de50999d16219020efbcecb21f4f23ba4d22cbde143d5fb36d842a46a72c71"}},{"input":{"b64":"","label":"clean","which":"traces","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"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","label":"header-flip","which":"logs","schema_intact":true},"output":{"error":"Cannot read properties of undefined (reading 'toString')"}},{"input":{"b64":"T2JqAQQWYXZyby5zY2hlbWGqL3sibmFtZSI6IlRyYWNlUmVjb3JkIiwidHlwZSI6InJlY29yZCIsImZpZWxkcyI6W3sibmFtZSI6InV1aWQiLCJ0eXBlIjpbIm51bGwiLCJzdHJpbmciXSwiZG9jIjoiVW5pcXVlIGlkZW50aWZpZXIgZm9yIHRoZSBzcGFuIHJlY29yZC4ifSx7Im5hbWUiOiJ0cmFjZV9pZCIsInR5cGUiOlsibnVsbCIsImJ5dGVzIl0sImRvYyI6IklkZW50aWZpZXIgZm9yIHRoZSB0cmFjZSB0aGlzIHNwYW4gYmVsb25ncyB0by4ifSx7Im5hbWUiOiJzcGFuX2lkIiwidHlwZSI6WyJudWxsIiwiYnl0ZXMiXSwiZG9jIjoiSWRlbnRpZmllciBmb3IgdGhpcyBzcGFuIHdpdGhpbiB0aGUgdHJhY2UuIn0seyJuYW1lIjoicGFyZW50X3NwYW5faWQiLCJ0eXBlIjpbIm51bGwiLCJieXRlcyJdLCJkb2MiOiJJZGVudGlmaWVyIGZvciB0aGUgcGFyZW50IHNwYW4sIGlmIGFueS4ifSx7Im5hbWUiOiJ0cmFjZV9zdGF0ZSIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdLCJkb2MiOiJXM0MgdHJhY2Ugc3RhdGUgc3RyaW5nLiJ9LHsibmFtZSI6Im5hbWUiLCJ0eXBlIjpbIm51bGwiLCJzdHJpbmciXSwiZG9jIjoiT3BlcmF0aW9uIG5hbWUgb2YgdGhlIHNwYW4uIn0seyJuYW1lIjoia2luZCIsInR5cGUiOlsibnVsbCIsImludCJdLCJkb2MiOiJTcGFuS2luZDogMD1VTlNQRUNJRklFRCwgMT1JTlRFUk5BTCwgMj1TRVJWRVIsIDM9Q0xJRU5ULCA0PVBST0RVQ0VSLCA1PUNPTlNVTUVSLiJ9LHsibmFtZSI6ImZsYWdzIiwidHlwZSI6WyJudWxsIiwiaW50Il0sImRvYyI6IlRyYWNlIGZsYWdzIGFzIGRlZmluZWQgaW4gVzNDIFRyYWNlIENvbnRleHQgc3BlY2lmaWNhdGlvbi4ifSx7Im5hbWUiOiJ0aW1lc3RhbXAiLCJ0eXBlIjpbIm51bGwiLCJsb25nIl0sImRvYyI6IlN0YXJ0IHRpbWUgb2YgdGhlIHNwYW4sIGluIG1pY3Jvc2Vjb25kcyBzaW5jZSBlcG9jaC4ifSx7Im5hbWUiOiJlbmRfdGltZSIsInR5cGUiOlsibnVsbCIsImxvbmciXSwiZG9jIjoiRW5kIHRpbWUgb2YgdGhlIHNwYW4sIGluIG1pY3Jvc2Vjb25kcyBzaW5jZSBlcG9jaC4ifSx7Im5hbWUiOiJvYnNlcnZlZF90aW1lc3RhbXAiLCJ0eXBlIjpbIm51bGwiLCJsb25nIl0sImRvYyI6IlRoZSB0aW1lc3RhbXAgd2hlbiB0aGUgc3BhbiB3YXMgcmVjZWl2ZWQgYnkgdGhlIGNvbGxlY3Rvci4ifSx7Im5hbWUiOiJzZXJ2aWNlX25hbWUiLCJ0eXBlIjpbIm51bGwiLCJzdHJpbmciXSwiZG9jIjoiVGhlIG5hbWUgb2YgdGhlIHNlcnZpY2UgdGhhdCBnZW5lcmF0ZWQgdGhlIHNwYW4uIn0seyJuYW1lIjoicmVzb3VyY2VfYXR0cmlidXRlcyIsInR5cGUiOlsibnVsbCIseyJ0eXBlIjoibWFwIiwidmFsdWVzIjoic3RyaW5nIn1dLCJkb2MiOiJBdHRyaWJ1dGVzIGRlc2NyaWJpbmcgdGhlIHJlc291cmNlIHRoYXQgcHJvZHVjZWQgdGhlIHNwYW4uIn0seyJuYW1lIjoiaW5zdHJ1bWVudGF0aW9uX3Njb3BlIiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6IlRoZSBuYW1lIGFuZCB2ZXJzaW9uIG9mIHRoZSBpbnN0cnVtZW50YXRpb24gbGlicmFyeSB0aGF0IGNhcHR1cmVkIHRoZSBzcGFuLiJ9LHsibmFtZSI6ImF0dHJpYnV0ZXMiLCJ0eXBlIjpbIm51bGwiLHsidHlwZSI6Im1hcCIsInZhbHVlcyI6InN0cmluZyJ9XSwiZG9jIjoiQSBtYXAgb2YgY3VzdG9tIHN0cmluZy12YWx1ZWQgYXR0cmlidXRlcyBhc3NvY2lhdGVkIHdpdGggdGhlIHNwYW4uIn0seyJuYW1lIjoiZHJvcHBlZF9hdHRyaWJ1dGVzX2NvdW50IiwidHlwZSI6WyJudWxsIiwiaW50Il0sImRvYyI6Ik51bWJlciBvZiBhdHRyaWJ1dGVzIHRoYXQgd2VyZSBkcm9wcGVkIGR1ZSB0byBsaW1pdHMuIn0seyJuYW1lIjoiZXZlbnRzIiwidHlwZSI6WyJudWxsIix7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoic3RyaW5nIn1dLCJkb2MiOiJBcnJheSBvZiBzcGFuIGV2ZW50cywgZWFjaCBzZXJpYWxpemVkIGFzIGEgSlNPTiBzdHJpbmcuIn0seyJuYW1lIjoiZHJvcHBlZF9ldmVudHNfY291bnQiLCJ0eXBlIjpbIm51bGwiLCJpbnQiXSwiZG9jIjoiTnVtYmVyIG9mIGV2ZW50cyB0aGF0IHdlcmUgZHJvcHBlZCBkdWUgdG8gbGltaXRzLiJ9LHsibmFtZSI6ImxpbmtzIiwidHlwZSI6WyJudWxsIix7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoic3RyaW5nIn1dLCJkb2MiOiJBcnJheSBvZiBzcGFuIGxpbmtzLCBlYWNoIHNlcmlhbGl6ZWQgYXMgYSBKU09OIHN0cmluZy4ifSx7Im5hbWUiOiJkcm9wcGVkX2xpbmtzX2NvdW50IiwidHlwZSI6WyJudWxsIiwiaW50Il0sImRvYyI6Ik51bWJlciBvZiBsaW5rcyB0aGF0IHdlcmUgZHJvcHBlZCBkdWUgdG8gbGltaXRzLiJ9LHsibmFtZSI6InN0YXR1c19jb2RlIiwidHlwZSI6WyJudWxsIiwiaW50Il0sImRvYyI6IlN0YXR1cyBjb2RlOiAwPVVOU0VULCAxPU9LLCAyPUVSUk9SLiJ9LHsibmFtZSI6InN0YXR1c19tZXNzYWdlIiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6IlN0YXR1cyBtZXNzYWdlIn0seyJuYW1lIjoiYnl0ZXNfdW5jb21wcmVzc2VkIiwidHlwZSI6WyJudWxsIiwibG9uZyJdLCJkb2MiOiJMb2dpY2FsIGNvbnRlbnQgc2l6ZSBvZiB0aGUgcm93IChzdW0gb2YgYnl0ZSBsZW5ndGhzIG9mIHN0cmluZy9tYXAvYXJyYXkgZmllbGRzKS4gVXNlZCBieSBkcm9wLXJ1bGUgYWNjb3VudGluZzsgZG9lcyBub3QgaW5jbHVkZSBmaXhlZC13aWR0aCBudW1lcmljIG9yIHRpbWVzdGFtcCBmaWVsZHMuIn0seyJuYW1lIjoicmV0ZW50aW9uX2RheXMiLCJ0eXBlIjpbIm51bGwiLCJpbnQiXSwiZGVmYXVsdCI6bnVsbCwiZG9jIjoiUGVyLXJvdyByZXRlbnRpb24gaW4gZGF5cywgc3RhbXBlZCBieSB0aGUgTm9kZSBjb25zdW1lciBmcm9tIHRlYW0gcmV0ZW50aW9uIHJ1bGVzLiBOdWxsIHdoZW4gdW5zZXQg4oCUIENsaWNrSG91c2UgdGhlbiBmYWxscyBiYWNrIHRvIHRoZSBiYXRjaCBgcmV0ZW50aW9uLWRheXNgIGhlYWRlci4gY2FwdHVyZS1sb2dzIGFsd2F5cyB3cml0ZXMgbnVsbDsgaXQgZG9lcyBub3QgZXZhbHVhdGUgdGVhbSBydWxlcy4ifV0sImRvYyI6IlNjaGVtYSBmb3IgYW4gT1RFTCB0cmFjZSBzcGFuLiJ9FGF2cm8uY29kZWMSenN0YW5kYXJkAPD1x88ZoRraBlGaeNooXxMKrAsotS/9YNAHZRYApiePSsBUcTqoO03Y5lhIg5G0TVMCTU4hy1u2lxAQ3EPJmahb9CAQ8TcfuAK5iKYT2kHwpq56ELkL0BOSLNlFLwoD0lEiqj72IOTpxOnLewB7AHwABYC+K2FJwuQBghwpWJADhFgbVLj+0rqvXIQ7g+hbq9r1okFbZlrrD/XvzswjeEsjzv103SnnW6c5guEV8PFYhiSqFMtQJGnogk5O+7mbhWOjSLM65fzPOjv3VhjpGRIaofOfz/wDNsanBYMS/P2lh4ZPjSujwXe2tO4BMVYLXMAcNHEhbxAxAaM+TFPUO/O5O59TWa1lS2u0mKwFgiorrdMs2dJ5k91avPO5M7xsajCgrtZplikSNYqn8FqamU1Nr0QYzBYb3aO2tDay907hNdFSlGYz3RvTa2aauuX+f81M76PXGt5qraW5pJ8vpnf+jUhHLEcUJzX34yERgXtxZFRnIshIOEHdrmPvXOHmAyQz82PIdz79vYqBqdaqrFWFt46hDWvMnFDHWxO40AutALWltWY16b4Ly9KKpDiGZXlJa8t6vpuVytIUbVYbuLbrZtnSCZr23myzmsXj3/sJmnUFAYbAjNyQkB0eOzx8j5kFBSsX4Z6mqPebRxG7lD25oOR4TyEqJZ7uqUSRJQlecARvhcFssSaN569KlTpdqmttWDvUUnQmSynEOMzQTBvRfKk/sWt79ijMfBW4kg8LLiC573wCBwyAIEtyUJwCkOjBI4bAqRf551t713Y81tzP6OLxtLUielFYvA8yICACgwxJ2R35UuGdCSjni+ceyF1GJTd8ZXj2d30gLXewOL/dRk2HG/H5B2fbTW/kNMHdaNtYRBHyCufROHZyQbZT3oupBgEf2QHctN+B9SsB0MlLOC9CaBBn5A0wK+H9zwTZnTBx1AxS1AzlrIW74qqlL2jUuSv/HXLG891nnBGalyvDoOAUhhPjO8vw9cfPGaEa2gZRmnjaKF8T","label":"clean","which":"traces","schema_intact":true},"output":{"codec":"zstandard","count":5,"sha256":"0518fd521b9ecd71a0ef34fd499280bc97414f48cc29e5c4990d5c1572b53317"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":2,"sha256":"5896dcdfcd6581f9594c24fc33a2f20bf98afb0afa17f639095a8ee01c66edd1"}},{"input":{"b64":"","label":"clean","which":"traces","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"T2JqAQQWYXZyby5zY2hlbWGqL3sibmFtZSI6IlRyYWNlUmVjb3JkIiwidHlwZSI6InJlY29yZCIsImZpZWxkcyI6W3sibmFtZSI6InV1aWQiLCJ0eXBlIjpbIm51bGwiLCJzdHJpbmciXSwiZG9jIjoiVW5pcXVlIGlkZW50aWZpZXIgZm9yIHRoZSBzcGFuIHJlY29yZC4ifSx7Im5hbWUiOiJ0cmFjZV9pZCIsInR5cGUiOlsibnVsbCIsImJ5dGVzIl0sImRvYyI6IklkZW50aWZpZXIgZm9yIHRoZSB0cmFjZSB0aGlzIHNwYW4gYmVsb25ncyB0by4ifSx7Im5hbWUiOiJzcGFuX2lkIiwidHlwZSI6WyJudWxsIiwiYnl0ZXMiXSwiZG9jIjoiSWRlbnRpZmllciBmb3IgdGhpcyBzcGFuIHdpdGhpbiB0aGUgdHJhY2UuIn0seyJuYW1lIjoicGFyZW50X3NwYW5faWQiLCJ0eXBlIjpbIm51bGwiLCJieXRlcyJdLCJkb2MiOiJJZGVudGlmaWVyIGZvciB0aGUgcGFyZW50IHNwYW4sIGlmIGFueS4ifSx7Im5hbWUiOiJ0cmFjZV9zdGF0ZSIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdLCJkb2MiOiJXM0MgdHJhY2Ugc3RhdGUgc3RyaW5nLiJ9LHsibmFtZSI6Im5hbWUiLCJ0eXBlIjpbIm51bGwiLCJzdHJpbmciXSwiZG9jIjoiT3BlcmF0aW9uIG5hbWUgb2YgdGhlIHNwYW4uIn0seyJuYW1lIjoia2luZCIsInR5cGUiOlsibnVsbCIsImludCJdLCJkb2MiOiJTcGFuS2luZDogMD1VTlNQRUNJRklFRCwgMT1JTlRFUk5BTCwgMj1TRVJWRVIsIDM9Q0xJRU5ULCA0PVBST0RVQ0VSLCA1PUNPTlNVTUVSLiJ9LHsibmFtZSI6ImZsYWdzIiwidHlwZSI6WyJudWxsIiwiaW50Il0sImRvYyI6IlRyYWNlIGZsYWdzIGFzIGRlZmluZWQgaW4gVzNDIFRyYWNlIENvbnRleHQgc3BlY2lmaWNhdGlvbi4ifSx7Im5hbWUiOiJ0aW1lc3RhbXAiLCJ0eXBlIjpbIm51bGwiLCJsb25nIl0sImRvYyI6IlN0YXJ0IHRpbWUgb2YgdGhlIHNwYW4sIGluIG1pY3Jvc2Vjb25kcyBzaW5jZSBlcG9jaC4ifSx7Im5hbWUiOiJlbmRfdGltZSIsInR5cGUiOlsibnVsbCIsImxvbmciXSwiZG9jIjoiRW5kIHRpbWUgb2YgdGhlIHNwYW4sIGluIG1pY3Jvc2Vjb25kcyBzaW5jZSBlcG9jaC4ifSx7Im5hbWUiOiJvYnNlcnZlZF90aW1lc3RhbXAiLCJ0eXBlIjpbIm51bGwiLCJsb25nIl0sImRvYyI6IlRoZSB0aW1lc3RhbXAgd2hlbiB0aGUgc3BhbiB3YXMgcmVjZWl2ZWQgYnkgdGhlIGNvbGxlY3Rvci4ifSx7Im5hbWUiOiJzZXJ2aWNlX25hbWUiLCJ0eXBlIjpbIm51bGwiLCJzdHJpbmciXSwiZG9jIjoiVGhlIG5hbWUgb2YgdGhlIHNlcnZpY2UgdGhhdCBnZW5lcmF0ZWQgdGhlIHNwYW4uIn0seyJuYW1lIjoicmVzb3VyY2VfYXR0cmlidXRlcyIsInR5cGUiOlsibnVsbCIseyJ0eXBlIjoibWFwIiwidmFsdWVzIjoic3RyaW5nIn1dLCJkb2MiOiJBdHRyaWJ1dGVzIGRlc2NyaWJpbmcgdGhlIHJlc291cmNlIHRoYXQgcHJvZHVjZWQgdGhlIHNwYW4uIn0seyJuYW1lIjoiaW5zdHJ1bWVudGF0aW9uX3Njb3BlIiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6IlRoZSBuYW1lIGFuZCB2ZXJzaW9uIG9mIHRoZSBpbnN0cnVtZW50YXRpb24gbGlicmFyeSB0aGF0IGNhcHR1cmVkIHRoZSBzcGFuLiJ9LHsibmFtZSI6ImF0dHJpYnV0ZXMiLCJ0eXBlIjpbIm51bGwiLHsidHlwZSI6Im1hcCIsInZhbHVlcyI6InN0cmluZyJ9XSwiZG9jIjoiQSBtYXAgb2YgY3VzdG9tIHN0cmluZy12YWx1ZWQgYXR0cmlidXRlcyBhc3NvY2lhdGVkIHdpdGggdGhlIHNwYW4uIn0seyJuYW1lIjoiZHJvcHBlZF9hdHRyaWJ1dGVzX2NvdW50IiwidHlwZSI6WyJudWxsIiwiaW50Il0sImRvYyI6Ik51bWJlciBvZiBhdHRyaWJ1dGVzIHRoYXQgd2VyZSBkcm9wcGVkIGR1ZSB0byBsaW1pdHMuIn0seyJuYW1lIjoiZXZlbnRzIiwidHlwZSI6WyJudWxsIix7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoic3RyaW5nIn1dLCJkb2MiOiJBcnJheSBvZiBzcGFuIGV2ZW50cywgZWFjaCBzZXJpYWxpemVkIGFzIGEgSlNPTiBzdHJpbmcuIn0seyJuYW1lIjoiZHJvcHBlZF9ldmVudHNfY291bnQiLCJ0eXBlIjpbIm51bGwiLCJpbnQiXSwiZG9jIjoiTnVtYmVyIG9mIGV2ZW50cyB0aGF0IHdlcmUgZHJvcHBlZCBkdWUgdG8gbGltaXRzLiJ9LHsibmFtZSI6ImxpbmtzIiwidHlwZSI6WyJudWxsIix7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoic3RyaW5nIn1dLCJkb2MiOiJBcnJheSBvZiBzcGFuIGxpbmtzLCBlYWNoIHNlcmlhbGl6ZWQgYXMgYSBKU09OIHN0cmluZy4ifSx7Im5hbWUiOiJkcm9wcGVkX2xpbmtzX2NvdW50IiwidHlwZSI6WyJudWxsIiwiaW50Il0sImRvYyI6Ik51bWJlciBvZiBsaW5rcyB0aGF0IHdlcmUgZHJvcHBlZCBkdWUgdG8gbGltaXRzLiJ9LHsibmFtZSI6InN0YXR1c19jb2RlIiwidHlwZSI6WyJudWxsIiwiaW50Il0sImRvYyI6IlN0YXR1cyBjb2RlOiAwPVVOU0VULCAxPU9LLCAyPUVSUk9SLiJ9LHsibmFtZSI6InN0YXR1c19tZXNzYWdlIiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6IlN0YXR1cyBtZXNzYWdlIn0seyJuYW1lIjoiYnl0ZXNfdW5jb21wcmVzc2VkIiwidHlwZSI6WyJudWxsIiwibG9uZyJdLCJkb2MiOiJMb2dpY2FsIGNvbnRlbnQgc2l6ZSBvZiB0aGUgcm93IChzdW0gb2YgYnl0ZSBsZW5ndGhzIG9mIHN0cmluZy9tYXAvYXJyYXkgZmllbGRzKS4gVXNlZCBieSBkcm9wLXJ1bGUgYWNjb3VudGluZzsgZG9lcyBub3QgaW5jbHVkZSBmaXhlZC13aWR0aCBudW1lcmljIG9yIHRpbWVzdGFtcCBmaWVsZHMuIn0seyJuYW1lIjoicmV0ZW50aW9uX2RheXMiLCJ0eXBlIjpbIm51bGwiLCJpbnQiXSwiZGVmYXVsdCI6bnVsbCwiZG9jIjoiUGVyLXJvdyByZXRlbnRpb24gaW4gZGF5cywgc3RhbXBlZCBieSB0aGUgTm9kZSBjb25zdW1lciBmcm9tIHRlYW0gcmV0ZW50aW9uIHJ1bGVzLiBOdWxsIHdoZW4gdW5zZXQg4oCUIENsaWNrSG91c2UgdGhlbiBmYWxscyBiYWNrIHRvIHRoZSBiYXRjaCBgcmV0ZW50aW9uLWRheXNgIGhlYWRlci4gY2FwdHVyZS1sb2dzIGFsd2F5cyB3cml0ZXMgbnVsbDsgaXQgZG9lcyBub3QgZXZhbHVhdGUgdGVhbSBydWxlcy4ifV0sImRvYyI6IlNjaGVtYSBmb3IgYW4gT1RFTCB0cmFjZSBzcGFuLiJ9FGF2cm8uY29kZWMSenN0YW5kYXJkAB0PqsB61W1Jxy7euVpePdUEpBkotS/9YJUZRTIAilbcEkiQHnEObAEwpAOSHhXyE2cwkEoKAG+TVRuqziZQ58JqBvijlBSty2i28j25BxdG9IKfflOBb92/ZfnCkR1CNF2IRBh45V+7BLUcAR0BFwE2NUVlMdj5MvXn2max7moqfBj8/HEUoyjq448fy2CPNfo9Rq0cb2XbD7225UEbOnCoMCIoRqNdIMLwgUiogpCGCinG+Wqbmp5Yf0upXXkrjieUCbgLaUJkyCriMHP9fuqsnZcO+fnuum0R5n4KfuKXwoV11LPhvUM6Sn8bt76ezmPl/gf6nYBQK6NckrpvrBeK5lfsdWoU/VjOqJP+pQufRqecc+1Xqwsgx03dlOc8AoNMQ1VKhfhFvL57Uyxy4qQe5/GF6hgMfaH6tfM33/GuSOnYVOSOPaKswBkjo+nem3ISOQPlDJS/6Pzyc3nqrB/c1AwEDlwavOZN63KYIOBHGyw+ELSuDDY4SBSoAsWLEqAESyaCOQ78Zp94Az0NPAIwyDSckkSNjq+6XInbN2xTU2c3m24LC/zW07X7CCO1rQ6F0fVrwHPOWeb6V7OTt932klaQBmApLoXBcCYMtenShjPVUsPOVxn72Fm+YLhTluJM13+lSlQRjRposMozSnN+HVL4NOL2Vm/pvrXc1G9TU5x5Qj+hlWgVEnFbGlLaGB1aaS+0BEJoaCVabTNVN6S0R7iLu81i71b+y6WK7bHsXpLz/+x3m5qWuVR/vd/LgUGmYZAKmtb540otu5F6bAdeCyJfqiORdLkOzhNpKY1IkjRLhpxB8uNMj5v6a+z2JTmFbVt3KWw1QNS1Od7eeVHQbCdnEQjMMfQArN0uiaeKImbH8//yyo2cx6YtdPxfzTsVKVZdDrdvAS5XDC2iP84ugOeVS50mWkobf9eFT65aBbiuHwufPOc7YvlNxxM2mICOpqgRYzHnH08s6jASZOjzr+YOGfQ194+vbOKc1xZ5i+DYaSnNA5EHD0EEbmlvp5QieVHQjEc/j13aprjzR8d3Etuerm+xfLemRxsXBc18ngjXjNqFTztOQCjX34Sl5bkcPefXftb5I754IDIlXbgSGmx4zNWPZaTi4aQofHIeN6FdX4Jl6ofgY7cvCcKzgLAipRBI4ZPv+OPsLQsYZBqqgif+UuX3lNFSWuv0+VezypMwSeOycp9Y8/iJv1z5asBoPs4LvhRXA8TygCybPzt2vqlhspf5JgqLoTH8GrLrH61cieoJAoSM/htAqJaTAamc4GXZPd4X5I8EIm9rbdtStiVduHjFm8r5jlr3pm7Kd29KvVe87hlfVUI63tSdkNoglvSGVeuK2AKUE6X2NtzgFmBsMHAj85s6cHOCN3VTP6jsGB5ouZMswCDTUGfH8Tn67/cTzQC50Yl/5Vl00l8uJ8UmV9i0chbPH9FzfgP+ksHQL5r7nSfnOwrh+r0oaKYTwRXwmFkBD3mdgFCjM4kRpYISxk/Xs7x1UqWddBH16id+8VyOHhw08KKgmcrd9buP00rWDCy+pPp5gNGdgFAqzz+68Gnc7ZJ47qxajd1tu2ebt+L2rVZzf/+pgFSCDH3HG/jKW2yvtSWxrY/XswHNwCL+q7nHUxfsRI0jZUb380eVb3nCVQSAhajRLIeQIcaMzEgkIxInByACQwgRmrsbEsiDIApiHCExDCImjXioYmokKKdwB3gCgNjZCgziKj01nqnikfSovugeEf8BRiXTmTA8ICDRGYCleZCMVjG+JE2Q9BjgQiHHlhucpOFSqaTe8EAvFsYTF0lcBZAa9gYZB8KTXxVDupicUESSlr4zkj1wTVtFcgA5AgrnKusMwY7dtyHqCPQTRKvPINK7Pn5uVYMXMM/1i6QtMLfGA8cNMaTHj7UwBVGD3JUSZ9agIwparsfmIYWCQbtjs+9YP0Y4BvGV1EcW5Zmai6EPUfFcghSiVyNNqo+bhWzD5gWpMLr3LpwFoFr00g1eHHBZnnVbWwsDrMv4vjSt4nJsmqC8OZkHNziPKmPINIkRAZ6oApyO5Aszjy3fAX7gTovEzg3H/ANuFkho8Q0qTpXO0pD2Z4qO6H8rUABwMdClV7XjTBrMTlQzoKWgv2XAqT76XAUz58sxGRYiyPqDfxC0n5tmgPvq0i+mWMzRRAG0t3ECYAfipVQBHQ+qwHrVbUnHLt65Wl491Q==","label":"clean","which":"traces","schema_intact":true},"output":{"codec":"zstandard","count":2,"sha256":"6751643323c58d59ac419bc58d7ceb626be4b0f537e6661ba7fed0d28ccef0de"}},{"input":{"b64":"T2JqAQQWYXZyby5zY2hlbWGALHsibmFtZSI6IkxvZ1JlY29yZCIsInR5cGUiOiJyZWNvcmQiLCJmaWVsZHMiOlt7Im5hbWUiOiJ1dWlkIiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6IlVuaXF1ZSBpZGVudGlmaWVyIGZvciB0aGUgbG9nIHJlY29yZC4ifSx7Im5hbWUiOiJ0cmFjZV9pZCIsInR5cGUiOlsibnVsbCIsImJ5dGVzIl0sImRvYyI6IklkZW50aWZpZXIgZm9yIHRoZSB0cmFjZSB0aGlzIGxvZyBpcyBhIHBhcnQgb2YuIn0seyJuYW1lIjoic3Bhbl9pZCIsInR5cGUiOlsibnVsbCIsImJ5dGVzIl0sImRvYyI6IklkZW50aWZpZXIgZm9yIHRoZSBzcGFuIHdpdGhpbiB0aGUgdHJhY2UuIn0seyJuYW1lIjoidHJhY2VfZmxhZ3MiLCJ0eXBlIjpbIm51bGwiLCJpbnQiXSwiZG9jIjoiRmxhZ3MgYXNzb2NpYXRlZCB3aXRoIHRoZSB0cmFjZS4ifSx7Im5hbWUiOiJ0aW1lc3RhbXAiLCJ0eXBlIjpbIm51bGwiLCJsb25nIl0sImRvYyI6IlRoZSBwcmltYXJ5IHRpbWVzdGFtcCBvZiB0aGUgZXZlbnQsIGluIG1pY3Jvc2Vjb25kcyBzaW5jZSBlcG9jaC4ifSx7Im5hbWUiOiJvYnNlcnZlZF90aW1lc3RhbXAiLCJ0eXBlIjpbIm51bGwiLCJsb25nIl0sImRvYyI6IlRoZSB0aW1lc3RhbXAgd2hlbiB0aGUgZXZlbnQgd2FzIG9ic2VydmVkIG9yIGluZ2VzdGVkLCBpbiBtaWNyb3NlY29uZHMgc2luY2UgZXBvY2guIn0seyJuYW1lIjoiYm9keSIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdLCJkb2MiOiJUaGUgbWFpbiBjb250ZW50IG9yIG1lc3NhZ2Ugb2YgdGhlIGxvZy4ifSx7Im5hbWUiOiJzZXZlcml0eV90ZXh0IiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6Ikh1bWFuLXJlYWRhYmxlIHNldmVyaXR5IGxldmVsIChlLmcuLCAnSU5GTycsICdFUlJPUicpLiJ9LHsibmFtZSI6InNldmVyaXR5X251bWJlciIsInR5cGUiOlsibnVsbCIsImludCJdLCJkb2MiOiJOdW1lcmljIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBzZXZlcml0eSBsZXZlbC4ifSx7Im5hbWUiOiJzZXJ2aWNlX25hbWUiLCJ0eXBlIjpbIm51bGwiLCJzdHJpbmciXSwiZG9jIjoiVGhlIG5hbWUgb2YgdGhlIHNlcnZpY2UgdGhhdCBnZW5lcmF0ZWQgdGhlIGV2ZW50LiJ9LHsibmFtZSI6InJlc291cmNlX2F0dHJpYnV0ZXMiLCJ0eXBlIjpbIm51bGwiLHsidHlwZSI6Im1hcCIsInZhbHVlcyI6InN0cmluZyJ9XSwiZG9jIjoiQXR0cmlidXRlcyBkZXNjcmliaW5nIHRoZSByZXNvdXJjZSB0aGF0IHByb2R1Y2VkIHRoZSBsb2cgKGUuZy4sIGhvc3QsIHJlZ2lvbikuIn0seyJuYW1lIjoiaW5zdHJ1bWVudGF0aW9uX3Njb3BlIiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6IlRoZSBuYW1lIG9mIHRoZSBsaWJyYXJ5IG9yIGZyYW1ld29yayB0aGF0IGNhcHR1cmVkIHRoZSBsb2cuIn0seyJuYW1lIjoiZXZlbnRfbmFtZSIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdLCJkb2MiOiJUaGUgbmFtZSBvZiBhIHNwZWNpZmljIGV2ZW50IHRoYXQgb2NjdXJyZWQuIn0seyJuYW1lIjoiYXR0cmlidXRlcyIsInR5cGUiOlsibnVsbCIseyJ0eXBlIjoibWFwIiwidmFsdWVzIjoic3RyaW5nIn1dLCJkb2MiOiJBIG1hcCBvZiBjdXN0b20gc3RyaW5nLXZhbHVlZCBhdHRyaWJ1dGVzIGFzc29jaWF0ZWQgd2l0aCB0aGUgbG9nLiJ9LHsibmFtZSI6ImJ5dGVzX3VuY29tcHJlc3NlZCIsInR5cGUiOlsibnVsbCIsImxvbmciXSwiZG9jIjoiTG9naWNhbCBjb250ZW50IHNpemUgb2YgdGhlIHJvdyAoc3VtIG9mIGJ5dGUgbGVuZ3RocyBvZiBzdHJpbmcvbWFwIGZpZWxkcykuIFVzZWQgYnkgZHJvcC1ydWxlIGFjY291bnRpbmc7IGRvZXMgbm90IGluY2x1ZGUgZml4ZWQtd2lkdGggbnVtZXJpYyBvciB0aW1lc3RhbXAgZmllbGRzLiJ9LHsibmFtZSI6InJldGVudGlvbl9kYXlzIiwidHlwZSI6WyJudWxsIiwiaW50Il0sImRlZmF1bHQiOm51bGwsImRvYyI6IlBlci1yb3cgcmV0ZW50aW9uIGluIGRheXMsIHN0YW1wZWQgYnkgdGhlIE5vZGUgY29uc3VtZXIgZnJvbSB0ZWFtIHJldGVudGlvbiBydWxlcy4gTnVsbCB3aGVuIHVuc2V0IOKAlCBDbGlja0hvdXNlIHRoZW4gZmFsbHMgYmFjayB0byB0aGUgYmF0Y2ggYHJldGVudGlvbi1kYXlzYCBoZWFkZXIuIGNhcHR1cmUtbG9ncyBhbHdheXMgd3JpdGVzIG51bGw7IGl0IGRvZXMgbm90IGV2YWx1YXRlIHRlYW0gcnVsZXMuIn0seyJuYW1lIjoicGF0dGVybiIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdLCJkZWZhdWx0IjpudWxsLCJkb2MiOiJNYXNrZWQgbG9nIGJvZHksIHN0YW1wZWQgYnkgdGhlIE5vZGUgY29uc3VtZXIuIElkZW50aWZpZXJzIGFyZSByZXBsYWNlZCB3aXRoIHBsYWNlaG9sZGVycywgc28gdHdvIGxpbmVzIGRpZmZlcmluZyBvbmx5IGJ5IGEgcmVxdWVzdCBpZCBzaGFyZSBvbmUgcGF0dGVybi4gY2FwdHVyZS1sb2dzIGFsd2F5cyB3cml0ZXMgbnVsbDsgaXQgZG9lcyBub3QgbWFzay4ifSx7Im5hbWUiOiJwYXR0ZXJuX3ZlcnNpb24iLCJ0eXBlIjpbIm51bGwiLCJpbnQiXSwiZGVmYXVsdCI6bnVsbCwiZG9jIjoiTWFza2luZyBydWxlIHNldCB0aGF0IHByb2R1Y2VkIGBwYXR0ZXJuYC4gQSBydWxlIGNoYW5nZSByZS1tYXNrcyBldmVyeSBsaW5lLCBzbyB0aGUgZGV0ZWN0b3IgY29tcGFyZXMgd2l0aGluIGEgdmVyc2lvbiBhbmQgdHJlYXRzIGEgY2hhbmdlIGFzIGEgY29sZCBzdGFydC4gTnVsbCByZWFkcyBhcyB2ZXJzaW9uIDAgaW4gQ2xpY2tIb3VzZSwgbWFya2luZyBhIHJvdyB3cml0dGVuIGJlZm9yZSBtYXNraW5nLiBjYXB0dXJlLWxvZ3MgYWx3YXlzIHdyaXRlcyBudWxsLiJ9XSwiZG9jIjoiU2NoZW1hIGZvciBhIHN0cnVjdHVyZWQgbG9nIG9yIHRyYWNlIGV2ZW50LiJ9FGF2cm8uY29kZWMSenN0YW5kYXJkAO3tNZWw8WaCrxloZkv3WowatBcotS/9oJopAQB1LgD6UlASR3AodQ6D1DMadKtJDQA5ROAIdyMEURyLnbM5UI1UUlUnXm3EUvY7iLbMzq97lb656i4It2Gv7W7/pprtNmU2IriS9/9tJi0DEgESAQ0BOKKBH0ixG+bnoKzPU1Jlzq3Pb0YVgULgT3g78J/z87h82G/AEbWe6HPeoSfXvf77f/6sp3b87DGxeHan4Ps7tUtDeQ9+Z1t4g7oBc8AbCl8MpKg+a5GAOH6LceKGBMwBeyDgJaSo3sRIR7s6m3ajisTeNCSSEMLIOb1L2j33btlaW9vqVmsoyrYpatNuUdifunZPldbS2k2rrTPa3uyapjKbdrV79phYtGl3b+1KaQBZRqoqLJdGOZcsV1rIRXlGnfHWEVk+ubqw2e96YNPbethnN8sOPCbn8DaPNJHzxEgcJUTimCbKzf0tIVdbALGxgeSDPv8RDZVpQGvu2Mfw8QL6QgMVs0dAK0S1kgHH/B2XH0yMbtQZys0pbtPuq10prbNpPtuz2spnaMu11BkMxkJdADv8XfsLJJPJQP9jqsMGORLxYv9jx9CJEEV6EBioukG1c1xezFfzZ00cEoldC6ktyq5t2qIpAq1dc0cxDXuzHmxieqG6Ue8Bg692dbof5dp1RJYMPj/n8HZ9/lfDQ4WOqluVN7HPn8blw/6NjEaj0fh57/KILHUwGAs1rNyhJ9dpof0vAjnS8HjD4pDYxOMxiJBMJpPJ5J8P+jUCKoi4spKSY0/kwAqTUJQF9MFBVK8tNFjzaXH5eQOOqPU55/6fs84d4W4aBv/n3BHu5noTbdudsqmKti1n925lE3J+PmeKroCgUJAn9nd+RVFiD4yewAEjOKT4wOJwHnJHJXI3DrcQHPTJd6mTcklJH7RQaaSqwtKw91lZ564jUuf8P6SFz2tIaChH7GswGaKRQQULiz04NCj1GXNlwnx2Z7335nEtlGGh++7Qk+vMHXpyHQS+y9L1v95h39t9UGaNXdWUhvIAPT7nX+PyM5F2Xe3iu3z6I7LUTIxu9Cvnp+f/qm1ahs6qnIautZTGae3KtuyMa/Tp+S6ntAnvvWN3h55cZ9NG4w8sfQaDsdCmg8CXqc+I3SnWUu5uakpzm60G+2x8b9QELinJft0368GvSezEt3ewaVRL2fT6/t51/dHWtofKej8aLENXNZWxnFVl6fpTa++PxvMB41ifux4Ti6c2AylKk3UVxnfJZ7u1vwy+xff3ev+ILNnPOsY5vM0t60qvk1NncsD3wz4nyL+LcCmakauSxJ4MVJikFwIk1FZsYKChI5dQ81Eetx72n7XRqpatdNNmu0LQRQvgktKv+3rw225efwIGeS6ciPbDgt5qCI+dA8aHkdhnzuMWz9A5LOsU2PS2vvxsbnFyBOtF4IjUM3L+zeNWUNZn8/1spKrCcuUjslRnKHcdkWXblgs+v5rhiDSXikrCHmxNAdCCAhsLGC4cxT63n1HOJcvVS7veDwZjoUtr19eLw/iFdvWCdP/L7MGvbLcyGGoIRWWlDVJr/a/C0tMASVCdMrGPYysCxepLlB/xCh8zS/xAkDK/FpcP+w8iSARjqJEoRghBChljREZGREgW2nEECBE6Q7Xa5hKAINg8j7McI0qACBKIxCeRxA8F4nsGv8eCIuSKjKBQdA3TXY4e0hQibTdSC4xYe2u80ghB8woC+xbetHN9VQCQlQ+WTgK4AEkru9Zgi4iJy/dhcZZmnHDlYwtIFD/6+c5t7/O+yyITYE3EGUo3LYZKo0Fszmx5mZZAalgBXCO4tZ9wKtkX5/RKKzNhydn6MiJIvC0mFgQMjwwG55nV/Mdmj3s4uqaUMopfCfLFurLqQgAK/XrVM34syH7wHJpEwQom+yLf+EcPLDLkyuLkuBH9Jpcq6DSUzig2ie4wgjAI0H74TIzzd3Q0RuFO1vGKwCSlz3az5sgAf9+SFcjCIb7lOmmUigqJNhUtrgypaFPYRAr2RFmauNgiWsAf7e01lbDxZoKvGWhmS/dajA6CCyi1L/2gWRgBAK0VAEZpkUnwkDgd7wwauzn7+RiXaa2sOKGTVaKeCImTxHs/b2dwPgyFZkbQjpnHiGUS7ubQOJUbZxnw2EZNRMgugqs77YeYHFt9+Jf6TVYGewB+AHsAnb+19zeMPzPHZKAM73f/y6n2z0NOJu39fpewFzJFMHtdWPq87I2hOIqjPCr/m3+/MbhWrNXJEuE2sUCbqYnL5ne+Kim136ManETsU1aG5pqImhU2NBtY3h+wruvNZ1SEsB3uyQN6yA2KFhaQmQSoGhiYCAQW3O1eTrUHIti5p/J0Pfjap5vT3d3v7veqpNRu39+6zBLjouYIy7MMw9MLR1XHqU4vxXUh+HFiFkHuC0+wVJ7eBo4yxjlkZvQ4YiA1bBDYoAE6CQA3zhgsRcaIF63Zx8xFynbQ9H7nnMJWVVmZ2TuCGhlhcAWUbwudGZdDzLX5HpEzsxXBJYfHkhiCn9dlLnVy4eS75L2iG5Nd8uJ8RXcbgZ6ZL3m7K7rbiTJTtHxd8uKLYmOkPoGko6qszKyZmrjsN3ZiOH5j933Y3IXM7Cn/xnjr8laOunHEn/iB3ThmEeOR68TyRUN3Jz6A3t0XRVPW/agqKzP7d79bZjoxWef1n7fpnB3v7vbc6zKpZWK2UlJ+kVYlJSmTZClVgcwYdyTnKh4HTFDQAQuBHuAkYvGitpAhAeHBpYRIChjbxza9G0VTlo3JOhl/EB6gHFh8i98HRVkzsK7ruq493t2lnGpvBaqqqur7xbn5gJkttDzJC4pgKJqyyHtRyOuScEX3RJUKIwAeM3C4JXMDTHL35aGBiswji4ykJbOn2dGjGNFNse1OMcSNSw7AbhPyjBDwW0yQYzGn/IkUEPoRd3ngqx5jeGYsFnK6F7EfjAtH5LE+oXkQwMuMhxPKcyWZjJgODQVXni+40XVHaDgeW0QOoO3tNZWw8WaCrxloZkv3Wow=","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":20,"sha256":"91afd8029d4c4e045ab679387c78b6d4fa39ca3d5399fa2e704f93574975a9d1"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":5,"sha256":"8c4f07b8ae72b75a00789bbb39b666ed814e50aaa7a0d92b01da6a29c56ee3fd"}},{"input":{"b64":"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","label":"truncate","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":0,"sha256":"4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":2,"sha256":"03a08ab2f4be01fbba1cc2f2322c34dbe470fe00a8ed1968c5190069e7d12ad5"}},{"input":{"b64":"","label":"clean","which":"traces","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"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","label":"clean","which":"traces","schema_intact":true},"output":{"codec":"zstandard","count":1,"sha256":"27f26730a5c0e9c26b7a6743429129a1deb481110faebea4d55c18304f3e07f1"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":20,"sha256":"369f28df2c95ef5b026cecf7bacf23d9111f68047324aa6e62f9a1ba748c9500"}},{"input":{"b64":"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","label":"truncate","which":"logs","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":2,"sha256":"e0e648874949df5fdec8f03ac6881569bde46b6bb45a91cf06406bc0c0b4fb3c"}},{"input":{"b64":"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","label":"flip","which":"logs","schema_intact":false},"output":{"error":"truncated block"}},{"input":{"b64":"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","label":"clean","which":"traces","schema_intact":true},"output":{"codec":"zstandard","count":5,"sha256":"22793c24381baf0e7b946cea806a3b4ab033ac8b90a7a9084206acfa2a9e5390"}},{"input":{"b64":"T2JqAQQWYXZyby5zY2hlbWGALHsibmFtZSI6IkxvZ1JlY29yZCIsInR5cGUiOg==","label":"truncate","which":"logs","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"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","label":"header-flip","which":"logs","schema_intact":true},"output":{"error":"Cannot read properties of undefined (reading 'toString')"}},{"input":{"b64":"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","label":"clean","which":"traces","schema_intact":true},"output":{"codec":"zstandard","count":5,"sha256":"948781a4e408affd9446c7c08a2e1026eb05718eaf48b62c7a2bee8f408fc042"}},{"input":{"b64":"T2JqAQQWYXZyby5zY2hlbWGqL3sibmFtZSI6IlRyYWNlUmVjb3JkIiwidHlwZSI6InJlY29yZCIsImZpZWxkcyI6W3sibmFtZSI6InV1aWQiLCJ0eXBlIjpbIm51bGwiLCJzdHJpbmciXSwiZG9jIjoiVW5pcXVlIGlkZW50aWZpZXIgZm9yIHRoZSBzcGFuIHJlY29yZC4ifSx7Im5hbWUiOiJ0cmFjZV9pZCIsInR5cGUiOlsibnVsbCIsImJ5dGVzIl0sImRvYyI6IklkZW50aWZpZXIgZm9yIHRoZSB0cmFjZSB0aGlzIHNwYW4gYmVsb25ncyB0by4ifSx7Im5hbWUiOiJzcGFuX2lkIiwidHlwZSI6WyJudWxsIiwiYnl0ZXMiXSwiZG9jIjoiSWRlbnRpZmllciBmb3IgdGhpcyBzcGFuIHdpdGhpbiB0aGUgdHJhY2UuIn0seyJuYW1lIjoicGFyZW50X3NwYW5faWQiLCJ0eXBlIjpbIm51bGwiLCJieXRlcyJdLCJkb2MiOiJJZGVudGlmaWVyIGZvciB0aGUgcGFyZW50IHNwYW4sIGlmIGFueS4ifSx7Im5hbWUiOiJ0cmFjZV9zdGF0ZSIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdLCJkb2MiOiJXM0MgdHJhY2Ugc3RhdGUgc3RyaW5nLiJ9LHsibmFtZSI6Im5hbWUiLCJ0eXBlIjpbIm51bGwiLCJzdHJpbmciXSwiZG9jIjoiT3BlcmF0aW9uIG5hbWUgb2YgdGhlIHNwYW4uIn0seyJuYW1lIjoia2luZCIsInR5cGUiOlsibnVsbCIsImludCJdLCJkb2MiOiJTcGFuS2luZDogMD1VTlNQRUNJRklFRCwgMT1JTlRFUk5BTCwgMj1TRVJWRVIsIDM9Q0xJRU5ULCA0PVBST0RVQ0VSLCA1PUNPTlNVTUVSLiJ9LHsibmFtZSI6ImZsYWdzIiwidHlwZSI6WyJudWxsIiwiaW50Il0sImRvYyI6IlRyYWNlIGZsYWdzIGFzIGRlZmluZWQgaW4gVzNDIFRyYWNlIENvbnRleHQgc3BlY2lmaWNhdGlvbi4ifSx7Im5hbWUiOiJ0aW1lc3RhbXAiLCJ0eXBlIjpbIm51bGwiLCJsb25nIl0sImRvYyI6IlN0YXJ0IHRpbWUgb2YgdGhlIHNwYW4sIGluIG1pY3Jvc2Vjb25kcyBzaW5jZSBlcG9jaC4ifSx7Im5hbWUiOiJlbmRfdGltZSIsInR5cGUiOlsibnVsbCIsImxvbmciXSwiZG9jIjoiRW5kIHRpbWUgb2YgdGhlIHNwYW4sIGluIG1pY3Jvc2Vjb25kcyBzaW5jZSBlcG9jaC4ifSx7Im5hbWUiOiJvYnNlcnZlZF90aW1lc3RhbXAiLCJ0eXBlIjpbIm51bGwiLCJsb25nIl0sImRvYyI6IlRoZSB0aW1lc3RhbXAgd2hlbiB0aGUgc3BhbiB3YXMgcmVjZWl2ZWQgYnkgdGhlIGNvbGxlY3Rvci4ifSx7Im5hbWUiOiJzZXJ2aWNlX25hbWUiLCJ0eXBlIjpbIm51bGwiLCJzdHJpbmciXSwiZG9jIjoiVGhlIG5hbWUgb2YgdGhlIHNlcnZpY2UgdGhhdCBnZW5lcmF0ZWQgdGhlIHNwYW4uIn0seyJuYW1lIjoicmVzb3VyY2VfYXR0cmlidXRlcyIsInR5cGUiOlsibnVsbCIseyJ0eXBlIjoibWFwIiwidmFsdWVzIjoic3RyaW5nIn1dLCJkb2MiOiJBdHRyaWJ1dGVzIGRlc2NyaWJpbmcgdGhlIHJlc291cmNlIHRoYXQgcHJvZHVjZWQgdGhlIHNwYW4uIn0seyJuYW1lIjoiaW5zdHJ1bWVudGF0aW9uX3Njb3BlIiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6IlRoZSBuYW1lIGFuZCB2ZXJzaW9uIG9mIHRoZSBpbnN0cnVtZW50YXRpb24gbGlicmFyeSB0aGF0IGNhcHR1cmVkIHRoZSBzcGFuLiJ9LHsibmFtZSI6ImF0dHJpYnV0ZXMiLCJ0eXBlIjpbIm51bGwiLHsidHlwZSI6Im1hcCIsInZhbHVlcyI6InN0cmluZyJ9XSwiZG9jIjoiQSBtYXAgb2YgY3VzdG9tIHN0cmluZy12YWx1ZWQgYXR0cmlidXRlcyBhc3NvY2lhdGVkIHdpdGggdGhlIHNwYW4uIn0seyJuYW1lIjoiZHJvcHBlZF9hdHRyaWJ1dGVzX2NvdW50IiwidHlwZSI6WyJudWxsIiwiaW50Il0sImRvYyI6Ik51bWJlciBvZiBhdHRyaWJ1dGVzIHRoYXQgd2VyZSBkcm9wcGVkIGR1ZSB0byBsaW1pdHMuIn0seyJuYW1lIjoiZXZlbnRzIiwidHlwZSI6WyJudWxsIix7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoic3RyaW5nIn1dLCJkb2MiOiJBcnJheSBvZiBzcGFuIGV2ZW50cywgZWFjaCBzZXJpYWxpemVkIGFzIGEgSlNPTiBzdHJpbmcuIn0seyJuYW1lIjoiZHJvcHBlZF9ldmVudHNfY291bnQiLCJ0eXBlIjpbIm51bGwiLCJpbnQiXSwiZG9jIjoiTnVtYmVyIG9mIGV2ZW50cyB0aGF0IHdlcmUgZHJvcHBlZCBkdWUgdG8gbGltaXRzLiJ9LHsibmFtZSI6ImxpbmtzIiwidHlwZSI6WyJudWxsIix7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoic3RyaW5nIn1dLCJkb2MiOiJBcnJheSBvZiBzcGFuIGxpbmtzLCBlYWNoIHNlcmlhbGl6ZWQgYXMgYSBKU09OIHN0cmluZy4ifSx7Im5hbWUiOiJkcm9wcGVkX2xpbmtzX2NvdW50IiwidHlwZSI6WyJudWxsIiwiaW50Il0sImRvYyI6Ik51bWJlciBvZiBsaW5rcyB0aGF0IHdlcmUgZHJvcHBlZCBkdWUgdG8gbGltaXRzLiJ9LHsibmFtZSI6InN0YXR1c19jb2RlIiwidHlwZSI6WyJudWxsIiwiaW50Il0sImRvYyI6IlN0YXR1cyBjb2RlOiAwPVVOU0VULCAxPU9LLCAyPUVSUk9SLiJ9LHsibmFtZSI6InN0YXR1c19tZXNzYWdlIiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6IlN0YXR1cyBtZXNzYWdlIn0seyJuYW1lIjoiYnl0ZXNfdW5jb21wcmVzc2VkIiwidHlwZSI6WyJudWxsIiwibG9uZyJdLCJkb2MiOiJMb2dpY2FsIGNvbnRlbnQgc2l6ZSBvZiB0aGUgcm93IChzdW0gb2YgYnl0ZSBsZW5ndGhzIG9mIHN0cmluZy9tYXAvYXJyYXkgZmllbGRzKS4gVXNlZCBieSBkcm9wLXJ1bGUgYWNjb3VudGluZzsgZG9lcyBub3QgaW5jbHVkZSBmaXhlZC13aWR0aCBudW1lcmljIG9yIHRpbWVzdGFtcCBmaWVsZHMuIn0seyJuYW1lIjoicmV0ZW50aW9uX2RheXMiLCJ0eXBlIjpbIm51bGwiLCJpbnQiXSwiZGVmYXVsdCI6bnVsbCwiZG9jIjoiUGVyLXJvdyByZXRlbnRpb24gaW4gZGF5cywgc3RhbXBlZCBieSB0aGUgTm9kZSBjb25zdW1lciBmcm9tIHRlYW0gcmV0ZW50aW9uIHJ1bGVzLiBOdWxsIHdoZW4gdW5zZXQg4oCUIENsaWNrSG91c2UgdGhlbiBmYWxscyBiYWNrIHRvIHRoZSBiYXRjaCBgcmV0ZW50aW9uLWRheXNgIGhlYWRlci4gY2FwdHVyZS1sb2dzIGFsd2F5cyB3cml0ZXMgbnVsbDsgaXQgZG9lcyBub3QgZXZhbHVhdGUgdGVhbSBydWxlcy4ifV0sImRvYyI6IlNjaGVtYSBmb3IgYW4gT1RFTCB0cmFjZSBzcGFuLiJ9FGF2cm8uY29kZWMSenN0YW5kYXJkANseIJDChr78MN7D9NvXn/sElAUotS/9YO4BBQoAVBICBHMwAiAVmMxLXcn/8LrfOtiHs0NHAhAn2/ab+7tODAIAAgZhPWICogYgw6kCBAACoIPg/b3vlQYCogACBmFwaQICAjAMRVJST1IgAAICcwIEAjAISU5GTwQ0MCgiQmVhcmVyIGFiYy5kZWYtZ2hpIgACAAIGDk5hTjB4MTBoM2ZhODVmNjQtNTcxNy00NTYyLWIzZmMtMmM5NjNmNjZhZmE2OTAwNzE5OTI1NDc0MDk5MggxMDALAAICAgIgeyJ0cmFjZV9pZCI6IngifQAAAgICBmVycgKaAQACBHMxAiDCr/2qf4L2WBqj9noQ911nAhDSjaikS2sWfAIAAAIG7o6rFDQyOTQ5NjcyOTUCdgJiDiJhXFxuYgACAAIGZXJyApoBAAgAKMGsdttrA2i7ILcNIMHmSyyZ6mKqKwPbHiCQwoa+/DDew/Tb15/7","label":"clean","which":"traces","schema_intact":true},"output":{"codec":"zstandard","count":2,"sha256":"4be13519afcffd51d904ac4f6ddd0d75a3f625959c2bf164e30feb05207ebbab"}},{"input":{"b64":"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","label":"append","which":"traces","schema_intact":true},"output":{"codec":"zstandard","count":1,"sha256":"5371a702bd00511e34fcb6df7823dce76d8a7df3ed4b506408728251cc8f238e"}},{"input":{"b64":"","label":"clean","which":"logs","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"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","label":"clean","which":"traces","schema_intact":true},"output":{"codec":"zstandard","count":1,"sha256":"7d2c019ddb79575d30da3fc4c9cc3cf0d29e0c9152e51649b17e5b319588f472"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":20,"sha256":"59b3faa240a42031f71953cb3adc1d41284d40eb339adcbf268b71889af615ba"}},{"input":{"b64":"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","label":"truncate","which":"traces","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"T2JqAQQWYXZyby5zY2hlbWGALHsibmFtZSI6IkxvZ1JlY29yZCIsInR5cGUiOiJyZWNvcmQiLCJmaWVsZHMiOlt7Im5hbWUiOiJ1dWlkIiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6IlVuaXF1ZSBpZGVudGlmaWVyIGZvciB0aGUgbG9nIHJlY29yZC4ifSx7Im5hbWUiOiJ0cmFjZV9pZCIsInR5cGUiOlsibnVsbCIsImJ5dGVzIl0sImRvYyI6IklkZW50aWZpZXIgZm9yIHRoZSB0cmFjZSB0aGlzIGxvZyBpcyBhIHBhcnQgb2YuIn0seyJuYW1lIjoic3Bhbl9pZCIsInR5cGUiOlsibnVsbCIsImJ5dGVzIl0sImRvYyI6IklkZW50aWZpZXIgZm9yIHRoZSBzcGFuIHdpdGhpbiB0aGUgdHJhY2UuIn0seyJuYW1lIjoidHJhY2VfZmxhZ3MiLCJ0eXBlIjpbIm51bGwiLCJpbnQiXSwiZG9jIjoiRmxhZ3MgYXNzb2NpYXRlZCB3aXRoIHRoZSB0cmFjZS4ifSx7Im5hbWUiOiJ0aW1lc3RhbXAiLCJ0eXBlIjpbIm51bGwiLCJsb25nIl0sImRvYyI6IlRoZSBwcmltYXJ5IHRpbWVzdGFtcCBvZiB0aGUgZXZlbnQsIGluIG1pY3Jvc2Vjb25kcyBzaW5jZSBlcG9jaC4ifSx7Im5hbWUiOiJvYnNlcnZlZF90aW1lc3RhbXAiLCJ0eXBlIjpbIm51bGwiLCJsb25nIl0sImRvYyI6IlRoZSB0aW1lc3RhbXAgd2hlbiB0aGUgZXZlbnQgd2FzIG9ic2VydmVkIG9yIGluZ2VzdGVkLCBpbiBtaWNyb3NlY29uZHMgc2luY2UgZXBvY2guIn0seyJuYW1lIjoiYm9keSIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdLCJkb2MiOiJUaGUgbWFpbiBjb250ZW50IG9yIG1lc3NhZ2Ugb2YgdGhlIGxvZy4ifSx7Im5hbWUiOiJzZXZlcml0eV90ZXh0IiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6Ikh1bWFuLXJlYWRhYmxlIHNldmVyaXR5IGxldmVsIChlLmcuLCAnSU5GTycsICdFUlJPUicpLiJ9LHsibmFtZSI6InNldmVyaXR5X251bWJlciIsInR5cGUiOlsibnVsbCIsImludCJdLCJkb2MiOiJOdW1lcmljIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBzZXZlcml0eSBsZXZlbC4ifSx7Im5hbWUiOiJzZXJ2aWNlX25hbWUiLCJ0eXBlIjpbIm51bGwiLCJzdHJpbmciXSwiZG9jIjoiVGhlIG5hbWUgb2YgdGhlIHNlcnZpY2UgdGhhdCBnZW5lcmF0ZWQgdGhlIGV2ZW50LiJ9LHsibmFtZSI6InJlc291cmNlX2F0dHJpYnV0ZXMiLCJ0eXBlIjpbIm51bGwiLHsidHlwZSI6Im1hcCIsInZhbHVlcyI6InN0cmluZyJ9XSwiZG9jIjoiQXR0cmlidXRlcyBkZXNjcmliaW5nIHRoZSByZXNvdXJjZSB0aGF0IHByb2R1Y2VkIHRoZSBsb2cgKGUuZy4sIGhvc3QsIHJlZ2lvbikuIn0seyJuYW1lIjoiaW5zdHJ1bWVudGF0aW9uX3Njb3BlIiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6IlRoZSBuYW1lIG9mIHRoZSBsaWJyYXJ5IG9yIGZyYW1ld29yayB0aGF0IGNhcHR1cmVkIHRoZSBsb2cuIn0seyJuYW1lIjoiZXZlbnRfbmFtZSIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdLCJkb2MiOiJUaGUgbmFtZSBvZiBhIHNwZWNpZmljIGV2ZW50IHRoYXQgb2NjdXJyZWQuIn0seyJuYW1lIjoiYXR0cmlidXRlcyIsInR5cGUiOlsibnVsbCIseyJ0eXBlIjoibWFwIiwidmFsdWVzIjoic3RyaW5nIn1dLCJkb2MiOiJBIG1hcCBvZiBjdXN0b20gc3RyaW5nLXZhbHVlZCBhdHRyaWJ1dGVzIGFzc29jaWF0ZWQgd2l0aCB0aGUgbG9nLiJ9LHsibmFtZSI6ImJ5dGVzX3VuY29tcHJlc3NlZCIsInR5cGUiOlsibnVsbCIsImxvbmciXSwiZG9jIjoiTG9naWNhbCBjb250ZW50IHNpemUgb2YgdGhlIHJvdyAoc3VtIG9mIGJ5dGUgbGVuZ3RocyBvZiBzdHJpbmcvbWFwIGZpZWxkcykuIFVzZWQgYnkgZHJvcC1ydWxlIGFjY291bnRpbmc7IGRvZXMgbm90IGluY2x1ZGUgZml4ZWQtd2lkdGggbnVtZXJpYyBvciB0aW1lc3RhbXAgZmllbGRzLiJ9LHsibmFtZSI6InJldGVudGlvbl9kYXlzIiwidHlwZSI6WyJudWxsIiwiaW50Il0sImRlZmF1bHQiOm51bGwsImRvYyI6IlBlci1yb3cgcmV0ZW50aW9uIGluIGRheXMsIHN0YW1wZWQgYnkgdGhlIE5vZGUgY29uc3VtZXIgZnJvbSB0ZWFtIHJldGVudGlvbiBydWxlcy4gTnVsbCB3aGVuIHVuc2V0IOKAlCBDbGlja0hvdXNlIHRoZW4gZmFsbHMgYmFjayB0byB0aGUgYmF0Y2ggYHJldGVudGlvbi1kYXlzYCBoZWFkZXIuIGNhcHR1cmUtbG9ncyBhbHdheXMgd3JpdGVzIG51bGw7IGl0IGRvZXMgbm90IGV2YWx1YXRlIHRlYW0gcnVsZXMuIn0seyJuYW1lIjoicGF0dGVybiIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdLCJkZWZhdWx0IjpudWxsLCJkb2MiOiJNYXNrZWQgbG9nIGJvZHksIHN0YW1wZWQgYnkgdGhlIE5vZGUgY29uc3VtZXIuIElkZW50aWZpZXJzIGFyZSByZXBsYWNlZCB3aXRoIHBsYWNlaG9sZGVycywgc28gdHdvIGxpbmVzIGRpZmZlcmluZyBvbmx5IGJ5IGEgcmVxdWVzdCBpZCBzaGFyZSBvbmUgcGF0dGVybi4gY2FwdHVyZS1sb2dzIGFsd2F5cyB3cml0ZXMgbnVsbDsgaXQgZG9lcyBub3QgbWFzay4ifSx7Im5hbWUiOiJwYXR0ZXJuX3ZlcnNpb24iLCJ0eXBlIjpbIm51bGwiLCJpbnQiXSwiZGVmYXVsdCI6bnVsbCwiZG9jIjoiTWFza2luZyBydWxlIHNldCB0aGF0IHByb2R1Y2VkIGBwYXR0ZXJuYC4gQSBydWxlIGNoYW5nZSByZS1tYXNrcyBldmVyeSBsaW5lLCBzbyB0aGUgZGV0ZWN0b3IgY29tcGFyZXMgd2l0aGluIGEgdmVyc2lvbiBhbmQgdHJlYXRzIGEgY2hhbmdlIGFzIGEgY29sZCBzdGFydC4gTnVsbCByZWFkcyBhcyB2ZXJzaW9uIDAgaW4gQ2xpY2tIb3VzZSwgbWFya2luZyBhIHJvdyB3cml0dGVuIGJlZm9yZSBtYXNraW5nLiBjYXB0dXJlLWxvZ3MgYWx3YXlzIHdyaXRlcyBudWxsLiJ9XSwiZG9jIjoiU2NoZW1hIGZvciBhIHN0cnVjdHVyZWQgbG9nIG9yIHRyYWNlIGV2ZW50LiJ9FGF2cm8uY29kZWMSenN0YW5kYXJkANS906jACJTzw9kLbAjE9fQEngQotS/9YEEBLQgAgg88OUBv0wGpH8Lh9hZWR3adJUNyjkJZqmSk7lkfqIbu/r9agcFgyUzNsYy03db2QVbTob0DHHH7N2LJytc9H8+6935vVIu4Xi1SAmMS8kIC8hJwXx0fXMLhE7H56GKUNm6G/D4NbDLhB3xBynj0fbIBwjAMX2BxYmg4aRHgvD/B6tc9H896a2TeUkrZyQ6C/N/95iKem4pqJctAmESlsI6UDJQRtCh06wKdFFRhTgygUpX1Nnh3nK2bRidmb77WZs12RDSKshaK1NYtcpOrcbO5djdr34gEghioJpRufcSgzLBwjFzz35oeKqfNBYLzlmD1BQB5Yzx0r11ao2VbhPIoKjAD1L3TqMAIlPPD2QtsCMT19A==","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":2,"sha256":"f4f5b6099b5934eeaea9867c582c2c5fa27a86ed7892d5d1bc4d8e0f85a1f57f"}},{"input":{"b64":"","label":"clean","which":"logs","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"","label":"clean","which":"logs","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":2,"sha256":"b89ceb6101d50a31aab5ece1eb9b679217722299eb3ce4aef8c6a0d87fc6ba5d"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":20,"sha256":"fa9ef7ebb93cbc1f08af97d765530614130ec1fde10e62c1948edb5e7ba89b01"}},{"input":{"b64":"","label":"clean","which":"logs","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"","label":"clean","which":"logs","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":1,"sha256":"83a8d5e79d7058343390a6370f860db0c67e980b875197865db92b5e60390672"}},{"input":{"b64":"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","label":"truncate","which":"logs","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"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","label":"header-flip","which":"logs","schema_intact":true},"output":{"error":"Cannot read properties of undefined (reading 'toString')"}},{"input":{"b64":"","label":"clean","which":"traces","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"","label":"clean","which":"logs","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"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","label":"header-flip","which":"traces","schema_intact":true},"output":{"error":"Cannot read properties of undefined (reading 'toString')"}},{"input":{"b64":"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","label":"clean","which":"traces","schema_intact":true},"output":{"codec":"zstandard","count":1,"sha256":"0eaa85350c18fa4ec1e709016299308e7bd2fa122182a0faa81db9723a6a0c09"}},{"input":{"b64":"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","label":"append","which":"traces","schema_intact":true},"output":{"codec":"zstandard","count":2,"sha256":"74fc75d7e51c5118af737170f17d345ae913fb1159f922ddb844fe004254950f"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":5,"sha256":"cfcf9825c0ef27a0cc82b89cea866c45cc56dba755aed580d6682c205455b4d3"}},{"input":{"b64":"T2JqAQQWYXZyby5zY2hlbWGALHsibmFtZSI6IkxvZ1JlY29yZCIsInR5cGUiOiJyZWNvcmQiLCJmaWVsZHMiOlt7Im5hbWUiOiJ1dWlkIiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6IlVuaXF1ZSBpZGVudGlmaWVyIGZvciB0aGUgbG9nIHJlY29yZC4ifSx7Im5hbWUiOiJ0cmFjZV9pZCIsInR5cGUiOlsibnVsbCIsImJ5dGVzIl0sImRvYyI6IklkZW50aWZpZXIgZm9yIHRoZSB0cmFjZSB0aGlzIGxvZyBpcyBhIHBhcnQgb2YuIn0seyJuYW1lIjoic3Bhbl9pZCIsInR5cGUiOlsibnVsbCIsImJ5dGVzIl0sImRvYyI6IklkZW50aWZpZXIgZm9yIHRoZSBzcGFuIHdpdGhpbiB0aGUgdHJhY2UuIn0seyJuYW1lIjoidHJhY2VfZmxhZ3MiLCJ0eXBlIjpbIm51bGwiLCJpbnQiXSwiZG9jIjoiRmxhZ3MgYXNzb2NpYXRlZCB3aXRoIHRoZSB0cmFjZS4ifSx7Im5hbWUiOiJ0aW1lc3RhbXAiLCJ0eXBlIjpbIm51bGwiLCJsb25nIl0sImRvYyI6IlRoZSBwcmltYXJ5IHRpbWVzdGFtcCBvZiB0aGUgZXZlbnQsIGluIG1pY3Jvc2Vjb25kcyBzaW5jZSBlcG9jaC4ifSx7Im5hbWUiOiJvYnNlcnZlZF90aW1lc3RhbXAiLCJ0eXBlIjpbIm51bGwiLCJsb25nIl0sImRvYyI6IlRoZSB0aW1lc3RhbXAgd2hlbiB0aGUgZXZlbnQgd2FzIG9ic2VydmVkIG9yIGluZ2VzdGVkLCBpbiBtaWNyb3NlY29uZHMgc2luY2UgZXBvY2guIn0seyJuYW1lIjoiYm9keSIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdLCJkb2MiOiJUaGUgbWFpbiBjb250ZW50IG9yIG1lc3NhZ2Ugb2YgdGhlIGxvZy4ifSx7Im5hbWUiOiJzZXZlcml0eV90ZXh0IiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6Ikh1bWFuLXJlYWRhYmxlIHNldmVyaXR5IGxldmVsIChlLmcuLCAnSU5GTycsICdFUlJPUicpLiJ9LHsibmFtZSI6InNldmVyaXR5X251bWJlciIsInR5cGUiOlsibnVsbCIsImludCJdLCJkb2MiOiJOdW1lcmljIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBzZXZlcml0eSBsZXZlbC4ifSx7Im5hbWUiOiJzZXJ2aWNlX25hbWUiLCJ0eXBlIjpbIm51bGwiLCJzdHJpbmciXSwiZG9jIjoiVGhlIG5hbWUgb2YgdGhlIHNlcnZpY2UgdGhhdCBnZW5lcmF0ZWQgdGhlIGV2ZW50LiJ9LHsibmFtZSI6InJlc291cmNlX2F0dHJpYnV0ZXMiLCJ0eXBlIjpbIm51bGwiLHsidHlwZSI6Im1hcCIsInZhbHVlcyI6InN0cmluZyJ9XSwiZG9jIjoiQXR0cmlidXRlcyBkZXNjcmliaW5nIHRoZSByZXNvdXJjZSB0aGF0IHByb2R1Y2VkIHRoZSBsb2cgKGUuZy4sIGhvc3QsIHJlZ2lvbikuIn0seyJuYW1lIjoiaW5zdHJ1bWVudGF0aW9uX3Njb3BlIiwidHlwZSI6WyJudWxsIiwic3RyaW5nIl0sImRvYyI6IlRoZSBuYW1lIG9mIHRoZSBsaWJyYXJ5IG9yIGZyYW1ld29yayB0aGF0IGNhcHR1cmVkIHRoZSBsb2cuIn0seyJuYW1lIjoiZXZlbnRfbmFtZSIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdLCJkb2MiOiJUaGUgbmFtZSBvZiBhIHNwZWNpZmljIGV2ZW50IHRoYXQgb2NjdXJyZWQuIn0seyJuYW1lIjoiYXR0cmlidXRlcyIsInR5cGUiOlsibnVsbCIseyJ0eXBlIjoibWFwIiwidmFsdWVzIjoic3RyaW5nIn1dLCJkb2MiOiJBIG1hcCBvZiBjdXN0b20gc3RyaW5nLXZhbHVlZCBhdHRyaWJ1dGVzIGFzc29jaWF0ZWQgd2l0aCB0aGUgbG9nLiJ9LHsibmFtZSI6ImJ5dGVzX3VuY29tcHJlc3NlZCIsInR5cGUiOlsibnVsbCIsImxvbmciXSwiZG9jIjoiTG9naWNhbCBjb250ZW50IHNpemUgb2YgdGhlIHJvdyAoc3VtIG9mIGJ5dGUgbGVuZ3RocyBvZiBzdHJpbmcvbWFwIGZpZWxkcykuIFVzZWQgYnkgZHJvcC1ydWxlIGFjY291bnRpbmc7IGRvZXMgbm90IGluY2x1ZGUgZml4ZWQtd2lkdGggbnVtZXJpYyBvciB0aW1lc3RhbXAgZmllbGRzLiJ9LHsibmFtZSI6InJldGVudGlvbl9kYXlzIiwidHlwZSI6WyJudWxsIiwiaW50Il0sImRlZmF1bHQiOm51bGwsImRvYyI6IlBlci1yb3cgcmV0ZW50aW9uIGluIGRheXMsIHN0YW1wZWQgYnkgdGhlIE5vZGUgY29uc3VtZXIgZnJvbSB0ZWFtIHJldGVudGlvbiBydWxlcy4gTnVsbCB3aGVuIHVuc2V0IOKAlCBDbGlja0hvdXNlIHRoZW4gZmFsbHMgYmFjayB0byB0aGUgYmF0Y2ggYHJldGVudGlvbi1kYXlzYCBoZWFkZXIuIGNhcHR1cmUtbG9ncyBhbHdheXMgd3JpdGVzIG51bGw7IGl0IGRvZXMgbm90IGV2YWx1YXRlIHRlYW0gcnVsZXMuIn0seyJuYW1lIjoicGF0dGVybiIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdLCJkRWZhdWx0IjpudWxsLCJkb2MiOiJNYXNrZWQgbG9nIGJvZHksIHN0YW1wZWQgYnkgdGhlIE5vZGUgY29uc3VtZXIuIElkZW50aWZpZXJzIGFyZSByZXBsYWNlZCB3aXRoIHBsYWNlaG9sZGVycywgc28gdHdvIGxpbmVzIGRpZmZlcmluZyBvbmx5IGJ5IGEgcmVxdWVzdCBpZCBzaGFyZSBvbmUgcGF0dGVybi4gY2FwdHVyZS1sb2dzIGFsd2F5cyB3cml0ZXMgbnVsbDsgaXQgZG9lcyBub3QgbWFzay4ifSx7Im5hbWUiOiJwYXR0ZXJuX3ZlcnNpb24iLCJ0eXBlIjpbIm51bGwiLCJpbnQiXSwiZGVmYXVsdCI6bnVsbCwiZG9jIjoiTWFza2luZyBydWxlIHNldCB0aGF0IHByb2R1Y2VkIGBwYXR0ZXJuYC4gQSBydWxlIGNoYW5nZSByZS1tYXNrcyBldmVyeSBsaW5lLCBzbyB0aGUgZGV0ZWN0b3IgY29tcGFyZXMgd2l0aGluIGEgdmVyc2lvbiBhbmQgdHJlYXRzIGEgY2hhbmdlIGFzIGEgY29sZCBzdGFydC4gTnVsbCByZWFkcyBhcyB2ZXJzaW9uIDAgaW4gQ2xpY2tIb3VzZSwgbWFya2luZyBhIHJvdyB3cml0dGVuIGJlZm9yZSBtYXNraW5nLiBjYXB0dXJlLWxvZ3MgYWx3YXlzIHdyaXRlcyBudWxsLiJ9XSwiZG9jIjoiU2NoZW1hIGZvciBhIHN0cnVjdHVyZWQgbG9nIG9yIHRyYWNlIGV2ZW50LiJ9FGF2cm8uY29kZWMSenN0YW5kYXJkAJfNi9yp6ej7U1/vSLhFK/wC7AEotS/9IG1pAwACBHUwAgACEMmqUXBaiHTDAgACoIPg/b3vlQYCoIPg/b3vlQYCPCJXZWQsIDE1IEphbiAyMDI1IDEyOjAwOjAwIEdNVAAAAgZhcGkCAAIAAAIEAjEK77u/MTIEMDEIIi41IgAAAgACBjxOPgIMl82L3Knp6PtTX+9IuEUr/A==","label":"flip","which":"logs","schema_intact":false},"output":{"codec":"zstandard","count":1,"sha256":"4b679e0d095f9c3d8372e3b27d18b7af2671be1176c9c25ef22691be429c3574"}},{"input":{"b64":"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","label":"append","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":5,"sha256":"5f109c94dae2c566d9509946a663ce764bccb98e4a058f16e9f1f88e5c3555b2"}},{"input":{"b64":"","label":"clean","which":"logs","schema_intact":false},"output":{"error":"No metadata found"}},{"input":{"b64":"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","label":"append","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":20,"sha256":"8446e03ef2120b3335881b08bac60fcf24b434fe3d2dd7f5d74cfafb2a126e86"}},{"input":{"b64":"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","label":"clean","which":"logs","schema_intact":true},"output":{"codec":"zstandard","count":1,"sha256":"7e53271c1ad0edc50cf07ba6fba5e27350cfd281602839463a592cbf22e65334"}}]}diff --git a/rust/logs-ingestion/tests/fixtures/fuzz/date.json b/rust/logs-ingestion/tests/fixtures/fuzz/date.jsonnew file mode 100644index 000000000000..888b2e4912b8--- /dev/null+++ b/rust/logs-ingestion/tests/fixtures/fuzz/date.json@@ -0,0 +1 @@+{"cases":[{"input":"--12:00:00.1234561970jan2025-13-01-","output":1736769600123,"regression":true},{"input":"-0800","output":-36921657600000,"regression":true},{"input":"-0800 1","output":-36921657600000,"regression":true},{"input":"-0800 12:00","output":-36921614400000,"regression":true},{"input":"-0800 12:00 Jan 1","output":-36921614400000,"regression":true},{"input":"-0800 12:00:00","output":-36921614400000,"regression":true},{"input":"-0800 12:00:00.123","output":-36921614399877,"regression":true},{"input":"-0800 12:00:00.123456","output":-36921614399877,"regression":true},{"input":"-0800 12:00:00.1234561970","output":-36921614399877,"regression":true},{"input":"-0800GMT12:00:00","output":-36921614400000,"regression":true},{"input":"-0800GMT12:00:00.1234561970","output":-36921614399877,"regression":true},{"input":"-2025 12:00","output":1735732800000,"regression":true},{"input":"-800 12:00","output":-36921614400000,"regression":true},{"input":"0800 12:00","output":-36921614400000,"regression":true},{"input":"12:00:00.1231736942400 Jan-2025-1-5+02:00","output":1735725600123,"regression":true},{"input":"12:00:00.1234562025-00-10 02025/01/15pm:","output":1736978400123,"regression":true},{"input":"12:00:00.1234562025/01/15","output":979560000123,"regression":true},{"input":"12:00:00.1234562025/01/15Z+2+231 ","output":979550940123,"regression":true},{"input":"2025-02-29T12:00:00.1234561550","output":1740830400123,"regression":true},{"input":"1-12:00:00.1234562025-13-01UT","output":978350400123,"regression":true},{"input":"19","output":null},{"input":"-000001)49","output":null},{"input":"12:00:00-+002025am","output":null},{"input":"z-","output":null},{"input":"12:00:00.12325:00 ","output":946728000123},{"input":"1979-01-13T03:49:47.904Z","output":285047387904},{"input":"321/15/2025 UTC,jan(comment)","output":-52036214400000},{"input":"12:00\nT+275760-09-13T00:00:00ZamJanuarygarbage","output":null},{"input":"garbage\npmgarbage+275760-09-13T00:00:00.001ZZ12 ","output":null},{"input":"15/1/2025","output":null},{"input":"20253212:00:00.123456T /","output":null},{"input":"Wed Oct 01 2031 05:50:08 GMT+0000 (Coordinated Universal Time)","output":1948600208000},{"input":"2025-13-01TT 12:00:00.1234561970","output":null},{"input":"25:00","output":null},{"input":"Sun Aug 05 2001 04:22:09 GMT+0000 (Coordinated Universal Time)","output":996985329000},{"input":"12:00:00.1232025-02-29TT12","output":null},{"input":"00janWednesdayT","output":946684800000},{"input":"/ 2025-01-15TAM","output":null},{"input":"50-2025/01/15","output":null},{"input":"pmgarbage5023:59:60 15/1/2025,","output":null},{"input":"\tWednesdaypm","output":null},{"input":"T2025-01-15T1231,AM z \t","output":null},{"input":"1957-04-02T02:03:51.936Z","output":-402357368064},{"input":"12:00:00-+275760-09-13T00:00:00.001Z","output":null},{"input":" ","output":null},{"input":"Thu May 02 1996 09:10:42 GMT+0000 (Coordinated Universal Time)","output":831028242000},{"input":"99z","output":915148800000},{"input":"2025-01-15T2025-00-10","output":null},{"input":"+275760-09-13T00:00:00.001ZUT","output":null},{"input":"Mon Sep 08 1975 01:18:57 GMT+0000 (Coordinated Universal Time)","output":179371137000},{"input":"1940-05-28","output":-933984000000},{"input":"50,","output":-631152000000},{"input":"1970janAM+002025AM","output":null},{"input":" \n","output":null},{"input":"2024-02-29-","output":null},{"input":"24:00:00.001+02:00-+002025T","output":null},{"input":"am","output":null},{"input":"1954-03-21T15:27:44.384Z","output":-498040335616},{"input":"2025-1-5Tjan","output":null},{"input":"2025-01-15 Feb12:00T99:","output":null},{"input":"(Z","output":null},{"input":"1978-06-26T15:44:57.600Z","output":267723897600},{"input":"garbage-1/15/2025","output":1736899200000},{"input":"T12,32+02:001970Z12 ","output":null},{"input":"99-","output":915148800000},{"input":"T-Jan","output":null},{"input":"1971-10-02T05:57:20.000Z","output":55231040000},{"input":"2024-02-29,+275760-09-13T00:00:00ZgarbageZ122025/01/15","output":null},{"input":"275760-09-13","output":8640000000000000},{"input":"+275760-09-13T00:00:00Z-","output":null},{"input":"Wed Oct 02 1974 00:22:52 GMT+0000 (Coordinated Universal Time)","output":149905372000},{"input":"1970T,TUTCT/,12:00:00 ","output":null},{"input":"1946-07-21T22:57:15.008Z","output":-739933364992},{"input":"15Z3215/1/20252025","output":null},{"input":"Fri Oct 24 1980 00:53:34 GMT+0000","output":341196814000},{"input":"1","output":978307200000},{"input":"jan2025-02-29-+275760-09-13T00:00:00.001Z,(comment)","output":null},{"input":"Wed, 06 Oct 2032 12:07:10 GMT","output":1980677230000},{"input":"ESTpm:","output":null},{"input":"4923:59:60","output":null},{"input":"15","output":null},{"input":"Wed, 04 Oct 1978 07:29:24 GMT","output":276334164000},{"input":"+275760-09-13T00:00:00.001Z,\n-pm","output":null},{"input":" ","output":null},{"input":"Mon Aug 23 2038 13:36:31 GMT+0000 (Coordinated Universal Time)","output":2166183391000},{"input":"2004-02-06T06:41:41.8","output":1076049701800},{"input":"32","output":1956528000000},{"input":" 2025-01-15T(+2","output":null},{"input":"195","output":-56013552000000},{"input":"1736942400,,","output":null},{"input":"Wednesday+00202515/1/2025-","output":null},{"input":" AM15GMT","output":null},{"input":"1/15/2025-","output":1736899200000},{"input":"12:00:00.1232025/01/15 25:00","output":null},{"input":"Fri Feb 24 1989 10:45:05 GMT+0000 (Coordinated Universal Time)","output":604320305000},{"input":"99 ","output":915148800000},{"input":"1967-01-17T22:04:","output":null},{"input":"1986-08-21T20:41:24.992Z","output":525040884992},{"input":"1 ","output":978307200000},{"input":"garbage-0800T10-","output":null},{"input":")2025-00-103249,PDT","output":null},{"input":"Thu, 08 Feb 2029 10:38:10 GMT","output":1865241490000},{"input":"2025,25:005023:59:60:12:00,","output":null},{"input":"32","output":1956528000000},{"input":"pmT+02:00(Wed,jan15/1/2025","output":null},{"input":"Tue Oct 25 2022 06:02:08 GMT+0000 (Coordinated Universal Time)","output":1666677728000},{"input":"1996-12-01T19:20:02.560Z","output":849468002560},{"input":"Tue, 25 Apr 2034 16:03:38 GMT","output":2029593818000},{"input":")+275760-09-13T00:00:00Z +02:00T-000001pm","output":null},{"input":"23:59:601970,9923:59:60PDT-","output":null},{"input":"+275760-09-13T00:00:00.001ZPDT+02:00-Jan","output":null},{"input":"+275760-09-13T00:00:00ZJanT","output":null},{"input":"Wednesday,2025-1-500T+275760-09-13T00:00:00Z -000001","output":null},{"input":"2025/01/15","output":1736899200000},{"input":" -","output":null},{"input":"2002-01-24T12:3","output":null},{"input":"UTCUT312025-01-15TTam","output":null},{"input":"2025\n50","output":null},{"input":"2003-06-1","output":1054425600000},{"input":"UT","output":null},{"input":"Tue Nov 01 2016 20:13:30 GMT+0000 (Coordinated Universal Time)","output":1478031210000},{"input":"2025-13-01(+275760-09-13T00:00:00ZAM","output":null},{"input":"25:00,Wed,,202532 ","output":null},{"input":"0024:00:00.0012025-00-10-Jan,","output":null},{"input":"Wed Jan 11 2017 05:25:47 GMT+0000","output":1484112347000},{"input":"2025-01-15T12:00Z","output":1736942400000},{"input":"2025-01-15T002025-01-15T12:00Z +002025","output":null},{"input":"Z.\t","output":null},{"input":"19","output":null},{"input":"112:00-","output":null},{"input":"PM,T2025-01-15TT2025-01-15T12-","output":null},{"input":"(comment)T2025 ","output":null},{"input":"\t:","output":null},{"input":"(comment)2024-02-29-00000120250","output":null},{"input":"2025-1-52025-01-15T12","output":null},{"input":".","output":null},{"input":"2025-13-0149 ","output":null},{"input":"1963-01-05T05:17:45.344Z","output":-220560134656},{"input":"2024-02-29-","output":null},{"input":"2025-02-292025-13-012025-01-15..ZT","output":null},{"input":"12:00:00+02:0019702024-02-29","output":null},{"input":"garbage","output":null},{"input":"+275760-09-13T00:00:00.001Z.2024-02-29T","output":null},{"input":"12:00-1736942400.24:00-2025-01-15T12:00Z","output":null},{"input":"1981-05-24T14:","output":null},{"input":"50Z12Feb-","output":-627523200000},{"input":"1956-09-26T05:11:10.336Z","output":-418589329664},{"input":"1939-11-24T15:29:45.728Z","output":-949998614272},{"input":"492025-01-15T12jan","output":null},{"input":"00(comment)","output":946684800000},{"input":"1736942400T(comment)+2","output":null},{"input":"zAM-000001+002025jan\n","output":null},{"input":"1958-02-27T02:15:40.032Z","output":-373758259968},{"input":"+275760-09-13T00:00:00ZZ12UTCJan-000001-","output":null},{"input":"Mon Nov 05 2035 12:06:59 GMT+0000","output":2077877219000},{"input":"(comment).-000001-12:00:00.123 UTC-Feb","output":null},{"input":"2025-1-5,- garbage jan,(Wed,-","output":null},{"input":"FebT12-+275760-09-13T00:00:00.001Z2025-1-5 ","output":null},{"input":"ZTz12:00:00.123456-25:00,T","output":null},{"input":"1965-12-21T23:44:1","output":null},{"input":"+002025 2025-01-15\n","output":null},{"input":"1979-11-05T2","output":null},{"input":"T50T12:00Wed,275760-09-13","output":null},{"input":"2025-13-0149","output":null},{"input":"1976-1","output":189302400000},{"input":"PDTGMT2025-13-01,","output":null},{"input":"2025-02-29T/Wednesday0January","output":null},{"input":"32+275760-09-13T00:00:00.001Z-","output":null},{"input":"002025-01-15,","output":1736899200000},{"input":"2025-02-29,PMgarbage 2025-01-15,","output":null},{"input":"99JanuaryJanJan,","output":915148800000},{"input":" (comment)","output":null},{"input":"GMT1+275760-09-13T00:00:00.001Z275760-09-13Z","output":null},{"input":"15/1/2025-000001-2024-02-29GMT","output":null},{"input":"1937-08-12T06:23:5","output":null},{"input":"+002025","output":1735689600000},{"input":"Feb,1970 -0000012025-01-15T","output":null},{"input":"12:00:00am","output":null},{"input":"\t2025-13-01+225:00-\tz","output":null},{"input":"1982-03-04T09:28:59.648Z","output":384082139648},{"input":"2025-01-15T","output":null},{"input":"+02:00UT","output":null},{"input":"+275760-09-13T00:00:00.001Z","output":null},{"input":"UT2025-01-15T1200 1","output":null},{"input":"1937-09-17T23:38:49.728Z","output":-1018916470272},{"input":"1935-03-10T03:24:17.280Z","output":-1098650142720},{"input":"00TpmTam ","output":null},{"input":"1988-03-30T03:47:52.704Z","output":575696872704},{"input":"12:0049,pm,,)","output":null},{"input":"001736942400.Wednesday","output":null},{"input":"z24:002025-13-01,","output":null},{"input":"1936-12-16T06:18:07.488Z","output":-1042738912512},{"input":".T12 0Wednesday","output":null},{"input":"Wednesday","output":null},{"input":",2025-13-01AM","output":null},{"input":"15/1/2025T2025-1-5( /2025/01/15","output":null},{"input":"UTC- ","output":null},{"input":"1952-11-12T10:07","output":-540741180000},{"input":"(PM12:0012:00","output":null},{"input":"+275760-09-13T00:00:00.001Z00","output":null},{"input":". 2025/01/15","output":1736899200000},{"input":"1940-12-02T18:02:06.464Z","output":-917675873536},{"input":"17369424002025-01-15T,1736942400T","output":null},{"input":"1970January/+002025","output":null},{"input":"1953-01-11T13:16:42.624Z","output":-535545797376},{"input":"25:00)-0800 Z12,","output":null},{"input":"23:59:60","output":-315532860000},{"input":"49 ","output":2493072000000},{"input":"EST +02:00PDT 2025/2025-00-10","output":null},{"input":"2025-01-15T122025-01-15T12:00Z2025-01-15T12:00Z32,","output":null},{"input":"2025-01-15T12-2025-1-523:59:60,","output":null},{"input":"garbage23:59:60T12:00:00.123","output":null},{"input":"1993-05-24T09:16:34.944Z","output":738234994944},{"input":"T1219702024-02-29","output":null},{"input":"janZ12+002025-,(comment)0","output":null},{"input":"amESTUTC 24:00","output":null},{"input":"Wed, 13 Feb 2019 09:51:36 GMT","output":1550051496000},{"input":"25:00","output":null},{"input":"1977-01-30T12:45:05.92","output":223476305920},{"input":"50:,2025-01-15T1215Z","output":null},{"input":":24:00:00.00124:00:00.0012025-01-15T32Feb","output":null},{"input":"Sun May 28 2028 05:01:39 GMT+0000 (Coordinated Universal Time)","output":1843102899000},{"input":"Sun Aug 27 2000 00:44:40 GMT+0000 (Coordinated Universal Time)","output":967337080000},{"input":"1Z12T","output":null},{"input":"Wednesday-","output":null},{"input":"PDT +2EST 2025-00-10PM","output":null},{"input":"4915/1/2025 24:00T","output":null},{"input":"1956","output":-441849600000},{"input":"garbage ","output":null},{"input":"49UTT,","output":null},{"input":"Mon Nov 11 1996 01:26:11 GMT+0000 (Coordinated Universal Time)","output":847675571000},{"input":"12:00:00.12315/1/202525:00-Jan","output":null},{"input":"2024-02-29","output":1709164800000},{"input":"am-+02:00JanuaryPM","output":null},{"input":"1970-10-09T23:52:37.120Z","output":24364357120},{"input":"Wed,17369424001736942400-AMT12,","output":null},{"input":"T-24:00:00.001 2025-02-2923:59:60+02:0031","output":null},{"input":"25:00-12:00:00.123456502025-01-15T PDT","output":null},{"input":"Wed, 10 Jan 2007 03:14:31 GMT","output":1168398871000},{"input":"2025-01-15T12:00Z31","output":null},{"input":"23:59:60T","output":null},{"input":"Sun Jul 24 2022 06:06:04 GMT+0000","output":1658642764000},{"input":"24:00:00.001 PDTpm23:59:60","output":null},{"input":"12:00 -3112:00:0012:00-","output":null},{"input":"1969-01-0","output":null},{"input":"Wed,)Wed, ","output":null},{"input":"WednesdayT-08001/15/2025+2","output":null},{"input":"50,1-","output":-631152000000},{"input":",2025/01/1524:00,T122025-02-29","output":null},{"input":"2025-13-01:(comment)Z12","output":null},{"input":"1938-01-28T09:03:07.008Z","output":-1007477812992},{"input":"1","output":978307200000},{"input":"1971-08-03T06:09:20.384Z","output":50047760384},{"input":"Fri Jan 12 1973 08:40:47 GMT+0000","output":95676047000},{"input":"am","output":null},{"input":"2025-02-292025-13-0132","output":null},{"input":"Z12GMT,(comment)1/15/2025garbage1736942400","output":null},{"input":"1942-06-24T10:49:39.584Z","output":-868540220416},{"input":"+02:00","output":null},{"input":"2025-13-012025/01/15-+02:00","output":null},{"input":"1980-08-23T23:","output":null},{"input":"+02:0012:00:00.123JanZ,","output":null},{"input":"\t0AM-","output":null},{"input":"Wed, 16 Dec 2037 18:21:32 GMT","output":2144600492000},{"input":"1972-02-16T06:36","output":67070160000},{"input":"Tue Jan 14 2031 18:07:04 GMT+0000","output":1926180424000},{"input":"1968-08-31T10:","output":null},{"input":",","output":null},{"input":"1/15/2025+02:00Feb 2025-1-5","output":null},{"input":"Sat, 04 Jun 2011 05:24:29 GMT","output":1307165069000},{"input":"2025-02-2932","output":null},{"input":"2025-01-15T","output":null},{"input":"23:59:60-z1970 (comment)am","output":null},{"input":"/49","output":2493072000000},{"input":"-000001T2025-01-15TEST","output":null},{"input":"Fri, 15 Oct 1982 20:51:29 GMT","output":403563089000},{"input":"\t99T12zAM1","output":null},{"input":"-08002025-01-15T122025-01-15T12","output":null},{"input":"Sun Jul 29 2001 01:15:47 GMT+0000","output":996369347000},{"input":"24:00:00.00112:00:00.123456Jan1","output":null},{"input":"-0000012025-00-10)12:00:00.12332","output":null},{"input":"PM,/)(Z,","output":null},{"input":"1968-09-13T10:47:30.","output":null},{"input":"1947-03-10T10:40:50.432Z","output":-719932749568},{"input":"12:00:00 275760-09-13","output":null},{"input":"Z12T-0800PDT(comment)UTCT","output":null},{"input":"\t+275760-09-13T00:00:00ZT1/15/20250","output":null},{"input":"12:00:00.1234562025-1-5","output":null},{"input":"-0800Z12T+275760-09-13T00:00:00.001Z15","output":null},{"input":"+02:00","output":null},{"input":"24:002025-1-5zT99Jan","output":null},{"input":"1995-07-23T05:23:34.784Z","output":806477014784},{"input":"Jan-","output":null},{"input":"Tue Feb 09 2027 04:49:35 GMT+0000 (Coordinated Universal Time)","output":1802148575000},{"input":"31Wed,,49Wednesday\t1736942400","output":null},{"input":"1978-07-25T09:20:36.35","output":270206436350},{"input":"+275760-09-13T00:00:00.001Z50-491/15/202523:59:60","output":null},{"input":"275760-09-1312:00:00.12315TWed,PM","output":null},{"input":"23:59:60PDT","output":-315507660000},{"input":"Thu Mar 05 1970 11:11:34 GMT+0000 (Coordinated Universal Time)","output":5483494000},{"input":"49","output":2493072000000},{"input":"garbagegarbage2025-13-01-Z12 +02:00 ","output":null},{"input":"1944-09-09T11:48:15.232Z","output":-798725504768},{"input":".-","output":null},{"input":"T","output":null},{"input":"2025-00-10(comment)","output":null},{"input":"Sat, 05 Apr 1986 18:41:24 GMT","output":513110484000},{"input":"PDT,15","output":null},{"input":"-000001502025-01-15T12","output":null},{"input":"Sun Feb 03 1991 23:10:52 GMT+0000 (Coordinated Universal Time)","output":665622652000},{"input":"12:00:00.1234562025-01-15,2025/01/15PMT00275760-09-13","output":null},{"input":"00 PM2025-01-15T12UT","output":null},{"input":"2025-01-15/2024-02-29 49","output":null},{"input":"Fri Jan 04 2008 14:06:39 GMT+0000 (Coordinated Universal Time)","output":1199455599000},{"input":"Feb\t(2025garbageT","output":null},{"input":"Jan+002025275760-09-13(comment)\n","output":null},{"input":"2025/01/150GMT","output":null},{"input":"/2025-01-15T12:00Z 24:00:00.0012025-13-012025-01-15+275760-09-13T00:00:00.001Z","output":null},{"input":"Mon, 12 Nov 1990 17:27:10 GMT","output":658430830000},{"input":"12:001","output":null},{"input":"1976-04-10T14:21:30.752Z","output":197994090752},{"input":"GMT 99jan ","output":915148800000},{"input":"(comment)GMT+00202500TT\nT","output":null},{"input":"+02:00UTC50-garbage","output":null},{"input":"T12Tam2025-1-52025-01-15T2025-02-29","output":null},{"input":"25:00+02:004912:00:00-PDT","output":null},{"input":"49","output":2493072000000},{"input":"+002025-0800275760-09-13T-T12","output":null},{"input":"T","output":null},{"input":"Thu Nov 16 1978 22:49:52 GMT+0000","output":280104592000},{"input":"Thu, 29 Aug 2002 15:18:59 GMT","output":1030634339000},{"input":"+002025PM","output":null},{"input":"12:00:00.123 25:00 -0800PDT EST","output":null},{"input":"PDTpm12:00,23:59:60+002025","output":null},{"input":"- 12:00:00.123,GMT2025-1-5UTC","output":1736078400123},{"input":"T12Feb24:0002025-01-15TAM","output":null},{"input":"T12+002025T1224:00:00.001Tam ","output":null},{"input":"+275760-09-13T00:00:00Z49-pm02025-1-5,2025","output":null},{"input":" ","output":null},{"input":"1956-02-21","output":-437443200000},{"input":"Wed,","output":null},{"input":"1946-05-08T22:55","output":-746327100000},{"input":"0","output":946684800000},{"input":"+275760-09-13T00:00:00ZEST15","output":null},{"input":"1982-05-08T21:46:20.288Z","output":389742380288},{"input":":TWednesday-","output":null},{"input":"1996-03-27T15:24:5","output":null},{"input":"2025-1-5","output":1736035200000},{"input":"Sat, 22 Apr 2000 09:06:08 GMT","output":956394368000},{"input":" ,2025-00-10-\t+2/","output":null},{"input":"Thu May 30 2030 10:48:27 GMT+0000","output":1906368507000},{"input":"31-2025-01-15T12 32+275760-09-13T00:00:00ZZ12-","output":null},{"input":". ","output":null},{"input":"GMTWednesday","output":null},{"input":"Fri Sep 20 2019 04:48:50 GMT+0000 (Coordinated Universal Time)","output":1568954930000},{"input":"TJanuary15","output":null},{"input":"2024-02-29 z15/1/20252025/01/15Feb","output":null},{"input":"9900 +275760-09-13T00:00:00Z,-,PDT\t","output":null},{"input":"GMT2025/01/15 T12:00:00.123,","output":null},{"input":"9912:00:00.123T.1-2024-02-29","output":null},{"input":"2025-1-52025","output":null},{"input":"Wed, 26 Aug 1981 09:03:55 GMT","output":367664635000},{"input":"+02:00-","output":null},{"input":".Feb12:00:00.123456Wed,T","output":null},{"input":"-,(+275760-09-13T00:00:00.001Z311/15/202531T","output":null},{"input":"-0800January-25:00","output":null},{"input":"1987-03-19T06:19:13.024Z","output":543133153024},{"input":"25:00-2025-00-10UTjan,2025-02-29","output":null},{"input":"(","output":null},{"input":"197049+002025","output":null},{"input":",1736942400--000001 ","output":null},{"input":"173694240025:0012:00:00.12345615/1/2025-1,15/1/2025","output":null},{"input":"2025-00-10+275760-09-13T00:00:00.001ZAM50,pm,","output":null},{"input":"AMFeb+002025,2025-01-15T12 ","output":null},{"input":"Sat, 13 Nov 1976 17:47:54 GMT","output":216755274000},{"input":"+02:00","output":null},{"input":"Wed Jun 16 1971 05:44:01 GMT+0000 (Coordinated Universal Time)","output":45899041000},{"input":"Wed,pm12:00:00.123456GMT2025-01-15275760-09-13","output":null},{"input":"25:00T2025-00-10-EST15 ","output":null},{"input":"janUT24:00:00.001\nPDT","output":null},{"input":"2025-1-5 (,PDT","output":1736035200000},{"input":"/EST+02:00janPM ","output":null},{"input":"1981-11-02T06:24:18.688Z","output":373530258688},{"input":"AM -,31","output":null},{"input":"2025-02-29(comment)T","output":null},{"input":"JanT-000001","output":978307200000},{"input":"2025/01/1524:002025/01/15","output":null},{"input":"2025-13-01 Z (comment)-pm","output":null},{"input":"Sat, 08 Aug 1998 02:20:16 GMT","output":902542816000},{"input":"1978-11-15T06:06:27.840Z","output":279957987840},{"input":"UT+275760-09-13T00:00:00ZPM -0800T","output":null},{"input":"25:0023:59:60T12-","output":null},{"input":"+22025-01-15T12:00Z2025-01-15T123215/1/2025","output":null},{"input":"00garbage-PDT-0000011/15/2025","output":null},{"input":"Z23:59:60,AM2025-13-01 ","output":null},{"input":"Wednesday","output":null},{"input":".1970","output":0},{"input":"1942-10-18T18:32:04","output":-858490076000},{"input":"Sun Jun 26 2011 12:49:34 GMT+0000 (Coordinated Universal Time)","output":1309092574000},{"input":"15T23:59:6012:00:00.12345612:00:00.123456T275760-09-13am","output":null},{"input":"2025-01-15T12T ","output":null},{"input":"Feb2025-01-15T12 ,15+2-","output":null},{"input":"PMJan19702025-01-15T12:00Z2025-01-15T","output":null},{"input":"12:00:00.1234562025-00-10 02025/01/15pm:","output":1736978400123},{"input":"-000001","output":-62198755200000},{"input":"UTC-","output":null},{"input":"1953-12-01T13:21:36.000Z","output":-507551904000},{"input":")12:00:00.123T12","output":null},{"input":"1/15/2025T--z24:00:00.00115/1/2025","output":null},{"input":"EST","output":null},{"input":"Sun, 24 Sep 1989 15:01:15 GMT","output":622652475000},{"input":"2025","output":1735689600000},{"input":"PM","output":null},{"input":"pm","output":null},{"input":"GMT+002025-UT-","output":null},{"input":"Wed Aug 09 2006 10:16:11 GMT+0000 (Coordinated Universal Time)","output":1155118571000},{"input":"198","output":-55918857600000},{"input":"Thu Jun 14 1984 13:41:33 GMT+0000 (Coordinated Universal Time)","output":456068493000},{"input":"Wed,,","output":null},{"input":"+2 ","output":980985600000},{"input":"Wed, 28 Dec 2005 09:34:58 GMT","output":1135762498000},{"input":"Wed, 15 Dec 1993 23:05:58 GMT","output":755996758000},{"input":"+275760-09-13T00:00:00Z2025/01/15,15/1/2025","output":null},{"input":"UTz\t,","output":null},{"input":"50ZWednesday","output":null},{"input":"2025/01/15T2025-01-1515(,","output":null},{"input":"T120January2025-01-15T2025-00-102025-00-10","output":null},{"input":"Wed, T\n1/15/2025","output":1736899200000},{"input":"Wed Oct 13 1971 06:37:53 GMT+0000 (Coordinated Universal Time)","output":56183873000},{"input":"12:00:00.1231/15/2025-Feb T12","output":null},{"input":"+215T+275760-09-13T00:00:00Z +275760-09-13T00:00:00.001Z-","output":null},{"input":"12:00:0032,012:00","output":null},{"input":"Febpm","output":null},{"input":"Feb","output":null},{"input":"Tue Dec 09 2003 22:34:37 GMT+0000","output":1071009277000},{"input":"UT12:00:00+275760-09-13T00:00:00.001ZT121T23:59:60","output":null},{"input":" .152025-13-0100EST,","output":null},{"input":"JanWednesday\tz--T2025-01-15,","output":null},{"input":"15T15/1/2025-.(comment)12:00","output":null},{"input":"2001-10-25T11:48:39.040Z","output":1004010519040},{"input":"GMT322025-01-15T12-0000012025-02-29PM","output":null},{"input":" z","output":null},{"input":"T-","output":null},{"input":"Wed Jan 18 1995 12:34:37 GMT+0000 (Coordinated Universal Time)","output":790432477000},{"input":"12:00:00.123-24:00:00.001","output":null},{"input":"Mon Jan 25 1993 14:45:39 GMT+0000","output":727973139000},{"input":"Z12025-01-15T12:00Z","output":null},{"input":"2025-01-15Tz15/1/2025","output":null},{"input":"2002-02-10T16:49:03.744Z","output":1013359743744},{"input":"Tue, 20 Mar 1984 05:01:13 GMT","output":448606873000},{"input":"2000-06-03T01:32","output":959995920000},{"input":"2025-01-15T12:00Z","output":1736942400000},{"input":" 15","output":null},{"input":"+02:00-1970(2025-00-10(T12:00:00","output":null},{"input":"23:59:601736942400\t12:00:00.1234562025-02-29 ","output":null},{"input":"(comment)12:00 z","output":null},{"input":"2025-01-15T,","output":null},{"input":" 2025-01-15T","output":null},{"input":"Sun Nov 29 2009 18:06:26 GMT+0000 (Coordinated Universal Time)","output":1259517986000},{"input":"T15/1/2025,pm+212:00,24:00:00.001","output":null},{"input":"24:00Z122025-1-5Wed,","output":null},{"input":"2025/01/15","output":1736899200000},{"input":"1969-08-16T21:46:58.176Z","output":-11844781824},{"input":")","output":null},{"input":"JanuaryGMT2025-02-29 ","output":1735776000000},{"input":"jan-garbageGMT","output":null},{"input":"+275760-09-13T00:00:00.001Z5015/1/202515, ","output":null},{"input":"pm","output":null},{"input":"1","output":978307200000},{"input":"2025-00-10+275760-09-13T00:00:00.001Z2025-01-15T12:00Z+02:00,","output":null},{"input":"Wed, 19 Jul 2023 21:32:07 GMT","output":1689802327000},{"input":"am+02:00+002025 2025/01/15UT","output":null},{"input":"Sat, 26 May 2007 16:24:37 GMT","output":1180196677000},{"input":"2025-13-0149","output":null},{"input":"1976-10-02T03:59:05.216Z","output":213076745216},{"input":"PDT-PDTJanuary-","output":null},{"input":"Thu, 16 Dec 1999 00:47:40 GMT","output":945305260000},{"input":"15 1(comment)Janam","output":979516800000},{"input":"1996-01-12T10:33:53.664Z","output":821442833664},{"input":"1993-08-24T0","output":null},{"input":"00T12-001970","output":null},{"input":"Wed,Z","output":null},{"input":"2025-01-15-","output":null},{"input":"AM1/15/20252025-13-01TT ","output":null},{"input":"32garbage ","output":null},{"input":"Sun, 05 Sep 2032 03:44:58 GMT","output":1977968698000},{"input":".31","output":null},{"input":"-2024-02-29UT.T","output":null},{"input":"Tue May 16 1995 17:42:11 GMT+0000","output":800646131000},{"input":"1971-11-19T11","output":null},{"input":"15/1/202523:59:6015/1/2025+275760-09-13T00:00:00Z1736942400","output":null},{"input":"pm","output":null},{"input":" 2024-02-292025/01/1512:00:00.123456","output":null},{"input":"2025-13-01 12:00:00.12317369424002025-02-29","output":null},{"input":"15,","output":null},{"input":"1/15/20250UT+275760-09-13T00:00:00.001Z","output":null},{"input":" ","output":null},{"input":"4900,GMTJan24:00","output":null},{"input":"1966-03-29T04:11:14.048Z","output":-118698525952},{"input":"(EST1/15/2025","output":null},{"input":"Tue Jul 22 1997 00:09:09 GMT+0000","output":869530149000},{"input":"T12","output":null},{"input":"2025-01-15","output":1736899200000},{"input":"1935-03-19T15:","output":null},{"input":"1972-06-11T00:45:04.128Z","output":77071504128},{"input":"275760-09-13+02:00 ","output":null},{"input":"24:00","output":null},{"input":"Fri Feb 19 2010 16:40:19 GMT+0000 (Coordinated Universal Time)","output":1266597619000},{"input":"Sat, 05 Sep 1970 12:05:52 GMT","output":21384352000},{"input":"Tue Sep 12 2017 15:15:34 GMT+0000","output":1505229334000},{"input":"\t2025-13-01--000001GMT Wed,","output":null},{"input":"25:00+002025T","output":null},{"input":"+275760-09-13T00:00:00ZGMTTT12T2025-00-102025-01-15T12:00Z","output":null},{"input":"1943-11-03T21:59:17.504Z","output":-825559242496},{"input":"24:0050-T","output":null},{"input":"z-,2025-00-1031","output":null},{"input":"12:00:00.12324:00:00.00124:00+02:00-","output":null},{"input":"(comment),","output":null},{"input":"Tue Apr 05 1988 16:13:32 GMT+0000 (Coordinated Universal Time)","output":576260012000},{"input":"-(","output":null},{"input":"+275760-09-13T00:00:00Z23:59:60","output":null},{"input":"32EST/1/15/2025WednesdayT+275760-09-13T00:00:00Z","output":null},{"input":" 49-2024-02-29 ","output":null},{"input":"Wed, 28 Mar 2029 20:51:32 GMT","output":1869425492000},{"input":"1/15/2025-1T275760-09-13","output":null},{"input":"Wed Mar 20 2013 16:17:36 GMT+0000 (Coordinated Universal Time)","output":1363796256000},{"input":"23:59:601,25:002025-01-15T12:00Z","output":null},{"input":"2025-00-10:","output":null},{"input":"Z1212:00:00.123:2025-1-52025-01-15T12","output":null},{"input":"T12am:","output":null},{"input":"T12T1249/2024-02-29-","output":null},{"input":"Thu Dec 02 1982 17:56:33 GMT+0000 (Coordinated Universal Time)","output":407699793000},{"input":"T ","output":null},{"input":"99:Wed,","output":null},{"input":"+275760-09-13T00:00:00ZWed,2025/01/15,","output":null},{"input":"2025-01-15T12)1970 pm","output":null},{"input":"jan23:59:600049","output":null},{"input":"275760-09-1323:59:60 +275760-09-13T00:00:00.001Z ","output":null},{"input":"Z12+002025,Feb-+2","output":null},{"input":"Z2025 12:00:00.123","output":null},{"input":"3215/1/2025","output":null},{"input":"12:00:00.12345612:00:00.123UT-275760-09-13","output":null},{"input":"2025-01-15T12:00Z(-am","output":null},{"input":"202512:00:00.1234562025-1-5","output":null},{"input":"24:00","output":null},{"input":"00+2","output":null},{"input":"2025-00-10,PDTJan-\tFeb","output":null},{"input":"2001-02-27T18:31:00.864Z","output":983298660864},{"input":"1972-10-13T01:35:03.680Z","output":87788103680},{"input":"\t,2025/01/15 ","output":1736899200000},{"input":"00-","output":946684800000},{"input":"Tue Jul 27 2032 14:51:16 GMT+0000","output":1974552676000},{"input":"+275760-09-13T00:00:00Z)am,\tPDT","output":null},{"input":"-0800","output":-36921657600000},{"input":"UTC2025-02-29","output":null},{"input":"Fri Feb 08 2036 13:11:29 GMT+0000","output":2086089089000},{"input":"12:00","output":null},{"input":" ,2025-1-5","output":1736035200000},{"input":"/-T pm","output":null},{"input":"garbage","output":null},{"input":"TESTT(1/15/2025","output":null},{"input":"Fri, 19 Jan 1990 23:12:22 GMT","output":632790742000},{"input":"Wed, 07 May 2031 00:32:23 GMT","output":1935880343000},{"input":"January,am( 12:00:00.123 ","output":null},{"input":"Wed May 03 1989 09:50:19 GMT+0000 (Coordinated Universal Time)","output":610192219000},{"input":"49-","output":2493072000000},{"input":"Thu Sep 30 2010 15:00:02 GMT+0000","output":1285858802000},{"input":"Wed Sep 18 2013 16:39:24 GMT+0000","output":1379522364000},{"input":"1970","output":0},{"input":"2003-09-18T22:08:59.392Z","output":1063922939392},{"input":"\tT","output":null},{"input":"2025-1-5+2TJan+00202512:00:00.123456","output":null},{"input":"January ZTUT,EST+275760-09-13T00:00:00.001Z","output":null},{"input":"- AM2025/01/15,2025","output":null},{"input":"23:59:6012:00:00+002025","output":null},{"input":"1946-03-28T07:39:16.864Z","output":-749924443136},{"input":"T173694240024:00:00.001","output":null},{"input":"Z 00","output":946684800000},{"input":"Z12-3100)-","output":null},{"input":"\n+002025","output":1735689600000},{"input":"15 1","output":null},{"input":"1","output":978307200000},{"input":"UTC","output":null},{"input":"1UTCJan","output":null},{"input":".","output":null},{"input":"AM","output":null},{"input":"garbage(","output":null},{"input":"1980-09-1","output":336614400000},{"input":"1/15/2025152025-01-15T12-","output":null},{"input":"Sat, 15 Mar 2003 04:07:46 GMT","output":1047701266000},{"input":"GMTT2025-13-01EST12:00:00 \t","output":null},{"input":"Sat Jan 23 2027 01:32:16 GMT+0000","output":1800667936000},{"input":" AM992025-01-15T12","output":null},{"input":",+02:001,,GMT,","output":null},{"input":"2025-02-2949-","output":null},{"input":"Mon Apr 03 1995 23:54:32 GMT+0000","output":796953272000},{"input":"Wed Nov 12 1980 05:55:13 GMT+0000 (Coordinated Universal Time)","output":342856513000},{"input":"23:59:60 -0800","output":-315504060000},{"input":"Mon Sep 17 2012 04:44:23 GMT+0000","output":1347857063000},{"input":"Z12AM(Feb,PDT15","output":null},{"input":"99UTWed,+02:0024:00:00.001","output":null},{"input":"Tue, 02 Jan 1979 08:36:23 GMT","output":284114183000},{"input":"2025-02-29 ","output":1740787200000},{"input":"Thu, 16 Nov 2023 03:20:47 GMT","output":1700104847000},{"input":"1950","output":-631152000000},{"input":"Feb zFebFeb- ,99","output":917827200000},{"input":"Fri Dec 27 2002 20:00:16 GMT+0000 (Coordinated Universal Time)","output":1041019216000},{"input":"2025 \n-+275760-09-13T00:00:00Z2025/01/15Jan","output":null},{"input":"Sat, 14 Oct 2017 13:36:58 GMT","output":1507988218000},{"input":"24:00:00.001-12:00:00 PM","output":null},{"input":"+275760-09-13T00:00:00Z Wed,1524:00:00.001Zjan","output":null},{"input":"2025-01-15T12:00Z99PDTUTT","output":null},{"input":"2025-01-152024-02-29 UT .12:00:00.123456pm","output":null},{"input":"Wed Nov 14 2007 18:27:46 GMT+0000","output":1195064866000},{"input":"AM1970-08002025-02-2920252025-1-5","output":null},{"input":"1997-02-26T06:03:59.360Z","output":856937039360},{"input":"/-1/15/2025-","output":1736899200000},{"input":"2025-13-01UTC","output":null},{"input":"1976-08-02T23:","output":null},{"input":"2025-1-52025.+2 ","output":null},{"input":"+2PDT312025-01-15 2024-02-29","output":null},{"input":"+02:00","output":null},{"input":"1995-12-13T20:01:59.296Z","output":818884919296},{"input":"UTCT2025-13-01-000001+02:00+02:00","output":null},{"input":"+002025 0 24:0032zWed,","output":null},{"input":"FebWed,","output":null},{"input":")TPDT2025/01/15EST12:00:00-PM","output":null},{"input":"1944-06-2","output":-807321600000},{"input":"PMUTC","output":null},{"input":"Wed, 17 Jan 2029 13:57:17 GMT","output":1863352637000},{"input":"24:00 31,T","output":null},{"input":"2025-13-01,2025-1-5z\n,PM-PM","output":null},{"input":".","output":null},{"input":"-TT19701+2","output":null},{"input":"Mon, 01 May 1972 10:00:59 GMT","output":73562459000},{"input":"2025-01-15T12:00Z","output":1736942400000},{"input":" 25:002025-01-15T2025-13-01,","output":null},{"input":"1/15/2025 4925:00","output":null},{"input":"Z1215/1/202531","output":null},{"input":"12:00:00UTC","output":null},{"input":"23:59:6023:59:60ZT","output":null},{"input":"\t2025-00-10 +21 ","output":null},{"input":"UTT1736942400Z) 24:00,z","output":null},{"input":"UTC23:59:60,garbage ","output":null},{"input":"+275760-09-13T00:00:00Z25:00EST(pm","output":null},{"input":"1978-03-06T09:0","output":null},{"input":"Tue, 17 Sep 1985 05:32:07 GMT","output":495783127000},{"input":"-08002025-02-29","output":null},{"input":"Mon Dec 10 1973 02:43:06 GMT+0000","output":124339386000},{"input":"12:00275760-09-1312:00:00.123","output":null},{"input":"+0020252025-01-15TAMESTT","output":null},{"input":"1","output":978307200000},{"input":"197099","output":6157676505600000},{"input":"Feb-080015/1/2025T-","output":null},{"input":"T,2025-01-15T12:00Z,.T12:00:00.123456JanFeb","output":null},{"input":"1972-02-24T16:30:37.824Z","output":67797037824},{"input":"Wednesday2025-13-0125:00UT+275760-09-13T00:00:00.001Z","output":null},{"input":"23:59:60","output":-315532860000},{"input":"Wednesday","output":null},{"input":" 2025-01-15T","output":null},{"input":",","output":null},{"input":"Mon, 04 Oct 2027 09:42:28 GMT","output":1822642948000},{"input":"1997-12-14T19:48:4","output":null},{"input":"Thu, 25 Mar 1982 00:32:46 GMT","output":385864366000},{"input":"WednesdayTUT\t","output":null},{"input":"/ --","output":null},{"input":"/+002025","output":1735689600000},{"input":"12:00:00.123ZWednesdayT,am","output":null},{"input":"Tue, 10 Jun 1980 11:19:25 GMT","output":329483965000},{"input":"50,1/15/2025","output":null},{"input":"0023:59:60","output":null},{"input":"1955-07-26T08:33:27.808Z","output":-455556392192},{"input":" +275760-09-13T00:00:00Z)","output":null},{"input":"/15","output":null},{"input":"+275760-09-13T00:00:00Z-2025-01-15T12:00Z2025-13-0117369424002025","output":null},{"input":"jan","output":null},{"input":"3223:59:60-000001T275760-09-131am","output":null},{"input":"PDTGMT24:00:00.001-12:00:00.123,","output":null},{"input":"UTT","output":null},{"input":"Tue, 11 Feb 1986 03:32:59 GMT","output":508476779000},{"input":"50-January ZTJanuary","output":null},{"input":"Fri Sep 30 2011 20:18:51 GMT+0000 (Coordinated Universal Time)","output":1317413931000},{"input":"312025-01-15T ","output":null},{"input":"AM20252025-01-15T,","output":null},{"input":"49+275760-09-13T00:00:00.001Z15173694240024:002024-02-29","output":null},{"input":"Mon, 25 Oct 1976 21:54:23 GMT","output":215128463000},{"input":"/,EST","output":null},{"input":"Fri Apr 15 2033 15:24:57 GMT+0000","output":1997191497000},{"input":"1952-08-30T02:58:07.488Z","output":-547160512512},{"input":"Mon, 07 Aug 2006 07:55:02 GMT","output":1154937302000},{"input":"1984-05-07T12:16:53.760Z","output":452780213760},{"input":"Wed,garbage49","output":null},{"input":"2025-02-2920251T.","output":null},{"input":"Wed Oct 08 2003 06:34:29 GMT+0000","output":1065594869000},{"input":" T-0800","output":-36921657600000},{"input":"jan2025-01-1512:00-2025-1-52025/01/15","output":null},{"input":"1991-06-17T01:31:15.840Z","output":677122275840},{"input":",0","output":946684800000},{"input":"2025-00-10","output":null},{"input":"UT-000001\t","output":978307200000},{"input":"1981-05-21T15:23:4","output":null},{"input":"2025-01-15AM--12:00:00 T12","output":null},{"input":"15131z49","output":null},{"input":"2025-01-15T12--000001 ","output":null},{"input":"-Wed,2025/01/15Wednesday","output":null},{"input":"1943-03-23T18:14:35.520Z","output":-845012724480},{"input":"1987-","output":536457600000},{"input":"2025-02-29 \t+275760-09-13T00:00:00.001ZJanuary2025-13-01z","output":null},{"input":"2025-02-2912:00-","output":null},{"input":"am","output":null},{"input":"GMTjan2025-13-012025-01-15","output":null},{"input":"1736942400T","output":null},{"input":"Sat Jan 01 1994 03:38:44 GMT+0000 (Coordinated Universal Time)","output":757395524000},{"input":" ,","output":null},{"input":"Tue Jul 08 1986 12:22:05 GMT+0000","output":521209325000},{"input":"23:59:60002025","output":null},{"input":"+275760-09-13T00:00:00.001Z","output":null},{"input":"ZWed,Z(","output":null},{"input":"Z","output":null},{"input":"ampmZWednesday1","output":null},{"input":")T2024-02-29\n-2025-01-15-T2025-01-15","output":null},{"input":"25:00T2025-00-1000","output":null},{"input":"Z12UT","output":null},{"input":"12:00-,PDTZ12","output":null},{"input":"Wednesday","output":null},{"input":"1963-11-01T0","output":null},{"input":"+2 ","output":980985600000},{"input":"(comment)jan+02:00UTJanuary2025/01/15T","output":null},{"input":"-0800 +02:00TJanz / UTC","output":null},{"input":"2025-13-0150am+275760-09-13T00:00:00Z,T31","output":null},{"input":"1990-07-31T15:56:53.376Z","output":649439813376},{"input":"23:59:60,","output":-315532860000},{"input":"Fri, 20 Jul 1990 03:57:11 GMT","output":648446231000},{"input":"2025-01-15T12","output":null},{"input":"1965-01-2","output":-157680000000},{"input":"15/1/2025Z12:00:00,","output":null},{"input":"Wed,UTC2025Jan1970,(","output":null},{"input":"2024-02-29-Feb12:00:00.123456garbage ","output":null},{"input":"1736942400+02:00,Wednesday jan 2025","output":null},{"input":"2025/01/15 Jan","output":1735689600000},{"input":"Wed Jun 30 2004 06:49:48 GMT+0000","output":1088578188000},{"input":",15/1/2025 25:00T:","output":null},{"input":"2024-02-29","output":1709164800000},{"input":"12:00:00.123, -pm","output":null},{"input":"1968-07-19T03:46:44.096Z","output":-45864795904},{"input":"UT50PDT49-+002025TT12","output":null},{"input":"1940-09-01T02:42:50.752Z","output":-925679829248},{"input":"+002025Wed,-","output":null},{"input":"12:00:00 2025-02-29+275760-09-13T00:00:00Z-+002025","output":null},{"input":"1970-10-22T01:15","output":25406100000},{"input":"(,","output":null},{"input":"1940-08-17T17:45:31.648Z","output":-926921668352},{"input":"Fri, 23 Jul 1999 23:36:33 GMT","output":932772993000},{"input":"AMJan-Z2025-13-01","output":null},{"input":"1989-02-20T02:42:25","output":603945745000},{"input":"1988-08-","output":586396800000},{"input":"Z00T1736942400,","output":null},{"input":"12:00TEST(comment))+2","output":null},{"input":"PDTJanuary2025-13-01","output":null},{"input":"Sat Jul 31 2032 22:03:26 GMT+0000","output":1974924206000},{"input":"/","output":null},{"input":"2025-1-515Z12+275760-09-13T00:00:00.001Z z,","output":null},{"input":"2025-02-29EST(comment)","output":1740805200000},{"input":"3124:00:00.001+275760-09-13T00:00:00.001Z-2025-01-15T12:00Z,\n","output":null},{"input":"49","output":2493072000000},{"input":"275760-09-132025-01-15T-","output":null},{"input":"AM\t2025-01-15T12AM2025-01-15T12:00Z15","output":null},{"input":"AM2024-02-291970+275760-09-13T00:00:00Z+02:00","output":null},{"input":".jan1173694240024:00:00.001","output":null},{"input":"23:59:60PM-Feb2025-01-15T12garbage","output":null},{"input":"25:00","output":null},{"input":"garbage,99pm","output":null},{"input":"24:00:00.001-275760-09-13,49","output":null},{"input":"ESTEST","output":null},{"input":"1962-02-19T23:29:49.568Z","output":-248142610432},{"input":"PMT) ","output":null},{"input":"PDTT24:002025-01-15UT2025-13-01,(","output":null},{"input":"Wed Sep 05 1973 01:31:57 GMT+0000 (Coordinated Universal Time)","output":116040717000},{"input":"1970T","output":null},{"input":"Mon, 12 Jul 1971 11:26:08 GMT","output":48165968000},{"input":" -","output":null},{"input":"-,AM+275760-09-13T00:00:00Z","output":null},{"input":"+275760-09-13T00:00:00.001Z ","output":null},{"input":"am2025-01-15T2025-00-10","output":null},{"input":"-UTC15/1/2025","output":null},{"input":"Z12 ,49","output":null},{"input":"garbage 31","output":null},{"input":"1964-03-26T20:38:03","output":-181970517000},{"input":"2025/01/152025-01-15T12:00:00.123456T12,-000001","output":null},{"input":" -000001:GMT ","output":null},{"input":"1982-03-19T18","output":null},{"input":"2025-1-5+002025,15","output":null},{"input":"(32+275760-09-13T00:00:00Z,,(","output":null},{"input":"-08002025Wed,","output":null},{"input":"","output":null},{"input":"Tue May 17 2039 18:46:41 GMT+0000","output":2189270801000},{"input":":12:00:00+275760-09-13T00:00:00.001Z,January,","output":null},{"input":"1","output":978307200000},{"input":"Fri Apr 05 2030 22:37:56 GMT+0000","output":1901659076000},{"input":")25:0023:59:60+20","output":null},{"input":"T4912:00","output":null},{"input":"12:00:00.123456 ","output":null},{"input":"(,","output":null},{"input":"15","output":null},{"input":"January,1garbage1970 \n Wednesday","output":null},{"input":"AM15+275760-09-13T00:00:00.001Z","output":null},{"input":"24:0024:00:00.001T,:1736942400","output":null},{"input":"1973-09-20T04:","output":null},{"input":"UTC","output":null},{"input":"UTT)2025-13-01","output":null},{"input":"1939-10-20T22:48:31.232Z","output":-952996288768},{"input":"23:59:60 -0800 ","output":-315504060000},{"input":"1941-02-13T1","output":null},{"input":"2025-00-10 ","output":null},{"input":"T\nUT-2025/01/15,23:59:6012:00:00.123","output":null},{"input":"PMzUTT+2","output":980985600000},{"input":"2025-13-0112:00:00","output":null},{"input":"2025/01/15JanuaryFebgarbage2025-01-15T12:00Zpm","output":null},{"input":"1152025-1-5","output":null},{"input":"Fri, 20 Oct 1978 02:16:50 GMT","output":277697810000},{"input":"Sat Nov 20 1982 22:35:18 GMT+0000 (Coordinated Universal Time)","output":406679718000},{"input":"Thu Jul 08 1993 18:31:23 GMT+0000","output":742156283000},{"input":"20252024-02-29Z12","output":null},{"input":"25:00","output":null},{"input":"Z1220251736942400","output":null},{"input":"zAM1-","output":null},{"input":"/-0000012025 15/1/2025,:","output":null},{"input":"99","output":915148800000},{"input":"garbageWed,2025-01-15T17369424002025-13-01","output":null},{"input":"1985-10-24T0","output":null},{"input":"2025-01-15T2025-01-15T12:00Z","output":null},{"input":"EST,GMT31-","output":null},{"input":"Sun, 13 Jul 2036 13:57:13 GMT","output":2099570233000},{"input":"32T2025/01/15","output":null},{"input":"UTCam2025-02-2923:59:60","output":null},{"input":"196","output":-55982016000000},{"input":"1975-03-17T17:55:37.856Z","output":164310937856},{"input":"EST15 2024-02-29+200+02:00","output":null},{"input":"+275760-09-13T00:00:00.001Z49PM","output":null},{"input":"0 99-000001-5015","output":null},{"input":"2025-02-291970,-\n","output":null},{"input":"12:00:00-50+275760-09-13T00:00:00ZPDT2024-02-29","output":null},{"input":"23:59:6023:59:60+2","output":null},{"input":"Tue Sep 04 2007 11:01:57 GMT+0000 (Coordinated Universal Time)","output":1188903717000},{"input":"z1 am\tam","output":null},{"input":"15 AM(comment)00-322025-01-15T12:00Z","output":null},{"input":"PM+275760-09-13T00:00:00ZT\t31 Z12T12","output":null},{"input":"z2025/01/15Z12z","output":null},{"input":"1946-04-22T11:","output":null},{"input":"23:59:60","output":-315532860000},{"input":"1994-04-26T15:44:40.704Z","output":767375080704},{"input":"1981-01-1","output":347155200000},{"input":"1967-03-25T01:02:1","output":null},{"input":"+275760-09-13T00:00:00Z-+275760-09-13T00:00:00.001Z1736942400jan/Jan-","output":null},{"input":"+275760-09-13T00:00:00.001Z31 24:00:00.001AM00","output":null},{"input":"25:0031-2025-01-15T12-","output":null},{"input":"32 12:00:00.123456","output":1956571200123},{"input":"PDT49z","output":null},{"input":"31-2024-02-29/","output":null},{"input":"1970 +2,","output":null},{"input":"-00000131am","output":null},{"input":"garbage garbage-T00TUTC,","output":null},{"input":"00 Z12,+2 2025-13-01","output":null},{"input":"24:00jan","output":null},{"input":"32","output":1956528000000},{"input":"1966-12-10T21:23:55.776Z","output":-96518164224},{"input":"1970:Z12 99T+02:00,","output":null},{"input":",","output":null},{"input":"Sat, 25 Jan 2031 21:15:32 GMT","output":1927142132000},{"input":"23:59:60 2025-01-15T.","output":null},{"input":"Thu Nov 24 1983 10:20:03 GMT+0000","output":438517203000},{"input":"Wed,-Wed,TWednesday24:00 pm","output":null},{"input":"amUTC","output":null},{"input":"23:59:60Feb ","output":-312854460000},{"input":"-0800T12","output":null},{"input":"Wed, 21 Nov 2029 18:48:22 GMT","output":1889981302000},{"input":"00\namT1215","output":null},{"input":"23:59:60pm24:00:00.001Jan00/","output":null},{"input":"2024-02-29am2025-13-012025-1-51,","output":null},{"input":"31 00 2025-01-15T12z1","output":null},{"input":" 2025-01-15","output":1736899200000},{"input":"2001-0","output":null},{"input":"Z12","output":null},{"input":"Z12+002025-000001","output":null},{"input":"32-Wed,z","output":null},{"input":"1/15/2025(2025/01/1524:00-0800","output":1736899200000},{"input":"1979-04-16T10:57:15.008Z","output":293108235008},{"input":"1970UT\n,","output":0},{"input":"Fri Jan 31 2003 15:35:03 GMT+0000 (Coordinated Universal Time)","output":1044027303000},{"input":"2025TAM-","output":null},{"input":"1959-04-07T22:47:05.216Z","output":-338778774784},{"input":"ESTjan1Jan 12:002025-01-15T","output":null},{"input":"275760-09-13TJan 99","output":null},{"input":"TWed,T2025 2025,15","output":null},{"input":"1736942400T 2025-02-29-Wednesday 2025-01-15T12","output":null},{"input":"24:00:00.001UTC 31-PDTT","output":null},{"input":"GMTT+275760-09-13T00:00:00.001Z","output":null},{"input":"JanuaryJanuary-0800","output":-36921657600000},{"input":"jan","output":null},{"input":"275760-09-1315/1/20252025-01-15T12","output":null},{"input":"1943-07-26T21:54:41.280Z","output":-834199518720},{"input":"275760-09-1315,12:00:00.123456T","output":null},{"input":"\tTT)2024-02-292025-01-15T12EST","output":null},{"input":"Thu, 04 Nov 1993 11:04:15 GMT","output":752411055000},{"input":"1-12:00:00.12324:00:00.00123:59:60Tam","output":null},{"input":"12:00 0012:00:00.123456-Z12-3115","output":null},{"input":"garbage-","output":null},{"input":"1985-07-28T03:51:16.480Z","output":491370676480},{"input":"+00202532z(comment)+275760-09-13T00:00:00.001Z","output":null},{"input":"Fri Feb 04 2033 19:10:06 GMT+0000","output":1991157006000},{"input":"275760-09-1324:00+275760-09-13T00:00:00Z31","output":null},{"input":"January","output":null},{"input":"Wed May 28 2008 08:02:39 GMT+0000 (Coordinated Universal Time)","output":1211961759000},{"input":"15/1/2025,202512:00:00.123456z275760-09-13 ","output":null},{"input":"T275760-09-1312:0024:00 :","output":null},{"input":"T2025-01-15,00ESTz,","output":null},{"input":"-31:January","output":null},{"input":"Mon, 24 Sep 2007 18:05:54 GMT","output":1190657154000},{"input":"JanUTC","output":null},{"input":"24:00.+275760-09-13T00:00:00.001Z,","output":null},{"input":"2025-","output":1735689600000},{"input":"1972-07-27T23:52:29.696Z","output":81129149696},{"input":"AMESTz","output":null},{"input":"Thu Apr 08 1982 05:34:50 GMT+0000 (Coordinated Universal Time)","output":387092090000},{"input":"15/1/2025TAM2025/01/15","output":null},{"input":")-2025-13-01 GMT12:00:00.123456,5050","output":null},{"input":"January,15/1/2025Jan","output":979516800000},{"input":"1/15/2025-1/15/2025","output":null},{"input":"T12 (comment)ESTamT","output":null},{"input":"2025-1-5+002025AMam,","output":null},{"input":"-15/1/2025","output":null},{"input":"1980-11","output":341884800000},{"input":"1940-05-04T","output":null},{"input":"2025-02-29,","output":1740787200000},{"input":"-z+2EST-000001,","output":null},{"input":"\n\n+275760-09-13T00:00:00.001Z","output":null},{"input":"Z","output":null},{"input":"+002025Z00","output":null},{"input":"Sat Nov 01 1986 09:51:44 GMT+0000 (Coordinated Universal Time)","output":531222704000},{"input":"Thu, 31 May 2018 16:40:16 GMT","output":1527784816000},{"input":"T2025-01-15T12-12:00:00.12345631z-AM","output":null},{"input":"+002025 +0020251/15/2025,99EST ","output":null},{"input":"EST+275760-09-13T00:00:00.001Z,31UT-0800","output":null},{"input":"31(AM1/15/2025Jan2025-01-15T12:00Z,","output":null},{"input":"1989-08-06T11:33:15.136Z","output":618406395136},{"input":" ESTpm\n-1970-","output":0},{"input":"Fri Jul 04 2036 00:45:34 GMT+0000","output":2098745134000},{"input":"Jan","output":null},{"input":"Fri Oct 17 2036 20:29:57 GMT+0000 (Coordinated Universal Time)","output":2107888197000},{"input":"Sat Jul 30 2016 06:59:26 GMT+0000","output":1469861966000},{"input":"T12- ","output":null},{"input":"1942-07-26T06:05:07.968Z","output":-865792492032},{"input":":T12:00:00.123456Wed,(comment))T","output":null},{"input":"1/15/2025UTC\n,T12,-0800,","output":null},{"input":"1935-11-23T01:1","output":null},{"input":"PM,2025-01-15T+275760-09-13T00:00:00.001Z50UTC","output":null},{"input":"1/15/202550(2025-1-51599","output":6329694672000000},{"input":"2025-00-102025-02-29amTAMT","output":null},{"input":"24:002025-01-15","output":null},{"input":"UTC-24:00T2025-1-5","output":null},{"input":"Thu, 17 Jan 2019 00:28:09 GMT","output":1547684889000},{"input":"Fri Oct 12 2012 12:32:48 GMT+0000 (Coordinated Universal Time)","output":1350045168000},{"input":"Thu, 10 Mar 2039 10:41:15 GMT","output":2183366475000},{"input":"+2","output":980985600000},{"input":"jan12:00:00.123","output":null},{"input":"+2am","output":null},{"input":"-","output":null},{"input":"504931","output":null},{"input":"1978-06-01T07:26:36.288Z","output":265533996288},{"input":"12:00:00.123456+02:00","output":null},{"input":"50","output":-631152000000},{"input":" 15JanT-0800+2","output":null},{"input":"GMT12:00:00.123UTC2025/01/15 2025/01/1599","output":null},{"input":"1989","output":599616000000},{"input":"31AM","output":null},{"input":"1946-10-20T","output":null},{"input":"Thu Jun 22 2023 14:39:20 GMT+0000","output":1687444760000},{"input":"-080024:00:00.00115/1/2025\nFeb","output":null},{"input":"Wed,2025-01-15T12Z-","output":null},{"input":"1995-06-07T04:27:","output":null},{"input":" -T12:00:00Z PM+002025","output":null},{"input":"Sun May 03 1987 18:00:48 GMT+0000","output":547063248000},{"input":"12:00:00,Feb-","output":null},{"input":"+02:001Jan15/1/2025TPDT12:00:00.123 ","output":null},{"input":"2025January-+002025","output":null},{"input":"31Januaryjan2025-1-5T15/1/2025\n","output":null},{"input":"Tue Nov 24 2026 09:14:24 GMT+0000","output":1795511664000},{"input":"15,12:00","output":null},{"input":"1947-06-17T05:40:49.792Z","output":-711397150208},{"input":"24:00:00.001-00000100PDT 197025:00","output":null},{"input":"EST jan2025Wed,T2025-02-291/15/2025","output":null},{"input":"1963-12-3","output":-191894400000},{"input":"2000-11-17T08:31:11.6","output":974449871600},{"input":"EST.","output":null},{"input":",,UTUTC T12:00","output":null},{"input":"1963-03-28T","output":null},{"input":"Wed Nov 06 2013 18:41:31 GMT+0000","output":1383763291000},{"input":"PM12:00:00,.-000001","output":null},{"input":"00T.","output":null},{"input":"32-000001PM","output":null},{"input":"T12+275760-09-13T00:00:00.001Z","output":null},{"input":"Sat Jul 30 1983 17:44:06 GMT+0000","output":428435046000},{"input":"Wednesday24:00:00.001,","output":null},{"input":"Feb 992025-02-2900","output":null},{"input":"UT-GMTT2025-01-1531UTC","output":null},{"input":"Mon Mar 11 2024 01:33:33 GMT+0000","output":1710120813000},{"input":"2024-02-29-UT /15/1/202515/1/2025T","output":null},{"input":"1950-03-05T14:58:27.712Z","output":-625654892288},{"input":"garbage","output":null},{"input":"2024-02-29","output":1709164800000},{"input":"pm,502024-02-29T24:00","output":null},{"input":"275760-09-13,z,UT2025/01/1515/1/2025","output":null},{"input":"Tue May 02 2028 01:10:32 GMT+0000","output":1840842632000},{"input":"+275760-09-13T00:00:00.001Z-99-0800","output":null},{"input":"1940-01-31T20:00:28.160Z","output":-944107171840},{"input":"00GMT2024-02-29-0800-1736942400-0800","output":null},{"input":"32z","output":1956528000000},{"input":"152025-01-15T12","output":null},{"input":"Z12+02:00-","output":null},{"input":"AM-+2","output":980985600000},{"input":"50T12 24:00:00.001 1970","output":null},{"input":"1985-09-16T01:12:37.8","output":495681157800},{"input":"31T2025-02-29,9999","output":null},{"input":"am2025-01-15T12:00Z,UTC31","output":null},{"input":"T2025/01/15 2025-00-102024-02-29","output":null},{"input":"Z12-23:59:60Z12-2025-00-10,","output":null},{"input":"Sun Oct 14 2012 03:42:41 GMT+0000 (Coordinated Universal Time)","output":1350186161000},{"input":"2025","output":1735689600000},{"input":"Fri Jun 12 2020 11:07:47 GMT+0000","output":1591960067000},{"input":"2025-01-15T15AM-Wed,TT12","output":null},{"input":"2003-01-17T03:33:","output":null},{"input":"15/1/2025-","output":null},{"input":"am","output":null},{"input":"+002025TZgarbage","output":null},{"input":" -197012:00:00.123-:","output":null},{"input":"Tue, 19 Oct 1976 13:11:10 GMT","output":214578670000},{"input":"32,2025-01-15T122025+02:00z","output":null},{"input":"Jan\nGMT12:00:00\t","output":null},{"input":"1979-04-25T10:52:38.272Z","output":293885558272},{"input":"Mon, 19 Mar 2007 06:34:17 GMT","output":1174286057000},{"input":"Wed Sep 05 1990 01:40:52 GMT+0000","output":652498852000},{"input":"12:00","output":null},{"input":"EST,UTTgarbageWed,","output":null},{"input":"-08002025-01-15T12,","output":null},{"input":"T1211/15/2025garbage2025-01-152025-00-10","output":null},{"input":"20253112:00:00- 15/1/2025","output":null},{"input":"25:00UT","output":null},{"input":"UTCWed,-000001","output":978307200000},{"input":"PM)(comment)","output":null},{"input":"2025-01-15T12","output":null},{"input":"PM32Wednesday","output":null},{"input":"+275760-09-13T00:00:00.001Z275760-09-132025-01-15T12","output":null},{"input":"pm1/15/2025 12:00:00-15/1/2025,\t","output":null},{"input":"am49","output":null},{"input":"2025-01-15T12:00Z2025-1-5 Z122025/01/15.,","output":null},{"input":"+02:00-2025-01-15T12131,19702024-02-29","output":null},{"input":"Sat Sep 11 2021 21:11:35 GMT+0000 (Coordinated Universal Time)","output":1631394695000},{"input":"Thu Oct 26 2023 23:26:02 GMT+0000","output":1698362762000},{"input":"Mon, 20 Apr 1998 11:45:43 GMT","output":893072743000},{"input":"am","output":null},{"input":"12:00T","output":null},{"input":"2025-01-15T12:00Z23:59:6025:00\t,","output":null},{"input":"2024-02-29January2024-02-29jan2025-01-15T","output":null},{"input":"+02:00T","output":null},{"input":"amjanTjan20251","output":null},{"input":"112:00:00","output":null},{"input":"2025-01-15T12+02:00T2024-02-29 31 0","output":null},{"input":"1970(comment)+275760-09-13T00:00:00Z","output":null},{"input":"Mon, 18 Dec 1989 20:28:07 GMT","output":630016087000},{"input":"Sat, 09 Jun 2007 03:03:02 GMT","output":1181358182000},{"input":"GMT24:00:00.0012025-01-1550-23:59:60","output":null},{"input":"Sat, 26 Jul 1975 09:43:47 GMT","output":175599827000},{"input":"24:00:00.001","output":null},{"input":"Fri Dec 02 1983 17:52:09 GMT+0000","output":439235529000},{"input":"25:0099-000001jan50T","output":null},{"input":"2024-02-292025-01-15T/+275760-09-13T00:00:00ZT+275760-09-13T00:00:00Z-000001","output":null},{"input":"50/","output":-631152000000},{"input":"23:59:60--00000100,).T00","output":null},{"input":"12:00:00/ ","output":null},{"input":"24:00","output":null},{"input":"1974-11-01T00:30:32.960Z","output":152497832960},{"input":"0 ","output":946684800000},{"input":" -","output":null},{"input":"19","output":null},{"input":"1","output":978307200000},{"input":"1985","output":473385600000},{"input":"ZFeb1970-Wednesday1T","output":null},{"input":"Sun Dec 25 2011 05:41:28 GMT+0000","output":1324791688000},{"input":"Wed,garbage","output":null},{"input":"2025-13-0149WednesdayT","output":null},{"input":"\t197012:00:00+002025T pm","output":null},{"input":"pm","output":null},{"input":"1952-11-05T02:39:24.416Z","output":-541372835584},{"input":"amZ-000001TWednesday","output":null},{"input":"1736942400,2025-1-5 ","output":null},{"input":"15/1/2025","output":null},{"input":"2025-01-15jan","output":1735689600000},{"input":"JanJanuary","output":null},{"input":"Wed Jul 16 1975 14:03:18 GMT+0000","output":174751398000},{"input":"2025-01-15+002025 ,garbage+2,","output":null},{"input":"+002025 2025T12:00:00Wed,\n23:59:60","output":null},{"input":"Sat May 13 2017 02:23:40 GMT+0000","output":1494642220000},{"input":"23:59:60,","output":-315532860000},{"input":" 12:00,. PM ","output":null},{"input":"Sat Jan 18 2014 08:50:16 GMT+0000 (Coordinated Universal Time)","output":1390035016000},{"input":" T","output":null},{"input":"z+2,0000-Jan+275760-09-13T00:00:00.001Z","output":null},{"input":"Mon Jun 29 1998 00:08:47 GMT+0000 (Coordinated Universal Time)","output":899078927000},{"input":"1938-10-12T18:10:40.000Z","output":-985240160000},{"input":"+275760-09-13T00:00:00Z.31) jan25:00","output":null},{"input":"15/1/202512:0031","output":null},{"input":"Feb 9912:00:00.12345625:00","output":null},{"input":"/,202531,UTC","output":6329093846400000},{"input":"2024-02-29T-","output":null},{"input":"zjan--Wed,-Wed,","output":null},{"input":"Wed Oct 31 1984 03:17:49 GMT+0000","output":468040669000},{"input":"1,12:00:00.1234562025-01-15T-UT2025-00-10","output":null},{"input":"23:59:60 2025-01-15T120T","output":null},{"input":"1951-03-30T16:54:33.728Z","output":-591951926272},{"input":"1997-12-21T21:29:20.384Z","output":882739760384},{"input":"2025/01/1524:00:00.001","output":null},{"input":"1983-09-06T13:16:0","output":null},{"input":"Wed Apr 23 2031 04:18:40 GMT+0000 (Coordinated Universal Time)","output":1934684320000},{"input":"00T1212:00:00.123","output":null},{"input":"24:00:00.001-0800","output":null},{"input":" ","output":null},{"input":"2025-01-15T12+275760-09-13T00:00:00.001Z2025-1-5am","output":null},{"input":"2025-00-10 15/1/20251970","output":null},{"input":"UTCzEST,2025/01/15","output":1736899200000},{"input":"1954-09-04T","output":null},{"input":"Fri, 28 Aug 1970 14:35:39 GMT","output":20702139000},{"input":"\t/AM-12:00:00.12312:00 T,","output":null},{"input":"January(+002025 garbage-T12","output":null},{"input":"\n","output":null},{"input":"T","output":null},{"input":"12:00:00.12312:00:00.123456-25:0024:00 ","output":null},{"input":"T122025-00-1012:00:00.1231 -","output":null},{"input":"\n002025-01-15,","output":1736899200000},{"input":"2025-02-29,FebJanuaryWed,T25:00","output":null},{"input":"JanuaryWednesday,2025-01-151/15/2025-00","output":null},{"input":"1992-11-11T03:36:07.424Z","output":721452967424},{"input":"2025-01-15T12UT-1970 Z12,","output":null},{"input":"Z12115/1/202525:00+2,am","output":null},{"input":"1/15/2025z12:00:00.123456","output":1736942400123},{"input":"Sat Dec 19 2015 01:34:47 GMT+0000","output":1450488887000},{"input":"UTC,January-25:00","output":null},{"input":"Feb\t-2025-00-102025-13-011/15/2025T","output":null},{"input":"+275760-09-13T00:00:00.001ZT2025-01-15","output":null},{"input":"(comment)PM:","output":null},{"input":"January :","output":null},{"input":"24:00:00.001+2","output":null},{"input":"Mon, 23 May 1994 01:17:12 GMT","output":769655832000},{"input":"2025-01-15T12zT","output":null},{"input":"1957-01-06T04:31:28.256Z","output":-409778911744},{"input":" 50PDT32-12:00:002025/01/15","output":null},{"input":"+02:00jan,(comment)UTC","output":null},{"input":"501970T50 \t","output":null},{"input":"12:00:00.123+002025","output":null},{"input":"Sat Jun 27 2020 11:17:07 GMT+0000","output":1593256627000},{"input":" 12:00:00.123456(-((,T12 ","output":null},{"input":"garbage,12:00:00.12312:00:002025-02-29","output":null},{"input":"Wednesday 23:59:60","output":-315532860000},{"input":"1935-08-14T03:41:13.856Z","output":-1085084326144},{"input":"Tue, 03 Jul 2012 10:22:11 GMT","output":1341310931000},{"input":":T(comment)T","output":null},{"input":"99GMT\t-0800Wednesday23:59:60","output":null},{"input":"UTC","output":null},{"input":"z+02:00T49Wednesday WednesdayWednesday","output":null},{"input":"Sun Oct 14 2012 16:16:12 GMT+0000","output":1350231372000},{"input":"Fri Jan 08 1993 13:43:57 GMT+0000 (Coordinated Universal Time)","output":726500637000},{"input":"2024-02-29TTPDTT","output":null},{"input":"32","output":1956528000000},{"input":"1980-08-09T","output":null},{"input":"12:00T131","output":null},{"input":"00275760-09-13 +002025Z","output":null},{"input":"Wed Jan 29 2020 12:11:34 GMT+0000","output":1580299894000},{"input":"1736942400garbagePDT2025-1-5-T","output":null},{"input":"PM","output":null},{"input":"Thu Aug 24 2034 08:43:06 GMT+0000","output":2040021786000},{"input":"2025-00-10+275760-09-13T00:00:00.001Z+275760-09-13T00:00:00.001Z","output":null},{"input":"12:00:00.123(comment)-12:00:00.123+002025 23:59:60","output":null},{"input":"24:00:00.001","output":null},{"input":"z2025-01-15T24:00:00.00112:00:00.123456,Jan","output":null},{"input":"Mon, 01 Jul 1996 05:55:58 GMT","output":836200558000},{"input":"(-1970T2025-01-15Tjan-","output":null},{"input":"275760-09-13","output":8640000000000000},{"input":"+002025","output":1735689600000},{"input":"2025-13-0124:00:00.001+002025,+0020252025-01-15T12","output":null},{"input":".12:00Jan+02:00-","output":null},{"input":"z","output":null},{"input":"31","output":null},{"input":"1975-08-20T03:","output":null},{"input":"..-:PM32-0800","output":null},{"input":"Sat, 08 Nov 1986 18:01:48 GMT","output":531856908000},{"input":"Z12- ","output":null},{"input":"-08001Feb,GMT)","output":null},{"input":"+275760-09-13T00:00:00.001ZZ12T19701TZ12","output":null},{"input":"Sat Mar 25 2028 07:46:53 GMT+0000 (Coordinated Universal Time)","output":1837583213000},{"input":"-12:00:00","output":null},{"input":"Sat Jun 03 2023 09:39:12 GMT+0000","output":1685785152000},{"input":"50 23:59:60-0800(comment),","output":null},{"input":"25:00UT,(comment),24:00:00.001","output":null},{"input":"1993-12-15T07:59:40","output":755942380000},{"input":"Sat Apr 24 2021 00:48:44 GMT+0000","output":1619225324000},{"input":"Wed Oct 08 1975 06:47:32 GMT+0000 (Coordinated Universal Time)","output":181982852000},{"input":"UTC","output":null},{"input":"1972-05-12T","output":null},{"input":"Z12","output":null},{"input":"1969-01-13T22:40:25.600Z","output":-30417574400},{"input":"+002025","output":1735689600000},{"input":"2025-00-105012:00:00.1232025-01-15T122025-01-15January","output":null},{"input":"Wed,--.","output":null},{"input":"1970","output":0},{"input":"+275760-09-13T00:00:00.001ZZ12-.","output":null},{"input":"UTC(comment)","output":null},{"input":"\t12:00:00.123","output":null},{"input":",TAMWednesday","output":null},{"input":"1736942400,24:002025-00-10","output":null},{"input":"2025-13-01\t 2025/01/15 2025-01-15TT","output":null},{"input":"2025-02-29+0020252025-01-15T12:00ZT275760-09-13T-","output":null},{"input":"2025-1-52025-13-0124:00:00.001-000001FebT","output":null},{"input":"-","output":null},{"input":"2025-01-15T12:00Z 275760-09-13 ","output":null},{"input":"2025-13-012025/01/15","output":null},{"input":"Sun Jul 17 2005 15:31:17 GMT+0000 (Coordinated Universal Time)","output":1121614277000},{"input":"24:00:00.00112:00275760-09-13,","output":null},{"input":"JanuaryEST 12:00\n","output":null},{"input":".","output":null},{"input":"AM ","output":null},{"input":"1979-08-28T11:14:","output":null},{"input":"12:00:00-+0020251/15/2025Z+002025Jan","output":null},{"input":"Sat Jun 28 2025 21:50:09 GMT+0000 (Coordinated Universal Time)","output":1751147409000},{"input":"z-3115/1/202512:00:00.123456","output":null},{"input":"49.-99+02:00Z12-24:00 ","output":null},{"input":"2025-01-15T12,-0000012025","output":null},{"input":"am-","output":null},{"input":"+02:00","output":null},{"input":"AM,2025/01/15-2025-02-29","output":null},{"input":"+02:00T","output":null},{"input":"2025-01-15T12:00Z","output":1736942400000},{"input":"UTC-2025/01/15,T,-2025-01-15","output":null},{"input":"garbage15/1/2025PDT","output":null},{"input":"Thu, 24 Jun 1976 00:23:57 GMT","output":204423837000},{"input":"Wed, 27 Sep 1978 15:17:49 GMT","output":275757469000},{"input":"+2Feb,","output":981072000000},{"input":"2025-01-15T12-2025-01-15T50","output":null},{"input":":-12:00:00.12345631","output":null},{"input":"2025-02-29jan50PDT","output":null},{"input":"am12:00","output":null},{"input":"GMTT,+275760-09-13T00:00:00ZUT12:00:00.123 +275760-09-13T00:00:00Z,","output":null},{"input":"1736942400UT2025-01-15T12:00ZEST115","output":null},{"input":"Wed May 23 2018 12:11:59 GMT+0000 (Coordinated Universal Time)","output":1527077519000},{"input":"(comment)","output":null},{"input":"1967-03-02T22:09:28.","output":null},{"input":"(","output":null},{"input":"1974-12-24T19:21:21.408Z","output":157144881408},{"input":")PDT(comment)jan2025","output":1735689600000},{"input":"January,Wed,-32EST","output":1956546000000},{"input":"T12T2025-01-15T12","output":null},{"input":"Fri Mar 08 2002 08:42:10 GMT+0000 (Coordinated Universal Time)","output":1015576930000},{"input":"GMTz24:00:00.001GMT ","output":null},{"input":"1960-03-07T21:26:52.416Z","output":-309839587584},{"input":"2024-02-29 1/15/20250- / (comment)","output":null},{"input":"2025/01/15","output":1736899200000},{"input":"1970:TT24:00,z+02:00","output":null},{"input":"Z12","output":null},{"input":"25:00UTC+02:00","output":null},{"input":"24:00:00.0011970Wed,12:0012:00(","output":null},{"input":"pm","output":null},{"input":"1/15/2025.,23:59:60-T12-24:00","output":null},{"input":"1969-03-19T04:59:28.896Z","output":-24865231104},{"input":"Wed Dec 07 1994 10:04:17 GMT+0000","output":786794657000},{"input":"+00202525:00,","output":null},{"input":"Tue Aug 18 1998 02:46:36 GMT+0000 (Coordinated Universal Time)","output":903408396000},{"input":" JanT1299-","output":-21174652800000},{"input":"UT1/15/2025 15/1/2025-","output":null},{"input":"AM00","output":null},{"input":"2025-02-29T\n","output":null},{"input":"(comment)jan32T(comment)2025-1-5 :-","output":null},{"input":"UT","output":null},{"input":"1984-02-05T06:41:52.","output":null},{"input":"z,15992025-01-15T+002025+2","output":null},{"input":"EST","output":null},{"input":")31Jan.2025-01-15T1/15/2025","output":null},{"input":"2025/01/15,12:00:00TWed, -2025-01-15T","output":null},{"input":"2025-01-15T12\t+212:00:00.123456","output":null},{"input":"Thu Oct 18 2001 01:10:23 GMT+0000","output":1003367423000},{"input":"UT","output":null},{"input":"2025-02-29TFebZ :,-000001, ","output":null},{"input":"T:","output":null},{"input":". January ","output":null},{"input":"am275760-09-13,2025-01-15T12:00ZZ12","output":null},{"input":"1987-01-04T2","output":null},{"input":"1937-01-03T03:18:27.840Z","output":-1041194492160},{"input":"Thu Nov 19 2037 06:08:06 GMT+0000 (Coordinated Universal Time)","output":2142223686000},{"input":"1961-07-30T","output":null},{"input":"2025\tWednesday-50-janT","output":null},{"input":"Feb,","output":null},{"input":"Mon, 28 Aug 1989 11:45:17 GMT","output":620307917000},{"input":"2025-01-15,50\t00","output":null},{"input":"00Z2025-01-15T12:00Z50","output":null},{"input":"Z1217369424002025-01-15T121 ","output":null},{"input":"+275760-09-13T00:00:00Z50+2 ","output":null},{"input":"Fri Jun 19 1992 18:11:28 GMT+0000","output":708977488000},{"input":"Z12\t2025-13-01,AM","output":null},{"input":",25:00:0012:00:00.123Wednesday ","output":null},{"input":"99Jan24:00","output":915235200000},{"input":"Tue Aug 07 1979 15:58:39 GMT+0000 (Coordinated Universal Time)","output":302889519000},{"input":"zZ12 2025-01-15T12:00Z24:00:00.001T -jan","output":null},{"input":"-TFebjan275760-09-13275760-09-13","output":null},{"input":"PDTUT/275760-09-1325:00PM ","output":null},{"input":"2025(-amT","output":1735689600000},{"input":"+02:00EST","output":null},{"input":"+2pmJan99\t15-","output":null},{"input":" 0050 ","output":-631152000000},{"input":"1979-02-18T14:40:11.52","output":288196811520},{"input":"1(Z","output":978307200000},{"input":"275760-09-1399T","output":null},{"input":"50T122025-00-10","output":null},{"input":"UT,25:00.","output":null},{"input":"2025/01/15ESTEST24:00:00.001","output":null},{"input":"\t-000001-00000112:00:00.123456Wed,","output":null},{"input":"2024-02-29+02:00-","output":null},{"input":"+02:00","output":null},{"input":"Tue, 04 Nov 1975 13:34:44 GMT","output":184340084000},{"input":"275760-09-13(comment)2025-02-29","output":null},{"input":"2025-1-5T,-","output":null},{"input":", 0","output":946684800000},{"input":"1944-03-15T06:42:31.552Z","output":-814123048448},{"input":"Sun Feb 04 1996 19:01:42 GMT+0000 (Coordinated Universal Time)","output":823460502000},{"input":".","output":null},{"input":"1981-04-14T08:16:47.616Z","output":356084207616},{"input":"jan-","output":null},{"input":"UTC2025-01-15-492025/01/15pm","output":null},{"input":"January2024-02-29 24:00UT","output":null},{"input":"1736942400 ","output":null},{"input":"+275760-09-13T00:00:00.001ZJanuary)312025-13-01","output":null},{"input":"Tue, 02 Apr 1974 04:46:20 GMT","output":134109980000},{"input":") 24:00:00.001WednesdayT275760-09-13JanZ12","output":null},{"input":"1952-10-18T22:25:06.816Z","output":-542856893184},{"input":"JanPDTZT12-","output":979257600000},{"input":"50 23:59:60","output":null},{"input":"24:00:00.001-1970 25:00","output":null},{"input":"UT,Z502025EST","output":null},{"input":"1962-08-06T11:25:07.712Z","output":-233670892288},{"input":"2025-01-15T12173694240012:00:00.123456,12:00:00Wed,Tpm","output":null},{"input":"Wednesday-January)","output":null},{"input":"z:2025/01/15-","output":1736899200000},{"input":"1998-06-12T21:36:04.352Z","output":897687364352},{"input":"+02:00","output":null},{"input":"T12","output":null},{"input":"2025-1-523:59:60UTC-Jan2025-13-01T-","output":null},{"input":"January","output":null},{"input":"4924:00-0800ESTT99","output":null},{"input":"1953-09-14","output":-514339200000},{"input":"Tue Feb 27 1979 01:14:52 GMT+0000 (Coordinated Universal Time)","output":288926092000},{"input":"15/1/2025UTC ,pm","output":null},{"input":"002025-01-15EST12:00:00.123-0800,","output":1736971200123},{"input":"1936-09-16T20:47:35.424Z","output":-1050549144576},{"input":"Wed May 06 2026 07:44:31 GMT+0000 (Coordinated Universal Time)","output":1778053471000},{"input":"GMTJanuary-15/1/2025","output":null},{"input":"1736942400,Z49T+02:00,2025-01-15Wednesday","output":null},{"input":"+0020251970:-UT-0800","output":null},{"input":"2025-13-0100T2025-13-0112:00:00.123AM","output":null},{"input":"1977-11-17T01:2","output":null},{"input":"00Jan2025-02-29-0800PDT","output":null},{"input":"(comment)Z","output":null},{"input":",UTC-00","output":946684800000},{"input":" ,","output":null},{"input":"2024-02-29 EST12:00:002025-13-01 ","output":null},{"input":"2025/01/1525:00z4912:00:00.12345612:00:00.123456","output":null},{"input":"jan50,","output":-631152000000},{"input":"Sat, 17 Dec 2005 14:46:23 GMT","output":1134830783000},{"input":"GMT,","output":null},{"input":"1987-10-06T11:17:12.320Z","output":560517432320},{"input":".z","output":null},{"input":"1970","output":0},{"input":"Z12 -2025-02-29","output":null},{"input":"2025-02-2915/1/2025(comment),","output":null},{"input":"2025-00-102025-01-15T12:00ZZ","output":null},{"input":"2025-01-15T12 ","output":null},{"input":"-+275760-09-13T00:00:00.001Z 1- pm2025-01-15T,","output":null},{"input":"2025-1-52025-00-10-","output":null},{"input":"\n/","output":null},{"input":"+275760-09-13T00:00:00.001Z 1/15/2025amWed,1736942400","output":null},{"input":"1982-05-07T11:40:38.272Z","output":389619638272},{"input":"Wed, 09 Oct 2030 23:18:52 GMT","output":1917818332000},{"input":"\t WednesdayFeb,2025-01-15T12)","output":null},{"input":"Tue, 19 Oct 1999 19:52:43 GMT","output":940362763000},{"input":"Mon, 08 Mar 1982 14:44:44 GMT","output":384446684000},{"input":"19","output":null},{"input":"15/1/202524:00:00.001T2025-01-15T12:00ZT1/","output":null},{"input":"Wed May 14 1986 23:51:32 GMT+0000 (Coordinated Universal Time)","output":516498692000},{"input":"Sat Aug 17 2013 08:36:12 GMT+0000 (Coordinated Universal Time)","output":1376728572000},{"input":"2025-02-29,JanFeb","output":1735776000000},{"input":"\n","output":null},{"input":"12:00PM+02:00am","output":null},{"input":"1943-03-08T18:03:56.","output":null},{"input":"Fri Jun 26 2020 17:42:14 GMT+0000 (Coordinated Universal Time)","output":1593193334000},{"input":"2025-01-15152025-02-29 2025Feb31","output":null},{"input":"z23:59:60","output":null},{"input":"-","output":null},{"input":"2025/01/15z","output":1736899200000},{"input":"50","output":-631152000000},{"input":"Fri Oct 09 1970 22:51:38 GMT+0000","output":24360698000},{"input":"+275760-09-13T00:00:00Z1/15/2025,2024-02-29garbage-2025/01/15","output":null},{"input":"+2+275760-09-13T00:00:00.001Z ESTJanuaryam","output":null},{"input":"/,Wed,","output":null},{"input":"Mon Jul 03 1989 13:56:12 GMT+0000","output":615477372000},{"input":"275760-09-13-Wednesday","output":null},{"input":"Feb+275760-09-13T00:00:00ZJanuaryGMT ","output":null},{"input":"-202524:00","output":null},{"input":"UTC12:0024:00garbage","output":null},{"input":"Mon Apr 16 2012 23:57:06 GMT+0000 (Coordinated Universal Time)","output":1334620626000},{"input":"-\n1736942400 2025-02-29 GMT","output":null},{"input":"Thu, 03 May 1973 11:32:14 GMT","output":105276734000},{"input":"T12 151/15/20252024-02-29,","output":null},{"input":"2025-1-5)garbagePM,2025-01-15T","output":null},{"input":"amT2025-13-01Z25:00","output":null},{"input":"2025-01-15T","output":null},{"input":")99,T1224:00janJanuaryT","output":null},{"input":"1970-12-2","output":28944000000},{"input":"PDT\n ","output":null},{"input":"pm2025-01-15T4949Januaryz-","output":null},{"input":"-","output":null},{"input":")0","output":946684800000},{"input":"garbage2025-02-29garbage-2024-02-2915/1/2025","output":null},{"input":"+2","output":980985600000},{"input":"+002025Feb--49+275760-09-13T00:00:00.001Z","output":null},{"input":"AM 2025-01-15T12:00Z-","output":null},{"input":"2025-01-15T1250Tgarbage31-1/15/2025-1/15/2025","output":null},{"input":"25:00\n","output":null},{"input":"Mon May 21 2035 10:11:18 GMT+0000 (Coordinated Universal Time)","output":2063355078000},{"input":"January15T","output":null},{"input":"Mon, 23 May 1994 05:16:49 GMT","output":769670209000},{"input":"-","output":null},{"input":"1962-11-08T07:41:36.128Z","output":-225562703872},{"input":"Wed, 28 Sep 2016 11:23:05 GMT","output":1475061785000},{"input":"garbage2025/01/15,1970","output":null},{"input":"+275760-09-13T00:00:00Zgarbage Wednesday+2T-275760-09-13","output":null},{"input":"UT99","output":null},{"input":"Sun Aug 22 1982 20:23:00 GMT+0000","output":398895780000},{"input":"12:00/","output":null},{"input":"EST","output":null},{"input":"Sun Dec 03 1989 22:02:20 GMT+0000","output":628725740000},{"input":"+21736942400garbage","output":null},{"input":"am24:002025-01-15T12","output":null},{"input":")","output":null},{"input":"pm\n(","output":null},{"input":"2025-1-5am2025-01-15T123215/1/2025","output":null},{"input":"1990-01-29T03","output":null},{"input":"-0800Wednesday ","output":null},{"input":"T122025 .TT12 Z","output":null},{"input":"23:59:60","output":-315532860000},{"input":")+002025T2025-01-15T12,+00202512:0099-","output":null},{"input":"12:00:00.12324:00:00.00125:00Wed,T12-","output":null},{"input":"Wed, 15 Dec 2021 15:00:10 GMT","output":1639580410000},{"input":"2025-01-15T12z","output":null},{"input":"Z12T+275760-09-13T00:00:00.001Z","output":null},{"input":"50AM","output":null},{"input":"1984-09-11T21:27:07.520Z","output":463786027520},{"input":"202500,EST-2025/01/15T12-24:00:00.001","output":null},{"input":"Wednesday,EST","output":null},{"input":"PDT,+002025","output":1735689600000},{"input":"2025-01-15T12garbageGMT","output":null},{"input":"32,49T-","output":null},{"input":"Tue Sep 12 2028 22:12:36 GMT+0000 (Coordinated Universal Time)","output":1852409556000},{"input":"Fri Jul 16 1999 22:46:24 GMT+0000","output":932165184000},{"input":"1985-","output":473385600000},{"input":"19","output":null},{"input":" 275760-09-13+275760-09-13T00:00:00.001Z1736942400PDTam ","output":null},{"input":"+02:00PM,,(comment)","output":null},{"input":"1965-04-05T23:34:56.000Z","output":-149559904000},{"input":"2025-01-15 //Z12","output":null},{"input":"1736942400,.Jan24:00:00.0012025-01-15T12","output":null},{"input":"Wed May 09 2007 04:33:36 GMT+0000","output":1178685216000},{"input":"24:00 2025-01-15TTam15/1/2025","output":null},{"input":"Z122025-00-10T","output":null},{"input":"50 24:00-","output":null},{"input":" PDT\n\t)2025-13-01 ","output":null},{"input":"1986-04-17T23:44:02","output":514165442000},{"input":"-000001,:2025-00-10","output":null},{"input":"1967-03-09T05:54:11.840Z","output":-88884348160},{"input":":January12:00:00.123456-000001UTC+2","output":null},{"input":"T+2Jan\n","output":978393600000},{"input":"PM49Z12,-2025-01-15T32","output":null},{"input":"1736942400,015","output":null},{"input":"Wed Jan 03 1996 13:05:06 GMT+0000 (Coordinated Universal Time)","output":820674306000},{"input":",garbage","output":null},{"input":"12:00:00.12345632TPDTgarbage","output":null},{"input":"24:00T3123:59:60amz","output":null},{"input":"Thu, 12 Mar 2037 18:16:54 GMT","output":2120494614000},{"input":"1971-08-0","output":null},{"input":"2025-01-15T12-1736942400 24:00 32","output":null},{"input":"15,PM275760-09-1312:00:00.123456","output":null},{"input":"2025 Z,z","output":1735689600000},{"input":"(comment),am+275760-09-13T00:00:00.001Z ","output":null},{"input":"Fri Oct 02 2015 21:59:01 GMT+0000 (Coordinated Universal Time)","output":1443823141000},{"input":"12:00:0015/1/2025EST32UTC/","output":null},{"input":"2025/01/15 Wed,15- 00","output":null},{"input":"z+275760-09-13T00:00:00.001Z","output":null},{"input":"2025/01/15-080012:00:00.123/(comment) ","output":null},{"input":"1+275760-09-13T00:00:00Z January2025-13-01 T","output":null},{"input":"ESTAM ","output":null},{"input":"T121/15/2025","output":null},{"input":"2025-01-15T12:00Z24:00/,+275760-09-13T00:00:00.001Z","output":null},{"input":"Fri May 07 1993 12:08:49 GMT+0000 (Coordinated Universal Time)","output":736776529000},{"input":" -2025-01-15T12:00Z,15/1/2025\tT275760-09-13T","output":null},{"input":"\t","output":null},{"input":"Mon, 09 Aug 2004 17:39:20 GMT","output":1092073160000},{"input":"12:00:00.123456-WednesdayZ12,PM","output":null},{"input":"GMT ","output":null},{"input":"2025-00-10T","output":null},{"input":"2025/01/1500+02:00UT","output":null},{"input":"15/1/2025-:Z12 24:00:00.001T12","output":null},{"input":"Feb12:00:002025-02-29","output":1738515602000},{"input":"-0000012025-01-15T0.","output":null},{"input":".2025-02-29 +02:00+02:00-jan","output":null},{"input":"(comment)+02:00T12:00T12AM","output":null},{"input":"WednesdayWed,,12:00:00","output":null},{"input":"+21","output":null},{"input":"11970zUTC24:00:00.001Feb","output":null},{"input":"1970Wednesday0UT)+275760-09-13T00:00:00Z-","output":null},{"input":"2025-1-5 .-000001","output":null},{"input":"UT12:00:00,Wed,","output":null},{"input":"1 T,","output":null},{"input":"24:00:00.0011736942400","output":null},{"input":"492025-01-15T122025-02-291","output":null},{"input":"PDTT2025-01-15T12PM","output":null},{"input":"Wednesday","output":null},{"input":"00,1736942400Wed,12:00 Wednesday","output":null},{"input":"Sat Mar 16 2013 14:34:52 GMT+0000","output":1363444492000},{"input":"12:00:00.12345624:00:00.001 2025-1-50275760-09-13T1736942400","output":null},{"input":"Fri Apr 24 1970 01:12:15 GMT+0000 (Coordinated Universal Time)","output":9767535000},{"input":":12:0015\n12:00 GMT","output":null},{"input":"25:0012:00:003215-02025-01-15T12:00Z","output":null},{"input":"\n 2025-01-1524:00:00.001AMTgarbageT","output":null},{"input":"Fri, 15 Feb 2036 13:44:25 GMT","output":2086695865000},{"input":"z-992025-01-15T 1/15/2025","output":null},{"input":"12:00:00.12345615/1/2025","output":null},{"input":"+2/pm am24:002025-01-15","output":null},{"input":"2025-01-15T49 ","output":null},{"input":"Jan","output":null},{"input":"1936-01-31T00:37:44.576Z","output":-1070407335424},{"input":"Thu, 30 Sep 2021 02:35:40 GMT","output":1632969340000},{"input":"2024-02-29+2","output":null},{"input":"1957-09-20T21:29:17.312Z","output":-387513042688},{"input":"1975-10-20T16","output":null},{"input":"Fri May 10 1991 08:01:22 GMT+0000 (Coordinated Universal Time)","output":673862482000},{"input":"PDTT199","output":null},{"input":"Wed Apr 02 1980 02:15:05 GMT+0000","output":323489705000},{"input":"Thu Mar 27 2031 10:17:06 GMT+0000","output":1932373026000},{"input":"1957-12-04T05:39:43.488Z","output":-381090016512},{"input":"Jan-2025/01/15 17369424002025-01-15T12:00Z-","output":null},{"input":"2025/01/15 Jan","output":1735689600000},{"input":"1970.1 ","output":0},{"input":"ESTPMT\ngarbage2025-02-29","output":null},{"input":",","output":null},{"input":"\n-AM,","output":null},{"input":"UTCT12024-02-292025-01-15T12","output":null},{"input":"z32Wednesday Z12","output":null},{"input":"Wed,3225:002025-02-29","output":null},{"input":"AM20250","output":null},{"input":"31","output":null},{"input":"Jan","output":null},{"input":"1963-10-16T02:27:38.880Z","output":-196032741120},{"input":"20","output":null},{"input":" 1736942400,)+002025-January","output":null},{"input":"173694240024:001/15/2025","output":null},{"input":"(comment)pm+02:00","output":null},{"input":"2025-01-15T12UT-Z.PDTT","output":null},{"input":"Thu May 10 2007 04:11:27 GMT+0000 (Coordinated Universal Time)","output":1178770287000},{"input":"2025-01-15T12TJanuary","output":null},{"input":"12:00:00,99275760-09-13","output":null},{"input":"1999-0","output":null},{"input":"JanuaryT2024-02-29,","output":1704153600000},{"input":"Wednesday","output":null},{"input":"2025--15/1/202515/1/2025+275760-09-13T00:00:00.001Z12:00:00.123","output":null},{"input":"50","output":-631152000000},{"input":"z2025-02-292025-01-15T12:00ZWednesdayWednesday","output":null},{"input":"UTC12:00:00.1231/15/20251736942400","output":null},{"input":"ESTJan,+002025TJan","output":null},{"input":"2025/01/15","output":1736899200000},{"input":"janT24:00:00.001(2025-00-10)T2025-1-5","output":null},{"input":"PMjan,--24:00:00.001PM+002025,","output":null},{"input":"\t502025-01-15z","output":null},{"input":".00","output":946684800000},{"input":"-0800 2025-00-10z-15/1/2025","output":null},{"input":"Wed,+002025,/T12","output":null},{"input":"z-,EST2025Z12","output":null},{"input":"Wed,","output":null},{"input":"Wed,2025/01/15UT1736942400","output":null},{"input":"2025-00-10,1-)0","output":null},{"input":"+275760-09-13T00:00:00Z,2025-1-5","output":null},{"input":"2025-01-15T+2-","output":null},{"input":"2025-02-29T50(comment)PDT,GMT","output":null},{"input":"1998-06-23T03:01:15.904Z","output":898570875904},{"input":"+002025Jan.2025/01/15","output":null},{"input":"Z-","output":null},{"input":"Mon Sep 06 2027 09:48:02 GMT+0000 (Coordinated Universal Time)","output":1820224082000},{"input":"Tue Oct 06 1970 00:51:27 GMT+0000 (Coordinated Universal Time)","output":24022287000},{"input":"1944-10-07T1","output":null},{"input":"00","output":946684800000},{"input":"Sat Dec 01 1984 15:02:35 GMT+0000","output":470761355000},{"input":")","output":null},{"input":"1977-01-18T08:20:11.136Z","output":222423611136},{"input":"garbage jan-UT275760-09-13+275760-09-13T00:00:00Z","output":null},{"input":"","output":null},{"input":". 12:0012:00","output":null},{"input":"pm99","output":null},{"input":"1","output":978307200000},{"input":"1736942400+002025-49","output":null},{"input":"2024-02-29UT+21736942400:T","output":null},{"input":"1955-","output":-473385600000},{"input":"am","output":null},{"input":"1970,+002025 ","output":null},{"input":"\t-Wednesday-- (comment)1Feb","output":980985600000},{"input":"1985-02-24T06:28:42.368Z","output":478074522368},{"input":",T2024-02-29GMT2025-01-15,24:00:00.0011","output":null},{"input":"-T12","output":null},{"input":"99T202512:00:00.12345612:00:00.123456","output":null},{"input":"UT UT.EST ","output":null},{"input":"PDTgarbage25:00","output":null},{"input":"+002025","output":1735689600000},{"input":"1957-12-03T14:56:16.384Z","output":-381143023616},{"input":"AM,2025-01-15T12:00Z2025-00-1015/1/2025","output":null},{"input":"(comment)-0800GMT","output":-36921657600000},{"input":"Fri Sep 03 2004 11:37:45 GMT+0000","output":1094211465000},{"input":"GMTGMT+02:002025-Jan","output":1735696800000},{"input":"- January","output":null},{"input":"EST12:001736942400","output":null},{"input":"2025-01-15Wed,T ,2025-13-01","output":null},{"input":"Wed, 27 Apr 1977 23:11:36 GMT","output":231030696000},{"input":"1951-08-26","output":-579139200000},{"input":"Sat, 11 Feb 2023 20:38:03 GMT","output":1676147883000},{"input":"2025-01-15T garbage/T","output":null},{"input":"garbage+002025","output":1735689600000},{"input":"Z12jan,","output":null},{"input":"23:59:60UT,:T12+002025","output":null},{"input":"2025-1-5,T1249","output":null},{"input":"2025-1-515/1/2025T24:00:00.0012024-02-29+275760-09-13T00:00:00.001Z2025-01-15T-","output":null},{"input":"2025-1-5-000001( 2025/01/152025-13-01 31","output":null},{"input":"UT,jan","output":null},{"input":"12:00:00.123456jan","output":null},{"input":"31-","output":null},{"input":"1941-01-01T05:21:16.544Z","output":-915129523456},{"input":"12:0000-1970","output":null},{"input":"-0800-GMT . 25:00Z12","output":null},{"input":"00- .T","output":null},{"input":"EST11970-UTC","output":null},{"input":"1956-05-09T05:55:41.18","output":-430682658820},{"input":"Fri Jul 31 1970 13:39:15 GMT+0000 (Coordinated Universal Time)","output":18279555000},{"input":"1999-","output":915148800000},{"input":"T-January,jan","output":null},{"input":"am-UTC","output":null},{"input":"Wed Sep 25 2030 08:54:59 GMT+0000","output":1916556899000},{"input":"Tue, 01 Mar 2016 07:23:07 GMT","output":1456816987000},{"input":"1","output":978307200000},{"input":"49","output":2493072000000},{"input":"1951-05-","output":-589248000000},{"input":"00202515/1/2025am","output":null},{"input":"\n","output":null},{"input":"1970","output":0},{"input":"PMWed,JanuaryT12:00:00.123456 -","output":null},{"input":"UTC(-25:00-0800,2025-01-152025/01/15","output":null},{"input":"2025-00-10 ","output":null},{"input":"Z12","output":null},{"input":"312024-02-29 -49-\n 2025-01-15T12:00Z","output":null},{"input":"49","output":2493072000000},{"input":"am31T","output":null},{"input":"Wed,2025-1-52024-02-29","output":null},{"input":"99 UT1/15/202549","output":null},{"input":"(comment).2024-02-29","output":1709164800000},{"input":"492025-00-10-1,--0800","output":null},{"input":"312025-01-15T12garbageT1736942400","output":null},{"input":"jan +002025","output":1735689600000},{"input":"1992-","output":694224000000},{"input":",.","output":null},{"input":"-/2025-02-29T","output":null},{"input":"Z12-","output":null},{"input":"AM2025/01/15","output":null},{"input":"pmGMTgarbage","output":null},{"input":"Z12Wed,-2025-00-10,2025/01/15-","output":null},{"input":"2025-02-2924:0012:00:00 2025-02-29 -","output":null},{"input":" PMGMT\t2025","output":1735689600000},{"input":"12:00T1224:00PDT24:00:00.001Z","output":null},{"input":"+002025","output":1735689600000},{"input":"24:00,25:002025-13-01+275760-09-13T00:00:00Z","output":null},{"input":"1992-04-29","output":704505600000},{"input":"+2","output":980985600000},{"input":"1970","output":0},{"input":"00,T15","output":null},{"input":"1975-10-24T01:10:00.960Z","output":183345000960},{"input":"1991-01-10T16:01:10.656Z","output":663523270656},{"input":"2025-01-15T12:00Z+02:002024-02-292025-13-01","output":null},{"input":"),","output":null},{"input":"Z12-WednesdayJanuary,","output":null},{"input":"00/-","output":null},{"input":"2025-00-1049,99,12:00:00.123T+00202550T","output":null},{"input":"Sun, 29 Sep 1996 04:43:05 GMT","output":843972185000},{"input":"jan32T00PM1970January","output":null},{"input":"./-1736942400-0800012:00:00.123456-","output":null},{"input":"Mon, 16 Sep 1996 23:31:53 GMT","output":842916713000},{"input":"Fri Mar 09 1973 02:46:58 GMT+0000 (Coordinated Universal Time)","output":100493218000},{"input":"15/1/2025z","output":null},{"input":"12:00:003132.-25:00","output":36669153625000},{"input":"20252025-1-5pm ","output":null},{"input":"2025-00-10 -\t- 99","output":null},{"input":"2024-02-29 UTC\t","output":1709164800000},{"input":"Tue Jul 10 2018 09:15:42 GMT+0000","output":1531214142000},{"input":")am","output":null},{"input":"31Z 2025-01-152025-13-01T24:00","output":null},{"input":"1947-06-20T16:56:57.600Z","output":-711097382400},{"input":" Tam12:00:00 24:0024:00:00.001T2025-01-15T","output":null},{"input":"1937-05-16","output":-1029715200000},{"input":"Sat, 14 Jan 2012 05:02:23 GMT","output":1326517343000},{"input":"1945-","output":-788918400000},{"input":"/1970","output":0},{"input":"4915jan","output":92935209600000},{"input":"Mon Feb 25 1974 12:55:22 GMT+0000 (Coordinated Universal Time)","output":131028922000},{"input":"1/15/2025","output":1736899200000},{"input":"/12:00:00.1232025/01/15-000001TEST","output":null},{"input":"GMT+275760-09-13T00:00:00Z ","output":null},{"input":"(T)T","output":null},{"input":"zJanuary-\n: PM","output":null},{"input":"15-GMTT2025-01-15T12:00ZT15 15","output":null},{"input":"1995-09-04T22:48:52.224Z","output":810254932224},{"input":"49Wednesday2025-01-15T12:00Z","output":null},{"input":"12:00275760-09-13-Wed,T","output":null},{"input":"Tue Feb 25 1992 20:44:29 GMT+0000 (Coordinated Universal Time)","output":699050669000},{"input":"Fri, 28 Jan 1972 06:45:36 GMT","output":65429136000},{"input":"+02:00","output":null},{"input":"Wed,23:59:60T49.","output":null},{"input":"T","output":null},{"input":"1963-12-14T","output":null},{"input":"Sat May 16 1981 09:54:08 GMT+0000 (Coordinated Universal Time)","output":358854848000},{"input":"Mon Sep 13 1976 19:21:56 GMT+0000 (Coordinated Universal Time)","output":211490516000},{"input":"2025-01-15T12am\t12:00:00.123--0800)","output":null},{"input":"1Wed,2025-02-29 2025-01-152025/01/15T","output":null},{"input":"0-1/15/2025322025-02-29\n1/15/2025","output":null},{"input":"32TJanuary-2025-01-15T12:00Z","output":null},{"input":"Mon, 06 Jul 2015 13:00:08 GMT","output":1436187608000},{"input":"Z","output":null},{"input":"1957-05","output":-399859200000},{"input":" (comment)z2025","output":null},{"input":"Tue, 15 Sep 2037 21:57:45 GMT","output":2136664665000},{"input":"Thu Aug 25 1977 10:33:00 GMT+0000","output":241353180000},{"input":"-197002024-02-29 -000001","output":null},{"input":"1946-11-22T03:40:03.200Z","output":-729289196800},{"input":"1998-06-20T1","output":null},{"input":"2025-02-29Z122025-1-524:00:00.001jan2025-00-10","output":null},{"input":"Tue Dec 22 2009 01:13:39 GMT+0000","output":1261444419000},{"input":"janWed,(comment)12:00:00.123,","output":null},{"input":"2025/01/1531","output":null},{"input":"2024-02-2949+002025T+2","output":null},{"input":" 23:59:60Wednesday- Wednesday-","output":null},{"input":"1/15/2025T31 Jan/","output":null},{"input":"12:00:00zPDT012:001736942400,","output":null},{"input":"99-2025-01-15T12","output":null},{"input":"Thu Nov 04 2010 03:06:02 GMT+0000","output":1288839962000},{"input":"2025-13-0124:00275760-09-1399am","output":null},{"input":"Thu Jan 28 2038 01:25:49 GMT+0000","output":2148254749000},{"input":"15-","output":null},{"input":"1970-","output":0},{"input":"+275760-09-13T00:00:00.001ZT12:00:00.123-2025-PDT","output":null},{"input":"00502025-1-5","output":null},{"input":"Feb1/15/2025 2025AM-UT","output":null},{"input":"12:00:00","output":null},{"input":"Z12jan50GMT","output":null},{"input":".-2025-13-0199","output":null},{"input":"\tT","output":null},{"input":"002025-00-10,2025-1-5-4924:00:00.001","output":null},{"input":"1+02:00:2025/01/151970AM","output":null},{"input":"Tue Oct 16 2018 00:42:05 GMT+0000 (Coordinated Universal Time)","output":1539650525000},{"input":"","output":null},{"input":"jan2025-01-15T12:00Z 2025-01-15","output":null},{"input":"Mon Dec 25 1978 01:16:32 GMT+0000 (Coordinated Universal Time)","output":283396592000},{"input":"Sat Apr 14 2029 15:40:16 GMT+0000 (Coordinated Universal Time)","output":1870875616000},{"input":"12:00:0000+002025","output":null},{"input":"-0800 2025-01-1512:00:00","output":null},{"input":"zFebam1970","output":null},{"input":"1952-04-17T00:25:51.872Z","output":-558833648128},{"input":"+275760-09-13T00:00:00Z ","output":null},{"input":"1977-05-22T01:08:13.952Z","output":233111293952},{"input":":2025-01-15T12:00Z-","output":null},{"input":"2025-01-15","output":1736899200000},{"input":"Wed,)275760-09-131970","output":null},{"input":"pm","output":null},{"input":", ","output":null},{"input":"2003-0","output":null},{"input":"198","output":-55918857600000},{"input":"PDT 2025-01-15,(31-","output":1736899200000},{"input":"24:00:00.001-,PDT","output":null},{"input":"2024-02-29-","output":null},{"input":"-0800","output":-36921657600000},{"input":"EST24:00Z122025-00-10","output":null},{"input":"Fri Jan 14 2022 00:46:43 GMT+0000 (Coordinated Universal Time)","output":1642121203000},{"input":"+275760-09-13T00:00:00Z","output":8640000000000000},{"input":"2025-02-2900T12PDT2025/01/15T","output":null},{"input":"-000001z","output":-62198755200000},{"input":"pm1736942400-12:00:002024-02-2912:00 UT","output":null},{"input":"Wed Oct 22 1986 11:23:07 GMT+0000","output":530364187000},{"input":"1972-05-11T17:17:56.352Z","output":74452676352},{"input":"1991-01-07T01:58:14","output":663213494000},{"input":"Tue, 05 May 1998 15:34:10 GMT","output":894382450000},{"input":"Tue, 09 Aug 1988 06:19:10 GMT","output":587110750000},{"input":"Z12","output":null},{"input":"Tue Apr 10 1973 00:32:52 GMT+0000 (Coordinated Universal Time)","output":103249972000},{"input":"UTamPDT\t","output":null},{"input":"1942-11-19T17:47","output":-855727980000},{"input":"2025-13-01","output":null},{"input":"0-31WednesdayUTCWednesdaygarbage","output":null},{"input":"-jan2025-01-15T12:00ZGMT","output":null},{"input":"1988-06-22T10:12:17.536Z","output":582977537536},{"input":"2025-01-15T12:00Z.2025/01/15ESTPDT31 ","output":null},{"input":"99-","output":915148800000},{"input":"2025-00-10T","output":null},{"input":"Sat, 08 Aug 2009 15:14:55 GMT","output":1249744495000},{"input":"12:00:00.12312:00:00.123)-000001,24:00:00.001/","output":null},{"input":"2025-02-29T2025-02-29","output":null},{"input":"GMT 1/15/2025","output":1736899200000},{"input":"1","output":978307200000},{"input":"15/1/202512:00:00.123456T)12:00 UT,","output":null},{"input":"25:002025/01/15275760-09-1324:00:00.0012025-01-15T12","output":null},{"input":"/","output":null},{"input":"Sun May 25 2025 22:40:17 GMT+0000 (Coordinated Universal Time)","output":1748212817000},{"input":"2025-01-15T12:00Z24:00:00.001","output":null},{"input":"2025/01/15-15/1/2025 -000001, 1970,12:00:00T","output":null},{"input":"Feb15/1/2025/,\nUTC","output":982195200000},{"input":"1992-11-06T04:32:03.584Z","output":721024323584},{"input":"2025-01-15T12:00Z 01736942400-Feb,275760-09-13 ","output":null},{"input":"31322025-02-292025-1-5(","output":null},{"input":"24:00T","output":null},{"input":"1948-07-25T07:15:58.848Z","output":-676485841152},{"input":"Thu, 21 Mar 1985 05:44:43 GMT","output":480231883000},{"input":"24:00Z122024-02-29-+275760-09-13T00:00:00.001Z-000001 ","output":null},{"input":"-24:00","output":null},{"input":"AM-080012:00","output":null},{"input":"jan","output":null},{"input":"\t","output":null},{"input":"Wed Oct 16 2013 11:43:14 GMT+0000 (Coordinated Universal Time)","output":1381923794000},{"input":"Fri, 17 Apr 2009 17:46:11 GMT","output":1239990371000},{"input":"+00202532Jan,ZPM 23:59:60 ","output":null},{"input":"+275760-09-13T00:00:00.001ZgarbageT\n-am","output":null},{"input":"31-):am","output":null},{"input":"garbageUT\t","output":null},{"input":"2025/01/1599","output":null},{"input":"2025-01-15T15-,","output":null},{"input":"+2 -0800UT275760-09-13January","output":null},{"input":"31 ","output":null},{"input":"pmTJan\n 1970 ","output":0},{"input":"+275760-09-13T00:00:00ZT","output":null},{"input":"-000001 z+275760-09-13T00:00:00.001Z-0800--PMT","output":null},{"input":"12:00:00AMjan2025-02-29","output":null},{"input":" (comment),17369424002025-01-15T,\nWed,","output":null},{"input":"24:00:00.001UTCJan2024-02-29","output":null},{"input":"\t\nEST)","output":null},{"input":"23:59:603225:002024-02-29","output":null},{"input":"Tue Jun 16 1970 22:43:08 GMT+0000 (Coordinated Universal Time)","output":14424188000},{"input":"2025-1-5(2025-00-10","output":1736035200000},{"input":"1736942400,2025- -AM \n","output":null},{"input":"Tz+2GMT-1736942400","output":null},{"input":"15/1/2025)15/1/2025,","output":null},{"input":"12:00:00.123456-Z1299T2025-00-10","output":null},{"input":"WednesdayJan9912024-02-2900","output":null},{"input":"ZTJanuaryFeb2025-01-15.,EST","output":null},{"input":"Sun, 21 Apr 2013 15:08:41 GMT","output":1366556921000},{"input":"jan-4900T(comment)25:00-","output":null},{"input":"31+275760-09-13T00:00:00Z:+02:00garbage-2025-1-5","output":null},{"input":"2024-02-2999 /,31T","output":null},{"input":"Sat Dec 25 1976 08:49:04 GMT+0000","output":220351744000},{"input":"12:00:00.123456,,12:002025-01-15T12 +02:00,","output":null},{"input":"000:","output":null},{"input":"garbage0PM00,-1736942400","output":null},{"input":"2000-11-09T2","output":null},{"input":"T12T1970T","output":null},{"input":"00+02:00","output":null},{"input":"jan12:00)TT","output":null},{"input":"am-12:00:00.12345612:00:00.12315/1/20251","output":null},{"input":"1997","output":852076800000},{"input":"/--000001","output":978307200000},{"input":"2025-02-29,2025-13-01","output":null},{"input":"1944-05-28","output":-807753600000},{"input":"\t+02:0024:00:00.001jan2025/01/15","output":1735698240000},{"input":"Sun Jul 06 1975 09:53:46 GMT+0000","output":173872426000},{"input":"T1970ESTT275760-09-13","output":null},{"input":"Sun Jan 06 2030 01:54:16 GMT+0000 (Coordinated Universal Time)","output":1893894856000},{"input":"275760-09-1332,ESTT z","output":null},{"input":"0015/1/202524:00,2025-01-15","output":null},{"input":"Tue Nov 09 2032 05:12:35 GMT+0000","output":1983589955000},{"input":"173694240050,Z99","output":null},{"input":"UTT24:00:00amz","output":null},{"input":"+2","output":980985600000},{"input":"+2am","output":null},{"input":"Z12","output":null},{"input":"12:00:00.12345632,2025-00-102025-01-15T12","output":null},{"input":"00.(comment),","output":946684800000},{"input":"1970T12,2025-01-15PM,","output":null},{"input":"-000001+02:00 ","output":null},{"input":"275760-09-13275760-09-13JanuaryPDT-","output":null},{"input":"(comment)Wed,2025-01-152025-00-10 T12 ","output":null},{"input":"1970 2025-01-15T2025-13-01,12:00:00.123","output":null},{"input":"T12-2025-01-15T","output":null},{"input":"1962-05-14T22:54:37.568Z","output":-240887122432},{"input":".2024-02-29-0800-0000012025-01-15T12:00Z2025-01-15","output":null},{"input":"2025-02-29T","output":null},{"input":"2025/01/15(comment),","output":1736899200000},{"input":"1970","output":0},{"input":"-00000132+275760-09-13T00:00:00Z)am","output":null},{"input":"1937-10-01T00:05:43.040Z","output":-1017791656960},{"input":"AM(comment)2025-1-5-January,JanuaryT31","output":null},{"input":"-","output":null},{"input":"2025/01/15-275760-09-13(1736942400","output":null},{"input":"2025PM-(WednesdayZ2025","output":null},{"input":"2025-01-15T12pmT12","output":null},{"input":"1989-09-19T15:54:25.152","output":622223665152},{"input":"1936-02-21T16:53:52.768Z","output":-1068534367232},{"input":"31Feb-2025-13-01+225:00","output":null},{"input":"Mon, 05 Jul 2004 06:39:31 GMT","output":1089009571000},{"input":"jan","output":null},{"input":"Thu, 27 Jul 2028 13:52:58 GMT","output":1848318778000},{"input":"Jan/UTCgarbageTWednesdayFebT","output":null},{"input":"12:00:00","output":null},{"input":"1943-10-26T16:09:05.792Z","output":-826271454208},{"input":"AM2025-01-15T12:00Z+275760-09-13T00:00:00.001ZT","output":null},{"input":"EST","output":null},{"input":"+275760-09-13T00:00:00Z","output":8640000000000000},{"input":"Wednesday2025-01-15T12/","output":null},{"input":"T","output":null},{"input":"+02:00\tTam3299","output":null},{"input":"jan23:59:60-","output":-315532860000},{"input":"T12-2025/01/15Feb2024-02-29","output":null},{"input":") 2024-02-29T122024-02-29275760-09-13","output":null},{"input":"UT, ","output":null},{"input":"1937-05-16T03:31:59.872Z","output":-1029702480128},{"input":"1947-06-15T19:54:40.","output":null},{"input":"PDT ,","output":null},{"input":" /T2025-01-15T","output":null},{"input":"am-000001 January","output":978307200000},{"input":"PM","output":null},{"input":"z-0800","output":-36921657600000},{"input":".T275760-09-13(,GMT","output":null},{"input":"1959-07-28T06:01:07.584Z","output":-329162332416},{"input":"Mon Feb 01 2021 21:16:05 GMT+0000 (Coordinated Universal Time)","output":1612214165000},{"input":"\t99,","output":915148800000},{"input":" ","output":null},{"input":"+2\n12:00 ,JanuaryT","output":978436800000},{"input":"2025-01-15T12:00Z2025-01-15Z","output":null},{"input":" 2025/01/15am","output":null},{"input":".: +275760-09-13T00:00:00ZGMT","output":null},{"input":"2025-13-01Wed,+275760-09-13T00:00:00Z-","output":null},{"input":"1972-12-07T02:43:50.656Z","output":92544230656},{"input":"24:00T12","output":null},{"input":"1973-07-22T13:35:22.112Z","output":112196122112},{"input":"1952-09-15T04:38:25.536Z","output":-545772094464},{"input":"+275760-09-13T00:00:00.001ZT,Januaryam0025:00","output":null},{"input":"12:00:00.123456January","output":null},{"input":"2025-01-151970January,","output":1735689600000},{"input":"2025-01-15T:","output":null},{"input":"/+275760-09-13T00:00:00.001Z","output":null},{"input":"+275760-09-13T00:00:00.001Z1/15/20251UT- ","output":null},{"input":"-000001","output":-62198755200000},{"input":"JanT12 EST50-31","output":-630183600000},{"input":"502024-02-292025-00-10(comment)PM","output":null},{"input":"1942","output":-883612800000},{"input":":,2025-00-10zFeb2025-01-15T12:00Z+002025","output":null},{"input":"+2,PDT ","output":981010800000},{"input":"25:00Feb -000001","output":null},{"input":"GMT-000001+275760-09-13T00:00:00Z,12:00:00.123456 (comment)","output":null},{"input":"Tue Dec 25 2007 10:48:00 GMT+0000 (Coordinated Universal Time)","output":1198579680000},{"input":"32AM-","output":null},{"input":"2025-1-5 January 24:00:00.001","output":null},{"input":"+02:0012:00:00.123456 :","output":null},{"input":"Mon, 04 Feb 2019 18:12:52 GMT","output":1549303972000},{"input":"1993-03-16T14:08:12.288Z","output":732290892288},{"input":"1953-06-05T13:51:27.232Z","output":-523015712768},{"input":"24:00:00.0011736942400PM-000001,","output":null},{"input":"janT2025-1-5","output":1735689600000},{"input":"2000-01-16T04","output":null},{"input":"24:00","output":null},{"input":"Fri Aug 12 2022 12:08:03 GMT+0000 (Coordinated Universal Time)","output":1660306083000},{"input":"1998-02-17T21:50:13.2","output":887752213200},{"input":"15,+02:00-0800(comment)12:00:00.1234562025-02-29","output":null},{"input":"12:00:00.123\t-08001/15/2025 \t","output":null},{"input":"/GMT zUT","output":null},{"input":"Z32","output":null},{"input":"24:00-jan23:59:60-.T124:00:00.001","output":null},{"input":"1998-10-04T08:12","output":907488720000},{"input":" TT12 :5099,","output":null},{"input":"1957-06-21T06:10:18.752Z","output":-395430581248},{"input":"492024-02-2923:59:602025-01-15T122025-00-10,25:00T","output":null},{"input":"Mon Apr 07 2014 01:07:48 GMT+0000","output":1396832868000},{"input":"Sat Feb 15 1997 06:40:50 GMT+0000 (Coordinated Universal Time)","output":855988850000},{"input":"am UTC12:00:00.12345632\n,Wed,","output":null},{"input":"4915","output":92935209600000},{"input":"1953-02-18T20:28:27.008Z","output":-532236692992},{"input":"Fri, 07 Feb 1986 10:21:35 GMT","output":508155695000},{"input":"2025-01-15-Wednesday25:002025-00-10","output":null},{"input":"Fri, 05 Jun 1992 04:16:01 GMT","output":707717761000},{"input":"EST","output":null},{"input":"Sun Dec 14 1986 01:57:00 GMT+0000","output":534909420000},{"input":"/2025-01-15+275760-09-13T00:00:00.001Z Wed,1","output":null},{"input":"Sun, 21 Sep 1975 22:25:24 GMT","output":180570324000},{"input":"Feb 2025-01-15T12:00Z,12:00:00,12:00:00-2025/01/15","output":null},{"input":"UTC,","output":null},{"input":"1988-","output":567993600000},{"input":"25:00 ","output":null},{"input":"+275760-09-13T00:00:00.001Z 12:00:00.123","output":null},{"input":"2025-01-15T12:00ZT173694240024:00","output":null},{"input":"(comment)-Wednesday","output":null},{"input":"2025-1-5z99\t,","output":null},{"input":"Fri Nov 28 2036 08:38:12 GMT+0000 (Coordinated Universal Time)","output":2111474292000},{"input":"12:00:00.123pm +275760-09-13T00:00:00.001Z2025-1-531,2025-13-01","output":null},{"input":"2025-01-15T12:00Z,2025-01-15T","output":null},{"input":"275760-09-13 24:00:00.001-0800z2025-13-01PM","output":null},{"input":"/-2025-01-15TT+002025-UTC","output":null},{"input":")50,2025-13-01GMTT","output":null},{"input":"1994-01-26T20:13:38.944Z","output":759615218944},{"input":"jan","output":null},{"input":"/ 1532T","output":null},{"input":"1997-10-29T11:47:10.976Z","output":878125630976},{"input":"UTC2025-1-5 Wed,+275760-09-13T00:00:00.001Z32T","output":null},{"input":"+275760-09-13T00:00:00Z23:59:6031T2025-13-01","output":null},{"input":"Fri Oct 06 1989 16:54:57 GMT+0000 (Coordinated Universal Time)","output":623696097000},{"input":"Tue Oct 10 2028 11:43:45 GMT+0000 (Coordinated Universal Time)","output":1854791025000},{"input":"Wed,+275760-09-13T00:00:00ZpmJan,Wed,","output":null},{"input":"50jan,","output":-631152000000},{"input":"1970EST/T2025TPM,","output":null},{"input":"1998-07-09T09:21:28.320Z","output":899976088320},{"input":"Z1212:00:00T","output":null},{"input":"1736942400","output":null},{"input":"12:00-080012:00:00.1234561736942400","output":null},{"input":"2025-01-15TWednesdayPM-0800","output":null},{"input":"2000-04-21T11:41:22.560Z","output":956317282560},{"input":"2025/01/15AM1z12:00","output":null},{"input":"24:00:00.001202523:59:602025-02-29","output":null},{"input":"1/15/2025\t","output":1736899200000},{"input":"Sat Dec 06 2003 17:59:09 GMT+0000 (Coordinated Universal Time)","output":1070733549000},{"input":"12:00:00.123456-0800Wednesday","output":null},{"input":"2025-13-01pm2025-01-15 ","output":null},{"input":"Sun, 03 Oct 2032 13:34:29 GMT","output":1980423269000},{"input":"Mon Jun 28 1993 23:47:41 GMT+0000 (Coordinated Universal Time)","output":741311261000},{"input":"2025AMUT12:00:00T(comment)","output":null},{"input":"GMT(comment)50.,garbagegarbageT","output":null},{"input":"am1/15/2025,23:59:60","output":null},{"input":"-+002025","output":1735689600000},{"input":"1971-03-04T00:26:25.408Z","output":36894385408},{"input":"2025-13-01FebT","output":1739404800000},{"input":".12:00:00T12:00:00T31","output":null},{"input":"1.","output":978307200000},{"input":"Sat Oct 26 2019 09:13:33 GMT+0000","output":1572081213000},{"input":"1970-0800,PMT","output":null},{"input":"Wed, 05 Apr 1978 17:50:48 GMT","output":260646648000},{"input":"Sun, 31 Jan 2016 12:14:03 GMT","output":1454242443000},{"input":"Sun, 17 Jun 2029 09:53:37 GMT","output":1876384417000},{"input":"+212:00:00.123AM99.+275760-09-13T00:00:00Z","output":null},{"input":"Tue, 09 Sep 2025 01:20:14 GMT","output":1757380814000},{"input":"0","output":946684800000},{"input":"2025-01-15T12:00Z","output":1736942400000},{"input":"EST","output":null},{"input":"992025-02-292025-00-10Feb-2025-1-5 /","output":null},{"input":"jan,9912:00:00.12345650","output":null},{"input":"PM,-000001-garbageFebJan15T","output":null},{"input":"1/15/2025Z ","output":1736899200000},{"input":"EST","output":null},{"input":"JanFeb,-12:00:00,+002025","output":null},{"input":"zJanuary12:00:00.123456","output":null},{"input":"1/15/2025,:2025-01-15T12:00ZT2025-01-15TJan","output":null},{"input":"4932","output":93471667200000},{"input":"Mon Jan 25 1982 18:39:57 GMT+0000","output":380831997000},{"input":"15","output":null},{"input":"1736942400T12:00:00.123456 ","output":null},{"input":"Wed, 02 Dec 2026 05:21:58 GMT","output":1796188918000},{"input":"25:00,GMT32","output":null},{"input":"275760-09-1323:59:60+02:0024:00:00.001 am,","output":null},{"input":" -,12:00:00.123","output":null},{"input":"1","output":978307200000},{"input":"1939-05-30T19:47:17.120Z","output":-965362362880},{"input":"-T","output":null},{"input":"jan","output":null},{"input":"AMgarbage1970","output":null},{"input":"(comment)00\n24:00:00.001)Wed,,","output":null},{"input":"Tue, 06 Aug 1985 13:18:54 GMT","output":492182334000},{"input":")12:00:00.123UTC","output":null},{"input":"15/1/202515/1/2025","output":null},{"input":"Wed,pm(","output":null},{"input":"2025-01-15T12 Z12T.EST2025-01-15T12:00ZJan","output":null},{"input":"Fri Oct 30 1970 14:16:54 GMT+0000","output":26144214000},{"input":"Sat Jan 01 2011 07:47:40 GMT+0000 (Coordinated Universal Time)","output":1293868060000},{"input":"Sun, 23 Sep 2012 07:51:42 GMT","output":1348386702000},{"input":"1","output":978307200000},{"input":"Thu Jun 08 2034 21:43:39 GMT+0000 (Coordinated Universal Time)","output":2033415819000},{"input":"z1970+2-,","output":null},{"input":"1966-02-11T08:16:35.328Z","output":-122658204672},{"input":"2025-01-15T12:00Zjan","output":null},{"input":"2025-02-2931.,2025-01-15T12","output":null},{"input":"AM+02:00z 12:00:00.123 ,2025-13-01,","output":null},{"input":"31T12T1225:00+275760-09-13T00:00:00.001ZT2024-02-29","output":null},{"input":"2025-00-102025/01/15","output":null},{"input":"2025-00-10T:PM2025-01-15T12:00Z","output":null},{"input":"1960-10-06T02:25:43.424Z","output":-291504856576},{"input":"2025-01-152024-02-2915/1/2025","output":null},{"input":"+002025,T1200 ","output":null},{"input":"50TJan24:00","output":null},{"input":"UT2025-01-15T","output":null},{"input":"275760-09-13","output":8640000000000000},{"input":"Wed,AM+2 +275760-09-13T00:00:00.001ZT.,12:00:00.123","output":null},{"input":"00Jan(T","output":946684800000},{"input":"12:00:00.123456Wed,275760-09-13,","output":null},{"input":"T12","output":null},{"input":"312025/01/15\nWednesday ","output":null},{"input":"am January2025-02-29","output":1735776000000},{"input":"UTC2025-01-15T2025-01-15","output":null},{"input":"202512:00 PDT /-1736942400","output":null},{"input":"PMT+275760-09-13T00:00:00.001Z25:00,Feb2025-1-5 ","output":null},{"input":"PM.","output":null},{"input":"12:00:00.123pm2025-1-5","output":1736078400123},{"input":"Jan31TUTC","output":null},{"input":"Thu Aug 25 2016 03:27:23 GMT+0000","output":1472095643000},{"input":"jan-080015/1/2025-23:59:60275760-09-13","output":null},{"input":"12:00","output":null},{"input":"jan(,()","output":null},{"input":",T12:00T","output":null},{"input":"12:00:00,12:00:00.123456,","output":null},{"input":":-12:00:00.123456T275760-09-1325:00Jan","output":null},{"input":"Thu, 09 Jun 2016 22:47:01 GMT","output":1465512421000},{"input":"2025-01-15T12-080015/1/20252025-01-15T12:00:0050","output":null},{"input":"UTCT\n- (","output":null},{"input":"2024-02-29Wed,JanPDT31 ","output":null},{"input":"2025-1-5T1970275760-09-1332-","output":null},{"input":"Jan2025-1-5","output":1735689600000},{"input":"garbageZjanT","output":null},{"input":"2025-01-15jan ","output":1735689600000},{"input":"24:00","output":null},{"input":"1993-01-28T02:","output":null},{"input":"garbage 995012:00","output":null},{"input":"1945-12-05T12:58:36.672Z","output":-759668483328},{"input":"Feb","output":null},{"input":"12:002025/01/15,-,)-2025-1-512:00:00.123","output":null},{"input":"(2025-01-15","output":null},{"input":"1987-11-18T23:08:56.192Z","output":564275336192},{"input":"\t2025-01-15\t15/1/2025,","output":null},{"input":"2025-01-152025,2024-02-29","output":null},{"input":"Mon Aug 19 2002 04:41:41 GMT+0000 (Coordinated Universal Time)","output":1029732101000},{"input":"1736942400January2025-01-15","output":null},{"input":"1-TT1-00000112:00:00T","output":null},{"input":"Tue Apr 12 1983 06:32:15 GMT+0000 (Coordinated Universal Time)","output":418977135000},{"input":"-000001-000001,","output":-62198755200000},{"input":"Sun, 11 Aug 2030 17:39:02 GMT","output":1912700342000},{"input":"12:00:00.1232025-01-15","output":null},{"input":"pm .2025-01-15T12 2025-13-011","output":null},{"input":"Sun, 15 Nov 1970 08:23:52 GMT","output":27505432000},{"input":"1956-02-13T05:07:43.23","output":-438115936770},{"input":"12:00:00.123456","output":null},{"input":"99-2025-00-10","output":null},{"input":",Z(comment)2025-01-15T12GMT2024-02-29","output":null},{"input":"T.T +02:00Wednesday","output":null},{"input":"1976-08-06T23:05:10.656Z","output":208220710656},{"input":"Mon Jan 12 1970 19:25:10 GMT+0000 (Coordinated Universal Time)","output":1020310000},{"input":"Sat Sep 25 2038 07:31:01 GMT+0000","output":2169012661000},{"input":"--T,T","output":null},{"input":"12:00:00T","output":null},{"input":"Jan2025-01-15T2025-01-15Tjan23:59:60/T","output":null},{"input":"AM2025-01-15T2025-00-102025-01-15T12: ","output":null},{"input":"Feb-50.31PDT","output":-625856400000},{"input":"99T2025-00-10 z1736942400","output":null},{"input":"12:00:00,2025-13-0112:00:00.123","output":null},{"input":"Wed, 08 Dec 2004 21:46:11 GMT","output":1102542371000},{"input":"Sat Jan 27 2007 23:32:15 GMT+0000 (Coordinated Universal Time)","output":1169940735000},{"input":"Wednesday1/15/2025 ,Wednesday","output":null},{"input":"AM-49275760-09-132025-01-15T1215\t","output":null},{"input":"15/1/2025Jan T12","output":null},{"input":"1937-09-01T17:39:02.78","output":-1020320457220},{"input":"Thu Jul 27 1972 19:41:51 GMT+0000","output":81114111000},{"input":"1:31 ","output":null},{"input":"Thu Jul 22 1976 20:55:44 GMT+0000 (Coordinated Universal Time)","output":206916944000},{"input":"1512:00:00.123+02:002025-01-15T12:00Z","output":null},{"input":"+275760-09-13T00:00:00.001Z-T","output":null},{"input":"1PDT2025-01-15-","output":null},{"input":"Z12T12","output":null},{"input":")-,","output":null},{"input":"1/15/2025","output":1736899200000},{"input":"Mon May 27 2013 19:34:08 GMT+0000 (Coordinated Universal Time)","output":1369683248000},{"input":"Z1217369424001Jan","output":null},{"input":"2025-01-15Z12,","output":null},{"input":"-+002025-32","output":null},{"input":"+002025+275760-09-13T00:00:00.001Z12:00:00.123T24:0012:00","output":null},{"input":"Z12UT2025-00-10-","output":null},{"input":"\nT502025-","output":null},{"input":"1957-10-14T07:","output":null},{"input":"1988-06-25T","output":null},{"input":"12:00:00+275760-09-13T00:00:00.001Zjan","output":null},{"input":"January , (comment)","output":null},{"input":"+02:00EST)\t ","output":null},{"input":"2025-02-29) -","output":null},{"input":"Sat, 13 Oct 2018 13:33:33 GMT","output":1539437613000},{"input":")24:00:00.001-","output":null},{"input":" 050","output":-631152000000},{"input":"amjan 31","output":null},{"input":"2025+002025","output":null},{"input":"2025-01-15T12,z50\tEST","output":null},{"input":"Sun Oct 14 1990 15:14:02 GMT+0000 (Coordinated Universal Time)","output":655917242000},{"input":"Fri Jun 17 2022 04:32:12 GMT+0000","output":1655440332000},{"input":"31\n 173694240012:00","output":null},{"input":"+275760-09-13T00:00:00.001Z","output":null},{"input":"24:00:00.001FebT+275760-09-13T00:00:00Z-0800UT","output":null},{"input":"--(comment)","output":null},{"input":"+275760-09-13T00:00:00.001Z ","output":null},{"input":"Z122024-02-29am2024-02-29pm","output":null},{"input":"9924:00:00.001January","output":251003923201000},{"input":"1989-02-13T08:13:39.968Z","output":603360819968},{"input":"1978-11-24T20:42:53.056Z","output":280788173056},{"input":"17369424002025-13-012025/01/152025-02-29pmT+275760-09-13T00:00:00Z","output":null},{"input":"EST","output":null},{"input":"0-0800Wednesday\t","output":null},{"input":"+275760-09-13T00:00:00.001Z,:jan23:59:6024:0024:00","output":null},{"input":"Tue Mar 26 1974 03:32:07 GMT+0000 (Coordinated Universal Time)","output":133500727000},{"input":"1/15/2025-0800","output":null},{"input":"1972-05-12T13:23:25.312Z","output":74525005312},{"input":"1970+02:00zam","output":null},{"input":"Z1223:59:60+275760-09-13T00:00:00.001Z32)-","output":null},{"input":"322025/01/15(+02:00PMWednesday","output":null},{"input":".(comment)pmEST-1736942400","output":null},{"input":"PM garbageT","output":null},{"input":"24:00-","output":null},{"input":"0 32-","output":null},{"input":"Wednesday+275760-09-13T00:00:00Z--T1299T2024-02-29","output":null},{"input":"12:00:00.123-","output":null},{"input":"1935-10-28T13:23:37.856Z","output":-1078569382144},{"input":"1980-12-03T17:43:45.408Z","output":344713425408},{"input":"jan-PDT","output":null},{"input":", -","output":null},{"input":".15/1/20252025-01-15T12:00Z,(comment)23:59:60Feb ","output":null},{"input":"+0020252025-00-10PM+02:00PMAM","output":null},{"input":",+02:00,pm\n+275760-09-13T00:00:00.001Z+002025","output":null},{"input":"2025-01-15T(PDT322025-1-5","output":null},{"input":"19","output":null},{"input":"2025-13-0112:00:00.1232025-01-15T12+275760-09-13T00:00:00Z31 \n","output":null},{"input":"Thu, 02 Apr 2020 01:44:36 GMT","output":1585791876000},{"input":"2025-01-15+002025EST,garbage","output":null},{"input":"12:00:00.123456(comment)T2025-01-15T12:00Z","output":null},{"input":"Z122025-1-5Jan","output":null},{"input":"173694240012025-02-29-275760-09-13","output":null},{"input":"2025T","output":null},{"input":"00275760-09-13:2025-01-15T12:00Z2025-01-15T","output":null},{"input":"Sat, 22 Aug 2015 00:40:28 GMT","output":1440204028000},{"input":"312025-01-15T12-+2Z1224:00:00.001","output":null},{"input":"AMT12","output":null},{"input":"00Wednesday2025-01-15+2 275760-09-13-)","output":null},{"input":"Wed,-/Tpm2025-1-512:00,","output":null},{"input":".","output":null},{"input":"jan15/1/2025T2025,","output":null},{"input":"1/15/2025PDT -000001 : ","output":null},{"input":"2025-1-55000,2025-01-15T12:00ZZ12","output":null},{"input":"AMAM2025-02-29\tpm","output":null},{"input":"z0,1525:00","output":null},{"input":"1952-03-10T13:39:06.624Z","output":-562069253376},{"input":",,1/15/2025-1PMJanuary ","output":null},{"input":"(comment)/","output":null},{"input":"Thu, 30 Sep 1993 01:30:36 GMT","output":749352636000},{"input":"1948-07-25T14:28:21.120Z","output":-676459898880},{"input":"1995-05-04","output":799545600000},{"input":"23:59:60)","output":null},{"input":"2025/01/15275760-09-13Z12+02:00,","output":null},{"input":"23:59:60\n2024-02-2949UTC-12:00","output":null},{"input":"12:00:00.123T0099AM ","output":null},{"input":"-000001\nz9912:00:00.123FebT","output":null},{"input":"1947-","output":-725846400000},{"input":"24:00:00.0010T","output":null},{"input":"24:00:00.001UTC,T23:59:60","output":null},{"input":"\t","output":null},{"input":"24:00,001/15/2025PDT2025-13-01","output":null},{"input":"+275760-09-13T00:00:00Z+002025jan","output":null},{"input":"\t-000001","output":978307200000},{"input":"/ +002025-janjan","output":1735689600000},{"input":"2025-01-15garbage","output":null},{"input":"(comment)PDT2025/01/15+002025(comment)-T12","output":null},{"input":"0 12:00:0023:59:602025-02-29+275760-09-13T00:00:00Z-12:00T","output":null},{"input":"-0800 AMT\tT2025-01-15T12 23:59:60 ","output":null},{"input":"1946-09-17T17","output":null},{"input":"\t+002025,T121+02:00z","output":null},{"input":"PDT,2025-01-15T12:00Z2025-02-29(","output":null},{"input":"2025-13-01Wed,","output":null},{"input":"2025-01-15T12:00Z12:00:00.123","output":null},{"input":"Thu Feb 27 1975 19:50:27 GMT+0000","output":162762627000},{"input":" ,31,+00202512:00:00.123 +02:0012:00:00.123 ","output":null},{"input":"12:00:00.123456 January50","output":-631108799877},{"input":"1974-10-04T05:44:34.048Z","output":150097474048},{"input":"Wed,Wed,-PM0099PM","output":null},{"input":"(PDT 132-000001\t","output":null},{"input":"+002025. \tGMT/GMT","output":1735689600000},{"input":"\npm","output":null},{"input":"12:00UTCjanT2025-00-10,(,","output":null},{"input":"2025-13-01(comment),,,Feb","output":1739404800000},{"input":"24:00:00.001-00000112:00 ","output":null},{"input":"1/15/2025T99-","output":null},{"input":"99,99","output":null},{"input":"1949-10-14T08:08:25.856Z","output":-637948294144},{"input":"AMAMJanuary2025-00-10","output":null},{"input":"janJanAM ","output":null},{"input":"1/15/2025","output":1736899200000},{"input":"1998-11-01T06:05:06.432Z","output":909900306432},{"input":"Tue, 08 Jan 1974 17:54:48 GMT","output":126899688000},{"input":"UT +002025","output":1735689600000},{"input":"1PDT,1736942400 50 GMT +002025","output":null},{"input":"24:00:00.001UT.12:00:00.123T1250T","output":null},{"input":"1/15/2025","output":1736899200000},{"input":"UTC2025-00-1015/1/2025--2025-01-15T12","output":null},{"input":"January25:00.ESTam","output":null},{"input":" zTz,)Tgarbage2025-01-15T12:00Z","output":null},{"input":"AMUTC ","output":null},{"input":"31Feb,garbage\nUTC,0","output":null},{"input":"+2+02:00WednesdayT","output":null},{"input":"January99 (comment)","output":915148800000}]}diff --git a/rust/logs-ingestion/tests/fixtures/fuzz/internal.json b/rust/logs-ingestion/tests/fixtures/fuzz/internal.jsonnew file mode 100644index 000000000000..cc5d142276f6--- /dev/null+++ b/rust/logs-ingestion/tests/fixtures/fuzz/internal.json@@ -0,0 +1 @@+{"cases":[{"input":{"keys":" k1 , k0 ","teams":"2 3","signature":"v1.hog_flow.1736944631.00","team_id":1,"created_at":null},"output":null},{"input":{"keys":" ","teams":"*","signature":"v1.hog_flow.1736944631","team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"01","signature":"v1.a.b.1736944631.00","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"","teams":" 1","signature":"v1.hog_flow.1736944631.00","team_id":-1,"created_at":""},"output":null},{"input":{"keys":",","teams":"1,2","signature":"v1..","team_id":1000,"created_at":""},"output":null},{"input":{"keys":"k1","teams":"1,2","signature":"v1.__proto__.1736944633.5986de5c0be04a017bd88a5d8e7e377350c28ffb1e4d151b02c9576a3882b465","team_id":3,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1","teams":" * ","signature":"v1.hog_flow. 1736944631.00","team_id":2,"created_at":"Wed, 15 Jan 2025 12:39:13 GMT"},"output":null},{"input":{"keys":"k1","teams":"+1","signature":"v1.hog_flow.1.73694463e9.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1,k0","teams":"0x1","signature":"v1.hog_flow.1736944934.000300fe73cb691fd47d440fcc60ab17e150e926bf1e2643dd231a0fbc614adc","team_id":-1,"created_at":""},"output":null},{"input":{"keys":" ","teams":"1,2","signature":"v1.__proto__.1736944932.21931de0d232a75653aa9e57700e11c2a82793f39cbf3a265185ef4f7a9e7aaf","team_id":0,"created_at":"garbage"},"output":null},{"input":{"keys":"k1","teams":" 2,abc","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.00","team_id":1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1","teams":" 1","signature":"v1..","team_id":2,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k0,,k1","teams":"1,2","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.00","team_id":1,"created_at":""},"output":null},{"input":{"keys":" ","teams":"1","signature":".hog_flow.1736944631.ab","team_id":1000,"created_at":"Wed, 15 Jan 2025 12:41:31 GMT"},"output":null},{"input":{"keys":"k1,k0","teams":"-1","signature":"v1.constructor.1736944332.1870cfb39fb41e580ad1033c581b07431669402d83626d604ad985859fddcc4c","team_id":3,"created_at":null},"output":null},{"input":{"keys":"k1,k0","teams":"1.9","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944634.00","team_id":3,"created_at":"Wed, 15 Jan 2025 12:32:46 GMT"},"output":null},{"input":{"keys":"k0,,k1","teams":"-1","signature":"v1.hog_flow.1736944633.ce0929d59cd02e65f461d6be8b95dadafee835f504a31019bf0321a079044883","team_id":0,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":",","teams":"","signature":"v1.billed_src.1736944332.9b12f76300c4675a6a8864a24804810945b676b346ad05b58704b99d318eb2d8","team_id":0,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1","teams":"01","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.00","team_id":0,"created_at":"Wed, 15 Jan 2025 12:42:57 GMT"},"output":null},{"input":{"keys":" ","teams":"1,","signature":"v1.constructor.1736944934.597a8dff44f39f468d40c6a913b7de9dc13198d57cb033b0dd1bffe684ca3334","team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"","teams":"+1","signature":"v1.hog_flow.1736944333.9e7d1c5b33411611492bd5e656571f354832675393861fc853235a9f5264e3cb","team_id":0,"created_at":"garbage"},"output":null},{"input":{"keys":"k1,k0","teams":" ","signature":"v1..","team_id":1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" ","teams":"","signature":"v1.hog_flow.1736944631.00","team_id":-1,"created_at":""},"output":null},{"input":{"keys":" ","teams":" 1","signature":"v1..1736944934.00","team_id":3,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":" 1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944332.04c2a0fa61cff40c51dd99fa019a035de64203426cde889861c74011f9dd3824","team_id":1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":",","teams":" * ","signature":"v1.constructor.1736944934.597a8dff44f39f468d40c6a913b7de9dc13198d57cb033b0dd1bffe684ca3334.extra","team_id":1000,"created_at":"1736944633250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1e3","signature":"v1..1736944634.00","team_id":-1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"","teams":"1,2","signature":"v1.a.b.1736944934.00","team_id":0,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"-1","signature":"v1.hog_flow.0736944631.ab","team_id":2,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1","teams":"","signature":"v1.hog_flow.1736944333.70719209bbb7211ba21223664412fc72ae18e06b2e26c3afb841301a7a1df445","team_id":1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k0,,k1","teams":"-1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944932.00","team_id":1,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k0,,k1","teams":"+1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944332.8c2610caeb61ea27b85b930f93d0c9cd8ea1a0b0c4199361a748d21c4a825382","team_id":-1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":",","teams":"1","signature":"v1.constructor.1736944631.d724ca8bd357c7d1ab5ec738efa834474d1b05c48b76a7fcb77ff5487945376f","team_id":2,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":",","teams":"+1","signature":"v1.constructor.1736944332.2a2edaab5e7e38efed92302ade75621346e92487660c00e90c7f852e56a6b3ec","team_id":1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1,k0","teams":" 1","signature":"v1.hog_flow.17369446310.00","team_id":1000,"created_at":null},"output":null},{"input":{"keys":" ","teams":" ","signature":"v1.hog_flow.1.73694463e9.00","team_id":1,"created_at":"1736944633250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":" 2,abc","signature":"v1.hog_flow. 1736944631.00","team_id":1000,"created_at":"Wed, 15 Jan 2025 12:39:09 GMT"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"-1","signature":"v1.a.b.1736944333.00.extra","team_id":-1,"created_at":""},"output":null},{"input":{"keys":" k1 , k0 ","teams":" 1","signature":"v1..1736944934.00.extra","team_id":-1,"created_at":"garbage"},"output":null},{"input":{"keys":" ","teams":" ","signature":"v1..","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":" ","teams":" 1","signature":"v1.a.b.1736944633.00.extra","team_id":1000,"created_at":""},"output":null},{"input":{"keys":"k0,,k1","teams":"+1","signature":"v1.hog_flow.17369446310.00","team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1,k0","teams":"2 3","signature":"","team_id":1000,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":",","teams":"+1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944631.2635d1b53669acf650b4b9655eafc85de40ca494d44301892e9178c79d7e17fc","team_id":3,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":",","teams":" 1","signature":"v1.HOG.1736944333.00","team_id":3,"created_at":"garbage"},"output":null},{"input":{"keys":"k0,,k1","teams":"1,","signature":null,"team_id":0,"created_at":null},"output":null},{"input":{"keys":"k0,,k1","teams":"0x1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944633.00","team_id":-1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k0,,k1","teams":"1,","signature":null,"team_id":3,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1","teams":"1.9","signature":"v1.__proto__.1736944332.28465d602c632cd5cbd063eafe2a43b3927c73c4119fcdc5183d289e1cb0ab02","team_id":2,"created_at":"garbage"},"output":null},{"input":{"keys":"","teams":"1,2","signature":"v1..1736944332.00","team_id":1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":",","teams":"1.9","signature":"v1.hog_flow.1736944631","team_id":3,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"01","signature":"v1.__proto__.1736944934.7de9723e8ff09f5bd9c90bbee59c90dfd0c72483a24d0be9e0bcf0cf81ffc787","team_id":2,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1,k0","teams":"01","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944633.ac1f982c4529d86c200d8c5149ac4f6215d3b45ce7b92202bddf6efa3f3c68b7","team_id":1,"created_at":null},"output":null},{"input":{"keys":"k0,,k1","teams":" * ","signature":".hog_flow.1736944631.ab","team_id":1,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k0,,k1","teams":" 2,abc","signature":"v1.HOG.1736944631.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"","teams":"","signature":".hog_flow.1736944631.ab","team_id":1000,"created_at":"Wed, 15 Jan 2025 12:41:57 GMT"},"output":null},{"input":{"keys":",","teams":" 2,abc","signature":"v1.a.b.1736944333.00","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1","teams":"01","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944633.08188c014f6925d1938b5ed5bf6e04ddd5abbda6c1bc31945748736afdb2ec4d","team_id":2,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k1","teams":"0x1","signature":"v1.hog_flow.1736944934.85c1a03ef2533dfafaed76a0132a6a6495e9439da708dad019095b2d3b9e67a0","team_id":-1,"created_at":"1736944633250"},"output":null},{"input":{"keys":" ","teams":" 1","signature":".hog_flow.1736944631.ab","team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"","teams":"1e3","signature":"v1..1736944932.00","team_id":2,"created_at":"garbage"},"output":null},{"input":{"keys":" ","teams":"1e3","signature":"v1.__proto__.1736944631.a33d8c607a4917bab02626c15f4f7bee0ea703ea8db2ed6f0e421cfa6f9ce780x","team_id":3,"created_at":"Wed, 15 Jan 2025 12:37:09 GMT"},"output":null},{"input":{"keys":"k1,k0","teams":"*","signature":"v1.hog_flow.1736944631.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1,k0","teams":"1e3","signature":"","team_id":2,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"","teams":"01","signature":"v1.constructor.1736944631.664507b0fb606cdc1df9361f36571d0f90b880153e99496f55d3a24578088406","team_id":0,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k0,,k1","teams":"1.9","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.00","team_id":1000,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1,k0","teams":"1","signature":"v1.hog_flow.1736944631\n.00","team_id":1,"created_at":null},"output":null},{"input":{"keys":"k1","teams":"1","signature":".hog_flow.1736944631.ab","team_id":1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" k1 , k0 ","teams":" 2,abc","signature":".hog_flow.1736944631.ab","team_id":0,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":",","teams":"*","signature":"v1..1736944333.00","team_id":3,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k0,,k1","teams":"1","signature":null,"team_id":1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"","teams":"1","signature":"v1.hog_flow.1736944631.00","team_id":3,"created_at":"1736944633250"},"output":null},{"input":{"keys":"","teams":"+1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944332.1f37634af5785566681d212718bf96795fa886f760598face9935fb285750df6","team_id":2,"created_at":""},"output":null},{"input":{"keys":",","teams":"1,","signature":"v1.hog_flow. 1736944631.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"2 3","signature":"v1..1736944934.00","team_id":1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":",","teams":" 1","signature":"v1.hog_flow.1736944631.00","team_id":0,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k0,,k1","teams":"01","signature":"v1.hog_flow.1736944631.00","team_id":1000,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k1,k0","teams":"-1","signature":"v1.hog_flow.1736944631\n.00","team_id":1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":",","teams":" * ","signature":"v1.__proto__.1736944631.582686303fda549060300c9f70f598848c562f959cca65452f96cd99a6593823","team_id":1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"","teams":"0x1","signature":"","team_id":1000,"created_at":"1736944633250"},"output":null},{"input":{"keys":",","teams":" 2,abc","signature":"v1.hog_flow.1736944633.3a525b66d6713bd3f6c6631ab917fe9200d384c5722fd9adaa3daf7817659a05x","team_id":0,"created_at":null},"output":null},{"input":{"keys":"","teams":"2 3","signature":"v1.billed_src.1736944633.eab15419d150b24ff0af0ca83f7d16373261797a2385d4888a4524201dcb519e","team_id":3,"created_at":null},"output":null},{"input":{"keys":"k1","teams":"-1","signature":"v1.__proto__.1736944333.e51b84837a2ead21e70b770608d2a10646535675de0fbf4daf2aedccb7835e8d","team_id":2,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1","teams":"01","signature":"v1.billed_src.1736944633.1510a8bb74b60b8d4557af3aefb048c89a1e60d781c6ea98d9d98c69a32187d3","team_id":0,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1","teams":"","signature":"v1.__proto__.1736944333.601667459fd6183b1bdfb61b862841b316732149c117d30324e45d81aecfbc94","team_id":3,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k1,k0","teams":"+1","signature":"","team_id":-1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k0,,k1","teams":"*","signature":"garbage","team_id":0,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" ","teams":"","signature":"v1.HOG.1736944633.00","team_id":1000,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1","teams":"1e3","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944631.00x","team_id":3,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" ","teams":" 2,abc","signature":"v1.a.b.1736944934.00","team_id":0,"created_at":null},"output":null},{"input":{"keys":",","teams":"1,2","signature":"v1.HOG.1736944333.00","team_id":1000,"created_at":"1736944633250"},"output":null},{"input":{"keys":",","teams":"1","signature":null,"team_id":3,"created_at":"garbage"},"output":null},{"input":{"keys":"k1","teams":"1","signature":"v1..1736944631.00","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1","teams":"*","signature":null,"team_id":-1,"created_at":"garbage"},"output":null},{"input":{"keys":",","teams":"1,","signature":"","team_id":0,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1","signature":null,"team_id":-1,"created_at":"garbage"},"output":null},{"input":{"keys":"k1","teams":"1.9","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944634.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":",","teams":" 2,abc","signature":"v1..1736944633.00","team_id":3,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1,k0","teams":" 2,abc","signature":null,"team_id":3,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":" k1 , k0 ","teams":" ","signature":"v1.hog_flow.1736944631.00","team_id":1000,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k0,,k1","teams":"1e3","signature":"v1.hog_flow.1736944631.00","team_id":3,"created_at":"1736944633250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"+1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.b3524144bd09c469a3a6ba68ac842ad43c6866e2a3c9a9bdc14e721fd8f05d98","team_id":0,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k0,,k1","teams":" ","signature":"","team_id":1,"created_at":"garbage"},"output":null},{"input":{"keys":"k0,,k1","teams":"1e3","signature":"v1.hog_flow.1736944332.409bbea5282ac77755f383cccb39960202608410a9d0deb87345ffc5f70d7373","team_id":-1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"","teams":"01","signature":"v1.billed_src.1736944631.031253eb06c6f0d9459269dd3e9546bb1a7f85e0f782f9c764b9eec4e64084f2","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1,k0","teams":" ","signature":"","team_id":1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":" ","teams":"*","signature":"v1.hog_flow.1736944631.00","team_id":1000,"created_at":"1736944633250"},"output":null},{"input":{"keys":"","teams":" ","signature":"v1.hog_flow.1736944332.03f7171a0bba46b6c714740d9df70f9ed1513f05634d2b49486bd636de2b0e36","team_id":1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1,k0","teams":"1","signature":"v1.billed_src.1736944633.a6e1885bd21d1ecb52673ec977e7d6d9559bcfd4848cedd9bc1d9f85c5fc215e","team_id":2,"created_at":null},"output":null},{"input":{"keys":"k1","teams":"-1","signature":".hog_flow.1736944631.ab","team_id":1000,"created_at":""},"output":null},{"input":{"keys":"k0,,k1","teams":" 2,abc","signature":"v1.a.b.1736944333.00","team_id":0,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1,k0","teams":"","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944633.00.extra","team_id":3,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k0,,k1","teams":" 2,abc","signature":".hog_flow.1736944631.ab","team_id":2,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k1","teams":"0x1","signature":"v1.billed_src.1736944633.7780ff567d784d8cb60e7ac54fd238369bed91f158e64c07c8c497f2dfb0d3a6","team_id":0,"created_at":null},"output":null},{"input":{"keys":" k1 , k0 ","teams":" * ","signature":"v1..1736944633.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":",","teams":"1,2","signature":"v1.hog_flow.1736944631","team_id":1000,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"","teams":"","signature":"v1.hog_flow.1736944631\n.00","team_id":2,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1,","signature":"v1..1736944633.00","team_id":0,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1,k0","teams":"*","signature":"v1.constructor.1736944634.6547e911967eb63528d4f2f547e926266851cc6927db958fc96759c2eefca7b7","team_id":-1,"created_at":"Wed, 15 Jan 2025 12:32:25 GMT"},"output":null},{"input":{"keys":"k1,k0","teams":" ","signature":"v1.hog_flow.0736944631.ab","team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k1","teams":" 1","signature":"v1.hog_flow.1.73694463e9.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":",","teams":"+1","signature":"v1.__proto__.1736944934.791039f4a361c1f294991fdc3a14b73cb4af7ce9adcfd467ff16f4ae00f1a601x","team_id":3,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" ","teams":"1,2","signature":"v1.hog_flow.1736944631","team_id":3,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1","teams":"+1","signature":".hog_flow.1736944631.ab","team_id":2,"created_at":"Wed, 15 Jan 2025 12:33:05 GMT"},"output":null},{"input":{"keys":" ","teams":"0x1","signature":"v1.a.b.1736944333.00.","team_id":-1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"*","signature":"","team_id":1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"","teams":"*","signature":"v1..1736944932.00","team_id":1000,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"","teams":"2 3","signature":"v1..","team_id":-1,"created_at":""},"output":null},{"input":{"keys":"k0,,k1","teams":"-1","signature":"v1.billed_src.1736944934.d3bc9860f08d1562b54661defdcb8cf009bbc3ae985ba53e3d45c48fbeb66695","team_id":-1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1","teams":"*","signature":"v1.hog_flow.0736944631.ab","team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1","teams":" * ","signature":"v1.HOG.1736944633.00","team_id":1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":",","teams":"+1","signature":"v1.hog_flow.1736944631.00","team_id":1,"created_at":""},"output":null},{"input":{"keys":" k1 , k0 ","teams":"+1","signature":"v1..1736944932.00","team_id":-1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k0,,k1","teams":"+1","signature":"v1..1736944333.00","team_id":-1,"created_at":""},"output":null},{"input":{"keys":"k1","teams":"0x1","signature":"v1.constructor.1736944631.af12db8930f8f21b5689f0fc9eae349babe2f519f94aaa3cc2ba1bb2faf19056x","team_id":2,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":",","teams":"","signature":"v1.hog_flow.1736944631.00","team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1","teams":"*","signature":"v1.constructor.1736944332.aeb9361fa1e95daedc6b722ef4ac7d12545b9fd5ff28ef5c15e5d86093f8d594","team_id":3,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":",","teams":" ","signature":"v1.billed_src.1736944633.7434505b24ee64d0839e2820505360e16aa9773343aba0c3860b1a0bf61b5f93","team_id":1000,"created_at":"1736944633250"},"output":null},{"input":{"keys":"","teams":"1.9","signature":"","team_id":2,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1,k0","teams":"2 3","signature":"v1.__proto__.1736944633.3bfa16bd3e81f12b1cb4be536146454bb887171ff737e25cbd8fb6f2ab0b4d65","team_id":1000,"created_at":"1736944633250"},"output":null},{"input":{"keys":"","teams":"0x1","signature":"v1.a.b.1736944633.00","team_id":1,"created_at":"Wed, 15 Jan 2025 12:39:24 GMT"},"output":null},{"input":{"keys":"k0,,k1","teams":"0x1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.b183aaaa167f7f146430a180e0adbb60b2b27698a71d6a826bd75a6822812284","team_id":1000,"created_at":""},"output":null},{"input":{"keys":"","teams":"2 3","signature":"v1.HOG.1736944631.00","team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1,k0","teams":"1","signature":"garbage","team_id":-1,"created_at":"garbage"},"output":null},{"input":{"keys":"k1,k0","teams":"*","signature":"v1.hog_flow.1736944633.e4b977fca36e4b73ac9a19b99ed491af689e78a11dcdd71babd461fa1600ea92","team_id":2,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":",","teams":"1","signature":"v1.HOG.1736944631.00","team_id":1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":",","teams":" * ","signature":"v1.constructor.1736944633.36e87df98bd192eb5421ef10e59c1b41991a671204f24a7cfbe4ed20d9e93295","team_id":-1,"created_at":null},"output":null},{"input":{"keys":"k0,,k1","teams":"2 3","signature":"v1.constructor.1736944332.d9dceac7fa8a61152d511aa05f00a22b0ba2900b2443d31528d751f793d56415","team_id":-1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":",","teams":"1","signature":"v1.HOG.1736944333.00","team_id":0,"created_at":"1736944633250"},"output":null},{"input":{"keys":",","teams":"1","signature":"v1.hog_flow.1736944332.a3e982c86c5e0c660dbc3e81f21c66280c750f987fee169740da895796a814c4","team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"","teams":"1","signature":"v1.hog_flow.1736944932.6ae64834b00255824da0d6b7531a9bb9cf224da521a75b00922d7a1d00a786a2","team_id":0,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k1","teams":"-1","signature":"v1.hog_flow. 1736944631.00","team_id":3,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1,k0","teams":" ","signature":".hog_flow.1736944631.ab","team_id":2,"created_at":""},"output":null},{"input":{"keys":",","teams":"","signature":"v1.__proto__.1736944934.116b8bee018f9dc86dce516d0655f0c60a72531041366071d45e15c8313fdd29","team_id":-1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" ","teams":"1,","signature":"v1.HOG.1736944934.00","team_id":-1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":",","teams":" ","signature":"v1.hog_flow.1736944631\n.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":" * ","signature":"","team_id":0,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k0,,k1","teams":"1,","signature":"v1.billed_src.1736944333.deb23bcd2d337f5154e349da55e0fb035ea7125feca8a6df39ad443e537a920b","team_id":2,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k1","teams":" ","signature":"","team_id":1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1,k0","teams":"+1","signature":"v1.hog_flow.1736944333.9e7d1c5b33411611492bd5e656571f354832675393861fc853235a9f5264e3cb","team_id":0,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" ","teams":"1.9","signature":"v1.__proto__.1736944332.28465d602c632cd5cbd063eafe2a43b3927c73c4119fcdc5183d289e1cb0ab02","team_id":2,"created_at":"1736944633250"},"output":null},{"input":{"keys":" ","teams":"1.9","signature":"v1.__proto__.1736944633.3dde20b79ba679196faff2e1908fddf2ae3b44983612fde85c5e71bb110ce3b7.","team_id":-1,"created_at":""},"output":null},{"input":{"keys":"","teams":"2 3","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944932.00.","team_id":1000,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k0,,k1","teams":"1.9","signature":"v1.constructor.1736944932.16cb3ece0dda95e99e4ddaddaf1f85488448cee4c3fb6ab98f91568630e80d60","team_id":1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" ","teams":"0x1","signature":"v1..1736944934.00","team_id":0,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":",","teams":"1,2","signature":"v1.hog_flow.1736944633.fe801d275761bb748ebaf4833194e8e46e8c4544e514ac6f3eb28db1d1805a42","team_id":-1,"created_at":""},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1,2","signature":"v1.constructor.1736944631.b21405c30fb775eec05713f82face143818f7246f304687d8a697e35c60b43b5","team_id":1000,"created_at":"garbage"},"output":null},{"input":{"keys":"k1","teams":"","signature":"","team_id":1000,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":" ","teams":" * ","signature":"v1.constructor.1736944633.fad65bbf01d32867caa266f07d5346494cf9305f5cea26301c6d9303e20884e6","team_id":1000,"created_at":""},"output":null},{"input":{"keys":"","teams":"*","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.00","team_id":2,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1","teams":"-1","signature":"v1..1736944631.00","team_id":3,"created_at":null},"output":null},{"input":{"keys":" k1 , k0 ","teams":"0x1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944332.00","team_id":-1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k1,k0","teams":" 1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.00","team_id":0,"created_at":null},"output":null},{"input":{"keys":",","teams":" * ","signature":"v1.hog_flow.0736944631.ab","team_id":0,"created_at":"Wed, 15 Jan 2025 12:40:54 GMT"},"output":null},{"input":{"keys":"k1","teams":"1","signature":"v1.a.b.1736944934.00.extra","team_id":3,"created_at":"Wed, 15 Jan 2025 12:42:16 GMT"},"output":null},{"input":{"keys":",","teams":"2 3","signature":"v1.billed_src.1736944634.4cf7b68cc1023a6ea4eadbb48d4313c87c197767eaec2cc9844a90ef8eb72954","team_id":3,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"","teams":"1e3","signature":"v1.a.b.1736944333.00","team_id":1,"created_at":null},"output":null},{"input":{"keys":"k1","teams":"*","signature":"v1.hog_flow.1736944631.b8674aa854253988efee73b5abab56bcc0b6bf27c6ec65bffdd6874cc425ff7a","team_id":1000,"created_at":"2025-01-15T12:37:13.250"},"output":{"source":"hog_flow","billed":false,"teamRules":false}},{"input":{"keys":" ","teams":"1e3","signature":"v1..1736944633.00","team_id":3,"created_at":null},"output":null},{"input":{"keys":"","teams":" 1","signature":"v1.hog_flow. 1736944631.00","team_id":-1,"created_at":"1736944633250"},"output":null},{"input":{"keys":",","teams":"*","signature":"v1.hog_flow.1736944332.63908840a4f7763e7168170e7240b4187acc6a4c110cfc393a01490fc7077956x","team_id":3,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k0,,k1","teams":" 1","signature":"v1.constructor.1736944633.f29bbeeae872e4b629394f8c344c9c8a6d84a66af758f5f6a65c05591f15e054","team_id":1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"","teams":"1,","signature":"v1.hog_flow.1.73694463e9.00","team_id":2,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"","teams":"0x1","signature":"v1.HOG.1736944332.00","team_id":0,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k0,,k1","teams":"1e3","signature":"v1.hog_flow.1736944631\n.00","team_id":3,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k1,k0","teams":"","signature":"v1.hog_flow.1.73694463e9.00","team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1,k0","teams":"*","signature":".hog_flow.1736944631.ab","team_id":2,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1,","signature":"v1.hog_flow.1736944631","team_id":3,"created_at":"garbage"},"output":null},{"input":{"keys":"k1,k0","teams":"1,2","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944631.8c15e88c7efded5f0e964248e0820b69ce43129dd442b12543e239716631cde4","team_id":1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"","teams":"1,2","signature":"v1.__proto__.1736944333.1c8122842f3ef48d1f9e5f2d11ddf87ddb616c4f1c86667d6726ecead4291099","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1","teams":" 2,abc","signature":"v1.a.b.1736944633.00.","team_id":2,"created_at":"Wed, 15 Jan 2025 12:39:24 GMT"},"output":null},{"input":{"keys":",","teams":" * ","signature":"v1.hog_flow.1736944634.ba8c3cc980cce7d27e4c420d4226dca4fae15b1d8fdd7a9bc46693c9a6b17fc7","team_id":0,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"","teams":"1.9","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944634.00","team_id":2,"created_at":"garbage"},"output":null},{"input":{"keys":"k0,,k1","teams":"1e3","signature":"v1.hog_flow.1736944934.e3a3ca5fa0f2dbce113296416a2bd1aecaaa467d8a5b068453c6594efadf229c","team_id":3,"created_at":null},"output":null},{"input":{"keys":"k1","teams":"01","signature":"v1.hog_flow.1736944932.6a60d62c732f25fbbb83940f819a22b874ea39fa652c2090fd710bab46091d25","team_id":3,"created_at":"garbage"},"output":null},{"input":{"keys":"k0,,k1","teams":"1,2","signature":"v1.billed_src.1736944932.df759da357c5e8d69a786c5f67e3f20e47bac2b64da0bb3763af4414a81435cf","team_id":1000,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k0,,k1","teams":"0x1","signature":"v1.hog_flow.1736944631.00","team_id":1000,"created_at":null},"output":null},{"input":{"keys":" ","teams":" ","signature":"v1.billed_src.1736944633.977ab2da0f8ca8e460d9b69a0045077e49c23ef7ca532a6b7679627c5501870f.","team_id":1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":",","teams":"1,","signature":"v1..","team_id":3,"created_at":"Wed, 15 Jan 2025 12:40:28 GMT"},"output":null},{"input":{"keys":"k0,,k1","teams":"","signature":"v1.hog_flow.1736944631.b8674aa854253988efee73b5abab56bcc0b6bf27c6ec65bffdd6874cc425ff7a","team_id":1000,"created_at":null},"output":null},{"input":{"keys":"k1","teams":"*","signature":"","team_id":-1,"created_at":""},"output":null},{"input":{"keys":"k0,,k1","teams":"","signature":"v1.constructor.1736944633.4b269f2662802a86b6377b700d321376423a0e19315a0354d017838a34277b81","team_id":3,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"2 3","signature":"v1.a.b.1736944332.00","team_id":0,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k1,k0","teams":"1e3","signature":"v1.hog_flow. 1736944631.00","team_id":1,"created_at":"garbage"},"output":null},{"input":{"keys":",","teams":"01","signature":"v1.hog_flow.1.73694463e9.00","team_id":-1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"","teams":"0x1","signature":"v1.a.b.1736944333.00","team_id":1000,"created_at":"1736944633250"},"output":null},{"input":{"keys":" ","teams":" * ","signature":"v1.hog_flow. 1736944631.00","team_id":3,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1,k0","teams":" ","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944932.3d4af4d90b7fd9d8abe2ea462fe8564a43c61c4a4d4117463198bb0918616464","team_id":1000,"created_at":"garbage"},"output":null},{"input":{"keys":"","teams":"2 3","signature":"v1.hog_flow.1736944631.a6ccb98308f2e8e717c4d7634d473d375096e2543422b6c27e1fe8fd0f87b37f","team_id":3,"created_at":""},"output":null},{"input":{"keys":"k1","teams":"1,","signature":"v1.a.b.1736944633.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":",","teams":"1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944633.00","team_id":0,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":",","teams":"1,2","signature":"v1..1736944633.00","team_id":1000,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k0,,k1","teams":"1","signature":"v1.hog_flow.1736944633.f2d9c25a119d56efb2031427d983ca6e7bea13a472a478110c9ccf406f859131","team_id":0,"created_at":"garbage"},"output":null},{"input":{"keys":" ","teams":"0x1","signature":"v1.hog_flow.1736944631\n.00","team_id":3,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":",","teams":"+1","signature":"v1.constructor.1736944333.f4e56df3c4d9a32117c6af71439999ceb975f20440101efeeebdf93b3199f3ec","team_id":-1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1,2","signature":"v1.hog_flow.1736944631.00","team_id":2,"created_at":"Wed, 15 Jan 2025 12:34:15 GMT"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"-1","signature":"v1.__proto__.1736944934.4fbb83724d5f3b7be954f7a7d5a93ca393fdad221e581a7fb53cc10669cbaef2","team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" ","teams":"","signature":"v1.constructor.1736944934.4dcb8f4bf47ededcb953ae0ed7ee7e2d124bd65955adb2fdcd35e0ef401f5a66","team_id":3,"created_at":"garbage"},"output":null},{"input":{"keys":"","teams":" 1","signature":"v1.a.b.1736944932.00","team_id":1000,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"2 3","signature":"v1..1736944934.00","team_id":2,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k0,,k1","teams":"+1","signature":"v1.billed_src.1736944631.2f0a95c022ac9952af86d79a405e73dc10d46d562f9fedbb31d2c50a44247326","team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" ","teams":"1e3","signature":"v1.hog_flow.1736944633.6a304a0916fa432a393e4e93e989aeeeb81f856ceea54b00db43f27c659ea4b3","team_id":2,"created_at":"1736944633250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"-1","signature":"v1.hog_flow.17369446310.00","team_id":2,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"","teams":"*","signature":"v1.constructor.1736944633.d8cc07e804ce009b386713ed7a22922e1b64a0e79e0f871bb81aab6f416f5d3d","team_id":-1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k0,,k1","teams":"","signature":"v1.hog_flow.0736944631.ab","team_id":-1,"created_at":"garbage"},"output":null},{"input":{"keys":"k0,,k1","teams":" ","signature":"v1.hog_flow.0736944631.ab","team_id":3,"created_at":"garbage"},"output":null},{"input":{"keys":"k1,k0","teams":" 1","signature":"v1.hog_flow.1736944631\n.00","team_id":2,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" ","teams":"+1","signature":null,"team_id":2,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1,k0","teams":"1","signature":"v1.HOG.1736944333.00","team_id":0,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1,k0","teams":"-1","signature":"v1.hog_flow.1736944631\n.00","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k0,,k1","teams":"*","signature":"v1.hog_flow.1736944631.00","team_id":1,"created_at":"1736944633250"},"output":null},{"input":{"keys":" ","teams":" 1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944932.7bb62f3c7ce7edb225fbde594371c4fb2ffacd1a20a646cfbee77837846b3828","team_id":-1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"","teams":"2 3","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944932.66aa57863affa6712bf2cb32d03bc0d56f41b9f0f312dd36295ea09ddaae1449","team_id":3,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"0x1","signature":"v1.hog_flow.17369446310.00","team_id":-1,"created_at":null},"output":null},{"input":{"keys":"k1,k0","teams":"1e3","signature":"v1.a.b.1736944633.00","team_id":0,"created_at":"1736944633250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"-1","signature":".hog_flow.1736944631.ab","team_id":1000,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" ","teams":"1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.957d43d5106d54c5b30efdb1eb98e9b9d15723bf17ac80ecc80b8d4c5e3ce1c9","team_id":1000,"created_at":"garbage"},"output":null},{"input":{"keys":"","teams":"1.9","signature":"v1.a.b.1736944932.00","team_id":1,"created_at":"1736944633250"},"output":null},{"input":{"keys":" ","teams":" 1","signature":"v1..","team_id":-1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k0,,k1","teams":"1,","signature":"v1.hog_flow. 1736944631.00","team_id":1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":" ","teams":"2 3","signature":"v1.hog_flow.1736944932.ebb8813a7916d222a26a0e1478bbc1eb4cb5ac5abec681ab4790206f2edbe793","team_id":2,"created_at":"Wed, 15 Jan 2025 12:38:46 GMT"},"output":null},{"input":{"keys":" ","teams":" ","signature":"","team_id":1,"created_at":"garbage"},"output":null},{"input":{"keys":",","teams":" * ","signature":"v1.billed_src.1736944633.ab4a9a180569c6d4f37fef5279a08accac297a215d95074992f1544f29858f56","team_id":0,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1","teams":"+1","signature":"v1.__proto__.1736944332.e8c2a78b66359f634f0bf2b1f3794efa128386f2511d35e8899280c8777c4b59","team_id":3,"created_at":"Wed, 15 Jan 2025 12:35:41 GMT"},"output":null},{"input":{"keys":",","teams":"1,2","signature":"v1.hog_flow.1736944631\n.00","team_id":2,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1","teams":" ","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944634.00.","team_id":1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":",","teams":"1e3","signature":"v1.hog_flow.1736944631.00","team_id":1000,"created_at":"garbage"},"output":null},{"input":{"keys":",","teams":"1,","signature":null,"team_id":3,"created_at":null},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1,","signature":"v1..1736944634.00","team_id":2,"created_at":"garbage"},"output":null},{"input":{"keys":"k1,k0","teams":"1,","signature":"v1.__proto__.1736944934.4933724b5bed6a54fa5e94e6d7ab63db14bb871abb243e856dc516f942d65c8a","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"","teams":"+1","signature":"v1.hog_flow.1.73694463e9.00","team_id":1000,"created_at":"Wed, 15 Jan 2025 12:41:59 GMT"},"output":null},{"input":{"keys":"","teams":"+1","signature":"v1.constructor.1736944934.55914a3cc6043a7c18711dda7fa9cd482cbcdfa53bd7ca25277105c13eedcfa2","team_id":0,"created_at":""},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1,","signature":"v1.a.b.1736944631.00","team_id":-1,"created_at":""},"output":null},{"input":{"keys":",","teams":" ","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.008a822c89bacbf87b2c5e063e10f1dcdc009f7da3217601e879684fe3d93538","team_id":0,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"","teams":" 1","signature":"v1.a.b.1736944333.00.","team_id":1000,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k0,,k1","teams":"","signature":"v1.hog_flow.1736944631.00","team_id":3,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" ","teams":"2 3","signature":"v1.__proto__.1736944934.73da83f2763a2a0624d4e491e74ae4112dc09d030561335486ecbbb2a43b9f63","team_id":2,"created_at":"Wed, 15 Jan 2025 12:41:03 GMT"},"output":null},{"input":{"keys":"k1","teams":"01","signature":"v1.hog_flow.1736944333.d88daca941723df740510bb62e1015e6236c153fb6b7ef03b983a532e6a693f6","team_id":-1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k0,,k1","teams":"2 3","signature":"v1..1736944934.00","team_id":2,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"","teams":" ","signature":"v1.HOG.1736944634.00","team_id":0,"created_at":"1736944633250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"2 3","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944634.00","team_id":2,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":",","teams":"1e3","signature":"v1.__proto__.1736944333.d8a256add22160339af9a766e2dad8580f904d306188508044ec1daeef338d60.","team_id":1000,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1","teams":" 2,abc","signature":"v1.hog_flow.1736944631.00","team_id":-1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"2 3","signature":"","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1,k0","teams":"+1","signature":"v1.a.b.1736944332.00","team_id":2,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k0,,k1","teams":"1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.fd594c13ac2ea2232dae6b3f56f9a2228864dc3c69e9556730f0c0f0560f636a","team_id":2,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k0,,k1","teams":" 1","signature":"v1.HOG.1736944634.00","team_id":1000,"created_at":""},"output":null},{"input":{"keys":"k1","teams":"01","signature":"v1.HOG.1736944934.00.extra","team_id":2,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"2 3","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944932.00","team_id":0,"created_at":"garbage"},"output":null},{"input":{"keys":"k0,,k1","teams":" 1","signature":"v1.billed_src.1736944332.319d7b7e62b4aa7f339fb80cf633c995483b68887527d174a9e8d4e273f8e1a7","team_id":1000,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":",","teams":"01","signature":"v1.hog_flow.1736944934.92caf3d7cb59863016db5cd841205aee15ad639605493c571ddbdf6d75ba4914","team_id":2,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" ","teams":"*","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944332.00","team_id":2,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":" ","teams":"1.9","signature":"v1.hog_flow.17369446310.00","team_id":0,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1,k0","teams":" ","signature":"v1.hog_flow.0736944631.ab","team_id":2,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" ","teams":"1,","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.00","team_id":1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":",","teams":"0x1","signature":"v1..","team_id":0,"created_at":"Wed, 15 Jan 2025 12:34:48 GMT"},"output":null},{"input":{"keys":" ","teams":" ","signature":"v1.a.b.1736944932.00x","team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k0,,k1","teams":"","signature":"v1.hog_flow.1.73694463e9.00","team_id":3,"created_at":"Wed, 15 Jan 2025 12:36:30 GMT"},"output":null},{"input":{"keys":",","teams":" 2,abc","signature":"v1.hog_flow. 1736944631.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1","teams":" 1","signature":"v1.hog_flow.1.73694463e9.00","team_id":2,"created_at":null},"output":null},{"input":{"keys":"","teams":" * ","signature":"v1.hog_flow.1736944631\n.00","team_id":1000,"created_at":""},"output":null},{"input":{"keys":",","teams":"+1","signature":null,"team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"","teams":"","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944631.95fd6957014f918715627f35b5c2a40fbaca3368d25f151e69f0ff8b76afc029","team_id":-1,"created_at":"Wed, 15 Jan 2025 12:41:51 GMT"},"output":null},{"input":{"keys":" ","teams":"01","signature":null,"team_id":-1,"created_at":null},"output":null},{"input":{"keys":"k1","teams":"01","signature":"v1.hog_flow.1736944631.00","team_id":2,"created_at":"Wed, 15 Jan 2025 12:36:39 GMT"},"output":null},{"input":{"keys":",","teams":"1","signature":"v1.hog_flow.1736944631.00","team_id":2,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k1,k0","teams":"0x1","signature":"v1..1736944633.00x","team_id":3,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k0,,k1","teams":"1","signature":"v1.constructor.1736944633.d8cc07e804ce009b386713ed7a22922e1b64a0e79e0f871bb81aab6f416f5d3d","team_id":-1,"created_at":"garbage"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"+1","signature":"v1.hog_flow.17369446310.00","team_id":1,"created_at":null},"output":null},{"input":{"keys":",","teams":"1","signature":"v1.hog_flow.17369446310.00","team_id":2,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1,k0","teams":"01","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944633.00","team_id":1000,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k0,,k1","teams":" * ","signature":"v1.__proto__.1736944633.88fb953cd44a1690a7f85abb888d1bedaae000cfb8f49f37acee6a5cf6a2d8b9","team_id":1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k0,,k1","teams":"","signature":"v1.hog_flow.17369446310.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1","teams":"1,2","signature":"v1.constructor.1736944333.f1d41f23d01f7947dd596522e65bdf0e0516e04a3db23d3a5b686c33f2c5c605","team_id":1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":",","teams":"1","signature":"v1.a.b.1736944333.00.extra","team_id":1000,"created_at":"garbage"},"output":null},{"input":{"keys":" ","teams":"1e3","signature":"v1.__proto__.1736944633.9d88afbb0a9885a33457e06f6abc05f817bfdad56c92fa4a9e8fc89297b127a7","team_id":3,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k0,,k1","teams":" * ","signature":"v1.billed_src.1736944932.c3d0bbfacea089763e562c01aa297050cb6960e7afdfbed398bd6a12f335b571","team_id":2,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":",","teams":"0x1","signature":"garbage","team_id":0,"created_at":"Wed, 15 Jan 2025 12:36:45 GMT"},"output":null},{"input":{"keys":"k1","teams":"+1","signature":"","team_id":3,"created_at":null},"output":null},{"input":{"keys":"k1,k0","teams":"-1","signature":"v1..","team_id":2,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1,k0","teams":"0x1","signature":"v1.hog_flow.1736944631.00","team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":",","teams":"*","signature":"v1.hog_flow.1736944934.1ff0b49a06c21ea5c5193d2cee5e8c17d88f002da5b92e7eeb42911a5da59fcbx","team_id":1000,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1","teams":"+1","signature":null,"team_id":-1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"-1","signature":"v1.hog_flow.1736944633.515af8726ec16e01d71dc6e8c40130ea6162b96b6a83f8e4c05faf572a2bd6b4","team_id":1000,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1","teams":" ","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944633.8690995a610717dbe11d2f91c3ee7f8e85dd4133a4e4f312423a90f4922c6cf6","team_id":2,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1,","signature":"v1.hog_flow.1736944333.f9d995cf8f6ff33dafd588e2a62743b33f8da237f223ead5e596b119d8718874x","team_id":3,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":" ","teams":"1e3","signature":"v1.hog_flow.1736944634.0ce8a3f40d90ee8f2c2cf2092cc35ec745ac991f999792660d0be35c0bad57c0x","team_id":0,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k0,,k1","teams":" * ","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944633.dc500daf52c1096f2c6358008aceff29d729e3b31ac2e077752a3a2c5a47cd9a","team_id":1000,"created_at":"Wed, 15 Jan 2025 12:42:57 GMT"},"output":null},{"input":{"keys":" ","teams":" * ","signature":"v1.HOG.1736944634.00","team_id":1000,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1,k0","teams":"01","signature":"v1.hog_flow.1736944631.00","team_id":-1,"created_at":null},"output":null},{"input":{"keys":"k1,k0","teams":"+1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.cc219a9baf0472fe49333a944ea6d391be3db08b9cc16f1b42969c633193ef12","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k0,,k1","teams":"01","signature":"v1.HOG.1736944633.00.extra","team_id":2,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1,k0","teams":"2 3","signature":".hog_flow.1736944631.ab","team_id":-1,"created_at":null},"output":null},{"input":{"keys":"","teams":" 1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944631.00","team_id":2,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" ","teams":" 1","signature":"v1.hog_flow.0736944631.ab","team_id":2,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1,","signature":"v1.billed_src.1736944634.5c85c49371b740c9e9cc472e5777b107a99862ae69bec50865cbabbd72371853","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":{"source":"billed_src","billed":true,"teamRules":true}},{"input":{"keys":"","teams":"1","signature":"v1.billed_src.1736944633.56c2c630974cbf52969def56b6f447c3578f708fae9575ae692ca0d16d68414c","team_id":1000,"created_at":"garbage"},"output":null},{"input":{"keys":"k1","teams":"2 3","signature":"v1.a.b.1736944633.00","team_id":0,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k0,,k1","teams":" 1","signature":"v1.hog_flow.1736944934.11e75e5b8bb4245ab61328d8a9b96ddefc9df6b33880eb1f8b036bad12819b7d","team_id":2,"created_at":null},"output":null},{"input":{"keys":" k1 , k0 ","teams":"+1","signature":"v1.hog_flow.1736944631.00","team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k0,,k1","teams":"0x1","signature":".hog_flow.1736944631.ab","team_id":-1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"+1","signature":"v1..1736944932.00","team_id":1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k1,k0","teams":"0x1","signature":null,"team_id":2,"created_at":"garbage"},"output":null},{"input":{"keys":"","teams":" ","signature":"v1.hog_flow.1736944633.cb84a251cac30eaacd2e76a73acda913c03f8b77adaafca552b9db9bbefc18e7","team_id":3,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1,k0","teams":"-1","signature":"v1.hog_flow.1736944633.cb84a251cac30eaacd2e76a73acda913c03f8b77adaafca552b9db9bbefc18e7x","team_id":3,"created_at":""},"output":null},{"input":{"keys":" k1 , k0 ","teams":" 1","signature":"v1..","team_id":3,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k0,,k1","teams":"1","signature":"v1.a.b.1736944333.00","team_id":0,"created_at":"garbage"},"output":null},{"input":{"keys":"k0,,k1","teams":"01","signature":"v1.__proto__.1736944633.cf5a62681af92aa0c463a9b12fe3e1c71047a72651cda1cfe9fe5922045109ce","team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k1","teams":"*","signature":"v1.hog_flow.1736944631.00","team_id":1,"created_at":"Wed, 15 Jan 2025 12:34:31 GMT"},"output":null},{"input":{"keys":",","teams":"*","signature":"v1.hog_flow.1736944631\n.00","team_id":-1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" ","teams":" * ","signature":"v1.a.b.1736944634.00","team_id":3,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":" k1 , k0 ","teams":" 1","signature":"v1.HOG.1736944633.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k0,,k1","teams":"0x1","signature":"v1.constructor.1736944934.93289e255fa65d31df8b2154932ff8e15bcd2cb71759ad6fcb215f0bccef5472","team_id":1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"-1","signature":"v1.HOG.1736944633.00","team_id":1000,"created_at":"Wed, 15 Jan 2025 12:32:16 GMT"},"output":null},{"input":{"keys":",","teams":" 1","signature":"v1..1736944633.00","team_id":-1,"created_at":null},"output":null},{"input":{"keys":"k1,k0","teams":" * ","signature":"v1.hog_flow.17369446310.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1","teams":"2 3","signature":"v1.hog_flow.1736944333.ea287566d15d6c3f9b0992362a8fab26df5633e82406bb2f5125c3f712323cef","team_id":2,"created_at":"Wed, 15 Jan 2025 12:37:09 GMT"},"output":null},{"input":{"keys":"","teams":"*","signature":"v1.hog_flow.17369446310.00","team_id":-1,"created_at":null},"output":null},{"input":{"keys":" k1 , k0 ","teams":"+1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944634.00","team_id":0,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" ","teams":" 1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944633.8690995a610717dbe11d2f91c3ee7f8e85dd4133a4e4f312423a90f4922c6cf6","team_id":2,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" ","teams":"0x1","signature":"","team_id":2,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1,k0","teams":"1e3","signature":"v1.hog_flow.1736944631.00","team_id":1000,"created_at":"1736944633250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1,","signature":"v1.billed_src.1736944634.85f76d43bdd9822b32ea0d5fc89b8fc10a260dd73e14017d72900550cc190135.","team_id":1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"","teams":"0x1","signature":"v1.billed_src.1736944934.a5394a5a960b439acbf69d3a5320504d72bda7b73be476a218910a91594010c4","team_id":2,"created_at":"garbage"},"output":null},{"input":{"keys":"k1","teams":" 1","signature":"v1.__proto__.1736944631.582686303fda549060300c9f70f598848c562f959cca65452f96cd99a6593823","team_id":1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" ","teams":"1","signature":"v1.hog_flow. 1736944631.00","team_id":1000,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":",","teams":"-1","signature":"v1.HOG.1736944932.00","team_id":1000,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"*","signature":"v1.__proto__.1736944934.b3b967984284e0aa93393faafe61d051fb6c2dca036a5b699f878728500051d1","team_id":0,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"01","signature":"v1.constructor.1736944934.22ff56c8b49c638e67ee795a2b2a32cfadb1be9bb68bb74abb95b52dcfd37fab","team_id":-1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"01","signature":"v1.__proto__.1736944633.cffa65017bca30d237c09a11647301f8b39ce794874f74a8376616d1661055a5","team_id":2,"created_at":""},"output":null},{"input":{"keys":"","teams":"1,2","signature":"v1.constructor.1736944934.c1cc5ce03420718e4f173ca73211e0f26c5e5810a9ad19f5def0c588eb95dc6f","team_id":0,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1","teams":"2 3","signature":"v1.__proto__.1736944633.5986de5c0be04a017bd88a5d8e7e377350c28ffb1e4d151b02c9576a3882b465","team_id":3,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" ","teams":"-1","signature":"v1.a.b.1736944333.00","team_id":0,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1","teams":"1","signature":".hog_flow.1736944631.ab","team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" ","teams":"+1","signature":"v1..1736944333.00","team_id":1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"01","signature":"v1.__proto__.1736944332.fd0b1b2c61fe04c65f4ee5721c12a06f74fa1978092ef1339f7367ae6ebd9be1x","team_id":3,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":",","teams":" * ","signature":"v1.hog_flow.1736944631","team_id":2,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k0,,k1","teams":"1","signature":".hog_flow.1736944631.ab","team_id":1,"created_at":null},"output":null},{"input":{"keys":" k1 , k0 ","teams":"-1","signature":"v1.HOG.1736944333.00.extra","team_id":3,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"-1","signature":"v1.HOG.1736944634.00","team_id":0,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"","teams":"2 3","signature":"v1.hog_flow.17369446310.00","team_id":0,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"","teams":"1e3","signature":"v1.hog_flow.1.73694463e9.00","team_id":3,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1,k0","teams":"1","signature":"v1.a.b.1736944934.00","team_id":1,"created_at":"garbage"},"output":null},{"input":{"keys":"","teams":"2 3","signature":"v1.billed_src.1736944934.901919117be24ce0b2c47752fbcb85f2313792b45cbaa2912aa238a13aedae5b","team_id":1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"","teams":"-1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944631.95fd6957014f918715627f35b5c2a40fbaca3368d25f151e69f0ff8b76afc029","team_id":-1,"created_at":"Wed, 15 Jan 2025 12:37:30 GMT"},"output":null},{"input":{"keys":"","teams":" 1","signature":"","team_id":1000,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"*","signature":null,"team_id":3,"created_at":""},"output":null},{"input":{"keys":",","teams":"01","signature":"v1.hog_flow.1736944631","team_id":3,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"","teams":"1e3","signature":"v1.hog_flow.1736944631.00","team_id":1,"created_at":"Wed, 15 Jan 2025 12:34:09 GMT"},"output":null},{"input":{"keys":"k1,k0","teams":"-1","signature":"v1.hog_flow.1736944934.c302484fc8ed930080f4bfa479fc1779d4c6ae6ebe9e5f60aa6a9f31ee7ada2b","team_id":-1,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k0,,k1","teams":"1,","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.5cadb4952d08a45499ab91e2d93645f57cdf2f6de18815468b11c575ed68ef50","team_id":1000,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k0,,k1","teams":"0x1","signature":"v1..1736944631.00","team_id":1000,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":",","teams":"2 3","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.fb54f66a020a51172586464275fbcd24347088538a1ba246c6f1b3b899805718","team_id":1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k1","teams":"+1","signature":"v1.hog_flow.1736944631","team_id":1000,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1,k0","teams":"01","signature":".hog_flow.1736944631.ab","team_id":2,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k0,,k1","teams":"0x1","signature":"v1.hog_flow.1736944934.e3a3ca5fa0f2dbce113296416a2bd1aecaaa467d8a5b068453c6594efadf229c","team_id":3,"created_at":null},"output":null},{"input":{"keys":"k1,k0","teams":"1e3","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.e8801e85c6188730e96f6d24e9ef6b32f387af259d983701284dd59e5e7d300e","team_id":1000,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1","teams":"0x1","signature":"v1.hog_flow.1736944631","team_id":2,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1,k0","teams":"1,2","signature":"garbage","team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1,","signature":"v1.hog_flow.0736944631.ab","team_id":2,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":",","teams":"1e3","signature":"v1..1736944633.00","team_id":1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1,k0","teams":"1,2","signature":"v1.billed_src.1736944633.eab15419d150b24ff0af0ca83f7d16373261797a2385d4888a4524201dcb519e","team_id":3,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k1,k0","teams":" 1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.00","team_id":1,"created_at":"1736944633250"},"output":null},{"input":{"keys":",","teams":" 2,abc","signature":"v1.HOG.1736944934.00","team_id":0,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":",","teams":" 2,abc","signature":"v1.hog_flow.17369446310.00","team_id":-1,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k0,,k1","teams":"1,","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944332.00","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k0,,k1","teams":"1.9","signature":"v1.constructor.1736944631.3bba470359fd1df6a283bfc8a321c0e9ffa1ad850d3fafc8da685a8551ef5e51","team_id":1000,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k1","teams":"+1","signature":null,"team_id":1000,"created_at":null},"output":null},{"input":{"keys":"k1","teams":"-1","signature":"v1.hog_flow.1736944631.00","team_id":-1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"","signature":"v1.HOG.1736944934.00","team_id":3,"created_at":"garbage"},"output":null},{"input":{"keys":",","teams":"0x1","signature":"v1.HOG.1736944633.00","team_id":1000,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":" ","teams":" * ","signature":"v1.hog_flow.0736944631.ab","team_id":2,"created_at":""},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1,","signature":"v1.a.b.1736944631.00","team_id":2,"created_at":""},"output":null},{"input":{"keys":",","teams":" ","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944633.00","team_id":1,"created_at":"Wed, 15 Jan 2025 12:38:11 GMT"},"output":null},{"input":{"keys":"","teams":"-1","signature":"v1.billed_src.1736944934.d22b88270f9c7d77cc45e0a3b36bc844a38182be4bfdd8353db4b65fcaf21c49","team_id":-1,"created_at":"1736944633250"},"output":null},{"input":{"keys":"","teams":" 1","signature":"v1.HOG.1736944332.00","team_id":3,"created_at":"1736944633250"},"output":null},{"input":{"keys":",","teams":" * ","signature":"v1..1736944631.00","team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"-1","signature":"v1.hog_flow.17369446310.00","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":" ","teams":"1","signature":"","team_id":1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1,k0","teams":"1,","signature":"v1.hog_flow. 1736944631.00","team_id":1,"created_at":"Wed, 15 Jan 2025 12:35:38 GMT"},"output":null},{"input":{"keys":"k1,k0","teams":"01","signature":null,"team_id":2,"created_at":"Wed, 15 Jan 2025 12:32:51 GMT"},"output":null},{"input":{"keys":"k1","teams":" 1","signature":".hog_flow.1736944631.ab","team_id":2,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k0,,k1","teams":"1","signature":"v1.hog_flow.1736944934.285be35fa33ef58ebf6094542f88c85624fb055146db026c7eb4c7ff1755cf07","team_id":1000,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1","teams":"0x1","signature":"","team_id":0,"created_at":""},"output":null},{"input":{"keys":" ","teams":"2 3","signature":".hog_flow.1736944631.ab","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k0,,k1","teams":"1e3","signature":"v1.hog_flow.1736944934.5d567e7f4d8c502c55855213098467b5e1c54478d252f85912ff3b4467b56f72","team_id":1000,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" ","teams":"1e3","signature":null,"team_id":-1,"created_at":"garbage"},"output":null},{"input":{"keys":" ","teams":"01","signature":"v1..","team_id":0,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k0,,k1","teams":"01","signature":"v1.hog_flow.1736944631\n.00","team_id":-1,"created_at":"Wed, 15 Jan 2025 12:37:38 GMT"},"output":null},{"input":{"keys":" ","teams":" ","signature":"v1.hog_flow.0736944631.ab","team_id":-1,"created_at":"garbage"},"output":null},{"input":{"keys":"","teams":"1.9","signature":"v1.constructor.1736944633.0c4d1d5c7f789c14a53e3ab1b58fcf8068612dde496a9afa64e146a72e6103ae","team_id":1000,"created_at":null},"output":null},{"input":{"keys":"k1","teams":"0x1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.90abfef0ac5b4f5c3732ab0b6f04a7b2dc33b3b415d4f2d2391d13fc475ef459.","team_id":1,"created_at":"Wed, 15 Jan 2025 12:37:23 GMT"},"output":null},{"input":{"keys":",","teams":"2 3","signature":"v1.hog_flow.1736944631.00","team_id":1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k1,k0","teams":"01","signature":"v1.constructor.1736944932.9b2c5283dc5a6b1dec12832021cd6b1de4bb8e5d4ab318f3bb8fab1e94f5431a.extra","team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k1,k0","teams":"1.9","signature":"v1.hog_flow.1736944333.8d4265275d7f5ed130e5604c32b8dc26a3b6de791a7adda143b2347327c7f942","team_id":3,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k1","teams":" 2,abc","signature":"v1.billed_src.1736944332.c4ac6fc8c25c2382d614971c37020376d2ef30e27e3ad044d31a832257186f20","team_id":3,"created_at":"Wed, 15 Jan 2025 12:39:00 GMT"},"output":null},{"input":{"keys":" ","teams":"01","signature":".hog_flow.1736944631.ab","team_id":2,"created_at":"garbage"},"output":null},{"input":{"keys":" k1 , k0 ","teams":" ","signature":"v1.a.b.1736944631.00","team_id":2,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1,k0","teams":"","signature":"v1.billed_src.1736944633.3f310930509dfe8fba1827711ecb962eae697be140250f2e0d63181357b7d57f","team_id":1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1","teams":"1,","signature":"v1.hog_flow. 1736944631.00","team_id":1,"created_at":"garbage"},"output":null},{"input":{"keys":",","teams":" 1","signature":".hog_flow.1736944631.ab","team_id":0,"created_at":"1736944633250"},"output":null},{"input":{"keys":" ","teams":"1e3","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944634.00","team_id":1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"","teams":"01","signature":"v1..1736944934.00","team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" k1 , k0 ","teams":" 1","signature":"v1.billed_src.1736944934.d22b88270f9c7d77cc45e0a3b36bc844a38182be4bfdd8353db4b65fcaf21c49.extra","team_id":-1,"created_at":""},"output":null},{"input":{"keys":" k1 , k0 ","teams":"-1","signature":"v1.hog_flow.1736944631.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1,k0","teams":"*","signature":"v1..1736944333.00","team_id":2,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":",","teams":"1.9","signature":"v1.constructor.1736944333.30de61e4253f396e87847521fc12352d659ef38bc4a721136776f5323cb6211b","team_id":0,"created_at":"garbage"},"output":null},{"input":{"keys":"","teams":" * ","signature":null,"team_id":1000,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":",","teams":"1e3","signature":"v1.a.b.1736944333.00.extra","team_id":1,"created_at":"Wed, 15 Jan 2025 12:42:00 GMT"},"output":null},{"input":{"keys":"k1,k0","teams":"0x1","signature":"v1..1736944631.00","team_id":2,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k1,k0","teams":"1,","signature":"garbage","team_id":3,"created_at":null},"output":null},{"input":{"keys":",","teams":"01","signature":"v1.hog_flow.1736944631.00","team_id":2,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":",","teams":" 1","signature":"v1.a.b.1736944333.00","team_id":3,"created_at":""},"output":null},{"input":{"keys":"k0,,k1","teams":"2 3","signature":"v1..","team_id":3,"created_at":"garbage"},"output":null},{"input":{"keys":" ","teams":"1","signature":"v1.HOG.1736944934.00","team_id":1000,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"","teams":"1","signature":"v1.hog_flow.1.73694463e9.00","team_id":1,"created_at":""},"output":null},{"input":{"keys":"k1","teams":"+1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.4eb38ae8214fc9f59a2d52bff71c080f50a15e67469b4e855ab69ebd9f10d3d6","team_id":2,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":",","teams":"-1","signature":"v1.HOG.1736944332.00","team_id":3,"created_at":""},"output":null},{"input":{"keys":"k1,k0","teams":"01","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944932.00","team_id":-1,"created_at":null},"output":null},{"input":{"keys":",","teams":" 2,abc","signature":"v1.hog_flow.1736944633.fe801d275761bb748ebaf4833194e8e46e8c4544e514ac6f3eb28db1d1805a42","team_id":-1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k0,,k1","teams":"2 3","signature":"v1.hog_flow.1736944934.285be35fa33ef58ebf6094542f88c85624fb055146db026c7eb4c7ff1755cf07.","team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"","teams":" 2,abc","signature":"v1..1736944333.00.extra","team_id":2,"created_at":"garbage"},"output":null},{"input":{"keys":" ","teams":"1,2","signature":null,"team_id":1000,"created_at":"1736944633250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1,2","signature":"v1.__proto__.1736944333.1691cdb201d7c293203302b4ea81ed9af448a9e488bf2dc0e5d09e19d767a397","team_id":1000,"created_at":"garbage"},"output":null},{"input":{"keys":" ","teams":"1","signature":"v1.HOG.1736944333.00","team_id":0,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k1","teams":"*","signature":"v1.billed_src.1736944932.fee7efc842778ebc566395c11003aeb95a1a0e6197d11d8d2da4d263e5c0f1b3","team_id":3,"created_at":"Wed, 15 Jan 2025 12:38:21 GMT"},"output":null},{"input":{"keys":",","teams":"1,","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.00","team_id":1,"created_at":null},"output":null},{"input":{"keys":"k1,k0","teams":"1,","signature":"v1.hog_flow.1736944332.2a716ea04e6ab9d5c3130d4c7169c091b46f0cba857122723e58cc104b272bfc","team_id":-1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1","teams":" * ","signature":"v1.hog_flow.1736944333.7ecf2a836223eb834cdac5892107e5c942deaa32d990775f63b9c6fd4f70cd39","team_id":1,"created_at":"garbage"},"output":null},{"input":{"keys":"k1","teams":"1.9","signature":"v1.hog_flow.1.73694463e9.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":",","teams":"1,2","signature":"v1.hog_flow.1736944631","team_id":3,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1,k0","teams":"1.9","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944634.00","team_id":0,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k1","teams":"1e3","signature":"v1.billed_src.1736944333.4b44e22e37e23d51a58dc900c2f915cfcfc81ddee02d0d177c3f0997593b0734","team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"","teams":" * ","signature":"v1.__proto__.1736944633.a1f205b018824e5666a6c24280e66387955ca950d2c447e6090db43a4ad6365b","team_id":0,"created_at":"garbage"},"output":null},{"input":{"keys":"k1,k0","teams":"*","signature":"v1.HOG.1736944631.00","team_id":0,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" k1 , k0 ","teams":" ","signature":"v1.HOG.1736944633.00","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1","teams":"2 3","signature":"v1.hog_flow.1736944631","team_id":1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" ","teams":"*","signature":"v1.billed_src.1736944332.2cdc94b17ed07b499875802eaf654df64d524321fff211840051fa961563f7b5","team_id":3,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1","teams":"1.9","signature":"v1..","team_id":-1,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k1","teams":"*","signature":"v1.billed_src.1736944932.df759da357c5e8d69a786c5f67e3f20e47bac2b64da0bb3763af4414a81435cf","team_id":1000,"created_at":""},"output":null},{"input":{"keys":",","teams":"+1","signature":"v1.hog_flow.17369446310.00","team_id":2,"created_at":"garbage"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1e3","signature":null,"team_id":-1,"created_at":"Wed, 15 Jan 2025 12:39:25 GMT"},"output":null},{"input":{"keys":"k0,,k1","teams":"+1","signature":"v1.a.b.1736944633.00","team_id":0,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":",","teams":"01","signature":"v1.hog_flow.1736944631.00","team_id":-1,"created_at":null},"output":null},{"input":{"keys":"","teams":"01","signature":"v1.HOG.1736944631.00","team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k0,,k1","teams":"+1","signature":"v1..1736944333.00","team_id":0,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k1","teams":"1.9","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1","teams":"-1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944633.00","team_id":0,"created_at":""},"output":null},{"input":{"keys":"k0,,k1","teams":" 1","signature":"v1.constructor.1736944333.b794f5897b8c861be378116bc6a692064fa89aebff6f09c91816dd36baba3d46","team_id":2,"created_at":null},"output":null},{"input":{"keys":" k1 , k0 ","teams":" * ","signature":"v1.constructor.1736944932.f7644281655879ac6bd1ba3c65ef7622544e9b097503f5ff07ba8058793a5b9d","team_id":1000,"created_at":"1736944633250"},"output":null},{"input":{"keys":" ","teams":"01","signature":"","team_id":-1,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k1","teams":"0x1","signature":"v1.hog_flow.1736944631\n.00","team_id":3,"created_at":"garbage"},"output":null},{"input":{"keys":"k1","teams":"1,","signature":"v1.billed_src.1736944932.9368b9e8641d5f6bbe2047732efdf263ac94f604c290b0e6c8ffcbda70cce6ea","team_id":1,"created_at":null},"output":null},{"input":{"keys":"k1","teams":"1,2","signature":"v1.hog_flow.1736944634.ea7565873b3d27a6812a9daeab557abb68b9f820caf83dcfc341e0c4f55f7800","team_id":2,"created_at":"garbage"},"output":null},{"input":{"keys":"k1","teams":"1,","signature":null,"team_id":3,"created_at":null},"output":null},{"input":{"keys":"","teams":"-1","signature":"v1.hog_flow.1736944631\n.00","team_id":0,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"+1","signature":"v1.__proto__.1736944932.c36c541c0edcc77d91aeb3c59a03c039f80daa7ae42d3019e84367ae3334af15","team_id":1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k0,,k1","teams":"1,2","signature":"","team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1,k0","teams":"*","signature":"v1.hog_flow.1736944333.09b407ff9c13d11ed25cdb225f9a37ebddb5b9cec28bae168ff2c6d22e8eb927x","team_id":1000,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":",","teams":" ","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.5cadb4952d08a45499ab91e2d93645f57cdf2f6de18815468b11c575ed68ef50","team_id":1000,"created_at":null},"output":null},{"input":{"keys":"k1,k0","teams":" ","signature":"v1.hog_flow.1736944631.00","team_id":1,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k1,k0","teams":"1,2","signature":"","team_id":0,"created_at":"1736944633250"},"output":null},{"input":{"keys":"","teams":"+1","signature":"v1..","team_id":2,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k0,,k1","teams":" ","signature":"v1.constructor.1736944332.be85bba62191364530f93be615e914a4c1b23a9ee9f862ab0aa3a7e2cc7d0e3a","team_id":2,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k1","teams":"","signature":"v1.billed_src.1736944631.42bd1b692099f18d56305b0a1b99cef5016a2003fe7600d2fc7451da917cb232.extra","team_id":-1,"created_at":null},"output":null},{"input":{"keys":",","teams":"*","signature":"v1..1736944934.00","team_id":2,"created_at":null},"output":null},{"input":{"keys":"k1,k0","teams":" ","signature":"v1.constructor.1736944934.32d29b98db24c99b4737cac929ea0d018221de412de070272bcefd98770ad5eax","team_id":2,"created_at":""},"output":null},{"input":{"keys":"k1,k0","teams":"01","signature":"v1.__proto__.1736944633.4adc6412d9173b7aec9151ee3539c62f38f96a4184c022fc59e2206da0c1056c.","team_id":0,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k0,,k1","teams":"1,","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":" ","teams":"1,","signature":"v1.hog_flow. 1736944631.00","team_id":0,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":",","teams":" 2,abc","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.00","team_id":1000,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1","teams":"1,","signature":".hog_flow.1736944631.ab","team_id":-1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"","teams":" 2,abc","signature":"v1.constructor.1736944333.41b25488987bf2e346327373e54f20e437479fea2f074d7ee294d24241686403","team_id":1,"created_at":"Wed, 15 Jan 2025 12:39:04 GMT"},"output":null},{"input":{"keys":"k0,,k1","teams":" 2,abc","signature":"v1.a.b.1736944631.00.","team_id":1000,"created_at":"garbage"},"output":null},{"input":{"keys":",","teams":"1.9","signature":"v1..","team_id":1,"created_at":"Wed, 15 Jan 2025 12:40:49 GMT"},"output":null},{"input":{"keys":"k0,,k1","teams":"","signature":"v1.constructor.1736944631.57100ec6ac91f0386f51178c20702caab4ae6c788c4ce2163dc912151ee8d3db.","team_id":0,"created_at":null},"output":null},{"input":{"keys":",","teams":" ","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.03211ec3debedf92e892e64ade45fec4642e315248a36e299d9a56a2345eec6f","team_id":1,"created_at":"garbage"},"output":null},{"input":{"keys":",","teams":"2 3","signature":"v1.constructor.1736944633.d8cc07e804ce009b386713ed7a22922e1b64a0e79e0f871bb81aab6f416f5d3d","team_id":-1,"created_at":null},"output":null},{"input":{"keys":",","teams":" 2,abc","signature":"v1.hog_flow.1.73694463e9.00","team_id":1,"created_at":"1736944633250"},"output":null},{"input":{"keys":"","teams":"1","signature":"v1.hog_flow.1736944932.6a60d62c732f25fbbb83940f819a22b874ea39fa652c2090fd710bab46091d25.","team_id":3,"created_at":"garbage"},"output":null},{"input":{"keys":"","teams":" 1","signature":"v1.__proto__.1736944633.0bba993cddab93486f7edcee5b0d6aa107228c35e359ebe9c3b80b2433d1d34b","team_id":0,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1","teams":"01","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944631.d1fc4c9fc6dd4ee41774725ed515104e05d623710bb2443a633a29e408b37a0a","team_id":1000,"created_at":"garbage"},"output":null},{"input":{"keys":",","teams":"*","signature":"v1.constructor.1736944934.32d29b98db24c99b4737cac929ea0d018221de412de070272bcefd98770ad5eax","team_id":2,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944633.00","team_id":0,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" ","teams":" 1","signature":"v1.hog_flow. 1736944631.00","team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"","teams":"+1","signature":"v1.hog_flow.1736944631\n.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":",","teams":"0x1","signature":"v1.constructor.1736944633.d8cc07e804ce009b386713ed7a22922e1b64a0e79e0f871bb81aab6f416f5d3d","team_id":-1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":",","teams":"01","signature":"v1.hog_flow.1736944633.e9f1e0a260389b44874c41e8006fa3dd033b1a81bfa3a72b558e2d1f66fea115","team_id":3,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k0,,k1","teams":"*","signature":"v1.hog_flow.1736944631.00","team_id":1,"created_at":""},"output":null},{"input":{"keys":" ","teams":"1e3","signature":"v1.constructor.1736944934.597a8dff44f39f468d40c6a913b7de9dc13198d57cb033b0dd1bffe684ca3334","team_id":1000,"created_at":"garbage"},"output":null},{"input":{"keys":" ","teams":"1,","signature":"v1.hog_flow.1736944631","team_id":1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k0,,k1","teams":" ","signature":"v1.hog_flow.1736944631.00","team_id":1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1","teams":" 2,abc","signature":"v1.hog_flow.0736944631.ab","team_id":1000,"created_at":"Wed, 15 Jan 2025 12:38:04 GMT"},"output":null},{"input":{"keys":" ","teams":"01","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944932.6d26cecdae4bb0cf5abfa1aec7d94d76fb4a2a5d5f52170acdb95e40057e8f6c","team_id":1000,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":" ","teams":"2 3","signature":"v1.hog_flow.1736944631.00","team_id":1,"created_at":""},"output":null},{"input":{"keys":"k1,k0","teams":"1.9","signature":"","team_id":-1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1","teams":"","signature":"v1.hog_flow.17369446310.00","team_id":0,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"+1","signature":"v1.hog_flow.1736944631\n.00","team_id":1000,"created_at":"garbage"},"output":null},{"input":{"keys":" ","teams":"1e3","signature":"v1.constructor.1736944634.39656ec7bd077719c099dce8cbc41344e9ac38b26932a44d9527cea1ffb1c4e4","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1","teams":" 1","signature":"garbage","team_id":3,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" ","teams":"0x1","signature":"v1.hog_flow.1736944332.d10b6aebc6abd895a6cf4254a24ad1626d47cb637107082f9de330ac3eabb83b","team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"","teams":"01","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.00","team_id":-1,"created_at":"Wed, 15 Jan 2025 12:36:17 GMT"},"output":null},{"input":{"keys":"","teams":"1,2","signature":"v1.hog_flow.1736944633.3a525b66d6713bd3f6c6631ab917fe9200d384c5722fd9adaa3daf7817659a05","team_id":0,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":",","teams":"","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944634.00","team_id":-1,"created_at":null},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.a74553053e711f6e9ea6e77e2c969f75a20fb79a4870a426eb1cb55e25dd8a3c","team_id":0,"created_at":"1736944633250"},"output":null},{"input":{"keys":"","teams":"1.9","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.00","team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" ","teams":"1e3","signature":"v1.hog_flow.1736944631\n.00","team_id":0,"created_at":""},"output":null},{"input":{"keys":" ","teams":"01","signature":"v1.hog_flow.1736944631.00","team_id":3,"created_at":"1736944633250"},"output":null},{"input":{"keys":"","teams":"-1","signature":"v1.constructor.1736944633.5b9a4287a6712bc85cad2872b3ee403f742bda5154eefad8c493fd3f53f3666a","team_id":2,"created_at":null},"output":null},{"input":{"keys":"k1","teams":"1.9","signature":"v1.hog_flow.1.73694463e9.00","team_id":1,"created_at":null},"output":null},{"input":{"keys":"k1,k0","teams":"2 3","signature":"v1.hog_flow.1.73694463e9.00","team_id":3,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1,k0","teams":" ","signature":"v1.hog_flow.1736944634.0ce8a3f40d90ee8f2c2cf2092cc35ec745ac991f999792660d0be35c0bad57c0.extra","team_id":0,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1","teams":"2 3","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944633.00","team_id":3,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"","teams":"1,2","signature":"v1.hog_flow.1736944633.ce0929d59cd02e65f461d6be8b95dadafee835f504a31019bf0321a079044883","team_id":0,"created_at":"garbage"},"output":null},{"input":{"keys":"","teams":" 2,abc","signature":"v1.constructor.1736944332.911f54c1e143e101cd267cadd1f5de04eff2e1e015f5843e415816bf390f415dx","team_id":1000,"created_at":"Wed, 15 Jan 2025 12:37:34 GMT"},"output":null},{"input":{"keys":"k1,k0","teams":" ","signature":"v1.HOG.1736944932.00","team_id":2,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":",","teams":"1e3","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944631.b0acd08f953a01424218439afae54b4b53f54a454cede18f5f00869438cf0548","team_id":0,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k1","teams":"0x1","signature":"v1.hog_flow.0736944631.ab","team_id":0,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1","teams":"+1","signature":"v1.a.b.1736944333.00","team_id":2,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"","teams":"1,","signature":"v1.constructor.1736944934.55914a3cc6043a7c18711dda7fa9cd482cbcdfa53bd7ca25277105c13eedcfa2.extra","team_id":0,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"+1","signature":"v1.__proto__.1736944333.d8a256add22160339af9a766e2dad8580f904d306188508044ec1daeef338d60","team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":",","teams":" * ","signature":"v1.hog_flow.0736944631.ab","team_id":2,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":",","teams":" * ","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944633.00","team_id":1,"created_at":"garbage"},"output":null},{"input":{"keys":"k1,k0","teams":" ","signature":"v1.hog_flow.1736944934.a1357fe4b4dded1ce0e2a386f0d8cde6c2123ced605aae9464492ae0aa4ee525","team_id":0,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"","teams":"","signature":"v1..1736944333.00","team_id":0,"created_at":"1736944633250"},"output":null},{"input":{"keys":"","teams":"1,","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944634.f7bd0a784d85735ff197d74fc021008011bd32736e8e110da36d4624b63243d3","team_id":0,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"","teams":"1,","signature":"v1.hog_flow.1736944631.00","team_id":1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" k1 , k0 ","teams":" 2,abc","signature":"v1.HOG.1736944932.00","team_id":2,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1,2","signature":"v1.hog_flow.1736944631","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k0,,k1","teams":" ","signature":"v1.constructor.1736944332.9b55356ce46780ef650e833762923b35d82f1b52fe5c358c67697213b1b42d4b","team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k0,,k1","teams":"1,2","signature":"v1.billed_src.1736944631.e31ade0a2e2bf60c99095b7361f571d093b02070cf774b84aafad58d437537bb.extra","team_id":1000,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"+1","signature":"v1.HOG.1736944932.00","team_id":-1,"created_at":"garbage"},"output":null},{"input":{"keys":"","teams":"1,2","signature":"v1.HOG.1736944934.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1","signature":"v1.constructor.1736944634.bfc93541a5843298cea2905330e239e1711f3d176b0e1ece24f557cf730bc8c1","team_id":3,"created_at":""},"output":null},{"input":{"keys":" k1 , k0 ","teams":"0x1","signature":"v1.billed_src.1736944633.c01a5a9ff046dda9bbd856f3f5eea0546ad2cf2e239764cd42f854ad69558c4f","team_id":1,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k0,,k1","teams":" 1","signature":"v1.a.b.1736944333.00","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"","teams":"1,","signature":"v1..1736944633.00","team_id":3,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"","teams":"1e3","signature":"v1.HOG.1736944332.00","team_id":3,"created_at":"Wed, 15 Jan 2025 12:41:43 GMT"},"output":null},{"input":{"keys":"k1","teams":"0x1","signature":"v1..1736944934.00","team_id":0,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1","teams":" * ","signature":"v1.hog_flow.1736944634.fb2ecf753d1f3ec4fc0b3191191a7ea98a892588b8192b300d0596ca8ad7a45d","team_id":3,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"2 3","signature":"v1.hog_flow.1736944631\n.00","team_id":2,"created_at":"1736944633250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"2 3","signature":"v1.hog_flow.17369446310.00","team_id":3,"created_at":null},"output":null},{"input":{"keys":" k1 , k0 ","teams":" ","signature":"v1.a.b.1736944631.00","team_id":3,"created_at":""},"output":null},{"input":{"keys":",","teams":"1","signature":"v1..","team_id":2,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k0,,k1","teams":" 2,abc","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.fd594c13ac2ea2232dae6b3f56f9a2228864dc3c69e9556730f0c0f0560f636a","team_id":2,"created_at":"garbage"},"output":null},{"input":{"keys":" k1 , k0 ","teams":" 1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944633.8ab1ce785a0730dcbeb525d977114c0aef5d07d59bbc6e02acf71e020276ea68","team_id":2,"created_at":"garbage"},"output":null},{"input":{"keys":"k1","teams":"0x1","signature":"v1.hog_flow.1736944631.00","team_id":0,"created_at":""},"output":null},{"input":{"keys":" k1 , k0 ","teams":"01","signature":"v1.hog_flow.1736944631","team_id":0,"created_at":"garbage"},"output":null},{"input":{"keys":"k1,k0","teams":"-1","signature":"v1.hog_flow.1736944631.00","team_id":2,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" ","teams":"01","signature":"v1..1736944934.00","team_id":1000,"created_at":"Wed, 15 Jan 2025 12:39:16 GMT"},"output":null},{"input":{"keys":"k1","teams":"+1","signature":"v1.billed_src.1736944932.4f3f8a84003004fd604e5d5a101039eb908c3469dbfa1939ace233e87e00b29c","team_id":-1,"created_at":"garbage"},"output":null},{"input":{"keys":"","teams":" 1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.00","team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" ","teams":"+1","signature":"v1.constructor.1736944333.481d68c75215e5a90d06aea101070c46f94e0d810c6f3ed01b597c78b6e77322","team_id":2,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" ","teams":"1,2","signature":".hog_flow.1736944631.ab","team_id":3,"created_at":"Wed, 15 Jan 2025 12:32:40 GMT"},"output":null},{"input":{"keys":"","teams":"","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944631.85b72559c3b8cf1f72accd5432eedcb5c57fb685105b6ed2d460be8b6caa44d7","team_id":1,"created_at":"Wed, 15 Jan 2025 12:36:04 GMT"},"output":null},{"input":{"keys":"k0,,k1","teams":"1,2","signature":"v1.HOG.1736944333.00","team_id":0,"created_at":null},"output":null},{"input":{"keys":"k1,k0","teams":" 1","signature":"","team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.00","team_id":0,"created_at":null},"output":null},{"input":{"keys":"","teams":" ","signature":"v1.__proto__.1736944934.ee5a67f5a8513a9c529c94c3134882bb8d744051f5113cc4d0fd727dd5b31229","team_id":1,"created_at":null},"output":null},{"input":{"keys":",","teams":"1,","signature":"v1.hog_flow.17369446310.00","team_id":3,"created_at":"Wed, 15 Jan 2025 12:33:44 GMT"},"output":null},{"input":{"keys":"","teams":"1","signature":null,"team_id":3,"created_at":null},"output":null},{"input":{"keys":"","teams":"1,2","signature":"v1.hog_flow.17369446310.00","team_id":2,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":",","teams":"1,","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.00x","team_id":3,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1","teams":"+1","signature":"v1.hog_flow.1736944934.ab7ecd216cc54d94ba97a962dada0f13107946636115dcbbab436fbebd017eaf","team_id":1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"","signature":"v1.hog_flow.1736944631.00","team_id":-1,"created_at":""},"output":null},{"input":{"keys":"k1","teams":"1.9","signature":"v1.constructor.1736944934.55914a3cc6043a7c18711dda7fa9cd482cbcdfa53bd7ca25277105c13eedcfa2","team_id":0,"created_at":""},"output":null},{"input":{"keys":"k1,k0","teams":" 2,abc","signature":"v1.constructor.1736944934.05540523f44381959b8b923119b27613418ccd67c1ba2d9d32eca0bfc043fdf6.extra","team_id":1000,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1","teams":"1.9","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944633.08188c014f6925d1938b5ed5bf6e04ddd5abbda6c1bc31945748736afdb2ec4d","team_id":2,"created_at":"Wed, 15 Jan 2025 12:42:19 GMT"},"output":null},{"input":{"keys":"","teams":" 2,abc","signature":"v1.constructor.1736944333.109a563f29ca0ae84edeef825ced3fa4bd5c8eb36dcdec320eedb8914c40d81b","team_id":1000,"created_at":"1736944633250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":" 1","signature":"v1.billed_src.1736944631.92e8e7f1008cddc80ca4ea9298efec5a7fd82c2e5a4d696318b917d738ee6cf1x","team_id":3,"created_at":null},"output":null},{"input":{"keys":"k0,,k1","teams":"2 3","signature":"v1.__proto__.1736944932.94ec19358f9f4785a136eec2e830c0349a38e87c47d8df4531cba26c3f2a436c","team_id":1000,"created_at":null},"output":null},{"input":{"keys":" k1 , k0 ","teams":"","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944932.486187dc533c043c44a2b1e2da45688bb321f1fa41f2170fd19d379994c66589","team_id":2,"created_at":"garbage"},"output":null},{"input":{"keys":"","teams":"1e3","signature":"garbage","team_id":1000,"created_at":""},"output":null},{"input":{"keys":"k1,k0","teams":" 2,abc","signature":"v1.hog_flow.17369446310.00","team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"","teams":"-1","signature":"v1.hog_flow.17369446310.00","team_id":2,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k1,k0","teams":"2 3","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.00","team_id":1000,"created_at":"Wed, 15 Jan 2025 12:41:36 GMT"},"output":null},{"input":{"keys":"k0,,k1","teams":" 2,abc","signature":"v1.hog_flow. 1736944631.00","team_id":-1,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k1,k0","teams":"","signature":"v1..","team_id":3,"created_at":null},"output":null},{"input":{"keys":"","teams":"0x1","signature":"v1.billed_src.1736944634.4cf7b68cc1023a6ea4eadbb48d4313c87c197767eaec2cc9844a90ef8eb72954","team_id":3,"created_at":"1736944633250"},"output":null},{"input":{"keys":",","teams":"1,","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.e8801e85c6188730e96f6d24e9ef6b32f387af259d983701284dd59e5e7d300e.","team_id":1000,"created_at":"garbage"},"output":null},{"input":{"keys":"k1,k0","teams":"1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944932.6d26cecdae4bb0cf5abfa1aec7d94d76fb4a2a5d5f52170acdb95e40057e8f6c","team_id":1000,"created_at":""},"output":null},{"input":{"keys":" ","teams":" ","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.00","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"","teams":" 1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944631.f84e6ed1605a735ce72d613212ca83cdc0408086c222ee80d189c90b71a5d6a9","team_id":1000,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1,k0","teams":"","signature":"v1.hog_flow. 1736944631.00","team_id":1000,"created_at":""},"output":null},{"input":{"keys":"k0,,k1","teams":"1","signature":"v1..1736944633.00","team_id":1000,"created_at":"1736944633250"},"output":null},{"input":{"keys":" ","teams":" * ","signature":"v1.constructor.1736944932.655163ddb7f73cfbf66f9e4b0989af3d91821e907fb40ce73cf4ce98219381a2","team_id":3,"created_at":null},"output":null},{"input":{"keys":"k1,k0","teams":" * ","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944634.00","team_id":1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"","teams":"1,2","signature":null,"team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1,k0","teams":" 2,abc","signature":null,"team_id":1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":",","teams":"0x1","signature":"v1.__proto__.1736944634.b2ea2328a7c697fa1db595efea408d34bfaef64ed4bfba34522d6dbaf6e90291","team_id":0,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1,k0","teams":" 1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.00","team_id":0,"created_at":"Wed, 15 Jan 2025 12:39:59 GMT"},"output":null},{"input":{"keys":"k1,k0","teams":" ","signature":"v1.hog_flow.1.73694463e9.00","team_id":1000,"created_at":"Wed, 15 Jan 2025 12:34:17 GMT"},"output":null},{"input":{"keys":" ","teams":" * ","signature":"v1.hog_flow.1736944631.00","team_id":-1,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k0,,k1","teams":"01","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944932.00","team_id":2,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1,k0","teams":"1.9","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944631.8c15e88c7efded5f0e964248e0820b69ce43129dd442b12543e239716631cde4","team_id":1,"created_at":""},"output":null},{"input":{"keys":"k1,k0","teams":"-1","signature":"v1.constructor.1736944932.2cfde7ab7d21f29506de4cf7a527722a50e2bd82a6288cf536f4eac023d2108b","team_id":2,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":" ","teams":"*","signature":"v1.hog_flow.1736944631.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"","teams":"*","signature":"v1.hog_flow.1736944631.d31be480b42c789ce111e8fb176c1f0ff0398d476191ba868c7dcc7b88d5c630","team_id":2,"created_at":"1736944633250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"01","signature":"v1.hog_flow.1736944631","team_id":2,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":",","teams":" 1","signature":"v1.hog_flow.1.73694463e9.00","team_id":0,"created_at":""},"output":null},{"input":{"keys":"k0,,k1","teams":"1e3","signature":"v1.billed_src.1736944932.c3d0bbfacea089763e562c01aa297050cb6960e7afdfbed398bd6a12f335b571","team_id":2,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k0,,k1","teams":"0x1","signature":"v1.hog_flow. 1736944631.00","team_id":1,"created_at":"1736944633250"},"output":null},{"input":{"keys":" ","teams":"2 3","signature":"v1.hog_flow.1.73694463e9.00","team_id":1000,"created_at":"garbage"},"output":null},{"input":{"keys":"","teams":"-1","signature":"v1.hog_flow.0736944631.ab","team_id":-1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1,k0","teams":"+1","signature":"v1.__proto__.1736944932.278335f0c1483ead2256eecc02d56508c0efb74383a89cdae6b064984115510c","team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1,k0","teams":"01","signature":".hog_flow.1736944631.ab","team_id":1000,"created_at":null},"output":null},{"input":{"keys":"k1","teams":" ","signature":"v1.hog_flow.1736944631\n.00","team_id":-1,"created_at":"garbage"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"+1","signature":"v1.hog_flow.1736944631","team_id":1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":" ","teams":"1e3","signature":"v1.hog_flow.1736944631.00","team_id":1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" ","teams":"","signature":"v1.__proto__.1736944934.53c68e6870a1e06048ed0936dedefbf40e882dcb4f79d7fdf94d62b9cc7d8499","team_id":1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"","signature":"v1.hog_flow.0736944631.ab","team_id":-1,"created_at":"garbage"},"output":null},{"input":{"keys":",","teams":"1,2","signature":"v1..1736944633.00","team_id":-1,"created_at":"Wed, 15 Jan 2025 12:42:43 GMT"},"output":null},{"input":{"keys":"k1,k0","teams":" 2,abc","signature":"v1.__proto__.1736944333.601667459fd6183b1bdfb61b862841b316732149c117d30324e45d81aecfbc94","team_id":3,"created_at":null},"output":null},{"input":{"keys":"k0,,k1","teams":"+1","signature":"v1.HOG.1736944934.00.extra","team_id":1000,"created_at":"garbage"},"output":null},{"input":{"keys":"k1,k0","teams":"1,","signature":"v1.hog_flow.1736944634.ba8c3cc980cce7d27e4c420d4226dca4fae15b1d8fdd7a9bc46693c9a6b17fc7","team_id":0,"created_at":null},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1,2","signature":"v1.hog_flow.17369446310.00","team_id":2,"created_at":"garbage"},"output":null},{"input":{"keys":"","teams":"1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.450913fc2a3260213795c7fe6da29549f0d65cd6b6901135f59f7976b0bd9ce3","team_id":-1,"created_at":""},"output":null},{"input":{"keys":" ","teams":"*","signature":null,"team_id":3,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k0,,k1","teams":"2 3","signature":"v1.hog_flow.1736944631\n.00","team_id":1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1","teams":"","signature":"v1.constructor.1736944633.f29bbeeae872e4b629394f8c344c9c8a6d84a66af758f5f6a65c05591f15e054","team_id":1,"created_at":"1736944633250"},"output":null},{"input":{"keys":",","teams":"1e3","signature":"v1.constructor.1736944631.af12db8930f8f21b5689f0fc9eae349babe2f519f94aaa3cc2ba1bb2faf19056","team_id":2,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"","teams":"","signature":"v1.a.b.1736944332.00","team_id":1000,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k1,k0","teams":"1,","signature":"v1.HOG.1736944932.00","team_id":-1,"created_at":null},"output":null},{"input":{"keys":"k0,,k1","teams":"01","signature":"v1.hog_flow.1736944631.00","team_id":1000,"created_at":"Wed, 15 Jan 2025 12:37:58 GMT"},"output":null},{"input":{"keys":" k1 , k0 ","teams":" 1","signature":"","team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" ","teams":"1","signature":"v1.constructor.1736944333.41b25488987bf2e346327373e54f20e437479fea2f074d7ee294d24241686403.extra","team_id":1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1","teams":" 2,abc","signature":"v1..1736944633.00","team_id":0,"created_at":""},"output":null},{"input":{"keys":"k1,k0","teams":"","signature":"v1.hog_flow.1736944631.00","team_id":0,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" ","teams":" 1","signature":"v1.hog_flow.1736944631.00","team_id":3,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1,k0","teams":" 2,abc","signature":"v1.hog_flow.1736944633.3a525b66d6713bd3f6c6631ab917fe9200d384c5722fd9adaa3daf7817659a05","team_id":0,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":",","teams":"1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.00","team_id":1000,"created_at":"Wed, 15 Jan 2025 12:34:10 GMT"},"output":null},{"input":{"keys":" ","teams":" * ","signature":"v1.__proto__.1736944633.0bba993cddab93486f7edcee5b0d6aa107228c35e359ebe9c3b80b2433d1d34b","team_id":0,"created_at":"Wed, 15 Jan 2025 12:36:21 GMT"},"output":null},{"input":{"keys":" ","teams":" 1","signature":".hog_flow.1736944631.ab","team_id":2,"created_at":""},"output":null},{"input":{"keys":"k1,k0","teams":"1,","signature":"v1..1736944934.00","team_id":2,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"","teams":"1.9","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944633.b02033ee292f36f02c5fbe70038d9af45e806f759616cc320ff252f89bbeabce","team_id":-1,"created_at":"garbage"},"output":null},{"input":{"keys":"k1","teams":" ","signature":"garbage","team_id":3,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1,2","signature":"v1.hog_flow. 1736944631.00","team_id":0,"created_at":"1736944633250"},"output":null},{"input":{"keys":"","teams":"1","signature":"v1..1736944333.00","team_id":-1,"created_at":""},"output":null},{"input":{"keys":"k0,,k1","teams":"1,","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.bff39e16ad9d279be25872d3bcdbf36b40dda312b6b788ed0295328e01838fa0","team_id":3,"created_at":""},"output":null},{"input":{"keys":"","teams":"1,","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944633.b02033ee292f36f02c5fbe70038d9af45e806f759616cc320ff252f89bbeabce","team_id":-1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k0,,k1","teams":"1,","signature":"v1.hog_flow.1736944631\n.00","team_id":-1,"created_at":"Wed, 15 Jan 2025 12:39:37 GMT"},"output":null},{"input":{"keys":" ","teams":" * ","signature":"","team_id":-1,"created_at":"1736944633250"},"output":null},{"input":{"keys":" ","teams":" * ","signature":"v1.hog_flow.1736944631.00","team_id":1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1","teams":"+1","signature":"v1.hog_flow.0736944631.ab","team_id":1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" ","teams":"-1","signature":"v1.hog_flow.1736944932.e5a92832ad5eb083569c18067cea58fcff7a21d5c0a070b093ea5d92ee586394","team_id":3,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" k1 , k0 ","teams":" 1","signature":"v1..1736944633.00","team_id":0,"created_at":"garbage"},"output":null},{"input":{"keys":"k1,k0","teams":"2 3","signature":"v1.billed_src.1736944634.5c85c49371b740c9e9cc472e5777b107a99862ae69bec50865cbabbd72371853","team_id":1,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" ","teams":" ","signature":"v1.hog_flow. 1736944631.00","team_id":2,"created_at":""},"output":null},{"input":{"keys":"k1","teams":" * ","signature":"v1.HOG.1736944332.00","team_id":2,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"01","signature":".hog_flow.1736944631.ab","team_id":0,"created_at":null},"output":null},{"input":{"keys":"k1","teams":"0x1","signature":"v1.hog_flow.1736944631","team_id":-1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"","teams":"01","signature":"v1.billed_src.1736944333.09ba9c784a7787259c4679c10c5f7ce665f29655cc5f936ae3c5019eafe77668","team_id":0,"created_at":"1736944633250"},"output":null},{"input":{"keys":"","teams":"0x1","signature":"v1.constructor.1736944934.597a8dff44f39f468d40c6a913b7de9dc13198d57cb033b0dd1bffe684ca3334","team_id":1000,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1,k0","teams":"1e3","signature":"v1.HOG.1736944333.00","team_id":1,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k1,k0","teams":"2 3","signature":"v1.hog_flow.1736944631.00","team_id":-1,"created_at":"1736944633250"},"output":null},{"input":{"keys":",","teams":"","signature":"v1.constructor.1736944934.0f6fcb19656a6e05191b5484388211cfcdef50db6ec93718b3655795adef29c4","team_id":1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"","teams":"*","signature":"v1.hog_flow.0736944631.ab","team_id":2,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":" ","teams":"1,2","signature":"v1..1736944333.00","team_id":2,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k1","teams":"1","signature":"v1.hog_flow.17369446310.00","team_id":2,"created_at":null},"output":null},{"input":{"keys":"k1","teams":"1.9","signature":"v1..","team_id":3,"created_at":""},"output":null},{"input":{"keys":"k1,k0","teams":"1","signature":"v1.HOG.1736944932.00","team_id":1000,"created_at":"Wed, 15 Jan 2025 12:32:00 GMT"},"output":null},{"input":{"keys":",","teams":"1.9","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.2c522f28c212a199a564e2f5265f138d99f9e955ef9bc25d9427291484b64bf2","team_id":-1,"created_at":"1736944633250"},"output":null},{"input":{"keys":",","teams":"*","signature":"v1.hog_flow.1736944631","team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" ","teams":" 1","signature":"v1.hog_flow.1736944631.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k1","teams":"0x1","signature":"v1.hog_flow.1.73694463e9.00","team_id":3,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1","teams":"1","signature":"","team_id":2,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"","teams":"2 3","signature":"v1.HOG.1736944633.00","team_id":1000,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":",","teams":" * ","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944333.957d43d5106d54c5b30efdb1eb98e9b9d15723bf17ac80ecc80b8d4c5e3ce1c9","team_id":1000,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":",","teams":"*","signature":"v1.hog_flow. 1736944631.00","team_id":0,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1","teams":"-1","signature":"","team_id":1000,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":"k1,k0","teams":"1,","signature":"v1.HOG.1736944333.00","team_id":1,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"","teams":" ","signature":"v1.HOG.1736944932.00","team_id":1000,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"+1","signature":null,"team_id":0,"created_at":null},"output":null},{"input":{"keys":"k0,,k1","teams":"*","signature":"v1.billed_src.1736944633.8e0149899443471ce1793f28f4e1392d84b4d3b7d6bdf6ea13749a53e17a5bd2","team_id":1000,"created_at":""},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1.9","signature":"v1.hog_flow.1736944631","team_id":3,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1,k0","teams":" 2,abc","signature":"v1.hog_flow.1.73694463e9.00","team_id":2,"created_at":"Wed, 15 Jan 2025 12:42:01 GMT"},"output":null},{"input":{"keys":"","teams":"1.9","signature":"v1.hog_flow.0736944631.ab","team_id":-1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k0,,k1","teams":"*","signature":"v1.a.b.1736944633.00","team_id":0,"created_at":null},"output":null},{"input":{"keys":"k1,k0","teams":"0x1","signature":"v1..1736944631.00x","team_id":-1,"created_at":"2025-01-15T12:37:13.250Z"},"output":null},{"input":{"keys":",","teams":"1,","signature":"garbage","team_id":0,"created_at":"2025-01-15 12:37:13"},"output":null},{"input":{"keys":"k1","teams":" 1","signature":"garbage","team_id":-1,"created_at":"Wed, 15 Jan 2025 12:39:20 GMT"},"output":null},{"input":{"keys":",","teams":"0x1","signature":"v1.constructor.1736944333.f4e56df3c4d9a32117c6af71439999ceb975f20440101efeeebdf93b3199f3ec","team_id":-1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1e3","signature":"v1.hog_flow.0736944631.ab","team_id":0,"created_at":""},"output":null},{"input":{"keys":"k1,k0","teams":"1.9","signature":"v1.__proto__.1736944634.acd3176ef328bd33f7d8f797fbb4d6a47f8bf3cee9fd6bdd57f3e13c580004c5x","team_id":1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1,2","signature":null,"team_id":3,"created_at":""},"output":null},{"input":{"keys":",","teams":" * ","signature":"v1.hog_flow. 1736944631.00","team_id":2,"created_at":"garbage"},"output":null},{"input":{"keys":" k1 , k0 ","teams":" ","signature":"v1.constructor.1736944634.57a1eff2611373cdf40418f489ce3b2bea9b1bed6ddc8e043b4616ce8a003814","team_id":1000,"created_at":""},"output":null},{"input":{"keys":" k1 , k0 ","teams":"*","signature":"v1..","team_id":1000,"created_at":""},"output":null},{"input":{"keys":"k1,k0","teams":"1,","signature":"v1.hog_flow.1.73694463e9.00","team_id":1,"created_at":null},"output":null},{"input":{"keys":" ","teams":"-1","signature":"v1.hog_flow.1736944934.e3a3ca5fa0f2dbce113296416a2bd1aecaaa467d8a5b068453c6594efadf229c","team_id":3,"created_at":"Wed, 15 Jan 2025 12:40:28 GMT"},"output":null},{"input":{"keys":"k1","teams":"1.9","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944934.a74553053e711f6e9ea6e77e2c969f75a20fb79a4870a426eb1cb55e25dd8a3c","team_id":0,"created_at":"garbage"},"output":null},{"input":{"keys":"k1","teams":"","signature":"v1..","team_id":2,"created_at":null},"output":null},{"input":{"keys":",","teams":"2 3","signature":"v1.billed_src.1736944332.b1da101a3762bada9a206ddef4b896fe520e0c9a5055a358e5405594e9eb24dex","team_id":3,"created_at":""},"output":null},{"input":{"keys":" ","teams":"01","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944633.00","team_id":0,"created_at":""},"output":null},{"input":{"keys":"k0,,k1","teams":"2 3","signature":"v1.HOG.1736944633.00","team_id":3,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":",","teams":"1,","signature":"v1.billed_src.1736944634.85e2e7b6815a4d6bbe402cbcda9f631ca8084398f88737b758b6d8e9b98aec26","team_id":1000,"created_at":""},"output":null},{"input":{"keys":" k1 , k0 ","teams":"1e3","signature":"v1.hog_flow. 1736944631.00","team_id":-1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"","teams":"","signature":"v1.a.b.1736944333.00","team_id":1000,"created_at":"garbage"},"output":null},{"input":{"keys":",","teams":"1.9","signature":"v1..1736944633.00","team_id":1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k0,,k1","teams":"*","signature":"v1.hog_flow.1736944631\n.00","team_id":1,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"","teams":"-1","signature":"v1.a.b.1736944932.00.extra","team_id":2,"created_at":"garbage"},"output":null},{"input":{"keys":"","teams":"01","signature":"v1.__proto__.1736944631.67ead39b88dbd4e50694bd1dac651557a5b68127f4a0143ef6d5fb4800374d7f","team_id":1000,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":" k1 , k0 ","teams":"-1","signature":"v1.hog_flow.1736944934.1ff0b49a06c21ea5c5193d2cee5e8c17d88f002da5b92e7eeb42911a5da59fcb","team_id":1000,"created_at":"Jan 15 2025 12:37:13 GMT+0000"},"output":null},{"input":{"keys":"k1,k0","teams":"*","signature":"v1.HOG.1736944633.00","team_id":0,"created_at":"2025-01-15T12:37:13.250"},"output":null},{"input":{"keys":"k0,,k1","teams":"-1","signature":"v1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.1736944631.af45b52067ff01918c083d2cf6aca3516b26693cb0a2afd5ce9eb3ff0011b452","team_id":1,"created_at":"Wed, 15 Jan 2025 12:39:39 GMT"},"output":null},{"input":{"keys":"k0,,k1","teams":"1.9","signature":"v1.constructor.1736944633.4142a51e4880899c4f20f7ec6751924060b2da39fc2797431472bdc61509181c","team_id":0,"created_at":null},"output":null},{"input":{"keys":" ","teams":"01","signature":"v1.hog_flow.1736944631.00","team_id":1000,"created_at":"1736944633250"},"output":null},{"input":{"keys":"k0,,k1","teams":"+1","signature":"v1.hog_flow.0736944631.ab","team_id":-1,"created_at":"2025-01-15T12:37:13.250+00:00"},"output":null},{"input":{"keys":"k1","teams":"1,","signature":"v1.hog_flow.1736944631.00","team_id":1,"created_at":"garbage"},"output":null}]}diff --git a/rust/logs-ingestion/tests/fixtures/fuzz/json.json b/rust/logs-ingestion/tests/fixtures/fuzz/json.jsonnew file mode 100644index 000000000000..ad2193efc734--- /dev/null+++ b/rust/logs-ingestion/tests/fixtures/fuzz/json.json@@ -0,0 +1 @@+{"cases":[{"input":"{\"\":\"12a0x10 \",\"4294967295\":{\"50\":null,\"a.\":{\"0\":[false,-0.002846777641680092,[100],\"-1user.email\",[true,4294967294,null],null,{\"http.method\":false},{\"\\\\\":{\"4294967295\":0.1,\"-1e400 host.example.com \":\"0x10éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\",\"a\":\"12\",\"http.method\":\".5NaN\",\"12.5abc 1_000 \":[\"�🚀\",2.5e-8,1e-7,\"0b11\",null,\"12 日本語\",null,true,null,1.7976931348623157e+308,4294967295,-11.32760166656226,\"-1.5/api/v1/users/123 \",\"0x1010b11\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}},1,1],\"-1e400 \":null}}}","output":{"ok":true,"s":"{\"\":\"12a0x10 \",\"4294967295\":{\"50\":null,\"a.\":{\"0\":[false,-0.002846777641680092,[100],\"-1user.email\",[true,4294967294,null],null,{\"http.method\":false},{\"\\\\\":{\"4294967295\":0.1,\"-1e400 host.example.com \":\"0x10éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\",\"a\":\"12\",\"http.method\":\".5NaN\",\"12.5abc 1_000 \":[\"�🚀\",2.5e-8,1e-7,\"0b11\",null,\"12 日本語\",null,true,null,1.7976931348623157e+308,4294967295,-11.32760166656226,\"-1.5/api/v1/users/123 \",\"0x1010b11\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}},1,1],\"-1e400 \":null}}}"}},{"input":"\"POST__defineGetter__\"","output":{"ok":true,"s":"\"POST__defineGetter__\""}},{"input":"[true,1e-7,\"\\u0000🚀 \"]","output":{"ok":true,"s":"[true,1e-7,\"\\u0000🚀 \"]"}},{"input":"{\"a\":[{\"0\":{\"b.c\":{\"b.c\":[[[[{\"0\":[{\"0\":[[{\"a\":[[[[[{\"0\":{\"0\":{\"\":[{\"a\":[{\"\":{\"\":{\"0\":[[{\"a\":{\"a\":{\"\":{\"b.c\":{\"b.c\":{\"0\":[{\"a\":[[{\"\":[[{\"b.c\":[{\"\":{\"\":[[[[{\"b.c\":{\"a\":[{\"a\":[[[{\"\":{\"0\":[[[[[[{\"\":[[{\"0\":[{\"\":[{\"\":[[[[[{\"\":{\"0\":{\"0\":[[[{\"a\":[[[{\"b.c\":{\"\":[[[[{\"0\":{\"a\":{\"0\":{\"a\":{\"0\":[[[[{\"a\":{\"b.c\":[[[[{\"b.c\":{\"\":{\"b.c\":[[{\"\":[[[{\"a\":[{\"0\":[{\"\":{\"0\":[[true]]}}]}]}]]]}]]}}}]]]]}}]]]]}}}}}]]]]}}]]]}]]]}}}]]]]]}]}]}]]}]]]]]]}}]]]}]}}]]]]}}]}]]}]]}]}}}}}}]]}}}]}]}}}]]]]]}]]}]}]]]]}}}]}","output":{"ok":true,"s":"{\"a\":[{\"0\":{\"b.c\":{\"b.c\":[[[[{\"0\":[{\"0\":[[{\"a\":[[[[[{\"0\":{\"0\":{\"\":[{\"a\":[{\"\":{\"\":{\"0\":[[{\"a\":{\"a\":{\"\":{\"b.c\":{\"b.c\":{\"0\":[{\"a\":[[{\"\":[[{\"b.c\":[{\"\":{\"\":[[[[{\"b.c\":{\"a\":[{\"a\":[[[{\"\":{\"0\":[[[[[[{\"\":[[{\"0\":[{\"\":[{\"\":[[[[[{\"\":{\"0\":{\"0\":[[[{\"a\":[[[{\"b.c\":{\"\":[[[[{\"0\":{\"a\":{\"0\":{\"a\":{\"0\":[[[[{\"a\":{\"b.c\":[[[[{\"b.c\":{\"\":{\"b.c\":[[{\"\":[[[{\"a\":[{\"0\":[{\"\":{\"0\":[[true]]}}]}]}]]]}]]}}}]]]]}}]]]]}}}}}]]]]}}]]]}]]]}}}]]]]]}]}]}]]}]]]]]]}}]]]}]}}]]]]}}]}]]}]]}]}}}}}}]]}}}]}]}}}]]]]]}]]}]}]]]]}}}]}"}},{"input":"\" \"","output":{"ok":true,"s":"\" \""}},{"input":"1234678901234568000","output":{"ok":true,"s":"1234678901234568000"}},{"input":"{\"1\":1,\"b\":2,\"1\":{\"x\":1}}","output":{"ok":true,"s":"{\"1\":{\"x\":1},\"b\":2}"}},{"input":"[[[{\"a\":{\"b.c\":{\"a\":[{\"a\":[{\"0\":[[[[[{\"\":[[{\"\":[[{\"b.c\":[{\"b.c\":[{\"b.c\":[[{\"a\":[[[[[[{\"a\":{\"b.c\":[{\"a\":{\"0\":[{\"b.c\":[{\"b.c\":[{\"\":{\"\":{\"\":[[[[[[{\"b.c\":[[[{\"a\":[{\"a\":{\"\":[[{\"0\":[[[{\"a\":[[[{\"\":{\"a\":{\"b.c\":[[[{\"b.c\":[{\"\":[{\"b.c\":{\"b.c\":{\"0\":[[{\"a\":{\"b.c\":[[{\"\":{\"0\":{\"b.c\":{\"a\":[[{\"b.c\":[[[[[{\"a\":[{\"0\":{\"a\":[{\"b.c\":{\"a\":{\"a\":[{\"a\":[[{\"0\":{\"b.c\":[[[[{\"b.c\":[[{\"b.c\":{\"\":1}}]]}]]]]}}]]}]}}}]}}]}]]]]]}]]}}}}]]}}]]}}}]}]}]]]}}}]]]}]]]}]]}}]}]]]}]]]]]]}}}]}]}]}}]}}]]]]]]}]]}]}]}]]}]]}]]]]]}]}]}}}]]]","output":{"ok":true,"s":"[[[{\"a\":{\"b.c\":{\"a\":[{\"a\":[{\"0\":[[[[[{\"\":[[{\"\":[[{\"b.c\":[{\"b.c\":[{\"b.c\":[[{\"a\":[[[[[[{\"a\":{\"b.c\":[{\"a\":{\"0\":[{\"b.c\":[{\"b.c\":[{\"\":{\"\":{\"\":[[[[[[{\"b.c\":[[[{\"a\":[{\"a\":{\"\":[[{\"0\":[[[{\"a\":[[[{\"\":{\"a\":{\"b.c\":[[[{\"b.c\":[{\"\":[{\"b.c\":{\"b.c\":{\"0\":[[{\"a\":{\"b.c\":[[{\"\":{\"0\":{\"b.c\":{\"a\":[[{\"b.c\":[[[[[{\"a\":[{\"0\":{\"a\":[{\"b.c\":{\"a\":{\"a\":[{\"a\":[[{\"0\":{\"b.c\":[[[[{\"b.c\":[[{\"b.c\":{\"\":1}}]]}]]]]}}]]}]}}}]}}]}]]]]]}]]}}}}]]}}]]}}}]}]}]]]}}}]]]}]]]}]]}}]}]]]}]]]]]]}}}]}]}]}}]}}]]]]]]}]]}]}]}]]}]]}]]]]]}]}]}}}]]]"}},{"input":"\"\\\"ar\"","output":{"ok":true,"s":"\"\\\"ar\""}},{"input":"null","output":{"ok":true,"s":"null"}},{"input":"\"C2001:db8::1\"","output":{"ok":true,"s":"\"C2001:db8::1\""}},{"input":"{\"50\":{\"-Infinity\":[{\"10\":\"10\"}],\"deadbeef\":{\"é\":null,\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":null,\"12.5abc\":[null,{\"a.\":-1},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,11,1,1,1,1,1,1,1]}},\"hasOwnProperty\":{\"192.168.0.1\":false}}","output":{"ok":true,"s":"{\"50\":{\"-Infinity\":[{\"10\":\"10\"}],\"deadbeef\":{\"é\":null,\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":null,\"12.5abc\":[null,{\"a.\":-1},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,11,1,1,1,1,1,1,1]}},\"hasOwnProperty\":{\"192.168.0.1\":false}}"}},{"input":"\t--5.12345678901234567890e+5","output":{"ok":false}},{"input":"\"lengthꝄ\"\\\\","output":{"ok":false}},{"input":"\"-Infinity\"\\u0000\\/","output":{"ok":false}},{"input":"null","output":{"ok":true,"s":"null"}},{"input":"123456789012345678901234567890.5e-5 ","output":{"ok":true,"s":"1.2345678901234568e+24"}},{"input":"true","output":{"ok":true,"s":"true"}},{"input":" -01.000001","output":{"ok":false}},{"input":" +0.5e-7 ","output":{"ok":false}},{"input":"rue","output":{"ok":false}},{"input":"{\"b.c\":[[[[[[{\"0\":{\"b.c\":[[{\"b.c\":[[[[{\"a\":[{\"b.c\":{\"a\":[[{\"a\":{\"\":{\"b.c\":[{\"0\":[{\"\":{\"b.c\":[[[[[[[{\"\":{\"a\":[[[{\"\":[{\"a\":[{\"a\":[[{\"\":{\"a\":[[[{\"a\":{\"a\":[[[[{\"a\":{\"a\":{\"a\":{\"\":[[[[[{\"a\":[[{\"0\":{\"0\":[{\"b.c\":{\"b.c\":{\"0\":[[{\"\":[[{\"a\":{\"\":{\"b.c\":{\"b.c\":{\"0\":{\"\":{\"\":{\"a\":{\"b.c\":{\"a\":{\"\":[{\"0\":{\"0\":{\"\":[[{\"\":[{\"b.c\":{\"0\":{\"b.c\":[[{\"b.c\":{\"0\":{\"\":{\"0\":[[[[[{\"b.c\":{\"a\":{\"0\":{\"\":[{\"b.c\":[[{\"\":{\"a\":{\"0\":{\"\":{\"\":[\"v\"]}}}}}]]}]}}}}]]]]]}}}}]]}}}]}]]}}}]}}}}}}}}}}}]]}]]}}}]}}]]}]]]]]}}}}]]]]}}]]]}}]]}]}]}]]]}}]]]]]]]}}]}]}}}]]}}]}]]]]}]]}}]]]]]]}","output":{"ok":true,"s":"{\"b.c\":[[[[[[{\"0\":{\"b.c\":[[{\"b.c\":[[[[{\"a\":[{\"b.c\":{\"a\":[[{\"a\":{\"\":{\"b.c\":[{\"0\":[{\"\":{\"b.c\":[[[[[[[{\"\":{\"a\":[[[{\"\":[{\"a\":[{\"a\":[[{\"\":{\"a\":[[[{\"a\":{\"a\":[[[[{\"a\":{\"a\":{\"a\":{\"\":[[[[[{\"a\":[[{\"0\":{\"0\":[{\"b.c\":{\"b.c\":{\"0\":[[{\"\":[[{\"a\":{\"\":{\"b.c\":{\"b.c\":{\"0\":{\"\":{\"\":{\"a\":{\"b.c\":{\"a\":{\"\":[{\"0\":{\"0\":{\"\":[[{\"\":[{\"b.c\":{\"0\":{\"b.c\":[[{\"b.c\":{\"0\":{\"\":{\"0\":[[[[[{\"b.c\":{\"a\":{\"0\":{\"\":[{\"b.c\":[[{\"\":{\"a\":{\"0\":{\"\":{\"\":[\"v\"]}}}}}]]}]}}}}]]]]]}}}}]]}}}]}]]}}}]}}}}}}}}}}}]]}]]}}}]}}]]}]]]]]}}}}]]]]}}]]]}}]]}]}]}]]]}}]]]]]]]}}]}]}}}]]}}]}]]]]}]]}}]]]]]]}"}},{"input":"false","output":{"ok":true,"s":"false"}},{"input":"\"message \"","output":{"ok":true,"s":"\"message \""}},{"input":"{\"50\":[2.5e-8,\"࣓ event\",104226.31027176976,\" 12 a\\\\nb \",\".5\",[],[[\"NaN\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1\\u12,1,1,1,1,1,1,1,1,1,1,,1,1,1,1,1,1,1,11,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\"51\":true,\"toString\":false,\"\":\"🚀 \",\"�\":true}","output":{"ok":false}},{"input":"[1.7976931348623157e+308,-1.5,9007199254740992,\"GETxpayload\",true,123456789012345680000,{\"1\":-1,\"length\":\"0user_12312\",\"1e3\":true,\"http.method\":{\"1\":\"..42949672951e400\",\"10\":\"[email protected]☻debug\",\"\":100,\"🚀 \":\"warn \",\"4294967295\":\"1 \",\"\\\\\":0.1,\"K\":null}},\"1e3\",\"deadbeef1\",{\"[email protected]\":{\"7\":\"Infinity\",\"12345678\":{\"2\":{\"__defineGetter__\":null,\"\\t\":{\"N\":{\"3\":\"POST 1msg\",\"4294967294\":\"GET \",\"a.b\":true,\"12__defineGetter__\":\"2025-01-15T10:00:00Z12 \",\"a\":\"10192.168.0.1\",\"\\\"\":-4.231166988611221e-18,\"1.5\":true}}}},\"�\":\"GET 0o7\",\"host.example.com\":{}}}]","output":{"ok":true,"s":"[1.7976931348623157e+308,-1.5,9007199254740992,\"GETxpayload\",true,123456789012345680000,{\"1\":-1,\"length\":\"0user_12312\",\"1e3\":true,\"http.method\":{\"1\":\"..42949672951e400\",\"10\":\"[email protected]☻debug\",\"\":100,\"🚀 \":\"warn \",\"4294967295\":\"1 \",\"\\\\\":0.1,\"K\":null}},\"1e3\",\"deadbeef1\",{\"[email protected]\":{\"7\":\"Infinity\",\"12345678\":{\"2\":{\"__defineGetter__\":null,\"\\t\":{\"N\":{\"3\":\"POST 1msg\",\"4294967294\":\"GET \",\"a.b\":true,\"12__defineGetter__\":\"2025-01-15T10:00:00Z12 \",\"a\":\"10192.168.0.1\",\"\\\"\":-4.231166988611221e-18,\"1.5\":true}}}},\"�\":\"GET 0o7\",\"host.example.com\":{}}}]"}},{"input":"\"龆ہInfinity\"\\\\\\/","output":{"ok":false}},{"input":"9007199254740992","output":{"ok":true,"s":"9007199254740992"}},{"input":"{\"\":[{\"0\":{\"b.c\":{\"a\":[[{\"0\":[{\"0\":[{\"a\":[{\"a\":{\"\":[{\"0\":{\"\":{\"b.c\":[[[{\"0\":[{\"0\":[[[{\"b.c\":[{\"0\":{\"a\":[{\"b.c\":{\"0\":{\"\":{\"\":[[{\"b.c\":{\"0\":[{\"b.c\":{\"\":{\"b.c\":[{\"a\":{\"b.c\":[{\"\":[{\"0\":[{\"\":[[[[[{\"0\":[{\"\":[{\"a\":{\"0\":{\"a\":{\"b.c\":{\"0\":[[{\"\":{\"b.c\":{\"0\":[{\"a\":{\"0\":{\"0\":{\"a\":[{\"\":[[{\"\":{\"a\":{\"0\":[{\"a\":{\"a\":{\"b.c\":{\"0\":[{\"b.c\":[[{\"\":[{\"a\":{\"\":{\"a\":[[[[[[{\"b.c\":{\"\":{\"0\":[{\"0\":{\"a\":[[[[{\"0\":{\"0\":[[[[[{\"b.c\":{\"\":[{\"\":{\"\":[[{\"\":null}]]}}]}}]]]]]}}]]]]}}]}}}]]]]]]}}}]}]]}]}}}}]}}}]]}]}}}}]}}}]]}}}}}]}]}]]]]]}]}]}]}}]}}}]}}]]}}}}]}}]}]]]}]}]]]}}}]}}]}]}]}]]}}}]}","output":{"ok":true,"s":"{\"\":[{\"0\":{\"b.c\":{\"a\":[[{\"0\":[{\"0\":[{\"a\":[{\"a\":{\"\":[{\"0\":{\"\":{\"b.c\":[[[{\"0\":[{\"0\":[[[{\"b.c\":[{\"0\":{\"a\":[{\"b.c\":{\"0\":{\"\":{\"\":[[{\"b.c\":{\"0\":[{\"b.c\":{\"\":{\"b.c\":[{\"a\":{\"b.c\":[{\"\":[{\"0\":[{\"\":[[[[[{\"0\":[{\"\":[{\"a\":{\"0\":{\"a\":{\"b.c\":{\"0\":[[{\"\":{\"b.c\":{\"0\":[{\"a\":{\"0\":{\"0\":{\"a\":[{\"\":[[{\"\":{\"a\":{\"0\":[{\"a\":{\"a\":{\"b.c\":{\"0\":[{\"b.c\":[[{\"\":[{\"a\":{\"\":{\"a\":[[[[[[{\"b.c\":{\"\":{\"0\":[{\"0\":{\"a\":[[[[{\"0\":{\"0\":[[[[[{\"b.c\":{\"\":[{\"\":{\"\":[[{\"\":null}]]}}]}}]]]]]}}]]]]}}]}}}]]]]]]}}}]}]]}]}}}}]}}}]]}]}}}}]}}}]]}}}}}]}]}]]]]]}]}]}]}}]}}}]}}]]}}}}]}}]}]]]}]}]]]}}}]}}]}]}]}]]}}}]}"}},{"input":"{\"1\":{\"日本\":false,\"payload\":[\"9007199254740993\"],\"-1\":-1,\"4294967295\":{\"01\":{\"100\":[[\"12 \"],true,\"k\",2.5e-8,\"⏂1,5\",\" \",[null,false,0.000001,\"12warn\",{\"1\":null,\"2\":null,\"3\":5e-324,\"51\":\"é\",\"100\":false,\"12345678\":\"5. 0b11\",\"4294967294\":true,\" \":\"\",\"4294967295\":-0.18549602711573243,\".a\":false,\"constructor\":\"xoxb-1234567890-abc Bearer abc.def-ghi Infinity \",\"\\\\ -1 \":-1.5,\"日本\":true,\"a.b\":true,\"user_123\":\"1.5 [email protected]\",\"deadbeef\":\"192.168.0.1\\\" \",\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":\"42949672941.5 \"},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}}}}","output":{"ok":true,"s":"{\"1\":{\"日本\":false,\"payload\":[\"9007199254740993\"],\"-1\":-1,\"4294967295\":{\"01\":{\"100\":[[\"12 \"],true,\"k\",2.5e-8,\"⏂1,5\",\" \",[null,false,0.000001,\"12warn\",{\"1\":null,\"2\":null,\"3\":5e-324,\"51\":\"é\",\"100\":false,\"12345678\":\"5. 0b11\",\"4294967294\":true,\" \":\"\",\"4294967295\":-0.18549602711573243,\".a\":false,\"constructor\":\"xoxb-1234567890-abc Bearer abc.def-ghi Infinity \",\"\\\\ -1 \":-1.5,\"日本\":true,\"a.b\":true,\"user_123\":\"1.5 [email protected]\",\"deadbeef\":\"192.168.0.1\\\" \",\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":\"42949672941.5 \"},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}}}}"}},{"input":"\"\ud818\\x4\udf4e 01\"","output":{"ok":false}},{"input":"-00.000001e309 ","output":{"ok":false}},{"input":"null","output":{"ok":true,"s":"null"}},{"input":"\"\\\\2025-01-15T10:00:00Z\"","output":{"ok":true,"s":"\"\\\\2025-01-15T10:00:00Z\""}},{"input":"null","output":{"ok":true,"s":"null"}},{"input":"\"-0 \\\\\"","output":{"ok":true,"s":"\"-0 \\\\\""}},{"input":"\"http.method 192.168.1.1\"","output":{"ok":true,"s":"\"http.method 192.168.1.1\""}},{"input":"[{\"🚀\":{\"4294967294\":\" 12 1 𜼚\",\"𐀀\":\"7\",\"..\":\"GET0.1 -Infnity \",\"full\":1e+21,\"deadbeef\":1.5,\"4294967295\":[{\"a\":\"msg -1e400\"},35.231749434024096],\"1e+100 \\\"quoted\\\"\":true,\"01\":\"1e3\"}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,tru1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","output":{"ok":false}},{"input":"+.0 ","output":{"ok":false}},{"input":"{\"192.168.1.1 \":{\"4294967295\":[{\"host.example.com\":\"-Infinity \",\".a\":{\"\\u20282\":null,\"10010\":{\"\\n\":[false,false,\"[email protected] event\",null,null,\"-Infinity2001:db8::1 \",-0.00047395818494260313,-3.1037682085298e-8,\"-0\",1e-7,\"0b11\",\"1e3日本-0\",true,\"hasOwnProperty\",\" a.\",0.1,\"/api/v1/users/123日本 \",2.565659387037158e-9,null,true,null,0.30000000000000004,false,9007199254740994,-1,12.5,0,-767848140094.4292,\"🚀 \",\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀-1 \",\"NaN \",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}}","output":{"ok":true,"s":"{\"192.168.1.1 \":{\"4294967295\":[{\"host.example.com\":\"-Infinity \",\".a\":{\"10010\":{\"\\n\":[false,false,\"[email protected] event\",null,null,\"-Infinity2001:db8::1 \",-0.00047395818494260313,-3.1037682085298e-8,\"-0\",1e-7,\"0b11\",\"1e3日本-0\",true,\"hasOwnProperty\",\" a.\",0.1,\"/api/v1/users/123日本 \",2.565659387037158e-9,null,true,null,0.30000000000000004,false,9007199254740994,-1,12.5,0,-767848140094.4292,\"🚀 \",\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀-1 \",\"NaN \",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},\" 2\":null}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}}"}},{"input":"false","output":{"ok":true,"s":"false"}},{"input":"{\"\\ud800\":1,\"b\":2,\"\\ud800\":null}","output":{"ok":true,"s":"{\"\\ud800\":null,\"b\":2}"}},{"input":"999.9999999","output":{"ok":true,"s":"999.9999999"}},{"input":"{\"\\u0030\":1,\"b\":2,\"\\u0030\":3}","output":{"ok":true,"s":"{\"0\":3,\"b\":2}"}},{"input":"full \"\\]","output":{"ok":false}},{"input":"{}","output":{"ok":true,"s":"{}"}},{"input":" --e21","output":{"ok":false}},{"input":"true","output":{"ok":true,"s":"true"}},{"input":"-9007199254740993.0e-7","output":{"ok":true,"s":"-900719925.4740993"}},{"input":"null","output":{"ok":true,"s":"null"}},{"input":"true","output":{"ok":true,"s":"true"}},{"input":"\"\\udfff12.5abc \"\\u2028","output":{"ok":false}},{"input":"\"user_123\"","output":{"ok":true,"s":"\"user_123\""}},{"input":"5.861726193688809e-14","output":{"ok":true,"s":"5.861726193688809e-14"}},{"input":"null","output":{"ok":true,"s":"null"}},{"input":"\u000b-0.12345678901234567890e-5","output":{"ok":false}},{"input":"123456789012345678901234567890.5e-400 ","output":{"ok":true,"s":"0"}},{"input":"{\"\":{\"\":[{\"b.c\":{\"a\":[{\"0\":{\"0\":[[{\"0\":[[[{\"b.c\":{\"0\":[[[[[{\"a\":[{\"0\":[[{\"\":{\"b.c\":{\"b.c\":{\"b.c\":[{\"0\":{\"a\":{\"0\":[[[[[{\"b.c\":[[[[[[{\"b.c\":[{\"b.c\":{\"\":{\"a\":[[{\"0\":[[[{\"b.c\":{\"a\":[{\"a\":[{\"a\":{\"\":{\"0\":[{\"b.c\":{\"a\":[[[{\"b.c\":{\"0\":[[[{\"a\":[{\"0\":[{\"0\":{\"0\":[{\"\":[{\"0\":{\"b.c\":{\"a\":{\"a\":[{\"b.c\":{\"b.c\":[{\"\":{\"b.c\":{\"0\":[{\"\":{\"\":[[[{\"b.c\":[[[{\"a\":[{\"a\":[{\"b.c\":[{\"\":{\"\":{\"b.c\":{\"\":{\"0\":{\"b.c\":[{\"b.c\":{\"\":[{\"\":{\"a\":{\"a\":{\"0\":[{\"0\":{\"\":{\"0\":{\"a\":{\"b.c\":[{\"b.c\":{\"\":[{\"a\":{\"a\":{\"\":[[[{\"\":{\"0\":[{\"b.c\":{\"\":[[[{\"b.c\":{\"\":[[{\"a\":[[[{\"\":{\"a\":{\"a\":{\"\":[[{\"b.c\":[{\"b.c\":[{\"0\":{\"\":{\"0\":[[[{\"a\":{\"0\":{\"b.c\":{\"\":[[{\"0\":[[{\"\":{\"\":[{\"a\":{\"\":{\"b.c\":[[[[[[[[[{\"a\":[1]}]]]]]]]]]}}}]}}]]}]]}}}}]]]}}}]}]}]]}}}}]]]}]]}}]]]}}]}}]]]}}}]}}]}}}}}]}}}}]}}]}}}}}}]}]}]}]]]}]]]}}]}}}]}}]}}}}]}]}}]}]}]]]}}]]]}}]}}}]}]}}]]]}]]}}}]}]]]]]]}]]]]]}}}]}}}}]]}]}]]]]]}}]]]}]]}}]}}]}}","output":{"ok":true,"s":"{\"\":{\"\":[{\"b.c\":{\"a\":[{\"0\":{\"0\":[[{\"0\":[[[{\"b.c\":{\"0\":[[[[[{\"a\":[{\"0\":[[{\"\":{\"b.c\":{\"b.c\":{\"b.c\":[{\"0\":{\"a\":{\"0\":[[[[[{\"b.c\":[[[[[[{\"b.c\":[{\"b.c\":{\"\":{\"a\":[[{\"0\":[[[{\"b.c\":{\"a\":[{\"a\":[{\"a\":{\"\":{\"0\":[{\"b.c\":{\"a\":[[[{\"b.c\":{\"0\":[[[{\"a\":[{\"0\":[{\"0\":{\"0\":[{\"\":[{\"0\":{\"b.c\":{\"a\":{\"a\":[{\"b.c\":{\"b.c\":[{\"\":{\"b.c\":{\"0\":[{\"\":{\"\":[[[{\"b.c\":[[[{\"a\":[{\"a\":[{\"b.c\":[{\"\":{\"\":{\"b.c\":{\"\":{\"0\":{\"b.c\":[{\"b.c\":{\"\":[{\"\":{\"a\":{\"a\":{\"0\":[{\"0\":{\"\":{\"0\":{\"a\":{\"b.c\":[{\"b.c\":{\"\":[{\"a\":{\"a\":{\"\":[[[{\"\":{\"0\":[{\"b.c\":{\"\":[[[{\"b.c\":{\"\":[[{\"a\":[[[{\"\":{\"a\":{\"a\":{\"\":[[{\"b.c\":[{\"b.c\":[{\"0\":{\"\":{\"0\":[[[{\"a\":{\"0\":{\"b.c\":{\"\":[[{\"0\":[[{\"\":{\"\":[{\"a\":{\"\":{\"b.c\":[[[[[[[[[{\"a\":[1]}]]]]]]]]]}}}]}}]]}]]}}}}]]]}}}]}]}]]}}}}]]]}]]}}]]]}}]}}]]]}}}]}}]}}}}}]}}}}]}}]}}}}}}]}]}]}]]]}]]]}}]}}}]}}]}}}}]}]}}]}]}]]]}}]]]}}]}}}]}]}}]]]}]]}}}]}]]]]]]}]]]]]}}}]}}}}]]}]}]]]]]}}]]]}]]}}]}}]}}"}},{"input":"\n+123456789012345678901234567890.12345678901234567890e-400","output":{"ok":false}},{"input":"{\"1\":1,\"b\":2,\"1\":\"s\"}","output":{"ok":true,"s":"{\"1\":\"s\",\"b\":2}"}},{"input":"\"+5b0o7 \"","output":{"ok":true,"s":"\"+5b0o7 \""}},{"input":"{}","output":{"ok":true,"s":"{}"}},{"input":"{\"2\":[false,\"[1,2]\\\"\",\"\\\"quoted\\\"\",{\"a. \":[{\"3\":\"/api/v1/users/123\",\"4294967294\":{\"4294967295\":false},\"192.168.1.1\":123456789012345680000,\"toString\":\" \",\"host.example.com\":null,\".a\":true},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,]}","output":{"ok":false}},{"input":"\"1e38\"+\\u125\"","output":{"ok":false}},{"input":"{\"..\":[{\"2\":null,\"-1\":[-1.5,[0,[null,\"\\\\0.10b11\",null,{\"50\":\"192.168.1.17 \",\"4294967294\":33744779089.465736,\"\\\\\":null,\"event\":\"1e+100 \",\"4294967296\":\"debug \"},{\"100\":\"message \",\"__defineGetter__\":null},{\"0\":\"+5 AKIAIOSFODNN7EXAMPLE0o7\",\"2\":\" \",\"5\":\"9007199254740992user_123 12.5\"},1e+100,{\"5\":true,\"49\":null,\"100\":4294967294,\"1,5 \":\"1e3 -InfinityBearer abc.def-ghi \",\"K\":false,\"constructor\":1,\"f \":false,\"\":5e-324,\"2001:db8::1\":\"� full\",\"host.example.com\":null,\"-1\":\"Kb\"x\\ude80,\"full\":\"日本語\"},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1]}","output":{"ok":false}},{"input":"\"205-01-15T10:00:00ZeyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\"","output":{"ok":true,"s":"\"205-01-15T10:00:00ZeyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\""}},{"input":"+.0E5","output":{"ok":false}},{"input":"+9007199254740993.0e-400 ","output":{"ok":false}},{"input":"-39425481623.03865","output":{"ok":true,"s":"-39425481623.03865"}},{"input":"nul","output":{"ok":false}},{"input":"{\"\\ud800\":1,\"b\":2,\"\\ud800\":\"s\"}","output":{"ok":true,"s":"{\"\\ud800\":\"s\",\"b\":2}"}},{"input":"\" \"","output":{"ok":true,"s":"\" \""}},{"input":"{\"0\":1,\"b\":2,\"0\":{\"x\":1}}","output":{"ok":true,"s":"{\"0\":{\"x\":1},\"b\":2}"}},{"input":"+01.0e+5","output":{"ok":false}},{"input":"[[{\"0\":[{\"b.c\":[[[[[[{\"b.c\":[{\"0\":{\"0\":[[[{\"\":{\"0\":{\"\":{\"0\":[{\"\":{\"b.c\":{\"a\":[[{\"\":{\"0\":[[{\"\":[[[{\"a\":[{\"\":[[{\"0\":[[{\"0\":[[{\"a\":[[[[{\"a\":[{\"a\":[[{\"\":{\"\":{\"b.c\":{\"0\":[{\"0\":[[[{\"b.c\":[{\"b.c\":{\"a\":[{\"\":{\"b.c\":{\"a\":{\"a\":{\"0\":[[[{\"b.c\":[[{\"0\":[[[{\"a\":[{\"b.c\":[[{\"0\":{\"b.c\":{\"\":{\"b.c\":{\"0\":[{\"0\":[{\"0\":{\"0\":[{\"\":[{\"0\":[[[[{\"\":[[{\"0\":{\"b.c\":[{\"a\":[{\"\":[{\"a\":[[[{\"a\":{\"a\":[[[[1]]]]}}]]]}]}]}]}}]]}]]]]}]}]}}]}]}}}}}]]}]}]]]}]]}]]]}}}}}]}}]}]]]}]}}}}]]}]}]]]]}]]}]]}]]}]}]]]}]]}}]]}}}]}}}}]]]}}]}]]]]]]}]}]]","output":{"ok":true,"s":"[[{\"0\":[{\"b.c\":[[[[[[{\"b.c\":[{\"0\":{\"0\":[[[{\"\":{\"0\":{\"\":{\"0\":[{\"\":{\"b.c\":{\"a\":[[{\"\":{\"0\":[[{\"\":[[[{\"a\":[{\"\":[[{\"0\":[[{\"0\":[[{\"a\":[[[[{\"a\":[{\"a\":[[{\"\":{\"\":{\"b.c\":{\"0\":[{\"0\":[[[{\"b.c\":[{\"b.c\":{\"a\":[{\"\":{\"b.c\":{\"a\":{\"a\":{\"0\":[[[{\"b.c\":[[{\"0\":[[[{\"a\":[{\"b.c\":[[{\"0\":{\"b.c\":{\"\":{\"b.c\":{\"0\":[{\"0\":[{\"0\":{\"0\":[{\"\":[{\"0\":[[[[{\"\":[[{\"0\":{\"b.c\":[{\"a\":[{\"\":[{\"a\":[[[{\"a\":{\"a\":[[[[1]]]]}}]]]}]}]}]}}]]}]]]]}]}]}}]}]}}}}}]]}]}]]]}]]}]]]}}}}}]}}]}]]]}]}}}}]]}]}]]]]}]]}]]}]]}]}]]]}]]}}]]}}}]}}}}]]]}}]}]]]]]]}]}]]"}},{"input":"[[{\"0\":{\"\":[{\"0\":[{\"\":[{\"0\":{\"a\":{\"0\":{\"a\":{\"b.c\":[{\"a\":{\"\":[{\"0\":{\"a\":[[{\"\":[[[{\"b.c\":{\"\":{\"a\":{\"b.c\":{\"\":{\"\":{\"0\":[[{\"0\":[{\"b.c\":[{\"\":[[[[[[[[[[[{\"0\":[[{\"b.c\":[[{\"a\":[{\"0\":[[{\"a\":{\"\":{\"\":[{\"\":[[[[{\"a\":[[{\"\":{\"a\":[{\"a\":[{\"0\":[{\"a\":[[{\"a\":{\"\":[{\"\":[{\"\":[{\"b.c\":{\"a\":{\"\":[[[[[{\"\":[[[{\"\":[[[[[{\"b.c\":{\"b.c\":[{\"\":{\"\":[{\"b.c\":{\"\":[[[[[{\"0\":{\"0\":[{\"b.c\":{\"\":[{\"\":[\"v\"]}]}}]}}]]]]]}}]}}]}}]]]]]}]]]}]]]]]}}}]}]}]}}]]}]}]}]}}]]}]]]]}]}}}]]}]}]]}]]}]]]]]]]]]]]}]}]}]]}}}}}}}]]]}]]}}]}}]}}}}}]}]}]}}]]","output":{"ok":true,"s":"[[{\"0\":{\"\":[{\"0\":[{\"\":[{\"0\":{\"a\":{\"0\":{\"a\":{\"b.c\":[{\"a\":{\"\":[{\"0\":{\"a\":[[{\"\":[[[{\"b.c\":{\"\":{\"a\":{\"b.c\":{\"\":{\"\":{\"0\":[[{\"0\":[{\"b.c\":[{\"\":[[[[[[[[[[[{\"0\":[[{\"b.c\":[[{\"a\":[{\"0\":[[{\"a\":{\"\":{\"\":[{\"\":[[[[{\"a\":[[{\"\":{\"a\":[{\"a\":[{\"0\":[{\"a\":[[{\"a\":{\"\":[{\"\":[{\"\":[{\"b.c\":{\"a\":{\"\":[[[[[{\"\":[[[{\"\":[[[[[{\"b.c\":{\"b.c\":[{\"\":{\"\":[{\"b.c\":{\"\":[[[[[{\"0\":{\"0\":[{\"b.c\":{\"\":[{\"\":[\"v\"]}]}}]}}]]]]]}}]}}]}}]]]]]}]]]}]]]]]}}}]}]}]}}]]}]}]}]}}]]}]]]]}]}}}]]}]}]]}]]}]]]]]]]]]]]}]}]}]]}}}}}}}]]]}]]}}]}}]}}}}}]}]}]}}]]"}},{"input":"[[{\"0\":{\"\":{\"a\":{\"\":{\"a\":{\"b.c\":[{\"a\":{\"0\":{\"a\":[[[{\"a\":{\"0\":[{\"0\":[{\"b.c\":{\"\":[{\"\":[[{\"\":[[{\"0\":[{\"0\":{\"b.c\":{\"\":[[{\"b.c\":{\"\":{\"a\":[[[[[[{\"b.c\":[{\"b.c\":{\"0\":[{\"0\":{\"\":{\"0\":[[{\"b.c\":{\"0\":{\"a\":[[[{\"b.c\":[{\"\":{\"0\":{\"a\":{\"b.c\":[{\"\":{\"a\":[[{\"\":[[[[[{\"0\":[[{\"b.c\":{\"a\":{\"\":[[{\"\":{\"a\":[[[{\"b.c\":{\"0\":[{\"0\":[{\"a\":{\"a\":{\"a\":{\"b.c\":{\"a\":{\"b.c\":[[{\"a\":[{\"b.c\":[{\"0\":{\"b.c\":{\"0\":[{\"a\":{\"0\":[[{\"b.c\":{\"\":{\"0\":[{\"0\":{\"\":[[{\"a\":[[{\"\":[{\"\":\"v\"}]}]]}]]}}]}}}]]}}]}}}]}]}]]}}}}}}]}]}}]]]}}]]}}}]]}]]]]]}]]}}]}}}}]}]]]}}}]]}}}]}}]}]]]]]]}}}]]}}}]}]]}]]}]}}]}]}}]]]}}}]}}}}}}]]","output":{"ok":true,"s":"[[{\"0\":{\"\":{\"a\":{\"\":{\"a\":{\"b.c\":[{\"a\":{\"0\":{\"a\":[[[{\"a\":{\"0\":[{\"0\":[{\"b.c\":{\"\":[{\"\":[[{\"\":[[{\"0\":[{\"0\":{\"b.c\":{\"\":[[{\"b.c\":{\"\":{\"a\":[[[[[[{\"b.c\":[{\"b.c\":{\"0\":[{\"0\":{\"\":{\"0\":[[{\"b.c\":{\"0\":{\"a\":[[[{\"b.c\":[{\"\":{\"0\":{\"a\":{\"b.c\":[{\"\":{\"a\":[[{\"\":[[[[[{\"0\":[[{\"b.c\":{\"a\":{\"\":[[{\"\":{\"a\":[[[{\"b.c\":{\"0\":[{\"0\":[{\"a\":{\"a\":{\"a\":{\"b.c\":{\"a\":{\"b.c\":[[{\"a\":[{\"b.c\":[{\"0\":{\"b.c\":{\"0\":[{\"a\":{\"0\":[[{\"b.c\":{\"\":{\"0\":[{\"0\":{\"\":[[{\"a\":[[{\"\":[{\"\":\"v\"}]}]]}]]}}]}}}]]}}]}}}]}]}]]}}}}}}]}]}}]]]}}]]}}}]]}]]]]]}]]}}]}}}}]}]]]}}}]]}}}]}}]}]]]]]]}}}]]}}}]}]]}]]}]}}]}]}}]]]}}}]}}}}}}]]"}},{"input":"null","output":{"ok":true,"s":"null"}},{"input":"\"\\u000b\"","output":{"ok":true,"s":"\"\\u000b\""}},{"input":"[{\"a\":{\"0\":[[{\"a\":[{\"b.c\":[[[{\"0\":{\"b.c\":{\"a\":[[[{\"\":[{\"a\":[{\"\":{\"a\":{\"0\":[[{\"0\":{\"0\":{\"a\":[{\"b.c\":[{\"0\":[[{\"\":[{\"\":{\"a\":[{\"a\":[{\"a\":{\"0\":{\"b.c\":[{\"0\":{\"b.c\":[[[{\"0\":[{\"a\":{\"a\":{\"\":{\"\":{\"b.c\":{\"b.c\":{\"\":{\"b.c\":[{\"0\":[[{\"0\":[{\"a\":{\"b.c\":[[[{\"\":[{\"\":{\"a\":{\"\":[{\"a\":[[[[[[[{\"0\":[{\"0\":[{\"\":{\"\":[{\"b.c\":[{\"0\":{\"a\":[{\"b.c\":[[[[{\"a\":{\"0\":[{\"b.c\":{\"b.c\":{\"\":[[[[[[[{\"0\":{\"\":[[{\"a\":{\"a\":[{\"\":{\"\":{\"a\":[{\"\":[[\"v\"]]}]}}}]}}]]}}]]]]]]]}}}]}}]]]]}]}}]}]}}]}]}]]]]]]]}]}}}]}]]]}}]}]]}]}}}}}}}}]}]]]}}]}}}]}]}}]}]]}]}]}}}]]}}}]}]}]]]}}}]]]}]}]]}}]","output":{"ok":true,"s":"[{\"a\":{\"0\":[[{\"a\":[{\"b.c\":[[[{\"0\":{\"b.c\":{\"a\":[[[{\"\":[{\"a\":[{\"\":{\"a\":{\"0\":[[{\"0\":{\"0\":{\"a\":[{\"b.c\":[{\"0\":[[{\"\":[{\"\":{\"a\":[{\"a\":[{\"a\":{\"0\":{\"b.c\":[{\"0\":{\"b.c\":[[[{\"0\":[{\"a\":{\"a\":{\"\":{\"\":{\"b.c\":{\"b.c\":{\"\":{\"b.c\":[{\"0\":[[{\"0\":[{\"a\":{\"b.c\":[[[{\"\":[{\"\":{\"a\":{\"\":[{\"a\":[[[[[[[{\"0\":[{\"0\":[{\"\":{\"\":[{\"b.c\":[{\"0\":{\"a\":[{\"b.c\":[[[[{\"a\":{\"0\":[{\"b.c\":{\"b.c\":{\"\":[[[[[[[{\"0\":{\"\":[[{\"a\":{\"a\":[{\"\":{\"\":{\"a\":[{\"\":[[\"v\"]]}]}}}]}}]]}}]]]]]]]}}}]}}]]]]}]}}]}]}}]}]}]]]]]]]}]}}}]}]]]}}]}]]}]}}}}}}}}]}]]]}}]}}}]}]}}]}]]}]}]}}}]]}}}]}]}]]]}}}]]]}]}]]}}]"}},{"input":"[[{\"a\":{\"b.c\":{\"a\":[[[[[{\"b.c\":[[{\"b.c\":{\"b.c\":[{\"b.c\":{\"a\":[{\"a\":{\"\":{\"a\":[{\"0\":[[[[[{\"0\":{\"\":{\"0\":[[{\"a\":[{\"\":{\"\":[[{\"b.c\":[[[[[{\"a\":[{\"a\":{\"\":{\"a\":[[{\"\":{\"\":[{\"\":[{\"\":[[{\"0\":{\"b.c\":[{\"\":{\"0\":[[[{\"a\":[{\"\":{\"b.c\":[[{\"\":{\"\":{\"\":{\"0\":[{\"a\":{\"\":{\"0\":{\"a\":{\"0\":{\"a\":{\"b.c\":{\"b.c\":{\"\":[[{\"0\":[{\"b.c\":{\"\":{\"a\":[{\"b.c\":{\"\":[[[[{\"0\":[[{\"\":{\"a\":[{\"b.c\":{\"a\":[[{\"0\":[[{\"b.c\":{\"b.c\":[[[[[{\"b.c\":{\"\":[{\"0\":null}]}}]]]]]}}]]}]]}}]}}]]}]]]]}}]}}}]}]]}}}}}}}}}]}}}}]]}}]}]]]}}]}}]]}]}]}}]]}}}]}]]]]]}]]}}]}]]}}}]]]]]}]}}}]}}]}}]]}]]]]]}}}]]","output":{"ok":true,"s":"[[{\"a\":{\"b.c\":{\"a\":[[[[[{\"b.c\":[[{\"b.c\":{\"b.c\":[{\"b.c\":{\"a\":[{\"a\":{\"\":{\"a\":[{\"0\":[[[[[{\"0\":{\"\":{\"0\":[[{\"a\":[{\"\":{\"\":[[{\"b.c\":[[[[[{\"a\":[{\"a\":{\"\":{\"a\":[[{\"\":{\"\":[{\"\":[{\"\":[[{\"0\":{\"b.c\":[{\"\":{\"0\":[[[{\"a\":[{\"\":{\"b.c\":[[{\"\":{\"\":{\"\":{\"0\":[{\"a\":{\"\":{\"0\":{\"a\":{\"0\":{\"a\":{\"b.c\":{\"b.c\":{\"\":[[{\"0\":[{\"b.c\":{\"\":{\"a\":[{\"b.c\":{\"\":[[[[{\"0\":[[{\"\":{\"a\":[{\"b.c\":{\"a\":[[{\"0\":[[{\"b.c\":{\"b.c\":[[[[[{\"b.c\":{\"\":[{\"0\":null}]}}]]]]]}}]]}]]}}]}}]]}]]]]}}]}}}]}]]}}}}}}}}}]}}}}]]}}]}]]]}}]}}]]}]}]}}]]}}}]}]]]]]}]]}}]}]]}}}]]]]]}]}}}]}}]}}]]}]]]]]}}}]]"}},{"input":"\"0 \"\\u2028","output":{"ok":false}},{"input":"{\"\\ud800\":1,\"b\":2,\"\\ud800\":{\"x\":1}}","output":{"ok":true,"s":"{\"\\ud800\":{\"x\":1},\"b\":2}"}},{"input":"{\"b.c\":[{\"\":[[[{\"b.c\":[{\"b.c\":[[[[[{\"b.c\":[{\"0\":[{\"0\":{\"0\":[{\"a\":[[[[[{\"\":{\"a\":[[[{\"a\":[[{\"b.c\":[{\"\":[{\"b.c\":{\"\":[{\"b.c\":[[[{\"\":{\"b.c\":[[[{\"b.c\":{\"\":[[[{\"\":[[[[[{\"b.c\":[[[[{\"\":{\"b.c\":{\"\":[[[{\"a\":{\"0\":[{\"a\":[[{\"a\":[{\"a\":{\"a\":{\"a\":[{\"a\":{\"\":[[[{\"0\":{\"b.c\":[[[[[{\"a\":{\"a\":[{\"\":{\"\":[{\"\":[[[{\"b.c\":{\"a\":[[[[{\"0\":[[[{\"\":{\"\":{\"\":{\"\":{\"b.c\":[{\"0\":[{\"b.c\":\"v\"}]}]}}}}}]]]}]]]]}}]]]}]}}]}}]]]]]}}]]]}}]}}}]}]]}]}}]]]}}}]]]]}]]]]]}]]]}}]]]}}]]]}]}}]}]}]]}]]]}}]]]]]}]}}]}]}]]]]]}]}]]]}]}","output":{"ok":true,"s":"{\"b.c\":[{\"\":[[[{\"b.c\":[{\"b.c\":[[[[[{\"b.c\":[{\"0\":[{\"0\":{\"0\":[{\"a\":[[[[[{\"\":{\"a\":[[[{\"a\":[[{\"b.c\":[{\"\":[{\"b.c\":{\"\":[{\"b.c\":[[[{\"\":{\"b.c\":[[[{\"b.c\":{\"\":[[[{\"\":[[[[[{\"b.c\":[[[[{\"\":{\"b.c\":{\"\":[[[{\"a\":{\"0\":[{\"a\":[[{\"a\":[{\"a\":{\"a\":{\"a\":[{\"a\":{\"\":[[[{\"0\":{\"b.c\":[[[[[{\"a\":{\"a\":[{\"\":{\"\":[{\"\":[[[{\"b.c\":{\"a\":[[[[{\"0\":[[[{\"\":{\"\":{\"\":{\"\":{\"b.c\":[{\"0\":[{\"b.c\":\"v\"}]}]}}}}}]]]}]]]]}}]]]}]}}]}}]]]]]}}]]]}}]}}}]}]]}]}}]]]}}}]]]]}]]]]]}]]]}}]]]}}]]]}]}}]}]}]]}]]]}}]]]]]}]}}]}]}]]]]]}]}]]]}]}"}},{"input":"-5.0E+0","output":{"ok":true,"s":"-5"}},{"input":"[{\"\":[[[{\"a\":[{\"a\":[[[[[[[{\"b.c\":{\"0\":{\"0\":[{\"\":[{\"\":[{\"b.c\":[[[[[[{\"b.c\":{\"\":{\"0\":[{\"a\":{\"\":[[{\"0\":[{\"a\":[{\"0\":[{\"0\":[[[[[{\"a\":{\"b.c\":[[[[[[[[[{\"a\":{\"\":[{\"\":[[[[{\"b.c\":{\"\":{\"0\":{\"a\":{\"\":{\"\":[[[[{\"0\":{\"\":{\"0\":{\"b.c\":[[{\"b.c\":{\"b.c\":{\"\":{\"a\":{\"a\":[[[[{\"a\":{\"\":[[{\"b.c\":[[{\"a\":[[[[{\"0\":[[[{\"0\":[[{\"b.c\":{\"b.c\":{\"a\":{\"\":[{\"b.c\":[{\"\":{\"a\":[{\"\":{\"0\":{\"\":{\"a\":[true]}}}}]}}]}]}}}}]]}]]]}]]]]}]]}]]}}]]]]}}}}}]]}}}}]]]]}}}}}}]]]]}]}}]]]]]]]]]}}]]]]]}]}]}]}]]}}]}}}]]]]]]}]}]}]}}}]]]]]]]}]}]]]}]","output":{"ok":true,"s":"[{\"\":[[[{\"a\":[{\"a\":[[[[[[[{\"b.c\":{\"0\":{\"0\":[{\"\":[{\"\":[{\"b.c\":[[[[[[{\"b.c\":{\"\":{\"0\":[{\"a\":{\"\":[[{\"0\":[{\"a\":[{\"0\":[{\"0\":[[[[[{\"a\":{\"b.c\":[[[[[[[[[{\"a\":{\"\":[{\"\":[[[[{\"b.c\":{\"\":{\"0\":{\"a\":{\"\":{\"\":[[[[{\"0\":{\"\":{\"0\":{\"b.c\":[[{\"b.c\":{\"b.c\":{\"\":{\"a\":{\"a\":[[[[{\"a\":{\"\":[[{\"b.c\":[[{\"a\":[[[[{\"0\":[[[{\"0\":[[{\"b.c\":{\"b.c\":{\"a\":{\"\":[{\"b.c\":[{\"\":{\"a\":[{\"\":{\"0\":{\"\":{\"a\":[true]}}}}]}}]}]}}}}]]}]]]}]]]]}]]}]]}}]]]]}}}}}]]}}}}]]]]}}}}}}]]]]}]}}]]]]]]]]]}}]]]]]}]}]}]}]]}}]}}}]]]]]]}]}]}]}}}]]]]]]]}]}]]]}]"}},{"input":"{\"100\":{\"length\":[100,[\"-1e400 192.168.0.1 \",[-18086222000420092,[\"ﭻ\",[true,\"__proto__\"],null]],true,[[\"429496729512 \\r\\n \",false,{\"3\":true,\"9\":100,\"user_123\":\"user_123\"},\"x\\ude80 .5-1\",{\"10\"\\ud83d\\ude80:null,\"�1e-7\":null,\"constructor\":null,\"deadbeef\":true,\"\":-4.865107741206885e-16,\"1e400\":\"\\n12345678ݨ\",\"msg\":null,\"\\r\\n \":null},\"xoxb-1234567890-abc1,5 \",true,\"🚀\",\"NaN 1.5\",true,{\"k\":null},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}}","output":{"ok":false}},{"input":"{}","output":{"ok":true,"s":"{}"}},{"input":"{\"__proto__\":1,\"b\":2,\"__proto__\":3}","output":{"ok":true,"s":"{\"__proto__\":3,\"b\":2}"}},{"input":"{\"level\":false,\"�\":{\"3\":\"0.1 \",\"host.example.com\":\"\"},\"13\":true,\"http.method\":{\"49\":[\"1e400\",999.9999999,\"null\",4294967295,{\"10\":\"\\\" \"},1,1,1,1,11,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\"4294967295\":\"1e3\"}}","output":{"ok":true,"s":"{\"13\":true,\"level\":false,\"�\":{\"3\":\"0.1 \",\"host.example.com\":\"\"},\"http.method\":{\"49\":[\"1e400\",999.9999999,\"null\",4294967295,{\"10\":\"\\\" \"},1,1,1,1,11,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\"4294967295\":\"1e3\"}}"}},{"input":"12.5","output":{"ok":true,"s":"12.5"}},{"input":"01.e ","output":{"ok":false}},{"input":"\t00.e-323 ","output":{"ok":false}},{"input":"{\"壡\":null,\"full 2001:db8::1\":\" 12\",\"payload\":[123456789012345680000,-9007199254740992],\"🚀\":{\"0\":{\"3\":\"\\t\",\"9\":\"մ b \",\"𐀀\":\"x\",\"deadbeef\":{\"4294967294\":{\"é\":{\"4294967295\":{\"2\":\"1e30.1\",\"3\":\"Ǯ枙\",\"5\":1.7976931348623157e+308,\"9\":\"t POST\",\"10\":1,\"4294967294\":null,\"error/api/v1/users/123\":null,\"deadbeef\":true,\"K\":\"x \",\" 2001:db8::1 \":null,\"4294967296\":\"12eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 \\\\ \",\"\":\"fatal日本語\",\"01\":\"192.168.1.1 日本語 \"}}}}},\"2\":\"1e400\",\"1e3\":\"9007199254740992a\\\\nbBearer abc.def-ghi\",\"é\":null,\"__proto__\":\"null a.日本\",\"K\":\"123456789012345680000 \",\"[email protected]\\r\\n\":\"2001:db8::1 \",\"\":123456789012345680000,\"-1. \":\"ééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééa.INFO \",\"host.example.com\":true,\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":9007199254740992}}","output":{"ok":true,"s":"{\"壡\":null,\"full 2001:db8::1\":\" 12\",\"payload\":[123456789012345680000,-9007199254740992],\"🚀\":{\"0\":{\"3\":\"\\t\",\"9\":\"մ b \",\"𐀀\":\"x\",\"deadbeef\":{\"4294967294\":{\"é\":{\"4294967295\":{\"2\":\"1e30.1\",\"3\":\"Ǯ枙\",\"5\":1.7976931348623157e+308,\"9\":\"t POST\",\"10\":1,\"4294967294\":null,\"error/api/v1/users/123\":null,\"deadbeef\":true,\"K\":\"x \",\" 2001:db8::1 \":null,\"4294967296\":\"12eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 \\\\ \",\"\":\"fatal日本語\",\"01\":\"192.168.1.1 日本語 \"}}}}},\"2\":\"1e400\",\"1e3\":\"9007199254740992a\\\\nbBearer abc.def-ghi\",\"é\":null,\"__proto__\":\"null a.日本\",\"K\":\"123456789012345680000 \",\"[email protected]\\r\\n\":\"2001:db8::1 \",\"\":123456789012345680000,\"-1. \":\"ééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééa.INFO \",\"host.example.com\":true,\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":9007199254740992}}"}},{"input":"[\" 12L🚀 \",\"full 12 \",\"4294967295\",\"3fa85f64-5717-4562-b3fc-2c963f66afa60x10 0x10 \",{\"100\":\"Wed, 15 Jan 2025 12:00:00 GMT\",\"日本3fa85f64-5717-4562-b3fc-2c963f66afa6\":null,\"\":\"1,5\",\"\\\\\":false,\"user.email\":\"🚀 1e400\"},\"1.7976931348623157e+308\",{\"message\":null,\" \":{\"0\":\"0𝣼Bearer abc.def-ghi \",\"49\":{\"user.email\":\"00 K\",\"..\":[\"AKIAIOSFODNN7EXAMPLE\",false,\"🍛 \",false,[false,{\"5\":true,\"10\":\" 12 GETa \",\"𐀀\":true,\"1.5\":null,\"\":true},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1]},\"4294967294\":0,\"-1\":{\"1\":null,\"10\":\"fatal \\n b\",\"-1\":\"00012\",\"http.method\":false,\"__proto__\":null},\" \":\"🚀 \"}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","output":{"ok":true,"s":"[\" 12L🚀 \",\"full 12 \",\"4294967295\",\"3fa85f64-5717-4562-b3fc-2c963f66afa60x10 0x10 \",{\"100\":\"Wed, 15 Jan 2025 12:00:00 GMT\",\"日本3fa85f64-5717-4562-b3fc-2c963f66afa6\":null,\"\":\"1,5\",\"\\\\\":false,\"user.email\":\"🚀 1e400\"},\"1.7976931348623157e+308\",{\"message\":null,\" \":{\"0\":\"0𝣼Bearer abc.def-ghi \",\"49\":{\"user.email\":\"00 K\",\"..\":[\"AKIAIOSFODNN7EXAMPLE\",false,\"🍛 \",false,[false,{\"5\":true,\"10\":\" 12 GETa \",\"𐀀\":true,\"1.5\":null,\"\":true},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1]},\"4294967294\":0,\"-1\":{\"1\":null,\"10\":\"fatal \\n b\",\"-1\":\"00012\",\"http.method\":false,\"__proto__\":null},\" \":\"🚀 \"}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]"}},{"input":"-01.000001E+0 ","output":{"ok":false}},{"input":"true","output":{"ok":true,"s":"true"}},{"input":"{\"0\":null,\"1\":{\"9\":{\"10\":1.2535080080851912e-13,\"é\":\"..2001:db8::10.30000000000000004\",\".a\":true},\"constructor\":\"[1,2]\",\"event\":{\"100\":true,\"\"\\ud83d:[\"3fa85f64-5717-4562-b3fc-2c963f66afa6 \"],\"🚀 \":false}},\"2\":999.9999999,\"100\":\"0x10 \",\"4294967294\":\"0o7 GETŸ\",\"192.168.0.1\":null,\"\":false,\"__proto__\":\"0b11deadbeef\",\"é\":[null,{},null,\" user_123 \",\"K 2001:db8::1\",-1.5,false,\"5e-324Bearer abc.def-ghi2\",\"\\n1e3\",false],\"4294967296\":{},\"user_123\":[0,true],\"level\":null,\"debug-9007199254740992\":null,\"\":\"ERROR1e+21𓋼 \",\"deadbeef\":{\"2\":\"𗲫1e400\"}}","output":{"ok":false}},{"input":"true","output":{"ok":true,"s":"true"}},{"input":"null","output":{"ok":true,"s":"null"}},{"input":"-01.5","output":{"ok":false}},{"input":"[]","output":{"ok":true,"s":"[]"}},{"input":" -9007199254740993e308 ","output":{"ok":false}},{"input":"\"125abcx\\t] ","output":{"ok":false}},{"input":"[[[[[[[[{\"\":[{\"0\":{\"b.c\":[[[[[[[{\"\":{\"\":[{\"b.c\":[[{\"\":{\"\":{\"\":[{\"b.c\":{\"b.c\":{\"a\":{\"a\":{\"0\":{\"b.c\":[[{\"a\":{\"0\":[{\"\":[{\"b.c\":[{\"0\":{\"b.c\":{\"b.c\":[{\"\":{\"b.c\":[{\"a\":{\"b.c\":{\"b.c\":[{\"a\":{\"\":{\"a\":{\"0\":[{\"\":{\"a\":{\"b.c\":{\"a\":{\"0\":[[[{\"\":{\"b.c\":[[{\"b.c\":[[[{\"b.c\":{\"0\":[[[{\"\":[{\"b.c\":[[{\"0\":{\"a\":{\"\":[[{\"\":{\"b.c\":[[{\"a\":{\"0\":{\"0\":[{\"b.c\":[{\"0\":{\"b.c\":{\"0\":[{\"a\":{\"a\":[[[{\"a\":{\"b.c\":{\"0\":{\"\":[{\"0\":[[{\"0\":{\"\":[{\"\":{\"\":{\"a\":[{\"0\":[{\"\":1}]}]}}}]}}]]}]}}}}]]]}}]}}}]}]}}}]]}}]]}}}]]}]}]]]}}]]]}]]}}]]]}}}}}]}}}}]}}}]}}]}}}]}]}]}}]]}}}}}}]}}}]]}]}}]]]]]]]}}]}]]]]]]]]","output":{"ok":true,"s":"[[[[[[[[{\"\":[{\"0\":{\"b.c\":[[[[[[[{\"\":{\"\":[{\"b.c\":[[{\"\":{\"\":{\"\":[{\"b.c\":{\"b.c\":{\"a\":{\"a\":{\"0\":{\"b.c\":[[{\"a\":{\"0\":[{\"\":[{\"b.c\":[{\"0\":{\"b.c\":{\"b.c\":[{\"\":{\"b.c\":[{\"a\":{\"b.c\":{\"b.c\":[{\"a\":{\"\":{\"a\":{\"0\":[{\"\":{\"a\":{\"b.c\":{\"a\":{\"0\":[[[{\"\":{\"b.c\":[[{\"b.c\":[[[{\"b.c\":{\"0\":[[[{\"\":[{\"b.c\":[[{\"0\":{\"a\":{\"\":[[{\"\":{\"b.c\":[[{\"a\":{\"0\":{\"0\":[{\"b.c\":[{\"0\":{\"b.c\":{\"0\":[{\"a\":{\"a\":[[[{\"a\":{\"b.c\":{\"0\":{\"\":[{\"0\":[[{\"0\":{\"\":[{\"\":{\"\":{\"a\":[{\"0\":[{\"\":1}]}]}}}]}}]]}]}}}}]]]}}]}}}]}]}}}]]}}]]}}}]]}]}]]]}}]]]}]]}}]]]}}}}}]}}}}]}}}]}}]}}}]}]}]}}]]}}}}}}]}}}]]}]}}]]]]]]]}}]}]]]]]]]]"}},{"input":"null","output":{"ok":true,"s":"null"}},{"input":"[]","output":{"ok":true,"s":"[]"}},{"input":" +123456789012345678901234567890.e-400","output":{"ok":false}},{"input":" --123456789012345678901234567890.5e-323 ","output":{"ok":false}},{"input":"\t+123456789012345678901234567890 ","output":{"ok":false}},{"input":"\"eventWed, 15 Jan 2025 12:00:00 GMT\"","output":{"ok":true,"s":"\"eventWed, 15 Jan 2025 12:00:00 GMT\""}},{"input":"\u000b--9007199254740993e-323","output":{"ok":false}},{"input":"false","output":{"ok":true,"s":"false"}},{"input":"{\"3\":\"debugfatalAKIAIOSFODNN7EXAMPLE\",\"full\":\"{ \",\"Wed, 15 Jan 2025 12:00:00 GMT\":{\"9\":{\"1\":\"212.5abc\",\"100\":\"ghp_0123456789abcdefghij0123456789abcdef eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\",\"K\":true,\"%AKIAIOSFODNN7EXAMPLE\":[{\"9\":[null,{\"2\":null,\"49\":\"/api/v1/users/123 INFO\",\"51\":\"level a\\\\nb{\\\"a\\\":1}\",\" 0b11\":4230732244905.0845,\"K\":\"true12\",\".a\":7,\"valueOf\":null,\"x\\ude80/api/v1/users/123 {\\\"a\\\":1}\":\"\\\"__proto__\",\"__proto__\":null,\"1.51.5\":100,\"4294967295\":\"0x10\",\"a.\":\" 12000\"},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},\"level\":\"level \\u000bGET \",\"1e3\":\"INFOuser_123__defineGetter__\",\"GET eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\":{\"10\":\"m0112.5 \",\"1.5\":true,\"truenull\":4294967295,\"host.example.com\":{\"k\":{\"debug -Infinity\":true,\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":\"靥\"}},\"constructor\":-1.5,\"4294967295\":\"__proto__\",\"\\n\":\"0fatal \",\"__proto__\":\"4294967295warn100\"}}}","output":{"ok":true,"s":"{\"3\":\"debugfatalAKIAIOSFODNN7EXAMPLE\",\"full\":\"{ \",\"Wed, 15 Jan 2025 12:00:00 GMT\":{\"9\":{\"1\":\"212.5abc\",\"100\":\"ghp_0123456789abcdefghij0123456789abcdef eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\",\"K\":true,\"%AKIAIOSFODNN7EXAMPLE\":[{\"9\":[null,{\"2\":null,\"49\":\"/api/v1/users/123 INFO\",\"51\":\"level a\\\\nb{\\\"a\\\":1}\",\" 0b11\":4230732244905.0845,\"K\":\"true12\",\".a\":7,\"valueOf\":null,\"x\\ude80/api/v1/users/123 {\\\"a\\\":1}\":\"\\\"__proto__\",\"__proto__\":null,\"1.51.5\":100,\"4294967295\":\"0x10\",\"a.\":\" 12000\"},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},\"level\":\"level \\u000bGET \",\"1e3\":\"INFOuser_123__defineGetter__\",\"GET eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\":{\"10\":\"m0112.5 \",\"1.5\":true,\"truenull\":4294967295,\"host.example.com\":{\"k\":{\"debug -Infinity\":true,\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":\"靥\"}},\"constructor\":-1.5,\"4294967295\":\"__proto__\",\"\\n\":\"0fatal \",\"__proto__\":\"4294967295warn100\"}}}"}},{"input":"{\"50\":null}","output":{"ok":true,"s":"{\"50\":null}"}},{"input":"\n01.0e309 ","output":{"ok":false}},{"input":"{\"0\":null,\"49\":{\"é\":{\"0\":{\"full\":{\"51\":0,\"a\":{\"\\t\":[\"b Wed, 15 Jan 2025 12:00:00 GMT9007199254740993 \",null,true,\"0b11null㒐\",1,1,1,1,1,1]}}},\"[email protected] \":\"🚀 ^ Wed, 15 Jan 12025 12:00:00 GMT \"}},\"user.email\":\"12 \\r\\n\"}","output":{"ok":true,"s":"{\"0\":null,\"49\":{\"é\":{\"0\":{\"full\":{\"51\":0,\"a\":{\"\\t\":[\"b Wed, 15 Jan 2025 12:00:00 GMT9007199254740993 \",null,true,\"0b11null㒐\",1,1,1,1,1,1]}}},\"[email protected] \":\"🚀 ^ Wed, 15 Jan 12025 12:00:00 GMT \"}},\"user.email\":\"12 \\r\\n\"}"}},{"input":"[{\"a\":[{\"\":{\"\":{\"\":{\"0\":{\"0\":[[{\"0\":[{\"a\":{\"a\":[{\"0\":[[[{\"\":[{\"b.c\":[{\"\":{\"0\":[{\"0\":[[[[[{\"0\":[{\"b.c\":{\"\":{\"b.c\":[[[{\"b.c\":{\"0\":[{\"a\":[[[[[{\"b.c\":[{\"b.c\":{\"a\":{\"b.c\":{\"a\":[[[{\"0\":[[[[{\"a\":{\"a\":{\"\":{\"\":[[[[[[{\"0\":[{\"a\":{\"b.c\":[{\"0\":{\"\":[[{\"0\":{\"a\":{\"\":[{\"b.c\":{\"0\":{\"b.c\":[[[{\"\":[{\"a\":{\"b.c\":[{\"\":{\"0\":{\"\":{\"0\":{\"0\":{\"\":{\"\":{\"\":[[[[[{\"a\":[{\"a\":{\"a\":{\"a\":{\"b.c\":{\"b.c\":[[{\"a\":[{\"b.c\":[[{\"a\":[[{\"b.c\":{\"a\":{\"\":\"v\"}}}]]}]]}]}]]}}}}}]}]]]]]}}}}}}}}]}}]}]]]}}}]}}}]]}}]}}]}]]]]]]}}}}]]]]}]]]}}}}]}]]]]]}]}}]]]}}}]}]]]]]}]}}]}]}]]]}]}}]}]]}}}}}]}]","output":{"ok":true,"s":"[{\"a\":[{\"\":{\"\":{\"\":{\"0\":{\"0\":[[{\"0\":[{\"a\":{\"a\":[{\"0\":[[[{\"\":[{\"b.c\":[{\"\":{\"0\":[{\"0\":[[[[[{\"0\":[{\"b.c\":{\"\":{\"b.c\":[[[{\"b.c\":{\"0\":[{\"a\":[[[[[{\"b.c\":[{\"b.c\":{\"a\":{\"b.c\":{\"a\":[[[{\"0\":[[[[{\"a\":{\"a\":{\"\":{\"\":[[[[[[{\"0\":[{\"a\":{\"b.c\":[{\"0\":{\"\":[[{\"0\":{\"a\":{\"\":[{\"b.c\":{\"0\":{\"b.c\":[[[{\"\":[{\"a\":{\"b.c\":[{\"\":{\"0\":{\"\":{\"0\":{\"0\":{\"\":{\"\":{\"\":[[[[[{\"a\":[{\"a\":{\"a\":{\"a\":{\"b.c\":{\"b.c\":[[{\"a\":[{\"b.c\":[[{\"a\":[[{\"b.c\":{\"a\":{\"\":\"v\"}}}]]}]]}]}]]}}}}}]}]]]]]}}}}}}}}]}}]}]]]}}}]}}}]]}}]}}]}]]]]]]}}}}]]]]}]]]}}}}]}]]]]]}]}}]]]}}}]}]]]]]}]}}]}]}]]]}]}}]}]]}}}}}]}]"}},{"input":"\n9007199254740993.e308 ","output":{"ok":false}},{"input":"0.000001","output":{"ok":true,"s":"0.000001"}},{"input":"{\"1\":null,\"1.5\":{\"\\udfff1\":null,\"�\":9007199254740992}}","output":{"ok":true,"s":"{\"1\":null,\"1.5\":{\"\\udfff1\":null,\"�\":9007199254740992}}"}},{"input":" -5.5e-5 ","output":{"ok":false}},{"input":"{\"1\":1,\"b\":2,\"1\":null}","output":{"ok":true,"s":"{\"1\":null,\"b\":2}"}},{"input":"[[[{\"a\":{\"a\":[{\"b.c\":{\"a\":{\"a\":{\"0\":[{\"\":{\"b.c\":{\"\":{\"b.c\":{\"0\":[[[[{\"b.c\":[[[[[{\"0\":[[{\"b.c\":[[[[{\"b.c\":[[[[{\"a\":[{\"a\":[{\"0\":{\"b.c\":{\"b.c\":[[[[{\"0\":{\"a\":[{\"b.c\":{\"0\":[{\"b.c\":[[{\"b.c\":{\"a\":{\"\":{\"a\":{\"b.c\":[{\"0\":{\"b.c\":{\"\":[{\"b.c\":{\"\":[[{\"a\":{\"\":{\"a\":{\"a\":{\"0\":[[[[{\"a\":{\"\":{\"b.c\":{\"\":{\"b.c\":[{\"a\":[{\"\":[[{\"\":[[{\"a\":[{\"0\":{\"\":[[[[[{\"\":{\"\":{\"b.c\":{\"\":[[[{\"a\":{\"b.c\":{\"0\":{\"0\":[{\"\":{\"\":[{\"\":[{\"\":{\"\":[{\"b.c\":true}]}}]}]}}]}}}}]]]}}}}]]]]]}}]}]]}]]}]}]}}}}}]]]]}}}}}]]}}]}}}]}}}}}]]}]}}]}}]]]]}}}]}]}]]]]}]]]]}]]}]]]]]}]]]]}}}}}]}}}}]}}]]]","output":{"ok":true,"s":"[[[{\"a\":{\"a\":[{\"b.c\":{\"a\":{\"a\":{\"0\":[{\"\":{\"b.c\":{\"\":{\"b.c\":{\"0\":[[[[{\"b.c\":[[[[[{\"0\":[[{\"b.c\":[[[[{\"b.c\":[[[[{\"a\":[{\"a\":[{\"0\":{\"b.c\":{\"b.c\":[[[[{\"0\":{\"a\":[{\"b.c\":{\"0\":[{\"b.c\":[[{\"b.c\":{\"a\":{\"\":{\"a\":{\"b.c\":[{\"0\":{\"b.c\":{\"\":[{\"b.c\":{\"\":[[{\"a\":{\"\":{\"a\":{\"a\":{\"0\":[[[[{\"a\":{\"\":{\"b.c\":{\"\":{\"b.c\":[{\"a\":[{\"\":[[{\"\":[[{\"a\":[{\"0\":{\"\":[[[[[{\"\":{\"\":{\"b.c\":{\"\":[[[{\"a\":{\"b.c\":{\"0\":{\"0\":[{\"\":{\"\":[{\"\":[{\"\":{\"\":[{\"b.c\":true}]}}]}]}}]}}}}]]]}}}}]]]]]}}]}]]}]]}]}]}}}}}]]]]}}}}}]]}}]}}}]}}}}}]]}]}}]}}]]]]}}}]}]}]]]]}]]]]}]]}]]]]]}]]]]}}}}}]}}}}]}}]]]"}},{"input":"\"121,5 \\\"\"","output":{"ok":true,"s":"\"121,5 \\\"\""}},{"input":"\"]ghp_0123456789abcdefghij0123456789abcdef\"","output":{"ok":true,"s":"\"]ghp_0123456789abcdefghij0123456789abcdef\""}},{"input":"--01.0E+0 ","output":{"ok":false}},{"input":"\"12345678901234568.0000 InfinityWed, 15 Jan 2025 12:00:00 GMT\"","output":{"ok":true,"s":"\"12345678901234568.0000 InfinityWed, 15 Jan 2025 12:00:00 GMT\""}},{"input":"-.0e309 ","output":{"ok":false}},{"input":"[{\"3\":{\"51\":-4472158.155404031,\"\":null,\"-Infinity\":\"12\",\"\\\\\":0.30000000000000004,\"deadbeef\":[\"ééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\",{\"constructor\":100},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},\"valueOf\":\"é𐀀\",\"0b11 9007199254740993 \":\"ښ0x10 \",\"message\":4203.969251830131,\"\\n\":null},1]","output":{"ok":true,"s":"[{\"3\":{\"51\":-4472158.155404031,\"\":null,\"-Infinity\":\"12\",\"\\\\\":0.30000000000000004,\"deadbeef\":[\"ééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\",{\"constructor\":100},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},\"valueOf\":\"é𐀀\",\"0b11 9007199254740993 \":\"ښ0x10 \",\"message\":4203.969251830131,\"\\n\":null},1]"}},{"input":"{\"9007199254740993\":{\"3\":123456789012345680000,\"10\":null}}","output":{"ok":true,"s":"{\"9007199254740993\":{\"3\":123456789012345680000,\"10\":null}}"}},{"input":"{\"0\":\" +5 12 \",\"51\":[false,{\"9\":{\"0\":\"12 4294967295𐀀 \",\"100\":null,\"\":\"2.5e-8a\\\\nbᾎ \",\"K\":-259.7035651560873,\"__proto__\":\"adeadbeef \",\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":[-3067545965313.9116,null,\"0o7 \",null,{\"10\":\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 \",\"100\":null,\"�\":null,\"\\ud83duser_123\":[null,true,null,\"msgfatal\",\"10 host.example.com\",\"ghp_0123456789abcdefghij0123456789abcdef𐀀 [email protected]\",\"\",null,\"\",\"3fa85f64-5717-4562-b3fc-2c963f66afa6\",100,-4167784964665770500,\"\\\\host.example.com \",null,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1]}}],\"100\":null,\"4294967294\":true,\"user.email12\":null,\"a.b\":null}","output":{"ok":true,"s":"{\"0\":\" +5 12 \",\"51\":[false,{\"9\":{\"0\":\"12 4294967295𐀀 \",\"100\":null,\"\":\"2.5e-8a\\\\nbᾎ \",\"K\":-259.7035651560873,\"__proto__\":\"adeadbeef \",\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":[-3067545965313.9116,null,\"0o7 \",null,{\"10\":\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 \",\"100\":null,\"�\":null,\"\\ud83duser_123\":[null,true,null,\"msgfatal\",\"10 host.example.com\",\"ghp_0123456789abcdefghij0123456789abcdef𐀀 [email protected]\",\"\",null,\"\",\"3fa85f64-5717-4562-b3fc-2c963f66afa6\",100,-4167784964665770500,\"\\\\host.example.com \",null,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1]}}],\"100\":null,\"4294967294\":true,\"user.email12\":null,\"a.b\":null}"}},{"input":"{\"0\":1,\"b\":2,\"0\":3}","output":{"ok":true,"s":"{\"0\":3,\"b\":2}"}},{"input":"\"🚀1e-7 \"\\\\","output":{"ok":false}},{"input":"{\"5\":true,\"10\":\"[email protected] \",\"49\":true,\"50\":12.5,\"4294967294\":null\"\\\\0.30000000000000004\":null,\"a\":\"]ᅌ\",\"__defineGetter__\":28626894.019544125,\"user_123\":\"-1e400/api/v1/users/1231e3\",\"4294967295 \":5e-324,\"ğE \":{\"warn \":\"p éAKIAIOSFODNN7EXAMPLE\",\"日本\":\"1\\n-1e400 \"},\"01\":false}","output":{"ok":false}},{"input":" 123456789012345678901234567890.5e-323 ","output":{"ok":true,"s":"1.2345678901234568e-294"}},{"input":"null","output":{"ok":true,"s":"null"}},{"input":"true","output":{"ok":true,"s":"true"}},{"input":"{\"1e3\":{\"2\":[null,\"+5Wed, 15 Jan 2025 12:00:00 GMT \",null,{\"msg\":\" \",\"日本\":\"toStringϻ\",\"ܡ5e-324\":{\"3\":\"B 192.168.1.1\",\"\\\" .5\":{\"4294967294\":null,\"𐀀\":{\"0\":null,\"1\":25.411181477829814,\"2\":3909621152561158000,\"5\":\"Wed, 15 Jan 2025 12:00:00 GMT\",\"9\":\"12\",\"10\":\"12.5abcerrorInfinity\",\"12\":-20667978259734.81,\"50\":100,\"100\":\".a\",\"12345678\":\"𐀀4294967296 1,5\",\"𐀀\":\"true\",\"2001:db8::1 \":false,\"__proto__\":true,\"level\":false,\".a\":\"toString\",\"9007199254740993\":9007199254740992,\"payload\":null,\"user_123\":null,\"é\":\"123456789012345680000 4294967295 5.\",\"�\":\"payload 2025-01-15T10:00:00Z \\n\",\"k\":\"🚀 NaN \"}}}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\"AKIAIOSFODNN7EXAMPLE.a\":\"xoxb-1234567890-abc éhttp.method\",\"01\":\".adebug\",\"message\":null}}","output":{"ok":true,"s":"{\"1e3\":{\"2\":[null,\"+5Wed, 15 Jan 2025 12:00:00 GMT \",null,{\"msg\":\" \",\"日本\":\"toStringϻ\",\"ܡ5e-324\":{\"3\":\"B 192.168.1.1\",\"\\\" .5\":{\"4294967294\":null,\"𐀀\":{\"0\":null,\"1\":25.411181477829814,\"2\":3909621152561158000,\"5\":\"Wed, 15 Jan 2025 12:00:00 GMT\",\"9\":\"12\",\"10\":\"12.5abcerrorInfinity\",\"12\":-20667978259734.81,\"50\":100,\"100\":\".a\",\"12345678\":\"𐀀4294967296 1,5\",\"𐀀\":\"true\",\"2001:db8::1 \":false,\"__proto__\":true,\"level\":false,\".a\":\"toString\",\"9007199254740993\":9007199254740992,\"payload\":null,\"user_123\":null,\"é\":\"123456789012345680000 4294967295 5.\",\"�\":\"payload 2025-01-15T10:00:00Z \\n\",\"k\":\"🚀 NaN \"}}}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\"AKIAIOSFODNN7EXAMPLE.a\":\"xoxb-1234567890-abc éhttp.method\",\"01\":\".adebug\",\"message\":null}}"}},{"input":"fa-lse","output":{"ok":false}},{"input":"-1.5","output":{"ok":true,"s":"-1.5"}},{"input":"{\"a\":[[{\"\":[[{\"b.c\":{\"\":[[{\"\":{\"0\":[[{\"a\":{\"a\":[[[{\"b.c\":[{\"a\":{\"a\":{\"a\":{\"a\":{\"b.c\":[[[[[[[[[[[{\"b.c\":{\"\":{\"0\":[{\"\":{\"0\":{\"\":{\"\":{\"0\":[{\"a\":{\"0\":[[{\"a\":{\"\":{\"\":{\"a\":[[{\"\":{\"b.c\":{\"b.c\":[[{\"a\":[[[[[{\"\":{\"a\":{\"0\":{\"a\":{\"a\":{\"0\":{\"b.c\":{\"\":[[{\"0\":{\"a\":[{\"b.c\":[{\"b.c\":[[[{\"0\":[[{\"a\":[{\"\":[[{\"0\":[{\"\":{\"0\":[[[{\"b.c\":{\"b.c\":[[[{\"0\":{\"a\":{\"0\":{\"\":[[[[{\"\":[[[{\"0\":{\"\":[{\"0\":{\"b.c\":[[{\"0\":{\"a\":{\"b.c\":{\"0\":\"v\"}}}}]]}}]}}]]]}]]]]}}}}]]]}}]]]}}]}]]}]}]]}]]]}]}]}}]]}}}}}}}}]]]]]}]]}}}]]}}}}]]}}]}}}}}]}}}]]]]]]]]]]]}}}}}]}]]]}}]]}}]]}}]]}]]}","output":{"ok":true,"s":"{\"a\":[[{\"\":[[{\"b.c\":{\"\":[[{\"\":{\"0\":[[{\"a\":{\"a\":[[[{\"b.c\":[{\"a\":{\"a\":{\"a\":{\"a\":{\"b.c\":[[[[[[[[[[[{\"b.c\":{\"\":{\"0\":[{\"\":{\"0\":{\"\":{\"\":{\"0\":[{\"a\":{\"0\":[[{\"a\":{\"\":{\"\":{\"a\":[[{\"\":{\"b.c\":{\"b.c\":[[{\"a\":[[[[[{\"\":{\"a\":{\"0\":{\"a\":{\"a\":{\"0\":{\"b.c\":{\"\":[[{\"0\":{\"a\":[{\"b.c\":[{\"b.c\":[[[{\"0\":[[{\"a\":[{\"\":[[{\"0\":[{\"\":{\"0\":[[[{\"b.c\":{\"b.c\":[[[{\"0\":{\"a\":{\"0\":{\"\":[[[[{\"\":[[[{\"0\":{\"\":[{\"0\":{\"b.c\":[[{\"0\":{\"a\":{\"b.c\":{\"0\":\"v\"}}}}]]}}]}}]]]}]]]]}}}}]]]}}]]]}}]}]]}]}]]}]]]}]}]}}]]}}}}}}}}]]]]]}]]}}}]]}}}}]]}}]}}}}}]}}}]]]]]]]]]]]}}}}}]}]]]}}]]}}]]}}]]}]]}"}},{"input":"\"1e\\x41\"","output":{"ok":false}},{"input":"true","output":{"ok":true,"s":"true"}},{"input":" -5E+0 ","output":{"ok":false}},{"input":"{\"0\":[{\"0\":[{\"b.c\":[{\"a\":[[{\"a\":{\"b.c\":[[{\"b.c\":{\"b.c\":{\"\":{\"\":[{\"0\":[[{\"0\":[[[[[{\"a\":{\"a\":[{\"\":[{\"b.c\":{\"\":{\"a\":[[{\"0\":{\"0\":{\"0\":[{\"0\":{\"b.c\":[[[[{\"0\":[[{\"0\":[[{\"\":[{\"\":{\"a\":[{\"\":{\"b.c\":[[{\"\":[{\"a\":[[{\"0\":{\"a\":{\"b.c\":[{\"b.c\":[{\"0\":[{\"b.c\":{\"\":{\"b.c\":{\"a\":{\"\":{\"0\":{\"b.c\":[[{\"\":{\"\":[{\"0\":[[{\"0\":[[[[{\"a\":[[[[{\"\":{\"b.c\":[{\"\":[{\"\":[[{\"b.c\":[[[[[{\"b.c\":{\"a\":{\"b.c\":[[[[{\"\":{\"0\":[{\"b.c\":[[{\"\":[{\"b.c\":{\"a\":[[[[{\"0\":[{\"b.c\":[{\"a\":[[[[{\"0\":{\"0\":{\"0\":{\"\":{\"0\":[[[{\"0\":[[{\"a\":{\"\":[{\"a\":[{\"0\":{\"a\":[{\"\":[{\"0\":{\"b.c\":[{\"a\":{\"\":{\"b.c\":{\"\":[{\"\":[[{\"0\":{\"\":{\"\":{\"0\":{\"b.c\":[[[[{\"\":[[[{\"a\":{\"b.c\":[[[{\"b.c\":[[[{\"b.c\":[1]}]]]}]]]}}]]]}]]]]}}}}}]]}]}}}}]}}]}]}}]}]}}]]}]]]}}}}}]]]]}]}]}]]]]}}]}]]}]}}]]]]}}}]]]]]}]]}]}]}}]]]]}]]]]}]]}]}}]]}}}}}}}]}]}]}}}]]}]}]]}}]}}]}]]}]]}]]]]}}]}}}]]}}}]}]}}]]]]]}]]}]}}}}]]}}]]}]}]}]}","output":{"ok":true,"s":"{\"0\":[{\"0\":[{\"b.c\":[{\"a\":[[{\"a\":{\"b.c\":[[{\"b.c\":{\"b.c\":{\"\":{\"\":[{\"0\":[[{\"0\":[[[[[{\"a\":{\"a\":[{\"\":[{\"b.c\":{\"\":{\"a\":[[{\"0\":{\"0\":{\"0\":[{\"0\":{\"b.c\":[[[[{\"0\":[[{\"0\":[[{\"\":[{\"\":{\"a\":[{\"\":{\"b.c\":[[{\"\":[{\"a\":[[{\"0\":{\"a\":{\"b.c\":[{\"b.c\":[{\"0\":[{\"b.c\":{\"\":{\"b.c\":{\"a\":{\"\":{\"0\":{\"b.c\":[[{\"\":{\"\":[{\"0\":[[{\"0\":[[[[{\"a\":[[[[{\"\":{\"b.c\":[{\"\":[{\"\":[[{\"b.c\":[[[[[{\"b.c\":{\"a\":{\"b.c\":[[[[{\"\":{\"0\":[{\"b.c\":[[{\"\":[{\"b.c\":{\"a\":[[[[{\"0\":[{\"b.c\":[{\"a\":[[[[{\"0\":{\"0\":{\"0\":{\"\":{\"0\":[[[{\"0\":[[{\"a\":{\"\":[{\"a\":[{\"0\":{\"a\":[{\"\":[{\"0\":{\"b.c\":[{\"a\":{\"\":{\"b.c\":{\"\":[{\"\":[[{\"0\":{\"\":{\"\":{\"0\":{\"b.c\":[[[[{\"\":[[[{\"a\":{\"b.c\":[[[{\"b.c\":[[[{\"b.c\":[1]}]]]}]]]}}]]]}]]]]}}}}}]]}]}}}}]}}]}]}}]}]}}]]}]]]}}}}}]]]]}]}]}]]]]}}]}]]}]}}]]]]}}}]]]]]}]]}]}]}}]]]]}]]]]}]]}]}}]]}}}}}}}]}]}]}}}]]}]}]]}}]}}]}]]}]]}]]]]}}]}}}]]}}}]}]}}]]]]]}]]}]}}}}]]}}]]}]}]}]}"}},{"input":"null","output":{"ok":true,"s":"null"}},{"input":"{\"0\":{\"a\":{\"a\":[[{\"b.c\":[{\"b.c\":{\"\":[{\"b.c\":{\"b.c\":{\"b.c\":{\"0\":[{\"a\":[[{\"b.c\":{\"a\":{\"a\":{\"0\":[{\"b.c\":{\"0\":[{\"b.c\":{\"\":[[{\"\":{\"0\":[{\"b.c\":{\"0\":{\"0\":{\"a\":{\"0\":[[{\"a\":[{\"0\":[[{\"a\":{\"0\":{\"b.c\":[{\"0\":[[{\"a\":{\"0\":{\"b.c\":{\"\":{\"0\":{\"0\":[{\"\":{\"0\":{\"\":[[[[[{\"a\":{\"\":{\"0\":[[{\"a\":[[{\"a\":{\"0\":[{\"a\":[[{\"\":[[[{\"\":{\"a\":{\"0\":{\"0\":[{\"\":{\"b.c\":[{\"0\":{\"\":{\"a\":[{\"0\":{\"0\":[[{\"0\":[[[{\"a\":[{\"0\":{\"0\":{\"\":[[[[[{\"b.c\":[[[[{\"b.c\":[{\"a\":{\"a\":{\"0\":[{\"a\":{\"\":1}}]}}}]}]]]]}]]]]]}}}]}]]]}]]}}]}}}]}}]}}}}]]]}]]}]}}]]}]]}}}]]]]]}}}]}}}}}}]]}]}}}]]}]}]]}}}}}]}}]]}}]}}]}}}}]]}]}}}}]}}]}]]}}}","output":{"ok":true,"s":"{\"0\":{\"a\":{\"a\":[[{\"b.c\":[{\"b.c\":{\"\":[{\"b.c\":{\"b.c\":{\"b.c\":{\"0\":[{\"a\":[[{\"b.c\":{\"a\":{\"a\":{\"0\":[{\"b.c\":{\"0\":[{\"b.c\":{\"\":[[{\"\":{\"0\":[{\"b.c\":{\"0\":{\"0\":{\"a\":{\"0\":[[{\"a\":[{\"0\":[[{\"a\":{\"0\":{\"b.c\":[{\"0\":[[{\"a\":{\"0\":{\"b.c\":{\"\":{\"0\":{\"0\":[{\"\":{\"0\":{\"\":[[[[[{\"a\":{\"\":{\"0\":[[{\"a\":[[{\"a\":{\"0\":[{\"a\":[[{\"\":[[[{\"\":{\"a\":{\"0\":{\"0\":[{\"\":{\"b.c\":[{\"0\":{\"\":{\"a\":[{\"0\":{\"0\":[[{\"0\":[[[{\"a\":[{\"0\":{\"0\":{\"\":[[[[[{\"b.c\":[[[[{\"b.c\":[{\"a\":{\"a\":{\"0\":[{\"a\":{\"\":1}}]}}}]}]]]]}]]]]]}}}]}]]]}]]}}]}}}]}}]}}}}]]]}]]}]}}]]}]]}}}]]]]]}}}]}}}}}}]]}]}}}]]}]}]]}}}}}]}}]]}}]}}]}}}}]]}]}}}}]}}]}]]}}}"}},{"input":"{}","output":{"ok":true,"s":"{}"}},{"input":"\r-0.12345678901234567890e-7 ","output":{"ok":false}},{"input":"{\"b.c\":{\"\":[[[{\"b.c\":[{\"\":[[[[[[{\"b.c\":{\"\":[[[[{\"\":[[{\"\":{\"0\":[[{\"b.c\":[[{\"b.c\":{\"a\":{\"\":{\"0\":[[{\"0\":[{\"0\":[[{\"\":{\"0\":{\"\":[{\"b.c\":[{\"0\":{\"0\":[{\"0\":[{\"b.c\":{\"a\":{\"0\":[{\"0\":[{\"a\":[[{\"a\":{\"b.c\":[[[{\"\":{\"\":[[[{\"\":{\"\":[{\"\":{\"a\":{\"a\":[[{\"b.c\":[{\"0\":{\"\":[[[[{\"b.c\":{\"\":{\"a\":[[[[[[[[{\"0\":{\"b.c\":{\"b.c\":[{\"\":[{\"0\":[{\"b.c\":[[[{\"a\":[[{\"0\":{\"b.c\":[{\"0\":[[{\"0\":{\"a\":[{\"a\":{\"a\":[[{\"0\":{\"0\":{\"a\":{\"\":null}}}}]]}}]}}]]}]}}]]}]]]}]}]}]}}}]]]]]]]]}}}]]]]}}]}]]}}}]}}]]]}}]]]}}]]}]}]}}}]}]}}]}]}}}]]}]}]]}}}}]]}]]}}]]}]]]]}}]]]]]]}]}]]]}}","output":{"ok":true,"s":"{\"b.c\":{\"\":[[[{\"b.c\":[{\"\":[[[[[[{\"b.c\":{\"\":[[[[{\"\":[[{\"\":{\"0\":[[{\"b.c\":[[{\"b.c\":{\"a\":{\"\":{\"0\":[[{\"0\":[{\"0\":[[{\"\":{\"0\":{\"\":[{\"b.c\":[{\"0\":{\"0\":[{\"0\":[{\"b.c\":{\"a\":{\"0\":[{\"0\":[{\"a\":[[{\"a\":{\"b.c\":[[[{\"\":{\"\":[[[{\"\":{\"\":[{\"\":{\"a\":{\"a\":[[{\"b.c\":[{\"0\":{\"\":[[[[{\"b.c\":{\"\":{\"a\":[[[[[[[[{\"0\":{\"b.c\":{\"b.c\":[{\"\":[{\"0\":[{\"b.c\":[[[{\"a\":[[{\"0\":{\"b.c\":[{\"0\":[[{\"0\":{\"a\":[{\"a\":{\"a\":[[{\"0\":{\"0\":{\"a\":{\"\":null}}}}]]}}]}}]]}]}}]]}]]]}]}]}]}}}]]]]]]]]}}}]]]]}}]}]]}}}]}}]]]}}]]]}}]]}]}]}}}]}]}}]}]}}}]]}]}]]}}}}]]}]]}}]]}]]]]}}]]]]]]}]}]]]}}"}},{"input":"null","output":{"ok":true,"s":"null"}},{"input":"{\"k\":{\"toString\":[false,100,\"constructor-0/api/v1/users/123\",{\"49\":[[\"-1e400\",true,{\"1\":0,\"3\":true,\"5\":null,\"9\":\"1e+21valueOf \",\"10\":\"user_123 -Infinityé\",\"49\":null,\"1e3\":\"0o7ERROR \",\"日本\":false,\"\\n\":\"ᰡ\",\"user_123\":null,\"deadbeef\":\"4294967294\",\" T\":\"10 error \",\"-1\":null,\"4294967295\":15864358.423277736,\"[1,2] \":null,\"valueOf\":1.7976931348623157e+308,\"𐀀\":\"1e+1000.1\\\\\",\"host.example.com\":false,\"a.b\":\"Infinity-0 \",\"a\":null,\"\\\"\":\"192.168.0.1\",\"日本語\":\"0o7 \",\"msg\":\"002025-01-15T10:00:00Z\"},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}}","output":{"ok":true,"s":"{\"k\":{\"toString\":[false,100,\"constructor-0/api/v1/users/123\",{\"49\":[[\"-1e400\",true,{\"1\":0,\"3\":true,\"5\":null,\"9\":\"1e+21valueOf \",\"10\":\"user_123 -Infinityé\",\"49\":null,\"1e3\":\"0o7ERROR \",\"日本\":false,\"\\n\":\"ᰡ\",\"user_123\":null,\"deadbeef\":\"4294967294\",\" T\":\"10 error \",\"-1\":null,\"4294967295\":15864358.423277736,\"[1,2] \":null,\"valueOf\":1.7976931348623157e+308,\"𐀀\":\"1e+1000.1\\\\\",\"host.example.com\":false,\"a.b\":\"Infinity-0 \",\"a\":null,\"\\\"\":\"192.168.0.1\",\"日本語\":\"0o7 \",\"msg\":\"002025-01-15T10:00:00Z\"},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}}"}},{"input":"\"a.GET\"","output":{"ok":true,"s":"\"a.GET\""}},{"input":"-0.00002943026288412511","output":{"ok":true,"s":"-0.00002943026288412511"}},{"input":"-3217635084.874928","output":{"ok":true,"s":"-3217635084.874928"}},{"input":"-9007199254740992","output":{"ok":true,"s":"-9007199254740992"}},{"input":" 0.12345678901234567890 ","output":{"ok":false}},{"input":"{\"4294967294\":\"ERROR\",\"__defineGetter__\":\"日本éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé 12.5abc\",\"message\":\"\\u000b1,5\",\"192.168.0.1\":{\"0\":0.000001,\"1\":\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123-Infinity -9007199254740992\",\"4294967294\":null,\"\\t\":123456789012345680000,\"payload\":true,\"Bearer abc.def-ghi\":false,\"__proto__\":7,\"a\":null,\"� 𐀀 \":0,\"ޛ\":[false,{\"192.168.0.1\":\"1,5 é -1\",\"日本\":[false,\"00 日本 \",null,100,[{\"1\":4.305523808579892e-11,\"\\\"\":42038370.31964213,\"9007199254740993\":null,\"K\":1,\"4294967295\":true},null,\"0\",{\"2\":true,\"51\":\"http.method /api/v1/users/123\",\"12345678\":null,\"a.b\":\"2025-01-15T10:00:00Z\",\"event\":\" \",\"\\t\":true},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}}","output":{"ok":true,"s":"{\"4294967294\":\"ERROR\",\"__defineGetter__\":\"日本éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé 12.5abc\",\"message\":\"\\u000b1,5\",\"192.168.0.1\":{\"0\":0.000001,\"1\":\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123-Infinity -9007199254740992\",\"4294967294\":null,\"\\t\":123456789012345680000,\"payload\":true,\"Bearer abc.def-ghi\":false,\"__proto__\":7,\"a\":null,\"� 𐀀 \":0,\"ޛ\":[false,{\"192.168.0.1\":\"1,5 é -1\",\"日本\":[false,\"00 日本 \",null,100,[{\"1\":4.305523808579892e-11,\"\\\"\":42038370.31964213,\"9007199254740993\":null,\"K\":1,\"4294967295\":true},null,\"0\",{\"2\":true,\"51\":\"http.method /api/v1/users/123\",\"12345678\":null,\"a.b\":\"2025-01-15T10:00:00Z\",\"event\":\" \",\"\\t\":true},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}}"}},{"input":"{\"\\/\\ud83duser.email\":null}","output":{"ok":true,"s":"{\"/\\ud83duser.email\":null}"}},{"input":"true","output":{"ok":true,"s":"true"}},{"input":"{\"100\":null,\"4294967294\":null,\"hasOwnProperty\":\"-1\",\"\\n\":true,\"1e3 🚀\":{\"\\\"\":{\"4294967294\":true,\"k\":null,\"__proto__\":true,\"1.5\":{\"51\":{\"\":[{\"0\":null,\"1\":4294967294,\"2\":null,\"5\":\"Bearer abc.def-ghi a\\\\nb \",\"49\":true,\"50\":\"\\\\eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\",\"4294967294\":\"true\\\\ \",\"\\\"quoted\\\" \":\"2\",\"..\":0.30000000000000004,\"host.example.com\":7,\"-1\":\"__defineGetter__ \",\"__proto__\":null,\"1e3\":\"msg\",\"INFO \":\"5.㎉ ﻇ\",\"é\":-1.5,\"http.method\":null,\"__defineGetter__\":\"ghp_0123456789abcdefghij0123456789abcdef\",\"a.\":9007199254740994,\"payload\":\"12__proto__\",\" \":null},1,1,1,1,1,1,1,1,1]}}}}}","output":{"ok":true,"s":"{\"100\":null,\"4294967294\":null,\"hasOwnProperty\":\"-1\",\"\\n\":true,\"1e3 🚀\":{\"\\\"\":{\"4294967294\":true,\"k\":null,\"__proto__\":true,\"1.5\":{\"51\":{\"\":[{\"0\":null,\"1\":4294967294,\"2\":null,\"5\":\"Bearer abc.def-ghi a\\\\nb \",\"49\":true,\"50\":\"\\\\eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\",\"4294967294\":\"true\\\\ \",\"\\\"quoted\\\" \":\"2\",\"..\":0.30000000000000004,\"host.example.com\":7,\"-1\":\"__defineGetter__ \",\"__proto__\":null,\"1e3\":\"msg\",\"INFO \":\"5.㎉ ﻇ\",\"é\":-1.5,\"http.method\":null,\"__defineGetter__\":\"ghp_0123456789abcdefghij0123456789abcdef\",\"a.\":9007199254740994,\"payload\":\"12__proto__\",\" \":null},1,1,1,1,1,1,1,1,1]}}}}}"}},{"input":"{\"4294967294\":\"2001:db8::1 -0éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"}","output":{"ok":true,"s":"{\"4294967294\":\"2001:db8::1 -0éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"}"}},{"input":"[{\"1\":null,\"9\":null,\"10\":\"\",\"\":\"d \",\"K\":{\"-1.5\":\"12 @\"},\"level\":null,\"1e3\":{\"2\":false,\"4294967294\":{\"4294967296\":9007199254740992,\"01\":{\"0\":[\"7 \",{\"2\":5423406162299216,\"3\":null,\"payload\":\"__defineGetter__a\\\\nb \",\".a\":\"AKIAIOSFODNN7EXAMPLE\\\"quoted\\\"\",\"deadbeef\":null},[],\"debug\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\"1\":{\"10\":\"4294967295\",\"4294967294\":true,\"\\n\":123456789012345680000,\" \":\"\\\"quoted\\\" .a [1,2]\",\"9007199254740993\":[]},\"\\n\":\"\",\"놔\":null}},\"12.5abc__proto__\":\"00.5 日本語 \",\"\\\"\":true,\"\\n\":null,\"host.example.com\"\\\":\"\\\"12.5abc\",\"user_123\":\"/api/v1/users/123 \",\"𐀀\":\"5.\",\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 \"\\\\:\"\\r\\n\"}},1,1,1,1,1,1,1,1,1]","output":{"ok":false}},{"input":"null","output":{"ok":true,"s":"null"}},{"input":"\"1e21\"","output":{"ok":true,"s":"\"1e21\""}},{"input":"{\"\\ud800\":1,\"b\":2,\"\\ud800\":{\"x\":1}}","output":{"ok":true,"s":"{\"\\ud800\":{\"x\":1},\"b\":2}"}},{"input":"{\"2\":\"ééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\",\"49\":true,\"100\":true,\"\\t\":\"2001:db8::1/api/v1/users/123\",\"\\\\\":0,\"toString\":100,\"\\\"\":\"\\\"quoted\\\" 日本語\",\"b\":[0.1,\"123456789012345680000 12 constructor\"]}","output":{"ok":true,"s":"{\"2\":\"ééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\",\"49\":true,\"100\":true,\"\\t\":\"2001:db8::1/api/v1/users/123\",\"\\\\\":0,\"toString\":100,\"\\\"\":\"\\\"quoted\\\" 日本語\",\"b\":[0.1,\"123456789012345680000 12 constructor\"]}"}},{"input":"[\"1e-7 NaN\",\"\\n\",{\"2\":[null,\"1e3\",0,{\"�\":\"-1 12 \",\"1e3\":null,\"4294967295\":{\"valueOf\":false,\"\\n\":[6746044.056490064,1.5,[\"debug GET\",null,\"AKIAIOSFODNN7EXAMPLE/api/v1/users/123 \",false,null,false,true,\"-1e400__proto__\",\"trueerror \",\"12.50.000001\",null,null,\"4294967295🚀 5. \",5e-324,\"-1e4001e+211_000 \",-0.000010531602962873876,null,\"192.168.1.1 éeyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 \",null,\"é 1.7976931348623157e+308\",null,null,\"0.1途2.5e-8\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}]","output":{"ok":true,"s":"[\"1e-7 NaN\",\"\\n\",{\"2\":[null,\"1e3\",0,{\"�\":\"-1 12 \",\"1e3\":null,\"4294967295\":{\"valueOf\":false,\"\\n\":[6746044.056490064,1.5,[\"debug GET\",null,\"AKIAIOSFODNN7EXAMPLE/api/v1/users/123 \",false,null,false,true,\"-1e400__proto__\",\"trueerror \",\"12.50.000001\",null,null,\"4294967295🚀 5. \",5e-324,\"-1e4001e+211_000 \",-0.000010531602962873876,null,\"192.168.1.1 éeyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 \",null,\"é 1.7976931348623157e+308\",null,null,\"0.1途2.5e-8\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}]"}},{"input":"+00.000001e21","output":{"ok":false}},{"input":"+.0 ","output":{"ok":false}},{"input":"[{\"0\":{\"\":[{\"0\":[[[[{\"0\":{\"a\":{\"\":{\"0\":[{\"0\":[[{\"a\":{\"b.c\":[{\"0\":{\"b.c\":[[[[{\"\":[[[{\"a\":[[{\"b.c\":[[{\"a\":{\"0\":[[[{\"a\":{\"0\":[{\"0\":[[{\"a\":{\"0\":[[[[[[[[[{\"0\":[[[[{\"b.c\":{\"0\":{\"b.c\":{\"\":{\"0\":{\"b.c\":{\"\":{\"0\":{\"a\":{\"0\":[[[{\"a\":[{\"0\":[[[{\"\":{\"0\":[[[[[{\"a\":[[{\"b.c\":[[[[{\"0\":[{\"b.c\":{\"0\":[{\"a\":[{\"0\":{\"b.c\":{\"a\":{\"0\":{\"\":{\"a\":[{\"0\":{\"0\":[[[{\"b.c\":{\"b.c\":[[{\"0\":[{\"0\":[[{\"0\":[{\"b.c\":true}]}]]}]}]]}}]]]}}]}}}}}}]}]}}]}]]]]}]]}]]]]]}}]]]}]}]]]}}}}}}}}}}]]]]}]]]]]]]]]}}]]}]}}]]]}}]]}]]}]]]}]]]]}}]}}]]}]}}}}]]]]}]}}]","output":{"ok":true,"s":"[{\"0\":{\"\":[{\"0\":[[[[{\"0\":{\"a\":{\"\":{\"0\":[{\"0\":[[{\"a\":{\"b.c\":[{\"0\":{\"b.c\":[[[[{\"\":[[[{\"a\":[[{\"b.c\":[[{\"a\":{\"0\":[[[{\"a\":{\"0\":[{\"0\":[[{\"a\":{\"0\":[[[[[[[[[{\"0\":[[[[{\"b.c\":{\"0\":{\"b.c\":{\"\":{\"0\":{\"b.c\":{\"\":{\"0\":{\"a\":{\"0\":[[[{\"a\":[{\"0\":[[[{\"\":{\"0\":[[[[[{\"a\":[[{\"b.c\":[[[[{\"0\":[{\"b.c\":{\"0\":[{\"a\":[{\"0\":{\"b.c\":{\"a\":{\"0\":{\"\":{\"a\":[{\"0\":{\"0\":[[[{\"b.c\":{\"b.c\":[[{\"0\":[{\"0\":[[{\"0\":[{\"b.c\":true}]}]]}]}]]}}]]]}}]}}}}}}]}]}}]}]]]]}]]}]]]]]}}]]]}]}]]]}}}}}}}}}}]]]]}]]]]]]]]]}}]]}]}}]]]}}]]}]]}]]]}]]]]}}]}}]]}]}}}}]]]]}]}}]"}},{"input":"\"éfatal \"","output":{"ok":true,"s":"\"éfatal \""}},{"input":"\u000b.5e309 ","output":{"ok":false}},{"input":"[{\"0\":true,\"2\":null,\"4294967294\":{\"4294967295\":{\"50\":-1,\"user.email\":null},\".a 0b11\":\"𞄌\",\"2001:db8::1\":{\"10\":null,\"日本\":[{\"50\":{\"1\":\"0o7 \",\"9\":null,\"49\":false,\"50\":\"1_000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx __defineGetter__ \",\"51\":\"\\\"quoted\\\"\",\"__defineGetter__\":\"error -0 \",\"🚀\":null,\"1e3\":\" 12uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\",\"4294967295\":\"z 12\",\"\\\"\":false,\"level\":1.7976931348623157e+308,\"a.\":null,\"+5 warn\":\"ERROR \",\"hasOwnProperty0b11\":null,\"12null \":\"aO 12 \",\"\\\"quoted\\\" toString\":true,\"\":\"user.email\\\\\",\"𐀀\":0.30000000000000004,\" \":null}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}},\"1.5\":{}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","output":{"ok":true,"s":"[{\"0\":true,\"2\":null,\"4294967294\":{\"4294967295\":{\"50\":-1,\"user.email\":null},\".a 0b11\":\"𞄌\",\"2001:db8::1\":{\"10\":null,\"日本\":[{\"50\":{\"1\":\"0o7 \",\"9\":null,\"49\":false,\"50\":\"1_000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx __defineGetter__ \",\"51\":\"\\\"quoted\\\"\",\"__defineGetter__\":\"error -0 \",\"🚀\":null,\"1e3\":\" 12uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\",\"4294967295\":\"z 12\",\"\\\"\":false,\"level\":1.7976931348623157e+308,\"a.\":null,\"+5 warn\":\"ERROR \",\"hasOwnProperty0b11\":null,\"12null \":\"aO 12 \",\"\\\"quoted\\\" toString\":true,\"\":\"user.email\\\\\",\"𐀀\":0.30000000000000004,\" \":null}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}},\"1.5\":{}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]"}},{"input":"{\"1\":\"debug\",\"3\":\"1e400 00x10\",\"10\":\"0x10true 192.168.1.1\",\"1.5\":1e-7,\"\":-254359126556664.72,\"__proto__\":\"1e+100 2001:db8::1 \",\"toString\":{\"a.\":\"Wed, 15 Jan 2025 12:00:00 GMTnull\",\"length\":[false,\"2\",2744285087101.1616,[\"00 12\",true,false,null,{\"9\":{\"5\":\"+5\",\"51\":{\"2\":null,\"50\":1e+21,\"\":\"\\u000b \",\"AKIAIOSFODNN7EXAMPLE\":3.8644016324542465e-11,\"1.5\":null,\"{\\\"a\\\":1} \":1.7976931348623157e+308,\"valueOf\":\"GET9007199254740992ө\",\"-1\":4294967294},\"4294967295\":\"0.30000000000000004 \",\"社 12\":\".5 \",\" \":\"error \",\"192.168.0.1\":0.1,\"\":[\"3fa85f64-5717-4562-b3fc-2c963f66afa6{\\\"a\\\":1}\"],\"message\":{\"msg\":\"Bearer abc.def-ghi\",\"event\":\"-15. +5\",\"01\":false}}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1]}}","output":{"ok":true,"s":"{\"1\":\"debug\",\"3\":\"1e400 00x10\",\"10\":\"0x10true 192.168.1.1\",\"1.5\":1e-7,\"\":-254359126556664.72,\"__proto__\":\"1e+100 2001:db8::1 \",\"toString\":{\"a.\":\"Wed, 15 Jan 2025 12:00:00 GMTnull\",\"length\":[false,\"2\",2744285087101.1616,[\"00 12\",true,false,null,{\"9\":{\"5\":\"+5\",\"51\":{\"2\":null,\"50\":1e+21,\"\":\"\\u000b \",\"AKIAIOSFODNN7EXAMPLE\":3.8644016324542465e-11,\"1.5\":null,\"{\\\"a\\\":1} \":1.7976931348623157e+308,\"valueOf\":\"GET9007199254740992ө\",\"-1\":4294967294},\"4294967295\":\"0.30000000000000004 \",\"社 12\":\".5 \",\" \":\"error \",\"192.168.0.1\":0.1,\"\":[\"3fa85f64-5717-4562-b3fc-2c963f66afa6{\\\"a\\\":1}\"],\"message\":{\"msg\":\"Bearer abc.def-ghi\",\"event\":\"-15. +5\",\"01\":false}}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1]}}"}},{"input":"{\"0\":[[{\"0\":[[[[[{\"a\":[[{\"0\":[{\"b.c\":[[[[{\"0\":{\"0\":[{\"0\":{\"a\":[{\"0\":{\"\":{\"b.c\":{\"a\":[{\"\":{\"b.c\":[{\"0\":[{\"\":{\"b.c\":[[[{\"\":{\"0\":[[{\"0\":[{\"0\":[[{\"\":[{\"0\":[[{\"0\":[[[[{\"b.c\":{\"\":[{\"a\":{\"0\":{\"b.c\":[[[{\"a\":[[[{\"b.c\":{\"a\":[{\"\":[{\"b.c\":[[[[[{\"\":[[[{\"\":[{\"\":{\"a\":[{\"a\":{\"b.c\":{\"a\":[{\"\":[[{\"b.c\":[[[[[[{\"a\":[[{\"0\":{\"0\":[[[[{\"a\":[{\"\":[[[[{\"0\":{\"\":{\"a\":[\"v\"]}}}]]]]}]}]]]]}}]]}]]]]]]}]]}]}}}]}}]}]]]}]]]]]}]}]}}]]]}]]]}}}]}}]]]]}]]}]}]]}]}]]}}]]]}}]}]}}]}}}}]}}]}}]]]]}]}]]}]]]]]}]]}","output":{"ok":true,"s":"{\"0\":[[{\"0\":[[[[[{\"a\":[[{\"0\":[{\"b.c\":[[[[{\"0\":{\"0\":[{\"0\":{\"a\":[{\"0\":{\"\":{\"b.c\":{\"a\":[{\"\":{\"b.c\":[{\"0\":[{\"\":{\"b.c\":[[[{\"\":{\"0\":[[{\"0\":[{\"0\":[[{\"\":[{\"0\":[[{\"0\":[[[[{\"b.c\":{\"\":[{\"a\":{\"0\":{\"b.c\":[[[{\"a\":[[[{\"b.c\":{\"a\":[{\"\":[{\"b.c\":[[[[[{\"\":[[[{\"\":[{\"\":{\"a\":[{\"a\":{\"b.c\":{\"a\":[{\"\":[[{\"b.c\":[[[[[[{\"a\":[[{\"0\":{\"0\":[[[[{\"a\":[{\"\":[[[[{\"0\":{\"\":{\"a\":[\"v\"]}}}]]]]}]}]]]]}}]]}]]]]]]}]]}]}}}]}}]}]]]}]]]]]}]}]}}]]]}]]]}}}]}}]]]]}]]}]}]]}]}]]}}]]]}}]}]}}]}}}}]}}]}}]]]]}]}]]}]]]]]}]]}"}},{"input":"\u000b01.12345678901234567890e21","output":{"ok":false}},{"input":"\u000b00.000001e+5","output":{"ok":false}},{"input":" -9007199254740993.5e ","output":{"ok":false}},{"input":"{\"0\":1,\"b\":2,\"0\":null}","output":{"ok":true,"s":"{\"0\":null,\"b\":2}"}},{"input":"\n9007199254740993.000001e-323","output":{"ok":true,"s":"9.007199254740994e-308"}},{"input":"{\"01\":1,\"b\":2,\"01\":3}","output":{"ok":true,"s":"{\"01\":3,\"b\":2}"}},{"input":"\"ﲢ 90071992547409940x10 \"","output":{"ok":true,"s":"\"ﲢ 90071992547409940x10 \""}},{"input":"[[[{\"\":{\"b.c\":{\"b.c\":[[{\"\":{\"0\":{\"b.c\":{\"0\":[[[[[[{\"\":[{\"a\":[{\"0\":{\"0\":{\"a\":[{\"b.c\":[{\"0\":[[[[[[{\"0\":{\"b.c\":{\"b.c\":{\"\":{\"\":{\"\":{\"\":[{\"0\":[{\"a\":{\"0\":[{\"b.c\":{\"0\":{\"\":[{\"0\":{\"0\":{\"\":{\"b.c\":[[[[[[{\"a\":{\"\":{\"\":[{\"0\":{\"0\":{\"b.c\":[{\"a\":[[{\"\":[[{\"a\":{\"b.c\":{\"\":{\"0\":[{\"\":[{\"b.c\":[{\"a\":[{\"b.c\":[[[[[{\"\":[{\"a\":[[[{\"b.c\":{\"a\":{\"a\":[{\"0\":{\"\":[{\"b.c\":{\"a\":[{\"a\":[[{\"b.c\":[{\"b.c\":{\"a\":[{\"0\":[{\"0\":{\"b.c\":{\"0\":{\"0\":[{\"a\":[{\"b.c\":true}]}]}}}}]}]}}]}]]}]}}]}}]}}}]]]}]}]]]]]}]}]}]}]}}}}]]}]]}]}}}]}}}]]]]]]}}}}]}}}]}}]}]}}}}}}}]]]]]]}]}]}}}]}]}]]]]]]}}}}]]}}}]]]","output":{"ok":true,"s":"[[[{\"\":{\"b.c\":{\"b.c\":[[{\"\":{\"0\":{\"b.c\":{\"0\":[[[[[[{\"\":[{\"a\":[{\"0\":{\"0\":{\"a\":[{\"b.c\":[{\"0\":[[[[[[{\"0\":{\"b.c\":{\"b.c\":{\"\":{\"\":{\"\":{\"\":[{\"0\":[{\"a\":{\"0\":[{\"b.c\":{\"0\":{\"\":[{\"0\":{\"0\":{\"\":{\"b.c\":[[[[[[{\"a\":{\"\":{\"\":[{\"0\":{\"0\":{\"b.c\":[{\"a\":[[{\"\":[[{\"a\":{\"b.c\":{\"\":{\"0\":[{\"\":[{\"b.c\":[{\"a\":[{\"b.c\":[[[[[{\"\":[{\"a\":[[[{\"b.c\":{\"a\":{\"a\":[{\"0\":{\"\":[{\"b.c\":{\"a\":[{\"a\":[[{\"b.c\":[{\"b.c\":{\"a\":[{\"0\":[{\"0\":{\"b.c\":{\"0\":{\"0\":[{\"a\":[{\"b.c\":true}]}]}}}}]}]}}]}]]}]}}]}}]}}}]]]}]}]]]]]}]}]}]}]}}}}]]}]]}]}}}]}}}]]]]]]}}}}]}}}]}}]}]}}}}}}}]]]]]]}]}]}}}]}]}]]]]]]}}}}]]}}}]]]"}},{"input":" +1.0e-400 ","output":{"ok":false}},{"input":"\"POST \"","output":{"ok":true,"s":"\"POST \""}},{"input":"{\"\\\"\"\\u0000\\udfff:null}","output":{"ok":false}},{"input":"\r+1.5e ","output":{"ok":false}},{"input":"\"/api/v1/users/123\"","output":{"ok":true,"s":"\"/api/v1/users/123\""}},{"input":"{\"a\":[[[[{\"\":{\"b.c\":{\"a\":{\"b.c\":[[{\"b.c\":[[[{\"0\":[[[{\"0\":[[{\"b.c\":{\"b.c\":[[[{\"a\":[{\"a\":[{\"\":[[{\"a\":[{\"\":{\"0\":{\"0\":{\"\":[{\"b.c\":[[[{\"0\":{\"\":[{\"\":[{\"b.c\":[{\"\":[{\"\":{\"\":[{\"a\":[{\"b.c\":[[{\"\":[{\"a\":[{\"0\":[{\"\":[{\"b.c\":[[{\"\":{\"0\":[[{\"b.c\":[[{\"0\":[[[[[{\"a\":[[{\"a\":[[{\"0\":{\"0\":{\"b.c\":{\"b.c\":{\"b.c\":[[[[{\"0\":[{\"a\":{\"a\":{\"0\":{\"\":[{\"a\":[[{\"b.c\":[{\"0\":[[[[[{\"a\":{\"0\":[{\"0\":{\"b.c\":{\"0\":[1]}}}]}}]]]]]}]}]]}]}}}}]}]]]]}}}}}]]}]]}]]]]]}]]}]]}}]]}]}]}]}]}]]}]}]}}]}]}]}]}}]]]}]}}}}]}]]}]}]}]]]}}]]}]]]}]]]}]]}}}}]]]]}","output":{"ok":true,"s":"{\"a\":[[[[{\"\":{\"b.c\":{\"a\":{\"b.c\":[[{\"b.c\":[[[{\"0\":[[[{\"0\":[[{\"b.c\":{\"b.c\":[[[{\"a\":[{\"a\":[{\"\":[[{\"a\":[{\"\":{\"0\":{\"0\":{\"\":[{\"b.c\":[[[{\"0\":{\"\":[{\"\":[{\"b.c\":[{\"\":[{\"\":{\"\":[{\"a\":[{\"b.c\":[[{\"\":[{\"a\":[{\"0\":[{\"\":[{\"b.c\":[[{\"\":{\"0\":[[{\"b.c\":[[{\"0\":[[[[[{\"a\":[[{\"a\":[[{\"0\":{\"0\":{\"b.c\":{\"b.c\":{\"b.c\":[[[[{\"0\":[{\"a\":{\"a\":{\"0\":{\"\":[{\"a\":[[{\"b.c\":[{\"0\":[[[[[{\"a\":{\"0\":[{\"0\":{\"b.c\":{\"0\":[1]}}}]}}]]]]]}]}]]}]}}}}]}]]]]}}}}}]]}]]}]]]]]}]]}]]}}]]}]}]}]}]}]]}]}]}}]}]}]}]}}]]]}]}}}}]}]]}]}]}]]]}}]]}]]]}]]]}]]}}}}]]]]}"}},{"input":"false","output":{"ok":true,"s":"false"}},{"input":" 5.12345678901234567890","output":{"ok":true,"s":"5.123456789012345"}},{"input":"{\"__proto__\":1,\"b\":2,\"__proto__\":3}","output":{"ok":true,"s":"{\"__proto__\":3,\"b\":2}"}},{"input":"{\"b.c\":{\"b.c\":[[{\"a\":{\"b.c\":{\"0\":{\"\":{\"\":[{\"a\":[{\"a\":{\"a\":{\"0\":{\"b.c\":{\"0\":[[{\"\":[[[{\"\":[[{\"b.c\":[{\"0\":{\"a\":[{\"a\":{\"0\":[{\"\":{\"a\":{\"0\":{\"b.c\":[[[{\"a\":{\"0\":{\"0\":{\"0\":[[{\"b.c\":[[{\"a\":{\"a\":[{\"a\":[[[[{\"a\":[[[[[[[{\"b.c\":[[{\"0\":[[[[{\"b.c\":{\"a\":[{\"0\":[{\"\":[[{\"\":[{\"0\":{\"\":{\"0\":{\"b.c\":{\"b.c\":{\"\":{\"a\":[{\"b.c\":{\"\":{\"0\":[{\"b.c\":[{\"0\":{\"a\":{\"b.c\":{\"\":{\"a\":[[[{\"b.c\":[{\"a\":[{\"b.c\":{\"\":[[[[{\"b.c\":{\"\":[{\"a\":[{\"a\":{\"0\":{\"0\":{\"0\":[{\"a\":[true]}]}}}}]}]}}]]]]}}]}]}]]]}}}}}]}]}}}]}}}}}}}]}]]}]}]}}]]]]}]]}]]]]]]]}]]]]}]}}]]}]]}}}}]]]}}}}]}}]}}]}]]}]]]}]]}}}}}]}]}}}}}]]}}","output":{"ok":true,"s":"{\"b.c\":{\"b.c\":[[{\"a\":{\"b.c\":{\"0\":{\"\":{\"\":[{\"a\":[{\"a\":{\"a\":{\"0\":{\"b.c\":{\"0\":[[{\"\":[[[{\"\":[[{\"b.c\":[{\"0\":{\"a\":[{\"a\":{\"0\":[{\"\":{\"a\":{\"0\":{\"b.c\":[[[{\"a\":{\"0\":{\"0\":{\"0\":[[{\"b.c\":[[{\"a\":{\"a\":[{\"a\":[[[[{\"a\":[[[[[[[{\"b.c\":[[{\"0\":[[[[{\"b.c\":{\"a\":[{\"0\":[{\"\":[[{\"\":[{\"0\":{\"\":{\"0\":{\"b.c\":{\"b.c\":{\"\":{\"a\":[{\"b.c\":{\"\":{\"0\":[{\"b.c\":[{\"0\":{\"a\":{\"b.c\":{\"\":{\"a\":[[[{\"b.c\":[{\"a\":[{\"b.c\":{\"\":[[[[{\"b.c\":{\"\":[{\"a\":[{\"a\":{\"0\":{\"0\":{\"0\":[{\"a\":[true]}]}}}}]}]}}]]]]}}]}]}]]]}}}}}]}]}}}]}}}}}}}]}]]}]}]}}]]]]}]]}]]]]]]]}]]]]}]}}]]}]]}}}}]]]}}}}]}}]}}]}]]}]]]}]]}}}}}]}]}}}}}]]}}"}},{"input":"\"\ude80 \"","output":{"ok":true,"s":"\"\\ude80 \""}},{"input":"\n--123456789012345678901234567890.E5 ","output":{"ok":false}},{"input":"\"POST\\\" -Infi\\u00nul41nity \"","output":{"ok":false}},{"input":"[{\"2025-01-15T10:00:00Z O\":{\"շ\":1e+100,\"192.168.0.1\":{\"__proto__\":false,\"msg\":[],\"🚀\":[[[1.5,\"日本語2001:db8::1Wed, 15 Jan 2025 12:00:00 GMT\",null,true,1e+100,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1tru,1,1,1,1,1,1,1,1,1,1,1,1]}}},1,1,1,1,1,1,1,1,1]","output":{"ok":false}},{"input":"[false,null,false,4294967295,[{},{},\"..KeyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\",\" 12 \",true,[{\"51\":true,\"user_123\":[null,false,{},{\"2\":\" 12\",\"3\":[null],\"5\":null,\"10\":\"ghp_0123456789abcdefghij0123456789abcdef𛰊3fa85f64-5717-4562-b3fc-2c963f66afa6\",\"4294967295\":true,\"\":false,\"3fa85f64-5717-4562-b3fc-2c963f66afa6 \\r\\n\":1e+21,\"𐀀\":[null,null],\"A[email protected] \":null,\"192.168.0.1\":\"\\\"quoted\\\" GET \",\".a\":\"M 12\",\"user_123\":[],\"GET\":\"xoxb-1234567890-abc\\\"[email protected]\"},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","output":{"ok":true,"s":"[false,null,false,4294967295,[{},{},\"..KeyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\",\" 12 \",true,[{\"51\":true,\"user_123\":[null,false,{},{\"2\":\" 12\",\"3\":[null],\"5\":null,\"10\":\"ghp_0123456789abcdefghij0123456789abcdef𛰊3fa85f64-5717-4562-b3fc-2c963f66afa6\",\"4294967295\":true,\"\":false,\"3fa85f64-5717-4562-b3fc-2c963f66afa6 \\r\\n\":1e+21,\"𐀀\":[null,null],\"A[email protected] \":null,\"192.168.0.1\":\"\\\"quoted\\\" GET \",\".a\":\"M 12\",\"user_123\":[],\"GET\":\"xoxb-1234567890-abc\\\"[email protected]\"},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]"}},{"input":"{\"1\":[\"1.5 \",{\"4294967294\":[[],{\"é\":null,\"192.168.0.1\":\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé \",\"a\\\\nb\":{\"51\":\"INFO\",\"valueOfINFO\":{\"0\":true,\"1\":null,\"4294967294\":5e-324,\"level\":\"1.5\",\"host.example.com\":null,\"4294967296\":-1.5,\"\":\"1.5\"},\"-9007199254740992fatal\":false,\"valueOf\":{\"10\":null,\"toString12\":\"debug debugཡ\",\"G5.\":null},\".a\":{},\"é\":null,\"\":{\"é\":true},\"msg\":false},\"hasOwnProperty\":[[9007199254740992,true,false,false,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1]},1],\"\":false,\"valueOf\":\" 㶋\",\"4294967295\":false},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\"\\\\\":true}","output":{"ok":true,"s":"{\"1\":[\"1.5 \",{\"4294967294\":[[],{\"é\":null,\"192.168.0.1\":\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé \",\"a\\\\nb\":{\"51\":\"INFO\",\"valueOfINFO\":{\"0\":true,\"1\":null,\"4294967294\":5e-324,\"level\":\"1.5\",\"host.example.com\":null,\"4294967296\":-1.5,\"\":\"1.5\"},\"-9007199254740992fatal\":false,\"valueOf\":{\"10\":null,\"toString12\":\"debug debugཡ\",\"G5.\":null},\".a\":{},\"é\":null,\"\":{\"é\":true},\"msg\":false},\"hasOwnProperty\":[[9007199254740992,true,false,false,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1]},1],\"\":false,\"valueOf\":\" 㶋\",\"4294967295\":false},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\"\\\\\":true}"}},{"input":"\r+123456789012345678901234567890.12345678901234567890e308","output":{"ok":false}},{"input":"false","output":{"ok":true,"s":"false"}},{"input":"{\"..\":[{\"9\":{\"5\":true,\"\\/msg\":{\"\\u20284294967294\":null,\"4294967295\":[[null,null,0,\"toString-0\",\"x0b11\",\"InfinityU 0o7\",false,-1,-3.4757070522755384e-18,false],true,\"é \",0.1,true,false,true,-347625635797.1579,\"日本語\",\"sk_live_0123456789abcdefghijkl\",{\"1\":\".5hasOwnProperty\",\"2\":123456789012345680000,\"01\":true,\"0\\\"\":\"'90071992547409924294967296\",\"+5\":true},\"12025-01-15T10:00:00Z\",{\"1.5\":null},\"2001:db8::1\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}},\"50\":null,\"a.b\":true}]}","output":{"ok":true,"s":"{\"..\":[{\"9\":{\"5\":true,\"/msg\":{\" 4294967294\":null,\"4294967295\":[[null,null,0,\"toString-0\",\"x0b11\",\"InfinityU 0o7\",false,-1,-3.4757070522755384e-18,false],true,\"é \",0.1,true,false,true,-347625635797.1579,\"日本語\",\"sk_live_0123456789abcdefghijkl\",{\"1\":\".5hasOwnProperty\",\"2\":123456789012345680000,\"01\":true,\"0\\\"\":\"'90071992547409924294967296\",\"+5\":true},\"12025-01-15T10:00:00Z\",{\"1.5\":null},\"2001:db8::1\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}},\"50\":null,\"a.b\":true}]}"}},{"input":"1e308 ","output":{"ok":false}},{"input":"5e-324","output":{"ok":true,"s":"5e-324"}},{"input":" 9007199254740993.5e309 ","output":{"ok":false}},{"input":"null","output":{"ok":true,"s":"null"}},{"input":"false","output":{"ok":true,"s":"false"}},{"input":"\u000b0E+0 ","output":{"ok":false}},{"input":" +123456789012345678901234567890.5e-5 ","output":{"ok":false}},{"input":"{\"5\":{\"49\":{\"3\":100,\"9\":null,\"49\":\"null\",\"50\":null,\"51\":null,\"\\r\\neyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\":\"01_000-Infinity\",\"event\":12511.154217645526,\"length\":\" 3fa85f64-5717-4562-b3fc-2c963f66afa6msg\",\"a.b\":{\"9\":\"9007199254740992 ﴅ \",\"4294967296\"\\/:-1,\"msg\":123456789012345680000},\"b\":-1,\"\\\\\":\"ܶa1,5\",\"deadbeef\":{\"4294967295\":[638882.436323911,null,-12096614297.479391,\"a.b0b11error \",{\"0\":true,\"10\":\"xPOST \",\"1.5\":\"Wed, 15 Jan 2025 12:00:00 GMT ǒ \",\"01\":true,\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":true,\"__proto__\":{\"a.\":null},\"constructor\":null,\"�\":{\"0\":true,\"1\":\"01\",\"50\":null,\"+5 0\":\"fatal999.9999999message\",\" 12 \":\"0 ERRORx \"}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}}},\"10\":false}","output":{"ok":false}},{"input":"{\"0\":{\"b.c\":{\"a\":[[{\"b.c\":{\"b.c\":{\"b.c\":[[{\"0\":[{\"0\":[[[[[{\"0\":{\"0\":{\"0\":{\"b.c\":[[[[{\"a\":{\"\":[[{\"a\":[{\"a\":{\"0\":{\"0\":{\"0\":[{\"0\":{\"b.c\":[{\"b.c\":{\"b.c\":[{\"b.c\":{\"b.c\":[[{\"a\":{\"a\":[[{\"b.c\":{\"b.c\":[[{\"\":{\"0\":{\"\":{\"a\":[[[{\"b.c\":[{\"b.c\":[{\"0\":{\"\":[{\"0\":[{\"0\":[{\"\":[{\"a\":[[[[[[{\"a\":{\"b.c\":[[[{\"b.c\":[{\"\":{\"a\":{\"0\":[[[{\"a\":{\"a\":{\"a\":{\"0\":[[{\"\":[[[{\"\":[{\"0\":{\"a\":[[[{\"\":[[{\"b.c\":{\"\":[[[{\"b.c\":{\"0\":{\"0\":{\"b.c\":{\"\":{\"a\":{\"0\":{\"a\":null}}}}}}}}]]]}}]]}]]]}}]}]]]}]]}}}}]]]}}}]}]]]}}]]]]]]}]}]}]}]}}]}]}]]]}}}}]]}}]]}}]]}}]}}]}}]}}}}]}]]}}]]]]}}}}]]]]]}]}]]}}}]]}}}","output":{"ok":true,"s":"{\"0\":{\"b.c\":{\"a\":[[{\"b.c\":{\"b.c\":{\"b.c\":[[{\"0\":[{\"0\":[[[[[{\"0\":{\"0\":{\"0\":{\"b.c\":[[[[{\"a\":{\"\":[[{\"a\":[{\"a\":{\"0\":{\"0\":{\"0\":[{\"0\":{\"b.c\":[{\"b.c\":{\"b.c\":[{\"b.c\":{\"b.c\":[[{\"a\":{\"a\":[[{\"b.c\":{\"b.c\":[[{\"\":{\"0\":{\"\":{\"a\":[[[{\"b.c\":[{\"b.c\":[{\"0\":{\"\":[{\"0\":[{\"0\":[{\"\":[{\"a\":[[[[[[{\"a\":{\"b.c\":[[[{\"b.c\":[{\"\":{\"a\":{\"0\":[[[{\"a\":{\"a\":{\"a\":{\"0\":[[{\"\":[[[{\"\":[{\"0\":{\"a\":[[[{\"\":[[{\"b.c\":{\"\":[[[{\"b.c\":{\"0\":{\"0\":{\"b.c\":{\"\":{\"a\":{\"0\":{\"a\":null}}}}}}}}]]]}}]]}]]]}}]}]]]}]]}}}}]]]}}}]}]]]}}]]]]]]}]}]}]}]}}]}]}]]]}}}}]]}}]]}}]]}}]}}]}}]}}}}]}]]}}]]]]}}}}]]]]]}]}]]}}}]]}}}"}},{"input":"[\"4294967295 v \",\"192.168.1.1x \",\"121,5\",\"ERRORhost.example.com-1e400\",{\"1\":true,\"5\":[0.30000000000000004,12.5,123456789012345680000,\"0.30000000000000004 \",1e-7,null,[[\"error \",true,\"é1e3\",{\"Ռ\":{\"100\":\"payload𐀀4294967295 \",\"4294967294\":\" 汣 \",\"01\":null,\"4294967296\":true,\".a\":4294967294,\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":\"\\\\-Infinity+5\"}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\"10\":{\"null \":null,\"user_123\":null,\"�\":null},\"12345678\":\"1.5 \\\"quoted\\\"\",\"\":\"ɓé \",\"__defineGetter__1e3 \":null,\"-1\":true,\"user_123\":{\"2\":null,\"192.168.0.1\":\"Wed, 15 Jan 2025 12:00:00 GMTpayload\"},\"理\":true,\"�\":null},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","output":{"ok":true,"s":"[\"4294967295 v \",\"192.168.1.1x \",\"121,5\",\"ERRORhost.example.com-1e400\",{\"1\":true,\"5\":[0.30000000000000004,12.5,123456789012345680000,\"0.30000000000000004 \",1e-7,null,[[\"error \",true,\"é1e3\",{\"Ռ\":{\"100\":\"payload𐀀4294967295 \",\"4294967294\":\" 汣 \",\"01\":null,\"4294967296\":true,\".a\":4294967294,\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":\"\\\\-Infinity+5\"}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\"10\":{\"null \":null,\"user_123\":null,\"�\":null},\"12345678\":\"1.5 \\\"quoted\\\"\",\"\":\"ɓé \",\"__defineGetter__1e3 \":null,\"-1\":true,\"user_123\":{\"2\":null,\"192.168.0.1\":\"Wed, 15 Jan 2025 12:00:00 GMTpayload\"},\"理\":true,\"�\":null},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]"}},{"input":"00.0e-7 ","output":{"ok":false}},{"input":"\"999.9999999 1_000999.9999999\"\\\\","output":{"ok":false}},{"input":"{\"0\":{\"9\":[null,{\"1e3\":\"2025-{01-15T10:00:00Z9007199254740994 \",\"4294967296\":[{\"3\":{\"51\":1.7976931348623157e+308}},\"[email protected], 15 Jan 2025 12:00:00 GMT\",\"a.b 0.1 \",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,11,\\u00411],\"4294967296\":\"1,500xoxb-1234567890-abc\"},\"1\":\"warn\",\"4294967295\":\"999.9999999𐀀\"}","output":{"ok":false}},{"input":"{\"01\":1,\"b\":2,\"01\":3}","output":{"ok":true,"s":"{\"01\":3,\"b\":2}"}},{"input":"--.E+0","output":{"ok":false}},{"input":"[{\"a\":[{\"a\":[[{\"0\":{\"\":{\"b.c\":[{\"a\":[{\"\":{\"0\":[{\"\":[{\"0\":[[{\"a\":{\"a\":{\"b.c\":[{\"0\":{\"0\":{\"\":[{\"0\":{\"a\":[[{\"\":{\"0\":[[{\"\":[[{\"\":{\"0\":[[{\"a\":{\"a\":[[{\"\":{\"a\":[{\"0\":{\"a\":{\"\":[{\"a\":[[[{\"b.c\":[{\"a\":{\"\":[[[{\"0\":[[{\"b.c\":{\"b.c\":{\"b.c\":{\"b.c\":{\"b.c\":{\"b.c\":{\"b.c\":{\"\":[{\"\":{\"\":{\"b.c\":[[[[[[[{\"0\":[{\"0\":[{\"0\":{\"\":[{\"b.c\":[[{\"b.c\":{\"b.c\":{\"0\":[[{\"\":{\"\":[{\"b.c\":{\"b.c\":{\"b.c\":[{\"b.c\":{\"\":{\"b.c\":[{\"a\":{\"b.c\":{\"\":[{\"a\":[[[{\"a\":{\"b.c\":{\"0\":[{\"\":{\"b.c\":[[null]]}}]}}}]]]}]}}}]}}}]}}}]}}]]}}}]]}]}}]}]}]]]]]]]}}}]}}}}}}}}]]}]]]}}]}]]]}]}}}]}}]]}}]]}}]]}]]}}]]}}]}}}]}}}]]}]}]}}]}]}}}]]}]}]","output":{"ok":true,"s":"[{\"a\":[{\"a\":[[{\"0\":{\"\":{\"b.c\":[{\"a\":[{\"\":{\"0\":[{\"\":[{\"0\":[[{\"a\":{\"a\":{\"b.c\":[{\"0\":{\"0\":{\"\":[{\"0\":{\"a\":[[{\"\":{\"0\":[[{\"\":[[{\"\":{\"0\":[[{\"a\":{\"a\":[[{\"\":{\"a\":[{\"0\":{\"a\":{\"\":[{\"a\":[[[{\"b.c\":[{\"a\":{\"\":[[[{\"0\":[[{\"b.c\":{\"b.c\":{\"b.c\":{\"b.c\":{\"b.c\":{\"b.c\":{\"b.c\":{\"\":[{\"\":{\"\":{\"b.c\":[[[[[[[{\"0\":[{\"0\":[{\"0\":{\"\":[{\"b.c\":[[{\"b.c\":{\"b.c\":{\"0\":[[{\"\":{\"\":[{\"b.c\":{\"b.c\":{\"b.c\":[{\"b.c\":{\"\":{\"b.c\":[{\"a\":{\"b.c\":{\"\":[{\"a\":[[[{\"a\":{\"b.c\":{\"0\":[{\"\":{\"b.c\":[[null]]}}]}}}]]]}]}}}]}}}]}}}]}}]]}}}]]}]}}]}]}]]]]]]]}}}]}}}}}}}}]]}]]]}}]}]]]}]}}}]}}]]}}]]}}]]}]]}}]]}}]}}}]}}}]]}]}]}}]}]}}}]]}]}]"}},{"input":"{\"a\":1,\"b\":2,\"a\":\"s\"}","output":{"ok":true,"s":"{\"a\":\"s\",\"b\":2}"}},{"input":"ull","output":{"ok":false}},{"input":"{\"\\ud800\":1,\"b\":2,\"\\ud800\":null}","output":{"ok":true,"s":"{\"\\ud800\":null,\"b\":2}"}},{"input":"-1.5\"","output":{"ok":false}},{"input":"false","output":{"ok":true,"s":"false"}},{"input":"ull","output":{"ok":false}},{"input":"[{\"0\":[[[[[{\"0\":{\"a\":[[{\"\":[{\"a\":{\"0\":{\"b.c\":{\"0\":[[[{\"0\":{\"0\":[{\"a\":[[[[[{\"a\":{\"b.c\":{\"\":[{\"b.c\":{\"b.c\":{\"a\":[[{\"a\":{\"a\":[{\"b.c\":{\"b.c\":[[[[{\"\":[[[[{\"a\":[[{\"b.c\":{\"0\":{\"b.c\":[[[{\"a\":{\"a\":{\"b.c\":[{\"b.c\":{\"b.c\":{\"0\":[{\"\":{\"b.c\":{\"a\":{\"\":[[[[{\"a\":[{\"\":{\"\":{\"a\":[[[[[[{\"b.c\":[[{\"b.c\":{\"0\":{\"b.c\":{\"0\":[{\"b.c\":{\"a\":{\"\":[[[{\"a\":{\"\":[[[{\"0\":[{\"0\":[[[{\"a\":{\"\":{\"0\":{\"a\":{\"a\":[{\"a\":[{\"b.c\":{\"b.c\":{\"b.c\":{\"\":{\"a\":[[{\"a\":[[{\"b.c\":{\"0\":{\"b.c\":[{\"a\":[[[{\"\":{\"a\":{\"a\":[[[[[[{\"b.c\":[[[{\"0\":{\"0\":{\"a\":[[{\"\":[[[[{\"b.c\":[[{\"0\":[{\"a\":[[[[[{\"\":[[[[{\"a\":{\"0\":{\"b.c\":{\"a\":[{\"\":[{\"a\":[{\"a\":{\"0\":{\"\":[[[[{\"b.c\":{\"a\":[[[[true]]]]}}]]]]}}}]}]}]}}}}]]]]}]]]]]}]}]]}]]]]}]]}}}]]]}]]]]]]}}}]]]}]}}}]]}]]}}}}}]}]}}}}}]]]}]}]]]}}]]]}}}]}}}}]]}]]]]]]}}}]}]]]]}}}}]}}}]}}}]]]}}}]]}]]]]}]]]]}}]}}]]}}}]}}}]]]]]}]}}]]]}}}}]}]]}}]]]]]}]","output":{"ok":true,"s":"[{\"0\":[[[[[{\"0\":{\"a\":[[{\"\":[{\"a\":{\"0\":{\"b.c\":{\"0\":[[[{\"0\":{\"0\":[{\"a\":[[[[[{\"a\":{\"b.c\":{\"\":[{\"b.c\":{\"b.c\":{\"a\":[[{\"a\":{\"a\":[{\"b.c\":{\"b.c\":[[[[{\"\":[[[[{\"a\":[[{\"b.c\":{\"0\":{\"b.c\":[[[{\"a\":{\"a\":{\"b.c\":[{\"b.c\":{\"b.c\":{\"0\":[{\"\":{\"b.c\":{\"a\":{\"\":[[[[{\"a\":[{\"\":{\"\":{\"a\":[[[[[[{\"b.c\":[[{\"b.c\":{\"0\":{\"b.c\":{\"0\":[{\"b.c\":{\"a\":{\"\":[[[{\"a\":{\"\":[[[{\"0\":[{\"0\":[[[{\"a\":{\"\":{\"0\":{\"a\":{\"a\":[{\"a\":[{\"b.c\":{\"b.c\":{\"b.c\":{\"\":{\"a\":[[{\"a\":[[{\"b.c\":{\"0\":{\"b.c\":[{\"a\":[[[{\"\":{\"a\":{\"a\":[[[[[[{\"b.c\":[[[{\"0\":{\"0\":{\"a\":[[{\"\":[[[[{\"b.c\":[[{\"0\":[{\"a\":[[[[[{\"\":[[[[{\"a\":{\"0\":{\"b.c\":{\"a\":[{\"\":[{\"a\":[{\"a\":{\"0\":{\"\":[[[[{\"b.c\":{\"a\":[[[[true]]]]}}]]]]}}}]}]}]}}}}]]]]}]]]]]}]}]]}]]]]}]]}}}]]]}]]]]]]}}}]]]}]}}}]]}]]}}}}}]}]}}}}}]]]}]}]]]}}]]]}}}]}}}}]]}]]]]]]}}}]}]]]]}}}}]}}}]}}}]]]}}}]]}]]]]}]]]]}}]}}]]}}}]}}}]]]]]}]}}]]]}}}}]}]]}}]]]]]}]"}},{"input":"{\"\\ud800\":1,\"b\":2,\"\\ud800\":3}","output":{"ok":true,"s":"{\"\\ud800\":3,\"b\":2}"}},{"input":"{\"1\":null,\"3\":null,\"49\":true,\"deadbeef\":null,\"4294967295\":123456789012345680000,\"192.168.0.1\":true,\"length\":9007199254740992,\" event\":\"valueOftrue\",\"__defineGetter__\":\"2001:db8::1 +5\",\"a.b\":{\"100\":{\"toString\":{\"9\":-9007199254740992,\"�\":{\"message\":\" 12 12 debug\"},\"__proto__\":{\"1\":[\"01\",{\"0\":\"0b11 \",\"3\":null,\"01\":0.30000000000000004,\"__proto__\":\"ᆭ warn 12.5abc\",\"user_123\":\"INFO\"},{\"0\":9007199254740994,\"12.5\":true,\"deadbeef\":\"5. 0.1\\\"quoted\\\" \",\"\\\\\":true,\"ň 12\":true,\"level\":9007199254740994,\"b\":false,\"192.168.1.10\":-439196416.64251685,\"__proto__\":true,\"192.168.0.1\":\"fatal\",\"é\":\"a\\\\nberror🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 \"},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\"__proto__\":\"hasOwnProperty\"}}}}}","output":{"ok":true,"s":"{\"1\":null,\"3\":null,\"49\":true,\"deadbeef\":null,\"4294967295\":123456789012345680000,\"192.168.0.1\":true,\"length\":9007199254740992,\" event\":\"valueOftrue\",\"__defineGetter__\":\"2001:db8::1 +5\",\"a.b\":{\"100\":{\"toString\":{\"9\":-9007199254740992,\"�\":{\"message\":\" 12 12 debug\"},\"__proto__\":{\"1\":[\"01\",{\"0\":\"0b11 \",\"3\":null,\"01\":0.30000000000000004,\"__proto__\":\"ᆭ warn 12.5abc\",\"user_123\":\"INFO\"},{\"0\":9007199254740994,\"12.5\":true,\"deadbeef\":\"5. 0.1\\\"quoted\\\" \",\"\\\\\":true,\"ň 12\":true,\"level\":9007199254740994,\"b\":false,\"192.168.1.10\":-439196416.64251685,\"__proto__\":true,\"192.168.0.1\":\"fatal\",\"é\":\"a\\\\nberror🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 \"},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\"__proto__\":\"hasOwnProperty\"}}}}}"}},{"input":"true","output":{"ok":true,"s":"true"}},{"input":"-218566942.4943626","output":{"ok":true,"s":"-218566942.4943626"}},{"input":"false","output":{"ok":true,"s":"false"}},{"input":"[{\"\":{\"0\":{\"a\":[{\"b.c\":[[{\"a\":[[[{\"0\":[[{\"\":{\"\":{\"b.c\":[{\"b.c\":[{\"\":[{\"\":{\"0\":{\"\":[[{\"b.c\":{\"a\":[{\"0\":{\"0\":[[{\"b.c\":[[[[{\"b.c\":[{\"0\":{\"0\":{\"a\":{\"b.c\":[[{\"0\":{\"\":[[{\"b.c\":{\"0\":[[{\"0\":{\"a\":{\"a\":[[[{\"b.c\":[[[[[{\"\":[{\"0\":{\"\":[[{\"a\":[[[[{\"\":{\"0\":{\"\":[[{\"a\":[{\"0\":[[[[[[[{\"b.c\":[{\"b.c\":[[{\"a\":{\"b.c\":{\"\":{\"0\":{\"a\":[[[{\"b.c\":{\"\":[{\"a\":[{\"\":{\"b.c\":[{\"0\":{\"0\":{\"\":[{\"b.c\":[[{\"\":{\"b.c\":[[[{\"b.c\":{\"\":[1]}}]]]}}]]}]}}}]}}]}]}}]]]}}}}}]]}]}]]]]]]]}]}]]}}}]]]]}]]}}]}]]]]]}]]]}}}]]}}]]}}]]}}}}]}]]]]}]]}}]}}]]}}}]}]}]}}}]]}]]]}]]}]}}}]","output":{"ok":true,"s":"[{\"\":{\"0\":{\"a\":[{\"b.c\":[[{\"a\":[[[{\"0\":[[{\"\":{\"\":{\"b.c\":[{\"b.c\":[{\"\":[{\"\":{\"0\":{\"\":[[{\"b.c\":{\"a\":[{\"0\":{\"0\":[[{\"b.c\":[[[[{\"b.c\":[{\"0\":{\"0\":{\"a\":{\"b.c\":[[{\"0\":{\"\":[[{\"b.c\":{\"0\":[[{\"0\":{\"a\":{\"a\":[[[{\"b.c\":[[[[[{\"\":[{\"0\":{\"\":[[{\"a\":[[[[{\"\":{\"0\":{\"\":[[{\"a\":[{\"0\":[[[[[[[{\"b.c\":[{\"b.c\":[[{\"a\":{\"b.c\":{\"\":{\"0\":{\"a\":[[[{\"b.c\":{\"\":[{\"a\":[{\"\":{\"b.c\":[{\"0\":{\"0\":{\"\":[{\"b.c\":[[{\"\":{\"b.c\":[[[{\"b.c\":{\"\":[1]}}]]]}}]]}]}}}]}}]}]}}]]]}}}}}]]}]}]]]]]]]}]}]]}}}]]]]}]]}}]}]]]]]}]]]}}}]]}}]]}}]]}}}}]}]]]]}]]}}]}}]]}}}]}]}]}}}]]}]]]}]]}]}}}]"}},{"input":"9007199254740993.000001e+5 ","output":{"ok":false}},{"input":"{\" 🚀 \":{\"host.example.com\":{\"1.5 12\":{\" 12 payload\":{\"0\":{\"12345678\":\"3fa85f64-5717-4562-b3fc-2c963f66afa6 9007199254740992\"},\"49\":true,\"100\":null,\"\\\\\":9007199254740992,\"hasOwnProperty\":null,\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":\"\\\\\",\" \":{\"2025-01-15T10:00:00Z𐀀\":12.5,\"01日本\":9007199254740994,\"level\":3.981342401821166e-7,\"\\\"\":12.5,\"4294967295\":[\"\\r\\nNaNx\",-4.866939249914139e-16,false,false,\"host.example.com캘\",-41378584690.39201,false,\"hasOwnProperty12\\\\\",\"true\\t \",\"null\",0.000001,null,\"/api/v1/users/123ʘ\",\"\\n 12.5abc\",0,false,\"ۂERROR\",\"1e3 \",null,1,\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\\u000b 100 \",\"1_000Ꮹ\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}}}}}}","output":{"ok":true,"s":"{\" 🚀 \":{\"host.example.com\":{\"1.5 12\":{\" 12 payload\":{\"0\":{\"12345678\":\"3fa85f64-5717-4562-b3fc-2c963f66afa6 9007199254740992\"},\"49\":true,\"100\":null,\"\\\\\":9007199254740992,\"hasOwnProperty\":null,\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":\"\\\\\",\" \":{\"2025-01-15T10:00:00Z𐀀\":12.5,\"01日本\":9007199254740994,\"level\":3.981342401821166e-7,\"\\\"\":12.5,\"4294967295\":[\"\\r\\nNaNx\",-4.866939249914139e-16,false,false,\"host.example.com캘\",-41378584690.39201,false,\"hasOwnProperty12\\\\\",\"true\\t \",\"null\",0.000001,null,\"/api/v1/users/123ʘ\",\"\\n 12.5abc\",0,false,\"ۂERROR\",\"1e3 \",null,1,\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\\u000b 100 \",\"1_000Ꮹ\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}}}}}}"}},{"input":"{\"0\":1,\"b\":2,\"0\":3}","output":{"ok":true,"s":"{\"0\":3,\"b\":2}"}},{"input":"\u000b--0.5e-323 ","output":{"ok":false}},{"input":"{\"01\":1,\"b\":2,\"01\":null}","output":{"ok":true,"s":"{\"01\":null,\"b\":2}"}},{"input":"1.5","output":{"ok":true,"s":"1.5"}},{"input":" -1.5e-400","output":{"ok":true,"s":"0"}},{"input":"\"AKIAIOSFODNN7EXAMPLE\"","output":{"ok":true,"s":"\"AKIAIOSFODNN7EXAMPLE\""}},{"input":"21306.426892988384","output":{"ok":true,"s":"21306.426892988384"}},{"input":"--.12345678901234567890 ","output":{"ok":false}},{"input":"\t+123456789012345678901234567890.5e-323","output":{"ok":false}},{"input":"1","output":{"ok":true,"s":"1"}},{"input":"[]","output":{"ok":true,"s":"[]"}},{"input":"--00.E+0 ","output":{"ok":false}},{"input":"\n--123456789012345678901234567890.0e-5 ","output":{"ok":false}},{"input":"[{\"constructor\":\"Bearer abc.def-ghi \"},\"\\u000b10é \",null,{\"1e3\":\"host.example.com \",\"error\":[1,false,{\"51\":null,\"constructor\":{\"4294967294\":7,\"4294967295\":null,\"a\":\"🚀12 \",\"192.168.0.1\":{\"1\":{\"0\":\"INFO\",\"2\":0,\"49\":4.566432067658752e-8,\"\\\\50\":\"-0-0 \",\"\\udfff__proto__\":null,\"\":false,\" toString\":\"null/\",\"hasOwnProperty\":\"2025-01-15T10:00:00Zx 0\",\"..\":0.000001,\"\\n\":\"xoxb-1234567890-abc4294967295\",\"K\":null,\"9007199254740994\":null,\"fatal-1.5\":null,\"a.\":\"/api/v1/users/123debug 12 \",\"é\":123456789012345680000},\"49\":[true,true,-1.5],\"4294967296\":0,\"\":\"日本語warn\"}}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1]","output":{"ok":true,"s":"[{\"constructor\":\"Bearer abc.def-ghi \"},\"\\u000b10é \",null,{\"1e3\":\"host.example.com \",\"error\":[1,false,{\"51\":null,\"constructor\":{\"4294967294\":7,\"4294967295\":null,\"a\":\"🚀12 \",\"192.168.0.1\":{\"1\":{\"0\":\"INFO\",\"2\":0,\"49\":4.566432067658752e-8,\"\\\\50\":\"-0-0 \",\"\\udfff__proto__\":null,\"\":false,\" toString\":\"null/\",\"hasOwnProperty\":\"2025-01-15T10:00:00Zx 0\",\"..\":0.000001,\"\\n\":\"xoxb-1234567890-abc4294967295\",\"K\":null,\"9007199254740994\":null,\"fatal-1.5\":null,\"a.\":\"/api/v1/users/123debug 12 \",\"é\":123456789012345680000},\"49\":[true,true,-1.5],\"4294967296\":0,\"\":\"日本語warn\"}}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1]"}},{"input":"{\"0\":null,\"3\":true,\"🚀\":1.5,\"4294967295\":\"192.168.0.1AKIAIOSFODNN7EXAMPLE\",\"valueOf\":\"\\\"42949672950.000001\",\"192.168.0.1\":{\"constructor\"\\:{\"51\":false},\"event\":\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀2\",\"é\":[null,0.30000000000000004,null,\"-1\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}}","output":{"ok":false}},{"input":" 12a 日]本 \"","output":{"ok":false}},{"input":"--.e-400 ","output":{"ok":false}},{"input":"false","output":{"ok":true,"s":"false"}},{"input":"[{\"a\":{\"a\":{\"\":{\"a\":[[{\"a\":[[{\"\":[{\"0\":{\"b.c\":[[[{\"0\":{\"b.c\":[{\"a\":[[{\"0\":{\"b.c\":{\"\":[[{\"a\":[{\"b.c\":{\"a\":{\"a\":{\"0\":{\"b.c\":[[[[[{\"\":{\"b.c\":[{\"b.c\":{\"\":[{\"0\":[[[[[[{\"a\":[{\"0\":{\"b.c\":[[[[[{\"b.c\":{\"a\":[[[[[{\"a\":[[{\"a\":[{\"a\":{\"b.c\":{\"\":[[{\"b.c\":{\"a\":[[[[[[{\"a\":{\"0\":[{\"a\":{\"\":[[[{\"0\":[[{\"b.c\":[{\"b.c\":{\"a\":[[{\"a\":{\"a\":[{\"a\":{\"a\":[{\"\":{\"0\":[[{\"\":{\"b.c\":[{\"0\":{\"\":{\"\":[[{\"0\":[{\"0\":{\"b.c\":[[true]]}}]}]]}}}]}}]]}}]}}]}}]]}}]}]]}]]]}}]}}]]]]]]}}]]}}}]}]]}]]]]]}}]]]]]}}]}]]]]]]}]}}]}}]]]]]}}}}}]}]]}}}]]}]}}]]]}}]}]]}]]}}}}]","output":{"ok":true,"s":"[{\"a\":{\"a\":{\"\":{\"a\":[[{\"a\":[[{\"\":[{\"0\":{\"b.c\":[[[{\"0\":{\"b.c\":[{\"a\":[[{\"0\":{\"b.c\":{\"\":[[{\"a\":[{\"b.c\":{\"a\":{\"a\":{\"0\":{\"b.c\":[[[[[{\"\":{\"b.c\":[{\"b.c\":{\"\":[{\"0\":[[[[[[{\"a\":[{\"0\":{\"b.c\":[[[[[{\"b.c\":{\"a\":[[[[[{\"a\":[[{\"a\":[{\"a\":{\"b.c\":{\"\":[[{\"b.c\":{\"a\":[[[[[[{\"a\":{\"0\":[{\"a\":{\"\":[[[{\"0\":[[{\"b.c\":[{\"b.c\":{\"a\":[[{\"a\":{\"a\":[{\"a\":{\"a\":[{\"\":{\"0\":[[{\"\":{\"b.c\":[{\"0\":{\"\":{\"\":[[{\"0\":[{\"0\":{\"b.c\":[[true]]}}]}]]}}}]}}]]}}]}}]}}]]}}]}]]}]]]}}]}}]]]]]]}}]]}}}]}]]}]]]]]}}]]]]]}}]}]]]]]]}]}}]}}]]]]]}}}}}]}]]}}}]]}]}}]]]}}]}]]}]]}}}}]"}},{"input":"\t-9007199254740993e-5 ","output":{"ok":false}},{"input":"\n+00e308","output":{"ok":false}},{"input":" +123456789012345678901234567890e309","output":{"ok":false}},{"input":"\"valueOfvalueOulf NaN\"","output":{"ok":true,"s":"\"valueOfvalueOulf NaN\""}},{"input":"\"length\"","output":{"ok":true,"s":"\"length\""}},{"input":"{}","output":{"ok":true,"s":"{}"}},{"input":"\"\\\\sk_live_01\\u004123456789abcdefghijkl5e-324\\u0041\"","output":{"ok":true,"s":"\"\\\\sk_live_01A23456789abcdefghijkl5e-324A\""}},{"input":"+5.5","output":{"ok":false}},{"input":"\"INFO{\\\"a\\\":1}1e3 \"","output":{"ok":true,"s":"\"INFO{\\\"a\\\":1}1e3 \""}},{"input":"{\"1\":1,\"b\":2,\"1\":null}","output":{"ok":true,"s":"{\"1\":null,\"b\":2}"}},{"input":"-8.444995852187277e-23","output":{"ok":true,"s":"-8.444995852187277e-23"}},{"input":"4294967294","output":{"ok":true,"s":"4294967294"}},{"input":"{\"valueOf\":{\"4294967294\":[4.3846657010726633e-16,true,null,\"GET 4294967295\",false,null,{\"0\":\"1\",\"2\":\"Wed, 15 Jan 2025 12:00:00 GMT-1 \",\"51\":0.000001,\"\\\\\":\"\\\"2001:db8::1 payload\",\"1e3\":[true,[true,\" \",{\"0\":false,\"2\":\" x0\",\"9\":1e+21,\"49\":false,\"50\":true,\"4294967294\":\"Infinity \",\"user.email\":1.5,\"toString\":0.30000000000000004,\"\":-1.857732147909701e-19,\"\\\"\":true},1,1,1,1,1,1,1]],\" \":29274229193106.293,\"valueOf\":-1,\"\\udfffhost.example.com\":{},\"POST12 \":\"12.5abc5.12\"},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\"𐀀\":null}}","output":{"ok":true,"s":"{\"valueOf\":{\"4294967294\":[4.3846657010726633e-16,true,null,\"GET 4294967295\",false,null,{\"0\":\"1\",\"2\":\"Wed, 15 Jan 2025 12:00:00 GMT-1 \",\"51\":0.000001,\"\\\\\":\"\\\"2001:db8::1 payload\",\"1e3\":[true,[true,\" \",{\"0\":false,\"2\":\" x0\",\"9\":1e+21,\"49\":false,\"50\":true,\"4294967294\":\"Infinity \",\"user.email\":1.5,\"toString\":0.30000000000000004,\"\":-1.857732147909701e-19,\"\\\"\":true},1,1,1,1,1,1,1]],\" \":29274229193106.293,\"valueOf\":-1,\"\\udfffhost.example.com\":{},\"POST12 \":\"12.5abc5.12\"},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\"𐀀\":null}}"}},{"input":"null","output":{"ok":true,"s":"null"}},{"input":"\"5 Ѝ {\\\"a\\\":1\\\"","output":{"ok":false}},{"input":"null","output":{"ok":true,"s":"null"}},{"input":"\"1.5 Wed, 15 Jan 2025 12:00:00 GMT\"","output":{"ok":true,"s":"\"1.5 Wed, 15 Jan 2025 12:00:00 GMT\""}},{"input":"\u000b9007199254740993.0E+0 ","output":{"ok":false}},{"input":"tre","output":{"ok":false}},{"input":"\r+1.000001e-400","output":{"ok":false}},{"input":"-1e308","output":{"ok":true,"s":"-1e+308"}},{"input":"\t+1e-324 ","output":{"ok":false}},{"input":"[{\"0\":{\"\":{\"\":{\"a\":[[[[[[[[{\"a\":[[{\"\":[[{\"a\":[[[{\"b.c\":{\"a\":{\"\":{\"b.c\":[[[{\"0\":[[[[[{\"b.c\":{\"b.c\":[[[{\"0\":[[{\"0\":{\"a\":[[{\"\":[[{\"b.c\":[{\"b.c\":{\"a\":{\"\":{\"\":{\"\":[[{\"\":{\"0\":{\"\":[{\"\":{\"0\":[[{\"b.c\":[[[{\"\":{\"\":{\"0\":{\"\":{\"0\":{\"a\":[[[[[{\"0\":{\"a\":{\"a\":[{\"b.c\":[[[[[{\"0\":[{\"b.c\":[[{\"0\":[[{\"0\":[[[{\"b.c\":{\"0\":{\"\":[[[{\"b.c\":{\"\":{\"b.c\":{\"a\":{\"0\":{\"a\":[[{\"b.c\":[[{\"a\":{\"\":{\"b.c\":{\"\":{\"a\":{\"a\":{\"a\":{\"\":{\"b.c\":{\"a\":{\"a\":[{\"a\":[[[[[[{\"0\":{\"a\":[[[{\"b.c\":{\"b.c\":[[[[{\"\":[{\"0\":[[{\"\":{\"b.c\":{\"b.c\":[[{\"a\":[{\"\":{\"\":{\"0\":[[[[[[[{\"0\":{\"\":{\"0\":{\"0\":{\"0\":{\"\":[{\"a\":{\"\":{\"0\":{\"0\":{\"0\":[[[[[{\"a\":[{\"\":[{\"a\":{\"b.c\":[{\"b.c\":{\"b.c\":null}}]}}]}]}]]]]]}}}}}]}}}}}}]]]]]]]}}}]}]]}}}]]}]}]]]]}}]]]}}]]]]]]}]}}}}}}}}}}}]]}]]}}}}}}]]]}}}]]]}]]}]]}]}]]]]]}]}}}]]]]]}}}}}}]]]}]]}}]}}}]]}}}}}]}]]}]]}}]]}]]]}}]]]]]}]]]}}}}]]]}]]}]]}]]]]]]]]}}}}]","output":{"ok":true,"s":"[{\"0\":{\"\":{\"\":{\"a\":[[[[[[[[{\"a\":[[{\"\":[[{\"a\":[[[{\"b.c\":{\"a\":{\"\":{\"b.c\":[[[{\"0\":[[[[[{\"b.c\":{\"b.c\":[[[{\"0\":[[{\"0\":{\"a\":[[{\"\":[[{\"b.c\":[{\"b.c\":{\"a\":{\"\":{\"\":{\"\":[[{\"\":{\"0\":{\"\":[{\"\":{\"0\":[[{\"b.c\":[[[{\"\":{\"\":{\"0\":{\"\":{\"0\":{\"a\":[[[[[{\"0\":{\"a\":{\"a\":[{\"b.c\":[[[[[{\"0\":[{\"b.c\":[[{\"0\":[[{\"0\":[[[{\"b.c\":{\"0\":{\"\":[[[{\"b.c\":{\"\":{\"b.c\":{\"a\":{\"0\":{\"a\":[[{\"b.c\":[[{\"a\":{\"\":{\"b.c\":{\"\":{\"a\":{\"a\":{\"a\":{\"\":{\"b.c\":{\"a\":{\"a\":[{\"a\":[[[[[[{\"0\":{\"a\":[[[{\"b.c\":{\"b.c\":[[[[{\"\":[{\"0\":[[{\"\":{\"b.c\":{\"b.c\":[[{\"a\":[{\"\":{\"\":{\"0\":[[[[[[[{\"0\":{\"\":{\"0\":{\"0\":{\"0\":{\"\":[{\"a\":{\"\":{\"0\":{\"0\":{\"0\":[[[[[{\"a\":[{\"\":[{\"a\":{\"b.c\":[{\"b.c\":{\"b.c\":null}}]}}]}]}]]]]]}}}}}]}}}}}}]]]]]]]}}}]}]]}}}]]}]}]]]]}}]]]}}]]]]]]}]}}}}}}}}}}}]]}]]}}}}}}]]]}}}]]]}]]}]]}]}]]]]]}]}}}]]]]]}}}}}}]]]}]]}}]}}}]]}}}}}]}]]}]]}}]]}]]]}}]]]]]}]]]}}}}]]]}]]}]]}]]]]]]]]}}}}]"}},{"input":"{\"\":[{\"a\":[{\"b.c\":{\"0\":{\"\":[{\"\":{\"\":[{\"\":{\"0\":[[{\"\":{\"\":[[[{\"\":{\"\":{\"\":{\"b.c\":{\"b.c\":{\"a\":[[{\"b.c\":[[{\"b.c\":[{\"0\":[[{\"0\":{\"b.c\":[{\"b.c\":[[[[[[{\"0\":{\"\":{\"a\":[[{\"0\":{\"\":[{\"b.c\":{\"\":[[{\"0\":{\"\":[[{\"a\":{\"a\":{\"a\":{\"\":[{\"0\":{\"a\":{\"a\":[{\"0\":[[[[{\"b.c\":{\"b.c\":{\"b.c\":[{\"0\":[[{\"\":{\"\":[{\"0\":{\"\":[[{\"0\":{\"\":{\"b.c\":{\"b.c\":[{\"0\":{\"a\":[{\"b.c\":{\"a\":[[{\"\":[{\"a\":{\"\":[{\"b.c\":[{\"\":[{\"0\":{\"0\":[[[[[[[[{\"b.c\":{\"a\":[[[{\"\":[[[null]]]}]]]}}]]]]]]]]}}]}]}]}}]}]]}}]}}]}}}}]]}}]}}]]}]}}}]]]]}]}}}]}}}}]]}}]]}}]}}]]}}}]]]]]]}]}}]]}]}]]}]]}}}}}}]]]}}]]}}]}}]}}}]}]}","output":{"ok":true,"s":"{\"\":[{\"a\":[{\"b.c\":{\"0\":{\"\":[{\"\":{\"\":[{\"\":{\"0\":[[{\"\":{\"\":[[[{\"\":{\"\":{\"\":{\"b.c\":{\"b.c\":{\"a\":[[{\"b.c\":[[{\"b.c\":[{\"0\":[[{\"0\":{\"b.c\":[{\"b.c\":[[[[[[{\"0\":{\"\":{\"a\":[[{\"0\":{\"\":[{\"b.c\":{\"\":[[{\"0\":{\"\":[[{\"a\":{\"a\":{\"a\":{\"\":[{\"0\":{\"a\":{\"a\":[{\"0\":[[[[{\"b.c\":{\"b.c\":{\"b.c\":[{\"0\":[[{\"\":{\"\":[{\"0\":{\"\":[[{\"0\":{\"\":{\"b.c\":{\"b.c\":[{\"0\":{\"a\":[{\"b.c\":{\"a\":[[{\"\":[{\"a\":{\"\":[{\"b.c\":[{\"\":[{\"0\":{\"0\":[[[[[[[[{\"b.c\":{\"a\":[[[{\"\":[[[null]]]}]]]}}]]]]]]]]}}]}]}]}}]}]]}}]}}]}}}}]]}}]}}]]}]}}}]]]]}]}}}]}}}}]]}}]]}}]}}]]}}}]]]]]]}]}}]]}]}]]}]]}}}}}}]]]}}]]}}]}}]}}}]}]}"}},{"input":"null","output":{"ok":true,"s":"null"}},{"input":" +9007199254740993e-323 ","output":{"ok":false}},{"input":"{\"4294967294\":null,\"msg\":\"Bearer abc.def-ghi 12345678\",\"\\n\":-3.677897916641086e-13,\".a\":[{\"5\":\"1.7976931348623157e+3082192.168.1.1\",\"10\":{\"\\ud83d�\":[true,null,{\"\\/2\":\"a\\\\nb-Infinity \",\"50\":null,\"100\":[false],\"4294967294\":{\"1\":true,\"NaN\":null},\"user.email\":[\"-1e4000o7 [email protected] \",true,4294967294,\".a\",false,7,null,null,\"\\\"\",true,false,true,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\" \":\"sk_live_0123456789abcdefghijklerror\",\"http.method\":null},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},\"valueOf\":0.30000000000000004,\"user.email\":false,\"𐀀\":null,\"\\\"\":null,\"\\\\\":{}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}","output":{"ok":true,"s":"{\"4294967294\":null,\"msg\":\"Bearer abc.def-ghi 12345678\",\"\\n\":-3.677897916641086e-13,\".a\":[{\"5\":\"1.7976931348623157e+3082192.168.1.1\",\"10\":{\"\\ud83d�\":[true,null,{\"50\":null,\"100\":[false],\"4294967294\":{\"1\":true,\"NaN\":null},\"/2\":\"a\\\\nb-Infinity \",\"user.email\":[\"-1e4000o7 [email protected] \",true,4294967294,\".a\",false,7,null,null,\"\\\"\",true,false,true,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\" \":\"sk_live_0123456789abcdefghijklerror\",\"http.method\":null},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},\"valueOf\":0.30000000000000004,\"user.email\":false,\"𐀀\":null,\"\\\"\":null,\"\\\\\":{}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}"}},{"input":"true","output":{"ok":true,"s":"true"}},{"input":"1818179457914084000","output":{"ok":true,"s":"1818179457914084000"}},{"input":" 123456789012345678901234567890.5e+5","output":{"ok":false}},{"input":"{\"1\":1,\"b\":2,\"1\":null}","output":{"ok":true,"s":"{\"1\":null,\"b\":2}"}},{"input":"\"͝12 valueOf\"","output":{"ok":true,"s":"\"͝12 valueOf\""}},{"input":"\r.e21 ","output":{"ok":false}},{"input":"\"{ \"\u0001","output":{"ok":false}},{"input":"{\"2\":\"1.5debug }full \",\"100\":[595017.4387544394,null,true,false,{\"0\":{\"deadbeef\":\"AK IAIOSFODNN7EXAMPLE日本語\",\"constructor\":1e+100,\"01\":\"ﯥuuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\"},\"-1\":\"1.5\",\"4294967295\":null},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\"INFO\":\"k \"}","output":{"ok":true,"s":"{\"2\":\"1.5debug }full \",\"100\":[595017.4387544394,null,true,false,{\"0\":{\"deadbeef\":\"AK IAIOSFODNN7EXAMPLE日本語\",\"constructor\":1e+100,\"01\":\"ﯥuuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\"},\"-1\":\"1.5\",\"4294967295\":null},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\"INFO\":\"k \"}"}},{"input":"\r+123456789012345678901234567890e ","output":{"ok":false}},{"input":"--9007199254740993.5e-400","output":{"ok":false}},{"input":"4294967294","output":{"ok":true,"s":"4294967294"}},{"input":"-5e309 ","output":{"ok":false}},{"input":"{\"1\":null,\"51\":false}","output":{"ok":true,"s":"{\"1\":null,\"51\":false}"}},{"input":"{\"2\":4655022225.342691,\"10\":\"1e3sk_live_0123456789abcdefghijkl\",\"100\":true,\"fatal\":false,\"constructor msg\":\"🚀ERROR\",\"user.email\":[true,true,{\"-1\":12.5,\"msg\":null,\" 5.\":\" 12\",\"1e-7c\":false,\"逸 xoxb-1234567890-abc\":{\"3\":\"ghp_0123456789abcdefghij0123456789abcdef{\\\"a\\\":1}\",\"\\t\":0.0029789705341681837},\".a\":{\"0\":\"1.5 \",\"a.b\":{\"10\":{\"a.\":\"7\",\"user_123\":{\"0\":null,\"1\":0,\"2\":null,\"3\":1.5,\"5\":\"xoxb-1234567890-abc\",\"9\":\"[email protected]\",\"49\":\"NaN\",\"51\":null,\"🚀\":false,\"__proto__\":\"߽\",\"full\":\"2025-01-15T10:00:00Zlength {\\\"a\\\":1}\",\"12 -1e400 \":null,\"01\":\"4294967294125. \",\".a\":\"0x104294967295ghp_0123456789abcdefghij0123456789abcdef \",\"hasOwnProperty\":0.000001,\"constructor\":\"-1e400 ✭\"}}}}}]}","output":{"ok":true,"s":"{\"2\":4655022225.342691,\"10\":\"1e3sk_live_0123456789abcdefghijkl\",\"100\":true,\"fatal\":false,\"constructor msg\":\"🚀ERROR\",\"user.email\":[true,true,{\"-1\":12.5,\"msg\":null,\" 5.\":\" 12\",\"1e-7c\":false,\"逸 xoxb-1234567890-abc\":{\"3\":\"ghp_0123456789abcdefghij0123456789abcdef{\\\"a\\\":1}\",\"\\t\":0.0029789705341681837},\".a\":{\"0\":\"1.5 \",\"a.b\":{\"10\":{\"a.\":\"7\",\"user_123\":{\"0\":null,\"1\":0,\"2\":null,\"3\":1.5,\"5\":\"xoxb-1234567890-abc\",\"9\":\"[email protected]\",\"49\":\"NaN\",\"51\":null,\"🚀\":false,\"__proto__\":\"߽\",\"full\":\"2025-01-15T10:00:00Zlength {\\\"a\\\":1}\",\"12 -1e400 \":null,\"01\":\"4294967294125. \",\".a\":\"0x104294967295ghp_0123456789abcdefghij0123456789abcdef \",\"hasOwnProperty\":0.000001,\"constructor\":\"-1e400 ✭\"}}}}}]}"}},{"input":"{\"01\":1,\"b\":2,\"01\":{\"x\":1}}","output":{"ok":true,"s":"{\"01\":{\"x\":1},\"b\":2}"}},{"input":"[[{\"0\":{\"a\":[[{\"0\":[{\"\":[{\"\":{\"a\":{\"b.c\":{\"\":[[[[[{\"0\":[{\"0\":[{\"b.c\":[{\"\":[[{\"0\":[[{\"\":[{\"b.c\":[[[[[[[[[[[{\"b.c\":{\"b.c\":{\"b.c\":{\"0\":{\"b.c\":{\"a\":[{\"\":[[[{\"0\":{\"0\":{\"\":[{\"\":{\"a\":[[[{\"a\":[{\"0\":{\"b.c\":{\"b.c\":[{\"b.c\":{\"b.c\":{\"0\":[{\"0\":{\"0\":[[[{\"0\":{\"b.c\":[{\"b.c\":{\"\":[{\"a\":[{\"a\":[{\"a\":{\"a\":{\"\":[{\"a\":[[[{\"a\":[[{\"0\":[[[[{\"a\":[[[[[{\"a\":[[[[{\"a\":{\"0\":[[[{\"a\":{\"a\":{\"a\":[true]}}}]]]}}]]]]}]]]]]}]]]]}]]}]]]}]}}}]}]}]}}]}}]]]}}]}}}]}}}]}]]]}}]}}}]]]}]}}}}}}]]]]]]]]]]]}]}]]}]]}]}]}]}]]]]]}}}}]}]}]]}}]]","output":{"ok":true,"s":"[[{\"0\":{\"a\":[[{\"0\":[{\"\":[{\"\":{\"a\":{\"b.c\":{\"\":[[[[[{\"0\":[{\"0\":[{\"b.c\":[{\"\":[[{\"0\":[[{\"\":[{\"b.c\":[[[[[[[[[[[{\"b.c\":{\"b.c\":{\"b.c\":{\"0\":{\"b.c\":{\"a\":[{\"\":[[[{\"0\":{\"0\":{\"\":[{\"\":{\"a\":[[[{\"a\":[{\"0\":{\"b.c\":{\"b.c\":[{\"b.c\":{\"b.c\":{\"0\":[{\"0\":{\"0\":[[[{\"0\":{\"b.c\":[{\"b.c\":{\"\":[{\"a\":[{\"a\":[{\"a\":{\"a\":{\"\":[{\"a\":[[[{\"a\":[[{\"0\":[[[[{\"a\":[[[[[{\"a\":[[[[{\"a\":{\"0\":[[[{\"a\":{\"a\":{\"a\":[true]}}}]]]}}]]]]}]]]]]}]]]]}]]}]]]}]}}}]}]}]}}]}}]]]}}]}}}]}}}]}]]]}}]}}}]]]}]}}}}}}]]]]]]]]]]]}]}]]}]]}]}]}]}]]]]]}}}}]}]}]]}}]]"}}]}diff --git a/rust/logs-ingestion/tests/fixtures/fuzz/metrics.json b/rust/logs-ingestion/tests/fixtures/fuzz/metrics.jsonnew file mode 100644index 000000000000..ddbd2a6db95c--- /dev/null+++ b/rust/logs-ingestion/tests/fixtures/fuzz/metrics.json@@ -0,0 +1 @@+{"cases":[{"input":{"rules":[{"id":"m0","metric_name":"count_all","filter_group":null,"value_attribute":"ms","group_by":["attributes.toString","attributes.🚀","attributes.http.method","event_name","status_code","resource_attributes.service.name"],"source":"spans"}],"defaults":"logs","now_ms":1736944633250,"records":[{"uuid":"s0","trace_id":{"$bytes":"fac596e1ac0648b80465e1421312f1f3"},"span_id":{"$bytes":"256ff9a40517d45d"},"timestamp":1736943523409000,"end_time":1736943523409001,"name":"","kind":9,"status_code":0,"service_name":"worker","resource_attributes":{"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6":"4294967294","k8s.pod.name":"\"null\"","a":"\"0\"","service.name":"\"ERROR\""},"attributes":{"kind":"\" \"","001":"\"12\"","a":"true","payload.x":"null","duration_ms":"[1,2]"}}]},"output":{"payload_json":"{\"resourceMetrics\":[{\"resource\":{\"attributes\":[{\"key\":\"service.name\",\"value\":{\"stringValue\":\"worker\"}}]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"posthog.log.records\",\"sum\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1,\"traceId\":\"fac596e1ac0648b80465e1421312f1f3\",\"spanId\":\"256ff9a40517d45d\"}],\"asDouble\":1}],\"aggregationTemporality\":1,\"isMonotonic\":true}}]}]}]}","value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"x y","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"__defineGetter__","operator":"not_in","value":"12","type":"span_attribute"},{"type":"AND","values":[{"type":"AND","values":[{"key":"service_name","operator":"lt","value":{"a":1},"type":"log"}]}]}]}]},"value_attribute":null,"group_by":["resource_attributes.service.name","event_name","attributes.payload","resource_attributes.service.name","resource_attributes.service.name"],"source":"other"},{"id":"m1","metric_name":"m.1","filter_group":null,"value_attribute":"attributes.valueOf","group_by":["resource_attributes.k8s.pod.name","severity_text","attributes.constructor"]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"9711f163dd4adccd"},"span_id":{"$bytes":"48336a994cc98d1b"},"trace_flags":null,"timestamp":1736943841555000,"observed_timestamp":1736944633250000,"body":"0b11full ","severity_text":"ERRor","severity_number":0,"service_name":"web","resource_attributes":{},"instrumentation_scope":null,"event_name":null,"attributes":{"duration_ms":"\"0.1\"","name":"\" \"","kind":"\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"","a":"null","count":"\"12.5abc\"","payload":"0.1"},"bytes_uncompressed":null}]},"output":{"payload_json":null,"value_skipped":1,"eval_errors":1,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"posthog.log.records","filter_group":null,"value_attribute":"ms","group_by":["status_code","attributes.payload","kind","event_name","body"]},{"id":"m1","metric_name":"","filter_group":null,"value_attribute":"duration_ms","group_by":["resource_attributes.service.name","resource_attributes.k8s.pod.name","service_name","body",5,"kind"]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"s0","trace_id":{"$bytes":"b35ffe4644f84c0abd8b83fa22cf2124"},"span_id":{"$bytes":"40e47e7931bd7ab9"},"timestamp":1736944529886000,"end_time":1736944529881000,"name":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","kind":0,"status_code":null,"service_name":"api","resource_attributes":{},"attributes":{"duration_ms":"-1","payload":"4294967294","http.method":"\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\""}},{"uuid":"s1","trace_id":{"$bytes":"e99c9a94c3143771afae679eadc8e1a0"},"span_id":null,"timestamp":1736942987297000,"end_time":1736943523384382,"name":"GET /a","kind":0,"status_code":-1,"service_name":"worker","resource_attributes":{"service.name":"\"1e3\"","-1e400":"\"🚀\"","k8s.pod.name":"9007199254740994","a":"2001:db8::1"},"attributes":{"payload":"\"日本語\"","忨 ":"\"ghp_0123456789abcdefghij0123456789abcdef\"","duration_ms":"9007199254740992","k8s.pod.name":"192.168.1.1 ","http.path":"0.1","hasOwnProperty":"false","ms":"9007199254740994","count":"1e+"}},{"uuid":"s2","trace_id":{"$bytes":"c952773c72d27fe5426179dc485a7973"},"span_id":{"$bytes":"a096d3e0fc1a8cb7"},"timestamp":1736944119861000,"end_time":1736944119861000,"name":"","kind":null,"status_code":7,"service_name":"worker","resource_attributes":null,"attributes":{"duration_ms":"123456789012345678901234567890"}}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"posthog.log.records","filter_group":null,"value_attribute":"attributes.payload","group_by":["kind","event_name","attributes.","severity_text","status_code"]},{"id":"m1","metric_name":"","filter_group":null,"value_attribute":"ms","group_by":[]},{"id":"m2","metric_name":"","filter_group":{"type":"AND","values":[]},"value_attribute":"resource_attributes.a","group_by":["attributes."]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"ca2ddde273cc0d5a3922ead6aae4d634"},"span_id":null,"trace_flags":null,"timestamp":1736942616088000,"observed_timestamp":1736944633250000,"body":"2025-01-15T10:00:00Z","severity_text":"info","severity_number":17,"service_name":null,"resource_attributes":{"host":"\"\\\"a\\\\\\\\nb 12 \\\\\\\"quoted\\\\\\\" \\\"\""},"instrumentation_scope":null,"event_name":"request","attributes":{"🚀":"4294967295","count":"\"3\"","payload":"[1,2]"},"bytes_uncompressed":221}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"constructor","value":-9007199254740992,"type":"span_attribute"},{"key":"1","operator":"not_icontains","value":"xoxb-1234567890-abc","type":"span_attribute"}]}]},"value_attribute":"attributes.count","group_by":["kind","attributes.level","attributes.ms","status_code"],"source":"other"}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":""},"span_id":{"$bytes":"9bb8ee2692f2b0fa"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"__defineGetter__ 🚀__proto__ 1.5 ","severity_text":null,"severity_number":13,"service_name":"web","resource_attributes":{"1":"{\"4294967294\":\"12\",\"__proto__\":{\".a\":null},\"\":\"1.5192.168.1.1ٌ \",\"length\":{\"\":[12.5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}}","𐀀":"false","service.name":"\"Wed, 15 Jan 2025 12:00:00 GMT\"","constructor":"\"Infinity\""},"instrumentation_scope":null,"event_name":null,"attributes":{"a":"\"ERROR \"","kind":"\"null\"","é":"false","count":"4294967295","payload":"[1,2]"},"bytes_uncompressed":null}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"","filter_group":{"type":"AND","values":[{"type":"AND","values":[]}]},"value_attribute":"ms","group_by":["body","status_code","attributes.payload","event_name","body","attributes.1"]},{"id":"m1","metric_name":"","filter_group":null,"value_attribute":"attributes.valueOf","group_by":[]},{"id":"m2","metric_name":"m.2","filter_group":null,"value_attribute":"ms","group_by":["attributes.","resource_attributes.service.name","kind","resource_attributes.service.name","attributes.toString",""],"source":"other"}],"defaults":"spans","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"5db975b05184e81d64bbd93c566bfd1b"},"span_id":{"$bytes":"b678dc80bd8b83f1"},"trace_flags":null,"timestamp":1736943543937000,"observed_timestamp":1736944633250000,"body":"true0b11","severity_text":null,"severity_number":null,"service_name":"API","resource_attributes":{"k8s.pod.name":"\"{\\\"a\\\":1}�payload\""},"instrumentation_scope":null,"event_name":"request","attributes":null,"bytes_uncompressed":1057}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"x y","filter_group":{"type":"AND","values":[{"type":"AND","values":[]}]},"value_attribute":null,"group_by":[]},{"id":"m1","metric_name":"m.1","filter_group":null,"value_attribute":"ms","group_by":["status_code","service_name"]},{"id":"m2","metric_name":"","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"missing","value":null,"type":"log"},{"key":"missing","operator":"not_ends_with","value":["GET",1e+21],"type":"span_attribute"},{"key":"severity_text","operator":"not_icontains","value":false,"type":"span_attribute"}]}]},"value_attribute":"attributes.valueOf","group_by":[5,"attributes.__proto__","attributes.toString","attributes.__proto__","name","attributes.http.method"]}],"defaults":"spans","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"2829f3dac81689e9"},"span_id":null,"trace_flags":null,"timestamp":1736944106616000,"observed_timestamp":1736944633250000,"body":"4294967295日本語 \\Bearer abc.def-ghi2","severity_text":"debug ","severity_number":17,"service_name":"worker","resource_attributes":null,"instrumentation_scope":null,"event_name":null,"attributes":{"payload":"4294967295"},"bytes_uncompressed":172},{"uuid":"u1","trace_id":{"$bytes":""},"span_id":null,"trace_flags":null,"timestamp":1736944297245000,"observed_timestamp":1736944633250000,"body":"0 ȼ NaN ","severity_text":"trace","severity_number":9,"service_name":null,"resource_attributes":{"host":"\"1e400\"","a":"7","constructor":"{\"1\":[\"constructor \",{\"user.email\":{\"b\":null,\"a.b\":false,\"constructor\":\"\"}},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}"},"instrumentation_scope":null,"event_name":null,"attributes":{"user.email":"2025-01-15T10:00:00Zhttp.method","4294967294 .5":"null","ms":"\"123456789012345678901234567890\"","count":"1e-400","payload":"\"123456789012345678901234567890\"","http.method":"\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\""},"bytes_uncompressed":140}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"m.0","filter_group":{"type":"AND","values":[{"key":"service_name","operator":"ends_with","value":"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀","type":"log_resource_attribute"},{"type":"AND","values":[{"type":"OR","values":[]}]},{"key":"url.path","operator":"lte","value":{"toString":1},"type":"log_attribute"}]},"value_attribute":null,"group_by":["attributes.payload"]},{"id":"m1","metric_name":"count_all","filter_group":null,"value_attribute":"attributes.valueOf","group_by":["resource_attributes.k8s.pod.name","attributes.level","attributes.payload",5,"attributes.payload"]},{"id":"m2","metric_name":"posthog.log.records","filter_group":null,"value_attribute":"attributes.count","group_by":["body","name","severity_text"],"source":"other"}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"8bf2aef0665c079a6114ed050441a53f"},"span_id":{"$bytes":"0b98583726c303ef"},"trace_flags":null,"timestamp":1736944447641000,"observed_timestamp":1736944633250000,"body":"1,5 000x10 12\\","severity_text":"fatal","severity_number":5,"service_name":null,"resource_attributes":{"1":"\"{\\\"full\\\":[{\\\"0\\\":\\\"1_000__defineGetter__ \\\"},null,null,null,null,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}\"","k8s.pod.name":"\"2025-01-15T10:00:00Z\""},"instrumentation_scope":null,"event_name":"","attributes":{"message":"\"\\\"\"","payload.x":" ","ms":"1e+100","count":"0.1","duration_ms":"5."},"bytes_uncompressed":1816}]},"output":{"payload_json":null,"value_skipped":1,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"","filter_group":null,"value_attribute":"attributes.count","group_by":["name","attributes.constructor",5,"attributes.level","body","attributes.__proto__"]},{"id":"m1","metric_name":"count_all","filter_group":null,"value_attribute":"ms","group_by":["resource_attributes.k8s.pod.name","body",5,"event_name","attributes.constructor"],"source":"logs"},{"id":"m2","metric_name":"count_all","filter_group":null,"value_attribute":"attributes.ms","group_by":["attributes.level"],"source":"spans"},{"id":"m3","metric_name":"x y","filter_group":null,"value_attribute":"duration_ms","group_by":["name","severity_text","attributes.level"],"source":"other"}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"s0","trace_id":null,"span_id":{"$bytes":"c5ac613d874ba8c6"},"timestamp":null,"end_time":1736942996684000,"name":"","kind":5,"status_code":-1,"service_name":"api","resource_attributes":{},"attributes":{"message":"0.000001","k":"false","payload.x":"1e+21","ms":"-.5e-2","duration_ms":"0.1","payload":"1"}}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"m.0","filter_group":null,"value_attribute":"attributes.payload","group_by":[""]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"1ed089b420d7e8600c7698367f8a3516"},"span_id":{"$bytes":"5f1a3d476745500b"},"trace_flags":null,"timestamp":1736944079920000,"observed_timestamp":1736944633250000,"body":"deadbeefeyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123100valueOf","severity_text":null,"severity_number":17,"service_name":"","resource_attributes":{"k8s.pod.name":"\"true\""},"instrumentation_scope":null,"event_name":"","attributes":{"K":"\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"","🚀":"\"12.5abc\"","k8s.pod.name":"\"debug\"","status_code":"12.5","payload":"\"1.7976931348623157e+308é\"","count":"\"-.5e-2\"","duration_ms":"1e+21"},"bytes_uncompressed":715}]},"output":{"payload_json":"{\"resourceMetrics\":[{\"resource\":{\"attributes\":[]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"m.0\",\"histogram\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1.7976931348623157e+308,\"traceId\":\"1ed089b420d7e8600c7698367f8a3516\",\"spanId\":\"5f1a3d476745500b\"}],\"count\":1,\"sum\":1.7976931348623157e+308,\"bucketCounts\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]}],\"aggregationTemporality\":1}}]}]}]}","value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"posthog.log.records","filter_group":null,"value_attribute":"attributes.payload","group_by":["",""],"source":"spans"},{"id":"m1","metric_name":"m.1","filter_group":{"type":"AND","values":[{"type":"XOR","values":[]},{"type":"AND","values":[{"type":"AND","values":[{"key":"severity_text","value":["x",{"toString":1}]}]}]},{"key":"constructor","operator":"not_in","value":"2025-01-15T10:00:00Z","type":"log_resource_attribute"}]},"value_attribute":"ms","group_by":["kind","service_name",""],"source":"spans"}],"defaults":"logs","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":""},"span_id":{"$bytes":"a923e1b102952ab4"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"/api/v1/users/1231,50x10é","severity_text":null,"severity_number":0,"service_name":"API","resource_attributes":{"a":"true","host":"\"{\\\"a\\\":1}\"","k8s.pod.name":"POST"},"instrumentation_scope":null,"event_name":null,"attributes":{"1":"null","duration_ms":"0","service.name":"true","http.path":"\"9007199254740993 \"","payload":"9007199254740992","http.server.duration_ms":"\u000b 12","ms":"00012"},"bytes_uncompressed":992},{"uuid":"u1","trace_id":{"$bytes":"e365d19ba929e3bbdb5c13faad9608e0"},"span_id":null,"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"user_123warn 慕","severity_text":"İnfo","severity_number":null,"service_name":"web","resource_attributes":{"service.name":"\"\\\\\""},"instrumentation_scope":null,"event_name":"request","attributes":null,"bytes_uncompressed":null}]},"output":{"payload_json":"{\"resourceMetrics\":[{\"resource\":{\"attributes\":[]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"posthog.log.records\",\"histogram\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"count\":1,\"sum\":9007199254740992,\"bucketCounts\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]}],\"aggregationTemporality\":1}}]}]}]}","value_skipped":1,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"x y","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[{"key":"service_name","operator":"gte","value":"xoxb-1234567890-abc","type":"log"}]},{"key":"count","operator":"is_not","value":[1e+21,"api",1e+21],"type":"span_resource_attribute"}]}]},"value_attribute":null,"group_by":[5,"attributes.http.method","service_name",5,"severity_text","attributes.payload"],"source":"other"}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"s0","trace_id":{"$bytes":"6c723797de37c6e4d3188a2da1e1d3e7"},"span_id":{"$bytes":"9a5e7dabb44d8ecb"},"timestamp":1736943356239000,"end_time":1736943356240500,"name":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","kind":1,"status_code":2,"service_name":"api","resource_attributes":{"k8s.pod.name":"4294967295","a":"\"\\\"Infinityéééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\\\"\""},"attributes":{"0":"Wed, 15 Jan 2025 12:00:00 GMT__proto__ {\"a\":1}","message":" ","count":"\"++7\""}}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"","filter_group":null,"value_attribute":"attributes.ms","group_by":["event_name","attributes.level",5,"attributes.constructor"],"source":"logs"},{"id":"m1","metric_name":"","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"OR","values":[{"key":"missing","operator":"is_not_set","value":"é","type":"span_resource_attribute"},{"key":"name","operator":"not_starts_with","value":9007199254740992,"type":"event"}]},{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[{"key":"severity_level","operator":"not_icontains","value":"sk_live_0123456789abcdefghijkl","type":"span_attribute"}]}]}]},{"key":"__proto__","operator":"icontains","value":"12","type":"span_resource_attribute"}]}]},"value_attribute":null,"group_by":["name","resource_attributes.service.name"]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":""},"span_id":{"$bytes":"77959719295e3f7a"},"trace_flags":null,"timestamp":1736943928567000,"observed_timestamp":1736944633250000,"body":"r🚀 ","severity_text":"DEBUG","severity_number":0,"service_name":"API","resource_attributes":{"1":"0","host":"false","a":"\"Wed, 15 Jan 2025 12:00:00 GMT\"","constructor":"true","k8s.pod.name":"\" \""},"instrumentation_scope":null,"event_name":null,"attributes":{"a.b":"\"0b11\"","payload.x":"\"+5\"","user.email":"0.1 Infinityé ","path":"a\\nbNaN","http.response.status_code":"false","count":"[1,2]","duration_ms":"1e-400"},"bytes_uncompressed":176},{"uuid":"u1","trace_id":{"$bytes":"98c5e8c12e73bff4"},"span_id":{"$bytes":"41518369c6365aee"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"1_000 [email protected]𑜡 ","severity_text":"info","severity_number":1,"service_name":"","resource_attributes":{"1":"\"{\\\"1\\\":{\\\"4294967294\\\":{\\\"constructor\\\":{\\\"1\\\":4294967294,\\\"49\\\":-1.5,\\\"4294967294\\\":\\\"INFO12\\\"}}}}\"","k":"\"true\"","a":"\"0\"","ERROR":"9007199254740992","constructor":"0x10",".510 ":"0"},"instrumentation_scope":null,"event_name":"","attributes":{"1":"true","level":"true","toString":"null","a.b":"false","payload.x":"0","a":"ERROR ","payload.0":"a\\nb","ms":"-0","count":"\"-.5e-2\"","duration_ms":"\"0.1\""},"bytes_uncompressed":211}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"posthog.log.records","filter_group":null,"value_attribute":"duration_ms","group_by":["resource_attributes.service.name","body","body","resource_attributes.k8s.pod.name","attributes.toString","body"]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"3709fd0d1d243fec94eb0a4bd74cfecb"},"span_id":{"$bytes":"85bb8cebfd8553ca"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"日本語 ","severity_text":null,"severity_number":0,"service_name":null,"resource_attributes":{"a":"-1"},"instrumentation_scope":null,"event_name":"","attributes":{"ms":"1e","duration_ms":"1e-7"},"bytes_uncompressed":null},{"uuid":"u1","trace_id":{"$bytes":"6f6110dcbfeadb27"},"span_id":null,"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":null,"severity_text":"debug ","severity_number":13,"service_name":"web","resource_attributes":{"1":"\"{\\\"12345678\\\":[\\\"\\\"]}\"","host":"-1.5","日本語":"false","constructor":"1","a":"\"\\\"quoted\\\" -0xoxb-1234567890-abc\"","service.name":"null"},"instrumentation_scope":null,"event_name":"","attributes":{"1":"\"debug\"","valueOf":"12.5","message":"\"-Infinity\"","level":"0.1","user.email":"\"{\\\"12\\\":null,\\\"message\\\":false,\\\"full\\\":{\\\"1\\\":[false,\\\"12 \\\"],\\\"90071992547409941e400\\\":null}}\"","ms":"++7","count":"12345.678"},"bytes_uncompressed":86}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"","filter_group":null,"value_attribute":"ms","group_by":["resource_attributes.k8s.pod.name","attributes.constructor","name","service_name"],"source":"other"},{"id":"m1","metric_name":"x y","filter_group":null,"value_attribute":null,"group_by":["attributes.level","","attributes.http.method","severity_text","kind","attributes.http.method"]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"a540e816ffd972f7"},"span_id":{"$bytes":"2320c0bc62dd5ac3"},"trace_flags":null,"timestamp":1736942310103000,"observed_timestamp":1736944633250000,"body":null,"severity_text":"WARN","severity_number":9,"service_name":"","resource_attributes":{"1":"null","a":"2.5e-8","host":"\"01\"","service.name":"false"},"instrumentation_scope":null,"event_name":"","attributes":{"count":"true","hasOwnProperty":"\" \"","severity_text":"1.7976931348623157e+308","ms":"1e400"},"bytes_uncompressed":225},{"uuid":"u1","trace_id":{"$bytes":"9e36d30c36487420aa4cba099b91994f"},"span_id":null,"trace_flags":null,"timestamp":1736942495806000,"observed_timestamp":1736944633250000,"body":"12 1e3 123456789012345680000 日本語","severity_text":"WARN","severity_number":0,"service_name":"api","resource_attributes":{"host":"\"00\"","constructor":"\"INFO\"","":"true"},"instrumentation_scope":null,"event_name":"","attributes":null,"bytes_uncompressed":458},{"uuid":"u2","trace_id":{"$bytes":"6b5fbcc4b688c8adf3059c1c15a9a769"},"span_id":null,"trace_flags":null,"timestamp":1736943443494000,"observed_timestamp":1736944633250000,"body":" 12a\\nbmessage ERROR 9007199254740994 ","severity_text":"fatal","severity_number":null,"service_name":"web","resource_attributes":{"sk_live_0123456789abcdefghijkl 192.168.0.1":"[-113259153.90625596,{\"9\":\"Bearer abc.def-ghi 日本語\",\"50\":null}]","a":"true","host":"5e-324"},"instrumentation_scope":null,"event_name":"request","attributes":{"message":"null","hasOwnProperty":"-1","http.path":"4294967295","ms":"\"3\""},"bytes_uncompressed":1376}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"count_all","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"payload","operator":"not_ends_with","value":0},{"key":"service_name","operator":"not_in","value":"Bearer abc.def-ghi"},{"key":"k8s.pod.name","operator":"is_not_set","value":false,"type":"log"}]}]},"value_attribute":"duration_ms","group_by":["attributes.ms","body","severity_text","attributes.","","severity_text"],"source":"spans"},{"id":"m1","metric_name":"posthog.log.records","filter_group":null,"value_attribute":"ms","group_by":[5]}],"defaults":"logs","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"288461bedfd117ef3c7ac05a59b56e5f"},"span_id":null,"trace_flags":null,"timestamp":1736943207077000,"observed_timestamp":1736944633250000,"body":"0.30000000000000004 🚀 12 2025-01-15T10:00:00Z","severity_text":"ERRor","severity_number":1,"service_name":"API","resource_attributes":{},"instrumentation_scope":null,"event_name":"request","attributes":null,"bytes_uncompressed":560},{"uuid":"u1","trace_id":{"$bytes":"58a1f6c83c27845a"},"span_id":{"$bytes":"13f6bf92894f04dc"},"trace_flags":null,"timestamp":1736942609841000,"observed_timestamp":1736944633250000,"body":" 0o7🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀顷 ","severity_text":"debug ","severity_number":12,"service_name":"worker","resource_attributes":{"service.name":"\"{\\\"0\\\":-1,\\\"12345678\\\":[2.833515638485551e-14,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\\\"deadbeef\\\":{\\\"4294967296\\\":null},\\\"\\\":9007199254740992}\""},"instrumentation_scope":null,"event_name":"request","attributes":{"01":"\"2025-01-15T10:00:00Z\"","K":"3fa85f64-5717-4562-b3fc-2c963f66afa6","kind":"0.1","k":"\"GET\"","count":"0","payload":"0.1"},"bytes_uncompressed":42}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"x y","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[]}]}]},"value_attribute":"attributes.ms","group_by":["attributes.toString","attributes.http.method","","attributes.level","attributes.1",""]}],"defaults":"spans","now_ms":1736944633250,"records":[{"uuid":"s0","trace_id":null,"span_id":{"$bytes":"717990d7e688c001"},"timestamp":1736943751297000,"end_time":1736943751297001,"name":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","kind":9,"status_code":0,"service_name":"worker","resource_attributes":{"service.name":"1e+21","a":"\"\\\"quoted\\\".5\"","k8s.pod.name":"false"},"attributes":{"🚀":"false","hasOwnProperty":"12AKIAIOSFODNN7EXAMPLE","constructor":"\"5.\"","path":"\"sk_live_0123456789abcdefghijkl\"","":"false","count":"\"NaN\""}}]},"output":{"payload_json":"{\"resourceMetrics\":[{\"resource\":{\"attributes\":[{\"key\":\"service.name\",\"value\":{\"stringValue\":\"worker\"}}]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"posthog.span.duration\",\"unit\":\"ms\",\"histogram\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"9\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"UNSET\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"count\":1,\"sum\":0.001,\"bucketCounts\":[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]}],\"aggregationTemporality\":1}}]}]}]}","value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"","filter_group":null,"value_attribute":"attributes.valueOf","group_by":["event_name","attributes.http.method"]},{"id":"m1","metric_name":"posthog.log.records","filter_group":{"type":"AND","values":[{"type":"OR","values":[]}]},"value_attribute":"ms","group_by":["attributes.toString","attributes.","body","attributes.ms"]},{"id":"m2","metric_name":"count_all","filter_group":null,"value_attribute":"attributes.ms","group_by":["attributes.__proto__","severity_text","attributes.","service_name","service_name"]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":null,"span_id":{"$bytes":"1cd983835422ea4b"},"trace_flags":null,"timestamp":1736942262300000,"observed_timestamp":1736944633250000,"body":"Wed, 15 Jan 2025 12:00:00 GMT12\"1_000","severity_text":null,"severity_number":9,"service_name":"api","resource_attributes":null,"instrumentation_scope":null,"event_name":null,"attributes":{"k":"\"1.929461571853608e-10\"","length":"false","http.path":"debug0b11 ","path":"1e-7","payload":"[1,2]"},"bytes_uncompressed":1965}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"count_all","filter_group":{"type":"AND","values":[{"type":"XOR","values":[]},{"type":"AND","values":[{"type":"OR","values":[{"key":"url.path","operator":"lt","value":[1e+21],"type":"span_attribute"}]}]},{"key":true,"operator":"not_in","value":"2001:db8::1","type":"log_resource_attribute"}]},"value_attribute":"attributes.valueOf","group_by":["name"],"source":"logs"},{"id":"m1","metric_name":"x y","filter_group":null,"value_attribute":"attributes.duration_ms","group_by":["attributes.__proto__"],"source":"spans"},{"id":"m2","metric_name":"","filter_group":{"type":"OR","values":[{"key":"toString","operator":"is_not","value":["x",{"toString":1}],"type":"span_resource_attribute"}]},"value_attribute":"duration_ms","group_by":["event_name","attributes.toString","attributes.__proto__"]},{"id":"m3","metric_name":"m.3","filter_group":null,"value_attribute":"duration_ms","group_by":["resource_attributes.service.name","resource_attributes.service.name","attributes.__proto__","attributes.__proto__","resource_attributes.k8s.pod.name"]}],"defaults":"logs","now_ms":1736944633250,"records":[{"uuid":"s0","trace_id":{"$bytes":"3b46a9c5915c1fc64d426da59242620d"},"span_id":null,"timestamp":1736943069730000,"end_time":1736943069730000,"name":null,"kind":2,"status_code":2,"service_name":null,"resource_attributes":{"a":"1_000 ",".a":"12.5","k8s.pod.name":"\"POST\"","length":"0","service.name":"9007199254740994"},"attributes":{"fatal":"9007199254740992","duration_ms":"\"{\\\"a\\\":1}\"","a":"\"null\"","constructor":"\"1e400\"","ms":"1","payload":"10000"}}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"posthog.log.records","filter_group":null,"value_attribute":null,"group_by":["event_name","severity_text","resource_attributes.k8s.pod.name","attributes.__proto__","attributes.level","attributes.🚀"]},{"id":"m1","metric_name":"count_all","filter_group":null,"value_attribute":"attributes.count","group_by":[]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":null,"span_id":{"$bytes":"191905e83505349d"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"0.1AKIAIOSFODNN7EXAMPLE","severity_text":"","severity_number":5,"service_name":null,"resource_attributes":{},"instrumentation_scope":null,"event_name":"","attributes":{"0":"\"\\\"null0ӊ\\\"\"","toString":"null","url.path":"ﭪxoxb-1234567890-abc 12","payload.x":"0.1","payload":"0"},"bytes_uncompressed":778}]},"output":{"payload_json":"{\"resourceMetrics\":[{\"resource\":{\"attributes\":[]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"posthog.log.records\",\"sum\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"event_name\",\"value\":{\"stringValue\":\"\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"\"}},{\"key\":\"k8s.pod.name\",\"value\":{\"stringValue\":\"\"}},{\"key\":\"__proto__\",\"value\":{\"stringValue\":{}}},{\"key\":\"level\",\"value\":{\"stringValue\":\"\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1}],\"aggregationTemporality\":1,\"isMonotonic\":true}}]}]}]}","value_skipped":1,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"m.0","filter_group":null,"value_attribute":"attributes.duration_ms","group_by":["resource_attributes.service.name","resource_attributes.service.name"]},{"id":"m1","metric_name":"posthog.log.records","filter_group":{"type":"AND","values":[]},"value_attribute":"attributes.valueOf","group_by":["resource_attributes.k8s.pod.name","attributes.","severity_text"],"source":"logs"}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"3f045c07cc6c33dc935662b94e0f7e32"},"span_id":{"$bytes":"d8ceddfe7f34928a"},"trace_flags":null,"timestamp":1736944096165000,"observed_timestamp":1736944633250000,"body":"Ӏ ","severity_text":"İnfo","severity_number":13,"service_name":"API","resource_attributes":{"1":"\"a\\\\nb\"","a":"\"[1,2]\"","service.name":"\"{\\\"5\\\":{\\\"49\\\":null,\\\"51\\\":\\\"4294967294 ?\\\",\\\"4294967296\\\":null,\\\"12__proto__\\\":[],\\\"hasOwnProperty\\\":true},\\\"10\\\":378733421908691.5}\"","k8s.pod.name":"-1"},"instrumentation_scope":null,"event_name":"","attributes":{"http.route":"12","ms":"12.5abc"},"bytes_uncompressed":850},{"uuid":"u1","trace_id":null,"span_id":null,"trace_flags":null,"timestamp":1736943599406000,"observed_timestamp":1736944633250000,"body":"0o7\" 10\n","severity_text":"","severity_number":0,"service_name":"web","resource_attributes":{"a":"true","service.name":"\"fatal\""},"instrumentation_scope":null,"event_name":null,"attributes":{"":"-9007199254740992","count":"\"+7\""},"bytes_uncompressed":650}]},"output":{"payload_json":null,"value_skipped":2,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"count_all","filter_group":{"type":"AND","values":[{"type":"OR","values":[]}]},"value_attribute":"attributes.count","group_by":["attributes.payload"]},{"id":"m1","metric_name":"x y","filter_group":null,"value_attribute":"attributes.valueOf","group_by":["attributes.http.method",5,"attributes.http.method","name","attributes.toString"],"source":"spans"}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":""},"span_id":{"$bytes":"a5d8dee12e4024f7"},"trace_flags":null,"timestamp":1736943427436000,"observed_timestamp":1736944633250000,"body":" ","severity_text":"INFO","severity_number":1,"service_name":"web","resource_attributes":{"1":"\"1_000\"","service.name":"\"\""},"instrumentation_scope":null,"event_name":"request","attributes":{"level":"false","01":"9007199254740993 𛂷 é ","ms":"7500","count":" 12","payload":"00012"},"bytes_uncompressed":475},{"uuid":"u1","trace_id":{"$bytes":"43d6a594261db231"},"span_id":null,"trace_flags":null,"timestamp":1736943523619000,"observed_timestamp":1736944633250000,"body":"length3fa85f64-5717-4562-b3fc-2c963f66afa6 full user.email","severity_text":"Warn","severity_number":0,"service_name":"","resource_attributes":{"1":"-Infinity ","event":"\" 12\"","k8s.pod.name":"1.7976931348623157e+308"},"instrumentation_scope":null,"event_name":null,"attributes":{"payload.x":"2.5e-8","payload":"\"-.5e-2\"","http.method":"\"deny\""},"bytes_uncompressed":1421},{"uuid":"u2","trace_id":{"$bytes":"a67403e9c23756f8c54805f1eff9c19f"},"span_id":{"$bytes":"452e30abb800c81a"},"trace_flags":null,"timestamp":1736942294558000,"observed_timestamp":1736944633250000,"body":"-1e400 eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123POST ","severity_text":"INFO","severity_number":5,"service_name":"API","resource_attributes":{"constructor":"2025-01-15T10:00:00Z","host":"false"},"instrumentation_scope":null,"event_name":null,"attributes":{"0":"1e400 ","kind":"1","":"\"\\\"1e+21 999.9999999 true\\\"\"","payload":"\"0b1\""},"bytes_uncompressed":248}]},"output":{"payload_json":null,"value_skipped":1,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"count_all","filter_group":null,"value_attribute":"attributes.valueOf","group_by":["attributes.level","attributes.ms","attributes.level"],"source":"logs"}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":""},"span_id":null,"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"ട 3fa85f64-5717-4562-b3fc-2c963f66afa6 � ","severity_text":"debug ","severity_number":9,"service_name":"web","resource_attributes":null,"instrumentation_scope":null,"event_name":null,"attributes":{"count":"\"-0\"","kind":"\"GET\"","user.email":"\"true\"","toString":"\"Infinity\"","ms":"2.5e-8","duration_ms":"123456789012345678901234567890"},"bytes_uncompressed":1549},{"uuid":"u1","trace_id":null,"span_id":{"$bytes":"41a475d0725b7623"},"trace_flags":null,"timestamp":1736943074391000,"observed_timestamp":1736944633250000,"body":"9007199254740993true100","severity_text":"debug ","severity_number":13,"service_name":"API","resource_attributes":{"1":"\"GET\"","host":"4294967295","\\":"é"},"instrumentation_scope":null,"event_name":null,"attributes":{"toString":"\"1_000\"","constructor":"-1323330323.2118487","payload.0":"\"AKIAIOSFODNN7EXAMPLE\"","http.server.duration_ms":"0.30000000000000004","service.name":"null","a.b":"\"1e3\""},"bytes_uncompressed":1969},{"uuid":"u2","trace_id":{"$bytes":"ce7a15a7633a7f1e"},"span_id":{"$bytes":"45c34137275819c6"},"trace_flags":null,"timestamp":1736942556336000,"observed_timestamp":1736944633250000,"body":"-0 true 5.","severity_text":"Warn","severity_number":null,"service_name":"web","resource_attributes":null,"instrumentation_scope":null,"event_name":"request","attributes":{"1":"4294967295","duration_ms":"\"++7\"","k":"\"x\"","user.email":"-1.5","a":"-9007199254740992","hasOwnProperty":"1.5","é":"sk_live_0123456789abcdefghijkl\tuser.email"},"bytes_uncompressed":955}]},"output":{"payload_json":null,"value_skipped":1,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"key":"constructor","operator":"not_starts_with","value":0.000001}]}]},{"key":"k8s.pod.name","operator":"is_set","value":"0x10"},{"key":"url.path","operator":"lt","value":"12"}]},"value_attribute":"attributes.count","group_by":["attributes.ms","attributes.🚀","attributes.constructor","attributes.level",5,"resource_attributes.k8s.pod.name"]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":null,"span_id":null,"trace_flags":null,"timestamp":1736942964745000,"observed_timestamp":1736944633250000,"body":"1INFO0.1","severity_text":"fatal","severity_number":5,"service_name":null,"resource_attributes":{"host":"\"192.168.1.1\"","a":"\"a\\\\nb\"","service.name":"/api/v1/users/123"},"instrumentation_scope":null,"event_name":"","attributes":{"1":"false","ms":"9007199254740993","192.168.0.1":"0.000001","service.name":"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé","count":"\"0b1\"","duration_ms":"1e+100"},"bytes_uncompressed":438}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"x y","filter_group":null,"value_attribute":"attributes.ms","group_by":["service_name","kind","status_code","attributes.toString","severity_text"]},{"id":"m1","metric_name":"posthog.log.records","filter_group":{"type":"AND","values":[{"key":"k8s.pod.name","value":2.5e-8,"type":"span_resource_attribute"},{"key":"a","operator":"not_icontains","value":["GET",true,"x"],"type":"log_resource_attribute"}]},"value_attribute":"ms","group_by":["service_name","attributes.1","attributes.__proto__"],"source":"other"},{"id":"m2","metric_name":"count_all","filter_group":null,"value_attribute":"attributes.count","group_by":["attributes.1"],"source":"other"}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"s0","trace_id":{"$bytes":"bbcfab58232eaa339cc1eb68f239ce12"},"span_id":{"$bytes":"31cac67a3d4475fa"},"timestamp":1736943306605000,"end_time":1736943313855125,"name":"","kind":-1,"status_code":-1,"service_name":"worker","resource_attributes":{"a":"\" 12 \"","service.name":"\"1_000\""},"attributes":null}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"count_all","filter_group":null,"value_attribute":null,"group_by":["attributes.payload","event_name","kind","attributes.toString","","attributes.payload"]},{"id":"m1","metric_name":"x y","filter_group":null,"value_attribute":"ms","group_by":["attributes.ms","attributes.🚀","attributes.__proto__","attributes.toString"],"source":"other"},{"id":"m2","metric_name":"posthog.log.records","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"message","operator":"icontains","value":{"a":1}}]}]},"value_attribute":"attributes.ms","group_by":["severity_text","attributes.level"],"source":"other"}],"defaults":"spans","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"f80e8c05fdc29f7801abc4b9da76e15e"},"span_id":{"$bytes":"8548adbdd85e6ec0"},"trace_flags":null,"timestamp":1736944312327000,"observed_timestamp":1736944633250000,"body":"12.5abc 0.000001POST؞AKIAIOSFODNN7EXAMPLE ","severity_text":"WARN","severity_number":9,"service_name":"web","resource_attributes":{},"instrumentation_scope":null,"event_name":"","attributes":{"duration_ms":"[1,2]"},"bytes_uncompressed":1017}]},"output":{"payload_json":null,"value_skipped":1,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"m.0","filter_group":{"type":"AND","values":[]},"value_attribute":"duration_ms","group_by":["attributes.__proto__",5,"","resource_attributes.service.name","kind"],"source":"other"},{"id":"m1","metric_name":"m.1","filter_group":null,"value_attribute":"ms","group_by":["attributes.🚀","attributes.🚀","service_name","resource_attributes.k8s.pod.name","attributes.toString"]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":null,"span_id":{"$bytes":"0acbc1f4c23c5f0c"},"trace_flags":null,"timestamp":1736943274278000,"observed_timestamp":1736944633250000,"body":"GETWed, 15 Jan 2025 12:00:00 GMT5.0 ","severity_text":"","severity_number":12,"service_name":"API","resource_attributes":{"service.name":"\"+5\""},"instrumentation_scope":null,"event_name":"request","attributes":{"constructor":"\"null\"","toString":"999.9999999","count":"4294967295","duration_ms":"[1,2]"},"bytes_uncompressed":1025},{"uuid":"u1","trace_id":{"$bytes":"71819446491d5812"},"span_id":{"$bytes":"65b00c8a013c7db9"},"trace_flags":null,"timestamp":1736943158408000,"observed_timestamp":1736944633250000,"body":" b日本語-Infinity\u000b ","severity_text":"info","severity_number":0,"service_name":"api","resource_attributes":{"1":"\"1e3\"","host":"-143319518.07253063","constructor":"\"/api/v1/users/123\"","a":"0.1"},"instrumentation_scope":null,"event_name":null,"attributes":null,"bytes_uncompressed":1798},{"uuid":"u2","trace_id":{"$bytes":"702159f2ba617751"},"span_id":{"$bytes":"ae18dbcf5647e552"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":null,"severity_text":"fatal","severity_number":null,"service_name":"","resource_attributes":{"a":"error"},"instrumentation_scope":null,"event_name":"","attributes":{"é":"3fa85f64-5717-4562-b3fc-2c963f66afa6","count":"-1.5","duration_ms":"10000","payload":" 12"},"bytes_uncompressed":391}]},"output":{"payload_json":null,"value_skipped":1,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"","filter_group":{"type":"AND","values":[{"type":"OR","values":[]}]},"value_attribute":"attributes.count","group_by":["attributes.__proto__","resource_attributes.service.name","name",5,"","attributes.ms"],"source":"logs"},{"id":"m1","metric_name":"m.1","filter_group":null,"value_attribute":"attributes.count","group_by":["attributes.payload","severity_text","attributes.level","name","attributes.1"],"source":"other"},{"id":"m2","metric_name":"posthog.log.records","filter_group":null,"value_attribute":null,"group_by":[]}],"defaults":"spans","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"66d038c5fb8deb7b3aab7c74bbed8292"},"span_id":{"$bytes":"b14bffa0cf85f355"},"trace_flags":null,"timestamp":1736943821200000,"observed_timestamp":1736944633250000,"body":"__proto__ ","severity_text":"ERRor","severity_number":-1,"service_name":"worker","resource_attributes":{},"instrumentation_scope":null,"event_name":null,"attributes":{"1":"1","valueOf":"\" \"","level":"\"+5\"","constructor":"0","-1":"0","":"\"[email protected]\"","ms":"1e+","duration_ms":".5","payload":"1e-400","http.method":"\"deny\""},"bytes_uncompressed":1224}]},"output":{"payload_json":"{\"resourceMetrics\":[{\"resource\":{\"attributes\":[]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"posthog.log.records\",\"sum\":{\"dataPoints\":[{\"attributes\":[],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1,\"traceId\":\"66d038c5fb8deb7b3aab7c74bbed8292\",\"spanId\":\"b14bffa0cf85f355\"}],\"asDouble\":1}],\"aggregationTemporality\":1,\"isMonotonic\":true}}]}]}]}","value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"","filter_group":{"type":"OR","values":[{"key":"status_code","operator":"icontains","value":1e+21,"type":"span_resource_attribute"}]},"value_attribute":"attributes.ms","group_by":"notarray"},{"id":"m1","metric_name":"","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"key":true,"operator":"ends_with","value":[true]}]}]}]}]},"value_attribute":null,"group_by":["status_code","attributes.payload","status_code"],"source":"other"}],"defaults":"spans","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"fe12c9f4c0fb16598bd1f892c91c6034"},"span_id":{"$bytes":"d7a57f3365fcc4ff"},"trace_flags":null,"timestamp":1736943142694000,"observed_timestamp":1736944633250000,"body":"1\"quoted\" \r\n 0o7 -Infinity","severity_text":"ERROR","severity_number":0,"service_name":"","resource_attributes":{"constructor":"\"ERROR\""},"instrumentation_scope":null,"event_name":null,"attributes":{"count":"9007199254740993","duration_ms":"0.1"},"bytes_uncompressed":null}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"x y","filter_group":null,"value_attribute":"attributes.ms","group_by":["attributes.level","attributes.ms"]},{"id":"m1","metric_name":"count_all","filter_group":null,"value_attribute":null,"group_by":["status_code","attributes.__proto__","event_name"]}],"defaults":"spans","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"afd02f392e48e03f000c86776a0e982a"},"span_id":{"$bytes":"e6c65c1e241242c8"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"trueconstructor","severity_text":"debug ","severity_number":17,"service_name":"API","resource_attributes":{"host":"-1","k8s.pod.name":"\"🚀\"","Wed, 15 Jan 2025 12:00:00 GMT0b11":"\"\\\"9007199254740992 a. 蜽\\\"\"","a":"1_000","1.5":"\"{\\\"10\\\":[null,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\\\"日本\\\":{\\\"-1\\\":123456789012345680000},\\\"deadbeef\\\":{\\\"00 fatal\\\":[],\\\"k\\\":\\\"x-1e400\\\"}}\""},"instrumentation_scope":null,"event_name":null,"attributes":{"10":"123456789012345680000","payload.0":"5.","kind":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"","level":"\"\\u000b\"","count":"-1.5","duration_ms":"[1,2]","payload":"1e3"},"bytes_uncompressed":737}]},"output":{"payload_json":null,"value_skipped":2,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"m.0","filter_group":{"type":"AND","values":[]},"value_attribute":"attributes.count","group_by":["attributes.level","attributes.constructor","service_name","attributes.level"],"source":"logs"},{"id":"m1","metric_name":"count_all","filter_group":{"type":"OR","values":[{"type":"AND","values":[{"type":"OR","values":[]}]},{"key":"http.method","operator":"gte","value":null,"type":"event"}]},"value_attribute":"resource_attributes.a","group_by":"notarray"},{"id":"m2","metric_name":"count_all","filter_group":null,"value_attribute":"attributes.duration_ms","group_by":["service_name",5,"attributes."]},{"id":"m3","metric_name":"m.3","filter_group":{"type":"AND","values":[{"key":"kind","operator":"starts_with","value":123456789012345680000,"type":"event"},{"key":"service.name","operator":"not_starts_with","value":true},{"type":"AND","values":[{"key":"name","value":[],"type":"span_attribute"},{"key":"toString","operator":"icontains","value":0,"type":"span_resource_attribute"},null]}]},"value_attribute":null,"group_by":["status_code","body","kind"]}],"defaults":"spans","now_ms":1736944633250,"records":[]},"output":{"compile_error":"TypeError: Cannot read properties of null (reading 'values')"}},{"input":{"rules":[{"id":"m0","metric_name":"x y","filter_group":null,"value_attribute":"attributes.valueOf","group_by":["attributes.🚀"],"source":"other"},{"id":"m1","metric_name":"m.1","filter_group":{"type":"AND","values":[null]},"value_attribute":null,"group_by":["attributes.level","resource_attributes.k8s.pod.name",5,"","resource_attributes.k8s.pod.name","attributes.1"],"source":"logs"}],"defaults":"spans","now_ms":1736944633250,"records":[]},"output":{"compile_error":"TypeError: Cannot read properties of null (reading 'values')"}},{"input":{"rules":[{"id":"m0","metric_name":"x y","filter_group":null,"value_attribute":"attributes.ms","group_by":[],"source":"logs"},{"id":"m1","metric_name":"posthog.log.records","filter_group":null,"value_attribute":"attributes.duration_ms","group_by":["body"]},{"id":"m2","metric_name":"posthog.log.records","filter_group":{"type":"AND","values":[null]},"value_attribute":"attributes.payload","group_by":["body","service_name"],"source":"logs"}],"defaults":null,"now_ms":1736944633250,"records":[]},"output":{"compile_error":"TypeError: Cannot read properties of null (reading 'values')"}},{"input":{"rules":[{"id":"m0","metric_name":"x y","filter_group":{"type":"AND","values":[{"type":"AND","values":[]}]},"value_attribute":null,"group_by":["attributes.http.method"]},{"id":"m1","metric_name":"posthog.log.records","filter_group":{"type":"AND","values":[{"type":"AND","values":[]}]},"value_attribute":"duration_ms","group_by":["attributes.level"]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":null,"span_id":{"$bytes":"5d5b95980060340a"},"trace_flags":null,"timestamp":1736944057167000,"observed_timestamp":1736944633250000,"body":"12.51e3 00","severity_text":"Warn","severity_number":null,"service_name":"API","resource_attributes":{"1":"[{\"3\":{\"a.\":true}},{\".a\":true,\"b\":{},\"level\":\"fatal-1.5\"},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","10":"0","a":"\"{\\\"b\\\":true,\\\".a {\\\\\\\"a\\\\\\\":1}\\\":null,\\\"é -1.5\\\":{\\\"message\\\":{\\\"+5🚀 \\\":{\\\"2\\\":-9007199254740992,\\\"3\\\":null}}}}\"","host":"\"warn\""},"instrumentation_scope":null,"event_name":"","attributes":null,"bytes_uncompressed":83}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"m.0","filter_group":null,"value_attribute":"ms","group_by":["attributes.","service_name","status_code"]},{"id":"m1","metric_name":"count_all","filter_group":null,"value_attribute":"attributes.ms","group_by":["severity_text","service_name","kind"],"source":"other"},{"id":"m2","metric_name":"","filter_group":null,"value_attribute":"duration_ms","group_by":["resource_attributes.service.name","attributes.","attributes.http.method","attributes.__proto__","resource_attributes.k8s.pod.name","attributes.ms"],"source":"other"}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"2b1bb6211394a9af"},"span_id":null,"trace_flags":null,"timestamp":1736942792695000,"observed_timestamp":1736944633250000,"body":"1e400hasOwnProperty error \\","severity_text":"trace","severity_number":17,"service_name":"API","resource_attributes":{"1":"\"null\"","service.name":"\"null\"","k8s.pod.name":" 12","host":"null","a":"\"a\\\\nb\""},"instrumentation_scope":null,"event_name":"request","attributes":{"count":"[1,2]","payload":"1e3"},"bytes_uncompressed":null}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"posthog.log.records","filter_group":null,"value_attribute":"attributes.payload","group_by":[],"source":"other"},{"id":"m1","metric_name":"m.1","filter_group":null,"value_attribute":null,"group_by":"notarray"},{"id":"m2","metric_name":"posthog.log.records","filter_group":null,"value_attribute":null,"group_by":[5,"attributes.__proto__"],"source":"logs"}],"defaults":"spans","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":""},"span_id":null,"trace_flags":null,"timestamp":1736942534250000,"observed_timestamp":1736944633250000,"body":"INFO Bearer abc.def-ghi0o7 ","severity_text":"INFO","severity_number":0,"service_name":"","resource_attributes":{"host":"\"12.5abc\"","service.name":"\" \""},"instrumentation_scope":null,"event_name":null,"attributes":{"kind":"false","duration_ms":"5.","payload":"[1,2]"},"bytes_uncompressed":479},{"uuid":"u1","trace_id":{"$bytes":"f871f70f2fec04bdb462555e7da85e68"},"span_id":{"$bytes":"9c8c55d2580770f3"},"trace_flags":null,"timestamp":1736943296766000,"observed_timestamp":1736944633250000,"body":" ","severity_text":"","severity_number":17,"service_name":"worker","resource_attributes":{},"instrumentation_scope":null,"event_name":"request","attributes":{"http.route":"\"1,5\""},"bytes_uncompressed":123}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"","filter_group":null,"value_attribute":null,"group_by":["kind","","attributes.constructor"]},{"id":"m1","metric_name":"m.1","filter_group":null,"value_attribute":"attributes.duration_ms","group_by":["attributes.http.method","attributes.1","body","body","attributes.__proto__"],"source":"spans"},{"id":"m2","metric_name":"m.2","filter_group":null,"value_attribute":"attributes.valueOf","group_by":["name",5,"severity_text","attributes.http.method"]},{"id":"m3","metric_name":"","filter_group":null,"value_attribute":"attributes.ms","group_by":["attributes."]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"s0","trace_id":null,"span_id":{"$bytes":"03af95c5614317ae"},"timestamp":1736944345258000,"end_time":1736944345258001,"name":"GET /a","kind":4,"status_code":-1,"service_name":"api","resource_attributes":{"k8s.pod.name":"a\\nb","a":"\"\\\"k \\\"\"","service.name":"false"},"attributes":{"\t":"{\"50\":{\"🚀 K\":\"12 0.30000000000000004 \",\"4294967295\":[true,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},\"51\":\"\\u000b9007199254740993msg\",\"4294967294\":true,\"u\":true}","ms":"100","count":"1.5","duration_ms":"[1,2]","payload":"\"1e3\""}}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"m.0","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"missing","operator":"lte","value":"Bearer abc.def-ghi","type":"span_resource_attribute"},{"type":"AND","values":[null]},{"key":"__defineGetter__","operator":"icontains","value":"true","type":"log_attribute"}]}]},"value_attribute":"attributes.ms","group_by":["resource_attributes.service.name"]},{"id":"m1","metric_name":"x y","filter_group":null,"value_attribute":"resource_attributes.a","group_by":["attributes.http.method","status_code","attributes.http.method"],"source":"logs"},{"id":"m2","metric_name":"x y","filter_group":null,"value_attribute":"attributes.ms","group_by":["service_name","event_name","service_name","attributes.constructor","event_name","attributes."]},{"id":"m3","metric_name":"m.3","filter_group":{"type":"OR","values":[{"key":"k8s.pod.name","value":1e+100,"type":"event"},{"type":"AND","values":[]},{"type":"AND","values":[{"key":"url.path","operator":"starts_with","value":" 12","type":"event"}]}]},"value_attribute":null,"group_by":["attributes.payload","service_name",5,"attributes.http.method","attributes."]}],"defaults":"logs","now_ms":1736944633250,"records":[]},"output":{"compile_error":"TypeError: Cannot read properties of null (reading 'values')"}},{"input":{"rules":[{"id":"m0","metric_name":"x y","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"toString","value":true,"type":"log_attribute"}]}]},"value_attribute":"resource_attributes.a","group_by":[]},{"id":"m1","metric_name":"","filter_group":null,"value_attribute":"resource_attributes.a","group_by":["service_name","kind","body"]},{"id":"m2","metric_name":"count_all","filter_group":null,"value_attribute":null,"group_by":["body","body"]},{"id":"m3","metric_name":"count_all","filter_group":null,"value_attribute":"attributes.valueOf","group_by":["attributes.payload","resource_attributes.k8s.pod.name","attributes.1",5,"attributes.1","resource_attributes.k8s.pod.name"],"source":"spans"}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":""},"span_id":null,"trace_flags":null,"timestamp":1736942569153000,"observed_timestamp":1736944633250000,"body":"Y1.7976931348623157e+308 uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6-1e400日本語","severity_text":"İnfo","severity_number":13,"service_name":"worker","resource_attributes":{"1":"{\"9\":false,\"10\":{\"49\":\"null123456789012345680000éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"},\"1e3\":true,\"🚀 \":1.0438152239657938e-20,\"1.5\":[],\"4294967295\":false}","a":"2.5e-8","service.name":"\"POST\"","constructor":"\"ghp_0123456789abcdefghij0123456789abcdef\""},"instrumentation_scope":null,"event_name":null,"attributes":{"count":"-.5e-2","http.method":"\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa🚀\""},"bytes_uncompressed":1387}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"m.0","filter_group":null,"value_attribute":"attributes.count","group_by":["attributes.payload"],"source":"spans"}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"s0","trace_id":{"$bytes":"03526cac3a525f339dd7f2117f507fb2"},"span_id":{"$bytes":"6fc88ebc2601d999"},"timestamp":1736942960269000,"end_time":1736942960269001,"name":"GET /a","kind":2,"status_code":2,"service_name":null,"resource_attributes":{"k8s.pod.name":"\"\""},"attributes":{"a.b":"\"\"","message":"4294967294","__defineGetter__":"7","ms":"-.5e-2","count":"[1,2]","payload":"\"3\""}}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"m.0","filter_group":{"type":"AND","values":[{"type":"AND","values":[]}]},"value_attribute":"attributes.payload","group_by":["event_name","body","severity_text"]},{"id":"m1","metric_name":"x y","filter_group":{"type":"OR","values":[]},"value_attribute":null,"group_by":["attributes."],"source":"spans"},{"id":"m2","metric_name":"posthog.log.records","filter_group":null,"value_attribute":"attributes.valueOf","group_by":["attributes.level"]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"576dbaca20d0d8f3"},"span_id":{"$bytes":"d8c1c0b89fb93fe0"},"trace_flags":null,"timestamp":1736942466343000,"observed_timestamp":1736944633250000,"body":"msg12.5abc.aW ","severity_text":"debug ","severity_number":-1,"service_name":"API","resource_attributes":{"1":"7","constructor":"\"\\\"\"","hasOwnProperty":"\"12\"","k8s.pod.name":"\"GET\"","host":"\"+5\""},"instrumentation_scope":null,"event_name":null,"attributes":{"severity_text":"\"xoxb-1234567890-abc\"","status_code":"\"a.3fa85f64-5717-4562-b3fc-2c963f66afa6\"","":"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀日本語0","service.name":"false","__defineGetter__":"\"12.5abc\"","payload.x":"4294967295","deadbeef":"\"ghp_0123456789abcdefghij0123456789abcdef\"","ms":"1"},"bytes_uncompressed":1879}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"posthog.log.records","filter_group":null,"value_attribute":null,"group_by":["resource_attributes.service.name","attributes.🚀","resource_attributes.k8s.pod.name","attributes.constructor"],"source":"spans"},{"id":"m1","metric_name":"count_all","filter_group":null,"value_attribute":"attributes.payload","group_by":["resource_attributes.service.name","severity_text"]}],"defaults":"logs","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"0e0a01df784a27cd00cdc1ceced1db88"},"span_id":{"$bytes":"32a743f718e5f15b"},"trace_flags":null,"timestamp":1736944499968000,"observed_timestamp":1736944633250000,"body":" d a.[1,2] ","severity_text":"Warn","severity_number":17,"service_name":"","resource_attributes":{"constructor":"null","k8s.pod.name":"\"ghp_0123456789abcdefghij0123456789abcdef\""},"instrumentation_scope":null,"event_name":"request","attributes":{"a.b":"5e-324","k":"\" 12\"","hasOwnProperty":"\"-0\"","payload.x":"🚀","🚀":"\"sk_live_0123456789abcdefghijkl\"","count":"[1,2]","http.method":"\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa🚀\""},"bytes_uncompressed":1744}]},"output":{"payload_json":"{\"resourceMetrics\":[{\"resource\":{\"attributes\":[]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"posthog.log.records\",\"sum\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"service.name\",\"value\":{\"stringValue\":\"\"}},{\"key\":\"🚀\",\"value\":{\"stringValue\":\"sk_live_0123456789abcdefghijkl\"}},{\"key\":\"k8s.pod.name\",\"value\":{\"stringValue\":\"ghp_0123456789abcdefghij0123456789abcdef\"}},{\"key\":\"constructor\",\"value\":{}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1,\"traceId\":\"0e0a01df784a27cd00cdc1ceced1db88\",\"spanId\":\"32a743f718e5f15b\"}],\"asDouble\":1}],\"aggregationTemporality\":1,\"isMonotonic\":true}}]}]}]}","value_skipped":1,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"m.0","filter_group":null,"value_attribute":"resource_attributes.a","group_by":["attributes.toString",5]},{"id":"m1","metric_name":"x y","filter_group":null,"value_attribute":"duration_ms","group_by":["attributes.__proto__","body","service_name","service_name","attributes.🚀","attributes.payload"],"source":"spans"},{"id":"m2","metric_name":"m.2","filter_group":null,"value_attribute":"resource_attributes.a","group_by":"notarray"},{"id":"m3","metric_name":"","filter_group":{"type":"AND","values":[{"key":"payload","operator":"regex","value":"^$","type":"log_resource_attribute"}]},"value_attribute":"duration_ms","group_by":["status_code","resource_attributes.service.name","attributes.constructor"],"source":"spans"}],"defaults":"spans","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"8dbaae6075d53aa2dd458f2591be3630"},"span_id":{"$bytes":"83068123832ea0bd"},"trace_flags":null,"timestamp":1736942640028000,"observed_timestamp":1736944633250000,"body":" ","severity_text":"DEBUG","severity_number":5,"service_name":"web","resource_attributes":null,"instrumentation_scope":null,"event_name":"","attributes":{"level":"null","payload":"9007199254740994","duration_ms":"[1,2]"},"bytes_uncompressed":1469}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"","filter_group":null,"value_attribute":null,"group_by":["resource_attributes.service.name","service_name","body","attributes.payload",5,"service_name"]},{"id":"m1","metric_name":"count_all","filter_group":null,"value_attribute":"duration_ms","group_by":["status_code","status_code"]},{"id":"m2","metric_name":"posthog.log.records","filter_group":{"type":"AND","values":[{"type":"AND","values":[]}]},"value_attribute":"attributes.payload","group_by":["service_name","name","event_name","resource_attributes.k8s.pod.name"]}],"defaults":"logs","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":null,"span_id":{"$bytes":"a61e22efae2618f2"},"trace_flags":null,"timestamp":1736943269905000,"observed_timestamp":1736944633250000,"body":" Infinity [email protected] ","severity_text":"warning","severity_number":13,"service_name":null,"resource_attributes":{"1":"\"12\"","host":"true","constructor":"false","a":"false","service.name":"-Infinity","message":"\"\\\"NaN \\\"\""},"instrumentation_scope":null,"event_name":"","attributes":{},"bytes_uncompressed":1322}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"x y","filter_group":null,"value_attribute":"duration_ms","group_by":["attributes.1","attributes.toString"],"source":"logs"},{"id":"m1","metric_name":"x y","filter_group":null,"value_attribute":"attributes.valueOf","group_by":[5,"kind","service_name","attributes.ms","service_name","attributes.__proto__"]},{"id":"m2","metric_name":"m.2","filter_group":{"type":"AND","values":[{"type":"AND","values":[]}]},"value_attribute":null,"group_by":"notarray"}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"s0","trace_id":{"$bytes":"abe0fbaf833acc3b3460feb17587ec42"},"span_id":{"$bytes":"c5c6d01e297b3cde"},"timestamp":1736942678646000,"end_time":1736942678647000,"name":"","kind":2,"status_code":7,"service_name":null,"resource_attributes":{"a":"1"},"attributes":{"severity_text":"true","level":"\"ERROR\"","kind":"false","duration_ms":"\"Infinity\""}},{"uuid":"s1","trace_id":{"$bytes":"a02d62cc6da589343462268d6ee57c8f"},"span_id":{"$bytes":"a65b270d26f09077"},"timestamp":1736942714868000,"end_time":1736942714868000,"name":"db.query","kind":null,"status_code":0,"service_name":"api","resource_attributes":{"service.name":".5"},"attributes":{"a":"\"5.\"","message":"\" \"","level":"\"é\"","http.path":"0 [1,2]ghp_0123456789abcdefghij0123456789abcdef","🚀":"[1.7976931348623157e+308,\"ERROR\",{\"10\":{\"5\":46846.10380791128},\"a.\":null,\"🚀\":\"nullERROR\"},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","service.name":"1,5","ms":"++7","duration_ms":"-.5e-2","payload":".5"}},{"uuid":"s2","trace_id":{"$bytes":"53e2e5669e9140777e756ae7682aaac3"},"span_id":null,"timestamp":1736944578265000,"end_time":1736944578266500,"name":"GET /a","kind":4,"status_code":3,"service_name":"worker","resource_attributes":{"12 ":"\"null\"","service.name":"1e+100","a":"true"},"attributes":{"status_code":"true","http.server.duration_ms":"0","k":"9007199254740992","count":"\"1\""}}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"","filter_group":null,"value_attribute":null,"group_by":["service_name","event_name","service_name","resource_attributes.service.name"]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"e4e5754791eec919"},"span_id":{"$bytes":"b7023dce689d55f2"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":null,"severity_text":"DEBUG","severity_number":13,"service_name":"API","resource_attributes":{"constructor":"\"\\\\\"","host":"🚀","user.email":"Infinity","k8s.pod.name":"\"error\"","service.name":"12\\1,5 "},"instrumentation_scope":null,"event_name":"request","attributes":{"4294967294":"\"00\"","http.route":"\"2001:db8::1\"","user.email":" ","01":" 12 ","count":"1_0","duration_ms":"\"00012\"","payload":"0b1"},"bytes_uncompressed":null}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"count_all","filter_group":{"type":"AND","values":[]},"value_attribute":"attributes.payload","group_by":["attributes.level","attributes.","resource_attributes.service.name","resource_attributes.k8s.pod.name","attributes.🚀"]},{"id":"m1","metric_name":"m.1","filter_group":null,"value_attribute":"attributes.count","group_by":["attributes.constructor","name","status_code"],"source":"spans"},{"id":"m2","metric_name":"count_all","filter_group":{"type":"AND","values":[null]},"value_attribute":"attributes.valueOf","group_by":["resource_attributes.k8s.pod.name","resource_attributes.service.name","attributes.","name","severity_text","event_name"],"source":"other"}],"defaults":"spans","now_ms":1736944633250,"records":[]},"output":{"compile_error":"TypeError: Cannot read properties of null (reading 'values')"}},{"input":{"rules":[{"id":"m0","metric_name":"m.0","filter_group":null,"value_attribute":null,"group_by":["body","attributes.ms",5,"attributes.payload","body","body"]},{"id":"m1","metric_name":"x y","filter_group":{"type":"AND","values":[{"type":"AND","values":[]}]},"value_attribute":"attributes.valueOf","group_by":["event_name"],"source":"logs"},{"id":"m2","metric_name":"count_all","filter_group":null,"value_attribute":"duration_ms","group_by":["event_name","resource_attributes.service.name"],"source":"spans"}],"defaults":"logs","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"40f584daeb6b36ee"},"span_id":{"$bytes":"261c8abc357997aa"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"0.1 ","severity_text":"Warn","severity_number":1,"service_name":"web","resource_attributes":{"host":"\"$-1e400 ࣝ\"","constructor":"[[{\"2\":{\"1e3\":-1,\" \":\"1,5\\\"\"},\"3\":true,\"toString\":null}],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","k8s.pod.name":"[123456789012345680000,{\"2\":true,\"4294967294\":{\"\\n\":{\"1\":1}},\"level\":false},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","deadbeef":"\"2025-01-15T10:00:00Z\""},"instrumentation_scope":null,"event_name":"request","attributes":{"name":"0","..":"false","url.path":"\"[]\"","hasOwnProperty":"9007199254740992","é":"\"0\"","duration_ms":"1e+100","ms":"-0"},"bytes_uncompressed":399}]},"output":{"payload_json":"{\"resourceMetrics\":[{\"resource\":{\"attributes\":[{\"key\":\"service.name\",\"value\":{\"stringValue\":\"web\"}}]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"posthog.log.records\",\"sum\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"Warn\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1}],\"aggregationTemporality\":1,\"isMonotonic\":true}}]}]}]}","value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"m.0","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[{"key":"a","operator":"in","value":4294967294,"type":"log_resource_attribute"}]}]}]},{"key":"k8s.pod.name","operator":"icontains","value":null,"type":"span_attribute"}]}]},"value_attribute":"attributes.ms","group_by":[]},{"id":"m1","metric_name":"posthog.log.records","filter_group":{"type":"AND","values":[{"key":"1","operator":"not_starts_with","value":"INFO","type":"log_resource_attribute"},{"key":"toString","operator":"is_not_set","value":{"toString":1},"type":"log_resource_attribute"}]},"value_attribute":"ms","group_by":["attributes.","attributes.http.method"]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"s0","trace_id":{"$bytes":"011959fc80e9d415ba67d2699b29481b"},"span_id":{"$bytes":"e644486205463424"},"timestamp":1736942297037000,"end_time":1736942297037999,"name":"","kind":5,"status_code":3,"service_name":"worker","resource_attributes":{"4294967294":"1","a":"1e-7","service.name":"\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\""},"attributes":{"1":"192.168.1.1","payload.0":"\"null\"","🚀":"1e3","toString":"\"\\\"quoted\\\"\"","__defineGetter__":"\"ghp_0123456789abcdefghij0123456789abcdef\"","k8s.pod.name":"\"[email protected] ","k":"\"Wed, 15 Jan 2025 12:00:00 GMT\""}},{"uuid":"s1","trace_id":{"$bytes":"256c258191bb990bd1c3a02d767a8827"},"span_id":{"$bytes":"54b62206556c6c9b"},"timestamp":1736944443259000,"end_time":1736944443260500,"name":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","kind":4,"status_code":0,"service_name":"api","resource_attributes":{"service.name":"1e+21","a":"\"00\"","k8s.pod.name":"0"},"attributes":null}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"posthog.log.records","filter_group":null,"value_attribute":"attributes.duration_ms","group_by":["status_code","attributes.http.method","attributes.🚀","attributes.🚀"]}],"defaults":"spans","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"566cd15f7f57dac2ace470091315d269"},"span_id":{"$bytes":"841300fee9aee5c6"},"trace_flags":null,"timestamp":1736942861172000,"observed_timestamp":1736944633250000,"body":null,"severity_text":"DEBUG","severity_number":21,"service_name":"API","resource_attributes":{"k8s.pod.name":"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123","service.name":"\\"},"instrumentation_scope":null,"event_name":"request","attributes":{"ms":"++7","duration_ms":"1e+100"},"bytes_uncompressed":1049},{"uuid":"u1","trace_id":{"$bytes":"1b4c63dbdec54b06"},"span_id":{"$bytes":"e9c8656b017198a0"},"trace_flags":null,"timestamp":1736943520127000,"observed_timestamp":1736944633250000,"body":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx120.30000000000000004","severity_text":"INFO","severity_number":9,"service_name":"api","resource_attributes":{"1":"false","k8s.pod.name":"\"[email protected]\"","host":"\"0\"","service.name":"\"warn\""},"instrumentation_scope":null,"event_name":"","attributes":{"k":"9007199254740994","status_code":"\"\\\"🚀\\\\\\\"quoted\\\\\\\"\\\"\"","payload.0":"\"1e400\"","a":"\"{\\\"0\\\":[],\\\"3\\\":false,\\\"\\\\t\\\":true,\\\"12 \\\":{\\\"51\\\":[445358806755393700],\\\"length\\\":null}}\"","count":"[1,2]","ms":"12.5","duration_ms":"0x10","http.method":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\""},"bytes_uncompressed":1508}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"posthog.log.records","filter_group":null,"value_attribute":"ms","group_by":["attributes.constructor"],"source":"spans"},{"id":"m1","metric_name":"count_all","filter_group":{"type":"OR","values":[{"type":"AND","values":[{"type":"OR","values":[{"key":"__proto__","operator":"not_in","value":[1e+21,1,true],"type":"span_attribute"}]}]}]},"value_attribute":"resource_attributes.a","group_by":["resource_attributes.service.name","kind","resource_attributes.k8s.pod.name",5,"severity_text","service_name"]},{"id":"m2","metric_name":"x y","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"status_code","operator":"is_not_set","value":-9007199254740992,"type":"log_resource_attribute"}]}]},"value_attribute":"duration_ms","group_by":[],"source":"logs"}],"defaults":"logs","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"3fe71a0da33913c1c27ef3adb1ec050e"},"span_id":{"$bytes":"e9023ac8ed9da26b"},"trace_flags":null,"timestamp":1736943282058000,"observed_timestamp":1736944633250000,"body":"-0 \u000b Infinity","severity_text":null,"severity_number":0,"service_name":"web","resource_attributes":{},"instrumentation_scope":null,"event_name":"request","attributes":{"ms":" 12","duration_ms":"\".5\"","payload":"\" 12 \""},"bytes_uncompressed":1474}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"m.0","filter_group":null,"value_attribute":"attributes.payload","group_by":["attributes.__proto__","","severity_text","attributes.constructor","attributes.1"]},{"id":"m1","metric_name":"count_all","filter_group":{"type":"OR","values":[{"key":"count","operator":"lt","value":true,"type":"span_resource_attribute"},{"key":"http.method","operator":"is_not","value":"0x10","type":"span_resource_attribute"},{"key":null,"operator":"is_set","value":{"a":1},"type":"log_resource_attribute"}]},"value_attribute":"duration_ms","group_by":"notarray","source":"logs"},{"id":"m2","metric_name":"posthog.log.records","filter_group":null,"value_attribute":"attributes.payload","group_by":["attributes.ms","resource_attributes.service.name","body"],"source":"logs"}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"2dcc8eb29148f16722872296ae95694f"},"span_id":null,"trace_flags":null,"timestamp":1736942492278000,"observed_timestamp":1736944633250000,"body":"\\ a__proto__","severity_text":"warning","severity_number":13,"service_name":"API","resource_attributes":{" 1e+21":"\""},"instrumentation_scope":null,"event_name":"request","attributes":{"🚀":"1","01":"00","__defineGetter__":"\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"","payload.x":"\"\"","toString":"\\","ms":"e5","duration_ms":"[1,2]"},"bytes_uncompressed":1173},{"uuid":"u1","trace_id":{"$bytes":"7da15f0012201fa1"},"span_id":{"$bytes":"589e00907735582b"},"trace_flags":null,"timestamp":1736943515496000,"observed_timestamp":1736944633250000,"body":"002025-01-15T10:00:00Z ","severity_text":"trace","severity_number":0,"service_name":"API","resource_attributes":{"service.name":"Ү ","k8s.pod.name":"true","a":"\" \""},"instrumentation_scope":null,"event_name":null,"attributes":{"http.status_code":"\"12\"","http.route":"4294967295","service.name":"\"12\"","payload.0":"\"null\"","ms":"[1,2]","count":"\"NaN\""},"bytes_uncompressed":null}]},"output":{"payload_json":null,"value_skipped":1,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"","filter_group":null,"value_attribute":null,"group_by":[5,"attributes.ms","resource_attributes.service.name","attributes.constructor","attributes.ms"],"source":"spans"}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"s0","trace_id":{"$bytes":"2dfa86518affa88251ff065458f992ba"},"span_id":null,"timestamp":1736943158167000,"end_time":null,"name":"","kind":2,"status_code":1,"service_name":"worker","resource_attributes":{"a":"\"12\"","service.name":"100"},"attributes":{"1":"INFO","kind":"false","ms":"[1,2]","http.route":"1e-7","duration_ms":"\"{\\\"a\\\":1}\""}},{"uuid":"s1","trace_id":{"$bytes":"8d2e31d2a6f869e88721fc1e6e600a20"},"span_id":{"$bytes":"c252d28e778802ae"},"timestamp":1736943524320000,"end_time":1736943524320999,"name":"","kind":1,"status_code":1,"service_name":"worker","resource_attributes":{"b":"Infinity","service.name":"1.7976931348623157e+308","a":"5e-324"},"attributes":null},{"uuid":"s2","trace_id":{"$bytes":"d536e2e6284f235aab39051c003ddc21"},"span_id":{"$bytes":"30dab85d49252bd6"},"timestamp":1736943659867000,"end_time":1736943659867001,"name":null,"kind":1,"status_code":0,"service_name":"api","resource_attributes":{},"attributes":{"valueOf":"\" \"","service.name":"\"NaN\"","k8s.pod.name":"false","ms":"\"-0\"","duration_ms":"[1,2]"}}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"posthog.log.records","filter_group":null,"value_attribute":"resource_attributes.a","group_by":["attributes.🚀","attributes.payload","event_name"],"source":"logs"},{"id":"m1","metric_name":"x y","filter_group":null,"value_attribute":"duration_ms","group_by":["name","severity_text","body","attributes.1","attributes.http.method","attributes."]},{"id":"m2","metric_name":"m.2","filter_group":{"type":"AND","values":[null]},"value_attribute":null,"group_by":["attributes.__proto__","resource_attributes.k8s.pod.name","attributes.level","body"],"source":"spans"},{"id":"m3","metric_name":"m.3","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"k8s.pod.name","operator":"lte","value":{},"type":"event"},{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"key":true,"operator":"exact","value":["api",true]}]}]}]}]}]}]},"value_attribute":"resource_attributes.a","group_by":[]}],"defaults":"spans","now_ms":1736944633250,"records":[]},"output":{"compile_error":"TypeError: Cannot read properties of null (reading 'values')"}},{"input":{"rules":[{"id":"m0","metric_name":"count_all","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[{"key":"service_name","operator":"lte","value":"false","type":"log"},{"key":"http.method","operator":"not_in","value":[true,"GET",1],"type":"log_resource_attribute"}]}]}]},"value_attribute":null,"group_by":["name"]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":null,"span_id":{"$bytes":"8a7672dce9208ea5"},"trace_flags":null,"timestamp":1736943096181000,"observed_timestamp":1736944633250000,"body":".5 ","severity_text":"DEBUG","severity_number":null,"service_name":"web","resource_attributes":null,"instrumentation_scope":null,"event_name":"","attributes":{"a.b":"\"NaN\"","http.status_code":"\"-4.0737691544927656e-7\"","ms":"Wed, 15 Jan 2025 12:00:00 GMTb ","level":"warn","count":"\"1e400\"","payload":"10000"},"bytes_uncompressed":1299}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"x y","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"http.method","operator":"ends_with","value":[true,"GET",["n"]],"type":"log"}]}]},"value_attribute":"ms","group_by":["attributes.payload","attributes.ms","","attributes.http.method","attributes.level"]},{"id":"m1","metric_name":"","filter_group":null,"value_attribute":"attributes.valueOf","group_by":["event_name"]},{"id":"m2","metric_name":"m.2","filter_group":{"type":"AND","values":[{"type":"AND","values":[null]},{"key":"http.method","operator":"lte","type":"event"},{"type":"AND","values":[{"type":"OR","values":[{"type":"OR","values":[{"key":"level","operator":"bogus","value":"GET","type":"span_resource_attribute"},{"type":"AND","values":[{"type":"AND","values":[{"key":"message","operator":"not_regex","value":"\\Qa.b\\E","type":"span_attribute"}]}]}]},{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"key":"service.name","operator":"not_regex","value":true,"type":"log_resource_attribute"}]},{"key":"constructor","operator":"not_in","value":[1,null,"api"],"type":"span_attribute"},{"type":"AND","values":[{"type":"OR","values":[{"key":"toString","operator":"not_icontains","value":"-Infinity","type":"span_resource_attribute"},{"key":"1","operator":"not_icontains","value":["x",{"toString":1}],"type":"log"}]}]}]}]}]}]}]},"value_attribute":"resource_attributes.a","group_by":["","resource_attributes.k8s.pod.name","attributes.payload","event_name","attributes.http.method","kind"],"source":"spans"}],"defaults":null,"now_ms":1736944633250,"records":[]},"output":{"compile_error":"TypeError: Cannot read properties of null (reading 'values')"}},{"input":{"rules":[{"id":"m0","metric_name":"count_all","filter_group":null,"value_attribute":"resource_attributes.a","group_by":["name","status_code","attributes.http.method","attributes.toString"]},{"id":"m1","metric_name":"posthog.log.records","filter_group":null,"value_attribute":null,"group_by":["kind"],"source":"logs"}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"s0","trace_id":{"$bytes":"2aa192fad1f29e95f0a3649b69b5be5f"},"span_id":{"$bytes":"92d704c7e7d6badd"},"timestamp":1736943594813000,"end_time":1736943594813999,"name":"","kind":null,"status_code":-1,"service_name":null,"resource_attributes":{"k8s.pod.name":"Infinity","a":"0","service.name":"false"},"attributes":null},{"uuid":"s1","trace_id":{"$bytes":"348a0155dcd20363fe927c5245d8d264"},"span_id":null,"timestamp":1736942585922000,"end_time":1736942585923500,"name":"","kind":null,"status_code":null,"service_name":null,"resource_attributes":{"http.method":"\"0\"","k8s.pod.name":"-1"},"attributes":{"__defineGetter__":"0","":"123456789012345680000","payload.x":"\"\\\"12.54294967296NaN \\\"\"","http.method":"false","count":"9007199254740994","duration_ms":"\"00012\"","payload":"\"1e3\""}}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"posthog.log.records","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"severity_level","operator":"not_in","value":["x",["n"],1],"type":"span_resource_attribute"},{"key":"constructor","operator":"exact","value":[],"type":"log"},{"type":"AND","values":[{"type":"OR","values":[{"key":"ms","operator":"is_set","value":"0"},{"key":"service_name","operator":"not_icontains","value":"\\","type":"event"},{"type":"OR","values":[{"key":"severity_level","operator":"in","value":1.5,"type":"span_resource_attribute"},{"type":"AND","values":[{"type":"AND","values":[{"key":"constructor","operator":"gt","value":[true,"GET"],"type":"log_attribute"},{"key":"a","operator":"not_icontains","value":1.7976931348623157e+308,"type":"log_attribute"}]}]},{"type":"OR","values":[{"key":true,"value":12.5,"type":"log_resource_attribute"},{"key":5,"operator":"not_in","value":["GET",1e+21,"true"],"type":"log_attribute"}]}]}]}]}]}]},"value_attribute":"attributes.ms","group_by":["resource_attributes.k8s.pod.name","resource_attributes.service.name","attributes.constructor","attributes.__proto__","resource_attributes.k8s.pod.name"],"source":"logs"},{"id":"m1","metric_name":"m.1","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"level","operator":"is_not_set","value":[]},{"type":"AND","values":[{"type":"AND","values":[null]}]}]}]},"value_attribute":"attributes.count","group_by":["attributes.constructor","attributes.level"]},{"id":"m2","metric_name":"","filter_group":null,"value_attribute":"resource_attributes.a","group_by":["attributes.http.method","attributes.http.method","attributes.level","status_code"],"source":"other"},{"id":"m3","metric_name":"x y","filter_group":{"type":"OR","values":[{"key":"service.name","value":["true",1],"type":"span_resource_attribute"}]},"value_attribute":"attributes.payload","group_by":["service_name","","attributes.payload"]}],"defaults":null,"now_ms":1736944633250,"records":[]},"output":{"compile_error":"TypeError: Cannot read properties of null (reading 'values')"}},{"input":{"rules":[{"id":"m0","metric_name":"m.0","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[{"type":"AND","values":[{"key":"level","operator":"not_ends_with","value":"True","type":"log_attribute"}]}]},{"key":"service_name","value":"1e3","type":"log"}]}]},"value_attribute":"attributes.valueOf","group_by":["attributes.http.method","attributes.toString","status_code"]},{"id":"m1","metric_name":"x y","filter_group":null,"value_attribute":"attributes.ms","group_by":["attributes.payload","status_code","body",5,"attributes.",""],"source":"spans"},{"id":"m2","metric_name":"","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"url.path","operator":"icontains","value":["GET"],"type":"span_attribute"},{"key":"http.method","operator":"is_not_set","value":1e+21},{"key":"service.name","operator":"ends_with","value":"σ","type":"span_resource_attribute"}]}]},"value_attribute":null,"group_by":["name","attributes.payload","kind"]}],"defaults":"logs","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"504bbab056ae9ab93fbca39baf6db597"},"span_id":{"$bytes":"36dfebfef813c256"},"trace_flags":null,"timestamp":1736943038215000,"observed_timestamp":1736944633250000,"body":"/api/v1/users/123","severity_text":"trace","severity_number":1,"service_name":"worker","resource_attributes":{"service.name":"\"Infinity\\\" \"","b ":"\"sk_live_0123456789abcdefghijkl\"","k8s.pod.name":"\"error\"","constructor":"4294967295","message":"Infinity"},"instrumentation_scope":null,"event_name":null,"attributes":{"http.status_code":"1.5","count":"2001:db8::1 12 ","service.name":"1e+100","ms":"12.5","payload":"1.7976931348623157e+308","http.method":"\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\""},"bytes_uncompressed":325}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"m.0","filter_group":null,"value_attribute":"ms","group_by":[]},{"id":"m1","metric_name":"","filter_group":null,"value_attribute":"attributes.payload","group_by":["event_name","attributes.payload","attributes.__proto__","attributes.payload","attributes.","attributes.http.method"]},{"id":"m2","metric_name":"","filter_group":{"type":"OR","values":[{"type":"AND","values":[{"type":"OR","values":[]},{"key":"severity_level","operator":"in","value":["x"],"type":"span_attribute"},{"key":"missing","operator":"not_ends_with","value":["x","GET"]}]},{"key":"service.name","operator":"icontains","value":[1,"x"],"type":"span_resource_attribute"},{"key":"payload","operator":"lt","value":"false","type":"log_resource_attribute"}]},"value_attribute":"resource_attributes.a","group_by":["body","attributes.ms","status_code","kind"]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"86709e549e9e8318fa308414d4abae57"},"span_id":null,"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"error","severity_text":"Warn","severity_number":9,"service_name":"worker","resource_attributes":{},"instrumentation_scope":null,"event_name":null,"attributes":{"1.5":"1.5","duration_ms":"e5","constructor":"7","hasOwnProperty":"null","ms":"\" 12\"","count":" 12","payload":"0"},"bytes_uncompressed":1967}]},"output":{"payload_json":null,"value_skipped":1,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"posthog.log.records","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"status_code","operator":"icontains","type":"span_resource_attribute"},{"key":"level","operator":"lte","value":9007199254740994,"type":"span_attribute"}]}]},"value_attribute":"attributes.duration_ms","group_by":["attributes."]},{"id":"m1","metric_name":"posthog.log.records","filter_group":{"type":"OR","values":[{"key":"__proto__","operator":"lte","type":"span_attribute"},{"key":"service.name","operator":"exact","value":"Wed, 15 Jan 2025 12:00:00 GMT","type":"span_attribute"}]},"value_attribute":null,"group_by":["severity_text","event_name","attributes.",""]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":null,"span_id":{"$bytes":"5722e46d7354f906"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":" 0o7ghp_0123456789abcdefghij0123456789abcdef ","severity_text":"INFO","severity_number":17,"service_name":"api","resource_attributes":{"1":"\"\\\"0b11\\\"\"","a":"12","constructor":"\"[\\\"-1e400 \\\",false,{\\\"2\\\":null,\\\"49\\\":{\\\"\\\\\\\"\\\":0.30000000000000004},\\\"hasOwnProperty\\\":9007199254740994},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\"","service.name":"1e-7"},"instrumentation_scope":null,"event_name":"request","attributes":{"http.status_code":"false","ms":"[1,2]","count":"12.5","payload":"1.7976931348623157e+308"},"bytes_uncompressed":151}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"","filter_group":null,"value_attribute":"attributes.valueOf","group_by":["resource_attributes.service.name","name","","attributes.toString"]}],"defaults":"spans","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":""},"span_id":{"$bytes":"f00e28d162dd743e"},"trace_flags":null,"timestamp":1736943811677000,"observed_timestamp":1736944633250000,"body":null,"severity_text":"INFO","severity_number":13,"service_name":"","resource_attributes":{"1":"0.30000000000000004","host":"\"{\\\"9\\\":4294967295,\\\"\\\\\\\"\\\":-33.4847962949425,\\\"..\\\":{\\\"é\\\":\\\"999.9999999b-Infinity\\\",\\\"length\\\":\\\"5.\\\\r\\\\n 2001:db8::1\\\",\\\"4294967296\\\":\\\"fatal\\\"}}\"","a":"\"debug\""},"instrumentation_scope":null,"event_name":null,"attributes":{"0":"0b11","name":"\"\\u000b\"","ms":"[\"촅 \",\"K eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 \",{},null,false,null,\"1.5 \",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","sk_live_0123456789abcdefghijkl л ":"\"2001:db8::1\"","é":"\"12.5abc\"","duration_ms":"3"},"bytes_uncompressed":null},{"uuid":"u1","trace_id":{"$bytes":"2a767ef115704f3ff8b45b25af27e294"},"span_id":{"$bytes":"5855a8ffcad960c1"},"trace_flags":null,"timestamp":1736944559011000,"observed_timestamp":1736944633250000,"body":"warn1e+100Ʉ 0o7","severity_text":"","severity_number":5,"service_name":"worker","resource_attributes":{"1":"[{\"49\":{\"5\":null,\"100\":{\"-1null\":1e+21},\"host.example.com\":\"0x10hasOwnProperty192.168.1.1\"},\"__defineGetter__\":-5.036121373996138e-9},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]","4294967294":"\"quoted\"","host":"\"GET\"","service.name":"\"{\\\"a\\\":1}\"","k8s.pod.name":"2a\\nb"},"instrumentation_scope":null,"event_name":"request","attributes":{"1":"9007199254740994","":"0.1","__defineGetter__":"1e3","count":"7500"},"bytes_uncompressed":1299}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"m.0","filter_group":{"type":"AND","values":[null]},"value_attribute":"ms","group_by":["status_code"]},{"id":"m1","metric_name":"x y","filter_group":null,"value_attribute":"ms","group_by":["attributes.payload"]},{"id":"m2","metric_name":"x y","filter_group":null,"value_attribute":"duration_ms","group_by":["status_code","body",5,"attributes.level","attributes.🚀"]}],"defaults":null,"now_ms":1736944633250,"records":[]},"output":{"compile_error":"TypeError: Cannot read properties of null (reading 'values')"}},{"input":{"rules":[{"id":"m0","metric_name":"m.0","filter_group":null,"value_attribute":"attributes.count","group_by":["name","attributes.payload","attributes.ms"]},{"id":"m1","metric_name":"","filter_group":{"type":"AND","values":[{"type":"AND","values":[]}]},"value_attribute":null,"group_by":["service_name","","attributes.🚀","service_name","attributes.payload"]}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"s0","trace_id":{"$bytes":"3769efc84b09c0f574f98ae8023dd86a"},"span_id":null,"timestamp":1736942836800000,"end_time":1736942836800001,"name":null,"kind":0,"status_code":1,"service_name":"worker","resource_attributes":{"k8s.pod.name":"\\","a":"-1"},"attributes":{"01":"\"1e3\"","a.b":"\"true\"","name":"\"12.5abc\"","http.response.status_code":"123456789012345680000","4294967296":"\"a\\\\nb\"","payload.x":"\" \"","http.server.duration_ms":"\"error\"","duration_ms":"\"1e-400\""}},{"uuid":"s1","trace_id":{"$bytes":"b2447c67d3c676cffaaa367a01c29492"},"span_id":null,"timestamp":1736943946792000,"end_time":1736943954042125,"name":"GET /a","kind":-1,"status_code":0,"service_name":"api","resource_attributes":{"service.name":"warn","length":"1e+100","偿":"0.000001"},"attributes":{"1":"\"\\\"quoted\\\"\"","a.b":"0.1","🚀":"0o7 ","name":"\"a\\\\nb\"","count":"-5","duration_ms":"-Infinity","payload":"-5","http.method":"\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa🚀\""}},{"uuid":"s2","trace_id":{"$bytes":"d234ac226e483ffdba3803b9269a488f"},"span_id":{"$bytes":"64bc0ff2ea9816ab"},"timestamp":1736944582390000,"end_time":1736944582391500,"name":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","kind":null,"status_code":3,"service_name":"worker","resource_attributes":null,"attributes":{"payload":"1_0"}}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[]}]}]},{"key":"service_name","operator":"exact","value":"True","type":"event"},{"key":"constructor","operator":"is_set","value":"true","type":"log_resource_attribute"}]},"value_attribute":"attributes.duration_ms","group_by":[5,"resource_attributes.service.name","resource_attributes.k8s.pod.name","body","attributes.🚀","status_code"]},{"id":"m1","metric_name":"count_all","filter_group":{"type":"AND","values":[{"type":"AND","values":[]}]},"value_attribute":"ms","group_by":["attributes.__proto__","attributes.http.method","kind"]},{"id":"m2","metric_name":"posthog.log.records","filter_group":null,"value_attribute":"attributes.payload","group_by":["service_name",5]},{"id":"m3","metric_name":"count_all","filter_group":null,"value_attribute":null,"group_by":["attributes.http.method"],"source":"other"}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":""},"span_id":null,"trace_flags":null,"timestamp":1736943347543000,"observed_timestamp":1736944633250000,"body":"é 1_000","severity_text":"İnfo","severity_number":null,"service_name":"worker","resource_attributes":{},"instrumentation_scope":null,"event_name":"","attributes":{"0":"\"ghp_0123456789abcdefghij0123456789abcdef\"","1":"\"[1,2]\"","hasOwnProperty":"1e+100","http.path":"\"-0\"","ms":"[1,2]","duration_ms":"-1","payload":"\"1e+\""},"bytes_uncompressed":1053}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":"x"},{"key":null,"operator":"not_regex","value":"(?i)error","type":"span_resource_attribute"}]}]},"value_attribute":"resource_attributes.a","group_by":["attributes.payload","attributes.http.method","attributes.ms"]},{"id":"m1","metric_name":"count_all","filter_group":null,"value_attribute":null,"group_by":"notarray","source":"spans"},{"id":"m2","metric_name":"","filter_group":{"type":"AND","values":[]},"value_attribute":null,"group_by":["body","resource_attributes.k8s.pod.name","attributes.1",5,"attributes.__proto__","kind"],"source":"logs"}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"4f9a0e1225543478941bf49b5ce27a9f"},"span_id":{"$bytes":"a20cc3dd42ea7f6a"},"trace_flags":null,"timestamp":1736944163702000,"observed_timestamp":1736944633250000,"body":"\r\nlevelNaN","severity_text":"INFO","severity_number":-1,"service_name":"worker","resource_attributes":{},"instrumentation_scope":null,"event_name":null,"attributes":{},"bytes_uncompressed":445}]},"output":{"payload_json":"{\"resourceMetrics\":[{\"resource\":{\"attributes\":[]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"count_all\",\"sum\":{\"dataPoints\":[{\"attributes\":[],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1,\"traceId\":\"4f9a0e1225543478941bf49b5ce27a9f\",\"spanId\":\"a20cc3dd42ea7f6a\"}],\"asDouble\":1}],\"aggregationTemporality\":1,\"isMonotonic\":true}}]}]}]}","value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"m.0","filter_group":null,"value_attribute":"duration_ms","group_by":["attributes.toString","resource_attributes.service.name"]},{"id":"m1","metric_name":"","filter_group":null,"value_attribute":null,"group_by":"notarray"},{"id":"m2","metric_name":"count_all","filter_group":null,"value_attribute":"ms","group_by":["resource_attributes.service.name"]},{"id":"m3","metric_name":"m.3","filter_group":{"type":"AND","values":[{"key":"http.method","operator":"lt","value":"-1e400","type":"log"},{"key":"name","operator":"in","value":[],"type":"log_resource_attribute"}]},"value_attribute":"ms","group_by":["attributes.payload","attributes.toString","attributes."],"source":"spans"}],"defaults":"logs","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":null,"span_id":null,"trace_flags":null,"timestamp":1736942762149000,"observed_timestamp":1736944633250000,"body":".5 POST�192.168.1.11,5 ","severity_text":"","severity_number":9,"service_name":"API","resource_attributes":{"1":"\"\\\"full 12 fatal\\\"\"","k8s.pod.name":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"","host":"\"1e400\"","service.name":"0x10","a":"\"1_000\""},"instrumentation_scope":null,"event_name":"request","attributes":{"ms":"[1,2]","count":"[1,2]","payload":"[1,2]"},"bytes_uncompressed":1526}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"m.0","filter_group":null,"value_attribute":null,"group_by":[],"source":"logs"},{"id":"m1","metric_name":"count_all","filter_group":{"type":"AND","values":[null]},"value_attribute":null,"group_by":"notarray"}],"defaults":"spans","now_ms":1736944633250,"records":[]},"output":{"compile_error":"TypeError: Cannot read properties of null (reading 'values')"}},{"input":{"rules":[{"id":"m0","metric_name":"","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[]}]},{"key":"constructor","operator":"ends_with","value":999.9999999,"type":"log_attribute"},{"key":"status_code","operator":"not_in","value":[true,"x"],"type":"span_resource_attribute"}]}]}]}]}]},"value_attribute":"attributes.valueOf","group_by":["attributes.http.method","attributes.http.method"],"source":"logs"},{"id":"m1","metric_name":"","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"1","operator":"not_icontains","value":"1e400"}]}]},"value_attribute":null,"group_by":["event_name"]}],"defaults":"spans","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":null,"span_id":{"$bytes":"27505fb21ec3f3c7"},"trace_flags":null,"timestamp":1736943741708000,"observed_timestamp":1736944633250000,"body":"1_000AKIAIOSFODNN7EXAMPLElength 12 ","severity_text":"ERROR","severity_number":-1,"service_name":"api","resource_attributes":{"4294967294":"constructor ","host":"12","k8s.pod.name":"4294967294","constructor":"null","a":"\"3fa85f64-5717-4562-b3fc-2c963f66afa6\""," éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé ":"12.5"},"instrumentation_scope":null,"event_name":null,"attributes":{"http.path":"null","":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"","count":"\"5.\"","duration_ms":"++7"},"bytes_uncompressed":77}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"posthog.log.records","filter_group":{"type":"AND","values":[{"key":"toString","value":[["n"]],"type":"log_attribute"},{"key":"url.path","operator":"in","value":"{\"a\":1}","type":"log"},{"type":"OR","values":[{"key":"kind","operator":"bogus","value":"1_000","type":"event"},{"key":"count","operator":"in","value":["x",null],"type":"log"}]}]},"value_attribute":"attributes.count","group_by":["body"],"source":"spans"}],"defaults":null,"now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"6ceac74a64baaa784deb6d49e30bd44a"},"span_id":{"$bytes":"59f906d834ddd900"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"","severity_text":"WARN","severity_number":1,"service_name":"","resource_attributes":{"a":"\"/api/v1/users/123\"","é":"\"\\\" \\\"\"","k8s.pod.name":"a 1.5","host":"🚀 7"},"instrumentation_scope":null,"event_name":null,"attributes":null,"bytes_uncompressed":457}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"x y","filter_group":null,"value_attribute":"attributes.valueOf","group_by":[]},{"id":"m1","metric_name":"m.1","filter_group":null,"value_attribute":"ms","group_by":["attributes.payload","attributes.level"],"source":"logs"},{"id":"m2","metric_name":"","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"name","operator":"is_set","value":{"toString":1},"type":"span_attribute"}]}]},"value_attribute":"resource_attributes.a","group_by":[5,"attributes.1","attributes.http.method","kind",""],"source":"logs"},{"id":"m3","metric_name":"x y","filter_group":{"type":"OR","values":[]},"value_attribute":"attributes.ms","group_by":["status_code","attributes.level","attributes.","event_name","service_name","body"],"source":"logs"}],"defaults":"spans","now_ms":1736944633250,"records":[{"uuid":"s0","trace_id":null,"span_id":null,"timestamp":1736943597966000,"end_time":1736944580083131,"name":"GET /a","kind":9,"status_code":0,"service_name":"worker","resource_attributes":{},"attributes":{"4294967294":"4294967294","constructor":" ","":"\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\""," ":"日本語","payload":"\"e5\"","k":"\" 12\"","payload.0":"\"sk_live_0123456789abcdefghijkl\""}}]},"output":{"payload_json":"{\"resourceMetrics\":[{\"resource\":{\"attributes\":[{\"key\":\"service.name\",\"value\":{\"stringValue\":\"worker\"}}]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"posthog.span.duration\",\"unit\":\"ms\",\"histogram\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"9\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"GET /a\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"UNSET\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"count\":1,\"sum\":982117.131,\"bucketCounts\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]}],\"aggregationTemporality\":1}}]}]}]}","value_skipped":2,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"posthog.log.records","filter_group":{"type":"AND","values":[{"key":null,"operator":"bogus","value":0.1,"type":"log_resource_attribute"},{"type":"OR","values":[{"type":"AND","values":[{"type":"OR","values":[]}]},{"key":"__proto__","operator":"gte","value":2.5e-8,"type":"log"},null]},{"key":"count","value":1e+21,"type":"span_attribute"}]},"value_attribute":"duration_ms","group_by":[]},{"id":"m1","metric_name":"","filter_group":null,"value_attribute":"resource_attributes.a","group_by":[],"source":"logs"},{"id":"m2","metric_name":"","filter_group":{"type":"AND","values":[]},"value_attribute":"duration_ms","group_by":["attributes.1","body","severity_text","attributes.constructor","attributes.http.method"]},{"id":"m3","metric_name":"m.3","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[{"type":"OR","values":[]}]},{"key":"__proto__","operator":"starts_with","value":"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123","type":"span_resource_attribute"},{"key":"http.method","operator":"is_set","value":"[email protected]","type":"log_resource_attribute"}]}]},"value_attribute":"attributes.valueOf","group_by":"notarray"}],"defaults":"spans","now_ms":1736944633250,"records":[]},"output":{"compile_error":"TypeError: Cannot read properties of null (reading 'values')"}},{"input":{"rules":[{"id":"m0","metric_name":"","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"__proto__","operator":"not_ends_with","value":{"toString":1},"type":"event"},{"key":"http.method","operator":"not_regex","value":"GET|POST","type":"log"}]}]},"value_attribute":null,"group_by":[],"source":"spans"},{"id":"m1","metric_name":"posthog.log.records","filter_group":null,"value_attribute":"attributes.valueOf","group_by":["event_name"]},{"id":"m2","metric_name":"","filter_group":null,"value_attribute":"attributes.duration_ms","group_by":["attributes.toString"]}],"defaults":"spans","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"14643766e6fa6d14f30ed83cdb85817d"},"span_id":null,"trace_flags":null,"timestamp":1736942734050000,"observed_timestamp":1736944633250000,"body":"payloadBearer abc.def-ghi null ","severity_text":"INFO","severity_number":5,"service_name":null,"resource_attributes":{"1":"\"GET\"","constructor":"false","k8s.pod.name":"true"},"instrumentation_scope":null,"event_name":"request","attributes":{"constructor":"\"{\\\"\\\":[[\\\"ز \\\",\\\"GET10\\\"],true,\\\"-1e400GET\\\",\\\"__defineGetter__ERRORfull\\\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}\"","message":"12","http.response.status_code":"\"\\\"quoted\\\"\"","é":"\"\\u000b\"","name":"0.1","ms":"-5","payload":"\"\""},"bytes_uncompressed":null}]},"output":{"payload_json":null,"value_skipped":0,"eval_errors":0,"series_overflow":{},"threw":null}},{"input":{"rules":[{"id":"m0","metric_name":"posthog.log.records","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[]}]}]},"value_attribute":"duration_ms","group_by":[]},{"id":"m1","metric_name":"x y","filter_group":{"type":"AND","values":[{"type":"OR","values":[]}]},"value_attribute":null,"group_by":["","severity_text","body","name"]}],"defaults":"spans","now_ms":1736944633250,"records":[{"uuid":"u0","trace_id":{"$bytes":"6a3357f1d012d5c32e06e75ee0234311"},"span_id":null,"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"0.300000000000000041xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","severity_text":"INFO","severity_number":13,"service_name":"worker","resource_attributes":{"1":"\"🚀\"","service.name":"\"2025-01-15T10:00:00Z\"","é":"5.","constructor":"\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\"","a":"Wed, 15 Jan 2025 12:00:00 GMT ՚"},"instrumentation_scope":null,"event_name":null,"attributes":{"toString":"\"\\\".5 \\\\\\\\ error \\\"\"","k8s.pod.name":"9007199254740994","name":"\"{\\\"a\\\":1}\"","kind":"\"xoxb-1234567890-abc\"","count":"[1,2]","duration_ms":"\" 12 \"","payload":"0b1"},"bytes_uncompressed":569},{"uuid":"u1","trace_id":null,"span_id":{"$bytes":"a08c8a44ab3a5df8"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"msg1.5T+5","severity_text":"warning","severity_number":12,"service_name":"api","resource_attributes":null,"instrumentation_scope":null,"event_name":null,"attributes":{"ms":"-Infinity","duration_ms":"[1,2]","payload":"5."},"bytes_uncompressed":1332},{"uuid":"u2","trace_id":{"$bytes":"dff94f19b2335a42a3d161038edbf15c"},"span_id":null,"trace_flags":null,"timestamp":1736943361605000,"observed_timestamp":1736944633250000,"body":" 12 ","severity_text":"fatal","severity_number":1,"service_name":"web","resource_attributes":{},"instrumentation_scope":null,"event_name":null,"attributes":{"ms":"\"\"","count":"\"-0\"","http.method":"\"deny\""},"bytes_uncompressed":212}]},"output":{"payload_json":null,"value_skipped":1,"eval_errors":0,"series_overflow":{},"threw":null}}]}diff --git a/rust/logs-ingestion/tests/fixtures/fuzz/normalize.json b/rust/logs-ingestion/tests/fixtures/fuzz/normalize.jsonnew file mode 100644index 000000000000..dc02e4f47347--- /dev/null+++ b/rust/logs-ingestion/tests/fixtures/fuzz/normalize.json@@ -0,0 +1 @@+{"cases":[{"input":{"settings":{"pii_scrub_logs":true},"record":{"uuid":"u0","trace_id":{"$bytes":"535ad424988b143859eccf8ad6e468e8"},"span_id":{"$bytes":"c8e500b8127f3b95"},"trace_flags":null,"timestamp":1736943293759000,"observed_timestamp":1736944633250000,"body":" \"-1e400 12 🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"\n","severity_text":"warning","severity_number":5,"service_name":null,"resource_attributes":{"a":"\"false\"","-1e4004294967296":"2.5e-8"},"instrumentation_scope":null,"event_name":"request","attributes":{"message":"0x10-1e400 ","payload.0":"-1 ","name":"NaN","4294967296":"null"},"bytes_uncompressed":1312}},"output":{"record":{"uuid":"u0","trace_id":{"$bytes":"535ad424988b143859eccf8ad6e468e8"},"span_id":{"$bytes":"c8e500b8127f3b95"},"trace_flags":null,"timestamp":1736943293759000,"observed_timestamp":1736944633250000,"body":" \"-1e400 12 🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"\n","severity_text":"warning","severity_number":5,"service_name":null,"resource_attributes":{"a":"\"false\"","-1e4004294967296":"2.5e-8"},"instrumentation_scope":null,"event_name":"request","attributes":{"message":"0x10-1e400 ","payload.0":"-1 ","name":"NaN","4294967296":"null"},"bytes_uncompressed":1312},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u2","trace_id":{"$bytes":""},"span_id":{"$bytes":"3c07541f954c9eb3"},"trace_flags":null,"timestamp":1736943879177000,"observed_timestamp":1736944633250000,"body":"\"x\\ude80\\ud800+5-1 \"","severity_text":"trace","severity_number":null,"service_name":"","resource_attributes":{"1":"4294967295","k8s.pod.name":"Bearer abc.def-ghi1e+21 ","constructor":"null","host":"\"0o7\""},"instrumentation_scope":null,"event_name":"","attributes":{"k":"1.7976931348623157e+308","b":"\"12.5abc\"","\"":"1.5","payload":"\"{\\\"a\\\":null,\""},"bytes_uncompressed":1363}},"output":{"record":{"uuid":"u2","trace_id":{"$bytes":""},"span_id":{"$bytes":"3c07541f954c9eb3"},"trace_flags":null,"timestamp":1736943879177000,"observed_timestamp":1736944633250000,"body":"\"x\\ude80\\ud800+5-1 \"","severity_text":"trace","severity_number":null,"service_name":"","resource_attributes":{"1":"4294967295","k8s.pod.name":"Bearer abc.def-ghi1e+21 ","constructor":"null","host":"\"0o7\""},"instrumentation_scope":null,"event_name":"","attributes":{"k":"1.7976931348623157e+308","b":"\"12.5abc\"","\"":"1.5","payload":"\"{\\\"a\\\":null,\""},"bytes_uncompressed":1363},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true},"record":{"uuid":"u3","trace_id":{"$bytes":"21df97c0cf9fabc10d9e2f1c124a9a52"},"span_id":{"$bytes":"48e5f7a1e278f2cd"},"trace_flags":null,"timestamp":1736943490282000,"observed_timestamp":1736944633250000,"body":"false","severity_text":"ERRor","severity_number":9,"service_name":null,"resource_attributes":{"1":"2025-01-15T10:00:00Z","2":"\"fatal\"","constructor":"12.5","service.name":"\" \"","k8s.pod.name":"\"sk_live_0123456789abcdefghijkl\""},"instrumentation_scope":null,"event_name":"request","attributes":{"payload.x":"7","日本":"\"INFO\"","msg":"\"sender\""},"bytes_uncompressed":1026}},"output":{"record":{"uuid":"u3","trace_id":{"$bytes":"21df97c0cf9fabc10d9e2f1c124a9a52"},"span_id":{"$bytes":"48e5f7a1e278f2cd"},"trace_flags":null,"timestamp":1736943490282000,"observed_timestamp":1736944633250000,"body":"false","severity_text":"ERRor","severity_number":9,"service_name":null,"resource_attributes":{"1":"2025-01-15T10:00:00Z","2":"\"fatal\"","constructor":"12.5","service.name":"\" \"","k8s.pod.name":"\"sk_live_0123456789abcdefghijkl\""},"instrumentation_scope":null,"event_name":"request","attributes":{"payload.x":"7","日本":"\"INFO\"","msg":"\"sender\""},"bytes_uncompressed":1026},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u4","trace_id":{"$bytes":""},"span_id":{"$bytes":"209af3c8b14e3766"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"{\"🚀\":{\"level\":{\"\\t\":{\"9\":1e-7,\"10\":\"fatal \",\"4294967294\":-339750081.9992274,\"hasOwnProperty\":\"eventtrue\",\"level\":\"host.example.com1\",\"100\\r\\n\":\"deadbeefdebug \"}}}}","severity_text":"INFO","severity_number":12,"service_name":"api","resource_attributes":{"1":"null","service.name":"\"GET\"","host":"true","a":"\"1e400\"","user.emaileyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123":"1e+100"},"instrumentation_scope":null,"event_name":"request","attributes":{"http.status_code":"\"AKIAIOSFODNN7EXAMPLE\"","duration_ms":"\"12.5abc\""},"bytes_uncompressed":1113}},"output":{"record":{"uuid":"u4","trace_id":{"$bytes":""},"span_id":{"$bytes":"209af3c8b14e3766"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"{\"🚀\":{\"level\":{\"\\t\":{\"9\":1e-7,\"10\":\"fatal \",\"4294967294\":-339750081.9992274,\"hasOwnProperty\":\"eventtrue\",\"level\":\"host.example.com1\",\"100\\r\\n\":\"deadbeefdebug \"}}}}","severity_text":"INFO","severity_number":12,"service_name":"api","resource_attributes":{"1":"null","service.name":"\"GET\"","host":"true","a":"\"1e400\"","user.emaileyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123":"1e+100"},"instrumentation_scope":null,"event_name":"request","attributes":{"http.status_code":"\"AKIAIOSFODNN7EXAMPLE\"","duration_ms":"\"12.5abc\""},"bytes_uncompressed":1113},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"pii_scrub_logs":true,"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u5","trace_id":{"$bytes":"6988daeca149bde7013fdba11192286e"},"span_id":{"$bytes":"db76d551275d575c"},"trace_flags":null,"timestamp":1736943245740000,"observed_timestamp":1736944633250000,"body":"[\"\\/{\\\"a\\\":1}\"]","severity_text":"İnfo","severity_number":null,"service_name":"API","resource_attributes":{"1":"\"a\\\\nb\"","service.name":"999.9999999","a":"\"\\\\\"","k8s.pod.name":"\"null\""},"instrumentation_scope":null,"event_name":"","attributes":{"1":"0.1","01":"100","service.name":"\"{\\\"1\\\":\\\"a\\\\\\\\nb覮 𒐆\\\",\\\"51\\\":\\\"\\\\r\\\\n{\\\\\\\"a\\\\\\\":1}[email protected]\\\"}\"","payload":"\"\\\"{\\\\\\\"a\\\\\\\":\\\\\\\"12.5abc \\\\\\\",\\\\\\\"arr\\\\\\\":[1,[2,{\\\\\\\"b\\\\\\\":null}]],\\\\\\\"s\\\\\\\":\\\\\\\"x\\\\\\\"}\\\"\""},"bytes_uncompressed":857}},"output":{"record":{"uuid":"u5","trace_id":{"$bytes":"6988daeca149bde7013fdba11192286e"},"span_id":{"$bytes":"db76d551275d575c"},"trace_flags":null,"timestamp":1736943245740000,"observed_timestamp":1736944633250000,"body":"[\"\\/{\\\"a\\\":1}\"]","severity_text":"İnfo","severity_number":null,"service_name":"API","resource_attributes":{"1":"\"a\\\\nb\"","service.name":"999.9999999","a":"\"\\\\\"","k8s.pod.name":"\"null\""},"instrumentation_scope":null,"event_name":"","attributes":{"0":"\"/{\\\"a\\\":1}\"","1":"0.1","01":"100","service.name":"\"{\\\"1\\\":\\\"a\\\\\\\\nb覮 𒐆\\\",\\\"51\\\":\\\"\\\\r\\\\n{\\\\\\\"a\\\\\\\":1}{{REDACTED}}\\\"}\"","payload":"\"\\\"{\\\\\\\"a\\\\\\\":\\\\\\\"12.5abc \\\\\\\",\\\\\\\"arr\\\\\\\":[1,[2,{\\\\\\\"b\\\\\\\":null}]],\\\\\\\"s\\\\\\\":\\\\\\\"x\\\\\\\"}\\\"\""},"bytes_uncompressed":857},"pii_replacements":1,"gap":false}},{"input":{"settings":{"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u7","trace_id":{"$bytes":"6ce6c9f6c6688496c5d81bd3f5a568bf"},"span_id":null,"trace_flags":null,"timestamp":1736944186638000,"observed_timestamp":1736944633250000,"body":"null","severity_text":"ERROR","severity_number":-1,"service_name":"API","resource_attributes":{"1":"\"{}\"","1.5":"null","service.name":"\"-Infinity\"","constructor":"123456789012345680000","k8s.pod.name":"a\\nb","a":"\"false\"","host":"\"日本語\""},"instrumentation_scope":null,"event_name":"request","attributes":null,"bytes_uncompressed":1306}},"output":{"record":{"uuid":"u7","trace_id":{"$bytes":"6ce6c9f6c6688496c5d81bd3f5a568bf"},"span_id":null,"trace_flags":null,"timestamp":1736944186638000,"observed_timestamp":1736944633250000,"body":"null","severity_text":"ERROR","severity_number":-1,"service_name":"API","resource_attributes":{"1":"\"{}\"","1.5":"null","service.name":"\"-Infinity\"","constructor":"123456789012345680000","k8s.pod.name":"a\\nb","a":"\"false\"","host":"\"日本語\""},"instrumentation_scope":null,"event_name":"request","attributes":null,"bytes_uncompressed":1306},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"a"},"record":{"uuid":"u9","trace_id":{"$bytes":""},"span_id":{"$bytes":"834ce43341b13711"},"trace_flags":null,"timestamp":1736943479221000,"observed_timestamp":1736944633250000,"body":"{\"2\":[1.7976931348623157e+308],\"123456789012345680000 \":\"+512\"}","severity_text":"info","severity_number":13,"service_name":"api","resource_attributes":{"k8s.pod.name":"\"9Bearer abc.def-ghi 1_000\""},"instrumentation_scope":null,"event_name":null,"attributes":{"0":"\"sender\"","1":"","constructor":"false","message":"null","http.method":"100","":"null","payload.a":"\"sender\"","n3":"\"sender\""},"bytes_uncompressed":399}},"output":{"record":{"uuid":"u9","trace_id":{"$bytes":""},"span_id":{"$bytes":"834ce43341b13711"},"trace_flags":null,"timestamp":1736943479221000,"observed_timestamp":1736944633250000,"body":"{\"2\":[1.7976931348623157e+308],\"123456789012345680000 \":\"+512\"}","severity_text":"info","severity_number":13,"service_name":"api","resource_attributes":{"k8s.pod.name":"\"9Bearer abc.def-ghi 1_000\""},"instrumentation_scope":null,"event_name":null,"attributes":{"0":"\"sender\"","1":"","2.0":"1.7976931348623157e+308","123456789012345680000 ":"\"+512\"","constructor":"false","message":"null","http.method":"100","":"null","payload.a":"\"sender\"","n3":"\"sender\""},"bytes_uncompressed":399},"pii_replacements":0,"gap":false}},{"input":{"settings":{"pii_scrub_logs":true},"record":{"uuid":"u10","trace_id":{"$bytes":"144b29d6f344826552285722934683b7"},"span_id":{"$bytes":"d26208fe8a04f4a9"},"trace_flags":null,"timestamp":1736943010933000,"observed_timestamp":1736944633250000,"body":" 0\n","severity_text":null,"severity_number":null,"service_name":"worker","resource_attributes":{},"instrumentation_scope":null,"event_name":"","attributes":{"service.name":"1e+21","payload.0":" ","hasOwnProperty":"\"{\\\"event\\\":[-15727650024928152,\\\"🚀\\\",[[\\\"12\\\",\\\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀[1,2]\\\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}\""},"bytes_uncompressed":412}},"output":{"record":{"uuid":"u10","trace_id":{"$bytes":"144b29d6f344826552285722934683b7"},"span_id":{"$bytes":"d26208fe8a04f4a9"},"trace_flags":null,"timestamp":1736943010933000,"observed_timestamp":1736944633250000,"body":" 0\n","severity_text":null,"severity_number":null,"service_name":"worker","resource_attributes":{},"instrumentation_scope":null,"event_name":"","attributes":{"service.name":"1e+21","payload.0":" ","hasOwnProperty":"\"{\\\"event\\\":[-15727650024928152,\\\"🚀\\\",[[\\\"12\\\",\\\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀[1,2]\\\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}\""},"bytes_uncompressed":412},"pii_replacements":0,"gap":false}},{"input":{"settings":{"pii_scrub_logs":true,"json_parse_logs":true},"record":{"uuid":"u13","trace_id":{"$bytes":"841fd5b7314998bd065d09b4551adce3"},"span_id":null,"trace_flags":null,"timestamp":1736943828685000,"observed_timestamp":1736944633250000,"body":"null","severity_text":"WARN","severity_number":13,"service_name":null,"resource_attributes":{"constructor":"null","k8s.pod.name":"\"AKIAIOSFODNN7EXAMPLE\"","service.name":"\"\\\"quoted\\\"\""},"instrumentation_scope":null,"event_name":null,"attributes":{"payload":"\"{\\\"a\\\":null\""},"bytes_uncompressed":null}},"output":{"record":{"uuid":"u13","trace_id":{"$bytes":"841fd5b7314998bd065d09b4551adce3"},"span_id":null,"trace_flags":null,"timestamp":1736943828685000,"observed_timestamp":1736944633250000,"body":"null","severity_text":"WARN","severity_number":13,"service_name":null,"resource_attributes":{"constructor":"null","k8s.pod.name":"\"AKIAIOSFODNN7EXAMPLE\"","service.name":"\"\\\"quoted\\\"\""},"instrumentation_scope":null,"event_name":null,"attributes":{"payload":"\"{\\\"a\\\":null\""},"bytes_uncompressed":null},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"constructor"},"record":{"uuid":"u14","trace_id":{"$bytes":"1ab37035a3306983"},"span_id":{"$bytes":"6be826e0f2de585b"},"trace_flags":null,"timestamp":1736942690586000,"observed_timestamp":1736944633250000,"body":"0.1","severity_text":"warning","severity_number":5,"service_name":"","resource_attributes":{"1":"\"[null,[\\\"192.168.1.1 NaN0b11\\\",\\\"[email protected]\\\",{\\\"__defineGetter__\\\":null,\\\"a.\\\":true}],1]\""},"instrumentation_scope":null,"event_name":"request","attributes":{"1":"null","01":"\"xoxb-1234567890-abc\"","message":"\" 12\"","":"-1","GET 🚀 ":"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123.5 \"quoted\"","constructor":"\"{\\\"a\\\":true,\\\"arr\\\":[1,[2,{\\\"b\\\":n\""},"bytes_uncompressed":352}},"output":{"record":{"uuid":"u14","trace_id":{"$bytes":"1ab37035a3306983"},"span_id":{"$bytes":"6be826e0f2de585b"},"trace_flags":null,"timestamp":1736942690586000,"observed_timestamp":1736944633250000,"body":"0.1","severity_text":"warning","severity_number":5,"service_name":"","resource_attributes":{"1":"\"[null,[\\\"192.168.1.1 NaN0b11\\\",\\\"[email protected]\\\",{\\\"__defineGetter__\\\":null,\\\"a.\\\":true}],1]\""},"instrumentation_scope":null,"event_name":"request","attributes":{"1":"null","01":"\"xoxb-1234567890-abc\"","message":"\" 12\"","":"-1","GET 🚀 ":"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123.5 \"quoted\"","constructor":"\"{\\\"a\\\":true,\\\"arr\\\":[1,[2,{\\\"b\\\":n\""},"bytes_uncompressed":352},"pii_replacements":0,"gap":false}},{"input":{"settings":{"pii_scrub_logs":true},"record":{"uuid":"u15","trace_id":{"$bytes":"9a751e07e484b965d2ea0bbb46fdb08f"},"span_id":{"$bytes":"c42e96226ebba865"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"\"\\nPOST1_000\"","severity_text":"ERROR","severity_number":12,"service_name":null,"resource_attributes":null,"instrumentation_scope":null,"event_name":"","attributes":{"payload":"\"{\\\"a\""},"bytes_uncompressed":132}},"output":{"record":{"uuid":"u15","trace_id":{"$bytes":"9a751e07e484b965d2ea0bbb46fdb08f"},"span_id":{"$bytes":"c42e96226ebba865"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"\"\\nPOST1_000\"","severity_text":"ERROR","severity_number":12,"service_name":null,"resource_attributes":null,"instrumentation_scope":null,"event_name":"","attributes":{"payload":"\"{\\\"a\""},"bytes_uncompressed":132},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"pii_scrub_logs":true,"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u17","trace_id":{"$bytes":"ac45c812247107e6"},"span_id":{"$bytes":"6d49a7b693ad1285"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"1","severity_text":"info","severity_number":13,"service_name":"","resource_attributes":{"k8s.pod.name":"\"ERROR\"","payload":"true"},"instrumentation_scope":null,"event_name":"","attributes":null,"bytes_uncompressed":1817}},"output":{"record":{"uuid":"u17","trace_id":{"$bytes":"ac45c812247107e6"},"span_id":{"$bytes":"6d49a7b693ad1285"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"1","severity_text":"info","severity_number":13,"service_name":"","resource_attributes":{"k8s.pod.name":"\"ERROR\"","payload":"true"},"instrumentation_scope":null,"event_name":"","attributes":null,"bytes_uncompressed":1817},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u18","trace_id":{"$bytes":""},"span_id":{"$bytes":"4cc99fcc93fcdcbf"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"0b11 ","severity_text":"","severity_number":-1,"service_name":"worker","resource_attributes":{"constructor":"\"null\"","host":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","service.name":"\"3fa85f64-5717-4562-b3fc-2c963f66afa6 \"","k8s.pod.name":"\"12\""},"instrumentation_scope":null,"event_name":"request","attributes":{"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 192.168.1.1":"true"},"bytes_uncompressed":1494}},"output":{"record":{"uuid":"u18","trace_id":{"$bytes":""},"span_id":{"$bytes":"4cc99fcc93fcdcbf"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"0b11 ","severity_text":"","severity_number":-1,"service_name":"worker","resource_attributes":{"constructor":"\"null\"","host":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","service.name":"\"3fa85f64-5717-4562-b3fc-2c963f66afa6 \"","k8s.pod.name":"\"12\""},"instrumentation_scope":null,"event_name":"request","attributes":{"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 192.168.1.1":"true"},"bytes_uncompressed":1494},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u21","trace_id":null,"span_id":{"$bytes":"6b68f4941bf64fab"},"trace_flags":null,"timestamp":1736944584762000,"observed_timestamp":1736944633250000,"body":"null","severity_text":"DEBUG","severity_number":21,"service_name":"api","resource_attributes":{"service.name":"\"123456789012345680000\"","__defineGetter__":"\"ghp_0123456789abcdefghij0123456789abcdef\"","1.5":"\"5.\"","host":"9007199254740994","𐀀":"ghp_0123456789abcdefghij0123456789abcdef 12 "},"instrumentation_scope":null,"event_name":null,"attributes":null,"bytes_uncompressed":1642}},"output":{"record":{"uuid":"u21","trace_id":null,"span_id":{"$bytes":"6b68f4941bf64fab"},"trace_flags":null,"timestamp":1736944584762000,"observed_timestamp":1736944633250000,"body":"null","severity_text":"DEBUG","severity_number":21,"service_name":"api","resource_attributes":{"service.name":"\"123456789012345680000\"","__defineGetter__":"\"ghp_0123456789abcdefghij0123456789abcdef\"","1.5":"\"5.\"","host":"9007199254740994","𐀀":"ghp_0123456789abcdefghij0123456789abcdef 12 "},"instrumentation_scope":null,"event_name":null,"attributes":null,"bytes_uncompressed":1642},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"a"},"record":{"uuid":"u22","trace_id":null,"span_id":{"$bytes":"aac0af03dfb65f00"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"null","severity_text":"ERRor","severity_number":0,"service_name":"","resource_attributes":{"constructor":"a\\nb","host":"\"12\"","k8s.pod.name":"4294967294"},"instrumentation_scope":null,"event_name":"request","attributes":{"__defineGetter__":"4294967294 ","a":"{\"51\":false,\"0.30000000000000004 \":{},\"valueOf\":null,\"b\":{\"�\":\"0x10eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 ݓ \",\"\":{\"🚀 é \":null,\" 12\":{\"2\":\"12 x 2025-01-15T10:00:00Z\"}}}}"},"bytes_uncompressed":492}},"output":{"record":{"uuid":"u22","trace_id":null,"span_id":{"$bytes":"aac0af03dfb65f00"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"null","severity_text":"ERRor","severity_number":0,"service_name":"","resource_attributes":{"constructor":"a\\nb","host":"\"12\"","k8s.pod.name":"4294967294"},"instrumentation_scope":null,"event_name":"request","attributes":{"a.51":"false","a.valueOf":"\"null\"","a.b.�":"\"0x10eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 ݓ \"","a.b..🚀 é ":"\"null\"","a.b.. 12.2":"\"12 x 2025-01-15T10:00:00Z\"","__defineGetter__":"4294967294 ","a":"{\"51\":false,\"0.30000000000000004 \":{},\"valueOf\":null,\"b\":{\"�\":\"0x10eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 ݓ \",\"\":{\"🚀 é \":null,\" 12\":{\"2\":\"12 x 2025-01-15T10:00:00Z\"}}}}"},"bytes_uncompressed":492},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"a"},"record":{"uuid":"u23","trace_id":{"$bytes":""},"span_id":{"$bytes":"54afff3a6c03fbf3"},"trace_flags":null,"timestamp":1736943834932000,"observed_timestamp":1736944633250000,"body":null,"severity_text":"","severity_number":17,"service_name":"api","resource_attributes":{"1":"\r\n","constructor":"\"00\"","a":"0.1","host":"\" \"","k8s.pod.name":"{\"9\":[\"K \"]}"},"instrumentation_scope":null,"event_name":null,"attributes":{"a":"\"{\\\"a\\\":\\\"\\\",\\\"arr\\\":[1,[2,\""},"bytes_uncompressed":940}},"output":{"record":{"uuid":"u23","trace_id":{"$bytes":""},"span_id":{"$bytes":"54afff3a6c03fbf3"},"trace_flags":null,"timestamp":1736943834932000,"observed_timestamp":1736944633250000,"body":null,"severity_text":"","severity_number":17,"service_name":"api","resource_attributes":{"1":"\r\n","constructor":"\"00\"","a":"0.1","host":"\" \"","k8s.pod.name":"{\"9\":[\"K \"]}"},"instrumentation_scope":null,"event_name":null,"attributes":{"a":"\"{\\\"a\\\":\\\"\\\",\\\"arr\\\":[1,[2,\""},"bytes_uncompressed":940},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"a"},"record":{"uuid":"u25","trace_id":null,"span_id":null,"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"\"0o7 1_000 -1.5\"","severity_text":"fatal","severity_number":5,"service_name":"worker","resource_attributes":{"valueOf":"errora\\nbdeadbeef "},"instrumentation_scope":null,"event_name":"request","attributes":{"0":"\"sender\"","k":"2.5e-8","http.path":"\"日本語\"","":"null","path":"1.5","payload":"\"\\\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx -1.5.5\\\"\"","status_code":"999.9999999","level":"\"00\"","a":"\"sender\"","n3":"\"sender\""},"bytes_uncompressed":null}},"output":{"record":{"uuid":"u25","trace_id":null,"span_id":null,"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"\"0o7 1_000 -1.5\"","severity_text":"fatal","severity_number":5,"service_name":"worker","resource_attributes":{"valueOf":"errora\\nbdeadbeef "},"instrumentation_scope":null,"event_name":"request","attributes":{"0":"\"sender\"","k":"2.5e-8","http.path":"\"日本語\"","":"null","path":"1.5","payload":"\"\\\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx -1.5.5\\\"\"","status_code":"999.9999999","level":"\"00\"","a":"\"sender\"","n3":"\"sender\""},"bytes_uncompressed":null},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u26","trace_id":{"$bytes":"6f7a4127b09f8ed3f64c5b23fbd6d273"},"span_id":{"$bytes":"5753cce38defbab9"},"trace_flags":null,"timestamp":1736943714074000,"observed_timestamp":1736944633250000,"body":"1.5","severity_text":"ERROR","severity_number":21,"service_name":"API","resource_attributes":{"1":"5.","host":"2.5e-8","constructor":"\"12\"","a.":"\"-Infinity\""," ":"1e+100"},"instrumentation_scope":null,"event_name":"request","attributes":{"b":"1e+21","message":"\"\""},"bytes_uncompressed":589}},"output":{"record":{"uuid":"u26","trace_id":{"$bytes":"6f7a4127b09f8ed3f64c5b23fbd6d273"},"span_id":{"$bytes":"5753cce38defbab9"},"trace_flags":null,"timestamp":1736943714074000,"observed_timestamp":1736944633250000,"body":"1.5","severity_text":"ERROR","severity_number":21,"service_name":"API","resource_attributes":{"1":"5.","host":"2.5e-8","constructor":"\"12\"","a.":"\"-Infinity\""," ":"1e+100"},"instrumentation_scope":null,"event_name":"request","attributes":{"b":"1e+21","message":"\"\""},"bytes_uncompressed":589},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"1"},"record":{"uuid":"u29","trace_id":{"$bytes":"ed31d8b596e6dc54307f49fedb0da3c0"},"span_id":null,"trace_flags":null,"timestamp":1736942413569000,"observed_timestamp":1736944633250000,"body":"true","severity_text":"debug ","severity_number":1,"service_name":"api","resource_attributes":null,"instrumentation_scope":null,"event_name":"request","attributes":{"1":"{\"a\":\"0 \\\"quoted\\\"\",\"arr\":[1,[2,{\"b\":null}]],\"s\":\"x\"}","url.path":"\"/api/v1/users/123\"","01":" ","1.5":"Infinity"},"bytes_uncompressed":1206}},"output":{"record":{"uuid":"u29","trace_id":{"$bytes":"ed31d8b596e6dc54307f49fedb0da3c0"},"span_id":null,"trace_flags":null,"timestamp":1736942413569000,"observed_timestamp":1736944633250000,"body":"true","severity_text":"debug ","severity_number":1,"service_name":"api","resource_attributes":null,"instrumentation_scope":null,"event_name":"request","attributes":{"1":"{\"a\":\"0 \\\"quoted\\\"\",\"arr\":[1,[2,{\"b\":null}]],\"s\":\"x\"}","1.a":"\"0 \\\"quoted\\\"\"","1.arr":"\"[1,[2,{\\\"b\\\":null}]]\"","1.s":"\"x\"","url.path":"\"/api/v1/users/123\"","01":" ","1.5":"Infinity"},"bytes_uncompressed":1206},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"1"},"record":{"uuid":"u31","trace_id":{"$bytes":""},"span_id":null,"trace_flags":null,"timestamp":1736943295457000,"observed_timestamp":1736944633250000,"body":" \"0x10\"\n","severity_text":"fatal","severity_number":21,"service_name":"worker","resource_attributes":{"http.method":"\"Infinity\""},"instrumentation_scope":null,"event_name":"request","attributes":{"kind":"user_123 x","http.status_code":"-1debug ","status_code":"ERROR","k1":"\"sender\"","n3":"\"sender\""},"bytes_uncompressed":null}},"output":{"record":{"uuid":"u31","trace_id":{"$bytes":""},"span_id":null,"trace_flags":null,"timestamp":1736943295457000,"observed_timestamp":1736944633250000,"body":" \"0x10\"\n","severity_text":"fatal","severity_number":21,"service_name":"worker","resource_attributes":{"http.method":"\"Infinity\""},"instrumentation_scope":null,"event_name":"request","attributes":{"kind":"user_123 x","http.status_code":"-1debug ","status_code":"ERROR","k1":"\"sender\"","n3":"\"sender\""},"bytes_uncompressed":null},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"pii_scrub_logs":true,"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u32","trace_id":{"$bytes":"cb7902925a52bd802c790fb500df7c8d"},"span_id":{"$bytes":"c94c4dab68151279"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"0.000009567317832261323","severity_text":"fatal","severity_number":null,"service_name":"api","resource_attributes":{"service.name":"\"12\"","host":"\"true\"","k":" 12 "},"instrumentation_scope":null,"event_name":"","attributes":{"user.email":"\"3fa85f64-5717-4562-b3fc-2c963f66afa6\"","level":"\"+5\"","k8s.pod.name":"true","payload":"{\"a\":[9007199254740992,true,{\"0\":{\"full\":\"12 1.50b11 \"},\"1\":true,\"10\":null,\"message\":1e-7,\"\\n\":\"0\"},1,1,1,1,1,1,1],\"arr\":[1,[2,{\"b\":null}]],\"s\":\"x\"}"},"bytes_uncompressed":598}},"output":{"record":{"uuid":"u32","trace_id":{"$bytes":"cb7902925a52bd802c790fb500df7c8d"},"span_id":{"$bytes":"c94c4dab68151279"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"0.000009567317832261323","severity_text":"fatal","severity_number":null,"service_name":"api","resource_attributes":{"service.name":"\"12\"","host":"\"true\"","k":" 12 "},"instrumentation_scope":null,"event_name":"","attributes":{"payload.a":"\"[9007199254740992,true,{\\\"0\\\":{\\\"full\\\":\\\"12 1.50b11 \\\"},\\\"1\\\":true,\\\"10\\\":null,\\\"message\\\":1e-7,\\\"\\\\n\\\":\\\"0\\\"},1,1,1,1,1,1,1]\"","payload.arr":"\"[1,[2,{\\\"b\\\":null}]]\"","payload.s":"\"x\"","user.email":"\"3fa85f64-5717-4562-b3fc-2c963f66afa6\"","level":"\"+5\"","k8s.pod.name":"true","payload":"{\"a\":[9007199254740992,true,{\"0\":{\"full\":\"12 1.50b11 \"},\"1\":true,\"10\":null,\"message\":1e-7,\"\\n\":\"0\"},1,1,1,1,1,1,1],\"arr\":[1,[2,{\"b\":null}]],\"s\":\"x\"}"},"bytes_uncompressed":598},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"constructor"},"record":{"uuid":"u33","trace_id":{"$bytes":""},"span_id":{"$bytes":"645209a486cb4797"},"trace_flags":null,"timestamp":1736944072110000,"observed_timestamp":1736944633250000,"body":"true","severity_text":"INFO","severity_number":13,"service_name":"API","resource_attributes":{"k8s.pod.name":"10 ","constructor":"\"null\"","a":"\"true\""},"instrumentation_scope":null,"event_name":"","attributes":{"🚀":"null","path":"fatal","":"null","constructor":"{\"a\":4294967294,\"arr\":[1,[2,{\"b\":null}]],\"s\":\"x\"}","msg":"\"sender\""},"bytes_uncompressed":null}},"output":{"record":{"uuid":"u33","trace_id":{"$bytes":""},"span_id":{"$bytes":"645209a486cb4797"},"trace_flags":null,"timestamp":1736944072110000,"observed_timestamp":1736944633250000,"body":"true","severity_text":"INFO","severity_number":13,"service_name":"API","resource_attributes":{"k8s.pod.name":"10 ","constructor":"\"null\"","a":"\"true\""},"instrumentation_scope":null,"event_name":"","attributes":{"constructor.a":"4294967294","constructor.arr":"\"[1,[2,{\\\"b\\\":null}]]\"","constructor.s":"\"x\"","🚀":"null","path":"fatal","":"null","constructor":"{\"a\":4294967294,\"arr\":[1,[2,{\"b\":null}]],\"s\":\"x\"}","msg":"\"sender\""},"bytes_uncompressed":null},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u34","trace_id":{"$bytes":"1236519491fc55f3befd8b463362855b"},"span_id":{"$bytes":"61c60e8896ef0408"},"trace_flags":null,"timestamp":1736943257311000,"observed_timestamp":1736944633250000,"body":"\"warn +5 \"","severity_text":"INFO","severity_number":5,"service_name":"web","resource_attributes":{"1":"\"sk_live_0123456789abcdefghijkl\"","🚀":"false","a":"\"Wed, 15 Jan 2025 12:00:00 GMT\"","constructor":"\"\\\"鑫\\\\\\\"quoted\\\\\\\"-Infinity\\\"\"","user.email":"\"2025-01-15T10:00:00Z\""},"instrumentation_scope":null,"event_name":null,"attributes":{"user.email":"\"[{\\\" 1 \\\":[true,null,\\\"ӊ\\\",null,\\\"0b11toString\\\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\"","192.168.0.1":"\"\\\"\"","duration_ms":"-1.5","\u000b":"0","payload":"\"{\\\"a\\\":[null,\\\"x\\\",true,false,\\\"NaN \\\\\\\" 0x10\\\",999.9999999,{\\\"0\\\":true,\\\"[1,2] \\\":false},1,1,1,1,1,1,1,1,1,1\""},"bytes_uncompressed":518}},"output":{"record":{"uuid":"u34","trace_id":{"$bytes":"1236519491fc55f3befd8b463362855b"},"span_id":{"$bytes":"61c60e8896ef0408"},"trace_flags":null,"timestamp":1736943257311000,"observed_timestamp":1736944633250000,"body":"\"warn +5 \"","severity_text":"INFO","severity_number":5,"service_name":"web","resource_attributes":{"1":"\"sk_live_0123456789abcdefghijkl\"","🚀":"false","a":"\"Wed, 15 Jan 2025 12:00:00 GMT\"","constructor":"\"\\\"鑫\\\\\\\"quoted\\\\\\\"-Infinity\\\"\"","user.email":"\"2025-01-15T10:00:00Z\""},"instrumentation_scope":null,"event_name":null,"attributes":{"user.email":"\"[{\\\" 1 \\\":[true,null,\\\"ӊ\\\",null,\\\"0b11toString\\\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\"","192.168.0.1":"\"\\\"\"","duration_ms":"-1.5","\u000b":"0","payload":"\"{\\\"a\\\":[null,\\\"x\\\",true,false,\\\"NaN \\\\\\\" 0x10\\\",999.9999999,{\\\"0\\\":true,\\\"[1,2] \\\":false},1,1,1,1,1,1,1,1,1,1\""},"bytes_uncompressed":518},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"a"},"record":{"uuid":"u35","trace_id":{"$bytes":"ffe6ad33f1f2df7948c3dd9aa62ebcbf"},"span_id":{"$bytes":"29fbeff2a8641063"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"[true]","severity_text":"DEBUG","severity_number":5,"service_name":"","resource_attributes":{},"instrumentation_scope":null,"event_name":null,"attributes":{"ms":"-9007199254740992","message":"1e+21"," 12":"\"1e3\"","-1":"false","a":"{\"a\":5e-324,\"arr\":[1,[2,{\"b\":null}]],\"s\":\"x\"}"},"bytes_uncompressed":null}},"output":{"record":{"uuid":"u35","trace_id":{"$bytes":"ffe6ad33f1f2df7948c3dd9aa62ebcbf"},"span_id":{"$bytes":"29fbeff2a8641063"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"[true]","severity_text":"DEBUG","severity_number":5,"service_name":"","resource_attributes":{},"instrumentation_scope":null,"event_name":null,"attributes":{"0":"true","a.a":"5e-324","a.arr":"\"[1,[2,{\\\"b\\\":null}]]\"","a.s":"\"x\"","ms":"-9007199254740992","message":"1e+21"," 12":"\"1e3\"","-1":"false","a":"{\"a\":5e-324,\"arr\":[1,[2,{\"b\":null}]],\"s\":\"x\"}"},"bytes_uncompressed":null},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"1"},"record":{"uuid":"u36","trace_id":{"$bytes":"4cf7a48fc369f1ae087195b77873d69d"},"span_id":{"$bytes":"a1412bd5de54cc14"},"trace_flags":null,"timestamp":1736944197514000,"observed_timestamp":1736944633250000,"body":"user_123NaN","severity_text":null,"severity_number":13,"service_name":"api","resource_attributes":{"1":"\"ERROR\"","a":"\"null\"","k8s.pod.name":"{\"51\":\"warn 🚀 \",\"\":1.5,\"length\":null,\".5\":true,\"ڊ\\u000b\":4110649195499.7183,\"host.example.com\":{},\"é\":\"POSTa.\"}"},"instrumentation_scope":null,"event_name":null,"attributes":{"kind":"\u000b","user.email":"\"GET\"","http.response.status_code":"true","a":"\"sender\""},"bytes_uncompressed":860}},"output":{"record":{"uuid":"u36","trace_id":{"$bytes":"4cf7a48fc369f1ae087195b77873d69d"},"span_id":{"$bytes":"a1412bd5de54cc14"},"trace_flags":null,"timestamp":1736944197514000,"observed_timestamp":1736944633250000,"body":"user_123NaN","severity_text":null,"severity_number":13,"service_name":"api","resource_attributes":{"1":"\"ERROR\"","a":"\"null\"","k8s.pod.name":"{\"51\":\"warn 🚀 \",\"\":1.5,\"length\":null,\".5\":true,\"ڊ\\u000b\":4110649195499.7183,\"host.example.com\":{},\"é\":\"POSTa.\"}"},"instrumentation_scope":null,"event_name":null,"attributes":{"kind":"\u000b","user.email":"\"GET\"","http.response.status_code":"true","a":"\"sender\""},"bytes_uncompressed":860},"pii_replacements":0,"gap":false}},{"input":{"settings":{"pii_scrub_logs":true},"record":{"uuid":"u37","trace_id":{"$bytes":"3ee8ccae2b974400d9351a69a2851b08"},"span_id":{"$bytes":"b9b07d1b1c3657b1"},"trace_flags":null,"timestamp":1736943107115000,"observed_timestamp":1736944633250000,"body":null,"severity_text":"warning","severity_number":21,"service_name":null,"resource_attributes":null,"instrumentation_scope":null,"event_name":"request","attributes":null,"bytes_uncompressed":1277}},"output":{"record":{"uuid":"u37","trace_id":{"$bytes":"3ee8ccae2b974400d9351a69a2851b08"},"span_id":{"$bytes":"b9b07d1b1c3657b1"},"trace_flags":null,"timestamp":1736943107115000,"observed_timestamp":1736944633250000,"body":null,"severity_text":"warning","severity_number":21,"service_name":null,"resource_attributes":null,"instrumentation_scope":null,"event_name":"request","attributes":null,"bytes_uncompressed":1277},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u39","trace_id":{"$bytes":"d6dcde21c38c2a7c"},"span_id":{"$bytes":"9e2a8d7c997bb4ef"},"trace_flags":null,"timestamp":1736944512559000,"observed_timestamp":1736944633250000,"body":" 🚀4294967294 121e-7 ","severity_text":"WARN","severity_number":null,"service_name":"API","resource_attributes":{"12.5abc":"0.1"},"instrumentation_scope":null,"event_name":null,"attributes":{"severity_text":"🚀2.5e-8Bearer abc.def-ghi ","payload":"\"{\\\"a\\\":[{\\\"49\\\":{\\\"0\\\":\\\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6 \\\",\\\"1\\\":9007199254740992,\\\"2\\\":{\\\"10\\\":true,\\\"host.example.com\\\":null,\\\"4294967295\\\":true,\\\"-1\\\":123456789012345680000,\\\"msg\\\":[[]],\\\"1e3\\\":[\\\"fatal\\\",[{\\\"0\\\":-3.852867914829403e-7,\\\"5\\\":\\\"Wed, 15 Jan 2025 12:00:00 GMT \\\",\\\"100\\\":null,\\\"host.example.com\\\":false,\\\"a\\\\\\\\nb\\\":\"","level":"0.000001","k1":"\"sender\"","n3":"\"sender\"","message":"\"sender\""},"bytes_uncompressed":1922}},"output":{"record":{"uuid":"u39","trace_id":{"$bytes":"d6dcde21c38c2a7c"},"span_id":{"$bytes":"9e2a8d7c997bb4ef"},"trace_flags":null,"timestamp":1736944512559000,"observed_timestamp":1736944633250000,"body":" 🚀4294967294 121e-7 ","severity_text":"WARN","severity_number":null,"service_name":"API","resource_attributes":{"12.5abc":"0.1"},"instrumentation_scope":null,"event_name":null,"attributes":{"severity_text":"🚀2.5e-8Bearer abc.def-ghi ","payload":"\"{\\\"a\\\":[{\\\"49\\\":{\\\"0\\\":\\\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6 \\\",\\\"1\\\":9007199254740992,\\\"2\\\":{\\\"10\\\":true,\\\"host.example.com\\\":null,\\\"4294967295\\\":true,\\\"-1\\\":123456789012345680000,\\\"msg\\\":[[]],\\\"1e3\\\":[\\\"fatal\\\",[{\\\"0\\\":-3.852867914829403e-7,\\\"5\\\":\\\"Wed, 15 Jan 2025 12:00:00 GMT \\\",\\\"100\\\":null,\\\"host.example.com\\\":false,\\\"a\\\\\\\\nb\\\":\"","level":"0.000001","k1":"\"sender\"","n3":"\"sender\"","message":"\"sender\""},"bytes_uncompressed":1922},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true},"record":{"uuid":"u41","trace_id":{"$bytes":"bf5da18f9d3bffeb7aae8b620e19f600"},"span_id":{"$bytes":"7018f42bab8795d6"},"trace_flags":null,"timestamp":1736942512233000,"observed_timestamp":1736944633250000,"body":"null","severity_text":"DEBUG","severity_number":21,"service_name":null,"resource_attributes":{"1":"\"[[[3.1365908263251185e-13,[\\\"-900719925474099201 \\\",\\\"0b11 k\\\",\\\"|\\\",1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\"","host":"\"[email protected]\"","k8s.pod.name":"1e+21","a":"\" 12\""},"instrumentation_scope":null,"event_name":"","attributes":{"k":"\"debug\"","🚀":"\"0.00014928759494796395\"","kind":"xoxb-1234567890-abc"},"bytes_uncompressed":505}},"output":{"record":{"uuid":"u41","trace_id":{"$bytes":"bf5da18f9d3bffeb7aae8b620e19f600"},"span_id":{"$bytes":"7018f42bab8795d6"},"trace_flags":null,"timestamp":1736942512233000,"observed_timestamp":1736944633250000,"body":"null","severity_text":"DEBUG","severity_number":21,"service_name":null,"resource_attributes":{"1":"\"[[[3.1365908263251185e-13,[\\\"-900719925474099201 \\\",\\\"0b11 k\\\",\\\"|\\\",1,1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\"","host":"\"[email protected]\"","k8s.pod.name":"1e+21","a":"\" 12\""},"instrumentation_scope":null,"event_name":"","attributes":{"k":"\"debug\"","🚀":"\"0.00014928759494796395\"","kind":"xoxb-1234567890-abc"},"bytes_uncompressed":505},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u42","trace_id":{"$bytes":"ceed5a6b991bd828ac221505ce24fe9d"},"span_id":{"$bytes":"46bfd3aceb762ae7"},"trace_flags":null,"timestamp":1736942601173000,"observed_timestamp":1736944633250000,"body":"\"2 \"","severity_text":"İnfo","severity_number":null,"service_name":null,"resource_attributes":{},"instrumentation_scope":null,"event_name":null,"attributes":{"0":"\"sender\"","a":"\"-1e400\"","http.status_code":"\"192.168.1.1\"","k":"\"+5\"","constructor":"\"[{\\\"2\\\":false,\\\"49\\\":false,\\\"ԅ-Infinity\\\":-9007199254740992,\\\"ERROR POST\\\":3666757447.645068,\\\"..\\\":1.5},\\\"Bearer abc.def-ghiBearer abc.def-ghi\\\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\"","warnhttp.method":"4294967294 warn🚀","b":"null","payload":"\"{\\\"a\\\":null,\\\"arr\\\":[1,[2,{\\\"b\\\":null}]],\\\"s\\\":\\\"x\\\"}\"","n3":"\"sender\""},"bytes_uncompressed":1618}},"output":{"record":{"uuid":"u42","trace_id":{"$bytes":"ceed5a6b991bd828ac221505ce24fe9d"},"span_id":{"$bytes":"46bfd3aceb762ae7"},"trace_flags":null,"timestamp":1736942601173000,"observed_timestamp":1736944633250000,"body":"\"2 \"","severity_text":"İnfo","severity_number":null,"service_name":null,"resource_attributes":{},"instrumentation_scope":null,"event_name":null,"attributes":{"0":"\"sender\"","payload.a":"\"null\"","payload.arr":"\"[1,[2,{\\\"b\\\":null}]]\"","payload.s":"\"x\"","a":"\"-1e400\"","http.status_code":"\"192.168.1.1\"","k":"\"+5\"","constructor":"\"[{\\\"2\\\":false,\\\"49\\\":false,\\\"ԅ-Infinity\\\":-9007199254740992,\\\"ERROR POST\\\":3666757447.645068,\\\"..\\\":1.5},\\\"Bearer abc.def-ghiBearer abc.def-ghi\\\",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\"","warnhttp.method":"4294967294 warn🚀","b":"null","payload":"\"{\\\"a\\\":null,\\\"arr\\\":[1,[2,{\\\"b\\\":null}]],\\\"s\\\":\\\"x\\\"}\"","n3":"\"sender\""},"bytes_uncompressed":1618},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"a"},"record":{"uuid":"u43","trace_id":{"$bytes":"7e82018b87c97d4144bbad13f171ab9e"},"span_id":{"$bytes":"fca1d9859ab096eb"},"trace_flags":null,"timestamp":1736943596807000,"observed_timestamp":1736944633250000,"body":"{\"2\":\"9007199254740992NaN[1,2] \",\"5\":[false,{\"1\":{\"0warn \":\"ERRORݭ\"}},1],\"4294967294\":[],\"message\":false,\"\\n\":1e+21}","severity_text":"trace","severity_number":21,"service_name":"worker","resource_attributes":{"a":"\"{\\\"3\\\":true,\\\"100\\\":\\\"k \\\\u000b\\\",\\\"日本\\\":null,\\\"msg\\\":\\\"12日本語日本語\\\",\\\"1.5\\\":[\\\" 12 éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\\\",null]}\"","host":"\"x\""},"instrumentation_scope":null,"event_name":"request","attributes":{"level":"-1.5","a":"\"{\\\"a\\\":1e+100,\\\"arr\\\":[1,[2,{\\\"b\\\":null}]],\\\"s\\\":\\\"x\\\"}\""},"bytes_uncompressed":86}},"output":{"record":{"uuid":"u43","trace_id":{"$bytes":"7e82018b87c97d4144bbad13f171ab9e"},"span_id":{"$bytes":"fca1d9859ab096eb"},"trace_flags":null,"timestamp":1736943596807000,"observed_timestamp":1736944633250000,"body":"{\"2\":\"9007199254740992NaN[1,2] \",\"5\":[false,{\"1\":{\"0warn \":\"ERRORݭ\"}},1],\"4294967294\":[],\"message\":false,\"\\n\":1e+21}","severity_text":"trace","severity_number":21,"service_name":"worker","resource_attributes":{"a":"\"{\\\"3\\\":true,\\\"100\\\":\\\"k \\\\u000b\\\",\\\"日本\\\":null,\\\"msg\\\":\\\"12日本語日本語\\\",\\\"1.5\\\":[\\\" 12 éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\\\",null]}\"","host":"\"x\""},"instrumentation_scope":null,"event_name":"request","attributes":{"2":"\"9007199254740992NaN[1,2] \"","5.0":"false","5.1.1.0warn ":"\"ERRORݭ\"","5.2":"1","message":"false","\n":"1e+21","a.a":"1e+100","a.arr":"\"[1,[2,{\\\"b\\\":null}]]\"","a.s":"\"x\"","level":"-1.5","a":"\"{\\\"a\\\":1e+100,\\\"arr\\\":[1,[2,{\\\"b\\\":null}]],\\\"s\\\":\\\"x\\\"}\""},"bytes_uncompressed":86},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"constructor"},"record":{"uuid":"u46","trace_id":{"$bytes":"98b3ae2132843e368ad7b3f40f5bb66e"},"span_id":{"$bytes":"7bb186174ad461f2"},"trace_flags":null,"timestamp":1736942597804000,"observed_timestamp":1736944633250000,"body":"true","severity_text":"info","severity_number":5,"service_name":"API","resource_attributes":{"\\":"\"\\\\\""},"instrumentation_scope":null,"event_name":"request","attributes":{"name":"\"{\\\"5\\\":false,\\\"50\\\":1,\\\"__proto__\\\":{\\\"0\\\":0,\\\"deadbeef\\\":\\\"\\\\r\\\\n+5\\\"},\\\"\\\\\\\\\\\":5e-324,\\\"b\\\":\\\"-1e400-Infinity\\\"}\"","level":"12.5abc","__defineGetter__":"1e-7","constructor":"{\"a\":100,\"arr\":[1,[2,{\"b\":null}]],\"s\":\"x\"}"},"bytes_uncompressed":1787}},"output":{"record":{"uuid":"u46","trace_id":{"$bytes":"98b3ae2132843e368ad7b3f40f5bb66e"},"span_id":{"$bytes":"7bb186174ad461f2"},"trace_flags":null,"timestamp":1736942597804000,"observed_timestamp":1736944633250000,"body":"true","severity_text":"info","severity_number":5,"service_name":"API","resource_attributes":{"\\":"\"\\\\\""},"instrumentation_scope":null,"event_name":"request","attributes":{"constructor.a":"100","constructor.arr":"\"[1,[2,{\\\"b\\\":null}]]\"","constructor.s":"\"x\"","name":"\"{\\\"5\\\":false,\\\"50\\\":1,\\\"__proto__\\\":{\\\"0\\\":0,\\\"deadbeef\\\":\\\"\\\\r\\\\n+5\\\"},\\\"\\\\\\\\\\\":5e-324,\\\"b\\\":\\\"-1e400-Infinity\\\"}\"","level":"12.5abc","__defineGetter__":"1e-7","constructor":"{\"a\":100,\"arr\":[1,[2,{\"b\":null}]],\"s\":\"x\"}"},"bytes_uncompressed":1787},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u47","trace_id":{"$bytes":"a0c96907b8b4fe243738b1eca996d315"},"span_id":null,"trace_flags":null,"timestamp":1736944301653000,"observed_timestamp":1736944633250000,"body":"\" 12event\"","severity_text":null,"severity_number":null,"service_name":"API","resource_attributes":{"1":"lá sk_live_0123456789abcdefghijkl","k8s.pod.name":"\u000b2001:db8::1 ","host":"9007199254740994"},"instrumentation_scope":null,"event_name":"","attributes":{},"bytes_uncompressed":1212}},"output":{"record":{"uuid":"u47","trace_id":{"$bytes":"a0c96907b8b4fe243738b1eca996d315"},"span_id":null,"trace_flags":null,"timestamp":1736944301653000,"observed_timestamp":1736944633250000,"body":"\" 12event\"","severity_text":null,"severity_number":null,"service_name":"API","resource_attributes":{"1":"lá sk_live_0123456789abcdefghijkl","k8s.pod.name":"\u000b2001:db8::1 ","host":"9007199254740994"},"instrumentation_scope":null,"event_name":"","attributes":{},"bytes_uncompressed":1212},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"pii_scrub_logs":true,"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u48","trace_id":{"$bytes":""},"span_id":null,"trace_flags":null,"timestamp":1736942879538000,"observed_timestamp":1736944633250000,"body":"{\"1\":\"true \",\"100\":{\"日本\":-101661714725.19637,\"message\":false,\"http.method \":\" ERROR \\\"quoted\\\" \",\"level\":\"[email protected]\",\"http.method\":\"00 \"},\"4294967295\":\" 12\",\"length\":null}","severity_text":"info","severity_number":null,"service_name":"api","resource_attributes":{"k8s.pod.name":"\"warn\"","constructor":"\"123456789012345680000\"","-Infinity+5 ":"\"POST\""},"instrumentation_scope":null,"event_name":null,"attributes":{"🚀":"0","payload":"\"\\\"{\\\\\\\"\\\\\\\\\\\\\\\\a\\\\\\\":1.5,\\\\\\\"arr\\\\\\\":[1,[2,{\\\\\\\"b\\\\\\\":null}]],\\\\\\\"s\\\\\\\":\\\\\\\"x\\\\\\\"}\\\"\"","n3":"\"sender\"","msg":"\"sender\""},"bytes_uncompressed":16}},"output":{"record":{"uuid":"u48","trace_id":{"$bytes":""},"span_id":null,"trace_flags":null,"timestamp":1736942879538000,"observed_timestamp":1736944633250000,"body":"{\"1\":\"true \",\"100\":{\"日本\":-101661714725.19637,\"message\":false,\"http.method \":\" ERROR \\\"quoted\\\" \",\"level\":\"{{REDACTED}}\",\"http.method\":\"00 \"},\"4294967295\":\" 12\",\"length\":null}","severity_text":"info","severity_number":null,"service_name":"api","resource_attributes":{"k8s.pod.name":"\"warn\"","constructor":"\"123456789012345680000\"","-Infinity+5 ":"\"POST\""},"instrumentation_scope":null,"event_name":null,"attributes":{"1":"\"true \"","100.日本":"-101661714725.19637","100.message":"false","100.http.method ":"\" ERROR \\\"quoted\\\" \"","100.level":"\"{{REDACTED}}\"","100.http.method":"\"00 \"","4294967295":"\" 12\"","length":"\"null\"","🚀":"0","payload":"\"\\\"{\\\\\\\"\\\\\\\\\\\\\\\\a\\\\\\\":1.5,\\\\\\\"arr\\\\\\\":[1,[2,{\\\\\\\"b\\\\\\\":null}]],\\\\\\\"s\\\\\\\":\\\\\\\"x\\\\\\\"}\\\"\"","n3":"\"sender\"","msg":"\"sender\""},"bytes_uncompressed":16},"pii_replacements":1,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"1"},"record":{"uuid":"u49","trace_id":{"$bytes":"ff6f6f29a843944b7c838fa43c2111b0"},"span_id":null,"trace_flags":null,"timestamp":1736943871957000,"observed_timestamp":1736944633250000,"body":"\"ﲸ-0\"","severity_text":"İnfo","severity_number":5,"service_name":"","resource_attributes":null,"instrumentation_scope":null,"event_name":"request","attributes":{"0":"\"sender\"","user.email":"true","n3":"\"sender\""},"bytes_uncompressed":661}},"output":{"record":{"uuid":"u49","trace_id":{"$bytes":"ff6f6f29a843944b7c838fa43c2111b0"},"span_id":null,"trace_flags":null,"timestamp":1736943871957000,"observed_timestamp":1736944633250000,"body":"\"ﲸ-0\"","severity_text":"İnfo","severity_number":5,"service_name":"","resource_attributes":null,"instrumentation_scope":null,"event_name":"request","attributes":{"0":"\"sender\"","user.email":"true","n3":"\"sender\""},"bytes_uncompressed":661},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"constructor"},"record":{"uuid":"u50","trace_id":{"$bytes":"2e749907830eab50f9881bcbdab67a5c"},"span_id":{"$bytes":"d8870668b3f835fd"},"trace_flags":null,"timestamp":1736943442459000,"observed_timestamp":1736944633250000,"body":"null","severity_text":"trace","severity_number":12,"service_name":null,"resource_attributes":{"1":"\"xoxb-1234567890-abc\""},"instrumentation_scope":null,"event_name":"","attributes":{"0":"\"sender\"","http.path":"\"é\"","payload.a":"\"sender\""},"bytes_uncompressed":null}},"output":{"record":{"uuid":"u50","trace_id":{"$bytes":"2e749907830eab50f9881bcbdab67a5c"},"span_id":{"$bytes":"d8870668b3f835fd"},"trace_flags":null,"timestamp":1736943442459000,"observed_timestamp":1736944633250000,"body":"null","severity_text":"trace","severity_number":12,"service_name":null,"resource_attributes":{"1":"\"xoxb-1234567890-abc\""},"instrumentation_scope":null,"event_name":"","attributes":{"0":"\"sender\"","http.path":"\"é\"","payload.a":"\"sender\""},"bytes_uncompressed":null},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u54","trace_id":{"$bytes":"33a903387b2dd0abce93bddce3d3e58a"},"span_id":{"$bytes":"5719edc4facc5236"},"trace_flags":null,"timestamp":1736943984759000,"observed_timestamp":1736944633250000,"body":"false","severity_text":"INFO","severity_number":17,"service_name":"web","resource_attributes":{"k8s.pod.name":"4.125042259693145e-21"},"instrumentation_scope":null,"event_name":"request","attributes":{"count":"🚀","http.route":"\"2001:db8::1\"","hasOwnProperty":"\"\\r\\n\"","path":"-9007199254740992","é":"a4294967296message","payload":"\"{\\\"a.\\\":{\\\"9\\\":[{\\\"\\\\t9007199254740994\\\":\\\"null2001:db8::1𗕤\\\"},100],\\\"1\""},"bytes_uncompressed":114}},"output":{"record":{"uuid":"u54","trace_id":{"$bytes":"33a903387b2dd0abce93bddce3d3e58a"},"span_id":{"$bytes":"5719edc4facc5236"},"trace_flags":null,"timestamp":1736943984759000,"observed_timestamp":1736944633250000,"body":"false","severity_text":"INFO","severity_number":17,"service_name":"web","resource_attributes":{"k8s.pod.name":"4.125042259693145e-21"},"instrumentation_scope":null,"event_name":"request","attributes":{"count":"🚀","http.route":"\"2001:db8::1\"","hasOwnProperty":"\"\\r\\n\"","path":"-9007199254740992","é":"a4294967296message","payload":"\"{\\\"a.\\\":{\\\"9\\\":[{\\\"\\\\t9007199254740994\\\":\\\"null2001:db8::1𗕤\\\"},100],\\\"1\""},"bytes_uncompressed":114},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u55","trace_id":{"$bytes":"2984be578880678bbbe755bbc72a7f49"},"span_id":null,"trace_flags":null,"timestamp":1736944250130000,"observed_timestamp":1736944633250000,"body":" 日本語4294967295uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6 ","severity_text":"INFO","severity_number":-1,"service_name":"","resource_attributes":{"1":"0","constructor":"4294967294","a":"1e400"},"instrumentation_scope":null,"event_name":null,"attributes":{"payload":"\"{\\\"\\\\ud83d2\\\":true,\\\"9\\\":null,\\\"50\\\":\\\"Wed, 15 Jan 2025 12:00:00 GMT.a{\\\"\\\\u0000,\\\"51\\\":\\\"length\""},"bytes_uncompressed":1966}},"output":{"record":{"uuid":"u55","trace_id":{"$bytes":"2984be578880678bbbe755bbc72a7f49"},"span_id":null,"trace_flags":null,"timestamp":1736944250130000,"observed_timestamp":1736944633250000,"body":" 日本語4294967295uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6 ","severity_text":"INFO","severity_number":-1,"service_name":"","resource_attributes":{"1":"0","constructor":"4294967294","a":"1e400"},"instrumentation_scope":null,"event_name":null,"attributes":{"payload":"\"{\\\"\\\\ud83d2\\\":true,\\\"9\\\":null,\\\"50\\\":\\\"Wed, 15 Jan 2025 12:00:00 GMT.a{\\\"\\\\u0000,\\\"51\\\":\\\"length\""},"bytes_uncompressed":1966},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"a"},"record":{"uuid":"u56","trace_id":{"$bytes":"fd2604c08954d50744cbba2b3c70a994"},"span_id":{"$bytes":"58323092cab70d7f"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"\" ghp_0123456789abcdefghij0123456789abcdef\"","severity_text":"warning","severity_number":0,"service_name":"api","resource_attributes":{},"instrumentation_scope":null,"event_name":"","attributes":null,"bytes_uncompressed":1455}},"output":{"record":{"uuid":"u56","trace_id":{"$bytes":"fd2604c08954d50744cbba2b3c70a994"},"span_id":{"$bytes":"58323092cab70d7f"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"\" ghp_0123456789abcdefghij0123456789abcdef\"","severity_text":"warning","severity_number":0,"service_name":"api","resource_attributes":{},"instrumentation_scope":null,"event_name":"","attributes":null,"bytes_uncompressed":1455},"pii_replacements":0,"gap":false}},{"input":{"settings":{"pii_scrub_logs":true,"json_parse_logs":true},"record":{"uuid":"u57","trace_id":null,"span_id":{"$bytes":"9205f0dc8db355ac"},"trace_flags":null,"timestamp":1736943732035000,"observed_timestamp":1736944633250000,"body":"5.3fa85f64-5717-4562-b3fc-2c963f66afa6 0b11","severity_text":null,"severity_number":17,"service_name":"","resource_attributes":{"k8s.pod.name":"\"\\\"9007199254740993\\\\r\\\\n10 \\\"\"","host":"\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\"","constructor":"123456789012345680000","service.name":"\"-Infinity\"","a":"2.5e-8"},"instrumentation_scope":null,"event_name":"request","attributes":{"payload.x":"\" \"","status_code":"\"error\"","payload":"{\"a\":2.5e-8,\"arr\":[1,[2,{\"b\":null}]],\"s\"\\ud83d:\"x\"\\/}"},"bytes_uncompressed":1271}},"output":{"record":{"uuid":"u57","trace_id":null,"span_id":{"$bytes":"9205f0dc8db355ac"},"trace_flags":null,"timestamp":1736943732035000,"observed_timestamp":1736944633250000,"body":"5.3fa85f64-5717-4562-b3fc-2c963f66afa6 0b11","severity_text":null,"severity_number":17,"service_name":"","resource_attributes":{"k8s.pod.name":"\"\\\"9007199254740993\\\\r\\\\n10 \\\"\"","host":"\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\"","constructor":"123456789012345680000","service.name":"\"-Infinity\"","a":"2.5e-8"},"instrumentation_scope":null,"event_name":"request","attributes":{"payload.x":"\" \"","status_code":"\"error\"","payload":"{\"a\":2.5e-8,\"arr\":[1,[2,{\"b\":null}]],\"s\"\\ud83d:\"x\"\\/}"},"bytes_uncompressed":1271},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u58","trace_id":{"$bytes":"c80da1d009cbf13adef606ddec816549"},"span_id":{"$bytes":"eb22e748d157595f"},"trace_flags":null,"timestamp":1736942778420000,"observed_timestamp":1736944633250000,"body":"9007199254740992","severity_text":"trace","severity_number":21,"service_name":"worker","resource_attributes":{"1":"0.1","constructor":"\"\\\"\"","service.name":"\"\\\\\"","host":"123456789012345680000","k8s.pod.name":"0.1"},"instrumentation_scope":null,"event_name":"request","attributes":null,"bytes_uncompressed":null}},"output":{"record":{"uuid":"u58","trace_id":{"$bytes":"c80da1d009cbf13adef606ddec816549"},"span_id":{"$bytes":"eb22e748d157595f"},"trace_flags":null,"timestamp":1736942778420000,"observed_timestamp":1736944633250000,"body":"9007199254740992","severity_text":"trace","severity_number":21,"service_name":"worker","resource_attributes":{"1":"0.1","constructor":"\"\\\"\"","service.name":"\"\\\\\"","host":"123456789012345680000","k8s.pod.name":"0.1"},"instrumentation_scope":null,"event_name":"request","attributes":null,"bytes_uncompressed":null},"pii_replacements":0,"gap":false}},{"input":{"settings":{"pii_scrub_logs":true},"record":{"uuid":"u60","trace_id":{"$bytes":"dc2e982bc414b29cb7035b36bd1b27f3"},"span_id":{"$bytes":"713e6a314797d4a9"},"trace_flags":null,"timestamp":1736943846710000,"observed_timestamp":1736944633250000,"body":"12 Wed, 15 Jan 2025 12:00:00 GMT K","severity_text":"Warn","severity_number":17,"service_name":"web","resource_attributes":null,"instrumentation_scope":null,"event_name":"","attributes":{"payload.x":"\"\\\"0b11\\\"\"","payload":"\"{\\\"a\\\":\\\"12\\\",\\\"arr\\\":[1,[2,{\\\"b\\\":nu\""},"bytes_uncompressed":92}},"output":{"record":{"uuid":"u60","trace_id":{"$bytes":"dc2e982bc414b29cb7035b36bd1b27f3"},"span_id":{"$bytes":"713e6a314797d4a9"},"trace_flags":null,"timestamp":1736943846710000,"observed_timestamp":1736944633250000,"body":"12 Wed, 15 Jan 2025 12:00:00 GMT K","severity_text":"Warn","severity_number":17,"service_name":"web","resource_attributes":null,"instrumentation_scope":null,"event_name":"","attributes":{"payload.x":"\"\\\"0b11\\\"\"","payload":"\"{\\\"a\\\":\\\"12\\\",\\\"arr\\\":[1,[2,{\\\"b\\\":nu\""},"bytes_uncompressed":92},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"1"},"record":{"uuid":"u61","trace_id":{"$bytes":"4415a41d1a99b59363598e89095b9251"},"span_id":null,"trace_flags":null,"timestamp":1736942692347000,"observed_timestamp":1736944633250000,"body":"100","severity_text":"","severity_number":13,"service_name":"","resource_attributes":{"k8s.pod.name":"\"{\\\"1\\\":false,\\\"10\\\":\\\"NaN\\\",\\\"4294967295\\\":false,\\\"01\\\":{\\\"4294967295\\\":\\\"error\\\",\\\"a.\\\":\\\"Infinity \\\"}}\"","host":"\"[{\\\"5\\\":{\\\"level\\\":\\\"user_12312 debug\\\",\\\"1.5 \\\":[],\\\"'\\\":{\\\"2\\\":\\\"Infinity\\\"}},\\\"12345678\\\":\\\"0b110.000001__proto__\\\"},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\"","\t":"0","a":"Infinity"},"instrumentation_scope":null,"event_name":null,"attributes":{"0":"\"sender\"","payload":"null","k8s.pod.name":"a\\nb","a":"\"sender\"","k":"\"[1,2]\"","..":"\" \"","http.path":"\"12\"","01":"999.9999999","payload.a":"\"sender\"","message":"\"sender\""},"bytes_uncompressed":1484}},"output":{"record":{"uuid":"u61","trace_id":{"$bytes":"4415a41d1a99b59363598e89095b9251"},"span_id":null,"trace_flags":null,"timestamp":1736942692347000,"observed_timestamp":1736944633250000,"body":"100","severity_text":"","severity_number":13,"service_name":"","resource_attributes":{"k8s.pod.name":"\"{\\\"1\\\":false,\\\"10\\\":\\\"NaN\\\",\\\"4294967295\\\":false,\\\"01\\\":{\\\"4294967295\\\":\\\"error\\\",\\\"a.\\\":\\\"Infinity \\\"}}\"","host":"\"[{\\\"5\\\":{\\\"level\\\":\\\"user_12312 debug\\\",\\\"1.5 \\\":[],\\\"'\\\":{\\\"2\\\":\\\"Infinity\\\"}},\\\"12345678\\\":\\\"0b110.000001__proto__\\\"},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\"","\t":"0","a":"Infinity"},"instrumentation_scope":null,"event_name":null,"attributes":{"0":"\"sender\"","payload":"null","k8s.pod.name":"a\\nb","a":"\"sender\"","k":"\"[1,2]\"","..":"\" \"","http.path":"\"12\"","01":"999.9999999","payload.a":"\"sender\"","message":"\"sender\""},"bytes_uncompressed":1484},"pii_replacements":0,"gap":false}},{"input":{"settings":{"pii_scrub_logs":true,"json_parse_logs":true},"record":{"uuid":"u62","trace_id":{"$bytes":"3bb544f5a74c12bf"},"span_id":{"$bytes":"7ece1f10e08cc703"},"trace_flags":null,"timestamp":1736943968917000,"observed_timestamp":1736944633250000,"body":"\"9007199254740992 \\\"quoted\\\"\"","severity_text":"İnfo","severity_number":21,"service_name":"web","resource_attributes":{"1":"Wed, 15 Jan 2025 12:00:00 GMT 1.7976931348623157e+308 12","service.name":"\"{\\\"a\\\":1}\""},"instrumentation_scope":null,"event_name":"","attributes":{"http.route":"true","k1":"\"sender\"","n3":"\"sender\"","message":"\"sender\""},"bytes_uncompressed":null}},"output":{"record":{"uuid":"u62","trace_id":{"$bytes":"3bb544f5a74c12bf"},"span_id":{"$bytes":"7ece1f10e08cc703"},"trace_flags":null,"timestamp":1736943968917000,"observed_timestamp":1736944633250000,"body":"\"9007199254740992 \\\"quoted\\\"\"","severity_text":"İnfo","severity_number":21,"service_name":"web","resource_attributes":{"1":"Wed, 15 Jan 2025 12:00:00 GMT 1.7976931348623157e+308 12","service.name":"\"{\\\"a\\\":1}\""},"instrumentation_scope":null,"event_name":"","attributes":{"http.route":"true","k1":"\"sender\"","n3":"\"sender\"","message":"\"sender\""},"bytes_uncompressed":null},"pii_replacements":0,"gap":false}},{"input":{"settings":{"pii_scrub_logs":true},"record":{"uuid":"u63","trace_id":{"$bytes":"e008a3ce81990d99f585d35f4b0654e4"},"span_id":{"$bytes":"660e873b3f6e88c2"},"trace_flags":null,"timestamp":1736943132022000,"observed_timestamp":1736944633250000,"body":"true","severity_text":null,"severity_number":13,"service_name":"API","resource_attributes":{"1":"-1","constructor":"null","hasOwnProperty":"\"{\\\"10\\\":{\\\"0\\\":null,\\\"payload\\\":\\\"fatallevel\\\",\\\"4294967295\\\":null},\\\"payload\\\":\\\" 12 \\\",\\\"\\\\\\\"\\\":\\\"ghp_0123456789abcdefghij0123456789abcdef2001:db8::1\\\",\\\"level\\\":false}\""},"instrumentation_scope":null,"event_name":null,"attributes":null,"bytes_uncompressed":1166}},"output":{"record":{"uuid":"u63","trace_id":{"$bytes":"e008a3ce81990d99f585d35f4b0654e4"},"span_id":{"$bytes":"660e873b3f6e88c2"},"trace_flags":null,"timestamp":1736943132022000,"observed_timestamp":1736944633250000,"body":"true","severity_text":null,"severity_number":13,"service_name":"API","resource_attributes":{"1":"-1","constructor":"null","hasOwnProperty":"\"{\\\"10\\\":{\\\"0\\\":null,\\\"payload\\\":\\\"fatallevel\\\",\\\"4294967295\\\":null},\\\"payload\\\":\\\" 12 \\\",\\\"\\\\\\\"\\\":\\\"ghp_0123456789abcdefghij0123456789abcdef2001:db8::1\\\",\\\"level\\\":false}\""},"instrumentation_scope":null,"event_name":null,"attributes":null,"bytes_uncompressed":1166},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true},"record":{"uuid":"u64","trace_id":{"$bytes":"0a067926ba983cfc39597cd211abac33"},"span_id":{"$bytes":"159842c7f18c8ee0"},"trace_flags":null,"timestamp":1736944218578000,"observed_timestamp":1736944633250000,"body":"\"9007199254740994 \\\\ERROR\"","severity_text":"ERRor","severity_number":1,"service_name":null,"resource_attributes":{"service.name":"\"[1,2]\""},"instrumentation_scope":null,"event_name":null,"attributes":{"a.b":"\"192.168.1.1\"","é":"ghp_0123456789abcdefghij0123456789abcdef 12 12 ","name":"\" \"","a":"0x10","level":"0","http.status_code":"4294967294","status_code":"0.30000000000000004","payload":"\"\\\"{\\\\\\\"a\\\\\\\":\\\\\\\"payload\\\\\\\",\\\\\\\"arr\\\\\\\"\\\\\\\\\\\\\\\\:[1,[2,{\\\\\\\"b\\\\\\\":null}]],\\\\\\\"s\\\\\\\":\\\\\\\"x\\\\\\\"}\\\"\""},"bytes_uncompressed":1554}},"output":{"record":{"uuid":"u64","trace_id":{"$bytes":"0a067926ba983cfc39597cd211abac33"},"span_id":{"$bytes":"159842c7f18c8ee0"},"trace_flags":null,"timestamp":1736944218578000,"observed_timestamp":1736944633250000,"body":"\"9007199254740994 \\\\ERROR\"","severity_text":"ERRor","severity_number":1,"service_name":null,"resource_attributes":{"service.name":"\"[1,2]\""},"instrumentation_scope":null,"event_name":null,"attributes":{"a.b":"\"192.168.1.1\"","é":"ghp_0123456789abcdefghij0123456789abcdef 12 12 ","name":"\" \"","a":"0x10","level":"0","http.status_code":"4294967294","status_code":"0.30000000000000004","payload":"\"\\\"{\\\\\\\"a\\\\\\\":\\\\\\\"payload\\\\\\\",\\\\\\\"arr\\\\\\\"\\\\\\\\\\\\\\\\:[1,[2,{\\\\\\\"b\\\\\\\":null}]],\\\\\\\"s\\\\\\\":\\\\\\\"x\\\\\\\"}\\\"\""},"bytes_uncompressed":1554},"pii_replacements":0,"gap":false}},{"input":{"settings":{"pii_scrub_logs":true,"json_parse_logs":true},"record":{"uuid":"u67","trace_id":null,"span_id":{"$bytes":"0b1ed5f06c20d6fe"},"trace_flags":null,"timestamp":1736944540774000,"observed_timestamp":1736944633250000,"body":"true","severity_text":"fatal","severity_number":9,"service_name":"web","resource_attributes":{"host":"true","service.name":"0.30000000000000004","0o7":"\"ghp_0123456789abcdefghij0123456789abcdef\"","a":"ERRORerror"},"instrumentation_scope":null,"event_name":"request","attributes":null,"bytes_uncompressed":1751}},"output":{"record":{"uuid":"u67","trace_id":null,"span_id":{"$bytes":"0b1ed5f06c20d6fe"},"trace_flags":null,"timestamp":1736944540774000,"observed_timestamp":1736944633250000,"body":"true","severity_text":"fatal","severity_number":9,"service_name":"web","resource_attributes":{"host":"true","service.name":"0.30000000000000004","0o7":"\"ghp_0123456789abcdefghij0123456789abcdef\"","a":"ERRORerror"},"instrumentation_scope":null,"event_name":"request","attributes":null,"bytes_uncompressed":1751},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"a"},"record":{"uuid":"u68","trace_id":{"$bytes":"ecbc848ad9097942ffbfc56be06439e9"},"span_id":{"$bytes":"6237653f20085b55"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"{\"2\":\"1e3 [1,2] \",\".a\":0.000001}","severity_text":"info","severity_number":9,"service_name":null,"resource_attributes":{"host":"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 GET","k8s.pod.name":"2.5e-8"},"instrumentation_scope":null,"event_name":null,"attributes":{"a":"\"sender\"","k1":"\"sender\"","n3":"\"sender\"","msg":"\"sender\""},"bytes_uncompressed":682}},"output":{"record":{"uuid":"u68","trace_id":{"$bytes":"ecbc848ad9097942ffbfc56be06439e9"},"span_id":{"$bytes":"6237653f20085b55"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"{\"2\":\"1e3 [1,2] \",\".a\":0.000001}","severity_text":"info","severity_number":9,"service_name":null,"resource_attributes":{"host":"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 GET","k8s.pod.name":"2.5e-8"},"instrumentation_scope":null,"event_name":null,"attributes":{"2":"\"1e3 [1,2] \"",".a":"0.000001","a":"\"sender\"","k1":"\"sender\"","n3":"\"sender\"","msg":"\"sender\""},"bytes_uncompressed":682},"pii_replacements":0,"gap":false}},{"input":{"settings":{"pii_scrub_logs":true},"record":{"uuid":"u69","trace_id":null,"span_id":{"$bytes":"14403ffe9da3140a"},"trace_flags":null,"timestamp":1736943985509000,"observed_timestamp":1736944633250000,"body":"\"\\u0000Bearer abc.def-ghi\"","severity_text":"debug ","severity_number":-1,"service_name":"worker","resource_attributes":{"1":"\" \"","a":"\"\\\"-Infinity{\\\\\\\"a\\\\\\\":1}true\\\"\"","http.method":"[{\"0\":null,\"4294967294\":{},\"user_123\":\"2\",\"http.method\":\"Wed, 15 Jan 2025 12:00:00 GMT900719925474099412.5abc\",\"192.168.0.1\":\"msg 0o7 \"}]","host":"4294967295"},"instrumentation_scope":null,"event_name":null,"attributes":{"0":"\"Bearer abc.def-ghi\"","é":"\"\\\"+5 \\\\r\\\\n0x10\\\"\"","http.status_code":"POSTsk_live_0123456789abcdefghijkl","service.name":"9007199254740994","level":"\" \""},"bytes_uncompressed":920}},"output":{"record":{"uuid":"u69","trace_id":null,"span_id":{"$bytes":"14403ffe9da3140a"},"trace_flags":null,"timestamp":1736943985509000,"observed_timestamp":1736944633250000,"body":"\"\\u0000Bearer {{REDACTED}}\"","severity_text":"debug ","severity_number":-1,"service_name":"worker","resource_attributes":{"1":"\" \"","a":"\"\\\"-Infinity{\\\\\\\"a\\\\\\\":1}true\\\"\"","http.method":"[{\"0\":null,\"4294967294\":{},\"user_123\":\"2\",\"http.method\":\"Wed, 15 Jan 2025 12:00:00 GMT900719925474099412.5abc\",\"192.168.0.1\":\"msg 0o7 \"}]","host":"4294967295"},"instrumentation_scope":null,"event_name":null,"attributes":{"0":"\"Bearer {{REDACTED}}\"","é":"\"\\\"+5 \\\\r\\\\n0x10\\\"\"","http.status_code":"POSTsk_live_0123456789abcdefghijkl","service.name":"9007199254740994","level":"\" \""},"bytes_uncompressed":920},"pii_replacements":2,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"pii_scrub_logs":true,"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u70","trace_id":{"$bytes":"e7d55239335e76e73ec50c52d5ec0c06"},"span_id":null,"trace_flags":null,"timestamp":1736943729915000,"observed_timestamp":1736944633250000,"body":"[null,-4.2293482925742866e-21,\"0sk_live_0123456789abcdefghijkl \",{\"51\":[{},999.9999999,\"🚀ghp_0123456789abcdefghij0123456789abcdef-Infinity\"],\"\":null},1,1,1,1,1,1]","severity_text":"INFO","severity_number":12,"service_name":"","resource_attributes":{"1":"4294967294","constructor":"\"Infinity\"","a":"\"\\u000b \"","k8s.pod.name":"100"},"instrumentation_scope":null,"event_name":"","attributes":{"k":"4294967294","message":"5e-324 0x10","é":"\"\\\\\""},"bytes_uncompressed":1624}},"output":{"record":{"uuid":"u70","trace_id":{"$bytes":"e7d55239335e76e73ec50c52d5ec0c06"},"span_id":null,"trace_flags":null,"timestamp":1736943729915000,"observed_timestamp":1736944633250000,"body":"[null,-4.2293482925742866e-21,\"0sk_live_0123456789abcdefghijkl \",{\"51\":[{},999.9999999,\"🚀{{REDACTED}}-Infinity\"],\"\":null},1,1,1,1,1,1]","severity_text":"INFO","severity_number":12,"service_name":"","resource_attributes":{"1":"4294967294","constructor":"\"Infinity\"","a":"\"\\u000b \"","k8s.pod.name":"100"},"instrumentation_scope":null,"event_name":"","attributes":{"0":"\"null\"","1":"-4.2293482925742866e-21","2":"\"0sk_live_0123456789abcdefghijkl \"","4":"1","5":"1","6":"1","7":"1","8":"1","9":"1","3.51.1":"999.9999999","3.51.2":"\"🚀{{REDACTED}}-Infinity\"","3.":"\"null\"","k":"4294967294","message":"5e-324 0x10","é":"\"\\\\\""},"bytes_uncompressed":1624},"pii_replacements":1,"gap":false}},{"input":{"settings":{"pii_scrub_logs":true,"json_parse_logs":true},"record":{"uuid":"u72","trace_id":{"$bytes":"21a8483fc789e4fd16c96ca50e243ff8"},"span_id":{"$bytes":"02721c0a893a238c"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"\"7 \"","severity_text":"İnfo","severity_number":0,"service_name":"web","resource_attributes":{"12345678":"false","service.name":"GET","constructor":"a.b1.5"},"instrumentation_scope":null,"event_name":"request","attributes":{"payload":"\"{\\\"a\\\":123456789012345680000,\\\"arr\\\":[1,[2,{\\\"b\\\":null}]],\"","a":"\"sender\"","payload.a":"\"sender\""},"bytes_uncompressed":null}},"output":{"record":{"uuid":"u72","trace_id":{"$bytes":"21a8483fc789e4fd16c96ca50e243ff8"},"span_id":{"$bytes":"02721c0a893a238c"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"\"7 \"","severity_text":"İnfo","severity_number":0,"service_name":"web","resource_attributes":{"12345678":"false","service.name":"GET","constructor":"a.b1.5"},"instrumentation_scope":null,"event_name":"request","attributes":{"payload":"\"{\\\"a\\\":123456789012345680000,\\\"arr\\\":[1,[2,{\\\"b\\\":null}]],\"","a":"\"sender\"","payload.a":"\"sender\""},"bytes_uncompressed":null},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"1"},"record":{"uuid":"u74","trace_id":{"$bytes":"d54d644eb696241d"},"span_id":null,"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"false","severity_text":"ERROR","severity_number":12,"service_name":null,"resource_attributes":{"a":"\"AKIAIOSFODNN7EXAMPLE\""},"instrumentation_scope":null,"event_name":"request","attributes":{"http.route":"5e-324","path":"\"\\r\\n\"","k1":"\"sender\"","msg":"\"sender\""},"bytes_uncompressed":473}},"output":{"record":{"uuid":"u74","trace_id":{"$bytes":"d54d644eb696241d"},"span_id":null,"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"false","severity_text":"ERROR","severity_number":12,"service_name":null,"resource_attributes":{"a":"\"AKIAIOSFODNN7EXAMPLE\""},"instrumentation_scope":null,"event_name":"request","attributes":{"http.route":"5e-324","path":"\"\\r\\n\"","k1":"\"sender\"","msg":"\"sender\""},"bytes_uncompressed":473},"pii_replacements":0,"gap":false}},{"input":{"settings":{"pii_scrub_logs":true,"json_parse_logs":true},"record":{"uuid":"u75","trace_id":null,"span_id":{"$bytes":"af4e88cda75cd462"},"trace_flags":null,"timestamp":1736944360503000,"observed_timestamp":1736944633250000,"body":"true","severity_text":"fatal","severity_number":17,"service_name":null,"resource_attributes":{"a":"\"{\\\"2\\\":{\\\"user.email\\\":{\\\".a\\\":7,\\\"full\\\":false},\\\"4294967295\\\":false,\\\"host.example.com\\\":\\\"\\\\n21e+21\\\"},\\\"51\\\":-3.900035496335476e-8}\"","length":"-1","host":"\"ghp_0123456789abcdefghij0123456789abcdef\"","k8s.pod.name":"\".5eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\""},"instrumentation_scope":null,"event_name":null,"attributes":{"url.path":"\"debug\"","user.email":"\"1e400\"","payload":"\"{\\\"a\\\":\\\"\\\\u2028 \\\",\\\"a\"","a":"\"sender\""},"bytes_uncompressed":660}},"output":{"record":{"uuid":"u75","trace_id":null,"span_id":{"$bytes":"af4e88cda75cd462"},"trace_flags":null,"timestamp":1736944360503000,"observed_timestamp":1736944633250000,"body":"true","severity_text":"fatal","severity_number":17,"service_name":null,"resource_attributes":{"a":"\"{\\\"2\\\":{\\\"user.email\\\":{\\\".a\\\":7,\\\"full\\\":false},\\\"4294967295\\\":false,\\\"host.example.com\\\":\\\"\\\\n21e+21\\\"},\\\"51\\\":-3.900035496335476e-8}\"","length":"-1","host":"\"ghp_0123456789abcdefghij0123456789abcdef\"","k8s.pod.name":"\".5eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\""},"instrumentation_scope":null,"event_name":null,"attributes":{"url.path":"\"debug\"","user.email":"\"1e400\"","payload":"\"{\\\"a\\\":\\\"\\\\u2028 \\\",\\\"a\"","a":"\"sender\""},"bytes_uncompressed":660},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true},"record":{"uuid":"u76","trace_id":{"$bytes":"48ab652399d7905280425e9f04575efc"},"span_id":{"$bytes":"efce8ce2ebf00797"},"trace_flags":null,"timestamp":1736943613618000,"observed_timestamp":1736944633250000,"body":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 0b11\"","severity_text":"DEBUG","severity_number":12,"service_name":"API","resource_attributes":{"1":"\"12\""},"instrumentation_scope":null,"event_name":"request","attributes":{"1,5 ":"ghp_0123456789abcdefghij0123456789abcdef"},"bytes_uncompressed":239}},"output":{"record":{"uuid":"u76","trace_id":{"$bytes":"48ab652399d7905280425e9f04575efc"},"span_id":{"$bytes":"efce8ce2ebf00797"},"trace_flags":null,"timestamp":1736943613618000,"observed_timestamp":1736944633250000,"body":"\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 0b11\"","severity_text":"DEBUG","severity_number":12,"service_name":"API","resource_attributes":{"1":"\"12\""},"instrumentation_scope":null,"event_name":"request","attributes":{"1,5 ":"ghp_0123456789abcdefghij0123456789abcdef"},"bytes_uncompressed":239},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"constructor"},"record":{"uuid":"u77","trace_id":null,"span_id":null,"trace_flags":null,"timestamp":1736943674359000,"observed_timestamp":1736944633250000,"body":" 12eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123.a","severity_text":"trace","severity_number":12,"service_name":"web","resource_attributes":{"1":"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé 4294967295 12 ","a":"4294967294"},"instrumentation_scope":null,"event_name":null,"attributes":{"é":"/api/v1/users/123","url.path":"false","event":"\"{\\\"1\\\":-1,\\\"\\\\\\\\\\\":{\\\"1\\\":null,\\\"5\\\":false,\\\"deadbeef\\\":true,\\\"b\\\":true,\\\"a\\\":1.5}}\"","k1":"\"sender\""},"bytes_uncompressed":16}},"output":{"record":{"uuid":"u77","trace_id":null,"span_id":null,"trace_flags":null,"timestamp":1736943674359000,"observed_timestamp":1736944633250000,"body":" 12eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123.a","severity_text":"trace","severity_number":12,"service_name":"web","resource_attributes":{"1":"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé 4294967295 12 ","a":"4294967294"},"instrumentation_scope":null,"event_name":null,"attributes":{"é":"/api/v1/users/123","url.path":"false","event":"\"{\\\"1\\\":-1,\\\"\\\\\\\\\\\":{\\\"1\\\":null,\\\"5\\\":false,\\\"deadbeef\\\":true,\\\"b\\\":true,\\\"a\\\":1.5}}\"","k1":"\"sender\""},"bytes_uncompressed":16},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"1"},"record":{"uuid":"u80","trace_id":{"$bytes":"76c30329cad4cfd242d4b708159c8c06"},"span_id":null,"trace_flags":null,"timestamp":1736942654281000,"observed_timestamp":1736944633250000,"body":"\"12 \"","severity_text":"WARN","severity_number":9,"service_name":null,"resource_attributes":{"host":"\"日本語\"","k8s.pod.name":"\" \""},"instrumentation_scope":null,"event_name":null,"attributes":{"payload.x":"\"[]\"","":"null","a":"null","kind":"\"{\\\"12345678\\\":{\\\"10\\\":null,\\\"é\\\":false,\\\"k\\\":254189332015812380},\\\"hasOwnProperty\\\":null,\\\"level\\\":\\\"0.000001 é 1e+100\\\",\\\"1e3\\\":[]}\"","count":"\"K10\"","path":"999.9999999"},"bytes_uncompressed":1283}},"output":{"record":{"uuid":"u80","trace_id":{"$bytes":"76c30329cad4cfd242d4b708159c8c06"},"span_id":null,"trace_flags":null,"timestamp":1736942654281000,"observed_timestamp":1736944633250000,"body":"\"12 \"","severity_text":"WARN","severity_number":9,"service_name":null,"resource_attributes":{"host":"\"日本語\"","k8s.pod.name":"\" \""},"instrumentation_scope":null,"event_name":null,"attributes":{"payload.x":"\"[]\"","":"null","a":"null","kind":"\"{\\\"12345678\\\":{\\\"10\\\":null,\\\"é\\\":false,\\\"k\\\":254189332015812380},\\\"hasOwnProperty\\\":null,\\\"level\\\":\\\"0.000001 é 1e+100\\\",\\\"1e3\\\":[]}\"","count":"\"K10\"","path":"999.9999999"},"bytes_uncompressed":1283},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"constructor"},"record":{"uuid":"u81","trace_id":{"$bytes":"363f9cbc51d1e3e5cb85b280eb59e37e"},"span_id":{"$bytes":"fd55a815a050b2fd"},"trace_flags":null,"timestamp":1736943587424000,"observed_timestamp":1736944633250000,"body":"null","severity_text":"info","severity_number":12,"service_name":"worker","resource_attributes":{"service.name":"[\" [email protected]12 \",false,true,\" 0x10-0 \",{\"𑄦 \":[\"true a. \",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]"},"instrumentation_scope":null,"event_name":"","attributes":{"toString":"\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"","ms":"\"0o7\"","level":"\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\"","payload.x":"\"1_000\""},"bytes_uncompressed":1338}},"output":{"record":{"uuid":"u81","trace_id":{"$bytes":"363f9cbc51d1e3e5cb85b280eb59e37e"},"span_id":{"$bytes":"fd55a815a050b2fd"},"trace_flags":null,"timestamp":1736943587424000,"observed_timestamp":1736944633250000,"body":"null","severity_text":"info","severity_number":12,"service_name":"worker","resource_attributes":{"service.name":"[\" [email protected]12 \",false,true,\" 0x10-0 \",{\"𑄦 \":[\"true a. \",1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]"},"instrumentation_scope":null,"event_name":"","attributes":{"toString":"\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"","ms":"\"0o7\"","level":"\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\"","payload.x":"\"1_000\""},"bytes_uncompressed":1338},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"1"},"record":{"uuid":"u83","trace_id":null,"span_id":{"$bytes":"70ef4577efdd57e7"},"trace_flags":null,"timestamp":1736943506442000,"observed_timestamp":1736944633250000,"body":"null","severity_text":"DEBUG","severity_number":9,"service_name":"","resource_attributes":{"..":"\"false\"","a":"192.168.1.1","":"__proto__\r\n100 ","service.name":"\"[\\\" 12 {\\\\\\\"a\\\\\\\":1}\\\",[false,[null],[],\\\".a0\\\",1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\"","host":"\u000b"},"instrumentation_scope":null,"event_name":"request","attributes":{"1":"\"\\\"{\\\\\\\"a\\\\\\\":2.5e-8,\\\\\\\"arr\\\\\\\":[1,[2,{\\\\\\\"b\\\\\\\":null}]],\\\\\\\"s\\\\\\\":\\\\\\\"x\\\\\\\"}\\\"\"","payload.x":"1e-7"},"bytes_uncompressed":320}},"output":{"record":{"uuid":"u83","trace_id":null,"span_id":{"$bytes":"70ef4577efdd57e7"},"trace_flags":null,"timestamp":1736943506442000,"observed_timestamp":1736944633250000,"body":"null","severity_text":"DEBUG","severity_number":9,"service_name":"","resource_attributes":{"..":"\"false\"","a":"192.168.1.1","":"__proto__\r\n100 ","service.name":"\"[\\\" 12 {\\\\\\\"a\\\\\\\":1}\\\",[false,[null],[],\\\".a0\\\",1,1,1,1,1,1],1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\"","host":"\u000b"},"instrumentation_scope":null,"event_name":"request","attributes":{"1":"\"\\\"{\\\\\\\"a\\\\\\\":2.5e-8,\\\\\\\"arr\\\\\\\":[1,[2,{\\\\\\\"b\\\\\\\":null}]],\\\\\\\"s\\\\\\\":\\\\\\\"x\\\\\\\"}\\\"\"","payload.x":"1e-7"},"bytes_uncompressed":320},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"a"},"record":{"uuid":"u85","trace_id":null,"span_id":{"$bytes":"985798866b40fb0c"},"trace_flags":null,"timestamp":1736942777124000,"observed_timestamp":1736944633250000,"body":" \"eventuser_123valueOf \"\n","severity_text":"trace","severity_number":1,"service_name":"worker","resource_attributes":{},"instrumentation_scope":null,"event_name":null,"attributes":{"1":"-1","é":"\"GET\"","ms":"4294967294","path":"1e-7","a":"\"{\\\"a\\\":12.5,\\\"arr\\\":\""},"bytes_uncompressed":null}},"output":{"record":{"uuid":"u85","trace_id":null,"span_id":{"$bytes":"985798866b40fb0c"},"trace_flags":null,"timestamp":1736942777124000,"observed_timestamp":1736944633250000,"body":" \"eventuser_123valueOf \"\n","severity_text":"trace","severity_number":1,"service_name":"worker","resource_attributes":{},"instrumentation_scope":null,"event_name":null,"attributes":{"1":"-1","é":"\"GET\"","ms":"4294967294","path":"1e-7","a":"\"{\\\"a\\\":12.5,\\\"arr\\\":\""},"bytes_uncompressed":null},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true},"record":{"uuid":"u86","trace_id":{"$bytes":"bc3fe70bf396fccc"},"span_id":{"$bytes":"2c5614e4b6c549a2"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"null","severity_text":"DEBUG","severity_number":-1,"service_name":"","resource_attributes":{"1":"4294967294",".5":"\"[\\\"1e+21 warn\\\",true,false,true,0.1,false,\\\"\\\\r\\\\n\\\",1,1,1]\"","service.name":"\u000b192.168.0.10.000001","constructor":"日本語x","a":"[email protected]","..":"\"a\\\\nb\""},"instrumentation_scope":null,"event_name":"request","attributes":{"0":"\"sender\"","event":"\"{\\\"2025-01-15T10:00:00Z\\\":1.7976931348623157e+308,\\\"\\\\\\\"quoted\\\\\\\" \\\":\\\"﮵ \\\"}\"","n3":"\"sender\""},"bytes_uncompressed":88}},"output":{"record":{"uuid":"u86","trace_id":{"$bytes":"bc3fe70bf396fccc"},"span_id":{"$bytes":"2c5614e4b6c549a2"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"null","severity_text":"DEBUG","severity_number":-1,"service_name":"","resource_attributes":{"1":"4294967294",".5":"\"[\\\"1e+21 warn\\\",true,false,true,0.1,false,\\\"\\\\r\\\\n\\\",1,1,1]\"","service.name":"\u000b192.168.0.10.000001","constructor":"日本語x","a":"[email protected]","..":"\"a\\\\nb\""},"instrumentation_scope":null,"event_name":"request","attributes":{"0":"\"sender\"","event":"\"{\\\"2025-01-15T10:00:00Z\\\":1.7976931348623157e+308,\\\"\\\\\\\"quoted\\\\\\\" \\\":\\\"﮵ \\\"}\"","n3":"\"sender\""},"bytes_uncompressed":88},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u88","trace_id":{"$bytes":"58082a56cefe292b"},"span_id":{"$bytes":"e3e85f399c07c253"},"trace_flags":null,"timestamp":1736942784901000,"observed_timestamp":1736944633250000,"body":" null\n","severity_text":"WARN","severity_number":0,"service_name":"web","resource_attributes":{"service.name":"0.1","k8s.pod.name":"true","host":"\"12\"","event":"9007199254740994"},"instrumentation_scope":null,"event_name":null,"attributes":{"payload.0":"[]","payload.x":"0","severity_text":"false","valueOf":"1e+100","http.status_code":"\"host.example.com","payload":"\"\\\"{\\\\\\\"a\\\\\\\":\\\\\\\"\\\\\\\\\\\\\\\" 0x10 \\\\\\\",\\\\\\\"arr\\\\\\\":[1,[2,{\\\\\\\"b\\\\\\\":null}]],\\\\\\\"s\\\\\\\":\\\\\\\"x\\\\\\\"}\\\"\""},"bytes_uncompressed":1346}},"output":{"record":{"uuid":"u88","trace_id":{"$bytes":"58082a56cefe292b"},"span_id":{"$bytes":"e3e85f399c07c253"},"trace_flags":null,"timestamp":1736942784901000,"observed_timestamp":1736944633250000,"body":" null\n","severity_text":"WARN","severity_number":0,"service_name":"web","resource_attributes":{"service.name":"0.1","k8s.pod.name":"true","host":"\"12\"","event":"9007199254740994"},"instrumentation_scope":null,"event_name":null,"attributes":{"payload.0":"[]","payload.x":"0","severity_text":"false","valueOf":"1e+100","http.status_code":"\"host.example.com","payload":"\"\\\"{\\\\\\\"a\\\\\\\":\\\\\\\"\\\\\\\\\\\\\\\" 0x10 \\\\\\\",\\\\\\\"arr\\\\\\\":[1,[2,{\\\\\\\"b\\\\\\\":null}]],\\\\\\\"s\\\\\\\":\\\\\\\"x\\\\\\\"}\\\"\""},"bytes_uncompressed":1346},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"constructor"},"record":{"uuid":"u89","trace_id":{"$bytes":"3acd701883cb93dc3916e46752efc469"},"span_id":null,"trace_flags":null,"timestamp":1736943332533000,"observed_timestamp":1736944633250000,"body":"-4462819357868284","severity_text":"info","severity_number":0,"service_name":"worker","resource_attributes":null,"instrumentation_scope":null,"event_name":"","attributes":{"0":"\"sender\"","constructor":"\"{\\\"a\\\":1.5,\\\"arr\\\":[1,[2\"","a":"\"sender\"","payload.a":"\"sender\"","msg":"\"sender\""},"bytes_uncompressed":null}},"output":{"record":{"uuid":"u89","trace_id":{"$bytes":"3acd701883cb93dc3916e46752efc469"},"span_id":null,"trace_flags":null,"timestamp":1736943332533000,"observed_timestamp":1736944633250000,"body":"-4462819357868284","severity_text":"info","severity_number":0,"service_name":"worker","resource_attributes":null,"instrumentation_scope":null,"event_name":"","attributes":{"0":"\"sender\"","constructor":"\"{\\\"a\\\":1.5,\\\"arr\\\":[1,[2\"","a":"\"sender\"","payload.a":"\"sender\"","msg":"\"sender\""},"bytes_uncompressed":null},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true},"record":{"uuid":"u90","trace_id":{"$bytes":""},"span_id":null,"trace_flags":null,"timestamp":1736943550699000,"observed_timestamp":1736944633250000,"body":"\"192.168.0.1ghp_0123456789abcdefghij0123456789abcdef \"","severity_text":null,"severity_number":13,"service_name":"worker","resource_attributes":{"1":"\"debug\"","1e3":"\"\\u000b\"","host":"999.9999999","..":"\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\"","k8s.pod.name":"\"3fa85f64-5717-4562-b3fc-2c963f66afa6\""},"instrumentation_scope":null,"event_name":null,"attributes":{"valueOf":"{\"a\":1}","severity_text":"true"},"bytes_uncompressed":466}},"output":{"record":{"uuid":"u90","trace_id":{"$bytes":""},"span_id":null,"trace_flags":null,"timestamp":1736943550699000,"observed_timestamp":1736944633250000,"body":"\"192.168.0.1ghp_0123456789abcdefghij0123456789abcdef \"","severity_text":null,"severity_number":13,"service_name":"worker","resource_attributes":{"1":"\"debug\"","1e3":"\"\\u000b\"","host":"999.9999999","..":"\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\"","k8s.pod.name":"\"3fa85f64-5717-4562-b3fc-2c963f66afa6\""},"instrumentation_scope":null,"event_name":null,"attributes":{"valueOf":"{\"a\":1}","severity_text":"true"},"bytes_uncompressed":466},"pii_replacements":0,"gap":false}},{"input":{"settings":{"pii_scrub_logs":true,"json_parse_logs":true},"record":{"uuid":"u92","trace_id":null,"span_id":{"$bytes":"e5566c3d46e8c540"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"false","severity_text":"warning","severity_number":1,"service_name":"worker","resource_attributes":{"service.name":"\"\\\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\\\"\"","toString":"\"null\""},"instrumentation_scope":null,"event_name":null,"attributes":{"0":"\"debug\"","\"":"\"12\"","4294967295":"4294967295","__defineGetter__":"null","k8s.pod.name":"\"2025-01-15T10:00:00Z\"","http.route":"9007199254740994","payload":"\"{\\\"a\\\":-1.5,\\\"arr\\\":[1,\""},"bytes_uncompressed":null}},"output":{"record":{"uuid":"u92","trace_id":null,"span_id":{"$bytes":"e5566c3d46e8c540"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"false","severity_text":"warning","severity_number":1,"service_name":"worker","resource_attributes":{"service.name":"\"\\\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\\\"\"","toString":"\"null\""},"instrumentation_scope":null,"event_name":null,"attributes":{"0":"\"debug\"","\"":"\"12\"","4294967295":"4294967295","__defineGetter__":"null","k8s.pod.name":"\"2025-01-15T10:00:00Z\"","http.route":"9007199254740994","payload":"\"{\\\"a\\\":-1.5,\\\"arr\\\":[1,\""},"bytes_uncompressed":null},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"pii_scrub_logs":true,"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u93","trace_id":{"$bytes":"26ab319ad9ce3018a07633d6b1f61e06"},"span_id":{"$bytes":"4b701dd2f401098b"},"trace_flags":null,"timestamp":1736943851938000,"observed_timestamp":1736944633250000,"body":"[-3.991480078548193e-18,null]","severity_text":"İnfo","severity_number":5,"service_name":"worker","resource_attributes":{"1":"9007199254740994","4294967294":"0","service.name":"\"true\"","constructor":"1.5"},"instrumentation_scope":null,"event_name":"","attributes":{"0":"\"true\"","10":"🚀","message":"Infinitydebug日本語","valueOf":"7","severity_text":"\" 12\""},"bytes_uncompressed":1322}},"output":{"record":{"uuid":"u93","trace_id":{"$bytes":"26ab319ad9ce3018a07633d6b1f61e06"},"span_id":{"$bytes":"4b701dd2f401098b"},"trace_flags":null,"timestamp":1736943851938000,"observed_timestamp":1736944633250000,"body":"[-3.991480078548193e-18,null]","severity_text":"İnfo","severity_number":5,"service_name":"worker","resource_attributes":{"1":"9007199254740994","4294967294":"0","service.name":"\"true\"","constructor":"1.5"},"instrumentation_scope":null,"event_name":"","attributes":{"0":"\"true\"","1":"\"null\"","10":"🚀","message":"Infinitydebug日本語","valueOf":"7","severity_text":"\" 12\""},"bytes_uncompressed":1322},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u94","trace_id":{"$bytes":""},"span_id":{"$bytes":"dc38d91272d362cc"},"trace_flags":null,"timestamp":1736943653275000,"observed_timestamp":1736944633250000,"body":" []\n","severity_text":"warning","severity_number":5,"service_name":"api","resource_attributes":{"1":"0","host":"\"0\"","message":"{\"12 msg \":[{\"3\":[\" error\",null,\"error0.0000019007199254740993 \",null,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}"},"instrumentation_scope":null,"event_name":"","attributes":{"1":"\" \"","sk_live_0123456789abcdefghijkl":"\"true\""},"bytes_uncompressed":1807}},"output":{"record":{"uuid":"u94","trace_id":{"$bytes":""},"span_id":{"$bytes":"dc38d91272d362cc"},"trace_flags":null,"timestamp":1736943653275000,"observed_timestamp":1736944633250000,"body":" []\n","severity_text":"warning","severity_number":5,"service_name":"api","resource_attributes":{"1":"0","host":"\"0\"","message":"{\"12 msg \":[{\"3\":[\" error\",null,\"error0.0000019007199254740993 \",null,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]},1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}"},"instrumentation_scope":null,"event_name":"","attributes":{"1":"\" \"","sk_live_0123456789abcdefghijkl":"\"true\""},"bytes_uncompressed":1807},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"1"},"record":{"uuid":"u97","trace_id":{"$bytes":"fe63a8b78a15989bec21d4dcdd8422f4"},"span_id":null,"trace_flags":null,"timestamp":1736943190792000,"observed_timestamp":1736944633250000,"body":"true","severity_text":"warning","severity_number":0,"service_name":"","resource_attributes":{},"instrumentation_scope":null,"event_name":null,"attributes":null,"bytes_uncompressed":450}},"output":{"record":{"uuid":"u97","trace_id":{"$bytes":"fe63a8b78a15989bec21d4dcdd8422f4"},"span_id":null,"trace_flags":null,"timestamp":1736943190792000,"observed_timestamp":1736944633250000,"body":"true","severity_text":"warning","severity_number":0,"service_name":"","resource_attributes":{},"instrumentation_scope":null,"event_name":null,"attributes":null,"bytes_uncompressed":450},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"1"},"record":{"uuid":"u98","trace_id":{"$bytes":"8fdc138f8bc31b49"},"span_id":{"$bytes":"65856ce67add41d9"},"trace_flags":null,"timestamp":1736943352387000,"observed_timestamp":1736944633250000,"body":"999.9999999","severity_text":"ERROR","severity_number":5,"service_name":"worker","resource_attributes":{"constructor":"\"\\\\\"","k8s.pod.name":"\"12\"","service.name":"é"},"instrumentation_scope":null,"event_name":null,"attributes":{"1":"\"\\\"{\\\\\\\"a\\\\\\\":999.9999999,\\\\\\\"arr\\\\\\\":[1,[2,{\\\\\\\"b\\\\\\\"x\\\\\\\\ude80:null}]],\\\\\\\"s\\\\\\\":\\\\\\\"x\\\\\\\"}\\\"\"","name":"1","service.name":"\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\""},"bytes_uncompressed":21}},"output":{"record":{"uuid":"u98","trace_id":{"$bytes":"8fdc138f8bc31b49"},"span_id":{"$bytes":"65856ce67add41d9"},"trace_flags":null,"timestamp":1736943352387000,"observed_timestamp":1736944633250000,"body":"999.9999999","severity_text":"ERROR","severity_number":5,"service_name":"worker","resource_attributes":{"constructor":"\"\\\\\"","k8s.pod.name":"\"12\"","service.name":"é"},"instrumentation_scope":null,"event_name":null,"attributes":{"1":"\"\\\"{\\\\\\\"a\\\\\\\":999.9999999,\\\\\\\"arr\\\\\\\":[1,[2,{\\\\\\\"b\\\\\\\"x\\\\\\\\ude80:null}]],\\\\\\\"s\\\\\\\":\\\\\\\"x\\\\\\\"}\\\"\"","name":"1","service.name":"\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\""},"bytes_uncompressed":21},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"a"},"record":{"uuid":"u100","trace_id":{"$bytes":"3f04c97ee7a1fa5d6e4e89ffad37f9ea"},"span_id":{"$bytes":"ed4a527d01e4cb5b"},"trace_flags":null,"timestamp":1736942294437000,"observed_timestamp":1736944633250000,"body":" ","severity_text":"warning","severity_number":21,"service_name":"worker","resource_attributes":{"1":"\"1e3\"","host":"-1.5","a":"null"},"instrumentation_scope":null,"event_name":"request","attributes":{"http.status_code":"null","http.path":"\"x\"","/api/v1/users/1234294967294 ":"[{\"4294967296\":{\"50\":false,\"4294967294\":{\"1\":null,\"\\t\":0},\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\":\"12 \"}},1,1]","":"\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"","payload.0":"true","payload.a":"\"sender\"","message":"\"sender\""},"bytes_uncompressed":null}},"output":{"record":{"uuid":"u100","trace_id":{"$bytes":"3f04c97ee7a1fa5d6e4e89ffad37f9ea"},"span_id":{"$bytes":"ed4a527d01e4cb5b"},"trace_flags":null,"timestamp":1736942294437000,"observed_timestamp":1736944633250000,"body":" ","severity_text":"warning","severity_number":21,"service_name":"worker","resource_attributes":{"1":"\"1e3\"","host":"-1.5","a":"null"},"instrumentation_scope":null,"event_name":"request","attributes":{"http.status_code":"null","http.path":"\"x\"","/api/v1/users/1234294967294 ":"[{\"4294967296\":{\"50\":false,\"4294967294\":{\"1\":null,\"\\t\":0},\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\":\"12 \"}},1,1]","":"\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"","payload.0":"true","payload.a":"\"sender\"","message":"\"sender\""},"bytes_uncompressed":null},"pii_replacements":0,"gap":false}},{"input":{"settings":{"pii_scrub_logs":true,"json_parse_logs":true},"record":{"uuid":"u101","trace_id":{"$bytes":"9b31396d651ac123f34cb2d234af4b6f"},"span_id":{"$bytes":"2c498f2f714c655a"},"trace_flags":null,"timestamp":1736942992573000,"observed_timestamp":1736944633250000,"body":"+5-1e400日本語2001:db8::1 .5","severity_text":"INFO","severity_number":1,"service_name":"API","resource_attributes":{"�":"\" 4294967294 ","k8s.pod.name":"\"日本語\""},"instrumentation_scope":null,"event_name":"","attributes":{"\n":"\"-1.5\"","payload":"\"\\\"{\\\\\\\"a\\\\\\\":\\\\\\\"100 -0 \\\\\\\",\\\\\\\"arr\\\\\\\":[1,[2,{\\\\\\\"b\\\\\\\":null}]],\\\\\\\"s\\\\\\\":\\\\\\\"x\\\\\\\"}\\\"\"","message":"\"sender\""},"bytes_uncompressed":334}},"output":{"record":{"uuid":"u101","trace_id":{"$bytes":"9b31396d651ac123f34cb2d234af4b6f"},"span_id":{"$bytes":"2c498f2f714c655a"},"trace_flags":null,"timestamp":1736942992573000,"observed_timestamp":1736944633250000,"body":"+5-1e400日本語2001:db8::1 .5","severity_text":"INFO","severity_number":1,"service_name":"API","resource_attributes":{"�":"\" 4294967294 ","k8s.pod.name":"\"日本語\""},"instrumentation_scope":null,"event_name":"","attributes":{"\n":"\"-1.5\"","payload":"\"\\\"{\\\\\\\"a\\\\\\\":\\\\\\\"100 -0 \\\\\\\",\\\\\\\"arr\\\\\\\":[1,[2,{\\\\\\\"b\\\\\\\":null}]],\\\\\\\"s\\\\\\\":\\\\\\\"x\\\\\\\"}\\\"\"","message":"\"sender\""},"bytes_uncompressed":334},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true},"record":{"uuid":"u102","trace_id":null,"span_id":{"$bytes":"757dfd3913b85954"},"trace_flags":null,"timestamp":1736943368811000,"observed_timestamp":1736944633250000,"body":"\"-Infinity 1e400 \"","severity_text":"Warn","severity_number":17,"service_name":"worker","resource_attributes":null,"instrumentation_scope":null,"event_name":"request","attributes":{"severity_text":"\"-1e400\"","payload.x":"\"[]\""},"bytes_uncompressed":745}},"output":{"record":{"uuid":"u102","trace_id":null,"span_id":{"$bytes":"757dfd3913b85954"},"trace_flags":null,"timestamp":1736943368811000,"observed_timestamp":1736944633250000,"body":"\"-Infinity 1e400 \"","severity_text":"Warn","severity_number":17,"service_name":"worker","resource_attributes":null,"instrumentation_scope":null,"event_name":"request","attributes":{"severity_text":"\"-1e400\"","payload.x":"\"[]\""},"bytes_uncompressed":745},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u103","trace_id":{"$bytes":"d3f258177d6bcfd7567bae2dec65416d"},"span_id":null,"trace_flags":null,"timestamp":1736943924738000,"observed_timestamp":1736944633250000,"body":"false","severity_text":"Warn","severity_number":9,"service_name":"API","resource_attributes":{"1":"4294967295","constructor":"true","a":"-1.5","service.name":"\"\"","host":"\"POST\""},"instrumentation_scope":null,"event_name":"request","attributes":{"0":"\"sender\"","http.status_code":"true","9007199254740994debug":"false","name":"\"1_000\"","payload":"{\"a\":5e-324,\"arr\":[1,[2,{\"b\":null}]],\"s\":\"x\"}","payload.a":"\"sender\"","message":"\"sender\""},"bytes_uncompressed":1431}},"output":{"record":{"uuid":"u103","trace_id":{"$bytes":"d3f258177d6bcfd7567bae2dec65416d"},"span_id":null,"trace_flags":null,"timestamp":1736943924738000,"observed_timestamp":1736944633250000,"body":"false","severity_text":"Warn","severity_number":9,"service_name":"API","resource_attributes":{"1":"4294967295","constructor":"true","a":"-1.5","service.name":"\"\"","host":"\"POST\""},"instrumentation_scope":null,"event_name":"request","attributes":{"0":"\"sender\"","payload.a":"\"sender\"","payload.arr":"\"[1,[2,{\\\"b\\\":null}]]\"","payload.s":"\"x\"","http.status_code":"true","9007199254740994debug":"false","name":"\"1_000\"","payload":"{\"a\":5e-324,\"arr\":[1,[2,{\"b\":null}]],\"s\":\"x\"}","message":"\"sender\""},"bytes_uncompressed":1431},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"constructor"},"record":{"uuid":"u104","trace_id":{"$bytes":"26ad5477f8d3f486d009a1c40c35fc75"},"span_id":{"$bytes":"3fb1d4dba2bb2c42"},"trace_flags":null,"timestamp":1736943602241000,"observed_timestamp":1736944633250000,"body":"\"\\ud83d\\ude80x\\ude80é\"","severity_text":"WARN","severity_number":21,"service_name":"worker","resource_attributes":{"1":"-Infinity","�":"1.7976931348623157e+308","":"\"\\\"\"","host":"\\a.","k8s.pod.name":"0","constructor":"\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\""},"instrumentation_scope":null,"event_name":"request","attributes":{"k":"\"0.000001\"","payload":"\"debug\"","warn1.5 ":".5日本語慰","payload.0":"ʚNaN","msg":"false"},"bytes_uncompressed":null}},"output":{"record":{"uuid":"u104","trace_id":{"$bytes":"26ad5477f8d3f486d009a1c40c35fc75"},"span_id":{"$bytes":"3fb1d4dba2bb2c42"},"trace_flags":null,"timestamp":1736943602241000,"observed_timestamp":1736944633250000,"body":"\"\\ud83d\\ude80x\\ude80é\"","severity_text":"WARN","severity_number":21,"service_name":"worker","resource_attributes":{"1":"-Infinity","�":"1.7976931348623157e+308","":"\"\\\"\"","host":"\\a.","k8s.pod.name":"0","constructor":"\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\""},"instrumentation_scope":null,"event_name":"request","attributes":{"k":"\"0.000001\"","payload":"\"debug\"","warn1.5 ":".5日本語慰","payload.0":"ʚNaN","msg":"false"},"bytes_uncompressed":null},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"constructor"},"record":{"uuid":"u105","trace_id":{"$bytes":"1217df8095e9011e"},"span_id":{"$bytes":"79b08da6b3706c6c"},"trace_flags":null,"timestamp":1736942729663000,"observed_timestamp":1736944633250000,"body":"-2.171312707941979e-17","severity_text":null,"severity_number":21,"service_name":"API","resource_attributes":{"service.name":"false","host":"1,5","constructor":"-0","k8s.pod.name":"{\"5e-324 \":999.9999999}"},"instrumentation_scope":null,"event_name":"request","attributes":{"payload.0":"\"Infinity\"","kind":"\"\\\"ERROR \\\"\"","url.path":"0.1","ms":"false","constructor":"\"{\\\"a\\\":false,\\\"arr\\\":[1,[2,{\\\"b\\\":null}]],\\\"s\\\":\\\"x\\\"}\""},"bytes_uncompressed":null}},"output":{"record":{"uuid":"u105","trace_id":{"$bytes":"1217df8095e9011e"},"span_id":{"$bytes":"79b08da6b3706c6c"},"trace_flags":null,"timestamp":1736942729663000,"observed_timestamp":1736944633250000,"body":"-2.171312707941979e-17","severity_text":null,"severity_number":21,"service_name":"API","resource_attributes":{"service.name":"false","host":"1,5","constructor":"-0","k8s.pod.name":"{\"5e-324 \":999.9999999}"},"instrumentation_scope":null,"event_name":"request","attributes":{"constructor.a":"false","constructor.arr":"\"[1,[2,{\\\"b\\\":null}]]\"","constructor.s":"\"x\"","payload.0":"\"Infinity\"","kind":"\"\\\"ERROR \\\"\"","url.path":"0.1","ms":"false","constructor":"\"{\\\"a\\\":false,\\\"arr\\\":[1,[2,{\\\"b\\\":null}]],\\\"s\\\":\\\"x\\\"}\""},"bytes_uncompressed":null},"pii_replacements":0,"gap":false}},{"input":{"settings":{"pii_scrub_logs":true},"record":{"uuid":"u106","trace_id":{"$bytes":"dea651f70fae3c4e"},"span_id":null,"trace_flags":null,"timestamp":1736943074929000,"observed_timestamp":1736944633250000,"body":"\"\\/+5/api/v1/users/123\"\\/","severity_text":"Warn","severity_number":21,"service_name":"","resource_attributes":{"k8s.pod.name":"\"Bearer abc.def-ghi\"","a":"Wed, 15 Jan 2025 12:00:00 GMT"},"instrumentation_scope":null,"event_name":"request","attributes":{"a":"host.example.com 遉ꈽ","payload.x":"\" \"","..":"\"é\""},"bytes_uncompressed":1322}},"output":{"record":{"uuid":"u106","trace_id":{"$bytes":"dea651f70fae3c4e"},"span_id":null,"trace_flags":null,"timestamp":1736943074929000,"observed_timestamp":1736944633250000,"body":"\"\\/+5/api/v1/users/123\"\\/","severity_text":"Warn","severity_number":21,"service_name":"","resource_attributes":{"k8s.pod.name":"\"Bearer abc.def-ghi\"","a":"Wed, 15 Jan 2025 12:00:00 GMT"},"instrumentation_scope":null,"event_name":"request","attributes":{"a":"host.example.com 遉ꈽ","payload.x":"\" \"","..":"\"é\""},"bytes_uncompressed":1322},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"1"},"record":{"uuid":"u107","trace_id":{"$bytes":"aad21c2af0c086ae39345eacdb9e6787"},"span_id":{"$bytes":"677ddf904ce90484"},"trace_flags":null,"timestamp":1736943630534000,"observed_timestamp":1736944633250000,"body":"{\"2\":null,\"a.\":\"error0x10 [email protected]\",\"b\":{\"user.email\":null,\"4294967295\":{\"1e3\":\"4294967294\",\"𑁿\":false,\"length\":[6.6145739983767276e-12,1,1,1,1,1,1,1,1,1]}}}","severity_text":"warning","severity_number":9,"service_name":"","resource_attributes":{"a":"1e+100 J "},"instrumentation_scope":null,"event_name":"","attributes":{"1":"\"{\\\"user_123\\\":\\\"messageWed, 15 J\"","ms":"true"},"bytes_uncompressed":937}},"output":{"record":{"uuid":"u107","trace_id":{"$bytes":"aad21c2af0c086ae39345eacdb9e6787"},"span_id":{"$bytes":"677ddf904ce90484"},"trace_flags":null,"timestamp":1736943630534000,"observed_timestamp":1736944633250000,"body":"{\"2\":null,\"a.\":\"error0x10 [email protected]\",\"b\":{\"user.email\":null,\"4294967295\":{\"1e3\":\"4294967294\",\"𑁿\":false,\"length\":[6.6145739983767276e-12,1,1,1,1,1,1,1,1,1]}}}","severity_text":"warning","severity_number":9,"service_name":"","resource_attributes":{"a":"1e+100 J "},"instrumentation_scope":null,"event_name":"","attributes":{"1":"\"{\\\"user_123\\\":\\\"messageWed, 15 J\"","2":"\"null\"","a.":"\"error0x10 [email protected]\"","b.user.email":"\"null\"","b.4294967295.1e3":"\"4294967294\"","b.4294967295.𑁿":"false","b.4294967295.length.0":"6.6145739983767276e-12","b.4294967295.length.1":"1","b.4294967295.length.2":"1","b.4294967295.length.3":"1","b.4294967295.length.4":"1","b.4294967295.length.5":"1","b.4294967295.length.6":"1","b.4294967295.length.7":"1","b.4294967295.length.8":"1","b.4294967295.length.9":"1","ms":"true"},"bytes_uncompressed":937},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"1"},"record":{"uuid":"u108","trace_id":{"$bytes":"53397b6f69bba454e3a44a60cd1a1d43"},"span_id":null,"trace_flags":null,"timestamp":1736944474973000,"observed_timestamp":1736944633250000,"body":"warnpayload12025-01-15T10:00:00Z","severity_text":"WARN","severity_number":0,"service_name":"worker","resource_attributes":null,"instrumentation_scope":null,"event_name":null,"attributes":{},"bytes_uncompressed":null}},"output":{"record":{"uuid":"u108","trace_id":{"$bytes":"53397b6f69bba454e3a44a60cd1a1d43"},"span_id":null,"trace_flags":null,"timestamp":1736944474973000,"observed_timestamp":1736944633250000,"body":"warnpayload12025-01-15T10:00:00Z","severity_text":"WARN","severity_number":0,"service_name":"worker","resource_attributes":null,"instrumentation_scope":null,"event_name":null,"attributes":{},"bytes_uncompressed":null},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"json_parse_logs_attribute_key":"constructor"},"record":{"uuid":"u110","trace_id":{"$bytes":"3d87dc4347df0cbd904bec296910178a"},"span_id":{"$bytes":"04caf6b5a7078ccc"},"trace_flags":null,"timestamp":1736942349419000,"observed_timestamp":1736944633250000,"body":"null","severity_text":"info","severity_number":17,"service_name":null,"resource_attributes":{"1":"ERROR","constructor":"\"sk_live_0123456789abcdefghijkl\"","service.name":"\"\\\"quoted\\\"\""},"instrumentation_scope":null,"event_name":null,"attributes":{"0":"\"sender\"","status_code":"13fa85f64-5717-4562-b3fc-2c963f66afa6 0","url.path":"\"\\\"\"","path":"1e+100","":"\"\\\"+5\\\"\"","toString":"level","🚀":"0","K":"\"[]\"","constructor":"\"{\\\"a\\\":\\\"192.168.0.1塚 \\\",\\\"arr\\\":[1,[2,{\\\"b\\\":null}]],\\\"s\\\":\\\"x\\\"}\"","a":"\"sender\"","n3":"\"sender\""},"bytes_uncompressed":null}},"output":{"record":{"uuid":"u110","trace_id":{"$bytes":"3d87dc4347df0cbd904bec296910178a"},"span_id":{"$bytes":"04caf6b5a7078ccc"},"trace_flags":null,"timestamp":1736942349419000,"observed_timestamp":1736944633250000,"body":"null","severity_text":"info","severity_number":17,"service_name":null,"resource_attributes":{"1":"ERROR","constructor":"\"sk_live_0123456789abcdefghijkl\"","service.name":"\"\\\"quoted\\\"\""},"instrumentation_scope":null,"event_name":null,"attributes":{"0":"\"sender\"","constructor.a":"\"192.168.0.1塚 \"","constructor.arr":"\"[1,[2,{\\\"b\\\":null}]]\"","constructor.s":"\"x\"","status_code":"13fa85f64-5717-4562-b3fc-2c963f66afa6 0","url.path":"\"\\\"\"","path":"1e+100","":"\"\\\"+5\\\"\"","toString":"level","🚀":"0","K":"\"[]\"","constructor":"\"{\\\"a\\\":\\\"192.168.0.1塚 \\\",\\\"arr\\\":[1,[2,{\\\"b\\\":null}]],\\\"s\\\":\\\"x\\\"}\"","a":"\"sender\"","n3":"\"sender\""},"bytes_uncompressed":null},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs":true,"pii_scrub_logs":true,"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u111","trace_id":{"$bytes":"7843f7f6b3d357d0b991d53a32557b91"},"span_id":null,"trace_flags":null,"timestamp":1736944379224000,"observed_timestamp":1736944633250000,"body":"\"ݪ\"","severity_text":"WARN","severity_number":null,"service_name":"web","resource_attributes":{"-1":"\"\\\"quoted\\\"\"","host":"-1","k8s.pod.name":"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123","a":"\"-1e400null\""},"instrumentation_scope":null,"event_name":null,"attributes":{"0":"\"sender\"","payload.0":"\"0x10\"","valueOf":"\"00 a.POST\"","constructor":"\"{\\\"b\\\":{\\\"4294967294\\\":{\\\"x\\\":{\\\"0\\\":\\\".a5.\\\",\\\"49\\\":null,\\\"valueOf\\\":\\\"⬾ \\\",\\\"\\\\n\\\":null}}}}\"","message":"\"sender\""},"bytes_uncompressed":440}},"output":{"record":{"uuid":"u111","trace_id":{"$bytes":"7843f7f6b3d357d0b991d53a32557b91"},"span_id":null,"trace_flags":null,"timestamp":1736944379224000,"observed_timestamp":1736944633250000,"body":"\"ݪ\"","severity_text":"WARN","severity_number":null,"service_name":"web","resource_attributes":{"-1":"\"\\\"quoted\\\"\"","host":"-1","k8s.pod.name":"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123","a":"\"-1e400null\""},"instrumentation_scope":null,"event_name":null,"attributes":{"0":"\"sender\"","payload.0":"\"0x10\"","valueOf":"\"00 a.POST\"","constructor":"\"{\\\"b\\\":{\\\"4294967294\\\":{\\\"x\\\":{\\\"0\\\":\\\".a5.\\\",\\\"49\\\":null,\\\"valueOf\\\":\\\"⬾ \\\",\\\"\\\\n\\\":null}}}}\"","message":"\"sender\""},"bytes_uncompressed":440},"pii_replacements":0,"gap":false}},{"input":{"settings":{"pii_scrub_logs":true},"record":{"uuid":"u112","trace_id":{"$bytes":"129ad6c554a81e239dbb2e0a9b8a1f4b"},"span_id":{"$bytes":"26d5d0d46dece285"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"false","severity_text":"Warn","severity_number":12,"service_name":"web","resource_attributes":{"service.name":"\r\n","host":"b debug 웩"},"instrumentation_scope":null,"event_name":"request","attributes":{"payload.0":"false","severity_text":"[\"1.5 12 a.b\",\"null \",{\"50\":null,\"k\":{\"51\":[1e+100,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}},1,1,1,1,1,1,1]","__defineGetter__":"\"+5\"","http.status_code":"{}","http.route":"4294967295","http.response.status_code":"Infinity"},"bytes_uncompressed":93}},"output":{"record":{"uuid":"u112","trace_id":{"$bytes":"129ad6c554a81e239dbb2e0a9b8a1f4b"},"span_id":{"$bytes":"26d5d0d46dece285"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"false","severity_text":"Warn","severity_number":12,"service_name":"web","resource_attributes":{"service.name":"\r\n","host":"b debug 웩"},"instrumentation_scope":null,"event_name":"request","attributes":{"payload.0":"false","severity_text":"[\"1.5 12 a.b\",\"null \",{\"50\":null,\"k\":{\"51\":[1e+100,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]}},1,1,1,1,1,1,1]","__defineGetter__":"\"+5\"","http.status_code":"{}","http.route":"4294967295","http.response.status_code":"Infinity"},"bytes_uncompressed":93},"pii_replacements":0,"gap":false}},{"input":{"settings":{"json_parse_logs_attribute_key":"payload"},"record":{"uuid":"u113","trace_id":{"$bytes":"7125ab958a77ec45945915f867217bf8"},"span_id":{"$bytes":"f9cdf1bd87aba554"},"trace_flags":null,"timestamp":1736942588492000,"observed_timestamp":1736944633250000,"body":" {\"51\":{},\"01\":\"deadbeefa\\\\nb1e+100\"}\n","severity_text":"WARN","severity_number":21,"service_name":null,"resource_attributes":{"a":"1.7976931348623157e+308"},"instrumentation_scope":null,"event_name":null,"attributes":null,"bytes_uncompressed":651}},"output":{"record":{"uuid":"u113","trace_id":{"$bytes":"7125ab958a77ec45945915f867217bf8"},"span_id":{"$bytes":"f9cdf1bd87aba554"},"trace_flags":null,"timestamp":1736942588492000,"observed_timestamp":1736944633250000,"body":" {\"51\":{},\"01\":\"deadbeefa\\\\nb1e+100\"}\n","severity_text":"WARN","severity_number":21,"service_name":null,"resource_attributes":{"a":"1.7976931348623157e+308"},"instrumentation_scope":null,"event_name":null,"attributes":null,"bytes_uncompressed":651},"pii_replacements":0,"gap":false}}]}diff --git a/rust/logs-ingestion/tests/fixtures/fuzz/numbers.json b/rust/logs-ingestion/tests/fixtures/fuzz/numbers.jsonnew file mode 100644index 000000000000..ec9d77217610--- /dev/null+++ b/rust/logs-ingestion/tests/fixtures/fuzz/numbers.json@@ -0,0 +1 @@+{"cases":[{"input":"403ed2f500000000","output":"30.824050903320312","regression":true},{"input":"40672c2440000000","output":"185.37942504882812","regression":true},{"input":"406e162740000000","output":"240.69229125976562","regression":true},{"input":"4096addf90000000","output":"1451.4683227539062","regression":true},{"input":"409aab1cd0000000","output":"1706.7781372070312","regression":true},{"input":"40a17dfc48000000","output":"2238.9927368164062","regression":true},{"input":"40a219b348000000","output":"2316.8501586914062","regression":true},{"input":"40a82f6668000000","output":"3095.7000122070312","regression":true},{"input":"40af64ed28000000","output":"4018.4631958007812","regression":true},{"input":"40c2109f94000000","output":"9249.246704101562","regression":true},{"input":"40c2210a84000000","output":"9282.082153320312","regression":true},{"input":"40c3ec3c54000000","output":"10200.471313476562","regression":true},{"input":"40c4ce8754000000","output":"10653.057250976562","regression":true},{"input":"40c5689ce4000000","output":"10961.225708007812","regression":true},{"input":"40ca810c64000000","output":"13570.096801757812","regression":true},{"input":"40ce5167d4000000","output":"15522.811157226562","regression":true},{"input":"40ceade5a4000000","output":"15707.794067382812","regression":true},{"input":"40d05e3032000000","output":"16760.753051757812","regression":true},{"input":"40d0b243b2000000","output":"17097.057739257812","regression":true},{"input":"40d0d1c63a000000","output":"17223.097290039062","regression":true},{"input":"40d1035212000000","output":"17421.282348632812","regression":true},{"input":"40d2c2233a000000","output":"19208.550415039062","regression":true},{"input":"40d5bb538a000000","output":"22253.305297851562","regression":true},{"input":"40d8f78eaa000000","output":"25566.229125976562","regression":true},{"input":"40d9f6864a000000","output":"26586.098266601562","regression":true},{"input":"40da3d304a000000","output":"26868.754516601562","regression":true},{"input":"40dcc8b74a000000","output":"29474.863891601562","regression":true},{"input":"40dd4c22ca000000","output":"30000.543579101562","regression":true},{"input":"40f04729c9000000","output":"66674.61157226562","regression":true},{"input":"40f38d8461000000","output":"80088.27368164062","regression":true},{"input":"40f592fc91000000","output":"88367.78540039062","regression":true},{"input":"40f6e9a549000000","output":"93850.33032226562","regression":true},{"input":"40f7b0c3d5000000","output":"97036.23950195312","regression":true},{"input":"40f9caac45000000","output":"105642.76684570312","regression":true},{"input":"40fa884cfd000000","output":"108676.81176757812","regression":true},{"input":"40fd4887a1000000","output":"119944.47680664062","regression":true},{"input":"40fd58f9f1000000","output":"120207.62133789062","regression":true},{"input":"41012f22de800000","output":"140772.35864257812","regression":true},{"input":"410187dbce800000","output":"143611.47583007812","regression":true},{"input":"41029f52d0800000","output":"152554.35180664062","regression":true},{"input":"410449ef26800000","output":"166205.89379882812","regression":true},{"input":"4105335104800000","output":"173674.12719726562","regression":true},{"input":"4106a69efe800000","output":"185555.87426757812","regression":true},{"input":"4108c6c8a8800000","output":"202969.08227539062","regression":true},{"input":"4109a18a30800000","output":"209969.27368164062","regression":true},{"input":"4109e5f3ce800000","output":"212158.47583007812","regression":true},{"input":"410a068576800000","output":"213200.68286132812","regression":true},{"input":"410a2fa10c800000","output":"214516.13110351562","regression":true},{"input":"410d8c445c800000","output":"242056.54516601562","regression":true},{"input":"410d9f2e12800000","output":"242661.75903320312","regression":true},{"input":"410fbf3880800000","output":"260071.06274414062","regression":true},{"input":"412145f2a2400000","output":"566009.3168945312","regression":true},{"input":"41223c9caf400000","output":"597582.3422851562","regression":true},{"input":"412273ce7c400000","output":"604647.2426757812","regression":true},{"input":"4122fbd19c400000","output":"622056.8051757812","regression":true},{"input":"41232f8751400000","output":"628675.6586914062","regression":true},{"input":"4123fa00ec400000","output":"654592.4614257812","regression":true},{"input":"4124523e8d400000","output":"665887.2758789062","regression":true},{"input":"412467dba1400000","output":"668653.8149414062","regression":true},{"input":"4125936ff2400000","output":"706999.9731445312","regression":true},{"input":"412638857d400000","output":"728130.7446289062","regression":true},{"input":"4127a90337400000","output":"775297.6079101562","regression":true},{"input":"4128170ebf400000","output":"789383.3735351562","regression":true},{"input":"4129b9f863400000","output":"843004.1938476562","regression":true},{"input":"412aed9238400000","output":"882377.1098632812","regression":true},{"input":"412b82dd21400000","output":"901486.5649414062","regression":true},{"input":"412ed1b220400000","output":"1009881.0629882812","regression":true},{"input":"412f0b1316400000","output":"1017225.5434570312","regression":true},{"input":"4302399b5699393a","output":"641236114548519.2","regression":true},{"input":"430d418eb0433392","output":"1029356927870578.2","regression":true},{"input":"431c3c37c8273ac1","output":"1986877406695088.2","regression":true},{"input":"431fbc4cb3726029","output":"2233190473046026.2","regression":true},{"input":"c30d76ba201b3f82","output":"-1036664512407536.2","regression":true},{"input":"4292309ce5400000","output":"5000000000000"},{"input":"3fed27a190f8a507","output":"0.911087783"},{"input":"43bfc05c80000000","output":"2287930315529781200"},{"input":"3c4bab8cbabb6582","output":"3.0000000000000002e-18"},{"input":"0e3a8e18db3b8715","output":"3.982454904007411e-240"},{"input":"444b1ae4d6e2ef4d","output":"999999999999999600000"},{"input":"3f0b40f867d88984","output":"0.0000519824798"},{"input":"80e82aa199d23d8e","output":"-2.753142294822131e-304"},{"input":"3a664e4246dd00f3","output":"2.2523e-27"},{"input":"3e767a35f2a163ba","output":"8.37347868e-8"},{"input":"44a620c739e793c7","output":"5.22483570967e+22"},{"input":"4471a658f5df21a6","output":"5.2093e+21"},{"input":"44a0f0cf064dd592","output":"4e+22"},{"input":"42d9328b0bc00000","output":"110819487449088"},{"input":"41c0b61d76000000","output":"560741100"},{"input":"3fb5da3dd0bd69a5","output":"0.0853613505"},{"input":"4c4995029bcec413","output":"3.211625252212152e+59"},{"input":"41f65a0bc0000000","output":"6000000000"},{"input":"3f16f7601adaa82d","output":"0.0000876095207"},{"input":"40e247526e978d50","output":"37434.576"},{"input":"beb0c6f7a0b5ed8d","output":"-0.000001"},{"input":"3f121ad07a6a9174","output":"0.000069064116"},{"input":"422274b6a3800000","output":"39633768896"},{"input":"3ece7548c031ced8","output":"0.00000363089339"},{"input":"8010000000000001","output":"-2.225073858507202e-308"},{"input":"3e7ad7f29abcaf49","output":"1.0000000000000001e-7"},{"input":"3eb0c6f7a0b5ed8b","output":"9.999999999999995e-7"},{"input":"3ea0c6f7a0b5ed8d","output":"5e-7"},{"input":"418483f55fc00000","output":"43024043.96875"},{"input":"855e093525c6cae3","output":"-8.079522713221634e-283"},{"input":"bc36b082c2148b90","output":"-1.2300000000000004e-18"},{"input":"3f09b5a55b1fc9b8","output":"0.0000490370834"},{"input":"44b52d02c7e14af6","output":"1e+23"},{"input":"45e15b7830c2b680","output":"4.29746e+28"},{"input":"42c9c9b352000000","output":"56708175233024"},{"input":"4435af1d78b58c40","output":"400000000000000000000"},{"input":"beb0c6f7a0b5ed8d","output":"-0.000001"},{"input":"8fc8102cce1f8537","output":"-1.2108948898863328e-232"},{"input":"45f0195fa6903a60","output":"7.971896e+28"},{"input":"3f0b7321557d4480","output":"0.0000523562"},{"input":"3eb0c6f7a0b5ed8e","output":"0.0000010000000000000002"},{"input":"3e406ed90d5d67cf","output":"7.65221168e-9"},{"input":"3dd53c1dafdd3e39","output":"7.72518541897e-11"},{"input":"3f474f8870df9364","output":"0.000711385366"},{"input":"3ee45d96fa47f69e","output":"0.00000971106767"},{"input":"7ff0000000000000","output":"Infinity"},{"input":"43d8094928000000","output":"6927983871392743000"},{"input":"8000000000000000","output":"0"},{"input":"3fe75869efa44b73","output":"0.7295427017692034"},{"input":"3c36b082c2148b8d","output":"1.2299999999999998e-18"},{"input":"43e158e460913d00","output":"10000000000000000000"},{"input":"c2f371ffdbecc024","output":"-342085517364226.25"},{"input":"3eb6003d534015d9","output":"0.00000131135796"},{"input":"3eb0c6f7a0b5ed8b","output":"9.999999999999995e-7"},{"input":"444b1ae4d6e2ef4d","output":"999999999999999600000"},{"input":"8010000000000000","output":"-2.2250738585072014e-308"},{"input":"3c814b37f4b51f70","output":"2.9999999999999994e-17"},{"input":"be7ad7f29abcaf46","output":"-9.999999999999997e-8"},{"input":"3dd07e1fe91b0b70","output":"6e-11"},{"input":"3fe59868ac91c3e2","output":"0.6748546"},{"input":"40a50d3bb8c00000","output":"2694.6166439056396"},{"input":"436f161421c8e000","output":"70000000000000000"},{"input":"428c9cbb543d4000","output":"3932435417000"},{"input":"2e41a7919e1e7421","output":"7.099835441628706e-86"},{"input":"3fc1cc385256e4e9","output":"0.1390448"},{"input":"0000000000000002","output":"1e-323"},{"input":"ad8cfdad358828a5","output":"-2.8463831319683616e-89"},{"input":"3e1696ba2d5e2800","output":"1.31483995e-9"},{"input":"6c0f122214f28f04","output":"3.2687360354711195e+212"},{"input":"aa15e135104d5934","output":"-5.962428913451336e-106"},{"input":"44fc34bc6c000000","output":"2.1311851110265532e+24"},{"input":"3c634bcf731bf8fc","output":"8.368364239577203e-18"},{"input":"41502ddf6c000000","output":"4241277.6875"},{"input":"3d819799812dea11","output":"2e-12"},{"input":"4024000000000000","output":"10"},{"input":"3a5db5e7526b5a18","output":"1.5e-27"},{"input":"3c9487634c4cd564","output":"7.1223787e-17"},{"input":"444b1ae4d6e2ef4f","output":"999999999999999900000"},{"input":"41c4dc9380000000","output":"700000000"},{"input":"3c36b082c2148b90","output":"1.2300000000000004e-18"},{"input":"3f304caed051ad6d","output":"0.00024871128"},{"input":"3eb032852c5d68dd","output":"9.65436969e-7"},{"input":"415312d000000000","output":"5000000"},{"input":"3c36b082c2148b8e","output":"1.23e-18"},{"input":"3f3dccc958b95398","output":"0.00045471111"},{"input":"4413b85e9ed79374","output":"90943342000000000000"},{"input":"c2d767e9f69aadab","output":"-102940297292470.67"},{"input":"0010000000000002","output":"2.2250738585072024e-308"},{"input":"3c66df15c9fd5792","output":"9.9189e-18"},{"input":"3ee0faf5a32f4491","output":"0.000008096843066159636"},{"input":"43a7bb29d9c00000","output":"855003249361551400"},{"input":"3fdf10bfb720cf3f","output":"0.485397271"},{"input":"72b0bd07cde77d61","output":"2.8572645123308455e+244"},{"input":"44a99cadfa82efaf","output":"6.047469531185925e+22"},{"input":"8000000000000001","output":"-5e-324"},{"input":"420227e662f00000","output":"9747352670"},{"input":"8ed6b52e8c362216","output":"-3.487204105793392e-237"},{"input":"42d07e780b250000","output":"72541463680000"},{"input":"4218db6452000000","output":"26690000000"},{"input":"3d8a636641c4df1a","output":"3e-12"},{"input":"3e5d4627d0e6972e","output":"2.7263579e-8"},{"input":"3a3555ff294da701","output":"2.6929723e-28"},{"input":"3aa9d37685c12258","output":"4.172419736e-26"},{"input":"3e025bae204ba03c","output":"5.34291778e-10"},{"input":"7ba3e211723c9037","output":"3.784508701702614e+287"},{"input":"40906705f0000000","output":"1049.7557983398438"},{"input":"433d2b4f3e000000","output":"8210393667207168"},{"input":"444b1ae4d6e2ef50","output":"1e+21"},{"input":"41c8b7386c000000","output":"829321432"},{"input":"beb0c6f7a0b5ed8b","output":"-9.999999999999995e-7"},{"input":"c44b1ae4d6e2ef4e","output":"-999999999999999700000"},{"input":"444b1ae4d6e2ef4d","output":"999999999999999600000"},{"input":"411a69079a800000","output":"432705.90087890625"},{"input":"3cfa1ef1d99c3cd3","output":"5.8e-15"},{"input":"3e7ad7f29abcaf48","output":"1e-7"},{"input":"40ffc47f58000000","output":"130119.958984375"},{"input":"3f70624dd2f1a9fc","output":"0.004"},{"input":"3d4887f11f155aa9","output":"1.74303401727229e-13"},{"input":"dccba792edcbf23c","output":"-1.0291416983649952e+139"},{"input":"3e7ad7f29abcaf48","output":"1e-7"},{"input":"3d16849b86a12b9b","output":"2e-14"},{"input":"41c0ae1f1e000000","output":"559693372"},{"input":"3eaa412684a1cd99","output":"7.82444894e-7"},{"input":"3fb34712c2f61563","output":"0.0753032423"},{"input":"41482dccbec00000","output":"3169177.490234375"},{"input":"3c32725dd1d243ac","output":"1e-18"},{"input":"4303798bcb800000","output":"685208234885120"},{"input":"41e65a0bc0000000","output":"3000000000"},{"input":"3f1a20b0d53fc36b","output":"0.0000996692591"},{"input":"44f86966f0000000","output":"1.8444979383231563e+24"},{"input":"ffffffffffffffff","output":"NaN"},{"input":"442794b2ec52ff2b","output":"217495000000000000000"},{"input":"3fa54103179c04d7","output":"0.0415116278"},{"input":"c415af1d78b58c41","output":"-100000000000000020000"},{"input":"4146e36000000000","output":"3000000"},{"input":"449ac64e5a400000","output":"3.160990744416422e+22"},{"input":"42df166ab1000000","output":"136724558905344"},{"input":"42361823e3c00000","output":"94894285760"},{"input":"3bfd83c94fb6d2ac","output":"1e-19"},{"input":"3ed4f8b588e368f0","output":"0.0000049999999999999996"},{"input":"3fe297075bc78497","output":"0.580936126"},{"input":"7ff0000000000001","output":"NaN"},{"input":"800ffffffffffffe","output":"-2.2250738585072004e-308"},{"input":"6ba7003dceb6a1f9","output":"3.780877706491191e+210"},{"input":"3a32b2a60f01576b","output":"2.36e-28"},{"input":"fffffffffffffffe","output":"NaN"},{"input":"413573285e5de15d","output":"1405736.36862"},{"input":"415b8480ce450dbc","output":"7213571.2229647"},{"input":"427ca1d494000000","output":"1967586361344"},{"input":"43b8c3b870000000","output":"1784472668544696300"},{"input":"eb118da83c3dfb94","output":"-5.635558940189799e+207"},{"input":"be7ad7f29abcaf4a","output":"-1.0000000000000002e-7"},{"input":"3ed5ae49f141201f","output":"0.00000516910929"},{"input":"44e1c1d0a8400000","output":"6.70843897221877e+23"},{"input":"41def1f269400000","output":"2076690853"},{"input":"424fd17490000000","output":"273316126720"},{"input":"4517293b0a9e69fe","output":"7e+24"},{"input":"3bb79ca10c924224","output":"5.0000000000000005e-21"},{"input":"3ea451c1c2bf1ed2","output":"6.05564201e-7"},{"input":"43f16333c2689659","output":"20046432502567770000"},{"input":"3fe6666666666667","output":"0.7000000000000001"},{"input":"3c2622d6fbc91e01","output":"6e-19"},{"input":"3fb3ebfacfea638c","output":"0.077819515"},{"input":"4054597b80a9de8b","output":"81.398163"},{"input":"3f14f8b588e368f0","output":"0.00007999999999999999"},{"input":"4312cecfac800000","output":"1323485232103424"},{"input":"3f7867c48cc5cc57","output":"0.00595833566"},{"input":"ffeffffffffffffd","output":"-1.7976931348623153e+308"},{"input":"42f4a0f71e000000","output":"362905172180992"},{"input":"3e348591d5dfd7ee","output":"4.77809378e-9"},{"input":"4499df9238000000","output":"3.054583054287665e+22"},{"input":"3d5c25c268497682","output":"4e-13"},{"input":"0000000000000003","output":"1.5e-323"},{"input":"5e57a9653d7eaa64","output":"2.9546352384173006e+146"},{"input":"436b88e2088767e0","output":"62002630066126590"},{"input":"45f1f9313138f7c9","output":"8.9e+28"},{"input":"b8f95162c93bf5e2","output":"-3.047532996428894e-34"},{"input":"4539b8ee82000000","output":"3.109646061579051e+25"},{"input":"8010000000000001","output":"-2.225073858507202e-308"},{"input":"4451eba720800000","output":"1.322300903628856e+21"},{"input":"3dd949eca9b20079","output":"9.2e-11"},{"input":"ed3e3bac4ed35065","output":"-1.667552551841072e+218"},{"input":"3fdfd60005f90224","output":"0.497436529"},{"input":"43d9607710000000","output":"7314369437262414000"},{"input":"b4f66bdd7908f3de","output":"-1.4630612330500347e-53"},{"input":"3da19799812dea11","output":"8e-12"},{"input":"404e000000000000","output":"60"},{"input":"3ea2afbb0e9b610e","output":"5.56899548e-7"},{"input":"4445af1d78b58c40","output":"800000000000000000000"},{"input":"452885ce18000000","output":"1.4823048085817102e+25"},{"input":"4295d3ef79800000","output":"6000000000000"},{"input":"3fb24b1ae85b151c","output":"0.071458513"},{"input":"4f0e4a5b6d97a268","output":"6.6898257586974135e+72"},{"input":"460d82cd0a020715","output":"2.922622051555663e+29"},{"input":"c44b1ae4d6e2ef51","output":"-1.0000000000000001e+21"},{"input":"439b3a469d800000","output":"490489557486141440"},{"input":"39d856c1984e1cbf","output":"4.8e-30"},{"input":"6567333993cac7e2","output":"3.0084114058656767e+180"},{"input":"3f37bb5e10648290","output":"0.000362120118"},{"input":"beb0c6f7a0b5ed8e","output":"-0.0000010000000000000002"},{"input":"44ed96131f000000","output":"1.1177361394742971e+24"},{"input":"420cb8b0ba000000","output":"15419709248"},{"input":"3eb0c6f7a0b5ed8c","output":"9.999999999999997e-7"},{"input":"3ad056f4728380b4","output":"2.11185252293944e-25"},{"input":"4090d010b6000000","output":"1076.0163192749023"},{"input":"426e2e5a32800000","output":"1037013455872"},{"input":"3fdb7b2ec62249e8","output":"0.429393476"},{"input":"3ede86d39192641b","output":"0.000007278124280273914"},{"input":"432550f7dca70000","output":"3000000000000000"},{"input":"3eb0c6f7a0b5ed8e","output":"0.0000010000000000000002"},{"input":"0000000000000002","output":"1e-323"},{"input":"f1128682817c4cef","output":"-4.7122126395120555e+236"},{"input":"41fec36f6cc00000","output":"8257992396"},{"input":"457ce3b07fc00000","output":"5.588024955701702e+26"},{"input":"3ba2e3b40a0e9b50","output":"2.0000000000000002e-21"},{"input":"461f2c0e583b693d","output":"6.1742693e+29"},{"input":"3b4e392010175ee6","output":"5e-23"},{"input":"8c264df951273ffc","output":"-3.894106001592241e-250"},{"input":"3ed91ff3abf78bd8","output":"0.00000599022195"},{"input":"44a969368974c05b","output":"6e+22"},{"input":"800ffffffffffffe","output":"-2.2250738585072004e-308"},{"input":"800fffffffffffff","output":"-2.225073858507201e-308"},{"input":"411dd591a0c00000","output":"488804.4069824219"},{"input":"3f94377f973ba5b0","output":"0.0197429596"},{"input":"3e3acec7a34fec78","output":"6.2416619e-9"},{"input":"3df7a93f86b9d432","output":"3.443146937061101e-10"},{"input":"821cf91ba9250153","output":"-1.7305292743210012e-298"},{"input":"3f009c6dfd309de1","output":"0.0000316830698"},{"input":"33acbddae56b1206","output":"8.942977435593112e-60"},{"input":"3f40aa663ca6df42","output":"0.000508594437"},{"input":"c44b1ae4d6e2ef4d","output":"-999999999999999600000"},{"input":"3f19793c91fe8b9c","output":"0.0000971739978"},{"input":"447e59a87e8827ed","output":"8.957806e+21"},{"input":"3bfd83c94fb6d2ac","output":"1e-19"},{"input":"40bb580000000000","output":"7000"},{"input":"43fc73fdf00eae76","output":"32804183405824010000"},{"input":"3a117d8ad213cb87","output":"5.518996948e-29"},{"input":"437ae7b949800000","output":"121170118121095170"},{"input":"3e7ad7f29abcaf46","output":"9.999999999999997e-8"},{"input":"000101873ffa6383","output":"1.39897346828227e-309"},{"input":"7feffffffffffffd","output":"1.7976931348623153e+308"},{"input":"43cef869d0000000","output":"4463299914872389600"},{"input":"1aa9a003700eae65","output":"3.0877161478413243e-180"},{"input":"3eca3279c66210ae","output":"0.0000031229461"},{"input":"071665065f6e43fd","output":"1.6170662960505037e-274"},{"input":"410490aa66000000","output":"168469.2998046875"},{"input":"c415af1d78b58c3f","output":"-99999999999999980000"},{"input":"3ab71e57ff55221a","output":"7.47e-26"},{"input":"3f910b7a87859adf","output":"0.01664535"},{"input":"3ef3b318cf3768d6","output":"0.000018787"},{"input":"3d04442592c440d9","output":"9.000000000000001e-15"},{"input":"42eef5bcee000000","output":"272326284279808"},{"input":"293ef98780b84a63","output":"5.1519191502431785e-110"},{"input":"43170601f9000000","output":"1620132501651456"},{"input":"3eb0c6f7a0b5ed8b","output":"9.999999999999995e-7"},{"input":"000fffffffffffff","output":"2.225073858507201e-308"},{"input":"404e000000000000","output":"60"},{"input":"bbac6afb5040514f","output":"-3.0088619066824996e-21"},{"input":"42282b9c97000000","output":"51905448832"},{"input":"3e32b89d1fecf36e","output":"4.35885683e-9"},{"input":"448476800f000000","output":"1.2079159131531517e+22"},{"input":"3efcf43b4c6f3f73","output":"0.0000276127146"},{"input":"425cdbfee7800000","output":"495800000000"},{"input":"4332713874000000","output":"5191036859056128"},{"input":"3c62725dd1d243ac","output":"8e-18"},{"input":"4299170000c00000","output":"6896643747840"},{"input":"000ffffffffffffe","output":"2.2250738585072004e-308"},{"input":"451769831066ca5a","output":"7.07589000929147e+24"},{"input":"42674876e8000000","output":"800000000000"},{"input":"3f6a334ef7e2e2a7","output":"0.00319829391"},{"input":"3febc71bb66147e6","output":"0.8680552065"},{"input":"3f9049d67c92bc74","output":"0.015906669"},{"input":"44e61c57966be620","output":"8.3531906246208e+23"},{"input":"43d8493fba64ef00","output":"7000000000000000000"},{"input":"3ed1effcea46fe6a","output":"0.00000427662204"},{"input":"447e76b219dbfd6b","output":"8.991283988580108e+21"},{"input":"8000000000000002","output":"-1e-323"},{"input":"444b1ae4d6e2ef4f","output":"999999999999999900000"},{"input":"8010000000000000","output":"-2.2250738585072014e-308"},{"input":"c54b47eb46d01e34","output":"-6.596125047469528e+25"},{"input":"444b1ae4d6e2ef4d","output":"999999999999999600000"},{"input":"f517f6f6e966d1d5","output":"-1.124471416499248e+256"},{"input":"3ead290d46d85f90","output":"8.69046415e-7"},{"input":"415ac1f097400000","output":"7014338.36328125"},{"input":"3c2a6693defb97be","output":"7.1559224021621e-19"},{"input":"8010000000000000","output":"-2.2250738585072014e-308"},{"input":"3eb0c6f7a0b5ed8d","output":"0.000001"},{"input":"bc36b082c2148b8d","output":"-1.2299999999999998e-18"},{"input":"b01050b4899ffb4a","output":"-3.522532258589368e-77"},{"input":"42645f680b000000","output":"700000000000"},{"input":"4512918c84b5b6b1","output":"5.612e+24"},{"input":"462551bab2c3da82","output":"8.445427014958113e+29"},{"input":"3ec68fb880512ae3","output":"0.00000268952954"},{"input":"452adac260000000","output":"1.6232566394562634e+25"},{"input":"3e8f6f90c293fdf6","output":"2.34214981e-7"},{"input":"412b774000000000","output":"900000"},{"input":"420cedc124000000","output":"15530992768"},{"input":"beb0c6f7a0b5ed8d","output":"-0.000001"},{"input":"8000000000000002","output":"-1e-323"},{"input":"beb0c6f7a0b5ed8c","output":"-9.999999999999997e-7"},{"input":"33cf520dde9b9b42","output":"3.898162003770567e-59"},{"input":"6594eb081b86d6fa","output":"2.1699987584586865e+181"},{"input":"3a0e6a516e384ec2","output":"4.79868901195e-29"},{"input":"3e29f04b42c6a1bd","output":"3.0196561e-9"},{"input":"3edd4425601b6f3a","output":"0.0000069776047"},{"input":"beb0c6f7a0b5ed8f","output":"-0.0000010000000000000004"},{"input":"4246244619000000","output":"190195708416"},{"input":"3f80624dd2f1a9fc","output":"0.008"},{"input":"3e0fffa02167b6bf","output":"9.3128e-10"},{"input":"3d1384674c06d3af","output":"1.73347569070756e-14"},{"input":"4ea03eb67e286a32","output":"5.605933848871686e+70"},{"input":"3dcb7cdfd9d7bdba","output":"4.9999999999999995e-11"},{"input":"3f19affdd9513cae","output":"0.0000979899108"},{"input":"3fea314866c37ae1","output":"0.818515969"},{"input":"3dbdf7099c3da57d","output":"2.7253e-11"},{"input":"3eb0c6f7a0b5ed8f","output":"0.0000010000000000000004"},{"input":"45f1034388476f21","output":"8.424305371009e+28"},{"input":"3e3530fb2bb30860","output":"4.9339916e-9"},{"input":"3b5b3369a815089c","output":"9.000000000000001e-23"},{"input":"40cd2fd520000000","output":"14943.6650390625"},{"input":"04c2f03f58cb2ba0","output":"9.949905037358247e-286"},{"input":"41024364b0000000","output":"149612.5859375"},{"input":"45f3d2d3e4c9742b","output":"9.8161443974823e+28"},{"input":"3f9e198a14c15825","output":"0.0293943"},{"input":"8010000000000000","output":"-2.2250738585072014e-308"},{"input":"42cb48eb57e00000","output":"60000000000000"},{"input":"44bd0a8bc8400000","output":"1.3714316781489217e+23"},{"input":"c0be903b5b85ea7e","output":"-7824.231865281819"},{"input":"3b20ecca46737cd3","output":"7.000000000000001e-24"},{"input":"3f504a6bc589293a","output":"0.000994305845"},{"input":"3cbcd2b297d889bc","output":"4e-16"},{"input":"43de1652ad52f3c6","output":"8672044700000000000"},{"input":"3e21b0a8c2284661","output":"2.05939578e-9"},{"input":"3ce203af9ee75616","output":"2e-15"},{"input":"ffffffffffffffff","output":"NaN"},{"input":"4eecbbbcc01f86cf","output":"1.5864822838608535e+72"},{"input":"41640199e2000000","output":"10489039.0625"},{"input":"3f6ad9e6e07a20d4","output":"0.00327773183"},{"input":"444043561a882930","output":"600000000000000000000"},{"input":"41faec4914800000","output":"7227085128"},{"input":"3cc59e05f1e2674d","output":"6e-16"},{"input":"800ffffffffffffe","output":"-2.2250738585072004e-308"},{"input":"5346b404c6d4c3a4","output":"1.4799113879189208e+93"},{"input":"43783fa0e0c00000","output":"109205754224836600"},{"input":"460d06ee4d39781a","output":"2.87470214e+29"},{"input":"beb0c6f7a0b5ed8b","output":"-9.999999999999995e-7"},{"input":"3fc40ef6c678fe4c","output":"0.156706664"},{"input":"3eff4dfbc8afb95f","output":"0.0000298544151"},{"input":"8010000000000001","output":"-2.225073858507202e-308"},{"input":"40fd58f9f1000000","output":"120207.62133789062"},{"input":"43e158e460913d00","output":"10000000000000000000"},{"input":"3dc5fd7fe1796495","output":"4e-11"},{"input":"272ff0803fea4b5e","output":"6.184424134488928e-120"},{"input":"3f7fd0b2d568c960","output":"0.00776738984"},{"input":"3e7ad7f29abcaf49","output":"1.0000000000000001e-7"},{"input":"a6252a428a3faed7","output":"-6.253334750688957e-125"},{"input":"43d8fae27693b400","output":"7200000000000000000"},{"input":"beb0c6f7a0b5ed8e","output":"-0.0000010000000000000002"},{"input":"3dd33dcfe54a3802","output":"6.999999999999999e-11"},{"input":"41fa13b860000000","output":"7000000000"},{"input":"39e092958fc08dc9","output":"6.536736e-30"},{"input":"40f5f90000000000","output":"90000"},{"input":"3e9672854e77762a","output":"3.3449153e-7"},{"input":"3f79268c25d19780","output":"0.00614027734"},{"input":"3f6b0dcd8e8ccce2","output":"0.0033024802"},{"input":"88731f5c9bf9691f","output":"-5.79146842630434e-268"},{"input":"3ccc47b20e354a52","output":"7.849293621e-16"},{"input":"41e65a0bc0000000","output":"3000000000"},{"input":"4110b2a809374bc7","output":"273578.009"},{"input":"42c00e85e1c00000","output":"35309123502080"},{"input":"c44b1ae4d6e2ef52","output":"-1.0000000000000003e+21"},{"input":"3eb0c6f7a0b5ed8b","output":"9.999999999999995e-7"},{"input":"3de5fa45f7330fe3","output":"1.59908305e-10"},{"input":"41b7464069000000","output":"390479977"},{"input":"429f86d768100000","output":"8666000000000"},{"input":"beb0c6f7a0b5ed8d","output":"-0.000001"},{"input":"c415af1d78b58c3f","output":"-99999999999999980000"},{"input":"3c29d35025bff856","output":"6.999999999999999e-19"},{"input":"84298f5dfe4717d5","output":"-1.3114009432438656e-288"},{"input":"44dd77c621ec35a3","output":"5.5663227e+23"},{"input":"432550f7dca70000","output":"3000000000000000"},{"input":"3f19413b11b71759","output":"0.00009633944539818913"},{"input":"425d93f1b0000000","output":"508144566272"},{"input":"3fcf40a385fffff6","output":"0.244160118512809"},{"input":"37f9c7b949604188","output":"4.7350695895588316e-39"},{"input":"3e3ce52b870eaf83","output":"6.72768695e-9"},{"input":"395667ccadf55f30","output":"1.7260543857290004e-32"},{"input":"42c6bcc41e900000","output":"50000000000000"},{"input":"076fa9791d5ccba8","output":"7.315977230790299e-273"},{"input":"3eb0c6f7a0b5ed8b","output":"9.999999999999995e-7"},{"input":"44b0f0cf064dd592","output":"8e+22"},{"input":"d64ad295414bd52d","output":"-4.9214058344879674e+107"},{"input":"41affa1acd800000","output":"268242278.75"},{"input":"3cc203af9ee75616","output":"5e-16"},{"input":"41ffe5ce2b000000","output":"8562467504"},{"input":"45efd710d669b3f4","output":"7.88322709501e+28"},{"input":"3eb0c6f7a0b5ed8f","output":"0.0000010000000000000004"},{"input":"0e16f6fa96a11443","output":"8.6100447916803e-241"},{"input":"3fe2360f02fd3575","output":"0.569098955"},{"input":"40f6b82003000000","output":"93058.00073242188"},{"input":"7fe355a999f9c9fa","output":"1.0861785042043675e+308"},{"input":"3c127e44cbd710b7","output":"2.506301e-19"},{"input":"444b1ae4d6e2ef4e","output":"999999999999999700000"},{"input":"41f2a05f20000000","output":"5000000000"},{"input":"44e4804d0f3947af","output":"7.745125249493867e+23"},{"input":"43010d9316ec0000","output":"600000000000000"},{"input":"40b4d6720c000000","output":"5334.445495605469"},{"input":"41b59e2567000000","output":"362685799"},{"input":"5f62e1c9a755827f","output":"3.0904053298930483e+151"},{"input":"41186a0000000000","output":"400000"},{"input":"4146e36000000000","output":"3000000"},{"input":"3f0fe86eaeb7720c","output":"0.0000608595636"},{"input":"4548036816000000","output":"5.806061363370089e+25"},{"input":"4044000000000000","output":"40"},{"input":"41c02cd89d800000","output":"542748987"},{"input":"3b55755be276fe42","output":"7.1e-23"},{"input":"45b727b1e3bbf662","output":"7.1661433926784e+27"},{"input":"3e33941a342e5d85","output":"4.55848054e-9"},{"input":"6370b9b8962ded14","output":"1.0099408952749512e+171"},{"input":"3dfb7cdfd9d7bdbb","output":"4e-10"},{"input":"3eb0c6f7a0b5ed8d","output":"0.000001"},{"input":"3ccdbb30caa26a30","output":"8.252069375e-16"},{"input":"43e41cc2ef800000","output":"11593980112055304000"},{"input":"3f186bc7d3c7295c","output":"0.0000931587901"},{"input":"24e0f5d37895c7aa","output":"4.77886046915292e-131"},{"input":"41aeb9ded0000000","output":"257748840"},{"input":"3dd5fd7fe1796495","output":"8e-11"},{"input":"3f84070f8ce78ed8","output":"0.0097790923"},{"input":"3ee47f696ad5c7fc","output":"0.00000977406611"},{"input":"3fed123a7603ce7d","output":"0.908475142"},{"input":"06c95ab8241e6e4b","output":"5.721196278182412e-276"},{"input":"0000000000000000","output":"0"},{"input":"458a0a4f40000000","output":"1.0073842201368607e+27"},{"input":"59e8418bdc4d293d","output":"1.282768020347812e+125"},{"input":"41522cde50000000","output":"4764537.25"},{"input":"3f8102d44eabf48d","output":"0.00830617776"},{"input":"42e26bfa1f000000","output":"162039737090048"},{"input":"41de8a7d34000000","output":"2049570000"},{"input":"c44b1ae4d6e2ef52","output":"-1.0000000000000003e+21"},{"input":"42a05ef39b200000","output":"9000000000000"},{"input":"3d819799812dea11","output":"2e-12"},{"input":"415312d000000000","output":"5000000"},{"input":"3eb0bbc0dbe6d50b","output":"9.97389051e-7"},{"input":"3b582db34012b252","output":"8.000000000000001e-23"},{"input":"5e0456d58549dee9","output":"7.936731784362497e+144"},{"input":"e6aae79d597ef0cf","output":"-3.6582738188224675e+186"},{"input":"ffeffffffffffffe","output":"-1.7976931348623155e+308"},{"input":"432893226e494dc8","output":"3458587764762340"},{"input":"42625057bb800000","output":"629258705920"},{"input":"3eaaf4742d6e4de0","output":"8.03318552e-7"},{"input":"42e69fd673000000","output":"199006027776000"},{"input":"4313e52b9abe0000","output":"1400000000000000"},{"input":"187ba0128287c347","output":"9.687896370803095e-191"},{"input":"f08d602b3dc649c3","output":"-1.4593997865045006e+234"},{"input":"3e9a48b6e61846a4","output":"3.91662729e-7"},{"input":"ed1b132979d020ed","output":"-3.7333866654091594e+217"},{"input":"3f1790a62f879979","output":"0.0000898934776"},{"input":"800ffffffffffffe","output":"-2.2250738585072004e-308"},{"input":"0008c194cec8e2c8","output":"1.2176962667186645e-308"},{"input":"beb0c6f7a0b5ed8b","output":"-9.999999999999995e-7"},{"input":"413669f742c00000","output":"1468919.2607421875"},{"input":"6cc0251051ac07bf","output":"6.956952638354338e+215"},{"input":"000fffffffffffff","output":"2.225073858507201e-308"},{"input":"beb0c6f7a0b5ed8d","output":"-0.000001"},{"input":"42a5e0c1855b8000","output":"12027531800000"},{"input":"3fa6d22f10a8888f","output":"0.0445723255"},{"input":"444b1ae4d6e2ef51","output":"1.0000000000000001e+21"},{"input":"3bfd83c94fb6d2ac","output":"1e-19"},{"input":"5656e7a4236f666c","output":"8.40515806136863e+107"},{"input":"d56d4dd57d4b2897","output":"-3.28167834584002e+103"},{"input":"c44b1ae4d6e2ef4e","output":"-999999999999999700000"},{"input":"a6594f489d0b0983","output":"-5.982308736474358e-124"},{"input":"3e6320498a22cc9e","output":"3.56251786e-8"},{"input":"40b0b461bac00000","output":"4276.381755828857"},{"input":"451d282bdc11140b","output":"8.812138123903e+24"},{"input":"45538276d8000000","output":"9.434276198276807e+25"},{"input":"42cb48eb57e00000","output":"60000000000000"},{"input":"42703e3d53c00000","output":"1116218932224"},{"input":"2bdb5d16901752a3","output":"2.001681853611775e-97"},{"input":"66466edf086f46f6","output":"4.766026709529427e+184"},{"input":"433b7ad7ff400000","output":"7734892490129408"},{"input":"92b00185f569f9bb","output":"-1.1335602819809853e-218"},{"input":"42304c533c000000","output":"70000000000"},{"input":"41fea1e2b91147d1","output":"8222813073.080033"},{"input":"3c3423eeeb6061c0","output":"1.09181134030223e-18"},{"input":"fc43dbb8d9077890","output":"-3.870505299765502e+290"},{"input":"3a8212ecb889d6ce","output":"7.3e-27"},{"input":"3f74a540203e7f66","output":"0.00504040765"},{"input":"3f71456a4b58021c","output":"0.00421659013"},{"input":"44cfc3842bd1f071","output":"2.9999999999999997e+23"},{"input":"44bdf45051000000","output":"1.4145542096420099e+23"},{"input":"bc2ec6de17ccdce1","output":"-8.342075503080358e-19"},{"input":"800fffffffffffff","output":"-2.225073858507201e-308"},{"input":"4202a05f20000000","output":"10000000000"},{"input":"3f618f3349999999","output":"0.002143478556536138"},{"input":"4567cc1e94000000","output":"2.3015376544390406e+26"},{"input":"446e7e4171bf4d3a","output":"4.5e+21"},{"input":"5befadc5c8c7cebe","output":"7.195430624044365e+134"},{"input":"3b10ced0f6493875","output":"3.475787292985741e-24"},{"input":"3c31c85c7d77c036","output":"9.64e-19"},{"input":"a05c8659470ccfdb","output":"-8.509907038103424e-153"},{"input":"41f3edc6f7000000","output":"5349601136"},{"input":"3deadcc59e186d1d","output":"1.95449614e-10"},{"input":"3e7828c0be769dc1","output":"9e-8"},{"input":"433c99eea5000000","output":"8050549597405184"},{"input":"3e78547c620f793f","output":"9.06363984e-8"},{"input":"456b23f4bc800000","output":"2.624863563592471e+26"},{"input":"3b8e392010175ee6","output":"8e-22"},{"input":"a06d9b834304c568","output":"-1.7665808938010948e-152"},{"input":"c09eab9dd9f785bb","output":"-1962.9041517901776"},{"input":"b24e23b4e1dbc264","output":"-2.2358708024423873e-66"},{"input":"444b1ae4d6e2ef4d","output":"999999999999999600000"},{"input":"518560f123548935","output":"5.191461946377796e+84"},{"input":"3ea3ecfc2d3baf7c","output":"5.93832818e-7"},{"input":"3f3b25b064581e28","output":"0.000414233746"},{"input":"4019f7ec54b00e2e","output":"6.492112468"},{"input":"3f8525e56cd6c2f0","output":"0.0103261875"},{"input":"bc36b082c2148b8c","output":"-1.2299999999999996e-18"},{"input":"ffeffffffffffffe","output":"-1.7976931348623155e+308"},{"input":"40b2c94ccccccccd","output":"4809.3"},{"input":"5b7a6cf9da91a825","output":"4.689260978166267e+132"},{"input":"503dcb6c27a7f1da","output":"3.4499811893234574e+78"},{"input":"3f4816ca23c2f3b9","output":"0.000735138608"},{"input":"3bc79ca10c924224","output":"1.0000000000000001e-20"},{"input":"3f4e48f4baf1890a","output":"0.000924224374"},{"input":"444b1ae4d6e2ef4e","output":"999999999999999700000"},{"input":"3bb42549c67e61ee","output":"4.2660088e-21"},{"input":"3bc2e3b40a0e9b50","output":"8.000000000000001e-21"},{"input":"3c9cd2b297d889bc","output":"1e-16"},{"input":"cd9e153e1faa6557","output":"-7.92026869477411e+65"},{"input":"43c515dfe5000000","output":"3038733247895830500"},{"input":"3f1168c822b12279","output":"0.0000664112237"},{"input":"3eb0c6f7a0b5ed8e","output":"0.0000010000000000000002"},{"input":"3edb34e865fc2b78","output":"0.00000648657587"},{"input":"7ed4a0d399d7dddb","output":"8.841329873052179e+302"},{"input":"43a637256c400000","output":"800394669706969100"},{"input":"433cbf8ac5800000","output":"8091902087790592"},{"input":"fff0000000000001","output":"NaN"},{"input":"3ed013828a802988","output":"0.0000038328673"},{"input":"3bc5402a8b506eba","output":"9.000000000000001e-21"},{"input":"beb0c6f7a0b5ed8c","output":"-9.999999999999997e-7"},{"input":"c44b1ae4d6e2ef4e","output":"-999999999999999700000"},{"input":"8010000000000001","output":"-2.225073858507202e-308"},{"input":"4372eedaf450a980","output":"85266780000000000"},{"input":"3f939d8c494d469d","output":"0.0191556854"},{"input":"3bba285ca7af9a23","output":"5.5391007661819e-21"},{"input":"3ad4e2b6f61111e9","output":"2.6994010829e-25"},{"input":"40d032c3d70a3d71","output":"16587.06"},{"input":"3fb10ebeccbe6600","output":"0.0666312456"},{"input":"beb0c6f7a0b5ed8c","output":"-9.999999999999997e-7"},{"input":"3f21cc45b11e7f27","output":"0.000135787494"},{"input":"3597397f350615a8","output":"1.5518471001799255e-50"},{"input":"3a4dd290a39c84fc","output":"7.52826231764629e-28"},{"input":"0000000000000001","output":"5e-324"},{"input":"c415af1d78b58c3f","output":"-99999999999999980000"},{"input":"3edc27748ecae697","output":"0.00000671246583"},{"input":"3d2452ce15bb960e","output":"3.6101712030359e-14"},{"input":"3d9a636641c4df1a","output":"6e-12"},{"input":"a66d74a62c8349ff","output":"-1.3924530411765646e-123"},{"input":"414e848000000000","output":"4000000"},{"input":"3fe0000000000000","output":"0.5"},{"input":"3e432dc0f0e2eb35","output":"8.93078991e-9"},{"input":"c44b1ae4d6e2ef4f","output":"-999999999999999900000"},{"input":"441ea8c7c2000000","output":"141391056208819910000"},{"input":"3af1aa0c809606b3","output":"9.1322049e-25"},{"input":"2695f9354fcb9de0","output":"8.30998839712753e-123"},{"input":"43df399b1438a100","output":"9000000000000000000"},{"input":"3ed495089e5dc653","output":"0.00000490717"},{"input":"40f60d74e3bfc2f9","output":"90327.3056028"},{"input":"7feffffffffffffe","output":"1.7976931348623155e+308"},{"input":"412a36f000000000","output":"859000"},{"input":"44b265f9a4400000","output":"8.688370641627865e+22"},{"input":"3c0d83c94fb6d2ac","output":"2e-19"},{"input":"423096ac26c00000","output":"71247341248"},{"input":"4415af1d78b58c40","output":"100000000000000000000"},{"input":"3e9bcb79fca2d8d5","output":"4.14175244e-7"},{"input":"937f140162a0d50a","output":"-9.015259020701976e-215"},{"input":"3b2811cd4fbb3f09","output":"9.954928029328585e-24"},{"input":"864c5dff13623c15","output":"-2.5004034118492583e-278"},{"input":"3d2c25c268497682","output":"5e-14"},{"input":"3f0dc64ed145a13f","output":"0.0000567906192"},{"input":"000fffffffffffff","output":"2.225073858507201e-308"},{"input":"3fb47ae147ae147b","output":"0.08"},{"input":"4201bbacfb800000","output":"9520390000"},{"input":"3feba541b353a9f6","output":"0.86392293"},{"input":"227ecfdadf4324ba","output":"1.579214109111541e-142"},{"input":"3f7bbf65aa2a95be","output":"0.0067743274"},{"input":"3ea0c6f7a0b5ed8d","output":"5e-7"},{"input":"4561f42bc0800000","output":"1.736384274908073e+26"},{"input":"443043561a882930","output":"300000000000000000000"},{"input":"3df54eb00c50f8f4","output":"3.10063097e-10"},{"input":"5b4c2ad230d6a034","output":"6.247882817641683e+131"},{"input":"c6d55b8af3a2d13a","output":"-1.7327334717387823e+33"},{"input":"3fe999999999999a","output":"0.8"},{"input":"3eb3c985182a992f","output":"0.000001179408258758485"},{"input":"449636713f000000","output":"2.6224086761040582e+22"},{"input":"437689ca89000000","output":"101503239400194050"},{"input":"40a5a369eec00000","output":"2769.7068996429443"},{"input":"3f845e63fd9c48af","output":"0.00994566076"},{"input":"c415af1d78b58c3f","output":"-99999999999999980000"},{"input":"40d3880000000000","output":"20000"},{"input":"3c626024e08a2994","output":"7.96913e-18"},{"input":"4245135da7800000","output":"181038436096"},{"input":"4351c37937e08000","output":"20000000000000000"},{"input":"3cff86735614d6a6","output":"7e-15"},{"input":"0000000000000002","output":"1e-323"},{"input":"3fb0994f927c7e5d","output":"0.0648393376"},{"input":"431d16e90b800000","output":"2046991125184512"},{"input":"433e60f8d6000000","output":"8550871159799808"},{"input":"444b1ae4d6e2ef51","output":"1.0000000000000001e+21"},{"input":"4357f5fabb5801e2","output":"26977526792325000"},{"input":"3f1cb15cb3ff0352","output":"0.000109454425"},{"input":"40c7f6bcd8400000","output":"12269.47534942627"},{"input":"3fe6666666666667","output":"0.7000000000000001"},{"input":"3afca7f18b2f4735","output":"1.481481997761875e-24"},{"input":"bc36b082c2148b8e","output":"-1.23e-18"},{"input":"45333a52d2800000","output":"2.3245015629821983e+25"},{"input":"4253af2d80000000","output":"338173493248"},{"input":"44d8dacc4a800000","output":"4.694916260640387e+23"},{"input":"c415af1d78b58c3f","output":"-99999999999999980000"},{"input":"43dbc16d674ec800","output":"8000000000000000000"},{"input":"449d72c5bd000000","output":"3.4766451343104668e+22"},{"input":"3feb851eb851eb85","output":"0.86"},{"input":"f9109f9a0260d1aa","output":"-1.438855072852561e+275"},{"input":"7fffffffffffffff","output":"NaN"},{"input":"e32e96758a718972","output":"-5.77184737842541e+169"},{"input":"3e7ad7f29abcaf46","output":"9.999999999999997e-8"},{"input":"3d30e374a4f8e0b4","output":"6e-14"},{"input":"c44b1ae4d6e2ef4e","output":"-999999999999999700000"},{"input":"3f44a400d05d6ea7","output":"0.000629902265"},{"input":"42d2309ce5400000","output":"80000000000000"},{"input":"4370e0198eaee000","output":"76000000000000000"},{"input":"407e4d9a40000000","output":"484.85015869140625"},{"input":"40eb865a31000000","output":"56370.81848144531"},{"input":"3eabd1ce6a033657","output":"8.29087373e-7"},{"input":"000fffffffffffff","output":"2.225073858507201e-308"},{"input":"3c9977768a4f1150","output":"8.83552e-17"},{"input":"00ba259597b29657","output":"3.723429886983707e-305"},{"input":"be7ad7f29abcaf48","output":"-1e-7"},{"input":"4661c3065faba3f7","output":"1.1257888360028782e+31"},{"input":"4415af1d78b58c3f","output":"99999999999999980000"},{"input":"42028e4904c00000","output":"9962070168"},{"input":"4415af1d78b58c3f","output":"99999999999999980000"},{"input":"44ab60912d800000","output":"6.464262181340174e+22"},{"input":"3eb0c6f7a0b5ed8d","output":"0.000001"},{"input":"3b56dbb487af54b3","output":"7.5631517e-23"},{"input":"3edc8296df5320f6","output":"0.00000679734102"},{"input":"5c5f2267484d4b65","output":"9.051871677392913e+136"},{"input":"3f60624dd2f1a9fc","output":"0.002"},{"input":"3b0d03a3e67cd5fc","output":"3.0000000000000003e-24"},{"input":"3f46168b267620c3","output":"0.00067407412"},{"input":"3e68ca7db68bdbe1","output":"4.61768e-8"},{"input":"3a525637c699c5c9","output":"9.257712403777986e-28"},{"input":"bc36b082c2148b8e","output":"-1.23e-18"},{"input":"440a055690d9db80","output":"60000000000000000000"},{"input":"cfce687729c0072e","output":"-2.7507919971261877e+76"},{"input":"431ff46747000000","output":"2248612172005376"},{"input":"3eafcf420bd7e94f","output":"9.48e-7"},{"input":"40eb5847d1000000","output":"56002.24426269531"},{"input":"4040df696a81f2ed","output":"33.7454045424"},{"input":"3c334bea9d40f8b2","output":"1.046068e-18"},{"input":"beb0c6f7a0b5ed8e","output":"-0.0000010000000000000002"},{"input":"42f5b3d3cd000000","output":"381793548107776"},{"input":"3c970ef54646d496","output":"7.999999999999999e-17"},{"input":"3e0dfaf3ba91c476","output":"8.7254103e-10"},{"input":"3f7b4d23f26804d4","output":"0.00666536371"},{"input":"3b25fcc88b4259d2","output":"9.09379e-24"},{"input":"c415af1d78b58c3f","output":"-99999999999999980000"},{"input":"4413d6be7ac00000","output":"91490519433806350000"},{"input":"3fb38ae2629c6892","output":"0.0763379565"},{"input":"40f86a0000000000","output":"100000"},{"input":"42d476b081e80000","output":"90000000000000"},{"input":"444b1ae4d6e2ef4d","output":"999999999999999600000"},{"input":"2acbd0d98ffecdfe","output":"1.552398986377937e-102"},{"input":"4008000000000000","output":"3"},{"input":"beb0c6f7a0b5ed8b","output":"-9.999999999999995e-7"},{"input":"44da402800000000","output":"4.958600099163588e+23"},{"input":"800ffffffffffffe","output":"-2.2250738585072004e-308"},{"input":"3f40624dd2f1a9fc","output":"0.0005"},{"input":"3eb0c6f7a0b5ed8b","output":"9.999999999999995e-7"},{"input":"444b1ae4d6e2ef50","output":"1e+21"},{"input":"437a4b61c8000000","output":"118419723741298690"},{"input":"44b1086266000000","output":"8.043489451603699e+22"},{"input":"4084e94257c5c000","output":"669.1573939751834"},{"input":"410d2b24415c6401","output":"238948.5319145024"},{"input":"b983ca08298f0756","output":"-1.2196028131096366e-31"},{"input":"3eb0c6f7a0b5ed8e","output":"0.0000010000000000000002"},{"input":"3c36b082c2148b8c","output":"1.2299999999999996e-18"},{"input":"3b910022090d2561","output":"9e-22"},{"input":"daac1099ffc4bd45","output":"-6.079262392237289e+128"},{"input":"4376345785d8a000","output":"100000000000000000"},{"input":"3da3ca8cb153a753","output":"9e-12"},{"input":"4288eef745c00000","output":"3426828728320"},{"input":"3ebc21dcee3026d6","output":"0.0000016768144"},{"input":"429808b683000000","output":"6606425210880"},{"input":"c415af1d78b58c41","output":"-100000000000000020000"},{"input":"0000000000000003","output":"1.5e-323"},{"input":"444b1ae4d6e2ef51","output":"1.0000000000000001e+21"},{"input":"8010000000000000","output":"-2.2250738585072014e-308"},{"input":"800fffffffffffff","output":"-2.225073858507201e-308"},{"input":"3f7fa97e132b55ef","output":"0.00773"},{"input":"3c970ef54646d496","output":"7.999999999999999e-17"},{"input":"4300779211800000","output":"579383608737792"},{"input":"3cd203af9ee75616","output":"1e-15"},{"input":"7ff0000000000000","output":"Infinity"},{"input":"4574adf4b7320335","output":"4e+26"},{"input":"41de393cc8000000","output":"2028270368"},{"input":"3fade0f011c2c27f","output":"0.058356764"},{"input":"2b16ea223b2c10ed","output":"4.0923564894240995e-101"},{"input":"8000000000000001","output":"-5e-324"},{"input":"4444f43c401cafc1","output":"773067786820000000000"},{"input":"72ae7fa4a2be6fd9","output":"2.6030738466375487e+244"},{"input":"3e04d32d555e7749","output":"6.06084664e-10"},{"input":"44fa784379d99db4","output":"2e+24"},{"input":"40a406f115000000","output":"2563.470863342285"},{"input":"c44b1ae4d6e2ef50","output":"-1e+21"},{"input":"3e0e09cf1a1bed79","output":"8.74230067e-10"},{"input":"3a7c76bae1d846cb","output":"5.7482164307e-27"},{"input":"44e65a59ef0ac5e9","output":"8.4447e+23"},{"input":"3edda61da7fd7827","output":"0.00000706884623"},{"input":"2d6d82c0439e7a4a","output":"7.243550570719996e-90"},{"input":"421306f9f2000000","output":"20430355584"},{"input":"445b1ae4d6e2ef50","output":"2e+21"},{"input":"3f4ce7e84213f55f","output":"0.000882137687"},{"input":"455368f20262da14","output":"9.3860723883607e+25"},{"input":"3f16904532e48e84","output":"0.00008607313495595"},{"input":"beb0c6f7a0b5ed8f","output":"-0.0000010000000000000004"},{"input":"b82f17a5a1c50bd7","output":"-4.5686133216014626e-38"},{"input":"c786bc2714325fc7","output":"-3.777495041350066e+36"},{"input":"beb0c6f7a0b5ed8f","output":"-0.0000010000000000000004"},{"input":"3fe24c95df9d2b6c","output":"0.571848809"},{"input":"3f7459beaa78a3a6","output":"0.0049683998"},{"input":"bade4ead4d27ecc9","output":"-3.9171308344603286e-25"},{"input":"fffffffffffffffe","output":"NaN"},{"input":"413794ac10400000","output":"1545388.0634765625"},{"input":"444fd544f2800000","output":"1.1744334814901216e+21"},{"input":"3e29c511dc3a41e0","output":"3.0000000000000004e-9"},{"input":"3bc0873d88ccc7e6","output":"7e-21"},{"input":"409e2eafecc00000","output":"1931.6718015670776"},{"input":"40eb701cea000000","output":"56192.903564453125"},{"input":"d96a3ec943169503","output":"-5.421745248134003e+122"},{"input":"c44b1ae4d6e2ef52","output":"-1.0000000000000003e+21"},{"input":"4415af1d78b58c3f","output":"99999999999999980000"},{"input":"3eb051071834956f","output":"9.72540051e-7"},{"input":"800ffffffffffffd","output":"-2.2250738585072e-308"},{"input":"411ca34549000000","output":"469201.3212890625"},{"input":"3c36b082c2148b90","output":"1.2300000000000004e-18"},{"input":"439e4aca1b935583","output":"545694797299802300"},{"input":"3d36849b86a12b9b","output":"8e-14"},{"input":"42c6a0420fc00000","output":"49755117813760"},{"input":"3e601b2b29a4692c","output":"3.0000000000000004e-8"},{"input":"42f879b64b000000","output":"430576455647232"},{"input":"3bfa90352e248a68","output":"9e-20"},{"input":"420177798a000000","output":"9377362240"},{"input":"2767cacebcbe35d0","output":"7.37100379398871e-119"},{"input":"4208d7336e213b12","output":"13336210884.153843"},{"input":"3f12021e82798c83","output":"0.000068696129"},{"input":"3b422246700e05be","output":"3.0000000000000006e-23"},{"input":"3d36ac616b2612ec","output":"8.0551961506717e-14"},{"input":"43f158e460913d00","output":"20000000000000000000"},{"input":"88953a9839ad6551","output":"-2.571763623221463e-267"},{"input":"3eb0c6f7a0b5ed8e","output":"0.0000010000000000000002"},{"input":"3f137b50449ba5e6","output":"0.0000743167630862445"},{"input":"3e0e1e27bcb2701f","output":"8.7654316565e-10"},{"input":"44cfc3842bd1f071","output":"2.9999999999999997e+23"},{"input":"3f14d7f0e3c8d64e","output":"0.0000795117166"},{"input":"3f1797cc39ffd60e","output":"0.00008999999999999999"},{"input":"be7ad7f29abcaf4a","output":"-1.0000000000000002e-7"},{"input":"4490f0cf064dd592","output":"2e+22"},{"input":"c44b1ae4d6e2ef4f","output":"-999999999999999900000"},{"input":"3e6e97e17824f74d","output":"5.69844323e-8"},{"input":"bc36b082c2148b8c","output":"-1.2299999999999996e-18"},{"input":"186384c30d9fc1f6","output":"3.422484220491014e-191"},{"input":"3edbba77d169125f","output":"0.00000661096353"},{"input":"3a8bbcbeada63a30","output":"1.1203e-26"},{"input":"3f12599ed7c6fbd2","output":"0.00007"},{"input":"434d0233e0000000","output":"16330392298586112"},{"input":"3df50fb4ec399767","output":"3.06483044e-10"},{"input":"3b912508d7431ddb","output":"9.0763106872e-22"},{"input":"43a4ce1345000000","output":"749578456517312500"},{"input":"66ca0b6768e2cf47","output":"1.4165246192847762e+187"},{"input":"57ddc5127eea2e96","output":"1.832797460820672e+115"},{"input":"3b4c3f7d719167ed","output":"4.6732408903e-23"},{"input":"449bae27c1a64e83","output":"3.2679123315e+22"},{"input":"3eb0c6f7a0b5ed8d","output":"0.000001"},{"input":"3ed99a5dcdc10a43","output":"0.00000610422941"},{"input":"451e78c2f0800000","output":"9.209513641146225e+24"},{"input":"77652f125e82f553","output":"1.3661285161630279e+267"},{"input":"3c5bab8cbabb6582","output":"6.0000000000000004e-18"},{"input":"4156e36000000000","output":"6000000"},{"input":"42c6bcc41e900000","output":"50000000000000"},{"input":"41086a0000000000","output":"200000"},{"input":"3e3112d2c71f5bf0","output":"3.97524068e-9"},{"input":"3fe35f7aa3d78280","output":"0.605405159"},{"input":"c415af1d78b58c40","output":"-100000000000000000000"},{"input":"fff0000000000001","output":"NaN"},{"input":"810fad5947423fd0","output":"-1.4435119919073622e-303"},{"input":"4330c3a9a9800000","output":"4718733087997952"},{"input":"3f695a40c515690b","output":"0.0030947938"},{"input":"40f7beeb2e000000","output":"97262.69873046875"},{"input":"3a1b41261e8ccd86","output":"8.6e-29"},{"input":"451fd2bcc0c00000","output":"9.61796981161081e+24"},{"input":"0000000000000000","output":"0"},{"input":"407fff4f671ffd54","output":"511.956885457"},{"input":"c6a8080b47dd163f","output":"-2.437075735003244e+32"},{"input":"45f37297e3484884","output":"9.63e+28"},{"input":"3fd9fc96e9e6e3fa","output":"0.40604184"},{"input":"42aecf736d800000","output":"16938171809792"},{"input":"454c44eb3c800000","output":"6.835076642877303e+25"},{"input":"2640af08bbc5363b","output":"1.971718333049882e-124"},{"input":"3d819799812dea11","output":"2e-12"},{"input":"4428689375000000","output":"225128676506705330000"},{"input":"41c4dc9380000000","output":"700000000"},{"input":"f60a1ac4dfd840af","output":"-4.013680082825338e+260"},{"input":"4540caf613000000","output":"4.060254082302031e+25"},{"input":"45491f1dc98913c8","output":"6.07401766581461e+25"},{"input":"fffffffffffffffe","output":"NaN"},{"input":"3a655837f6ed58cc","output":"2.15525422012e-27"},{"input":"42c93e30ff3212b3","output":"55509801395237.4"},{"input":"8e2b5887ecbd1adb","output":"-2.0505222598504942e-240"},{"input":"42446c1234000000","output":"175424956416"},{"input":"43b6ddd8ce000000","output":"1647711417962332200"},{"input":"0000000000000002","output":"1e-323"},{"input":"4415af1d78b58c40","output":"100000000000000000000"},{"input":"f3883ba934876e88","output":"-3.3887109777953796e+248"},{"input":"3eab02fc5280f78f","output":"8.05010278e-7"},{"input":"66e03e4ffd49a8e6","output":"3.5338203724371955e+187"},{"input":"0010000000000001","output":"2.225073858507202e-308"},{"input":"44205f7aac000000","output":"151013952838057330000"},{"input":"40c546d8d4fdf3b6","output":"10893.694"},{"input":"41c9e71293400000","output":"869147942.5"},{"input":"3f4d7dbf487fcb92","output":"0.0009"},{"input":"4573adfe3f2ec32e","output":"3.8066e+26"},{"input":"8010000000000001","output":"-2.225073858507202e-308"},{"input":"3fb47ae147ae147b","output":"0.08"},{"input":"41340a2ec8000000","output":"1313326.78125"},{"input":"3f32b7cfc083126f","output":"0.0002856142241507769"},{"input":"3be1ee53fb409a93","output":"3.0376242962665857e-20"},{"input":"fff0000000000001","output":"NaN"},{"input":"4415af1d78b58c42","output":"100000000000000030000"},{"input":"40943bc6fe000000","output":"1294.9443283081055"},{"input":"40e403728a47ecff","output":"40987.57938"},{"input":"a45d77b0c7c4dd28","output":"-1.6216825118993381e-133"},{"input":"3eb5028d1edf070c","output":"0.00000125229155"},{"input":"3f486e5c69b95d53","output":"0.00074557793"},{"input":"3e19e3750a5d923c","output":"1.5069093e-9"},{"input":"3ef96c48384a3a69","output":"0.0000242452402"},{"input":"424f3a8f35500000","output":"268252900000"},{"input":"414be90523c00000","output":"3658250.279296875"},{"input":"7feffffffffffffd","output":"1.7976931348623153e+308"},{"input":"44702dd3a0c00000","output":"4.775201038042235e+21"},{"input":"30632b0651258414","output":"1.3243091313542471e-75"},{"input":"45ec45d492766062","output":"7e+28"},{"input":"800ffffffffffffd","output":"-2.2250738585072e-308"},{"input":"439a181f90000000","output":"470071886940733440"},{"input":"410433fbbf000000","output":"165503.46826171875"},{"input":"44d68d6066cad11e","output":"4.26e+23"},{"input":"8010000000000001","output":"-2.225073858507202e-308"},{"input":"45251e76afc00000","output":"1.2765651293158076e+25"},{"input":"3e000d7e75ebf0a7","output":"4.67195376e-10"},{"input":"41627a10e4400000","output":"9687175.1328125"},{"input":"beb0c6f7a0b5ed8d","output":"-0.000001"},{"input":"3e3b4f2f07604180","output":"6.35844454e-9"},{"input":"ffefffffffffffff","output":"-1.7976931348623157e+308"},{"input":"be7ad7f29abcaf46","output":"-9.999999999999997e-8"},{"input":"3f92577c80be883a","output":"0.0179118589"},{"input":"bc36b082c2148b90","output":"-1.2300000000000004e-18"},{"input":"be7ad7f29abcaf46","output":"-9.999999999999997e-8"},{"input":"0000000000000001","output":"5e-324"},{"input":"3af168958a4ae6ca","output":"9e-25"},{"input":"4373fbe85edc9000","output":"90000000000000000"},{"input":"44a7ebf4c97ca7f7","output":"5.64835263649e+22"},{"input":"44d0cbaa17c00000","output":"3.17259236995578e+23"},{"input":"3fa47ae147ae147b","output":"0.04"},{"input":"41c7d78400000000","output":"800000000"},{"input":"3bf79ca10c924224","output":"8.000000000000001e-20"},{"input":"4300ce6e7b000000","output":"591321691586560"},{"input":"401c000000000000","output":"7"},{"input":"be7ad7f29abcaf48","output":"-1e-7"},{"input":"28add666195b993c","output":"9.692905973311057e-113"},{"input":"4351c37937e08000","output":"20000000000000000"},{"input":"4551695d60000000","output":"8.419723951551157e+25"},{"input":"42cb48eb57e00000","output":"60000000000000"},{"input":"3bc8d5bdaaa99aa9","output":"1.0518e-20"},{"input":"3ee2ba82ccc6c5dc","output":"0.00000893047254"},{"input":"4415af1d78b58c3f","output":"99999999999999980000"},{"input":"3ae7361cb863de63","output":"6.0000000000000005e-25"},{"input":"3e379c3bf4725133","output":"5.49719898e-9"},{"input":"3feca00b474ab118","output":"0.894536628"},{"input":"8669e4f9fa4b8474","output":"-9.129784432388159e-278"},{"input":"22ac4cf03b88acb2","output":"1.1603974970504338e-141"},{"input":"c44b1ae4d6e2ef4f","output":"-999999999999999900000"},{"input":"43048ed63a000000","output":"723318785179648"},{"input":"4018000000000000","output":"6"},{"input":"43d263ec4e400000","output":"5300650144809615000"},{"input":"44d22bd534908ff8","output":"3.43244679e+23"},{"input":"424a3928b9800000","output":"225256239872"},{"input":"7e144b81e045d2f7","output":"2.1236537250744363e+299"},{"input":"450e494ee1c00000","output":"4.5767453068409953e+24"},{"input":"7feffffffffffffd","output":"1.7976931348623153e+308"},{"input":"bc36b082c2148b8c","output":"-1.2299999999999996e-18"},{"input":"4079000000000000","output":"400"},{"input":"407f400000000000","output":"500"},{"input":"41870e743f400000","output":"48352903.90625"},{"input":"3fb5569b6798f932","output":"0.0833527687"},{"input":"456f423550c00000","output":"3.023148807360762e+26"},{"input":"3be1b578c96db19b","output":"3e-20"},{"input":"61c55dae34eda572","output":"9.61235196533108e+162"},{"input":"3eb0c6f7a0b5ed8b","output":"9.999999999999995e-7"},{"input":"e9e222972d8eaa8a","output":"-1.1105229154896656e+202"},{"input":"3e42cd4bfa886557","output":"8.75533586e-9"},{"input":"3ee094cdacf19026","output":"0.0000079065625"},{"input":"3fe0000000000000","output":"0.5"},{"input":"0000000000000000","output":"0"},{"input":"9e5d1891d732c210","output":"-2.0210416808359448e-162"},{"input":"01a19f07bd86ee01","output":"8.222617970605746e-301"},{"input":"3e7ad7f29abcaf47","output":"9.999999999999998e-8"},{"input":"3e61cd79c74986ae","output":"3.316e-8"},{"input":"49547474d23eb91a","output":"1.8246387254272612e+45"},{"input":"41389cf554000000","output":"1613045.328125"},{"input":"3fa73c4d866d2d5a","output":"0.0453819491"},{"input":"3ae357c299a88ea8","output":"5.0000000000000005e-25"},{"input":"3eaad7f29abcaf48","output":"8e-7"},{"input":"3d2c25c268497682","output":"5e-14"},{"input":"445256deb4800000","output":"1.3532041292828492e+21"},{"input":"3e701b2b29a4692c","output":"6.000000000000001e-8"},{"input":"7fffffffffffffff","output":"NaN"},{"input":"3cf5a84719523ce2","output":"4.80889436788857e-15"},{"input":"412b774000000000","output":"900000"},{"input":"c44b1ae4d6e2ef50","output":"-1e+21"},{"input":"e98a304f26df4a7b","output":"-2.505769987881287e+200"},{"input":"3a08e26f7e09a1d8","output":"3.926084006670862e-29"},{"input":"3e7ad7f29abcaf48","output":"1e-7"},{"input":"3b8e392010175ee6","output":"8e-22"},{"input":"05ffcd3eaaaad242","output":"8.759814089818086e-280"},{"input":"3eb0c6f7a0b5ed8e","output":"0.0000010000000000000002"},{"input":"4180138945000000","output":"33714472.625"},{"input":"3ea00d3e266fce56","output":"4.7837882e-7"},{"input":"368ddcb1a4370ddd","output":"6.538389794360894e-46"},{"input":"3f847ae147ae147b","output":"0.01"},{"input":"40ed4c0000000000","output":"60000"},{"input":"44df7fdb4a000000","output":"5.950075956342508e+23"},{"input":"f76f8cfc42799743","output":"-2.0346771284314958e+267"},{"input":"3eabdfc64d016c10","output":"8.30713498e-7"},{"input":"3e7ad7f29abcaf4a","output":"1.0000000000000002e-7"},{"input":"3f1bda883f88bad2","output":"0.00010625321"},{"input":"4195752a00000000","output":"90000000"},{"input":"410bbb87ad000000","output":"227184.95947265625"},{"input":"3f64b921cdf1c225","output":"0.00252968409"},{"input":"40ed4c0000000000","output":"60000"},{"input":"458625612ec00000","output":"8.567324254161821e+26"},{"input":"3ef05e5f95d7667a","output":"0.0000156103573"},{"input":"3ad7361cb863de63","output":"3.0000000000000002e-25"},{"input":"4209aa9ca8000000","output":"13779571968"},{"input":"3ee227ca43228205","output":"0.00000865718366"},{"input":"41fd4f93e0000000","output":"7868071424"},{"input":"440a93103d400000","output":"61276547898092290000"},{"input":"3bc2e3b40a0e9b50","output":"8.000000000000001e-21"},{"input":"3c158ebc2b1d1470","output":"2.921594e-19"},{"input":"43c546f83fc00000","output":"3066371351708172300"},{"input":"c415af1d78b58c3e","output":"-99999999999999970000"},{"input":"79c8c67fc7480de0","output":"4.391839474007636e+278"},{"input":"982e3b1f102706bc","output":"-3.3130231458198374e-192"},{"input":"3f33a92a30553261","output":"0.0003"},{"input":"3e7ad7f29abcaf48","output":"1e-7"},{"input":"3f80624dd2f1a9fc","output":"0.008"},{"input":"41377eee08c00000","output":"1539822.0341796875"},{"input":"3cbcd2b297d889bc","output":"4e-16"},{"input":"448efa3159000000","output":"1.8285779547237191e+22"},{"input":"3f7f263ac4228c78","output":"0.00760481792"},{"input":"adf685167e21f3aa","output":"-2.830135515085506e-87"},{"input":"4310737aae000000","output":"1157642592452608"},{"input":"4477b7883c069166","output":"7e+21"},{"input":"41255c08e6000000","output":"699908.44921875"},{"input":"444b1ae4d6e2ef52","output":"1.0000000000000003e+21"},{"input":"3f8141b1ee529823","output":"0.0084260846"},{"input":"3f04f8b588e368f0","output":"0.000039999999999999996"},{"input":"6c75c368a80282f0","output":"2.930636752275851e+214"},{"input":"3c52622528d00720","output":"3.98626e-18"},{"input":"4363586c056d0308","output":"43561964225960000"},{"input":"3faa3d0d51a2341d","output":"0.05124704"},{"input":"40f4728c04000000","output":"83752.7509765625"},{"input":"4851508e476043ce","output":"2.3567508924602516e+40"},{"input":"3fb869d50dff6b31","output":"0.0953648719"},{"input":"3e93bccf4b1d19dc","output":"2.94112236e-7"},{"input":"426a3185c5000000","output":"900000000000"},{"input":"414e848000000000","output":"4000000"},{"input":"4295d3ef79800000","output":"6000000000000"},{"input":"4187d78400000000","output":"50000000"},{"input":"34cba569c5bc0a9f","output":"2.2549939356697745e-54"},{"input":"794cbe4973ac2f22","output":"1.9903194823864295e+276"},{"input":"3f9271db2a2bcf46","output":"0.0180124516"},{"input":"dd17a6d3cce41be1","output":"-2.81656510935758e+140"},{"input":"3c29d35025bff856","output":"6.999999999999999e-19"},{"input":"8ccfdefabd41c97d","output":"-5.697829409643704e-247"},{"input":"4146e36000000000","output":"3000000"},{"input":"427d1377ec800000","output":"1998090848256"},{"input":"0bb2a2e2613c766b","output":"2.541923996974099e-252"},{"input":"3c1d83c94fb6d2ac","output":"4e-19"},{"input":"455b6c004e8c198b","output":"1.326040734786873e+26"},{"input":"3f08500337e241ff","output":"0.0000463725073"},{"input":"3fa702d3288d6625","output":"0.0449434268"},{"input":"43ba29df73000000","output":"1885283604045496300"},{"input":"440b236e3b000000","output":"62576891612513700000"},{"input":"42792e3fea800000","output":"1730401970176"},{"input":"40c5170efe000000","output":"10798.117126464844"},{"input":"3e6ff94688153fcf","output":"5.95557177e-8"},{"input":"be7ad7f29abcaf48","output":"-1e-7"},{"input":"3f8475b040dd0d5f","output":"0.00999009798"},{"input":"ff8092681b63eee1","output":"-1.4546480831635763e+306"},{"input":"41f1e1917ec00000","output":"4799928300"},{"input":"3df55c52204b88f1","output":"3.1083805e-10"},{"input":"3eae056a75f60377","output":"8.94700161e-7"},{"input":"412dab7c06000000","output":"972222.01171875"},{"input":"3e74cad0f4a6bdc1","output":"7.74571706e-8"},{"input":"d6a4093ea6e9cd56","output":"-2.35278313988171e+109"},{"input":"3f63598ebc43dc2f","output":"0.00236204031"},{"input":"3c60e6de483fb1d8","output":"7.33e-18"},{"input":"000fffffffffffff","output":"2.225073858507201e-308"},{"input":"436aa535d3d0c000","output":"60000000000000000"},{"input":"415bf65e80000000","output":"7330170"},{"input":"579f8d820745d4b7","output":"1.2141037645421562e+114"},{"input":"3f4ab7743d9a0a72","output":"0.00081532646"},{"input":"3d5c25c268497682","output":"4e-13"},{"input":"3b55bea26a034f3c","output":"7.19470637152e-23"},{"input":"3e3180116de68d68","output":"4.074598185252398e-9"},{"input":"3e392e76306f1e8d","output":"5.86302274e-9"},{"input":"3fbaeffb20d94fa3","output":"0.105224319"},{"input":"588c41cf8dd8bc00","output":"3.5628332039559014e+118"},{"input":"402976f7c0000000","output":"12.732358932495117"},{"input":"3b0357c299a88ea8","output":"2.0000000000000002e-24"},{"input":"3eb0c6f7a0b5ed8b","output":"9.999999999999995e-7"},{"input":"3e6ee5e424bf15f8","output":"5.7552033e-8"},{"input":"4395e9e72cd6a84a","output":"394761831034000000"},{"input":"d1b2b6ad0714da3b","output":"-3.6354285245654456e+85"},{"input":"3f9eb851eb851eb8","output":"0.03"},{"input":"3d6faa7ab552a552","output":"9e-13"},{"input":"beb0c6f7a0b5ed8b","output":"-9.999999999999995e-7"},{"input":"3f16fbf685c0e0f2","output":"0.0000876778808"},{"input":"bc36b082c2148b8e","output":"-1.23e-18"},{"input":"3e0b38f6593df25a","output":"7.92279286e-10"},{"input":"c44b1ae4d6e2ef51","output":"-1.0000000000000001e+21"},{"input":"44b0f0cf064dd592","output":"8e+22"},{"input":"40a22189ef44a032","output":"2320.7694035955"},{"input":"40f86a0000000000","output":"100000"},{"input":"3cbcd2b297d889bc","output":"4e-16"},{"input":"3e5ce002a9fd1bac","output":"2.68919772e-8"},{"input":"3f70624dd2f1a9fc","output":"0.004"},{"input":"42b6426f57c00000","output":"24474591674368"},{"input":"3e9c29becc5308ac","output":"4.1966241e-7"},{"input":"6a36da0d58ed2943","output":"4.4779254353287685e+203"},{"input":"a929c4e660b07188","output":"-2.1430461805354086e-110"},{"input":"3f789374bc6a7efa","output":"0.006"},{"input":"3f44a2b2f0baa485","output":"0.000629746793"},{"input":"452f60edda000000","output":"1.896721758865498e+25"},{"input":"3e3da7bde2b0a71a","output":"6.90464889e-9"},{"input":"3e5084e41f246957","output":"1.53846162e-8"},{"input":"b3d82f8cd9df557d","output":"-6.020329919521809e-59"},{"input":"40c1940000000000","output":"9000"},{"input":"419312d000000000","output":"80000000"},{"input":"422c988b57800000","output":"61409176512"},{"input":"3e10b4e17ed7eeb6","output":"9.724501164164394e-10"},{"input":"4474542ba12a337c","output":"6e+21"},{"input":"40bfdfe6237a94d4","output":"8159.898978864036"},{"input":"4262c0cf74afa000","output":"644353860989"},{"input":"45335b248ab3ee85","output":"2.34e+25"},{"input":"9493b6ef5dd71e37","output":"-1.4991696270129282e-209"},{"input":"42086f33bd000000","output":"13118109600"},{"input":"7feffffffffffffd","output":"1.7976931348623153e+308"},{"input":"436d02077216dd4f","output":"65320042613893750"},{"input":"0010000000000000","output":"2.2250738585072014e-308"},{"input":"874fb6984e3a603d","output":"-1.831955241528593e-273"},{"input":"41f5c1be7e000000","output":"5840300000"},{"input":"3e18fcd64b6cd140","output":"1.45447236e-9"},{"input":"422bf08eb0000000","output":"60000000000"},{"input":"3dd07e1fe91b0b70","output":"6e-11"},{"input":"3e78779e83587251","output":"9.11476555e-8"},{"input":"43852a101f800000","output":"190631143911981060"},{"input":"43bbc16d674ec800","output":"2000000000000000000"},{"input":"3f106684a9c05812","output":"0.0000625627967"},{"input":"40b7700000000000","output":"6000"},{"input":"3fd51eb851eb851f","output":"0.33"},{"input":"beb0c6f7a0b5ed8f","output":"-0.0000010000000000000004"},{"input":"452e936c1d800000","output":"1.8481978417739849e+25"},{"input":"c4e53f15de81b763","output":"-8.026673348516041e+23"},{"input":"085ecb98954880ee","output":"2.3316763789101161e-268"},{"input":"39dd61bbf1d36e4c","output":"5.79453322e-30"},{"input":"c415af1d78b58c3f","output":"-99999999999999980000"},{"input":"4200f0bfa0a0737c","output":"9094820884.056389"},{"input":"45e4c1f05808cafe","output":"5.139326297212392e+28"},{"input":"6ec30c462613269d","output":"3.5252904690331955e+225"},{"input":"4324d7e891c00000","output":"2933446705938432"},{"input":"3ee2b872295deb5f","output":"0.00000892662619"},{"input":"444b1ae4d6e2ef4f","output":"999999999999999900000"},{"input":"3ea57f4acb9bedc9","output":"6.40667529e-7"},{"input":"43c592667c000000","output":"3108835008316440600"},{"input":"3e7469978618dad8","output":"7.60423702e-8"},{"input":"3efa5b89e0316231","output":"0.00002513654"},{"input":"445348e44a000000","output":"1.422962167319051e+21"},{"input":"f3d22d4768158beb","output":"-8.13383839342848e+249"},{"input":"41675d7200000000","output":"12250000"},{"input":"3e04807fd8ed2827","output":"5.966853e-10"},{"input":"44bf847eac000000","output":"1.4883745885723344e+23"},{"input":"44b0f0cf064dd592","output":"8e+22"},{"input":"3ea7cb1f63f896e3","output":"7.091e-7"},{"input":"4415af1d78b58c3f","output":"99999999999999980000"},{"input":"42e53f8183790000","output":"186900000000000"},{"input":"beb0c6f7a0b5ed8b","output":"-9.999999999999995e-7"},{"input":"ed697bb1311f15af","output":"-1.1244505438383658e+219"},{"input":"40e9f1f4f9800000","output":"53135.65545654297"},{"input":"448a893914000000","output":"1.5664105675633585e+22"},{"input":"43e0cf3975203120","output":"9690000000000000000"},{"input":"4209db0f0b400000","output":"13881172328"},{"input":"3f1797cc39ffd60e","output":"0.00008999999999999999"},{"input":"3d6faa7ab552a552","output":"9e-13"},{"input":"3ddb7cdfd9d7bdbb","output":"1e-10"},{"input":"408de51fc4800000","output":"956.6405115127563"},{"input":"3b2132bde30c837c","output":"7.113012918271124e-24"},{"input":"431b4c8eaa744000","output":"1921000000000000"},{"input":"3f7b87aea50c70ff","output":"0.00672119351"},{"input":"3e42c9e365d45d73","output":"8.7491358e-9"},{"input":"bade74baa48fd766","output":"-3.936342243005466e-25"},{"input":"0000000000000002","output":"1e-323"},{"input":"45019e7b9ec00000","output":"2.6625191533007775e+24"},{"input":"3e66958096e72b04","output":"4.20659657e-8"},{"input":"c415af1d78b58c40","output":"-100000000000000000000"},{"input":"40f5f90000000000","output":"90000"},{"input":"3f4af2a0ff9105a6","output":"0.00082238065"},{"input":"3eb0c6f7a0b5ed8f","output":"0.0000010000000000000004"},{"input":"455a59df91000000","output":"1.2742594399694132e+26"},{"input":"3cf6849b86a12b9c","output":"5.000000000000001e-15"},{"input":"aa28f612599e0e20","output":"-1.360433429400675e-105"},{"input":"43a0a741a4627800","output":"600000000000000000"},{"input":"44a969368974c05b","output":"6e+22"},{"input":"88f8933e80e0c838","output":"-1.9053747584322353e-265"},{"input":"3fea411085d69092","output":"0.820442449"},{"input":"3f0dcbd68ff86edb","output":"0.0000568318228"},{"input":"3e6fbe39e7646ef9","output":"5.91260773e-8"},{"input":"41bdcd6500000000","output":"500000000"},{"input":"85e3e33a1226eab5","output":"-2.739028351568414e-280"},{"input":"3f3a36e2eb1c432c","output":"0.00039999999999999996"},{"input":"3dba3cb3c764ce7b","output":"2.386252e-11"},{"input":"4470f0cf064dd592","output":"5e+21"},{"input":"bc36b082c2148b8f","output":"-1.2300000000000002e-18"},{"input":"3f00b1308dd75bcf","output":"0.000031837744"},{"input":"43e56c64fb400000","output":"12349758420436386000"},{"input":"3ead52763e96ac17","output":"8.73867177e-7"},{"input":"43be1d6380ba9900","output":"2170000000000000000"},{"input":"3bc2e3b40a0e9b50","output":"8.000000000000001e-21"},{"input":"3e42524ceab942df","output":"8.53160683e-9"},{"input":"3eb0c6f7a0b5ed8f","output":"0.0000010000000000000004"},{"input":"3eaa2cc582573169","output":"7.80072473e-7"},{"input":"410f66d77e000000","output":"257242.9365234375"},{"input":"686d8c176f89cc5a","output":"1.0784599532332548e+195"},{"input":"3b0357c299a88ea8","output":"2.0000000000000002e-24"},{"input":"40a49841b0000000","output":"2636.1282958984375"},{"input":"3e78fe2bfca915a2","output":"9.3105654e-8"},{"input":"fffffffffffffffe","output":"NaN"},{"input":"7feffffffffffffd","output":"1.7976931348623153e+308"},{"input":"40451c72c7257690","output":"42.222252744"},{"input":"3b382db34012b252","output":"2.0000000000000002e-23"},{"input":"4165932500000000","output":"11311400"},{"input":"c415af1d78b58c3f","output":"-99999999999999980000"},{"input":"3fea3a1966836cb2","output":"0.81959219"},{"input":"3ed98b07968012ea","output":"0.00000608994592"},{"input":"42357df33c1a0000","output":"92307405850"},{"input":"b71839c7faec5afc","output":"-2.7157957603600197e-43"},{"input":"5dae265f8e355538","output":"1.8382889211029956e+143"},{"input":"3d4c25c268497682","output":"2e-13"},{"input":"45268ee9eb000000","output":"1.3635629548496552e+25"},{"input":"4415af1d78b58c40","output":"100000000000000000000"},{"input":"8000000000000002","output":"-1e-323"},{"input":"f53353e82efde427","output":"-3.627587384999341e+256"},{"input":"3eb0c6f7a0b5ed8f","output":"0.0000010000000000000004"},{"input":"41f65a0bc0000000","output":"6000000000"},{"input":"3a7e675feb61e8ff","output":"6.14e-27"},{"input":"8000000000000002","output":"-1e-323"},{"input":"429a1f3bcd232f3b","output":"7180362401995.808"},{"input":"3c36b082c2148b8e","output":"1.23e-18"},{"input":"3fe8be0531174f27","output":"0.773195835"},{"input":"3e3cad68d90abe3b","output":"6.6769731e-9"},{"input":"3e491d71895126af","output":"1.16950896e-8"},{"input":"ffffffffffffffff","output":"NaN"},{"input":"3bac558e0f15e8f8","output":"3.0000000000000003e-21"},{"input":"40e1344666666666","output":"35234.2"},{"input":"3c970ef54646d496","output":"7.999999999999999e-17"},{"input":"8010000000000001","output":"-2.225073858507202e-308"},{"input":"3dd33dcfe54a3802","output":"6.999999999999999e-11"},{"input":"3d248bf8a91dc46e","output":"3.6498383e-14"},{"input":"409890f76d000000","output":"1572.241626739502"},{"input":"bdf53585a377ce4f","output":"-3.086325947136632e-10"},{"input":"800ffffffffffffe","output":"-2.2250738585072004e-308"},{"input":"4044000000000000","output":"40"},{"input":"3f689374bc6a7efa","output":"0.003"},{"input":"beb0c6f7a0b5ed8b","output":"-9.999999999999995e-7"},{"input":"3f686acbadc26057","output":"0.00298061162"},{"input":"e2ab33081d7bd553","output":"-2.0048690794533337e+167"},{"input":"3d30e374a4f8e0b4","output":"6e-14"},{"input":"440a055690d9db80","output":"60000000000000000000"},{"input":"800fffffffffffff","output":"-2.225073858507201e-308"},{"input":"44de88c9de800000","output":"5.767771915387912e+23"},{"input":"4410adaa762dc238","output":"76915462408214800000"},{"input":"3f07b019aebadc49","output":"0.0000451810682"},{"input":"9469acb063063ace","output":"-2.440485087241542e-210"},{"input":"3d06564e62d284cd","output":"9.91968e-15"},{"input":"0010000000000000","output":"2.2250738585072014e-308"},{"input":"8010000000000000","output":"-2.2250738585072014e-308"},{"input":"800fffffffffffff","output":"-2.225073858507201e-308"},{"input":"4688e1573ef24fc9","output":"6.307889604336116e+31"},{"input":"8a222abea979d795","output":"-7.384758409112228e-260"},{"input":"42f6bcc41e900000","output":"400000000000000"},{"input":"426cd93aa4c00000","output":"991228667392"},{"input":"45894b5cfc400000","output":"9.785292241140426e+26"},{"input":"d525961bdc45e78f","output":"-1.5108731929149642e+102"},{"input":"be7ad7f29abcaf46","output":"-9.999999999999997e-8"},{"input":"428ee2d330000000","output":"4244944322560"},{"input":"3df781b43cbe0dc7","output":"3.42066872e-10"},{"input":"3a16a126105cbfe6","output":"7.1406070585e-29"},{"input":"9e793499f23fb82c","output":"-7.0032109929675e-162"},{"input":"ee55c8f980cbd55c","output":"-3.149890835709288e+223"},{"input":"bc36b082c2148b90","output":"-1.2300000000000004e-18"},{"input":"419a71287a666666","output":"110905886.6"},{"input":"bef53756a8455121","output":"-0.00002023331264074211"},{"input":"43a8fae27693b400","output":"900000000000000000"},{"input":"3f07e8ba40838363","output":"0.0000456029739"},{"input":"448a1e72e0000000","output":"1.5417901061617146e+22"},{"input":"3cefac8ee5d291f2","output":"3.516526564e-15"},{"input":"4295d3ef79800000","output":"6000000000000"},{"input":"be7ad7f29abcaf46","output":"-9.999999999999997e-8"},{"input":"3ee5f261770df290","output":"0.0000104650496"},{"input":"3e4353cd652bb168","output":"9.000000000000001e-9"},{"input":"4217a78df4000000","output":"25398836480"},{"input":"4445af1d78b58c40","output":"800000000000000000000"},{"input":"3c5bab8cbabb6582","output":"6.0000000000000004e-18"},{"input":"3f7658c631a97890","output":"0.00545575542"},{"input":"41d80602a2000000","output":"1612188296"},{"input":"451f44761b22a8b0","output":"9.45e+24"},{"input":"a5adcd351f17f3ac","output":"-3.4394682505263422e-127"},{"input":"3e94805eb4985596","output":"3.05495338e-7"},{"input":"432d1d5202000000","output":"4097506191343616"},{"input":"d7d3d667b84eab41","output":"-1.2213095179854063e+115"},{"input":"3c770ef54646d496","output":"1.9999999999999998e-17"},{"input":"c56f5e7c4649872e","output":"-3.0338316254749023e+26"},{"input":"fff0000000000000","output":"-Infinity"},{"input":"4468014378000000","output":"3.542503249023217e+21"},{"input":"42cfd51291300000","output":"70000000000000"},{"input":"3d551c51ce3718e2","output":"3.0000000000000003e-13"},{"input":"44a52d02c7e14af6","output":"5e+22"},{"input":"24147a87e1b2542b","output":"7.043734464249669e-135"},{"input":"3d68a10a1b4047b2","output":"7e-13"},{"input":"3dfa42f5478cb6da","output":"3.8215592457e-10"},{"input":"3f08a09564aeac45","output":"0.000046972808"},{"input":"9954e28ee42a5675","output":"-1.199988344820897e-186"},{"input":"3c47d8b3ad4595fd","output":"2.58544180542231e-18"},{"input":"42c6bcc41e900000","output":"50000000000000"},{"input":"c44b1ae4d6e2ef4f","output":"-999999999999999900000"},{"input":"57a9a5de7b1bad0d","output":"1.973788556079752e+114"},{"input":"3df366fb5d16a709","output":"2.82340232e-10"},{"input":"3e106ad71aa3ee66","output":"9.55615235e-10"},{"input":"a1b70e5df4ad7693","output":"-2.8850168998449147e-146"},{"input":"3e926414b655b94b","output":"2.74046377e-7"},{"input":"7ffffffffffffffe","output":"NaN"},{"input":"451e0b0f252e08c1","output":"9.08e+24"},{"input":"438caf9237800000","output":"258378940131835900"},{"input":"3e311e5296e9305c","output":"3.9856992e-9"},{"input":"5c8f84d1f6c5e5f9","output":"7.330913700218418e+137"},{"input":"f4c9d9f71cfa1b6b","output":"-3.7906254391759397e+254"},{"input":"a3c210cfc8dd219a","output":"-1.9418069839937248e-136"},{"input":"3d30e374a4f8e0b4","output":"6e-14"},{"input":"42d291d1d5af0000","output":"81670000000000"},{"input":"41cdb7b040000000","output":"997154944"},{"input":"3ec2f5c4b1701d54","output":"0.00000226021201"},{"input":"a219d7ab455bbd02","output":"-2.0695498628800373e-144"},{"input":"3f32acebd0a82cb2","output":"0.000284965107"},{"input":"4503da329b633647","output":"3e+24"},{"input":"3c6024121797fb36","output":"7e-18"},{"input":"40c3880000000000","output":"10000"},{"input":"439bc16d674ec800","output":"500000000000000000"},{"input":"40a3cd0fe1000000","output":"2534.5310134887695"},{"input":"41b4abfef1000000","output":"346816241"},{"input":"4351d7798ac00000","output":"20087966491738110"},{"input":"44b9646730c00000","output":"1.199112721332031e+23"},{"input":"41612a8800000000","output":"9000000"},{"input":"0010000000000001","output":"2.225073858507202e-308"},{"input":"bc36b082c2148b8f","output":"-1.2300000000000002e-18"},{"input":"3c309a213cd6d681","output":"9e-19"},{"input":"40c95fdd08800000","output":"12991.726821899414"},{"input":"3d0203af9ee75616","output":"8e-15"},{"input":"4106a69efe800000","output":"185555.87426757812"},{"input":"beb0c6f7a0b5ed8e","output":"-0.0000010000000000000002"},{"input":"40ed029c96000000","output":"59412.893310546875"},{"input":"442fdce825400000","output":"293883540062372630000"},{"input":"42c6c15260000000","output":"50039133044736"},{"input":"45130b1c77c00000","output":"5.755515435430118e+24"},{"input":"4034000000000000","output":"20"},{"input":"3b0fd99f222b5320","output":"3.2932215440087e-24"},{"input":"42304c533c000000","output":"70000000000"},{"input":"4117f8543f000000","output":"392725.0615234375"},{"input":"420d719338800000","output":"15807440656"},{"input":"3ed0c6f7a0b5ed8d","output":"0.000004"},{"input":"d33a8d9e80a3c6c5","output":"-8.654371726723906e+92"},{"input":"418a7daea3c00000","output":"55555540.46875"},{"input":"3adf3288efa8e442","output":"4.0321697e-25"},{"input":"3ea463fdf47e0314","output":"6.0768705e-7"},{"input":"3c942d169d7dfa03","output":"6.999999999999999e-17"},{"input":"ff2450e586e540db","output":"-2.7864027304169257e+304"},{"input":"3e58003c9a2a8edf","output":"2.2352603e-8"},{"input":"3ed4256ccabb6cb7","output":"0.0000048032263"},{"input":"8d04d59b737c77fa","output":"-5.95956576674871e-246"},{"input":"3bf1b578c96db19b","output":"6e-20"},{"input":"4480f0cf064dd592","output":"1e+22"},{"input":"bc36b082c2148b8d","output":"-1.2299999999999998e-18"},{"input":"aff67e19479b6e6e","output":"-1.2140603357490023e-77"},{"input":"6069bf71421f1e93","output":"2.7617748088773948e+156"},{"input":"40eec8e8f5c28f5c","output":"63047.28"},{"input":"3c970ef54646d496","output":"7.999999999999999e-17"},{"input":"3e3361c2bf886215","output":"4.5126951e-9"},{"input":"3e45598ac9106119","output":"9.94176322e-9"},{"input":"8000000000000002","output":"-1e-323"},{"input":"44f316821f800000","output":"1.442242686365305e+24"},{"input":"42c6bcc41e900000","output":"50000000000000"},{"input":"4415af1d78b58c42","output":"100000000000000030000"},{"input":"437610cee6000000","output":"99374884731224060"},{"input":"ffffffffffffffff","output":"NaN"},{"input":"3fe87f26686bf18d","output":"0.765521244"},{"input":"435684dac4000000","output":"25354098454822910"},{"input":"3f9b53cf4b5c68c4","output":"0.0266868963"},{"input":"4425af1d78b58c40","output":"200000000000000000000"},{"input":"e6a5c9d2bb05d721","output":"-2.9625938008044634e+186"},{"input":"b3104df3515f4d95","output":"-9.908507341025379e-63"},{"input":"8000000000000001","output":"-5e-324"},{"input":"3ad6542bd4d2f60f","output":"2.88592896e-25"},{"input":"3e080d43de9cc604","output":"7.000000000000001e-10"},{"input":"3a4809e12470fa34","output":"6.06819365406409e-28"},{"input":"8ca94b063b703f70","output":"-1.1304595250731656e-247"},{"input":"3ed79c2b40740637","output":"0.00000562907099"},{"input":"fffffffffffffffe","output":"NaN"},{"input":"e20120274b7621d1","output":"-1.232745539809491e+164"},{"input":"3d602f4fc8c3d757","output":"4.6e-13"},{"input":"3fa0ea0636cccecb","output":"0.03303546351381"},{"input":"3b219a31d08d531c","output":"7.28015e-24"},{"input":"3e75798ee2308c3a","output":"8e-8"},{"input":"3b1ea35f5caab115","output":"6.33582585491e-24"},{"input":"44d101c2c6400000","output":"3.212508477140607e+23"},{"input":"418ee2b7b7c00000","output":"64771830.96875"},{"input":"3d059d725ef3d8bb","output":"9.599e-15"},{"input":"3c1d83c94fb6d2ac","output":"4e-19"},{"input":"3fd8068741050b8b","output":"0.375398458"},{"input":"4604eec7a7cd208a","output":"2.0730775641e+29"},{"input":"45108b2a2c280290","output":"4.999999999999999e+24"},{"input":"3e3f5900c9539b85","output":"7.29869777569547e-9"},{"input":"4513da329b633647","output":"6e+24"},{"input":"3adc244a66b5467b","output":"3.637237265677727e-25"},{"input":"82da43982596ee01","output":"-6.4254832309901925e-295"},{"input":"4451e9b0e941c88d","output":"1.32173545891419e+21"},{"input":"c44b1ae4d6e2ef4e","output":"-999999999999999700000"},{"input":"3f9f55f711f6a0d1","output":"0.0306013684"},{"input":"3d8a636641c4df1a","output":"3e-12"},{"input":"418b464bd4c00000","output":"57198970.59375"},{"input":"3eded4672b94a1eb","output":"0.00000735037309"},{"input":"e7f3672fc5278583","output":"-5.532835426921635e+192"},{"input":"3eb0c6f7a0b5ed8e","output":"0.0000010000000000000002"},{"input":"05984e11865ac82f","output":"1.0460655189704796e-281"},{"input":"96d4787a6a1a161c","output":"-1.0697291299194736e-198"},{"input":"beb0c6f7a0b5ed8c","output":"-9.999999999999997e-7"},{"input":"ec6dd1ff576c6ac6","output":"-2.0077931970956865e+214"},{"input":"41224f8000000000","output":"600000"},{"input":"8d6d5baca4a4b5f7","output":"-5.3745426811452976e-244"},{"input":"4435af1d78b58c40","output":"400000000000000000000"},{"input":"85092573041035f2","output":"-2.1138197983468677e-284"},{"input":"41e65a0bc0000000","output":"3000000000"},{"input":"3f1d02efe635930c","output":"0.000110669987"},{"input":"be7ad7f29abcaf49","output":"-1.0000000000000001e-7"},{"input":"444b1ae4d6e2ef52","output":"1.0000000000000003e+21"},{"input":"3fb273414261f1af","output":"0.0720711505"},{"input":"3e059e30f28e2d17","output":"6.29164697e-10"},{"input":"442bb2bbb0800000","output":"255470585806678130000"},{"input":"3c2710d8d847d60c","output":"6.252e-19"},{"input":"3b25c2baecdda07d","output":"9.000000000000001e-24"},{"input":"3eae41c3649bd44e","output":"9.01725522e-7"},{"input":"3b810022090d2561","output":"4.5e-22"},{"input":"3b0b677d6318d5cd","output":"2.833533762023e-24"},{"input":"7e7645d96b48c805","output":"1.4915968248600795e+301"},{"input":"a2514d1fc0d190ce","output":"-2.2168685897004427e-143"},{"input":"3eb0c6f7a0b5ed8b","output":"9.999999999999995e-7"},{"input":"439bc16d674ec800","output":"500000000000000000"},{"input":"3c36b082c2148b8f","output":"1.2300000000000002e-18"},{"input":"e8c750750cec7fb3","output":"-5.446146336725946e+196"},{"input":"bf75dd653de4826c","output":"-0.005338092303902014"},{"input":"3ed7a159be6ba1a4","output":"0.00000563389674"},{"input":"45041698d9400000","output":"3.035653501815903e+24"},{"input":"3e32bc1979f44914","output":"4.3620271e-9"},{"input":"414a12365c000000","output":"3417196.71875"},{"input":"45ef34819036610f","output":"7.726009034086019e+28"},{"input":"43cf867d10000000","output":"4543281139455885300"},{"input":"0010000000000000","output":"2.2250738585072014e-308"},{"input":"4510a202d2800000","output":"5.02697213641766e+24"},{"input":"3fb4adbd7ec357ee","output":"0.0807760653"},{"input":"4136e1ac15400000","output":"1499564.0830078125"},{"input":"3eb0c6f7a0b5ed8b","output":"9.999999999999995e-7"},{"input":"fcd15174d936de0c","output":"-1.7282170063234046e+293"},{"input":"42274876e8000000","output":"50000000000"},{"input":"4415af1d78b58c3f","output":"99999999999999980000"},{"input":"43043d6330000000","output":"712124468822016"},{"input":"3caee8e18a3bad8a","output":"2.144790696911514e-16"},{"input":"408df4ff36ef4000","output":"958.6246164981276"},{"input":"3f1109038b7703e5","output":"0.0000649841703"},{"input":"0000000000000001","output":"5e-324"},{"input":"0891da7690b57c8b","output":"2.1628385664706867e-267"},{"input":"3f0aeb65a4a910e5","output":"0.0000513449091"},{"input":"bffb6831e3fc6119","output":"-1.7129382043550037"},{"input":"40d554bddcc00000","output":"21842.966598510742"},{"input":"3e8456f3af0e7321","output":"1.51542245e-7"},{"input":"3e8ad7f29abcaf48","output":"2e-7"},{"input":"44dfc3842bd1f071","output":"5.9999999999999995e+23"},{"input":"415ab3f000000000","output":"7000000"},{"input":"412801b398000000","output":"786649.796875"},{"input":"3fa47ae147ae147b","output":"0.04"},{"input":"3e9424acaa138005","output":"3.00157959e-7"},{"input":"42267ea899000000","output":"48307129472"},{"input":"ca07499c03ce1670","output":"-4.254346654074591e+48"},{"input":"800ffffffffffffe","output":"-2.2250738585072004e-308"},{"input":"3feccccccccccccd","output":"0.9"},{"input":"3c52725dd1d243ac","output":"4e-18"},{"input":"7b6158f7783e9585","output":"2.0636851690524834e+286"},{"input":"3e93807cc2165e0a","output":"2.9060101e-7"},{"input":"449b6936f2480892","output":"3.2361190617860996e+22"},{"input":"42dd66c8c6000000","output":"129309169156096"},{"input":"3a42c053a698d654","output":"4.7334876423702e-28"},{"input":"41f2a05f20000000","output":"5000000000"},{"input":"42674876e8000000","output":"800000000000"},{"input":"425176592e000000","output":"300000000000"},{"input":"b54c19046a50adc2","output":"-5.8670784477260845e-52"},{"input":"41b12ddf23ed9e84","output":"288218915.9282"},{"input":"44c4856a50000000","output":"1.9381681448432486e+23"},{"input":"446da45d78000000","output":"4.374394661392213e+21"},{"input":"4356571c4d400000","output":"25152914217500670"},{"input":"000ffffffffffffd","output":"2.2250738585072e-308"},{"input":"3fb050ce981eb257","output":"0.0637330171"},{"input":"3fab7ef933a1dcce","output":"0.0537031055"},{"input":"444b1ae4d6e2ef51","output":"1.0000000000000001e+21"},{"input":"4415af1d78b58c42","output":"100000000000000030000"},{"input":"1c66532d0c4c0c23","output":"7.221079493827578e-172"},{"input":"3c22725dd1d243ac","output":"5e-19"},{"input":"9adf568393c9582c","output":"-3.0208774677358378e-179"},{"input":"428e355891800000","output":"4151808503808"},{"input":"404e000000000000","output":"60"},{"input":"8a3a91b8426bf334","output":"-2.1600435915670255e-259"},{"input":"4232a05f20000000","output":"80000000000"},{"input":"3b2357c299a88ea8","output":"8.000000000000001e-24"},{"input":"b84a19a3cf5c1277","output":"-1.534029284466568e-37"},{"input":"3eb0c6f7a0b5ed8d","output":"0.000001"},{"input":"3e428ebb84e20593","output":"8.64153207e-9"},{"input":"3f60a552bd70a3d0","output":"0.00203195724636316"},{"input":"000fffffffffffff","output":"2.225073858507201e-308"},{"input":"4101714504000000","output":"142888.626953125"},{"input":"3e65798ee2308c3a","output":"4e-8"},{"input":"429977420dc00000","output":"7000000000000"},{"input":"451527edbcf9006a","output":"6.394e+24"},{"input":"4306bcc41e900000","output":"800000000000000"},{"input":"3a4b9d9e55653e52","output":"6.97118205251e-28"},{"input":"408d369acd000000","output":"934.8255863189697"},{"input":"44b2f2cfd2000000","output":"8.948168378920229e+22"},{"input":"408ea00000000000","output":"980"},{"input":"3f7cb269cde5adc5","output":"0.00700608568"},{"input":"be7ad7f29abcaf48","output":"-1e-7"},{"input":"4010000000000000","output":"4"},{"input":"42db6be417800000","output":"120600808783872"},{"input":"3df4421800d3b808","output":"2.947953e-10"},{"input":"3e7ad7f29abcaf49","output":"1.0000000000000001e-7"},{"input":"44223f2607800000","output":"168295863023306800000"},{"input":"3fd3333333333334","output":"0.30000000000000004"},{"input":"3a328fd6c800f82f","output":"2.34283750411e-28"},{"input":"42274876e8000000","output":"50000000000"},{"input":"c415af1d78b58c41","output":"-100000000000000020000"},{"input":"a488f054f6d88fd6","output":"-1.0979622573352463e-132"},{"input":"41284811a1d83200","output":"795656.8161025643"},{"input":"3eb0c6f7a0b5ed8e","output":"0.0000010000000000000002"},{"input":"3c770ef54646d496","output":"1.9999999999999998e-17"},{"input":"40de58bd8e000000","output":"31074.961791992188"},{"input":"3f1122536cee354f","output":"0.000065361349"},{"input":"418bfa8000000000","output":"58675200"},{"input":"42e7cb83c3000000","output":"209302851158016"},{"input":"414f42130d000000","output":"4097062.1015625"},{"input":"41bb422051000000","output":"457318481"},{"input":"439c603cf42ebc8a","output":"511175312570000000"},{"input":"3e77c796fede4050","output":"8.85860911e-8"},{"input":"43fb2731b5000000","output":"31305395465193783000"},{"input":"40bb580000000000","output":"7000"},{"input":"4338edefc7937cbb","output":"7017013542354107"},{"input":"eac8bf3f82e65c80","output":"-2.482851291398172e+206"},{"input":"3ed8bb3bf90f700b","output":"0.0000058964214"},{"input":"9e2b541e51c1af59","output":"-2.3728459875250862e-163"},{"input":"41c6bd8127d4678c","output":"763036239.65941"},{"input":"418b355500000000","output":"57060000"},{"input":"4175a52ebcfdf3b6","output":"22696683.812"},{"input":"425f3cda18800000","output":"536659649024"},{"input":"4415af1d78b58c42","output":"100000000000000030000"},{"input":"67e99f2b9a5e9426","output":"3.6530548224143773e+192"},{"input":"3e212e0be826d695","output":"2e-9"},{"input":"3c168a3377e2f6e4","output":"3.054719e-19"},{"input":"4303e52b9abe0000","output":"700000000000000"},{"input":"3ea2f300f9d8d91f","output":"5.6473117e-7"},{"input":"432d3d25b0557474","output":"4115003203041850"},{"input":"456c48097f800000","output":"2.7352086835212908e+26"},{"input":"417d825df882cc2d","output":"30942687.531933"},{"input":"0010000000000000","output":"2.2250738585072014e-308"},{"input":"4411a76128000000","output":"81413903627650600000"},{"input":"beb0c6f7a0b5ed8d","output":"-0.000001"},{"input":"3b64668f3e0fc675","output":"1.35e-22"},{"input":"4153fcede4800000","output":"5239735.5703125"},{"input":"df2ae705073d9d0f","output":"-2.7519415785703424e+150"},{"input":"44dfc3842bd1f071","output":"5.9999999999999995e+23"},{"input":"426a3185c5000000","output":"900000000000"},{"input":"428a442467000000","output":"3609996353536"},{"input":"d0ecfe0081e1937e","output":"-6.875272926396012e+81"},{"input":"3c8cd2b297d889bc","output":"5e-17"},{"input":"3ec2d94bc172d6b0","output":"0.00000224695351"},{"input":"421d2bd137000000","output":"31322295744"},{"input":"43cf65c3f8800000","output":"4524859719780663300"},{"input":"3f92ccf6be37de94","output":"0.01836"},{"input":"3f14f8b588e368f0","output":"0.00007999999999999999"},{"input":"7feffffffffffffe","output":"1.7976931348623155e+308"},{"input":"be7ad7f29abcaf48","output":"-1e-7"},{"input":"41c83071af800000","output":"811656031"},{"input":"3e312e0be826d695","output":"4e-9"},{"input":"3f20ba25448a9392","output":"0.000127617883"},{"input":"4449aacc9d800000","output":"946951973795033800000"},{"input":"4146e36000000000","output":"3000000"},{"input":"416b98065d800000","output":"14467122.921875"},{"input":"3f153f157f2104d4","output":"0.000081048667"},{"input":"43e3286ea0c00000","output":"11043799379872842000"},{"input":"41fbfa1818000000","output":"7510000000"},{"input":"40d17daa0b000000","output":"17910.65692138672"},{"input":"3eade5ff87f182ca","output":"8.9104266e-7"},{"input":"4147ee6180000000","output":"3136707"},{"input":"3f34772ee24af639","output":"0.00031227965"},{"input":"bc36b082c2148b90","output":"-1.2300000000000004e-18"},{"input":"e6ec4b53ebe3810f","output":"-6.155530557813048e+187"},{"input":"3d3c25c268497682","output":"1e-13"},{"input":"8010000000000001","output":"-2.225073858507202e-308"},{"input":"9d87b1ca2c18af5e","output":"-2.0090918551093195e-166"},{"input":"58e945b5bd4fa563","output":"2.039356402824847e+120"},{"input":"3fb6b39dd36f6630","output":"0.0886782304"},{"input":"3acef2d0f5da7dd9","output":"2e-25"},{"input":"409f3f18ef400000","output":"1999.7743501663208"},{"input":"1eaff20d31a09079","output":"7.100717035524647e-161"},{"input":"449cdb753c800000","output":"3.4068636560057747e+22"},{"input":"3d3787de8ef3f314","output":"8.3597980882041e-14"},{"input":"c44b1ae4d6e2ef50","output":"-1e+21"},{"input":"43aa29459b51d341","output":"942557226213155000"},{"input":"4415af1d78b58c42","output":"100000000000000030000"},{"input":"c44b1ae4d6e2ef4e","output":"-999999999999999700000"},{"input":"2a45e98873339696","output":"4.7770332537128565e-105"},{"input":"3fe2c7710a50b343","output":"0.586845894"},{"input":"444b1ae4d6e2ef4f","output":"999999999999999900000"},{"input":"3eaa3bbda163590b","output":"7.8181512e-7"},{"input":"3b76aad80c11872c","output":"3e-22"},{"input":"3ed0542e20721e37","output":"0.00000389309617"},{"input":"f5588857b87baef2","output":"-1.8417882109822377e+257"},{"input":"cccc6de34af0dc43","output":"-9.13680850602435e+61"},{"input":"fffffffffffffffe","output":"NaN"},{"input":"3fbaca4a4cbb80b0","output":"0.104649204"},{"input":"43b66db869c00000","output":"1616150605628178400"},{"input":"3e723b4a5363be6d","output":"6.79180133e-8"},{"input":"8000000000000001","output":"-5e-324"},{"input":"74f42184016d5e1b","output":"2.3614566312067393e+255"},{"input":"42bd3b2109000000","output":"32139794513920"},{"input":"3e0e32578ab9c48d","output":"8.78838132e-10"},{"input":"444b1ae4d6e2ef51","output":"1.0000000000000001e+21"},{"input":"3fa36eefe098c99f","output":"0.0379557573"},{"input":"54b15892b8c1e3ac","output":"9.485006641314152e+99"},{"input":"404e000000000000","output":"60"},{"input":"4480f0cf064dd592","output":"1e+22"},{"input":"43fde43d0b800000","output":"34462618262261727000"},{"input":"935778bfd596be8a","output":"-1.7021868703809664e-215"},{"input":"14c61a9354cd4efd","output":"1.3446837730608743e-208"},{"input":"4353d0dcd0000000","output":"22310685434183680"},{"input":"0f5128161d45d0ba","output":"6.744881107648957e-235"},{"input":"4415af1d78b58c3e","output":"99999999999999970000"},{"input":"3f80f2826c131218","output":"0.00827505009"},{"input":"42a2e8409c000000","output":"10394362839040"},{"input":"0000000000000002","output":"1e-323"},{"input":"442f7fbd58000000","output":"290526838127717250000"},{"input":"3ed755a071a9156c","output":"0.00000556337343"},{"input":"ffeffffffffffffd","output":"-1.7976931348623153e+308"},{"input":"3f826e978d4fdf3c","output":"0.009000000000000001"},{"input":"7fefffffffffffff","output":"1.7976931348623157e+308"},{"input":"42cc35995a800000","output":"62033063378944"},{"input":"3f8c03f7d3ae09e0","output":"0.0136794435"},{"input":"3d6aa6877969ff4a","output":"7.574529e-13"},{"input":"3e72ca5d05ea7ab3","output":"7e-8"},{"input":"eb7612e5b772f6b8","output":"-4.535596912219325e+209"},{"input":"90db4c98df76b588","output":"-1.800583759878515e-227"},{"input":"3f14f8b588e368f0","output":"0.00007999999999999999"},{"input":"beb0c6f7a0b5ed8f","output":"-0.0000010000000000000004"},{"input":"41086a0000000000","output":"200000"},{"input":"3eb0c6f7a0b5ed8f","output":"0.0000010000000000000004"},{"input":"4385317dfc000000","output":"190892533742567420"},{"input":"25e07724f0e770c6","output":"3.040495093838348e-126"},{"input":"448413b9d6000000","output":"1.1851401085666927e+22"},{"input":"eab8d850d1107f97","output":"-1.2463377753838963e+206"},{"input":"c44b1ae4d6e2ef4f","output":"-999999999999999900000"},{"input":"3e692a09e8df5ebd","output":"4.68720006e-8"},{"input":"444b1ae4d6e2ef51","output":"1.0000000000000001e+21"},{"input":"3eb0c6f7a0b5ed8f","output":"0.0000010000000000000004"},{"input":"408c200000000000","output":"900"},{"input":"1ab91df8d5b0c4a7","output":"6.053014562711293e-180"},{"input":"e9b42b58d09925dd","output":"-1.5438619456173179e+201"},{"input":"44d046d3f4400000","output":"3.074576348547162e+23"},{"input":"41d1778619800000","output":"1172183142"},{"input":"3c480ef1e4eb0abc","output":"2.608414625e-18"},{"input":"4123375341800000","output":"629673.6279296875"},{"input":"416312d000000000","output":"10000000"},{"input":"3ee0de5162f9bcda","output":"0.00000804349392"},{"input":"444b1ae4d6e2ef4f","output":"999999999999999900000"},{"input":"3ed7b9785168eaff","output":"0.00000565635971"},{"input":"3f177da013dc2ae4","output":"0.00008961"},{"input":"42274876e8000000","output":"50000000000"},{"input":"1b6a3ba955c7d0a3","output":"1.2947364777750181e-176"},{"input":"3fd999999999999a","output":"0.4"},{"input":"4124a38017800000","output":"676288.0458984375"},{"input":"19a43eb461cd213e","output":"3.722281102020191e-185"},{"input":"44f1722dd6800000","output":"1.318183392020817e+24"},{"input":"42cbe8f47c000000","output":"61374696259584"},{"input":"c44b1ae4d6e2ef50","output":"-1e+21"},{"input":"404d42d15b8bfff8","output":"58.522014087066"},{"input":"4503da329b633647","output":"3e+24"},{"input":"3b482db34012b252","output":"4.0000000000000004e-23"},{"input":"43866d7b84000000","output":"202010456020221950"},{"input":"3fe819de2e5a41a6","output":"0.753157702"},{"input":"1ae0656ce3495749","output":"3.1610808489571665e-179"},{"input":"3f49923a4c006244","output":"0.000780371156"},{"input":"c44b1ae4d6e2ef4f","output":"-999999999999999900000"},{"input":"ffffffffffffffff","output":"NaN"},{"input":"44de74cf3d63848a","output":"5.75303e+23"},{"input":"443fb97e8d000000","output":"585215342060217800000"},{"input":"2574a84715b4a109","output":"2.9801363951254473e-128"},{"input":"3f377ef6946a2f72","output":"0.000358519745"},{"input":"bc36b082c2148b8d","output":"-1.2299999999999998e-18"},{"input":"440a055690d9db80","output":"60000000000000000000"},{"input":"426b98d365f94000","output":"948224864202"},{"input":"443cd43f29c00000","output":"531802822828051400000"},{"input":"42d29b163e000000","output":"81829209571328"},{"input":"3e006da9c8c89e5f","output":"4.78128552e-10"},{"input":"87a4d02af522fc23","output":"-7.694702841295245e-272"},{"input":"3e7a652259bcbfde","output":"9.83292438e-8"},{"input":"3e43eacf05aa7826","output":"9.27467896e-9"},{"input":"3eae32f0ee144531","output":"9e-7"},{"input":"24d836257e2e4bd0","output":"3.4110160889535035e-131"},{"input":"3d6ba1ee16ce7a5b","output":"7.85364e-13"},{"input":"3ea569477f8ca81a","output":"6.381048925686628e-7"},{"input":"3ee4144207bb55cc","output":"0.0000095744765"},{"input":"3eb0c6f7a0b5ed8f","output":"0.0000010000000000000004"},{"input":"4415af1d78b58c3f","output":"99999999999999980000"},{"input":"3edf87becaf7059f","output":"0.0000075173986"},{"input":"3c1622d6fbc91e01","output":"3e-19"},{"input":"428d1a94a2000000","output":"4000000000000"},{"input":"3e1b6d6d6e77fd36","output":"1.59648777e-9"},{"input":"3bc478e211c41444","output":"8.6703137588e-21"},{"input":"3ea0c6f7a0b5ed8d","output":"5e-7"},{"input":"3fe975d83e9af05c","output":"0.79563534"},{"input":"448e9ba1cf000000","output":"1.8067737419434328e+22"},{"input":"4470f0cf064dd592","output":"5e+21"},{"input":"3a84d2195082ad98","output":"8.409413262270391e-27"},{"input":"3cc9385c44dd7885","output":"7e-16"},{"input":"40f86a0000000000","output":"100000"},{"input":"417ab3f000000000","output":"28000000"},{"input":"3ac5a9f8ac18f1b1","output":"1.4e-25"},{"input":"fffbc045e2f218bc","output":"NaN"},{"input":"3f053c9d33aa7cca","output":"0.0000405059313"},{"input":"45f32449000fc092","output":"9.47853e+28"},{"input":"c415af1d78b58c41","output":"-100000000000000020000"},{"input":"39e66ca2c7a1f0f3","output":"8.84485e-30"},{"input":"3ee4f8b588e368f0","output":"0.000009999999999999999"},{"input":"451fc3842bd1f072","output":"9.6e+24"},{"input":"42010db510000000","output":"9155551744"},{"input":"3f7883bae58fab75","output":"0.00598500258"},{"input":"3fe0f04962b94c81","output":"0.529331868"},{"input":"3f947ae147ae147b","output":"0.02"},{"input":"3ed92a737110e454","output":"0.000006"},{"input":"4233e23c96000000","output":"85400000000"},{"input":"422229298c000000","output":"39000000000"},{"input":"444b1ae4d6e2ef51","output":"1.0000000000000001e+21"},{"input":"43a6345785d8a000","output":"800000000000000000"},{"input":"3e3018f0b2843256","output":"3.7479733e-9"},{"input":"3b87007c73f6eda1","output":"6.08855197e-22"},{"input":"9648e3891b1c9298","output":"-2.5402534865379272e-201"},{"input":"8000000000000003","output":"-1.5e-323"},{"input":"3c3838f07e657b02","output":"1.3131e-18"},{"input":"3cc9385c44dd7884","output":"6.999999999999999e-16"},{"input":"62b26db2772f8864","output":"2.7167376258193213e+167"},{"input":"3ea0d585d5d62a0e","output":"5.01694483e-7"},{"input":"43d8fca8ea327b53","output":"7201998699456450000"},{"input":"40b3880000000000","output":"5000"},{"input":"4403d0066a400000","output":"45684740329167650000"},{"input":"83f1e277f560d747","output":"-1.1470027351519032e-289"},{"input":"4212a05f20000000","output":"20000000000"},{"input":"3e34537f32e60659","output":"4.732552834320813e-9"},{"input":"619ef848bb0b57e2","output":"1.7416341173269812e+162"},{"input":"3cb48f84dbdfb8ed","output":"2.8533593565226e-16"},{"input":"3e7ad7f29abcaf49","output":"1.0000000000000001e-7"},{"input":"45f059eedc239374","output":"8.09677206265178e+28"},{"input":"44a81e111f42b7b0","output":"5.69457158446312e+22"},{"input":"3f4019e2544881a4","output":"0.000491366875"},{"input":"41cad27480000000","output":"900000000"},{"input":"3f69c327382472f5","output":"0.00314481411"},{"input":"beb0c6f7a0b5ed8f","output":"-0.0000010000000000000004"},{"input":"3fe182c3cf4d2fb4","output":"0.54721251"},{"input":"7feffffffffffffe","output":"1.7976931348623155e+308"},{"input":"43d08c8660000000","output":"4769902992885285000"},{"input":"29c959331ee4b4a6","output":"2.1586524745650987e-107"},{"input":"3c36b082c2148b8d","output":"1.2299999999999998e-18"},{"input":"3d95fd7fe1796495","output":"5e-12"},{"input":"3e03a31ce5038654","output":"5.71516565e-10"},{"input":"bee5e55393b10bd0","output":"-0.000010440734163568848"},{"input":"b01488105303ac01","output":"-4.432837170462069e-77"},{"input":"423fd55540000000","output":"136723120128"},{"input":"8e35d2278e48b303","output":"-3.272475831180131e-240"},{"input":"42b3099c6ca80000","output":"20932000000000"},{"input":"42798a6bfec00000","output":"1755144252416"},{"input":"efe685294c0e78b7","output":"-1.0925924376628378e+231"},{"input":"439b1c9878800000","output":"488400995420733440"},{"input":"5f69f13dc9d676c6","output":"4.245972089068616e+151"},{"input":"3ff0000000000000","output":"1"},{"input":"3ef6510b460aa64c","output":"0.000021282747527584433"},{"input":"426d1a94a2000000","output":"1000000000000"},{"input":"3eb0c6f7a0b5ed8d","output":"0.000001"},{"input":"3eff75104d551d68","output":"0.000029999999999999997"},{"input":"3fd9c3b731517e19","output":"0.402570532"},{"input":"4474542ba12a337c","output":"6e+21"},{"input":"44a817550fa38a84","output":"5.68836e+22"},{"input":"a4b76b8903500b1a","output":"-8.24878340460975e-132"},{"input":"4034000000000000","output":"20"},{"input":"44d1dd4700800000","output":"3.3744830751595184e+23"},{"input":"7fffffffffffffff","output":"NaN"},{"input":"45621bc75cc29e01","output":"1.75134769874e+26"},{"input":"41b6c8e524800000","output":"382264612.5"},{"input":"beb0c6f7a0b5ed8f","output":"-0.0000010000000000000004"},{"input":"d9ab8a9b9702f690","output":"-9.103215531138791e+123"},{"input":"3fc83dc486ad2dcb","output":"0.189385"},{"input":"3f12c0cdc81b5e90","output":"0.0000715375518"},{"input":"4072c00000000000","output":"300"},{"input":"4503da329b633647","output":"3e+24"},{"input":"42a05ef39b200000","output":"9000000000000"},{"input":"8003470c3ddd67cd","output":"-4.55796720716893e-309"},{"input":"beb0c6f7a0b5ed8c","output":"-9.999999999999997e-7"},{"input":"3fec9092b9a2f0d3","output":"0.892648089"},{"input":"67b79e87b666e41f","output":"4.209432166598629e+191"},{"input":"3f1396e2d57e3352","output":"0.0000747276257"},{"input":"44eafe1b04c00000","output":"1.0197515875310253e+24"},{"input":"c415af1d78b58c41","output":"-100000000000000020000"},{"input":"3db5fd7fe1796495","output":"2e-11"},{"input":"417312d000000000","output":"20000000"},{"input":"41bc1dab84000000","output":"471706500"},{"input":"3ed859461075a976","output":"0.0000058051885"},{"input":"3e049da7e361ce4c","output":"6e-10"},{"input":"4515c4435a000000","output":"6.578567114896516e+24"},{"input":"3eb0c6f7a0b5ed8d","output":"0.000001"},{"input":"3cf625784df0ac7e","output":"4.9174813e-15"},{"input":"3e965e8e941c01a1","output":"3.33329485e-7"},{"input":"434f8076b4000000","output":"17733943184850944"},{"input":"0000000000000001","output":"5e-324"},{"input":"425471f945000000","output":"351246029824"},{"input":"c415af1d78b58c3e","output":"-99999999999999970000"},{"input":"e964fd4a0360bb58","output":"-5.020736000846346e+199"},{"input":"3e588731fce4a5b5","output":"2.28435793e-8"},{"input":"004a53dd290b6e7a","output":"2.9290419903451738e-307"},{"input":"c415af1d78b58c40","output":"-100000000000000000000"},{"input":"444b1ae4d6e2ef50","output":"1e+21"},{"input":"9ec07c45720a2d8d","output":"-1.465725764627008e-160"},{"input":"4517293b0a9e69fe","output":"7e+24"},{"input":"3eb0c6f7a0b5ed8c","output":"9.999999999999997e-7"},{"input":"3e2a945ce68bf640","output":"3.094266e-9"},{"input":"beb0c6f7a0b5ed8b","output":"-9.999999999999995e-7"},{"input":"3df7e3d2c3304832","output":"3.47644305e-10"},{"input":"3e7f8453d35ef422","output":"1.17409617e-7"},{"input":"77032c6a92a3713a","output":"1.9320022224191048e+265"},{"input":"3eab21db54942ae6","output":"8.0860415e-7"},{"input":"3e74f0441138297f","output":"7.80021348e-8"},{"input":"800fffffffffffff","output":"-2.225073858507201e-308"},{"input":"3c36b082c2148b8d","output":"1.2299999999999998e-18"},{"input":"c8c49a2eea89b8d9","output":"-3.5894231308392714e+42"},{"input":"18c54f641b4b57f7","output":"2.3914354174416925e-189"},{"input":"3eb0c6f7a0b5ed8e","output":"0.0000010000000000000002"},{"input":"41f7e0ac00c00000","output":"6409601036"},{"input":"7fffffffffffffff","output":"NaN"},{"input":"3ce203af9ee75616","output":"2e-15"},{"input":"3fa1881791f22458","output":"0.0342414251"},{"input":"3f15d999528deb20","output":"0.0000833511191"},{"input":"3fb282e333666ae0","output":"0.0723096848"},{"input":"df22b65605ae8697","output":"-1.914140740999919e+150"},{"input":"7ff0000000000000","output":"Infinity"},{"input":"4089000000000000","output":"800"},{"input":"be7ad7f29abcaf47","output":"-9.999999999999998e-8"},{"input":"1f685f43389d7803","output":"2.2189400793394207e-157"},{"input":"3b82e3b40a0e9b50","output":"5.0000000000000005e-22"},{"input":"45622d726a000000","output":"1.7580225449377464e+26"},{"input":"3f7795bbad5983c4","output":"0.005758031"},{"input":"000ffffffffffffe","output":"2.2250738585072004e-308"},{"input":"426176592e000000","output":"600000000000"},{"input":"4234f46b04000000","output":"90000000000"},{"input":"3e18526134db54a6","output":"1.41571484e-9"},{"input":"3b522246700e05be","output":"6.000000000000001e-23"},{"input":"4306bcc41e900000","output":"800000000000000"},{"input":"0000000000000002","output":"1e-323"},{"input":"3dbf03217ff714a8","output":"2.82054588e-11"},{"input":"000d8dae123a8598","output":"1.8848374484731246e-308"},{"input":"4549fe8511000000","output":"6.285016243791104e+25"},{"input":"3deb7cdfd9d7bdbb","output":"2e-10"},{"input":"444b1ae4d6e2ef51","output":"1.0000000000000001e+21"},{"input":"3e0eec7bd512b572","output":"9e-10"},{"input":"426176592e000000","output":"600000000000"},{"input":"139e68704c74cf32","output":"3.528340029113983e-214"},{"input":"7feffffffffffffe","output":"1.7976931348623155e+308"},{"input":"418c48844a800000","output":"59314313.3125"},{"input":"3b0d03a3e67cd5fc","output":"3.0000000000000003e-24"},{"input":"3b73616e7af562ef","output":"2.565e-22"},{"input":"3ba352dafc7a9ba3","output":"2.0459714462049304e-21"},{"input":"3b725d00f8cea3e0","output":"2.430362e-22"},{"input":"454395b1efc00000","output":"4.73530110562695e+25"},{"input":"5066df1a032a1cc3","output":"2.1186701506554358e+79"},{"input":"44138400eca364a0","output":"90000000000000000000"},{"input":"43f54cb256400000","output":"24556762504594720000"},{"input":"3aa2c5d5f2756006","output":"3.03290874e-26"},{"input":"400238dcb7d0083a","output":"2.27776473621"},{"input":"4c2de85e787e570a","output":"9.386681113359346e+58"},{"input":"3c36b082c2148b8d","output":"1.2299999999999998e-18"},{"input":"6bda3a9d866917e0","output":"3.449198161518471e+211"},{"input":"e1e1ee15e2537db1","output":"-3.2266248289541895e+163"},{"input":"697d6368bdba7b1d","output":"1.4059564018179313e+200"},{"input":"44e0a9a86d99c1de","output":"6.295e+23"},{"input":"be7ad7f29abcaf4a","output":"-1.0000000000000002e-7"},{"input":"3c4bab8cbabb6582","output":"3.0000000000000002e-18"},{"input":"418ffcb191800000","output":"67081778.1875"},{"input":"3ed391ee8baae343","output":"0.0000046658626"},{"input":"3e2327c779a6b50b","output":"2.2299806005321443e-9"},{"input":"3f49e2b68862786f","output":"0.000789965751"},{"input":"3ea1703062cb05b5","output":"5.197e-7"},{"input":"110852855d79590b","output":"1.2833903297470633e-226"},{"input":"42785570dd400000","output":"1672202802176"},{"input":"44a52d02c7e14af6","output":"5e+22"},{"input":"3ee06643aa7230c3","output":"0.00000781987667"},{"input":"7d6e2b8c6dbf95df","output":"1.5414969527994765e+296"},{"input":"41214e2dacc00000","output":"567062.8374023438"},{"input":"3a7749b83614d981","output":"4.70296750077978e-27"},{"input":"44f7ce655ac00000","output":"1.7987481879366076e+24"},{"input":"c44b1ae4d6e2ef4e","output":"-999999999999999700000"},{"input":"be7ad7f29abcaf47","output":"-9.999999999999998e-8"},{"input":"4292b97558000000","output":"5146936737792"},{"input":"81141635c6dd6795","output":"-1.830687550738031e-303"},{"input":"e0698f0033c40788","output":"-2.7414780586314794e+156"},{"input":"4459a4c068000000","output":"1.8921608192387868e+21"},{"input":"41971d4c83345eb4","output":"96949024.80114251"},{"input":"449066ea58000000","output":"1.936407946705888e+22"},{"input":"3eeef5e49f912604","output":"0.000014763126261157888"},{"input":"438889d4d2000000","output":"221022290890981380"},{"input":"b19b35ca409bf1f3","output":"-9.856243626314189e-70"},{"input":"44362dfe78000000","output":"409142587938796700000"},{"input":"481f9f2907171b06","output":"2.690078413464393e+39"},{"input":"a89ef78903bbbd2f","output":"-5.029905821103787e-113"},{"input":"449969368974c05b","output":"3e+22"},{"input":"40ec352a5f000000","output":"57769.32409667969"},{"input":"44533c2fa18e7bfa","output":"1.4193e+21"},{"input":"c415af1d78b58c3f","output":"-99999999999999980000"},{"input":"420ca75608800000","output":"15383314704"},{"input":"414dc6157d651b0d","output":"3902506.979648"},{"input":"452f8bfa8a043947","output":"1.9068865490163833e+25"},{"input":"beb0c6f7a0b5ed8f","output":"-0.0000010000000000000004"},{"input":"800ffffffffffffe","output":"-2.2250738585072004e-308"},{"input":"4621f88219486b12","output":"7.1189416246489e+29"},{"input":"3f93e7a596271e52","output":"0.01943835"},{"input":"3ed9898b000c5462","output":"0.00000608856135"},{"input":"4343517c77000000","output":"10875239143571456"},{"input":"43cbc16d674ec800","output":"4000000000000000000"},{"input":"4212a05f20000000","output":"20000000000"},{"input":"40c7087106d38ffe","output":"11792.88302082568"},{"input":"3ece06f7d97dd2d1","output":"0.00000357952349"},{"input":"4117b683c4ab2075","output":"388512.9420590469"},{"input":"447e7e4171bf4d3a","output":"9e+21"},{"input":"43af9508ee000000","output":"1137867502500446200"},{"input":"3a1768dafcad00cb","output":"7.386764609254897e-29"},{"input":"0000000000000000","output":"0"},{"input":"beb0c6f7a0b5ed8d","output":"-0.000001"},{"input":"40ebe1e000000000","output":"57103"},{"input":"3e7ad7f29abcaf48","output":"1e-7"},{"input":"0e3d06762f90b93d","output":"4.3529061258627225e-240"},{"input":"45f0d74e84a7b827","output":"8.33928e+28"},{"input":"3f70624dd2f1a9fc","output":"0.004"},{"input":"bc36b082c2148b8f","output":"-1.2300000000000002e-18"},{"input":"3eae32f0ee144531","output":"9e-7"},{"input":"c44b1ae4d6e2ef51","output":"-1.0000000000000001e+21"},{"input":"8000000000000002","output":"-1e-323"},{"input":"3e005825f6893f20","output":"4.75682588e-10"},{"input":"41c9af0a28000000","output":"861803600"},{"input":"3f17077a63847437","output":"0.0000878494692"},{"input":"3f7908ed8a959952","output":"0.00611202993"},{"input":"447d6f44deb696e0","output":"8.6875737e+21"},{"input":"bc36b082c2148b8f","output":"-1.2300000000000002e-18"},{"input":"d05028c073208306","output":"-7.484423883816695e+78"},{"input":"3fcf257dc8adae4f","output":"0.243331645"},{"input":"4010000000000000","output":"4"},{"input":"3ee20c8d173d850d","output":"0.00000860644716"},{"input":"3f45a0dacc7255ed","output":"0.000660044513"},{"input":"3e012e0be826d695","output":"5e-10"},{"input":"c44b1ae4d6e2ef4e","output":"-999999999999999700000"},{"input":"3d0203af9ee75616","output":"8e-15"},{"input":"be7ad7f29abcaf49","output":"-1.0000000000000001e-7"},{"input":"444b1ae4d6e2ef4f","output":"999999999999999900000"},{"input":"0c1689df310cbf97","output":"1.967477696398248e-250"},{"input":"3ab8c1b16614ee28","output":"7.999293133616448e-26"},{"input":"3ee72613071f9f27","output":"0.0000110381736"},{"input":"3fb5041b1bfefde6","output":"0.082093901"},{"input":"3acef2d0f5da7dd9","output":"2e-25"},{"input":"948dd57a4aa4747c","output":"-1.1343394098436734e-209"},{"input":"8000000000000002","output":"-1e-323"},{"input":"43ded7d363c00000","output":"8889909466028311000"},{"input":"53878a4a2c11771d","output":"2.4551537987726003e+94"},{"input":"3f7192ab25ce94d0","output":"0.00429026465"},{"input":"44e482eb70ddf24a","output":"7.748989735264332e+23"},{"input":"3dd33dcfe54a3802","output":"6.999999999999999e-11"},{"input":"3d34c802507ac47b","output":"7.38299566e-14"},{"input":"3d8438e34500f043","output":"2.299e-12"},{"input":"444b1ae4d6e2ef4d","output":"999999999999999600000"},{"input":"4435af1d78b58c40","output":"400000000000000000000"},{"input":"44ea784379d99db4","output":"1e+24"},{"input":"449ec87f59540ed0","output":"3.63423799397424e+22"},{"input":"43f31c72b7800000","output":"22033627496329510000"},{"input":"3ed045f70e7e444c","output":"0.00000387985731"},{"input":"3f9bf1a22f9a6b5e","output":"0.0272889463"},{"input":"3e9421f5f40d8376","output":"3e-7"},{"input":"127c21910c612fc0","output":"1.2451744185590781e-219"},{"input":"0010000000000001","output":"2.225073858507202e-308"},{"input":"442b2e86da000000","output":"250707348328158330000"},{"input":"c415af1d78b58c42","output":"-100000000000000030000"},{"input":"3e7ad7f29abcaf49","output":"1.0000000000000001e-7"},{"input":"beb0c6f7a0b5ed8b","output":"-9.999999999999995e-7"},{"input":"0000000000000001","output":"5e-324"},{"input":"3f02c754174ca1d7","output":"0.0000358173883"},{"input":"3e6fa2e1c95cc850","output":"5.8927122e-8"},{"input":"3bb631f38bd129b1","output":"4.7e-21"},{"input":"3fdf36148f033da2","output":"0.4876758"},{"input":"45067ece5d400000","output":"3.3993991196266557e+24"},{"input":"40b8780d7b0c2de9","output":"6264.052658807"},{"input":"be7ad7f29abcaf49","output":"-1.0000000000000001e-7"},{"input":"3f0a36e2eb1c432c","output":"0.000049999999999999996"},{"input":"0000000000000003","output":"1.5e-323"},{"input":"453467e303c00000","output":"2.4669107821148867e+25"},{"input":"3e8ad7f29abcaf48","output":"2e-7"},{"input":"43a0a741a4627800","output":"600000000000000000"},{"input":"4415af1d78b58c40","output":"100000000000000000000"},{"input":"41bccfbce0800000","output":"483376352.5"},{"input":"3e7ad7f29abcaf4a","output":"1.0000000000000002e-7"},{"input":"97ee793b526252cd","output":"-2.0872574011789385e-193"},{"input":"3c36b082c2148b8e","output":"1.23e-18"},{"input":"3fc2718ac743cbdd","output":"0.14409003"},{"input":"4014000000000000","output":"5"},{"input":"40d0b243b2000000","output":"17097.057739257812"},{"input":"3f9f9aedc65b5d63","output":"0.030864444"},{"input":"3e6527e4138a6740","output":"3.94057928e-8"},{"input":"4415af1d78b58c42","output":"100000000000000030000"},{"input":"43bd7e3aa1400000","output":"2125200538403340300"},{"input":"42bedcd1aa1b1800","output":"33933759224600"},{"input":"96a82a4327db3bbc","output":"-1.5784878753521517e-199"},{"input":"f6ab55a99c9c6ffe","output":"-4.3036728791844566e+263"},{"input":"412b774000000000","output":"900000"},{"input":"43f949c0c9450cc3","output":"29155191918840000000"},{"input":"3e7ad7f29abcaf46","output":"9.999999999999997e-8"},{"input":"3f7b902093583fe8","output":"0.00672924733"},{"input":"3fa1b8473febb988","output":"0.034609057"},{"input":"441158e460913d00","output":"80000000000000000000"},{"input":"43dfcbf12bb6c0b7","output":"9164760022000000000"},{"input":"800fffffffffffff","output":"-2.225073858507201e-308"},{"input":"3eb0c6f7a0b5ed8b","output":"9.999999999999995e-7"},{"input":"3af168958a4ae6ca","output":"9e-25"},{"input":"0000000000000003","output":"1.5e-323"},{"input":"6478c470039a86c5","output":"9.80114353743781e+175"},{"input":"4325039c91000000","output":"2957472746700800"},{"input":"3ea4ac35793171a8","output":"6.160942e-7"},{"input":"0010000000000001","output":"2.225073858507202e-308"},{"input":"40c3ec3c54000000","output":"10200.471313476562"},{"input":"3cb7f88cae4ff154","output":"3.32663016859442e-16"},{"input":"444b1ae4d6e2ef51","output":"1.0000000000000001e+21"},{"input":"7ff0000000000001","output":"NaN"},{"input":"41dba7da04800000","output":"1855940626"},{"input":"3f9298b94d52bef6","output":"0.0181607202"},{"input":"3faeb851eb851eb8","output":"0.06"},{"input":"5253d71feb1e0f65","output":"3.946823007283384e+88"},{"input":"000fffffffffffff","output":"2.225073858507201e-308"},{"input":"455321f8d7272805","output":"9.25200758501887e+25"},{"input":"4044000000000000","output":"40"},{"input":"4313bd0845000000","output":"1388966943129600"},{"input":"40e1f0e75c000000","output":"36743.22998046875"},{"input":"414444c000000000","output":"2656640"},{"input":"3e001af579aa3bb1","output":"4.68726158e-10"},{"input":"3fa999999999999a","output":"0.05"},{"input":"3f4d7dbf487fcb92","output":"0.0009"},{"input":"3d651c51ce3718e2","output":"6.000000000000001e-13"},{"input":"c44b1ae4d6e2ef51","output":"-1.0000000000000001e+21"},{"input":"454ce8f34be213d8","output":"6.99e+25"},{"input":"ad8f1c650ea1cbab","output":"-3.0545279878476552e-89"},{"input":"3f6ff1155416ace7","output":"0.00389913717"},{"input":"40c2b586c0872842","output":"9579.052750487"},{"input":"3f196a08e2fd6d8b","output":"0.000096947472"},{"input":"c44b1ae4d6e2ef4e","output":"-999999999999999700000"},{"input":"3e65798ee2308c3a","output":"4e-8"},{"input":"d6e4307999e3b661","output":"-3.79324488621142e+110"},{"input":"3162927bf993650b","output":"8.409196054219328e-71"},{"input":"849433a9d266a680","output":"-1.3267051632878038e-286"},{"input":"4188104e41c00000","output":"50465224.21875"},{"input":"3b8a2ca184da4e9c","output":"6.92829e-22"},{"input":"3eb0c6f7a0b5ed8b","output":"9.999999999999995e-7"},{"input":"3c5ee9af41247f38","output":"6.70315158e-18"},{"input":"3ce203af9ee75616","output":"2e-15"},{"input":"3e055e942f88e77c","output":"6.2193281e-10"},{"input":"451d55deee2f09cb","output":"8.866090565e+24"},{"input":"3f4667f9291a574f","output":"0.0006837813"},{"input":"3e67c73ec31071e2","output":"4.42905378e-8"},{"input":"3ec92a737110e454","output":"0.000003"},{"input":"3b8e392010175ee6","output":"8e-22"},{"input":"c44b1ae4d6e2ef4d","output":"-999999999999999600000"},{"input":"3e6bfe7687c8b223","output":"5.21428811e-8"},{"input":"41b6832daf800000","output":"377695663.5"},{"input":"453177d319800000","output":"2.1117594645378384e+25"},{"input":"4152db02db800000","output":"4942859.4296875"},{"input":"fb2414fea30be6b2","output":"-1.4931144548246343e+285"},{"input":"3c309a213cd6d681","output":"9e-19"},{"input":"3fb8886c87a90668","output":"0.0958316642"},{"input":"3f784f1a28a501ae","output":"0.00593481272"},{"input":"3eb0c6f7a0b5ed8c","output":"9.999999999999997e-7"},{"input":"3e401649fe00c85a","output":"7.49112411e-9"},{"input":"42e6c4cd80000000","output":"200276136951808"},{"input":"000ffffffffffffe","output":"2.2250738585072004e-308"},{"input":"4262f2c534800000","output":"651059373056"},{"input":"ea52b7fc4d49f181","output":"-1.4672111285649078e+204"},{"input":"444b1ae4d6e2ef51","output":"1.0000000000000001e+21"},{"input":"224c30169f4e6ee8","output":"1.8059010669457218e-143"},{"input":"3e049da7e361ce4c","output":"6e-10"},{"input":"3e77dd70e5b70f93","output":"8.89040676e-8"},{"input":"3fb72858a19d4247","output":"0.0904593844"},{"input":"42d77f699a380000","output":"103344000000000"},{"input":"c44b1ae4d6e2ef51","output":"-1.0000000000000001e+21"},{"input":"906e13ae1d7682b9","output":"-1.5498370387866041e-229"},{"input":"3cbcd2b297d889bc","output":"4e-16"},{"input":"41e7a44d90000000","output":"3173149824"},{"input":"4565213826400000","output":"2.043545286377041e+26"},{"input":"41ddcd6500000000","output":"2000000000"},{"input":"40d66abc89c00000","output":"22954.945907592773"},{"input":"c1c744400b16cdc3","output":"-780697622.1781543"},{"input":"742e4e5b348f571e","output":"4.339664449283775e+251"},{"input":"44b71b769f000000","output":"1.0912103874660977e+23"},{"input":"3f713ff83d1eb852","output":"0.004211396868340671"},{"input":"41b623b980000000","output":"371440000"},{"input":"4201517f96000000","output":"9297720000"},{"input":"41fb24a9c36d1d69","output":"7286201398.81968"},{"input":"41ad58413c800000","output":"246161566.25"},{"input":"3ed819608eef6a85","output":"0.00000574568024"}]}diff --git a/rust/logs-ingestion/tests/fixtures/fuzz/pattern.json b/rust/logs-ingestion/tests/fixtures/fuzz/pattern.jsonnew file mode 100644index 000000000000..726c72ed13ba--- /dev/null+++ b/rust/logs-ingestion/tests/fixtures/fuzz/pattern.json@@ -0,0 +1 @@+{"cases":[{"input":{"body":"fi Mon Jan 5 10:00:00 2025:W1301 10:00:00\n١٢٣=aes_128\nuser_A1b2_","keys":["text","nope"]},"output":{"pattern":"fi <TIMESTAMP>:W1301 <N>:<N>:<N>\n١٢٣=aes_128\n<ID>_","maskedLength":49,"ruleFires":[0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,3,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"E1231 23:59:59-E1231 23:59:59.é12١٢٣:🚀@ASIA0000000000000000Xa\\nbGET,0b11xoxb-1234567890-abcBEARER Kabc ","keys":["text","nope"]},"output":{"pattern":"E<KLOGTIME>-E<KLOGTIME>.é<N>١٢٣:🚀@ASIA0000000000000000Xa\\nbGET,<N>b11xoxb-<N>-abcBEARER Kabc ","maskedLength":94,"ruleFires":[0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"[]","keys":["message","msg","event"]},"output":{"pattern":"<JSON_ARRAY>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":12,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"null","keys":["__proto__"]},"output":{"pattern":"null","maskedLength":4,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"primitive","inputCapped":false}},{"input":{"body":"token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig 15/Jan/2025:10:00:00 +0000\n0é\nhost-1.internal_ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1full0x10 ","keys":["__proto__"]},"output":{"pattern":"token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig <TIMESTAMP>\n<N>é\nhost-<N>.internal_ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1full<HEX> ","maskedLength":132,"ruleFires":[0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,2,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"error:Infinitya\\nb_deadbeef12\"1_000api.example.com POSTéééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé =eyJabcdefghijk.abcd.\n","keys":["text","nope"]},"output":{"pattern":"error:Infinitya\\nb_deadbeef12\"<N>_000api.<HOST> POSTéééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé =eyJabcdefghijk.abcd.\n","maskedLength":275,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{-🚀straße-:,","keys":["message","msg","event"]},"output":{"pattern":"{-🚀straße-:,","maskedLength":13,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"message\":\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"}","keys":["__proto__"]},"output":{"pattern":"<JSON:message>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":14,"jsonKeyCount":1,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":" 12,Wed Jan 15 10:00:00 UTC 2025 fi/token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig=sk_live_aaaaaaaaaaaaaaaaaaaaaaaa/gho_short_�=","keys":["message","msg","event"]},"output":{"pattern":" <N>,<TIMESTAMP> fi/token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig=sk_live_aaaaaaaaaaaaaaaaaaaaaaaa/gho_short_�=","maskedLength":112,"ruleFires":[0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{}","keys":["message","msg","event"]},"output":{"pattern":"<JSON:>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":7,"jsonKeyCount":0,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"10x109007199254740994","keys":["__proto__"]},"output":{"pattern":"<N>x109007199254740994","maskedLength":22,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"[email protected]__defineGetter__0-1e40000","keys":["message","msg","event"]},"output":{"pattern":"<EMAIL>__defineGetter__0-<N>e40000","maskedLength":34,"ruleFires":[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"-0,日本語\n \n{\t./api/users/12345/orders/987.xoxb-12345-xoxb-12345-BEARER Kabc=libssl.so/cus_ABCDEFGHIJKLMN/","keys":[]},"output":{"pattern":"-<N>,日本語\n \n{\t./api/users/<N>/orders/<N>.xoxb-<N>-xoxb-<N>-BEARER Kabc=libssl.so/<ID>/","maskedLength":85,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,5,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"日本:BEARER Kabc:[email protected]🚀.Mon Jan 5 10:00:00 2025/4111 1111 1111 1111-\"䙱\" -) /=\t.","keys":["text","nope"]},"output":{"pattern":"日本:BEARER Kabc:[email protected]🚀.<TIMESTAMP>/<N> <N> <N> <N>-\"䙱\" -) /=\t.","maskedLength":62,"ruleFires":[0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"12 =","keys":["message","msg","event"]},"output":{"pattern":"<N> =","maskedLength":5,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":" {} ","keys":[]},"output":{"pattern":"<JSON:>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":7,"jsonKeyCount":0,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"{\"Bearer\\tabc=\":\"4294967294 𐘧β \\\"abc3fa85f64-5717-4562-b3fc-2c963f66afa6,[email protected]\\\"[email protected]_straße_eyJabcdefghijk.abcd.\",\"libssl.so@_12345_3fa\":8,\"xoxb-1234567890-abc \":\"Bearer\\tabc١٢٣deadbeef12:-1true_3fa85f64-5717-4562-b3fc-2c963f66afa6user_A1b2\\\":.Wed, 15 Jan 2025 10:00:00 GMT\",\"message\":\"level :\"}","keys":["text","nope"]},"output":{"pattern":"<JSON:Bearer\tabc=,libssl.so@_12345_3fa,message,xoxb-<N>-abc >","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":61,"jsonKeyCount":4,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0]}},{"input":{"body":"١٢٣Wed, 15 Jan 2025 10:00:00 GMT.\r\n7token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sigΣΑΣ.12345678.","keys":[]},"output":{"pattern":"١٢٣<TIMESTAMP>.\r\n<N>token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sigΣΑΣ.<N>.","maskedLength":74,"ruleFires":[0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"1\":\"host-1.internal,gho_short\\n3fa85f64-5717-4562-b3fc-2c963f66afa6-Jan 5 10:00:00\\\"g[email protected]🚀_12.5abc,abc3fa85f64-5717-4562-b3fc-2c963f66afa6:/api/users/12345/orders/987@\",\"4294967294\":\"xoxb-12345-,\\t\\\"\",\"b\":\"]_job_12345.eyJabcdefghijk.abcd.\\n00 hasOwnProperty_\",\"_12345_3fa85f64-5717\":\"sub_Abcdefghijklmnopqrstuvwx\\\"quoted\\\"@\\r\\n_AKIAA1B2C3D4E5F6G7H8 İstanbul\\n\",\"host.example.com\":2,\"1.5\":2,\"۱\":3,\"2001:db8::1 @192.168\":\"0xDEADbeef:192.168.001.001 k[1,2]=\",\"level\":7,\"deploy.sh-İstanbul/0\":\"100deadbeef / /Bearer\\u000bab_\",\"payload\":1,\"host-1.internal.user\":\"].éa\\\\nb=xoxp-1234567890/é@example.com\\n日本\\r\\n/\\r\\n-Infinity _\",\"Infinity AKIAA1B2C3D\":1,\"abc3fa85f64-5717-456\":1,\"ERROR@deadbeef12\":\"0o7http.method.0.1 -\\\"⦯ ,job_12345:host-1.internal-I0827 11:39:40.307946E1231 23:59:59\\\"3fa85f64-5717-4562-b3fc-2c963f66afa6=AKIAA1B2C3D4E5F6G7H8.deadbeef12 \",\"job_12345\\\\ [email protected] /\":6,\"0.1 \\\"token=eyJhbGciO\":4,\"ASIA0000000000000000\":9,\"k\":\"\\t\\\\ null-libssl.so,gho_short-BEARER Kabc=3fa85f64-5717-4562-b3fc-2c963f66afa6,x_1234\\n\",\"\\\\\":6,\"Wed, 15 Jan 2025 10:\":\"\\\\日本語 \\n🚀.\",\"deadbeef12,\":\"msg \\n\\\" \",\"\\\\:\":\"::1-\",\"GET Infinity\":\"2025-01-15T10:00:00.123Z-sk_live_aaaaaaaaaaaaaaaaaaaaaaaa 3fa85f64-5717-4562-b3fc-2c963f66afa6\\nsub_Abcdefghijklmnopqrstuvwx_W1301 10:00:00\\\"Wed, 15 Jan 2025 10:00:00 GMT\\\"fatal true deploy.sh,\",\" \":2,\"\\\\@1.7976931348623157\":1,\"full\":3,\"Dž.aes_128/.50/Wed, 1\":\"1e3 ,2.5e-8é@example.com:12345678:x_1234,[email protected]🚀=\",\"3fa85f64-5717-4562-b\":\"0o7 ,sk_live_0123456789abcdefghijkl@123456789012345680000{\\\"a\\\":1}.}_Ɍ [email protected]🚀,sub_Abcdefghijklmnopqrstuvwx/libssl.so日本語\\\"quoted\\\"@192.168.001.001,\"}","keys":["message","msg","event"]},"output":{"pattern":"<JSON: ,<HEX>,,<HEX>-<N>-<N>,<HEX>-<N>-<N>-b,<HOST>,<HOST>.user,<N>,<N>.<N>,<N>.<N> \"token=eyJhbGciO,<N>:db8::<N> @<N>.<N>,ASIA0000000000000000,ERROR@<HEX>,GET Infinity,Infinity AKIAA1B2C3D,Wed, <N> Jan <N> <N>:,\\,\\:,\\@<N>.<N>,_12345_3fa85f64-<N>,b,deploy.sh-İstanbul/<N>,job_<N>\\ [email protected] /,k,level,payload,Dž.aes_128/.<N>/Wed, <N>,۱,full>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":338,"jsonKeyCount":29,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,0,0,23,4,0]}},{"input":{"body":"{\"0\":9,\"1\":2,\"cus_ABCDEFGHIJKLMN/x\":0,\"2001:db8::1\":\"aes_128/\",\"message\":7,\"[email protected] bearer x.y-z\":\"0xDEADbeef\\n\\u000b \\\"4294967295 =\",\"api.example.comDž 3fa\":7,\" \":\"},deadbeef12,]@\",\".a\":5,\"é\":\"[email protected]🚀/abc3fa85f64-5717-4562-b3fc-2c963f66afa6/ /ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1:\\\":123/sk_live_aaaaaaaaaaaaaaaaaaaaaaaa,\",\"[email protected]:é123fa85f\":3,\"http.method\":3,\"𐀀fatal/1.5 ,@\":2,\"sk_test_ZZZZZZZZZZZZ\":\"a\\\\nb:W1301 10:00:00=\\u000b null\\nlibssl.so.\",\"user.email\":2,\"Wed, 15 Jan 2025 10:\":1,\"🚀\":\"Infinity9007199254740994\\\"aes_128_BEARER Kabcxoxb-12345-\\n2025-01-15T10:00:00.123Z\\\"job_12345,libssl.so,\",\"{:\":7,\"b\":\"é@example.com 🚀 :user [email protected] logged in-1e400 -0xDEADbeef:debug1.5 @\",\"-1\":\"job_12345 sk_live_aaaaaaaaaaaaaaaaaaaaaaaa\\\"[host-1.internal\\n{ Dž,BEARER Kabc/messagex@\\\\\\\"\",\"uuid_3fa85f64-5717-4\":\"2001:db8::1: @2025-01-15T10:00:00.123Zsk_live_aaaaaaaaaaaaaaaaaaaaaaaa\\\"x_1234_INFO+5 /\\\\/xoxb-12345-@\",\"[1,2]AKIAIOSFODNN7EXAMPLE\":\"W1301 10:00:00=\\t é[email protected],gho_short_{\\\"a\\\":1} \",\"msg\":5,\"\\t5e-324 {\\\"a\\\":1},-1.5\":\"deploy.sh@[email protected]@4294967295:I0827 11:39:40.307946/xoxb-1234567890-abc @Wed Jan 15 10:00:00 UTC 2025.}:/api/users/12345/orders/987 [email protected]\\n\",\"Wed Jan 15 10:00:00 \":8,\"1e3\":\"AKIAIOSFODNN7EXAMPLE @O𐀀 \\n𐀀\\\"Bearer abc.def-ghi[1,2] .length 01\\\"\",\"0o7\":3,\" /_12345_3fa85f64-57\":\"libssl.so@{=\\\".deadbeef _+5 2 AKIAA1B2C3D4E5F6G7H8\\n/api/users/12345/orders/987__12345_3fa85f64-5717-4562-b3fc-2c963f66afa6/10.0.0.256=sk_live_aaaaaaaaaaaaaaaaaaaaaaaa_\",\"-1.5 Infinity 15/Jan\":1}","keys":["constructor","msg"]},"output":{"pattern":"<JSON:\t<N>e-<N> {\"a\":<N>},-<N>.<N>, /_12345_3fa85f64-<N>,-<N>,-<N>.<N> Infinity <N>/Jan,.a,<EMAIL> bearer x.y-z,<HOST>Dž <N>fa,<ID>/x,<N>,<N>:db8::<N>,<N>e3,<N>o7,<TIMESTAMP> ,Wed, <N> Jan <N> <N>:,[<N>,<N>]AKIAIOSFODNN7EXAMPLE,b,http.method,message,msg,sk_test_ZZZZZZZZZZZZ,user.email,uuid_3fa85f64-<N>-<N>,{:, ,é,𐀀fatal/<N>.<N> ,@,🚀,<EMAIL>:é<HEX>>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":353,"jsonKeyCount":29,"ruleFires":[0,0,0,0,0,0,0,0,1,2,0,1,0,0,0,0,1,0,0,22,1,4]}},{"input":{"body":"١٢٣=","keys":[]},"output":{"pattern":"١٢٣=","maskedLength":4,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"2\":0,\"[1,2]\":7,\"payload\":4,\"eyJabcdefghijk.abcd.\":5,\"é@example.com\\n🚀 \\n\":\"deploy.sh/:_🚀.3fa85f64-5717-4562-b3fc-2c963f66afa6 =4111 1111 1111 1111-\",\"AKIAA1B2C3D4E5F6G7H8\":0,\"\":4,\"host.example.com\":5,\"I0827 11:39:40.30794\":0,\"Mon Jan 5 10:00:00 2\":\"\\\\@toString,Dž=/api/users/12345/orders/987 ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1.Dž,4111 1111 1111 1111-\",\"9007199254740993\":0,\"\\n\":9,\"日本\":4,\"é@example.com.\":3,\"Jan 5 10:00:00\\\"ms=1\":2,\"debug - k.[:\":5,\"http.method\":7,\"192.168.0.1\":7,\"cus_ABCDEFGHIJKLMN_\":\"cus_ABCDEFGHIJKLMN\\\"\\\\=__defineGetter__ POST@Bearer\\tabc,user [email protected] logged in,I0827 11:39:40.307946.libssl.so\\\"\",\"1.5\":6,\"2.5e-82.5e-8a. /15/J\":\"日本 _15/Jan/2025:10:00:00 [email protected] _[1,2]ERROR=token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig:\",\"🚀 \\r\\n,xxxxxxxxxxxxxx\":\"é@example.com= /\",\" \":5,\"full\":6,\"libssl.so\\n =\":2,\"\\\"/\":1,\"\":\"_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6\\\"\",\"0 k cus_ABCDEFGHIJKL\":4,\"deadbeef12_job_12345\":2,\"01\":6,\"sub_Abcdefghijklmnop\":9,\"[email protected]🚀\\\"3fa85f64-571\":9}","keys":["message","msg","event"]},"output":{"pattern":"<JSON:,\n, ,\"/,<HOST>,<IP>,<N>,<N> k cus_ABCDEFGHIJKL,<N>.<N>,<N>.<N>e-<N>.<N>e-<N>a. /<N>/J,<TIMESTAMP> <N>,<TIMESTAMP>\"ms=<N>,AKIAA1B2C3D4E5F6G7H8,I<KLOGTIME>,[<N>,<N>],cus_ABCDEFGHIJKLMN_,deadbeef12_job_<N>,debug - k.[:,eyJabcdefghijk.abcd.,http.method,libssl.so\n =,payload,sub_Abcdefghijklmnop,[email protected]🚀\"<HEX>-<N>,é@<HOST>\n🚀 \n,é@<HOST>.,日本,🚀 \r\n,xxxxxxxxxxxxxx,full,>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":370,"jsonKeyCount":32,"ruleFires":[0,1,0,0,0,0,0,0,2,0,0,0,0,0,0,1,3,0,1,14,1,3]}},{"input":{"body":"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 12","keys":["message","msg","event"]},"output":{"pattern":"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 <N>","maskedLength":48,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"0o7-1e4005.","keys":["message","msg","event"]},"output":{"pattern":"<N>o7-<N>e4005.","maskedLength":15,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"[email protected]\ntoken=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig.0b11é\"١٢٣\n\\.192.168.001.001 ","keys":["constructor","msg"]},"output":{"pattern":"<EMAIL>\ntoken=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig.<N>b11é\"١٢٣\n\\.<IP> ","maskedLength":74,"ruleFires":[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":",-sub_Abcdefghijklmnopqrstuvwx=é12-deadbeef12\ngho_short= 12 \n3fa85f64-5717-4562-b3fc-2c963f66afa6=١٢٣/eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123[.","keys":[]},"output":{"pattern":",-<ID>=é<N>-<HEX>\ngho_short= <N> \n<UUID>=١٢٣/eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123[.","maskedLength":91,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,2,1,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"ASIA0000000000000000X,\\\"-4111 1111 1111 1111\\njob_12345.2025-01-15T10:00:00.123Z\\n3fa85f64-5717-4562-b3fc-2c963f66afa6-4294967294\\r\\n@\"","keys":[]},"output":{"pattern":"ASIA0000000000000000X,\"-<N> <N> <N> <N>\njob_<N>.<TIMESTAMP>\n<UUID>-<N>\r\n@","maskedLength":73,"ruleFires":[1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,5,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"{\"İstanbul.api.example\":\"5.event.2025-01-15 10:00:00,123+0100 -١٢٣/[email protected] _١٢٣\\\"\",\"1.7976931348623157e+308hasOwnProperty\":3,\"-1\":\"eyJabcdefghijk.abcd.._12345_3fa85f64-5717-4562-b3fc-2c963f66afa6\\n\",\"event\":5}","keys":[]},"output":{"pattern":"<JSON:-<N>,<N>.<HEX>+<N>hasOwnProperty,event,İstanbul.api.example>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":66,"jsonKeyCount":4,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,1]}},{"input":{"body":"user_A1b2:ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1.0x104_bearer x.y-z~+/[email protected]_debugtrue.Bearer abc.def-ghi msg/]-/api/users/12345/orders/987-12345678=","keys":["message","msg","event"]},"output":{"pattern":"<ID>:<ID>.<N>x104_bearer x.y-z~+/[email protected]_debugtrue.Bearer abc.def-ghi msg/]-/api/users/<N>/orders/<N>-<N>=","maskedLength":108,"ruleFires":[0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,3,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"sk_test_ZZZZZZZZZZZZZZZZZZZ-5e-324\n\".ms=12\"[,ghp_0123456789abcdefghij0123456789abcdef 0o7 -","keys":["message","msg","event"]},"output":{"pattern":"sk_test_ZZZZZZZZZZZZZZZZZZZ-<N>e-<N>\n\".ms=<N>\"[,ghp_0123456789abcdefghij0123456789abcdef <N>o7 -","maskedLength":96,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,2],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"12.5\"xwarn \n9007199254740994 xoxb-1234567890-abc @/api/users/12345/orders/987-","keys":[]},"output":{"pattern":"<N>.<N>\"xwarn \n<N> xoxb-<N>-abc @/api/users/<N>/orders/<N>-","maskedLength":59,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"event.K x [email protected]=::1_AKIAA1B2C3D4E5F6G7H8\"::1@","keys":["__proto__"]},"output":{"pattern":"event.K x <N>[email protected]=::<N>_AKIAA1B2C3D4E5F6G7H8\"::<N>@","maskedLength":61,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,2],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"aes_128,_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6-Bearer abc.def-ghi 2025-01-15T10:00:00Z sk_test_ZZZZZZZZZZZZZZZZZZZ:Bearer\\tabc_日本._12345_3fa85f64-5717-4562-b3fc-2c963f66afa6\\\"\\\\.日本/token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig \"","keys":["text","nope"]},"output":{"pattern":"aes_128,_<N>_<UUID>-Bearer abc.def-ghi <TIMESTAMP> sk_test_ZZZZZZZZZZZZZZZZZZZ:Bearer\tabc_日本._<N>_<UUID>\"\\.日本/token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig ","maskedLength":157,"ruleFires":[1,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"}\n0=Mon Jan 5 10:00:00 2025,","keys":["message","msg","event"]},"output":{"pattern":"}\n<N>=<TIMESTAMP>,","maskedLength":18,"ruleFires":[0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"-1.5\nfull\"x_1234@[email protected].","keys":["text","nope"]},"output":{"pattern":"-<N>.<N>\nfull\"x_<N>@[email protected].","maskedLength":26,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,2,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"10\":3,\"4294967294\":\"[email protected]\\nW1301 10:00:00,Wed Jan 15 10:00:00 UTC 2025aes_128/2.5e-8/\",\"[email protected]🚀=4111 1111 11\":\"libssl.so user_123 /xoxp-1234567890/\\\\_deadbeef12\\\"}.\",\"é\":7,\"a\":\"token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig k=0x10=ɑ 1_000 -:} \",\"Bearer\\u000bab_\":\"Dž_12345678 E1231 23:59:59:\",\"4294967295\":\"GET 日本,[email protected] /Mon Jan 5 10:00:00 2025\\n{=1.5 user.email=abc3fa85f64-5717-4562-b3fc-2c963f66afa6 \",\"level\":4,\"1.5\":2,\"\":7,\"b\":6,\"warn\":0,\"4294967294 \":\"Wed Jan 15 10:00:00 UTC 2025\\\"bearer x.y-z~+/==\\\"_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6/api/users/12345/orders/987\\ncus_ABCDEFGHIJKLMN=xoxb-1234567890-abc𗸴,eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123{\\\"a\\\":1}_\",\"123_W1301 10:00:00@a\":\"日本語\\\\_\\r\\n\\\"ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1@ms=12 bearer x.y-z~+/==-0éx ,\",\"ghp_0123456789abcdef\":7,\"Mon Jan 5 10:00:00 2\":7,\"9007199254740992ERROR\":6,\"payload\":9,\"[email protected]🚀\\nhost-1.inter\":\"GET \\\"\\t=15/Jan/2025:10:00:00 +0000,\",\"sub_Abcdefghijklmnop\":6,\"event\":4,\"\\n\":\"xoxb-12345-:POST.deadbeef12@\",\"a.\":\"valueOf/1e31e3,{/xoxp-1234567890=é@example.com.2025-01-15 10:00:00,123+0100:\",\"0.30000000000000004-\":9,\"E1231 23:59:59,é_a@b\":2,\"eyJabcdefghijk.abcd.\":1,\"١٢٣\\\"Wed, 15 Jan 2025\":5,\".a\":4,\"Infinity.null.🚀=é-1\":2,\"msg\":2}","keys":["message","msg","event"]},"output":{"pattern":"<JSON:,\n,.a,<N>,<N> ,<N>.<N>,<N>.<N>-,<N>ERROR,<TIMESTAMP> <N>,Bearer\u000bab_,E<KLOGTIME>,é_a@b,Infinity.null.🚀=é-<N>,a,a.,b,event,eyJabcdefghijk.abcd.,ghp_0123456789abcdef,level,msg,payload,sub_Abcdefghijklmnop,warn,[email protected]🚀\nhost-<N>.inter,[email protected]🚀=<N> <N> <N>,é,١٢٣\"Wed, <N> Jan <N>,123_W1301 <N>:<N>:<N>@a>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":304,"jsonKeyCount":30,"ruleFires":[0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,19,0,1]}},{"input":{"body":"fatal \"quoted\"𐀀a ","keys":["constructor","msg"]},"output":{"pattern":"fatal \"quoted\"𐀀a ","maskedLength":18,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"AKIAIOSFODNN7EXAMPLE\":9}","keys":["text","nope"]},"output":{"pattern":"<JSON:AKIAIOSFODNN7EXAMPLE>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":27,"jsonKeyCount":1,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"3fa85f64-5717-4562-b3fc-2c963f66afa6ERROR-straße=xoxb-12345-/[email protected]\" -","keys":[]},"output":{"pattern":"<UUID>ERROR-straße=xoxb-<N>-/<EMAIL>-\" -","maskedLength":40,"ruleFires":[0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{=cus_ABCDEFGHIJKLMN-é /Wed Jan 15 10:00:00 UTC 2025:1e3 /warn0\n 12\"é@example.com","keys":["constructor","msg"]},"output":{"pattern":"{=<ID>-é /<TIMESTAMP>:<N>e3 /warn0\n <N>\"é@<HOST>","maskedLength":49,"ruleFires":[0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"msg\":null}","keys":["text","nope"]},"output":{"pattern":"<JSON:msg>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":10,"jsonKeyCount":1,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"{\"\\\\ASIA0000000000000000\":6,\"21234567890123456800\":\"{\\\"999.9999999 1.7976931348623157e+308 \\n::1.x_1234-full_\",\"éééééééééééééééééééé\":3}","keys":["text","nope"]},"output":{"pattern":"<JSON:<N>,\\ASIA0000000000000000,éééééééééééééééééééé>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":53,"jsonKeyCount":3,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0]}},{"input":{"body":" 12 .🚀_192.168.001.001:sub_Abcdefghijklmnopqrstuvwx_\\=I0827 11:39:40.307946=0o7 /api/v1/users/123.1e-7\ndeadbeef12, 10 /","keys":["constructor","msg"]},"output":{"pattern":" <N> .🚀_192.<N>.<N>.<N>:sub_Abcdefghijklmnopqrstuvwx_\\=I<KLOGTIME>=<N>o7 /api/v1/users/<N>.<N>e-<N>\n<HEX>, <N> /","maskedLength":114,"ruleFires":[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,1,2],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"15/Jan/2025:10:00:00 +0000=0.1 full/日本/eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123fatal/é@example.com-1_000-Infinity\\\".51.7976931348623157e+308 eyJabcdefghijk.abcd.=\"","keys":["text","nope"]},"output":{"pattern":"<TIMESTAMP>=<N>.<N> full/日本/eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123fatal/é@<HOST>-<N>_000-Infinity\".<N>.<HEX>+<N> eyJabcdefghijk.abcd.=","maskedLength":139,"ruleFires":[0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,4,1,1],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"cus_ABCDEFGHIJKLMN,","keys":["text","nope"]},"output":{"pattern":"<ID>,","maskedLength":5,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"日本語 +5 \"","keys":["text","nope"]},"output":{"pattern":"日本語 +<N> ","maskedLength":9,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"ghp_0123456789abcdefghij0123456789abcdef 1e-7-aes_128::1\"15/Jan/2025:10:00:00 +0000,\\:日本語 __defineGetter__ ::1@-InfinityF ,","keys":["__proto__"]},"output":{"pattern":"ghp_0123456789abcdefghij0123456789abcdef <N>e-<N>-aes_128::<N>\"<TIMESTAMP>,\\:日本語 __defineGetter__ ::<N>@-InfinityF ,","maskedLength":117,"ruleFires":[0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":" POSTdebug12 ","keys":["message","msg","event"]},"output":{"pattern":" POSTdebug<N> ","maskedLength":15,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"Mon Jan 5 10:00:00 2025\n日本\"AKIAA1B2C3D4E5F6G7H8. /xoxb-12345-,","keys":["constructor","msg"]},"output":{"pattern":"<TIMESTAMP>\n日本\"AKIAA1B2C3D4E5F6G7H8. /xoxb-<N>-,","maskedLength":48,"ruleFires":[0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"Wed Jan 15 10:00:00 \":7,\"event\":\" \\nabc3fa85f64-5717-4562-b3fc-2c963f66afa6\\\"Wed, 15 Jan 2025 10:00:00 GMT, 12:user_A1b2.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx!\\n\"}","keys":[]},"output":{"pattern":"<JSON:<TIMESTAMP> ,event>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":25,"jsonKeyCount":2,"ruleFires":[0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"\"job_12345.00 true _bAKIAIOSFODNN7EXAMPLE: ,K.trueGET\\nghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1- 123\\nΣΑΣ-\"","keys":["__proto__"]},"output":{"pattern":"job_<N>.<N> true _bAKIAIOSFODNN7EXAMPLE: ,K.trueGET\n<ID>- 123\nΣΑΣ-","maskedLength":67,"ruleFires":[0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"{\"Bearer\\u000babuser alice.\":6}","keys":["constructor","msg"]},"output":{"pattern":"<JSON:Bearer\u000babuser alice.>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":27,"jsonKeyCount":1,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"{\"0\":\"abc3fa85f64-5717-4562-b3fc-2c963f66afa6/fi_::1/\",\"10\":\"١٢٣\\n-1e400,bearer x.y-z~+/== [email protected]\\nxoxb-12345--job_12345 \",\"sk_live_aaaaaaaaaaaa\":\"bearer x.y-z~+/=== @bearer x.y-z~+/==\\n0xDEADbeef=İstanbul [email protected]\\n\",\"0o7\\\"10.0.0.256/AKIAI\":8,\"valueOf\":\"0x10 _𘋊12:\",\"Bearer\\tabc2025-01-15\":\"libssl.so bearer x.y-z~+/===}@sub_Abcdefghijklmnopqrstuvwx]\\\"api.example.com-\\\\,job_1234512 .-\",\"W1301 10:00:00\\nI0827\":4,\"Dž,é12/libssl.so, \\nWe\":6,\"Wed Jan 15 10:00:00 \":0,\"\\\"\":0,\"fi,192.168.001.001=sk\":1,\"2025-01-15 10:00:00,\":\"\\\\\\\"[email protected] x_1234-12\\r\\n.éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé4294967295:é12,[.Bearer abc.def-ghi a.:W1301 10:00:00\",\"/api/users/12345/ord\":1,\"Infinity:[\\\"]@a.b吩 :\":6,\"BEARER Kabc-ms=12:xo\":9,\"a.\":6,\"é\":\",_\\u000b\\\"\",\"𐀀\":\"1e400 _user [email protected] logged in@/api/users/12345/orders/987\",\"1/-1.5:abc3fa85f64-5\":\"BEARER KabcΣΑΣ,_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6 a _BEARER Kabc \\t\\\"\",\"éééééééééééééééééééé\":\"[ 1,5\\\" _\",\"1_000 日本語\":6,\"日本\":8,\"🚀_straße,[email protected]🚀@[\\n\":3,\"Wed, 15 Jan 2025 12:00:00 GMT\":3,\"straße-ASIA000000000\":0,\"sub_Abcdefghijklmnop\":9,\"01 1e3 \\n/api/users/1\":\"payload�,15/Jan/2025:10:00:00 +0000@/api/users/12345/orders/987@日本語 @[email protected]🚀\\\":.gho_short\\\"\"}","keys":["message","msg","event"]},"output":{"pattern":"<JSON:\",/api/users/<N>/ord,<N>,<N> <N>e3 \n/api/users/<N>,<N>/-<N>.<N>:<HEX>-<N>,<N>_000 日本語,<N>o7\"<IP>/AKIAI,<TIMESTAMP>,<TIMESTAMP> ,<TIMESTAMP>,,BEARER Kabc-ms=<N>:xo,Bearer\tabc2025-<N>-<N>,Infinity:[\"]@a.b吩 :,W1301 <N>:<N>:<N>\nI0827,a.,sk_live_aaaaaaaaaaaa,straße-ASIA000000000,sub_Abcdefghijklmnop,valueOf,é,éééééééééééééééééééé,Dž,é<N>/libssl.so, \nWe,日本,𐀀,🚀_straße,[email protected]🚀@[\n,fi,<IP>=sk>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":392,"jsonKeyCount":27,"ruleFires":[1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,2,16,1,3]}},{"input":{"body":"\"2025-01-15T10:00:00.123Z.12345678./api/users/12345/orders/987 /Bearer abc.def-ghi 1e3 \\n\"","keys":["text","nope"]},"output":{"pattern":"<TIMESTAMP>.<N>./api/users/<N>/orders/<N> /Bearer abc.def-ghi <N>e3 \n","maskedLength":70,"ruleFires":[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,1],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"\"Wed, 15 Jan 2025 10:00:00 GMT/123=\"","keys":["__proto__"]},"output":{"pattern":"<TIMESTAMP>/123=","maskedLength":16,"ruleFires":[0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6@deadbeef12=_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6\"Wed, 15 Jan 2025 10:00:00 GMT=api.example.comdeploy.sh bearer x.y-z~+/== ","keys":["message","msg","event"]},"output":{"pattern":"_<N>_<UUID>_<N>_<UUID>@<HEX>=_<N>_<UUID>\"<TIMESTAMP>=api.example.comdeploy.sh bearer x.y-z~+/== ","maskedLength":97,"ruleFires":[0,0,0,0,0,0,0,1,0,0,0,0,3,0,0,0,0,0,0,0,1,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"é[email protected]@\\\"_\\\" \"","keys":["text","nope"]},"output":{"pattern":"é<N>=<EMAIL>@\"_\" ","maskedLength":17,"ruleFires":[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"\"\\t@\"","keys":["message","msg","event"]},"output":{"pattern":"\t@","maskedLength":2,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"\"/api/users/12345/orders/9873fa85f64-5717-4562-b3fc-2c963f66afa6123456789012345680000.\"","keys":["message","msg","event"]},"output":{"pattern":"/api/users/<N>/orders/<UUID>123456789012345680000.","maskedLength":50,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"[1,2]","keys":[]},"output":{"pattern":"<JSON_ARRAY>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":12,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"0.1 ","keys":["text","nope"]},"output":{"pattern":"<N>.<N> ","maskedLength":8,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0],"bodyKind":"primitive","inputCapped":false}},{"input":{"body":"\\=sk_live_aaaaaaaaaaaaaaaaaaaaaaaa:{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"a.12:1.5 \"W1301 10:00:00=","keys":["__proto__"]},"output":{"pattern":"\\=sk_live_aaaaaaaaaaaaaaaaaaaaaaaa:{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"a.<N>:<N>.<N> \"W1301 <N>:<N>:<N>=","maskedLength":632,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"1e400","keys":["__proto__"]},"output":{"pattern":"<N>e400","maskedLength":7,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],"bodyKind":"primitive","inputCapped":false}},{"input":{"body":"日本/\",deploy.sh_A[email protected]","keys":["message","msg","event"]},"output":{"pattern":"日本/\",<EMAIL>","maskedLength":12,"ruleFires":[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{}","keys":["text","nope"]},"output":{"pattern":"<JSON:>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":7,"jsonKeyCount":0,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"\"é@example.com \"","keys":["text","nope"]},"output":{"pattern":"é@<HOST> ","maskedLength":9,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"{\"4294967294\":\"[@ ,é.5.192.168.1.1 @host-1.internal@user_A1b2\\\"1e3 Dž\\\"\\\"\\nghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1@\",\"1e-7 é \":\"é@example.com.é12,job_12345-host-1.internal\\nDž:\\\"\",\"user_123\":1,\"0xDEADbeef.libssl.so\":3,\"length\":3,\"00\\neyJabcdefghijk.ab\":\"5e-3249007199254740992 :AKIAA1B2C3D4E5F6G7H8,b.user [email protected] logged in\\n\\\"@api.example.com\\\"\\t@Dž/2025-01-15 10:00:00,123+0100-sub_Abcdefghijklmnopqrstuvwx=\",\"gho_short=]@192.168.\":4,\"�\":9,\"2025-01-15T10:00:00Z\":\"0.30000000000000004_E1231 23:59:59\\n4111 1111 1111 1111=POST@debug /:/2025-01-15 10:00:00,123+0100=message,\",\": bearer x.y-z~+/==\":\"[email protected].\",\"valueOf\":7,\"x_1234-x_1234,4111 1\":4,\"0xDEADbeef,:\\nsk_test\":\"ERROR .}@ 1.5 [email protected]🚀@\",\"١٢٣/\\r\\n\\njob_12345.\":8,\"k\":\"__defineGetter__ @0 \",\"warn \":\"[email protected]🚀.xoxp-1234567890\\ndeadbeef12=ms=12.é12.é Infinity-]@12345678\\n _,\",\"192.168.0.1\":2,\"a.b\":\"𐀀 payload abc3fa85f64-5717-4562-b3fc-2c963f66afa6/\",\"constructor\":\"}@2025-01-15T10:00:00.123Z\\\"E1231 23:59:59/\",\"ERROR192.168.1.1 -be\":9,\"4111 1111 1111 1111:\":\"Bearer\\u000bab\\\"deploy.sh:Jan 5 10:00:00=bearer x.y-z~+/===\",\"sk_test_ZZZZZZZZZZZZ\":\"eyJabcdefghijk.abcd., :123456789012345680000 =ASIA0000000000000000X \\nx_1234\\na.b2001:db8::1 -BEARER Kabc\\n10.0.0.256,\",\"event\":\"[email protected]\\\"Wed Jan 15 10:00:00 UTC [email protected]\\n🚀 a\\\\nb_🚀_::1\",\"user alice.smith+tag\":\"192.168.001.001@token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sigDž_]-[3fa85f64-5717-4562-b3fc-2c963f66afa6 .\",\"abc3fa85f64-5717-456\":\"::\\r\\n-xoxb-12345-=\",\"Infinity \":\"12345678 BEARER Kabc BEARER Kabc=\\\\,3fa85f64-5717-4562-b3fc-2c963f66afa6@fi=ms=12,x_1234,Mon Jan 5 10:00:00 2025/\\r\\n_\",\" \":2,\"𐬤 api.example.com=\":\"eyJabcdefghijk.abcd.\\\"I0827 11:39:40.307946-bearer x.y-z~+/==@straße,日本 5./10.0.0.256.\",\"AKIAA1B2C3D4E5F6G7H8\":\"user_A1b2.x_1234.2=é@[email protected]\\\"Jan 5 10:00:00\\nhost-1.internal=12-\",\"124294967294\":\"job_12345-\"}","keys":["message","msg","event"]},"output":{"pattern":"<EMAIL><UUID>\"<TIMESTAMP>[email protected]\n🚀 a\\nb_🚀_::<N>","maskedLength":47,"ruleFires":[0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0],"bodyKind":"json_object_or_array","inputCapped":false}},{"input":{"body":"0xDEADbeef\né12\nASIA0000000000000000X_deadbeef12\"-9007199254740992a.\na \"sub_Abcdefghijklmnopqrstuvwx_1e3[1,2],+5 =","keys":["__proto__"]},"output":{"pattern":"<HEX>\né<N>\nASIA0000000000000000X_deadbeef12\"-<HEX>.\na \"sub_Abcdefghijklmnopqrstuvwx_1e3[<N>,<N>],+<N> =","maskedLength":103,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,4,1,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"𘗆 \"user_123\\ 12345678 straße\"12\"quoted\"_192.168.001.001 api.example.com,, 9007199254740992","keys":["message","msg","event"]},"output":{"pattern":"𘗆 \"user_123\\ <N> straße\"<N>\"quoted\"_192.<N>.<N>.<N> <HOST>,, <N>","maskedLength":65,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,6,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"0o7 true192.168.0.1=,/user_123 _AKIAIOSFODNN7EXAMPLE 日本語,5e-324 12345678 ) host-1.internal\n:abc3fa85f64-5717-4562-b3fc-2c963f66afa6_","keys":["message","msg","event"]},"output":{"pattern":"<N>o7 true192.<N>.<N>.<N>=,/user_123 _AKIAIOSFODNN7EXAMPLE 日本語,<N>e-<N> <N> ) <HOST>\n:<UUID>_","maskedLength":95,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,5,0,2],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"Ӹ,I0827 11:39:40.307946-/api/v1/users/123\"gho_short@\t_192.168.001.001:","keys":["message","msg","event"]},"output":{"pattern":"Ӹ,I<KLOGTIME>-/api/v1/users/<N>\"gho_short@\t_192.<N>.<N>.<N>:","maskedLength":60,"ruleFires":[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6,0-","keys":["text","nope"]},"output":{"pattern":"_<N>_<UUID>,<N>-","maskedLength":16,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"[email protected]_{_gho_short ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1\n🚀日本\"2.5e-8 0.1@I0827 11:39:40.307946.::1_x_1234_sk_test_ZZZZZZZZZZZZZZZZZZZ_","keys":["__proto__"]},"output":{"pattern":"[email protected]_{_gho_short <ID>\n🚀日本\"<N>.<N>e-<N> <N>.<N>@I<KLOGTIME>.::<N>_x_1234_sk_test_ZZZZZZZZZZZZZZZZZZZ_","maskedLength":102,"ruleFires":[0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,4,0,2],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"}\\n0x10🚀 :=\"","keys":["text","nope"]},"output":{"pattern":"}\n<HEX>🚀 :=","maskedLength":12,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"\"12.5.ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1\\\"deadbeef12-🚀9007199254740992 /\"","keys":["__proto__"]},"output":{"pattern":"<N>.<N>.<ID>\"<HEX>-🚀<N> /","maskedLength":26,"ruleFires":[0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,3,1,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"\"[email protected]🚀,user [email protected] logged in/deadbeef12:]\\n15/Jan/2025:10:00:00 +0000,\"","keys":["__proto__"]},"output":{"pattern":"[email protected]🚀,user <EMAIL> logged in/<HEX>:]\n<TIMESTAMP>,","maskedLength":51,"ruleFires":[0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"\"123:\\u000b :event\\napi.example.com@-Infinity\\n15/Jan/2025:10:00:00 +0000_eyJabcdefghijk.abcd.@Bearer\\tabc:\"","keys":["message","msg","event"]},"output":{"pattern":"123:\u000b :event\n<HOST>@-Infinity\n<TIMESTAMP>_eyJabcdefghijk.abcd.@Bearer\tabc:","maskedLength":74,"ruleFires":[0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"1_000éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\nJan 5 10:00:00Dž:é@example.com\nx_1234_deadbeef12AKIAA1B2C3D4E5F6G7H8=E1231 23:59:59-E1231 23:59:59_","keys":["message","msg","event"]},"output":{"pattern":"<N>_000éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\n<TIMESTAMP>Dž:é@<HOST>\nx_1234_deadbeef12AKIAA1B2C3D4E5F6G7H8=E<KLOGTIME>-E<KLOGTIME>_","maskedLength":292,"ruleFires":[0,0,0,2,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"job_12345,","keys":[]},"output":{"pattern":"job_<N>,","maskedLength":8,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"Bearer\\u000bab@/api/users/12345/orders/987-\\\",éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"","keys":["__proto__"]},"output":{"pattern":"Bearer\u000bab@/api/users/<N>/orders/<N>-\",éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé","maskedLength":238,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"abc3fa85f64-5717-4562-b3fc-2c963f66afa6\"","keys":["message","msg","event"]},"output":{"pattern":"<UUID>\"","maskedLength":7,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"[]","keys":["message","msg","event"]},"output":{"pattern":"<JSON_ARRAY>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":12,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"1_000payload.","keys":["text","nope"]},"output":{"pattern":"<N>_000payload.","maskedLength":15,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"msg\":\"2025-01-15 10:00:00,123+0100 Jan 5 10:00:00\\\" _00\\\"5. -\"}","keys":["__proto__"]},"output":{"pattern":"<JSON:msg>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":10,"jsonKeyCount":1,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"-1e400 0.1 ","keys":["constructor","msg"]},"output":{"pattern":"-<N>e400 <N>.<N> ","maskedLength":17,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"Wed Jan 15 10:00:00 \":7,\"valueOf\":5,\" \":\"ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1.token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig_ASIA0000000000000000X,\"\\u0000,\"text\":null}","keys":["text","nope"]},"output":{"pattern":"{\"<TIMESTAMP> \":<N>,\"valueOf\":<N>,\" \":\"<ID>.token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.<ID>,\"\\u0000,\"text\":null}","maskedLength":113,"ruleFires":[0,0,0,0,0,0,0,0,1,0,2,0,0,0,0,0,0,0,0,2,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"Է","keys":["message","msg","event"]},"output":{"pattern":"Է","maskedLength":1,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":" {} ","keys":["text","nope"]},"output":{"pattern":"<JSON:>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":7,"jsonKeyCount":0,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"[email protected]@valueOf /api/v1/users/123/١٢٣:_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6_2025-01-15T10:00:00.123Z._12345_3fa85f64-5717-4562-b3fc-2c963f66afa6=::1@12345678/gho_short@\r\n ","keys":["text","nope"]},"output":{"pattern":"<EMAIL>@valueOf /api/v1/users/<N>/١٢٣:_<N>_<UUID>_<N>-<N>-<N>T10:<N>:<N>.<N>Z._<N>_<UUID>=::<N>@<N>/gho_short@\r\n ","maskedLength":113,"ruleFires":[0,0,0,0,0,0,0,0,0,1,0,0,2,0,0,1,0,0,0,6,0,2],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"http.method sk_live_0123456789abcdefghijkl-0 ","keys":["text","nope"]},"output":{"pattern":"\"http.method sk_live_0123456789abcdefghijkl-<N> ","maskedLength":50,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"api.example.com\"","keys":[]},"output":{"pattern":"<HOST>\"","maskedLength":7,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"ΣΑΣ.\"_","keys":[]},"output":{"pattern":"ΣΑΣ.\"_","maskedLength":6,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"full\":\"0.300000000000000049007199254740992/}\\[email protected]:deploy.sh\\nconstructordebug .\",\"0xDEADbeef.alice@exa\":8,\"job_12345-BEARER Kab\":9,\"msg\":\"日本host-1.internal\\ndebug-䩄0=sub_Abcdefghijklmnopqrstuvwx,deadbeef12,\"}","keys":["message","msg","event"]},"output":{"pattern":"日本<HOST>\ndebug-䩄<N>=<ID>,<HEX>,","maskedLength":31,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,1,0],"bodyKind":"json_object_or_array","inputCapped":false}},{"input":{"body":"sk_test_ZZZZZZZZZZZZZZZZZZZ=x_1234 00日本語 //api/users/12345/orders/987:sk_live_aaaaaaaaaaaaaaaaaaaaaaaa\"192.168.001.001\"-Infinityevent = _","keys":["message","msg","event"]},"output":{"pattern":"sk_test_ZZZZZZZZZZZZZZZZZZZ=x_<N> <N>日本語 //api/users/<N>/orders/<N>:sk_live_aaaaaaaaaaaaaaaaaaaaaaaa\"<IP>\"-Infinityevent = _","maskedLength":124,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,3,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\r\nİstanbul=\r\n/ႇ null.1_000 \"","keys":["message","msg","event"]},"output":{"pattern":"\r\nİstanbul=\r\n/ႇ null.<N>_000 \"","maskedLength":30,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"[email protected]@[email protected]:ΣΑΣ,","keys":[]},"output":{"pattern":"<EMAIL>@<EMAIL>:ΣΑΣ,","maskedLength":20,"ruleFires":[0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"true 4294967294","keys":["message","msg","event"]},"output":{"pattern":"true <N>","maskedLength":8,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"fi=12.5/aes_128,12345678:::1_.5-0 _a.\n\"\"","keys":["constructor","msg"]},"output":{"pattern":"fi=<N>.<N>/aes_128,<N>:::<N>_.<N>-<N> _a.\n\"\"","maskedLength":43,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"10.0.0.256\\nxoxb-1234\":7,\"\\n\":6,\"1_000:deploy.sh � =4\":\"Dž={/\",\"0 \":\"15/Jan/2025:10:00:00 +0000,],{.\\\"-Bearer\\u000bab,user [email protected] logged in=Bearer abc.def-ghi١٢٣=Mon Jan 5 10:00:00 2025.\",\"xxxxxxxxxxxxxxxxxxxx\":\"0x10 -Bearer abc.def-ghiuser.email \\nghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1 x4294967294 -\",\"Wed Jan 15 10:00:00 \":\"0x10true\\\"4294967294 @\\\\ .12.5abc 1=Mon Jan 5 10:00:00 2025_W1301 10:00:00\\n\",\"payload\":6,\"message\":\"Jan 5 10:00:00:xoxp-1234567890/\",\"ghp_A1A1A1A1A1A1A1A1\":3,\"deadbeef\":8,\"192.168.0.1\":3,\"\\\"quoted\\\"\":\"eyJabcdefghijk.abcd.@ms=12\\\"bearer x.y-z~+/[email protected]/fi_0=W1301 10:00:00.deploy.sh \",\"�\":3,\"3fa85f64-5717-4562-b\":\"deadbeef12@fi=Jan 5 10:00:00-日本:a1e3 :}message .,_\",\" 12 -fighp_A1A1A1A1A1\":1,\"}-xxxxxxxxxxxxxxxxxx\":3,\"4111 1111 1111 1111é\":\"ΣΑΣ-{\\\"a\\\":1} @straße:\",\"-1\":\"KMon Jan 5 10:00:00 2025:,ésk_live_0123456789abcdefghijkl,W1301 10:00:00_bearer x.y-z~+/==\\\"/api/users/12345/orders/987-0xDEADbeef=libssl.so@AKIAA1B2C3D4E5F6G7H8\\\"\",\"a.b\":3,\"host-1.internal.\":9,\"token=eyJhbGciOiJIUz\":\"eyJabcdefghijk.abcd.:true\\\"quoted\\\" /xoxp-1234567890.ΣΑΣ@Wed Jan 15 10:00:00 UTC 2025 [\",\"Jan 5 10:00:00\\\"E123\":8,\"toString\":\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6/12345678/ASIA0000000000000000X=Wed Jan 15 10:00:00 UTC 2025:\",\"Wed, 15 Jan 2025 12:\":8,\"𐀀-cus_ABCDEFGHIJKLM\":9,\"..\":6,\"\\\\\":\"/api/users/12345/orders/987/W1301 10:00:00-15/Jan/2025:10:00:00 +0000=NaN payload \",\"msg\":\"nulltrue =warn -9007199254740992_BEARER Kabc/ms=12=\\\":AKIAA1B2C3D4E5F6G7H8,level _msg@\"}","keys":["message","msg","event"]},"output":{"pattern":"<TIMESTAMP>:xoxp-<N>/","maskedLength":21,"ruleFires":[0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"json_object_or_array","inputCapped":false}},{"input":{"body":"[]","keys":["message","msg","event"]},"output":{"pattern":"<JSON_ARRAY>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":12,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":null,"keys":["__proto__"]},"output":{"pattern":"","bodyKind":"empty","inputCapped":false,"maskedLength":0,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"-1e400 1_000={\n🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀INFO-","keys":[]},"output":{"pattern":"-<N>e400 <N>_000={\n🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀INFO-","maskedLength":284,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"","keys":["message","msg","event"]},"output":{"pattern":"","bodyKind":"empty","inputCapped":false,"maskedLength":0,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"xoxb-12345-_","keys":["message","msg","event"]},"output":{"pattern":"xoxb-<N>-_","maskedLength":10,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"192.168.001.001:\"","keys":["__proto__"]},"output":{"pattern":"<IP>:","maskedLength":5,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"{\"message\":\"ééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"}","keys":["message","msg","event"]},"output":{"pattern":"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé","maskedLength":1025,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"json_object_or_array","inputCapped":false}},{"input":{"body":"deploy.sh_deploy.sh.]\n","keys":["message","msg","event"]},"output":{"pattern":"deploy.sh_deploy.sh.]\n","maskedLength":22,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"3fa85f64-5717-4562-b3fc-2c963f66afa6,Jan 5 10:00:00@\"","keys":["__proto__"]},"output":{"pattern":"<UUID>,<TIMESTAMP>@","maskedLength":19,"ruleFires":[0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"/api/v1/users/123 🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"POST[1,2] \n","keys":["__proto__"]},"output":{"pattern":"/api/v1/users/<N> 🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"POST[<N>,<N>] \n","maskedLength":294,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"0\":\",@xoxb-12345-\\\"[email protected]=sub_Abcdefghijklmnopqrstuvwxmsg12-\",\"1\":\" {\\\"a\\\":1}=12345678=1,5_0o70b11 deploy.sh/fatalé@example.com 12ݿ\\\"\",\"[email protected]🚀- 🚀\":\"10.0.0.256\\\"١٢٣_AKIAIOSFODNN7EXAMPLEwarn .token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig=2025-01-15T10:00:00.123Z {@0o7 /[email protected]/ :\",\"9007199254740993\":3,\": 4111 1111 1111 111\":0,\"Bearer\\u000bab-\":7,\"é12,\":\"ghp_0123456789abcdefghij0123456789abcdef 12 =0xDEADbeef\\\"+5 _abc3fa85f64-5717-4562-b3fc-2c963f66afa6-1e-7xoxb-1234567890-abc.3fa85f64-5717-4562-b3fc-2c963f66afa6user [email protected] logged in\\nx/\",\"..\":0,\"}:aes_128-::1-Wed, 1\":1,\"http.method\":3,\"192.168.1.1✈ -4111 1\":9,\"}=W1301 10:00:00@sk_\":\"[_١٢٣\\\"121_000\\\"Bearer\\u000bab,\",\"job_12345.0{\\\"a\\\":1}sk\":8,\"event\":4,\"::1/.5sk_live_012345\":\"s[email protected]@é@example.com\\nxoxp-1234567890.libssl.so=x_1234.\",\"a.b\":8,\"1e3=Dž\\\"\":6,\"ϭߧ/Dž \":9,\"192.168.1.1 \\nINFO_\":\"+5\\\"123/é@example.comWed, 15 Jan 2025 10:00:00 GMT.BEARER Kabc_\",\"token=eyJhbGciOiJIUz\":8,\"__defineGetter__\":9,\"xoxb-12345- ghp_0123\":9,\"constructor\":1,\"sub_Abcdefghijklmnop\":\"I0827 11:39:40.307946_ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1@\\n{:sk_live_aaaaaaaaaaaaaaaaaaaaaaaa-straße\\n4111 1111 1111 1111\\nASIA0000000000000000X.\",\"\\n\":\"I0827 11:39:40.307946=Wed, 15 Jan 2025 10:00:00 GMT\\n误 @0xDEADbeef.sk_test_ZZZZZZZZZZZZZZZZZZZ:日本=15/Jan/2025:10:00:00 +0000/0b11 [email protected]\\\\\",\"192.168.0.1\":5,\"aes_128\\\"\":\"192.168.001.001:7 ,Dž\\\"BEARER Kabc-\\t.ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1-xoxb-1234567890-abc 0.30000000000000004 İstanbul\",\"4111 1111 1111 1111:\":2,\"Mon Jan 5 10:00:00 2\":\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123a:\\r\\n\"}","keys":["constructor","msg"]},"output":{"pattern":"<JSON:\n,..,: <N> <N> <N> <N>,::<N>/.<N>sk_live_<N>,<IP>,<IP>✈ -<N> <N>,<IP> \nINFO_,<N>,<N> <N> <N> <N>:,<N>[email protected]🚀- 🚀,<N>e3=Dž\",<TIMESTAMP> <N>,Bearer\u000bab-,__defineGetter__,a.b,aes_128\",constructor,event,http.method,job_<N>.<N>{\"a\":<N>}sk,sub_Abcdefghijklmnop,token=eyJhbGciOiJIUz,xoxb-<N>- ghp_<N>,}:aes_128-::<N>-Wed, <N>,}=W1301 <N>:<N>:<N>@sk_,é<N>,,ϭߧ/Dž >","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":362,"jsonKeyCount":29,"ruleFires":[0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,3,0,0,3,25,0,2]}},{"input":{"body":"[email protected] /é@example.com\"ms=12 host-1.internalabc3fa85f64-5717-4562-b3fc-2c963f66afa6\"Jan 5 10:00:00\"","keys":["text","nope"]},"output":{"pattern":"<EMAIL>-<N> /é@<HOST>\"ms=<N> host-<N>.internal<UUID>\"<TIMESTAMP>\"","maskedLength":65,"ruleFires":[0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,0,1,0,0,3,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"[1,2] 12ޚ","keys":["constructor","msg"]},"output":{"pattern":"[<N>,<N>] <N>ޚ","maskedLength":15,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"1e400","keys":["text","nope"]},"output":{"pattern":"<N>e400","maskedLength":7,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],"bodyKind":"primitive","inputCapped":false}},{"input":{"body":":\n띉 INFO :.].","keys":["text","nope"]},"output":{"pattern":":\n띉 INFO :.].","maskedLength":13,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{_ 12@日本_\"\"é12 _12345_3fa85f64-5717-4562-b3fc-2c963f66afa6,","keys":["constructor","msg"]},"output":{"pattern":"{_ <N>@日本_\"\"é<N> _<N>_<UUID>,","maskedLength":31,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,2,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"ghp_0123456789abcdefghij0123456789abcdefé\\\"[email protected] ]-deadbeef12ւ,\"","keys":["constructor","msg"]},"output":{"pattern":"ghp_0123456789abcdefghij0123456789abcdefé\"<EMAIL> ]-<HEX>ւ,","maskedLength":59,"ruleFires":[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"\"INFOAKIAIOSFODNN7EXAMPLE=_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6\\\"2025-01-15T10:00:00.123Z.,\\n/api/users/12345/orders/987\\\"\"","keys":[]},"output":{"pattern":"INFOAKIAIOSFODNN7EXAMPLE=_<N>_<UUID>\"<TIMESTAMP>.,\n/api/users/<N>/orders/<N>\"","maskedLength":77,"ruleFires":[1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,2,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":":.sk_test_ZZZZZZZZZZZZZZZZZZZ.sub_Abcdefghijklmnopqrstuvwx.+5 .123\nabc3fa85f64-5717-4562-b3fc-2c963f66afa6=1_000<","keys":["__proto__"]},"output":{"pattern":":.sk_test_ZZZZZZZZZZZZZZZZZZZ.<ID>.+<N> .123\n<UUID>=<N>_000<","maskedLength":60,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"event\":\"é@example.com@日本語=::1,fatal GET-Bearer\\tabc_toString日本語-10.0.0.256NaN\\\"İstanbul\"}","keys":["message","msg","event"]},"output":{"pattern":"é@<HOST>@日本語=::<N>,fatal GET-Bearer\tabc_toString日本語-<N>.<N>.<N>.<N>NaN\"İstanbul","maskedLength":79,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,4,0,1],"bodyKind":"json_object_or_array","inputCapped":false}},{"input":{"body":"12 -ERROR\n[:","keys":["message","msg","event"]},"output":{"pattern":"<N> -ERROR\n[:","maskedLength":13,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"-90071992547409925.,","keys":["__proto__"]},"output":{"pattern":"-<N>.,","maskedLength":6,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"١٢٣-{=user [email protected] logged in=","keys":["message","msg","event"]},"output":{"pattern":"١٢٣-{=user <EMAIL> logged in=","maskedLength":29,"ruleFires":[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1 ,_user [email protected] logged in\r\n 10 015/Jan/2025:10:00:00 +0000=","keys":["__proto__"]},"output":{"pattern":"<ID> ,_user <EMAIL> logged in\r\n <N> <N>/Jan/<N>:<N>:<N>:<N> +<N>=","maskedLength":65,"ruleFires":[0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,7,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\\-n AKIAIOSFODNN7EXAMPLE ]=ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1=","keys":["__proto__"]},"output":{"pattern":"\\-n AKIAIOSFODNN7EXAMPLE ]=<ID>=","maskedLength":32,"ruleFires":[0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":" warn 01 0x10POST","keys":["__proto__"]},"output":{"pattern":" warn <N> <N>x10POST","maskedLength":20,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"toString@é@example.com_\teyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc1231,5\nbearer x.y-z~+/===èmsg =Wed, 15 Jan 2025 10:00:00 GMT","keys":["constructor","msg"]},"output":{"pattern":"toString@é@example.com_\teyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc1231,<N>\nbearer x.y-z~+/===èmsg =<TIMESTAMP>","maskedLength":109,"ruleFires":[0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"null","keys":["__proto__"]},"output":{"pattern":"null","maskedLength":4,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"primitive","inputCapped":false}},{"input":{"body":"0b1112u ","keys":["text","nope"]},"output":{"pattern":"<N>b11<N>u ","maskedLength":12,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"fi:user_A1b2-","keys":["message","msg","event"]},"output":{"pattern":"fi:<ID>-","maskedLength":7,"ruleFires":[0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"message\":\"xéééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"}","keys":["constructor","msg"]},"output":{"pattern":"<JSON:message>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":14,"jsonKeyCount":1,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"{\"0\":\"[email protected].{/abc3fa85f64-5717-4562-b3fc-2c963f66afa6\\\"\\\"\\n[1,2]-1e400 \",\"10\":0,\"a\":7,\"Bearer\\u000bab/ݹa_GET Wed\":7,\"[email protected] ev\":8,\"\\t\":\"123.192.168.001.001\\n12345678,é12_12\\naes_128.\",\"192.168.0.1\":\"E1231 23:59:59.Bearer\\u000bab\\\"::1,2025-01-15T10:00:00Z 192.168.0.1.{\\\"a\\\":1}/api/v1/users/123-\\tghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1}.fi/\",\"\\\"192.168.1.1.constru\":6,\",/x_1234.BEARER Kabc\":0,\"ǝ \":1,\"�\":\"\\r\\n-Dž_\",\"E1231 23:59:59\":1,\"k\":\"0o7=10.0.0.256.90071992547409930.30000000000000004\\\"gho_short\\\"3fa85f64-5717-4562-b3fc-2c963f66afa6_api.example.com-\",\"user alice.smith+tag\":\"E1231 23:59:59:123,xoxb-12345-\\n12345678/ 12 1e3\",\"valueOf\":\"42949672941e400.\\r\\n\\\"-Infinity123456789012345680000 //api/users/12345/orders/987_\",\".a\":7,\"9007199254740993\":4,\"ghp_0123456789abcdefghij0123456789abcdef12 \":6,\"BEARER Kabc,Wed, 15 \":\"2025-01-15T10:00:00.123Z Dž\\\"\",\"\\\", \\\"\":\"0x10..:4294967296@sk_live_aaaaaaaaaaaaaaaaaaaaaaaa\\\",/\",\"🚀\":9,\"00,NaNhost.example.c\":9,\"Bearer abc.def-ghi 0.000001\":\"10.0.0.256\",\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\":3,\"[/\":\"sub_Abcdefghijklmnopqrstuvwx/k.E1231 23:59:59@0GET /é@example.com_xoxp-1234567890\",\"POST4294967294:W1301\":\"]\\nlibssl.so\\n{,job_12345-user [email protected] logged in 192.168.001.001\\nWed, 15 Jan 2025 12:00:00 GMT\\\\\\ngho_short\"}","keys":["message","msg","event"]},"output":{"pattern":"<JSON:\t,\"<IP>.constru,,/x_<N>.BEARER Kabc,.a,<EMAIL> ev,<IP>,<N>,<N>,NaNhost.example.c,BEARER Kabc,Wed, <N> ,Bearer\u000bab/ݹa_GET Wed,Bearer abc.def-ghi <N>.<N>,E<KLOGTIME>,POST4294967294:W1301,[/,a,ghp_0123456789abcdefghij0123456789abcdef12 ,k,user alice.smith+tag,valueOf,ǝ ,🚀,🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀,\", \",�>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":306,"jsonKeyCount":26,"ruleFires":[0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,2,7,0,0]}},{"input":{"body":",@debug,[email protected],deadbeef12\"eyJabcdefghijk.abcd.\"host-1.internal12 .","keys":["message","msg","event"]},"output":{"pattern":",@debug,<EMAIL>,<HEX>\"eyJabcdefghijk.abcd.\"<HOST><N> .","maskedLength":55,"ruleFires":[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,1,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":" \"quoted\"=\"./api/users/12345/orders/987\n2025-01-15 10:00:00,123+0100 api.example.com:token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig_","keys":["message","msg","event"]},"output":{"pattern":" \"quoted\"=\"./api/users/<N>/orders/<N>\n<TIMESTAMP> <HOST>:token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig_","maskedLength":104,"ruleFires":[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,2,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"::1_","keys":["message","msg","event"]},"output":{"pattern":"::<N>_","maskedLength":6,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"𑆮01 🚀0o7","keys":["message","msg","event"]},"output":{"pattern":"𑆮<N> 🚀<N>o7","maskedLength":13,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{}","keys":[]},"output":{"pattern":"<JSON:>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":7,"jsonKeyCount":0,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"\"x\"","keys":["message","msg","event"]},"output":{"pattern":"x","maskedLength":1,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"\r\n/job_12345\"deadbeef12:3fa85f64-5717-4562-b3fc-2c963f66afa6- :그 \n","keys":["text","nope"]},"output":{"pattern":"\r\n/job_<N>\"<HEX>:<UUID>- :그 \n","maskedLength":29,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":" {} ","keys":[]},"output":{"pattern":"<JSON:>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":7,"jsonKeyCount":0,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":",:\"sk_live_aaaaaaaaaaaaaaaaaaaaaaaa\"5e-3240-","keys":["message","msg","event"]},"output":{"pattern":",:\"sk_live_aaaaaaaaaaaaaaaaaaaaaaaa\"<N>e-<N>-","maskedLength":45,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"5e-324","keys":["message","msg","event"]},"output":{"pattern":"<N>e-<N>","maskedLength":8,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1],"bodyKind":"primitive","inputCapped":false}},{"input":{"body":" {} ","keys":["constructor","msg"]},"output":{"pattern":"<JSON:>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":7,"jsonKeyCount":0,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"true","keys":["text","nope"]},"output":{"pattern":"true","maskedLength":4,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"primitive","inputCapped":false}},{"input":{"body":"0o7","keys":["message","msg","event"]},"output":{"pattern":"<N>o7","maskedLength":5,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{}","keys":["constructor","msg"]},"output":{"pattern":"<JSON:>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":7,"jsonKeyCount":0,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"123/🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀1e+21=BEARER Kabc_","keys":[]},"output":{"pattern":"123/🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀<N>e+<N>=BEARER Kabc_","maskedLength":285,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"2025-01-15T10:00:00.123Z@ ߞ Bearer\tabc,sub_Abcdefghijklmnopqrstuvwx,W1301 10:00:00\n12345678.Ͱ /deadbeef12@","keys":[]},"output":{"pattern":"<TIMESTAMP>@ ߞ Bearer\tabc,<ID>,W1301 <N>:<N>:<N>\n<N>.Ͱ /<HEX>@","maskedLength":64,"ruleFires":[1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,4,1,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"192.168.0.1\":\"ASIA0000000000000000X,eyJabcdefghijk.abcd.\\\"a\\\\nb/api/v1/users/123 /\",\"_12345_3fa85f64-5717\":2,\"user_123\":4,\"ɰ 0.000001 : = \\\"E\":8,\"a.b 0.30000000000000004\":5,\"[@ghp_A1A1A1A1A1A1A1\":\"gho_short:0\\ndeadbeef12\\n1_000 12 -İstanbul/[email protected]_user_A1b2\\\"user [email protected] logged in:[email protected] \",\"4294967295\":4,\"a.\":\"2025-01-15T10:00:00.123Z W1301 10:00:00\\n\\r\\n@aes_128\\n\",\"gho_short-\\\"_host-1.i\":8,\"Bearer\\u000bab\\nInfinity@\":0,\"ǵ=\":7,\"x_1234.\\\\=\\r\\n/deploy.s\":\"İstanbul,\",\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":\",\\\"\",\"日本\":1,\"éééééééééééééééééééé\":\"gho_short=192.168.001.001 \\\\@x_1234-\\[email protected]_10b11 \\\"[email protected]\\\"\",\"xoxp-1234567890 \":2,\"12\\\"quoted\\\"\":3,\"deploy.sh@🚀0.300000\":1,\"-1true.user alice.sm\":4,\".a\":\"x .eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123-xoxp-1234567890=straße\\\"xoxb-12345-/🚀 \",\"user alice.smith+tag\":0,\"[email protected]🚀/\":\" 0b11 ,\\\\\\\"\\\":[email protected]\\nE1231 23:59:59_\\\\,🚀 \",\"a\":6,\"\":3,\"3fa85f64-5717-4562-b\":\"123\\nE1231 23:59:59-W1301 10:00:00.true_sub_Abcdefghijklmnopqrstuvwx=ASIA0000000000000000X.\",\"12345678901234568000\":\"aes_128,xoxb-12345- /api/users/12345/orders/987..a0.000001=é12-4111 1111 1111 1111\",\"0 \":7,\":.15/Jan/2025:10:00:\":2,\"0 2025-01-15 10:00:0\":6,\"text\":\"12345678xoxb-12345--abc3fa85f64-5717-4562-b3fc-2c963f66afa6\\\"libssl.so.AKIAA1B2C3D4E5F6G7H8.eyJabcdefghijk.abcd.\\\"AKIAIOSFODNN7EXAMPLE@\"}","keys":[]},"output":{"pattern":"<JSON:-<N>true.user alice.sm,.a,:.<N>/Jan/<N>:<N>:<N>:,<HEX>-<N>-<N>-b,<IP>,<N>,<N> ,<N> <N>-<N>-<N> <N>:<N>:<N>,[@<ID>,_12345_3fa85f64-<N>,a,a.,a.b <N>.<N>,deploy.sh@🚀<N>.<N>,gho_short-\"_host-<N>.i,text,user alice.smith+tag,user_123,uuid_<UUID>,[email protected]🚀/,x_<N>.\\=\r\n/deploy.s,xoxp-<N> ,éééééééééééééééééééé,ǵ=,ɰ <N>.<N> : = \"E,日本,<N>\"quoted\",,Bearer\u000bab\nInfinity@>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":369,"jsonKeyCount":30,"ruleFires":[0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,1,26,1,1]}},{"input":{"body":"{}","keys":["message","msg","event"]},"output":{"pattern":"<JSON:>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":7,"jsonKeyCount":0,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"sk_live_0123456789abcdefghijkl2001:db8::1@ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1-Jan 5 10:00:[email protected]","keys":[]},"output":{"pattern":"sk_live_0123456789abcdefghijkl2001:db8::<N>@<ID> <N> <N>:<N>:<N>[email protected]","maskedLength":71,"ruleFires":[0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,4,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"x//api/users/12345/orders/987,12.5 @ \n\t\".a,GET/","keys":[]},"output":{"pattern":"x//api/users/<N>/orders/<N>,<N>.<N> @ \n\t\".a,GET/","maskedLength":50,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"+5-straße\"-Infinity,xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 9007199254740993ﺦ\"Wed Jan 15 10:00:00 UTC 2025\"0xDEADbeef-sk_live_0123456789abcdefghijkl.5,ghp_0123456789abcdefghij0123456789abcdef12,","keys":["__proto__"]},"output":{"pattern":"+<N>-straße\"-Infinity,xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx <N>ﺦ\"<TIMESTAMP>\"<HEX>-sk_live_0123456789abcdefghijkl.<N>,ghp_0123456789abcdefghij0123456789abcdef<N>,","maskedLength":426,"ruleFires":[0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,4,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"user [email protected] logged in/1,5͂,0xDEADbeef/libssl.so@debugsk_live_0123456789abcdefghijkl :W1301 10:00:00-aes_128\nASIA0000000000000000X: 2025-01-15T10:00:00Z@","keys":["__proto__"]},"output":{"pattern":"user <EMAIL> logged in/<N>,<N>͂,<HEX>/libssl.so@debugsk_live_0123456789abcdefghijkl :W1301 <N>:<N>:<N>-aes_128\nASIA0000000000000000X: <TIMESTAMP>@","maskedLength":148,"ruleFires":[1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,5,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"true","keys":[]},"output":{"pattern":"true","maskedLength":4,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"primitive","inputCapped":false}},{"input":{"body":"a\\[email protected] ","keys":["message","msg","event"]},"output":{"pattern":"a\\<EMAIL> ","maskedLength":10,"ruleFires":[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"fi 123[email protected].","keys":["text","nope"]},"output":{"pattern":"fi 123<EMAIL>.","maskedLength":13,"ruleFires":[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"k \"quoted\"@日本@[email protected]\"12345678@4111 1111 1111 1111=sk_test_ZZZZZZZZZZZZZZZZZZZ.Dž \"quoted\"4294967294\u000b1e+100\n","keys":["text","nope"]},"output":{"pattern":"k \"quoted\"@日本@[email protected]\"<N>@<N> <N> <N> <N>=sk_test_ZZZZZZZZZZZZZZZZZZZ.Dž \"quoted\"<N>\u000b<N>e+<N>\n","maskedLength":91,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"xoxp-1234567890BEARER Kabc@-Infinity :deploy.sh,\\twarn.xoxb-12345-\\n\"","keys":[]},"output":{"pattern":"xoxp-<N>BEARER Kabc@-Infinity :deploy.sh,\twarn.xoxb-<N>-\n","maskedLength":57,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 Bearer\u000bab [email protected]KIAA1B2C3D4E5F6G7H8_bearer x.y-z~+/===日本語:aes_128\nAKIAA1B2C3D4E5F6G7H8=gho_short=","keys":["message","msg","event"]},"output":{"pattern":"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 Bearer\u000bab ms=<EMAIL>-AKIAA1B2C3D4E5F6G7H8_bearer x.y-z~+/===日本語:aes_128\nAKIAA1B2C3D4E5F6G7H8=gho_short=","maskedLength":365,"ruleFires":[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\\2025-01-15T10:00:00Z 1_000INFO 日本12.Jan 5 10:00:00_","keys":["constructor","msg"]},"output":{"pattern":"\\<TIMESTAMP> <N>_000INFO 日本<N>.<TIMESTAMP>_","maskedLength":44,"ruleFires":[1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"job_12345=鸥🚀,user_A1b2 _12345_3fa85f64-5717-4562-b3fc-2c963f66afa6 123/Mon Jan 5 10:00:00 2025@2025-01-15 10:00:00,123+0100:user_A1b2,\"","keys":["message","msg","event"]},"output":{"pattern":"job_<N>=鸥🚀,<ID> _<N>_<UUID> 123/<TIMESTAMP>@<TIMESTAMP>:<ID>,","maskedLength":62,"ruleFires":[1,0,0,0,0,0,1,0,0,0,2,0,1,0,0,1,0,0,0,0,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé","keys":["constructor","msg"]},"output":{"pattern":"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé","maskedLength":1024,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"-1\":4}","keys":["text","nope"]},"output":{"pattern":"<JSON:-<N>>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":11,"jsonKeyCount":1,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0]}},{"input":{"body":"{\"length\":\"s.\",\"constructor\":8,\"sk_test_ZZZZZZZZZZZZ\":\"\\\", 4294967295 -1 \\\"NaN.\"}","keys":[]},"output":{"pattern":"<JSON:constructor,length,sk_test_ZZZZZZZZZZZZ>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":46,"jsonKeyCount":3,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"{\"a\":1}-1e400 null","keys":["message","msg","event"]},"output":{"pattern":"{\"a\":<N>}-<N>e400 null","maskedLength":22,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"true","keys":["message","msg","event"]},"output":{"pattern":"true","maskedLength":4,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"primitive","inputCapped":false}},{"input":{"body":"\",@é@example.com.2025-01-15T10:00:00.123Z:1e3 192.168.1.1 \"","keys":[]},"output":{"pattern":",@é@<HOST>.<TIMESTAMP>:<N>e3 <IP> ","maskedLength":35,"ruleFires":[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"{\"sk_live_aaaaaaaaaaaa\":\"host-1.internal.é\",\"3fa85f64-5717-4562-b\":1,\" libssl.so:Dž\\\"[email protected]\":\"12345678 deadbeef12@abc3fa85f64-5717-4562-b3fc-2c963f66afa6:Wed, 15 Jan 2025 10:00:00 GMT,é@example.com\\\"Bearer abc.def-ghi \\t/\\\":\"}","keys":["constructor","msg"]},"output":{"pattern":"<JSON:<HEX>-<N>-<N>-b,sk_live_aaaaaaaaaaaa, libssl.so:Dž\"[email protected]>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":64,"jsonKeyCount":3,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,0]}},{"input":{"body":"a./.a a.b:sub_Abcdefghijklmnopqrstuvwx\"fatal -Wed, 15 Jan 2025 12:00:00 GMT-1\":},","keys":["message","msg","event"]},"output":{"pattern":"a./.a a.b:<ID>\"fatal -<TIMESTAMP>-<N>\":},","maskedLength":41,"ruleFires":[0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"0o7\"xoxb-12345- Wed Jan 15 10:00:00 UTC 2025:1e400\"3fa85f64-5717-4562-b3fc-2c963f66afa6 192.168.001.001\"","keys":["constructor","msg"]},"output":{"pattern":"<N>o7\"xoxb-<N>- <TIMESTAMP>:<N>e400\"<UUID> <IP>\"","maskedLength":49,"ruleFires":[0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,1,0,2],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"abc3fa85f64-5717-4562-b3fc-2c963f66afa6[\\\"Wed, 15 Jan 2025 10:00:00 GMT-2025-01-15T10:00:00.123Z\\\"123/host-1.internal@-0debug -\"","keys":["text","nope"]},"output":{"pattern":"<UUID>[\"<TIMESTAMP>-<TIMESTAMP>\"123/<HOST>@-<N>debug -","maskedLength":54,"ruleFires":[1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,1],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"user [email protected] logged in@aes_128\"","keys":["constructor","msg"]},"output":{"pattern":"user <EMAIL> logged in@aes_128\"","maskedLength":31,"ruleFires":[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"192.168.0.1:","keys":[]},"output":{"pattern":"<IP>:","maskedLength":5,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"fi:-2025-01-15 10:00:00,123+0100@3fa85f64-5717-4562-b3fc-2c963f66afa6:,=sk_test_ZZZZZZZZZZZZZZZZZZZ,sk_live_aaaaaaaaaaaaaaaaaaaaaaaa\\n-Infinity.é@example.com x_1234-\"","keys":[]},"output":{"pattern":"fi:-<TIMESTAMP>@<UUID>:,=sk_test_ZZZZZZZZZZZZZZZZZZZ,sk_live_aaaaaaaaaaaaaaaaaaaaaaaa\n-Infinity.é@<HOST> x_<N>-","maskedLength":113,"ruleFires":[1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":null,"keys":["message","msg","event"]},"output":{"pattern":"","bodyKind":"empty","inputCapped":false,"maskedLength":0,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":": http.method{\"a\":1} token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig@İstanbul@,\"K /","keys":["message","msg","event"]},"output":{"pattern":": http.method{\"a\":<N>} token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig@İstanbul@,\"K /","maskedLength":86,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"toString ","keys":[]},"output":{"pattern":"toString ","maskedLength":11,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"[1,2]INFO:eyJabcdefghijk.abcd.\" ","keys":["message","msg","event"]},"output":{"pattern":"[<N>,<N>]INFO:eyJabcdefghijk.abcd.\" ","maskedLength":39,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"constructor2001:db8::1 deploy.sh xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx , 1_000\"","keys":[]},"output":{"pattern":"constructor2001:db8::<N> deploy.sh xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx , <N>_000","maskedLength":347,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"{\"message\":\"x12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 \"}","keys":[]},"output":{"pattern":"<JSON:message>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":14,"jsonKeyCount":1,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"ERRORa_fatal .straße=١٢٣,E1231 23:59:59\"5.:","keys":["constructor","msg"]},"output":{"pattern":"ERRORa_fatal .straße=١٢٣,E<KLOGTIME>\"<N>.:","maskedLength":44,"ruleFires":[0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"bearer x.y-z~+/==_ASIA0000000000000000X_2025-01-15T10:00:00Z❀ /AKIAA1B2C3D4E5F6G7H8/INFO:0x10 \u000b -host.example.com -::1.x_1234=","keys":["constructor","msg"]},"output":{"pattern":"bearer x.y-z~+/==_ASIA0000000000000000X_<N>-<N>-<N>T10:<N>:<N>Z❀ /AKIAA1B2C3D4E5F6G7H8/INFO:<HEX> \u000b -<HOST> -::<N>.x_<N>=","maskedLength":122,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,1,0,3,0,2],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"msg\":1,\"event\":5}","keys":["message","msg","event"]},"output":{"pattern":"<JSON:event,msg>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":16,"jsonKeyCount":2,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"INFO-msg _10.0.0.256/4111 1111 1111 1111=Wed, 15 Jan 2025 10:00:00 GMT_192.168.001.001/Bearer\tabc ","keys":["constructor","msg"]},"output":{"pattern":"INFO-msg _10.<N>.<N>.<N>/<N> <N> <N> <N>=<TIMESTAMP>_192.<N>.<N>.<N>/Bearer\tabc ","maskedLength":80,"ruleFires":[0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,10,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{=straße","keys":["message","msg","event"]},"output":{"pattern":"{=straße","maskedLength":8,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"1\":\"xoxb-1234567890-abc日本語 ,api.example.com@\",\"event a\\\\nb\":\"192.168.001.001\\n:: .İstanbul [email protected]🚀,2é@\\r\\n-xoxp-1234567890=bearer x.y-z~+/==/\",\"[email protected] \":\"1e+100 =__defineGetter__ \\n\",\" -\\\":BEARER Kabc=libs\":\"W1301 10:00:00.15/Jan/2025:10:00:00 +0000\\nghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1\\n[-3fa85f64-5717-4562-b3fc-2c963f66afa6=3fa85f64-5717-4562-b3fc-2c963f66afa6\\ndeadbeef12/\",\"level @job_12345.E12\":\" deploy.sh=0b11 1.5 =12345678@\",\"xoxp-1234567890,-Inf\":8,\"𐀀\":\"token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig\\n00-Bearer\\u000bab@日本:Bearer\\u000babé@example.com/payload debug-\",\"valueOf\":9,\"AKIAA1B2C3D4E5F6G7H8\":6,\"AKIAIOSFODNN7EXAMPLE\":5,\"__defineGetter__\":1,\"::日本語 @\":\"0xDEADbeefJan 5 10:00:00:bearer x.y-z~+/==,Mon Jan 5 10:00:00 2025\",\"123\\\"1212.5abc /]depl\":0,\"b\":9,\"\\r\\n,é12=}:\":7,\"xoxp-1234567890.:_ey\":2,\"abc3fa85f64-5717-456\":\"[email protected]_000 =ms=12 2025-01-15T10:00:00.123Z [email protected] Jan 5 10:00:00\\n\",\" 12 null\":\"\\r\\n,Wed, 15 Jan 2025 10:00:00 GMT Bearer\\tabc,\",\"10.0.0.256=🚀=xoxb-1\":8,\",@Bearer\\u000bab\":\" 1212\\\"İstanbul/\",\"..\":5,\"ΣΑΣ:-İstanbul-ASIA\":7,\"_12345_3fa85f64-5717\":7,\"\\r\\nInfinity /Wed Jan \":4,\"\\\\\":\"straß[email protected] @deadbeef valueOf/ĵ:user [email protected] logged in-\",\" true, 12\\n\\t:0b1112.\":9,\"msg\":\"xoxp-1234567890.]\\\"_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6=abc3fa85f64-5717-4562-b3fc-2c963f66afa6\\\"POST\\n\"}","keys":["text","nope"]},"output":{"pattern":"<JSON:\r\n,é<N>=}:,\r\nInfinity /Wed Jan , <N> null,,@Bearer\u000bab,..,::日本語 @,<HEX>-<N>-<N>,<IP>=🚀=xoxb-<N>,<N>,AKIAA1B2C3D4E5F6G7H8,AKIAIOSFODNN7EXAMPLE,\\,_12345_3fa85f64-<N>,__defineGetter__,[email protected] ,b,event a\\nb,level @job_<N>.E12,msg,valueOf,xoxp-<N>,-Inf,xoxp-<N>.:_ey,ΣΑΣ:-İstanbul-ASIA, true, <N>\n\t:<N>b1112., -\":BEARER Kabc=libs,𐀀,123\"<N>.<N>abc /]depl>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":357,"jsonKeyCount":27,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,11,1,2]}},{"input":{"body":"[]","keys":["message","msg","event"]},"output":{"pattern":"<JSON_ARRAY>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":12,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"\"L-Bearer\\tabc \"","keys":["__proto__"]},"output":{"pattern":"L-Bearer\tabc ","maskedLength":14,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"\\\ntrue 2001:db8::1 E1231 23:59:594111 1111 1111 1111/","keys":[]},"output":{"pattern":"\\\ntrue <N>:db8::<N> E<KLOGTIME>4111 <N> <N> <N>/","maskedLength":48,"ruleFires":[0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"BEARER Kabc\"10.0.0.256/ :W1301 10:00:00AKIAA1B2C3D4E5F6G7H8.fi\"","keys":["constructor","msg"]},"output":{"pattern":"BEARER Kabc\"<IP>/ :W1301 <N>:<N>:<N>AKIAA1B2C3D4E5F6G7H8.fi\"","maskedLength":59,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"é@example.com\\\"🚀\\\"192.168.001.001:é1e3 \\\"ΣΑΣ\\\"gho_short/\\\"=sk_live_aaaaaaaaaaaaaaaaaaaaaaaa =\"","keys":["constructor","msg"]},"output":{"pattern":"é@<HOST>\"🚀\"<IP>:é<N>e3 \"ΣΑΣ\"gho_short/\"=sk_live_aaaaaaaaaaaaaaaaaaaaaaaa =","maskedLength":77,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"999.9999999fatal\"xoxp-1234567890Infinity .@2,","keys":[]},"output":{"pattern":"<N>.<N>fatal\"xoxp-<N>Infinity .@<N>,","maskedLength":36,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,2],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"null","keys":["message","msg","event"]},"output":{"pattern":"null","maskedLength":4,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"primitive","inputCapped":false}},{"input":{"body":"/api/users/12345/orders/987,xoxb-12345-=","keys":["constructor","msg"]},"output":{"pattern":"/api/users/<N>/orders/<N>,xoxb-<N>-=","maskedLength":36,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\\_api.example.com@bearer x.y-z~+/==,x_1234\nfi\"4294967294.http.methodvalueOf=","keys":["text","nope"]},"output":{"pattern":"\\_api.<HOST>@bearer x.y-z~+/==,x_<N>\nfi\"<N>.http.methodvalueOf=","maskedLength":63,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\\/10.0.0.256\nerror5..\r\n @","keys":["__proto__"]},"output":{"pattern":"\\/<IP>\nerror5..\r\n @","maskedLength":19,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"2\":2,\"event\":\"straße@valueOf \\r\\n xoxb-12345-,\",\" \":4,\"🚀\":5,\"\\\"quoted\\\"0b11:eyJabcd\":0,\"http.method\":\"-1.5 .0xDEADbeef/x_1234\\n\",\"length\":7,\"-Infinity \":\"Wed, 15 Jan 2025 10:00:00 GMT.\",\"Wed, 15 Jan 2025 10:\":1,\"aes_128 𐀀:\":7,\"payload\":9,\"01\":\"job_12345:\",\"1 \":\"2025-01-15T10:00:00.123Z\\n 12 null\\\"\",\"0 payload\":2,\"日本\":\"xoxp-1234567890\\\" 2025-01-15T10:00:00.123Z.host-1.internal=\",\"K\":3,\"Wed, 15 Jan 2025 12:\":\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé_deadbeef12,\",\"b\":\"}\\n日本語\\n🚀\\\"I0827 11:39:40.307946-aes_128\\n\\\"\",\"İstanbul\\n0xDEADbeef\":\".5 éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé @\",\"日本.5.ָ90071992547409\":4,\"123/\\\". ,Infinity\\\"x_1\":9,\"user_A1b2:192.168.00\":\"İstanbul3fa85f64-5717-4562-b3fc-2c963f66afa6-::1_ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1@]=sub_Abcdefghijklmnopqrstuvwx=Wed, 15 Jan 2025 10:00:00 GMT libssl.so,192.168.001.001=\",\"NaN -900719925474099\":3,\"deadbeef12=ghp_A1A1A\":1,\"ghp_A1A1A1A1A1A1A1A1\":\"INFO:sub_Abcdefghijklmnopqrstuvwx\\n🚀@\",\"\\\"\":\"[email protected]🚀.🚀\\nstraße/4111 1111 1111 1111=Wed, 15 Jan 2025 10:00:00 GMT-\\\\=ΣΑΣ,2025-01-15T10:00:00.123Z\\r\\n@12345678/\",\"日本@AKIAA1B2C3D4E5F6G\":3}","keys":["text","nope"]},"output":{"pattern":"<JSON: ,\",\"quoted\"<N>b11:eyJabcd,-Infinity ,<HEX>=<ID>,<ID>,<ID>:<N>.<N>.<N>,<N>,<N> ,<N> payload,K,NaN -<N>,Wed, <N> Jan <N> <N>:,aes_128 𐀀:,b,event,http.method,length,payload,İstanbul\n<HEX>,日本,日本.<N>.ָ<N>,日本@AKIAA1B2C3D4E5F6G,🚀,123/\". ,Infinity\"x_1>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":253,"jsonKeyCount":27,"ruleFires":[0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,1,0,16,1,1]}},{"input":{"body":"12345678\nx_1234 \"_ -12.5abc@fatal-Խ 2,é@_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6\"","keys":["message","msg","event"]},"output":{"pattern":"<N>\nx_<N> \"_ -<N>.<N>abc@fatal-Խ <N>,é@_<N>_<UUID>\"","maskedLength":51,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,3,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":" .192.168.001.001-user [email protected] logged in:xoxp-1234567890\nsk_test_ZZZZZZZZZZZZZZZZZZZ,123\"","keys":["message","msg","event"]},"output":{"pattern":" .<IP>-user <EMAIL> logged in:xoxp-<N>\nsk_test_ZZZZZZZZZZZZZZZZZZZ,123\"","maskedLength":72,"ruleFires":[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"eyJabcdefghijk.abcd.@gho_short\\nsk_live_aaaaaaaaaaaaaaaaaaaaaaaa\\n\\r\\n,= /Bearer\\u000bab@3fa85f64-5717-4562-b3fc-2c963f66afa6🚀-1_000\\\"\"","keys":[]},"output":{"pattern":"eyJabcdefghijk.abcd.@gho_short\nsk_live_aaaaaaaaaaaaaaaaaaaaaaaa\n\r\n,= /Bearer\u000bab@<UUID>🚀-<N>_000\"","maskedLength":98,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"Infinity ᳭","keys":["__proto__"]},"output":{"pattern":"Infinity ᳭","maskedLength":10,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"1e400","keys":["__proto__"]},"output":{"pattern":"<N>e400","maskedLength":7,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],"bodyKind":"primitive","inputCapped":false}},{"input":{"body":"\" \\nx_1234--1 m.2025-01-15T10:00:00Z1_000@deadbeef .ΣΑΣ_sub_Abcdefghijklmnopqrstuvwx:-1 @debug@\"","keys":["text","nope"]},"output":{"pattern":" \nx_<N>--<N> m.<TIMESTAMP>1_000@<HEX> .ΣΑΣ_sub_Abcdefghijklmnopqrstuvwx:-<N> @debug@","maskedLength":84,"ruleFires":[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,2,1,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"Jan 5 10:00:00-/api/users/12345/orders/987:sk_live_0123456789abcdefghijkl ::1\n","keys":["__proto__"]},"output":{"pattern":"<TIMESTAMP>-/api/users/<N>/orders/<N>:sk_live_0123456789abcdefghijkl ::<N>\n","maskedLength":75,"ruleFires":[0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,3,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"1e400","keys":["__proto__"]},"output":{"pattern":"<N>e400","maskedLength":7,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],"bodyKind":"primitive","inputCapped":false}},{"input":{"body":"Bearer\u000bab=🚀-Wed, 15 Jan 2025 10:00:00 GMT\n[ x䕡=x🚀.2001:db8::1 true !-\t:","keys":["message","msg","event"]},"output":{"pattern":"Bearer\u000bab=🚀-<TIMESTAMP>\n[ x䕡=x🚀.<N>:db8::<N> true !-\t:","maskedLength":58,"ruleFires":[0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,2,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"xoxb-12345-:fatal12 ,[email protected],","keys":["__proto__"]},"output":{"pattern":"xoxb-<N>-:fatal12 ,<EMAIL>,","maskedLength":27,"ruleFires":[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"12","keys":["text","nope"]},"output":{"pattern":"<N>","maskedLength":3,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"primitive","inputCapped":false}},{"input":{"body":null,"keys":["__proto__"]},"output":{"pattern":"","bodyKind":"empty","inputCapped":false,"maskedLength":0,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":" {} ","keys":["message","msg","event"]},"output":{"pattern":"<JSON:>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":7,"jsonKeyCount":0,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"{\"sk_live_0123456789ab\":3,\"http.method\":4,\"constructor\":0,\"[email protected]🚀/ע1.5/é12\\\"dep\":0,\"libssl.so/ 12_ghp_A1\":1,\"INFOwarn],\":\"Wed, 15 Jan 2025 12:00:00 GMT @4294967295,BEARER Kabc١٢٣-straßegho_short@/api/users/12345/orders/987/\",\"1 \":\"-1e4001e3 , 0xDEADbeef\\\"abc3fa85f64-5717-4562-b3fc-2c963f66afa6:Rsk_live_0123456789abcdefghijkl\",\"4294967295\":7,\"𐀀\":3,\"ghp_A1A1A1A1A1A1A1A1\":4,\"a.b\":7,\"1e3\":3,\"xoxb-12345-\\nhttp.met\":\"0/[email protected]🚀:Mon Jan 5 10:00:00 2025\\\"sub_Abcdefghijklmnopqrstuvwx\\n0xDEADbeef_host-1.internal:[email protected]🚀deploy.sh-Mon Jan 5 10:00:00 2025.\",\"user_A1b2-日本=user_A1\":9,\"AKIAA1B2C3D4E5F6G7H8\":\"[email protected]🚀BEARER Kabc=4111 1111 1111 1111\\\"4111 1111 1111 1111=\",\"3fa85f64-5717-4562-b\":0,\"GET\":\"Wed, 15 Jan 2025 10:00:00 GMT4294967296.ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1\\\"bearer x.y-z~+/==\\n 12 192.168.0.1:.5:Bearer\\u000bab@\",\"192.168.0.1\":\"귌3fa85f64-5717-4562-b3fc-2c963f66afa6 =x_1234,length \\\"sk_test_ZZZZZZZZZZZZZZZZZZZ\\\"deadbeef event𐋥-\",\"deadbeef\":7,\"\\ud800__defineGetter__\":1,\"0xDEADbeef-15/Jan/20\":3,\"[email protected]/Wed, 15 Jan 20\":2,\"k\":0,\"K\":\"ERROR:[email protected]🚀/1e3 a\\\\nb@[email protected],deploy.sh libssl.so/日本語0.30000000000000004@]2001:db8::1/AKIAA1B2C3D4E5F6G7H8:\",\"4111 1111 1111 1111=\":7,\"host-1.internalJan \":9,\"2025-01-15 10:00:00,\":\"ASIA0000000000000000X:[email protected]=\\\"12.5abc\\n\\t\\n١٢٣,日本語1,5 \\n日本=15/Jan/2025:10:00:00 +0000=\",\".a\":\" -日本_é12@2025-01-15T10:00:00.123Z=}-deploy.sh-\",\"message\":4,\"2025-01-15T10:00:00Z 0x10 \":\"AKIAIOSFODNN7EXAMPLE-1e400,\",\"level\":\"\\\"1_000:0length \\\"Bearer\\tabc\\\"\\r\\n=İstanbul@Jan 5 10:00:00\"}","keys":[]},"output":{"pattern":"<JSON:.a,<HEX>,<HEX>-<N>-<N>-b,<HEX>-<N>/Jan/<N>,<ID>,<ID>-日本=<ID>,<IP>,<N>,<N> ,<N> <N> <N> <N>=,<N>e3,<TIMESTAMP> <HEX> ,<TIMESTAMP>,,AKIAA1B2C3D4E5F6G7H8,GET,INFOwarn],,K,a.b,[email protected]/Wed, <N> Jan <N>,constructor,host-<N>.internalJan ,http.method,k,level,libssl.so/ <N>_ghp_A1,message,sk_live_0123456789ab,[email protected]🚀/ע<N>.<N>/é<N>\"dep,xoxb-<N>-\nhttp.met,𐀀,�__defineGetter__>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":373,"jsonKeyCount":31,"ruleFires":[2,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,2,1,17,2,2]}},{"input":{"body":"1e400","keys":["constructor","msg"]},"output":{"pattern":"<N>e400","maskedLength":7,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],"bodyKind":"primitive","inputCapped":false}},{"input":{"body":"192.168.001.001:deadbeef12,","keys":["message","msg","event"]},"output":{"pattern":"<IP>:<HEX>,","maskedLength":11,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"lengtha 00 5e-324 0b11日本語 ","keys":["message","msg","event"]},"output":{"pattern":"lengtha <N> <N>e-<N> <N>b11日本語 ","maskedLength":31,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,2],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"榮 12.5abc \ncus_ABCDEFGHIJKLMN_2025-01-15T10:00:00.123Z,[email protected]\n::1.\"quoted\"@xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx :\r\n\\ host-1.internal ","keys":["message","msg","event"]},"output":{"pattern":"榮 <N>.<N>abc \ncus_ABCDEFGHIJKLMN_<N>-<N>-<N>T10:<N>:<N>.<N>Z,<EMAIL>\n::<N>.\"quoted\"@xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx :\r\n\\ <HOST> ","maskedLength":399,"ruleFires":[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,1,0,0,5,0,3],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"P debug","keys":["text","nope"]},"output":{"pattern":"P debug","maskedLength":7,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"sk_live_aaaaaaaaaaaaaaaaaaaaaaaa,","keys":[]},"output":{"pattern":"sk_live_aaaaaaaaaaaaaaaaaaaaaaaa,","maskedLength":33,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\r\n--Infinity4294967294\naes_128:AKIAA1B2C3D4E5F6G7H8/W1301 10:00:00,user_A1b2/éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\\:","keys":["constructor","msg"]},"output":{"pattern":"\r\n--Infinity4294967294\naes_128:AKIAA1B2C3D4E5F6G7H8/W1301 <N>:<N>:<N>,<ID>/éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\\:","maskedLength":277,"ruleFires":[0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,3,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"1e400","keys":["text","nope"]},"output":{"pattern":"<N>e400","maskedLength":7,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],"bodyKind":"primitive","inputCapped":false}},{"input":{"body":"user_A1b2_","keys":["message","msg","event"]},"output":{"pattern":"<ID>_","maskedLength":5,"ruleFires":[0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"deploy.sh:eyJabcdefghijk.abcd.\\nwarn I0827 11:39:40.307946/15/Jan/2025:10:00:00 +0000:[\\\"BEARER Kabc@W1301 10:00:00\"","keys":["message","msg","event"]},"output":{"pattern":"deploy.sh:eyJabcdefghijk.abcd.\nwarn I<KLOGTIME>/<TIMESTAMP>:[\"BEARER Kabc@W1301 <N>:<N>:<N>","maskedLength":91,"ruleFires":[0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"2.5e-8 12 GET 12\"quoted\"12","keys":["constructor","msg"]},"output":{"pattern":"<N>.<N>e-<N> <N> GET <N>\"quoted\"<N>","maskedLength":36,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":".5:uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6-1e400.","keys":[]},"output":{"pattern":".<N>:uuid_<UUID>-<N>e400.","maskedLength":25,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":" {} ","keys":[]},"output":{"pattern":"<JSON:>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":7,"jsonKeyCount":0,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"{\"0b11Wed Jan 15 10:00\":\"eyJabcdefghijk.abcd._user [email protected] logged in ::1\\n0.0000014294967294@:_3fa85f64-5717-4562-b3fc-2c963f66afa6,\",\"192.168.001.001-alic\":0,\"\\\"=١٢٣_10.0.0.256.gho\":\"xoxb-12345--host-1.internal@0xDEADbeef=Bearer\\tabc-\",\"-1\":\"aes_128\\napi.example.com_\\t,\",\"192.168.001.001:host\":7,\" \\u000b\\n[-\\\\ .deadbeef-12.\":6,\"k\":1,\"_12345_3fa85f64-5717\":\"fi:\",\"Dž:2025-01-15 10:00:0\":5,\".a\":3,\"12345678\\\"2025-01-15 \":0,\"\":\"[email protected]\\\",\\\"_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6@} 123=Dž.\",\"�\":2,\"K\":\"3fa85f64-5717-4562-b3fc-2c963f66afa6,xoxb-1234567890-abc fatal_Mon Jan 5 10:00:00 2025/0xDEADbeef=xoxb-12345-:token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig@[email protected]ho_short \",\"deadbeef12\\neyJhbGciO\":\"12 \\nsk_test_ZZZZZZZZZZZZZZZZZZZ@é12,host-1.internal=:,\\r\\n\\n\",\"deadbeef\":5,\"12{\\\"a\\\":1} \\\"𐀀/deplo\":\"].cus_ABCDEFGHIJKLMN_ 12 @🚀.\",\"msg\":\"BEARER Kabc_fi/\\\" [_ /api/v1/users/123.AKIAA1B2C3D4E5F6G7H8-[.2025-01-15T10:00:00.123Z.BEARER Kabc,é@example.com,\",\"2025-01-15 10:00:00,\":\"api.example.com=\",\"0xDEADbeef:xoxb-1234\":4,\"Wed Jan 15 10:00:00 \":\"-1e400\\\"fi_10.0.0.256\\\"Ġ {\\\"a\\\":1}/日本.W1301 10:00:00\\\"İstanbul@aes_128 [email protected]\\\"\",\" -1.5_aes_128:\":\"4111 1111 1111 1111/Dž-\",\"uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\":1,\"host.example.com\":0,\"cus_ABCDEFGHIJKLMN/ \":\"gho_short\\\"\",\"level\":6,\",\\n15/Jan/2025:10:00:\":3,\"xx POST \\né12.0warn\\n\":\"user_A1b2/Bearer\\tabc\\\"\",\"192.168.001.001@ERRO\":9,\"日本\":3,\"\":0}","keys":[]},"output":{"pattern":"<JSON: \u000b\n[-\\ .<HEX>-<N>., -<N>.<N>_aes_128:,\"=١٢٣_10.<N>.<N>.<N>.gho,,\n<N>/Jan/<N>:<N>:<N>:,-<N>,.a,<HEX>,<HEX>\neyJhbGciO,<HEX>:xoxb-<N>,<HOST>,<ID>/ ,<IP>-alic,<IP>:host,<IP>@ERRO,<N>\"<N>-<N>-<N> ,<N>b11Wed Jan <N> <N>:<N>,<TIMESTAMP> ,<TIMESTAMP>,,K,_12345_3fa85f64-<N>,k,level,msg,uuid_<UUID>,xx POST \né<N>.<N>warn\n,Dž:<N>-<N>-<N> <N>:<N>:<N>,日本,,<N>{\"a\":<N>} \"𐀀/deplo,�,>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":380,"jsonKeyCount":31,"ruleFires":[1,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,1,1,3,28,3,3]}},{"input":{"body":"xoxp-1234567890:http.method@debugBearer abc.def-ghi [email protected]🚀,[email protected]:","keys":["__proto__"]},"output":{"pattern":"xoxp-<N>:http.method@debugBearer abc.def-ghi [email protected]🚀,<EMAIL>:","maskedLength":63,"ruleFires":[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"12.straße\"deadbeef12@뵻0 +5.192.168.001.001-","keys":["message","msg","event"]},"output":{"pattern":"<N>.straße\"<HEX>@뵻<N> +<IP>.<N>-","maskedLength":33,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,3,1,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"E1231 23:59:59\n","keys":["text","nope"]},"output":{"pattern":"E<KLOGTIME>\n","maskedLength":12,"ruleFires":[0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{}","keys":["message","msg","event"]},"output":{"pattern":"<JSON:>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":7,"jsonKeyCount":0,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"INFO.\\ .Wed, 15 Jan 2025 12:00:00 GMT \u000b =١٢٣:ms=12:W1301 10:00:00-host-1.internal 01-I0827 11:39:40.307946.{-","keys":["__proto__"]},"output":{"pattern":"INFO.\\ .<TIMESTAMP> \u000b =١٢٣:ms=<N>:W1301 <N>:<N>:<HOST> <N>-I<KLOGTIME>.{-","maskedLength":75,"ruleFires":[0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,4,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":null,"keys":[]},"output":{"pattern":"","bodyKind":"empty","inputCapped":false,"maskedLength":0,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":",,ΣΑΣ /api/users/12345/orders/987@sk_live_aaaaaaaaaaaaaaaaaaaaaaaa.gho_short:]-0xDEADbeef15/Jan/2025:10:00:00 +0000=","keys":["text","nope"]},"output":{"pattern":",,ΣΑΣ /api/users/<N>/orders/<N>@sk_live_aaaaaaaaaaaaaaaaaaaaaaaa.gho_short:]-<HEX>/Jan/<N>:<N>:<N>:<N> +<N>=","maskedLength":108,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,7,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"_12345_3fa85f64-5717\":5,\"0xDEADbeef,𓏀_x_1234\":1,\"123-10=10.0.0.256/\":9,\".a\":4,\"cus_ABCDEFGHIJKLMN\\nf\":7,\"user.email\":4,\"user.email\":2,\"Jan 5 10:00:00-GET \":0,\"9007199254740993\":3,\"\\\"+5 \":7,\"ASIA0000000000000000\":5,\"1.5\":8,\"[email protected]_ho\":\"Wed Jan 15 10:00:00 UTC 2025/_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6:sk_live_aaaaaaaaaaaaaaaaaaaaaaaa2025-01-15T10:00:00.123Z E1231 23:59:59@ASIA0000000000000000X_I0827 11:39:40.307946-\",\"user_A1b2@🚀-abc3fa8\":3,\"Wed Jan 15 10:00:00 \":\"sub_Abcdefghijklmnopqrstuvwx/user_123a. :é@example.com-\",\"\\\" \\\"user alice.smith+\":\"é12:嶫a\\\\nb,12.5 .2025-01-15T10:00:00Z warn :truenull \\\"ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1.eyJabcdefghijk.abcd.=\",\"İstanbul= /gho_short\":\"sk_test_ZZZZZZZZZZZZZZZZZZZ İstanbul,\\t-\",\"user_123\":6,\"constructor\":0,\"4294967296\":2,\"msg:cus_ABCDEFGHIJ\":1,\"\\t\":8,\"-1\":\"host-1.internal,bearer x.y-z~+/==.xoxb-12345-\\n\",\"http.method\":0,\"GET 4294967295\":1,\"Bearer abc.def-ghi \":\"-Infinity۠\\\"🚀,xoxp-1234567890\\n\",\"` \\\"quoted\\\",\":0,\"k\":\"100=bearer x.y-z~+/==@{@,,\\r\\n.\",\"x / : Ҩ +5 /\\\"éééééé\":5,\"-1e400 4294967295 :é\":4,\"toString\":6,\"debug@1,\\\"=192.168.1.\":\"job_12345/bearer x.y-z~+/==@}/123:[email protected]:Mon Jan 5 10:00:00 2025/\",\"\":3,\"msg\":3,\"\\n\":\"job_12345\\\"{:abc3fa85f64-5717-4562-b3fc-2c963f66afa6\\\"user_A1b2@,\\\"_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6:W1301 10:00:00-1.7976931348623157e+308 12345678_\",\"123\\nsub_Abcdefghijkl\":0}","keys":["message","msg","event"]},"output":{"pattern":"<JSON:\t,\n,\" \"user alice.smith+,\"+<N> ,-<N>,-<N>e400 <N> :é,.a,<EMAIL>_ho,<HEX>,𓏀_x_<N>,<ID>\nf,<ID>@🚀-abc3fa8,<N>,<N>.<N>,<TIMESTAMP> ,<TIMESTAMP>-GET ,ASIA0000000000000000,Bearer abc.def-ghi ,GET <N>,_12345_3fa85f64-<N>,` \"quoted\",,constructor,debug@<N>,\"=<N>.<N>.<N>.,http.method,k,msg,msg:cus_ABCDEFGHIJ,toString,user.email,user.email,user_123,x / : Ҩ +<N> /\"éééééé,İstanbul= /gho_short,+3>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":398,"jsonKeyCount":36,"ruleFires":[0,0,0,0,0,0,0,0,2,1,1,1,0,0,0,1,0,1,1,15,0,1]}},{"input":{"body":"\"ms=12_-9007199254740992+5/GET,AKIAA1B2C3D4E5F6G7H8:12不-/api/v1/users/123🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\\\"\"","keys":["constructor","msg"]},"output":{"pattern":"ms=<N>_-<N>+<N>/GET,AKIAA1B2C3D4E5F6G7H8:<N>不-/api/v1/users/<N>🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"","maskedLength":326,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,1],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"\"x\"","keys":["__proto__"]},"output":{"pattern":"x","maskedLength":1,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"1e400deadbeef🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀fatal-1.5","keys":["__proto__"]},"output":{"pattern":"<HEX>🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀fatal-<N>.<N>","maskedLength":278,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"I0827 11:39:40.307946\"2001:db8::1 :api.example.com_msgAKIAIOSFODNN7EXAMPLE\".51_000 _Wed Jan 15 10:00:00 UTC 2025/POST .3fa85f64-5717-4562-b3fc-2c963f66afa6 [,\\ 5. ","keys":[]},"output":{"pattern":"I<KLOGTIME>\"<N>:db8::<N> :api.example.<ID>\".<N>_000 _Wed <TIMESTAMP> UTC <N>/POST .<UUID> [,\\ <N>. ","maskedLength":101,"ruleFires":[0,1,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,4,0,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"x\"quoted\"\n\t:0-","keys":["constructor","msg"]},"output":{"pattern":"x\"quoted\"\n\t:<N>-","maskedLength":16,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"/","keys":["message","msg","event"]},"output":{"pattern":"\"/","maskedLength":2,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"xoxp-1234567890=","keys":["text","nope"]},"output":{"pattern":"xoxp-<N>=","maskedLength":9,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"[email protected]=api.example.com token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig/","keys":[]},"output":{"pattern":"<EMAIL>=<HOST> token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig/","maskedLength":62,"ruleFires":[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"[,E1231 23:59:59@token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig_4111 1111 1111 1111/","keys":["text","nope"]},"output":{"pattern":"[,E<KLOGTIME>@token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig_<N> <N> <N> <N>/","maskedLength":77,"ruleFires":[0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,3,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"12345678é@example.com\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxvalueOf@:.日本-123,eyJabcdefghijk.abcd.:::1=gho_short@job_12345\"","keys":["constructor","msg"]},"output":{"pattern":"<N>é@<HOST>\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxvalueOf@:.日本-123,eyJabcdefghijk.abcd.:::<N>=gho_short@job_<N>\"","maskedLength":374,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,2,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"W1301 10:00:00_/api/users/12345/orders/987@\"","keys":["constructor","msg"]},"output":{"pattern":"W1301 <N>:<N>:<N>_/api/users/<N>/orders/<N>@","maskedLength":44,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,1],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"BEARER Kabc [email protected]:].user [email protected] logged in.2.5e-8 12,::1:abc3fa85f64-5717-4562-b3fc-2c963f66afa6:W1301 10:00:00 INFO .deadbeef12\n","keys":["message","msg","event"]},"output":{"pattern":"BEARER Kabc <EMAIL>:].user <EMAIL> logged in.<N>.<N>e-<N> <N>,::<N>:<UUID>:W1301 <N>:<N>:<N> INFO .<HEX>\n","maskedLength":107,"ruleFires":[0,0,0,0,0,0,0,0,0,2,0,0,0,0,1,0,0,0,0,7,1,1],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"{\"event\":5}","keys":["__proto__"]},"output":{"pattern":"<JSON:event>","bodyKind":"json_object_or_array","inputCapped":false,"maskedLength":12,"jsonKeyCount":1,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},{"input":{"body":"[email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] [email protected] ","keys":["message","msg","event"]},"output":{"pattern":"<EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> <EMAIL> ","maskedLength":1176,"ruleFires":[0,0,0,0,0,0,0,0,0,147,0,0,0,0,0,0,0,0,0,0,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\"host.example.com:\"","keys":["constructor","msg"]},"output":{"pattern":"<HOST>:","maskedLength":7,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0],"bodyKind":"json_string","inputCapped":false}},{"input":{"body":"cus_ABCDEFGHIJKLMN.100 _","keys":["message","msg","event"]},"output":{"pattern":"<ID>.<N> _","maskedLength":11,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"\r\n@/api/users/12345/orders/987=aes_128_BEARER Kabc,true/\t,token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig.Bearer\u000bab.bearer x.y-z~+/===","keys":["message","msg","event"]},"output":{"pattern":"\r\n@/api/users/<N>/orders/<N>=aes_128_BEARER Kabc,true/\t,token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig.Bearer\u000bab.bearer x.y-z~+/===","maskedLength":132,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0],"bodyKind":"plaintext","inputCapped":false}},{"input":{"body":"INFO 0b11 /-1e400\nERROR1,5 x \nlibssl.so1.5@1_000:","keys":["constructor","msg"]},"output":{"pattern":"INFO <N>b11 /-<N>e400\nERROR1,<N> x \nlibssl.so1.<N>@<N>_000:","maskedLength":59,"ruleFires":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,3],"bodyKind":"plaintext","inputCapped":false}}]}diff --git a/rust/logs-ingestion/tests/fixtures/fuzz/pii.json b/rust/logs-ingestion/tests/fixtures/fuzz/pii.jsonnew file mode 100644index 000000000000..ff290436a132--- /dev/null+++ b/rust/logs-ingestion/tests/fixtures/fuzz/pii.json@@ -0,0 +1 @@+{"cases":[{"input":" 12 12 [email protected]🚀, .NaNk_a =10.0.0.256 3fa85f64-5717-4562-b3fc-2c963f66afa6:ms=12.Bearer\tabc-","output":{"output":" 12 12 [email protected]🚀, .NaNk_a =10.0.0.256 3fa85f64-5717-4562-b3fc-2c963f66afa6:ms=12.Bearer {{REDACTED}}","piiReplacements":1}},{"input":"4294967296 @ΣΑΣ=bearer x.y-z~+/==:\\-01.","output":{"output":"4294967296 @ΣΑΣ=Bearer {{REDACTED}}:\\-01.","piiReplacements":1}},{"input":"libssl.so.-1e400,0\\ 4111 1111 1111 1111\"-1.5:straße-abc3fa85f64-5717-4562-b3fc-2c963f66afa6\"\"","output":{"output":"libssl.so.-1e400,0\\ 4111 1111 1111 1111\"-1.5:straße-abc3fa85f64-5717-4562-b3fc-2c963f66afa6\"\"","piiReplacements":0}},{"input":",=_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6=Infinity:deadbeef12user [email protected] logged in 10.0.0.256\neyJabcdefghijk.abcd._日本語192.168.1.1@,-","output":{"output":",=_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6=Infinity:deadbeef12user {{REDACTED}} logged in 10.0.0.256\n{{REDACTED}}日本語192.168.1.1@,-","piiReplacements":2}},{"input":"eyJabcdefghijk.abcd.\"","output":{"output":"{{REDACTED}}\"","piiReplacements":1}},{"input":"1 @__proto__ 123:","output":{"output":"1 @__proto__ 123:","piiReplacements":0}},{"input":"[email protected]=host-1.internal/E1231 23:59:59\nE1231 23:59:59.é@example.com.","output":{"output":"{{REDACTED}}=host-1.internal/E1231 23:59:59\nE1231 23:59:59.é@example.com.","piiReplacements":1}},{"input":"12 GET .ms=12,[email protected]/],Wed, 15 Jan 2025 10:00:00 GMT:message,Dž ","output":{"output":"12 GET .ms=12,{{REDACTED}}/],Wed, 15 Jan 2025 10:00:00 GMT:message,Dž ","piiReplacements":1}},{"input":"ms=12.sub_Abcdefghijklmnopqrstuvwx.Dž=sk_test_ZZZZZZZZZZZZZZZZZZZ,","output":{"output":"ms=12.sub_Abcdefghijklmnopqrstuvwx.Dž=sk_test_ZZZZZZZZZZZZZZZZZZZ,","piiReplacements":0}},{"input":"[.deploy.sh_123123_GET01 .Wed, 15 Jan 2025 10:00:00 GMT sk_test_ZZZZZZZZZZZZZZZZZZZ-","output":{"output":"[.deploy.sh_123123_GET01 .Wed, 15 Jan 2025 10:00:00 GMT sk_test_ZZZZZZZZZZZZZZZZZZZ-","piiReplacements":0}},{"input":"Wed Jan 15 10:00:00 UTC 2025-2025-01-15 10:00:00,123+0100,deploy.sh\npayload \n,@","output":{"output":"Wed Jan 15 10:00:00 UTC 2025-2025-01-15 10:00:00,123+0100,deploy.sh\npayload \n,@","piiReplacements":0}},{"input":"\"_/api/users/12345/orders/987-2025-01-15 10:00:00,123+0100bearer x.y-z~+/===떹[1,2].\\\nk日本=","output":{"output":"\"_/api/users/12345/orders/987-2025-01-15 10:00:00,123+0100Bearer {{REDACTED}}떹[1,2].\\\nk日本=","piiReplacements":1}},{"input":"+5_fi192.168.001.001/}\nmessage=Bearer abc.def-ghi_ms=12@ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1/\\_ASIA0000000000000000X ","output":{"output":"+5_fi192.168.001.001/}\nmessage=Bearer {{REDACTED}}12@{{REDACTED}}/\\_ASIA0000000000000000X ","piiReplacements":2}},{"input":"deploy.sh:00 ,🚀\nBearer\tabc/sk_live_aaaaaaaaaaaaaaaaaaaaaaaa00=/GET4294967296_ms=12\"","output":{"output":"deploy.sh:00 ,🚀\nBearer {{REDACTED}}/GET4294967296_ms=12\"","piiReplacements":1}},{"input":"\\@\\-abc3fa85f64-5717-4562-b3fc-2c963f66afa6@a\\nb.cus_ABCDEFGHIJKLMN-[\n","output":{"output":"\\@\\-abc3fa85f64-5717-4562-b3fc-2c963f66afa6@a\\nb.cus_ABCDEFGHIJKLMN-[\n","piiReplacements":0}},{"input":"__proto__-0=Bearer\[email protected]\n/api/users/12345/orders/987 \"\nfi/NaN,\r\n @Jan 5 10:00:00 ","output":{"output":"__proto__-0=Bearer {{REDACTED}}@b.co\n/api/users/12345/orders/987 \"\nfi/NaN,\r\n @Jan 5 10:00:00 ","piiReplacements":1}},{"input":"1 _","output":{"output":"1 _","piiReplacements":0}},{"input":"\t abc3fa85f64-5717-4562-b3fc-2c963f66afa6,deploy.sh=user_12300 _ﻔ@W1301 10:00:00,host-1.internal@[_ERROR =straße_","output":{"output":"\t abc3fa85f64-5717-4562-b3fc-2c963f66afa6,deploy.sh=user_12300 _ﻔ@W1301 10:00:00,host-1.internal@[_ERROR =straße_","piiReplacements":0}},{"input":"[email protected]","output":{"output":"{{REDACTED}}","piiReplacements":1}},{"input":"Wed Jan 15 10:00:00 UTC 2025@},","output":{"output":"Wed Jan 15 10:00:00 UTC 2025@},","piiReplacements":0}},{"input":"0xDEADbeef .[1,2]:sub_Abcdefghijklmnopqrstuvwx4111 1111 1111 1111\"12 5.-","output":{"output":"0xDEADbeef .[1,2]:sub_Abcdefghijklmnopqrstuvwx4111 1111 1111 1111\"12 5.-","piiReplacements":0}},{"input":"libssl.so 12345678s[email protected]🚀=libssl.so 12345678s[email protected]🚀=libssl.so 12345678s[email protected]🚀=libssl.so 12345678s[email protected]🚀=libssl.so 12345678s[email protected]🚀=libssl.so 12345678s[email protected]🚀=libssl.so 12345678s[email protected]🚀=","output":{"output":"libssl.so 12345678s[email protected]🚀=libssl.so 12345678s[email protected]🚀=libssl.so 12345678s[email protected]🚀=libssl.so 12345678s[email protected]🚀=libssl.so 12345678s[email protected]🚀=libssl.so 12345678s[email protected]🚀=libssl.so 12345678s[email protected]🚀=","piiReplacements":0}},{"input":"é@example.com/job_12345/ms=12_token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig:I0827 11:39:40.307946-x=message12.5abc :sk_test_ZZZZZZZZZZZZZZZZZZZ-","output":{"output":"é@example.com/job_12345/ms=12_token={{REDACTED}}:I0827 11:39:40.307946-x=message12.5abc :sk_test_ZZZZZZZZZZZZZZZZZZZ-","piiReplacements":1}},{"input":"12a fi,�/","output":{"output":"12a fi,�/","piiReplacements":0}},{"input":"ΣΑΣ.0xDEADbeef@15/Jan/2025:10:00:00 +0000-\r\n AKIAIOSFODNN7EXAMPLE ","output":{"output":"ΣΑΣ.0xDEADbeef@15/Jan/2025:10:00:00 +0000-\r\n {{REDACTED}} ","piiReplacements":1}},{"input":"15/Jan/2025:10:00:00 +0000=İstanbul=3fa85f64-5717-4562-b3fc-2c963f66afa6@\r\n:sk_test_ZZZZZZZZZZZZZZZZZZZ\"[1,2]2001:db8::1.","output":{"output":"15/Jan/2025:10:00:00 +0000=İstanbul=3fa85f64-5717-4562-b3fc-2c963f66afa6@\r\n:sk_test_ZZZZZZZZZZZZZZZZZZZ\"[1,2]2001:db8::1.","piiReplacements":0}},{"input":"١٢٣/3fa85f64-5717-4562-b3fc-2c963f66afa6-日本\n[1,2] \n🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 ,::","output":{"output":"١٢٣/3fa85f64-5717-4562-b3fc-2c963f66afa6-日本\n[1,2] \n🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 ,::","piiReplacements":0}},{"input":"gho_short,I0827 11:39:40.307946 xoxp-1234567890@","output":{"output":"gho_short,I0827 11:39:40.307946 {{REDACTED}}@","piiReplacements":1}},{"input":"İstanbul\"İstanbul-\t.user_A1b2/ms=12..full\"","output":{"output":"İstanbul\"İstanbul-\t.user_A1b2/ms=12..full\"","piiReplacements":0}},{"input":"é12\nDž=cus_ABCDEFGHIJKLMN-AKIAIOSFODNN7EXAMPLE-1e400 :é12:{:\":123 ","output":{"output":"é12\nDž=cus_ABCDEFGHIJKLMN-{{REDACTED}}-1e400 :é12:{:\":123 ","piiReplacements":1}},{"input":"E1231 23:59:59_user [email protected] logged in_user.email/api/v1/users/123sk_live_aaaaaaaaaaaaaaaaaaaaaaaa=I0827 11:39:40.307946/aes_128\n2025-01-15 10:00:00,123+0100=日本 日本語=token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig.","output":{"output":"E1231 23:59:59_user {{REDACTED}} logged in_user.email/api/v1/users/123sk_live_aaaaaaaaaaaaaaaaaaaaaaaa=I0827 11:39:40.307946/aes_128\n2025-01-15 10:00:00,123+0100=日本 日本語=token={{REDACTED}}.","piiReplacements":2}},{"input":"12345678 🚀\n","output":{"output":"12345678 🚀\n","piiReplacements":0}},{"input":"payload .hasOwnProperty__defineGetter___1e+21message=@ΣΑΣ.host-1.internal\"[email protected],.5-15/Jan/2025:10:00:00 +0000@","output":{"output":"payload .hasOwnProperty__defineGetter___1e+21message=@ΣΑΣ.host-1.internal\"{{REDACTED}},.5-15/Jan/2025:10:00:00 +0000@","piiReplacements":1}},{"input":"api.example.com\"İstanbul/","output":{"output":"api.example.com\"İstanbul/","piiReplacements":0}},{"input":"İstanbul\n0xDEADbeef=9007199254740994-I0827 11:39:40.307946.5.hasOwnProperty =xoxb-12345-:[email protected] 23:59:59_123-","output":{"output":"İstanbul\n0xDEADbeef=9007199254740994-I0827 11:39:40.307946.5.hasOwnProperty =xoxb-12345-:{{REDACTED}}.E1231 23:59:59_123-","piiReplacements":1}},{"input":"\t@\"quoted\"\n123\"","output":{"output":"\t@\"quoted\"\n123\"","piiReplacements":0}},{"input":"-Infinity[1,2].123true@Bearer\tabc=\u000b ,Bearer\u000bab:15/Jan/2025:10:00:00 +0000bearer x.y-z~+/==-","output":{"output":"-Infinity[1,2].123true@Bearer {{REDACTED}}\u000b ,Bearer\u000bab:15/Jan/2025:10:00:00 +0000Bearer {{REDACTED}}-","piiReplacements":2}},{"input":"日本.\r\n\neyJabcdefghijk.abcd.-BEARER Kabc-","output":{"output":"日本.\r\n\n{{REDACTED}} Kabc-","piiReplacements":1}},{"input":"POSTx[email protected] ,user [email protected] logged in,4111 1111 1111 1111@\r\n@xoxp-1234567890_{@-9007199254740992true\"","output":{"output":"{{REDACTED}}.com192.168.1.11.5 ,user {{REDACTED}} logged in,4111 1111 1111 1111@\r\n@xoxp-1234567890_{@-9007199254740992true\"","piiReplacements":2}},{"input":"0.000001 @3fa85f64-5717-4562-b3fc-2c963f66afa610-deadbeef12:0xDEADbeef\"\\ASIA0000000000000000X@BEARER Kabc.xoxp-1234567890\"token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig@15/Jan/2025:10:00:00 +0000:","output":{"output":"0.000001 @3fa85f64-5717-4562-b3fc-2c963f66afa610-deadbeef12:0xDEADbeef\"\\ASIA0000000000000000X@Bearer {{REDACTED}}\"token={{REDACTED}}@15/Jan/2025:10:00:00 +0000:","piiReplacements":2}},{"input":"libssl.so=_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6:api.example.com/12[1,2]@aes_128_00日本:4294967295/-Infinity.é@example.com_user [email protected] logged in/","output":{"output":"libssl.so=_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6:api.example.com/12[1,2]@aes_128_00日本:4294967295/-Infinity.é@example.com_user {{REDACTED}} logged in/","piiReplacements":1}},{"input":"Wed, 15 Jan 2025 10:00:00 GMT:2025-01-15 10:00:00,123+0100-ܠ\nERROR@/api/users/12345/orders/987 ","output":{"output":"Wed, 15 Jan 2025 10:00:00 GMT:2025-01-15 10:00:00,123+0100-ܠ\nERROR@/api/users/12345/orders/987 ","piiReplacements":0}},{"input":"a._\"@\r\n:true \n","output":{"output":"a._\"@\r\n:true \n","piiReplacements":0}},{"input":"libssl.so2.5e-81e3 @bearer x.y-z~+/==\"/api/users/12345/orders/987/[1,2] =/api/users/12345/orders/987\"","output":{"output":"libssl.so2.5e-81e3 @Bearer {{REDACTED}}\"/api/users/12345/orders/987/[1,2] =/api/users/12345/orders/987\"","piiReplacements":1}},{"input":"ms=12-12.5abc/é@example.com:삱 日本語_1é\"W1301 10:00:00\"BEARER Kabc/","output":{"output":"ms=12-12.5abc/é@example.com:삱 日本語_1é\"W1301 10:00:00\"Bearer {{REDACTED}}","piiReplacements":1}},{"input":"3fa85f64-5717-4562-b3fc-2c963f66afa6=ms=12=0xDEADbeef-","output":{"output":"3fa85f64-5717-4562-b3fc-2c963f66afa6=ms=12=0xDEADbeef-","piiReplacements":0}},{"input":"9007199254740993 :xoxb-12345-,","output":{"output":"9007199254740993 :xoxb-12345-,","piiReplacements":0}},{"input":"\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/","output":{"output":"\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/\r\n_,_ΣΑΣ/","piiReplacements":0}},{"input":"eyJabcdefghijk.abcd.\n[0.30000000000000004full.","output":{"output":"{{REDACTED}}\n[0.30000000000000004full.","piiReplacements":1}},{"input":"}_\"quoted\",","output":{"output":"}_\"quoted\",","piiReplacements":0}},{"input":"Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@","output":{"output":"Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@Infinity =2.5e-8payload \t@","piiReplacements":0}},{"input":"[email protected],eyJabcdefghijk.abcd. cus_ABCDEFGHIJKLMN/1e-71e400, [email protected] \n1_000-","output":{"output":"{{REDACTED}},{{REDACTED}} cus_ABCDEFGHIJKLMN/1e-71e400, {{REDACTED}} \n1_000-","piiReplacements":3}},{"input":" 123fa85f64-5717-4562-b3fc-2c963f66afa6\ngho_short_AKIAA1B2C3D4E5F6G7H8_123=日本語INFO/","output":{"output":" 123fa85f64-5717-4562-b3fc-2c963f66afa6\ngho_short_AKIAA1B2C3D4E5F6G7H8_123=日本語INFO/","piiReplacements":0}},{"input":"token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig\n1,5/12345678_١٢٣[email protected] Dž 🚀日本語 \n","output":{"output":"token={{REDACTED}}\n1,5/12345678_١٢٣={{REDACTED}} Dž 🚀日本語 \n","piiReplacements":2}},{"input":"bearer x.y-z~+/==\n192.168.001.001\n3fa85f64-5717-4562-b3fc-2c963f66afa6@sk_live_aaaaaaaaaaaaaaaaaaaaaaaa","output":{"output":"Bearer {{REDACTED}}\n192.168.001.001\n3fa85f64-5717-4562-b3fc-2c963f66afa6@{{REDACTED}}","piiReplacements":2}},{"input":"Bearer\u000bab,straß[email protected]\n🚀_","output":{"output":"Bearer\u000bab,straße={{REDACTED}}\n🚀_","piiReplacements":1}},{"input":"ނ.","output":{"output":"ނ.","piiReplacements":0}},{"input":",.deadbeef12.12345678{\"a\":1}=ms=12=é@example.com-","output":{"output":",.deadbeef12.12345678{\"a\":1}=ms=12=é@example.com-","piiReplacements":0}},{"input":"2025-01-15 10:00:00,123+0100.\t@� 4294967295\"","output":{"output":"2025-01-15 10:00:00,123+0100.\t@� 4294967295\"","piiReplacements":0}},{"input":"constructor@15/Jan/2025:10:00:00 +0000 2025-01-15 10:00:00,123+0100 [email protected]\"[email protected]/","output":{"output":"constructor@15/Jan/2025:10:00:00 +0000 2025-01-15 10:00:00,123+0100 {{REDACTED}}\"{{REDACTED}}/","piiReplacements":2}},{"input":"bearer x.y-z~+/===constructor01__12345_3fa85f64-5717-4562-b3fc-2c963f66afa6-host.example.com-deploy.sh@uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6 1.5 \n{-host-1.internal@t4294967295 _","output":{"output":"Bearer {{REDACTED}}constructor01__12345_3fa85f64-5717-4562-b3fc-2c963f66afa6-host.example.com-deploy.sh@uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6 1.5 \n{-host-1.internal@t4294967295 _","piiReplacements":1}},{"input":"bearer x.y-z~+/==\"[email protected]:db8::1valueOf=Ў 192.168.1.1/user_A1b2:user_A1b2\n١٢٣\"\\_İstanbul\"日本語/","output":{"output":"Bearer {{REDACTED}}\"[email protected]:db8::1valueOf=Ў 192.168.1.1/user_A1b2:user_A1b2\n١٢٣\"\\_İstanbul\"日本語/","piiReplacements":1}},{"input":"+5 @straße,Mon Jan 5 10:00:00 2025.-1e400=token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig:AKIAA1B2C3D4E5F6G7H8:I0827 11:39:40.307946. :","output":{"output":"+5 @straße,Mon Jan 5 10:00:00 2025.-1e400=token={{REDACTED}}:{{REDACTED}}:I0827 11:39:40.307946. :","piiReplacements":2}},{"input":"7=constructorPOST\néééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé.\\@","output":{"output":"7=constructorPOST\néééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé.\\@","piiReplacements":0}},{"input":"123/[email protected][1,2] \"I0827 11:39:40.307946\n\t:-1\"quoted\" _","output":{"output":"123/{{REDACTED}}[1,2] \"I0827 11:39:40.307946\n\t:-1\"quoted\" _","piiReplacements":1}},{"input":"I0827 11:39:40.307946@2025-01-15T10:00:00Z =İstanbul/Mon Jan 5 10:00:00 2025-true warn 2025-01-15T10:00:00.123Z\nȪ \n_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6","output":{"output":"I0827 11:39:40.307946@2025-01-15T10:00:00Z =İstanbul/Mon Jan 5 10:00:00 2025-true warn 2025-01-15T10:00:00.123Z\nȪ \n_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6","piiReplacements":0}},{"input":"deploy.sh host-1.internal@token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig/sk_live_aaaaaaaaaaaaaaaaaaaaaaaa.E1231 23:59:59,}_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6 ] ","output":{"output":"deploy.sh host-1.internal@token={{REDACTED}}/{{REDACTED}}.E1231 23:59:59,}_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6 ] ","piiReplacements":2}},{"input":"} g[email protected]\"","output":{"output":"} {{REDACTED}}\"","piiReplacements":1}},{"input":"POSTWed, 15 Jan 2025 12:00:00 GMT\t:15/Jan/2025:10:00:00 +0000,\\\n","output":{"output":"POSTWed, 15 Jan 2025 12:00:00 GMT\t:15/Jan/2025:10:00:00 +0000,\\\n","piiReplacements":0}},{"input":"http.method =xoxb-12345-,12345678/15/Jan/2025:10:00:00 +0000=\r\n \t_Wed, 15 Jan 2025 10:00:00 GMT/Dž,","output":{"output":"http.method =xoxb-12345-,12345678/15/Jan/2025:10:00:00 +0000=\r\n \t_Wed, 15 Jan 2025 10:00:00 GMT/Dž,","piiReplacements":0}},{"input":"0nulluuid_3fa85f64-5717-4562-b3fc-2c963f66afa6:Mon Jan 5 10:00:00 2025,Wed, 15 Jan 2025 10:00:00 GMT=,:","output":{"output":"0nulluuid_3fa85f64-5717-4562-b3fc-2c963f66afa6:Mon Jan 5 10:00:00 2025,Wed, 15 Jan 2025 10:00:00 GMT=,:","piiReplacements":0}},{"input":"1e400NaN@ms=12\"bearer x.y-z~+/==_=15/Jan/2025:10:00:00 +0000{ sk_test_ZZZZZZZZZZZZZZZZZZZ ","output":{"output":"1e400NaN@ms=12\"Bearer {{REDACTED}}_=15/Jan/2025:10:00:00 +0000{ sk_test_ZZZZZZZZZZZZZZZZZZZ ","piiReplacements":1}},{"input":" @0x10 =井12 =straße/\r\n- @0x10 =井12 =straße/\r\n- @0x10 =井12 =straße/\r\n- @0x10 =井12 =straße/\r\n- @0x10 =井12 =straße/\r\n- @0x10 =井12 =straße/\r\n- @0x10 =井12 =straße/\r\n-","output":{"output":" @0x10 =井12 =straße/\r\n- @0x10 =井12 =straße/\r\n- @0x10 =井12 =straße/\r\n- @0x10 =井12 =straße/\r\n- @0x10 =井12 =straße/\r\n- @0x10 =井12 =straße/\r\n- @0x10 =井12 =straße/\r\n-","piiReplacements":0}},{"input":"2025-01-15T10:00:00Z:7 ,deploy.sh:","output":{"output":"2025-01-15T10:00:00Z:7 ,deploy.sh:","piiReplacements":0}},{"input":"0x10:Jan 5 10:00:00 W1301 10:00:00/Jan 5 10:00:[email protected].,job_12345,::1:","output":{"output":"0x10:Jan 5 10:00:00 W1301 10:00:00/Jan 5 10:00:{{REDACTED}}.,job_12345,::1:","piiReplacements":1}},{"input":"a.b 1e400-","output":{"output":"a.b 1e400-","piiReplacements":0}},{"input":"1e+100=.5 W1301 10:00:00@123=5.999.9999999\"","output":{"output":"1e+100=.5 W1301 10:00:00@123=5.999.9999999\"","piiReplacements":0}},{"input":"http.method _","output":{"output":"http.method _","piiReplacements":0}},{"input":"12error ","output":{"output":"12error ","piiReplacements":0}},{"input":"ERROR null,[email protected]🚀:12.5abc fatal -2025-01-15 10:00:00,123+0100/","output":{"output":"ERROR null,{{REDACTED}}-🚀:12.5abc fatal -2025-01-15 10:00:00,123+0100/","piiReplacements":1}},{"input":"\r\n\n:.abc3fa85f64-5717-4562-b3fc-2c963f66afa6gho_short/api.example.com@","output":{"output":"\r\n\n:.abc3fa85f64-5717-4562-b3fc-2c963f66afa6gho_short/api.example.com@","piiReplacements":0}},{"input":"-0/api/v1/users/123\n","output":{"output":"-0/api/v1/users/123\n","piiReplacements":0}},{"input":"١٢٣","output":{"output":"١٢٣","piiReplacements":0}},{"input":"{\n/api/users/12345/orders/987\"Dž--1e400sk_live_0123456789abcdefghijkl true-libssl.so\n","output":{"output":"{\n/api/users/12345/orders/987\"Dž--1e400sk_live_0123456789abcdefghijkl true-libssl.so\n","piiReplacements":0}},{"input":"user_A1b2,ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1/0xDEADbeef \t.cus_ABCDEFGHIJKLMN\"","output":{"output":"user_A1b2,{{REDACTED}}/0xDEADbeef \t.cus_ABCDEFGHIJKLMN\"","piiReplacements":1}},{"input":"Mon Jan 5 10:00:00 2025:Bearer\u000bab/+5🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀,eyJabcdefghijk.abcd. eyJabcdefghijk.abcd.,192.168.1.1 5e-324=deadbeef12_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6_token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig@abc3fa85f64-5717-4562-b3fc-2c963f66afa6/","output":{"output":"Mon Jan 5 10:00:00 2025:Bearer\u000bab/+5🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀,{{REDACTED}} {{REDACTED}},192.168.1.1 5e-324=deadbeef12_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6_token={{REDACTED}}@abc3fa85f64-5717-4562-b3fc-2c963f66afa6/","piiReplacements":3}},{"input":"1,5=1 .","output":{"output":"1,5=1 .","piiReplacements":0}},{"input":" a.\"[email protected]@a\\nb@","output":{"output":" a.\"{{REDACTED}}@a\\nb@","piiReplacements":1}},{"input":"true ,","output":{"output":"true ,","piiReplacements":0}},{"input":"deadbeef122025-01-15 10:00:00,123+0100🚀4294967295\t\n\\@W1301 10:00:00\"W1301 10:00:00=fi\"BEARER Kabc-[ ","output":{"output":"deadbeef122025-01-15 10:00:00,123+0100🚀4294967295\t\n\\@W1301 10:00:00\"W1301 10:00:00=fi\"Bearer {{REDACTED}}[ ","piiReplacements":1}},{"input":"123.日本.2025-01-15 10:00:00,123+0100\"AKIAA1B2C3D4E5F6G7H8\"[email protected]_","output":{"output":"123.日本.2025-01-15 10:00:00,123+0100\"{{REDACTED}}\"[email protected]_","piiReplacements":1}},{"input":"GET 12 4294967296 v\"http.method/eyJabcdefghijk.abcd.\n:\nI0827 11:39:40.307946\"[email protected]+308\"quoted\":12345678\"4111 1111 1111 1111:","output":{"output":"GET 12 4294967296 v\"http.method/{{REDACTED}}\n:\nI0827 11:39:40.307946\"{{REDACTED}}@1.7976931348623157e+308\"quoted\":12345678\"4111 1111 1111 1111:","piiReplacements":2}},{"input":"Mon Jan 5 10:00:00 2025\"0.1debug@2025-01-15 10:00:00,123+0100 4294967296\"x[email protected]\"fatal 日本語 :","output":{"output":"Mon Jan 5 10:00:00 2025\"0.1debug@2025-01-15 10:00:00,123+0100 4294967296\"x[email protected]\"fatal 日本語 :","piiReplacements":0}},{"input":"-Infinity-}@\n0bearer x.y-z~+/==-ASIA0000000000000000X\"2025-01-15 10:00:00,123+0100=::1é@example.com\n-Infinity𐀀 /䩞 :","output":{"output":"-Infinity-}@\n0Bearer {{REDACTED}}-ASIA0000000000000000X\"2025-01-15 10:00:00,123+0100=::1é@example.com\n-Infinity𐀀 /䩞 :","piiReplacements":1}},{"input":"/api/users/12345/orders/987@bearer x.y-z~+/==_🚀/","output":{"output":"/api/users/12345/orders/987@Bearer {{REDACTED}}_🚀/","piiReplacements":1}},{"input":"[email protected]/5. 日本語-","output":{"output":"[email protected]/5. 日本語-","piiReplacements":0}},{"input":"日本\"\\:user [email protected] logged in/2025-01-15 10:00:00,123+0100 K :xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx [\"","output":{"output":"日本\"\\:user {{REDACTED}} logged in/2025-01-15 10:00:00,123+0100 K :xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx [\"","piiReplacements":1}},{"input":"🚀/[\n2025-01-15T10:00:00Z [email protected]/","output":{"output":"🚀/[\n2025-01-15T10:00:00Z {{REDACTED}}/","piiReplacements":1}},{"input":"abc3fa85f64-5717-4562-b3fc-2c963f66afa6@sub_Abcdefghijklmnopqrstuvwx.fi/[1,2]:ERROR\\user [email protected] logged in\"120.1 /user_A1b2_ΣΑΣ-","output":{"output":"abc3fa85f64-5717-4562-b3fc-2c963f66afa6@sub_Abcdefghijklmnopqrstuvwx.fi/[1,2]:ERROR\\user {{REDACTED}} logged in\"120.1 /user_A1b2_ΣΑΣ-","piiReplacements":1}},{"input":"user_A1b2 ASIA0000000000000000X=ដ,sub_Abcdefghijklmnopqrstuvwx.","output":{"output":"user_A1b2 ASIA0000000000000000X=ដ,sub_Abcdefghijklmnopqrstuvwx.","piiReplacements":0}},{"input":"\t_[\"2025-01-15 10:00:00,123+0100ms=12\nsk_test_ZZZZZZZZZZZZZZZZZZZ\",,ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1Jan 5 10:00:00/[1,2] =","output":{"output":"\t_[\"2025-01-15 10:00:00,123+0100ms=12\nsk_test_ZZZZZZZZZZZZZZZZZZZ\",,{{REDACTED}} 5 10:00:00/[1,2] =","piiReplacements":1}},{"input":"12345678=12345678\"2025-01-15T10:00:00Z 7:日本 [email protected] 100=","output":{"output":"12345678=12345678\"2025-01-15T10:00:00Z 7:日本 [email protected] 100=","piiReplacements":0}},{"input":"abc3fa85f64-5717-4562-b3fc-2c963f66afa6@ \nms=12,ֶ_🚀-xu\n ","output":{"output":"abc3fa85f64-5717-4562-b3fc-2c963f66afa6@ \nms=12,ֶ_🚀-xu\n ","piiReplacements":0}},{"input":"user [email protected] logged in\n}:é@example.com_k_eyJabcdefghijk.abcd.\"host-1.internal/","output":{"output":"user {{REDACTED}} logged in\n}:é@example.com_k_eyJabcdefghijk.abcd.\"host-1.internal/","piiReplacements":1}},{"input":"00 fatal-bearer x.y-z~+/==@","output":{"output":"00 fatal-Bearer {{REDACTED}}@","piiReplacements":1}},{"input":"[email protected]🚀=4294967294.5-12_Bearer\u000bab:10.0.0.256:١٢٣ [\njob_12345.","output":{"output":"[email protected]🚀=4294967294.5-12_Bearer\u000bab:10.0.0.256:١٢٣ [\njob_12345.","piiReplacements":0}},{"input":"1.5_E1231 23:59:59_event,\"\"[email protected]/a_Bearer\u000bab=-Infinity 0o7@ms=12I0827 11:39:40.307946:","output":{"output":"1.5_E1231 23:59:59_event,\"\"{{REDACTED}}/a_Bearer\u000bab=-Infinity 0o7@ms=12I0827 11:39:40.307946:","piiReplacements":1}},{"input":"true/deadbeef12 3fa85f64-5717-4562-b3fc-2c963f66afa6\n123Wed, 15 Jan 2025 10:00:00 GMTERROR/ -1e400/","output":{"output":"true/deadbeef12 3fa85f64-5717-4562-b3fc-2c963f66afa6\n123Wed, 15 Jan 2025 10:00:00 GMTERROR/ -1e400/","piiReplacements":0}},{"input":"-1e400 =xoxp-1234567890- @","output":{"output":"-1e400 ={{REDACTED}}- @","piiReplacements":1}},{"input":"job_12345-bearer x.y-z~+/==.eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123Bearer abc.def-ghi.gho_short\ntrue:sk_test_ZZZZZZZZZZZZZZZZZZZ=_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6-job_12345@1e3 ","output":{"output":"job_12345-Bearer {{REDACTED}}.{{REDACTED}} abc.def-ghi.gho_short\ntrue:sk_test_ZZZZZZZZZZZZZZZZZZZ=_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6-job_12345@1e3 ","piiReplacements":2}},{"input":"xoxp-1234567890.4111 1111 1111 1111.__proto__-Infinity \neyJabcdefghijk.abcd./eyJabcdefghijk.abcd.@INFO,1.5@BEARER Kabc\\,token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig,","output":{"output":"{{REDACTED}}.4111 1111 1111 1111.__proto__-Infinity \n{{REDACTED}}/{{REDACTED}}@INFO,1.5@Bearer {{REDACTED}}\\,token={{REDACTED}},","piiReplacements":5}},{"input":"sk_live_0123456789abcdefghijklsk_live_aaaaaaaaaaaaaaaaaaaaaaaa/cus_ABCDEFGHIJKLMN-AKIAA1B2C3D4E5F6G7H8\na.user.email- _deploy.sh-","output":{"output":"sk_live_0123456789abcdefghijklsk_live_aaaaaaaaaaaaaaaaaaaaaaaa/cus_ABCDEFGHIJKLMN-{{REDACTED}}\na.user.email- _deploy.sh-","piiReplacements":1}},{"input":"cus_ABCDEFGHIJKLMN [email protected]:,,İstanbul ::1_a\\nbdeadbeef=toString 2001:db8::1.abc3fa85f64-5717-4562-b3fc-2c963f66afa6-E1231 23:59:59_\t_","output":{"output":"cus_ABCDEFGHIJKLMN {{REDACTED}}:,,İstanbul ::1_a\\nbdeadbeef=toString 2001:db8::1.abc3fa85f64-5717-4562-b3fc-2c963f66afa6-E1231 23:59:59_\t_","piiReplacements":1}},{"input":"/api/users/12345/orders/987,b.api.example.com\"debug @","output":{"output":"/api/users/12345/orders/987,b.api.example.com\"debug @","piiReplacements":0}},{"input":"deadbeef12/ :xoxb-12345-:","output":{"output":"deadbeef12/ :xoxb-12345-:","piiReplacements":0}},{"input":"INFO .{,W1301 10:00:[email protected][email protected] 0xDEADbeef\"token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig.4294967294\n","output":{"output":"INFO .{,W1301 10:00:{{REDACTED}}[email protected] 0xDEADbeef\"token={{REDACTED}}.4294967294\n","piiReplacements":2}},{"input":"Wed Jan 15 10:00:00 UTC [email protected]:","output":{"output":"Wed Jan 15 10:00:00 UTC [email protected]:","piiReplacements":0}},{"input":"AKIAA1B2C3D4E5F6G7H8/api.example.com.0xDEADbeef.Bearer\u000bab\"\"İstanbul=__proto__\\ /","output":{"output":"{{REDACTED}}/api.example.com.0xDEADbeef.Bearer\u000bab\"\"İstanbul=__proto__\\ /","piiReplacements":1}},{"input":"\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@","output":{"output":"\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@\r\n7@","piiReplacements":0}},{"input":"W1301 10:00:00\n2025-01-15T10:00:00.123Z.١٢٣-/api/users/12345/orders/987.2025-01-15T10:00:00.123Z\"deadbeef12 ","output":{"output":"W1301 10:00:00\n2025-01-15T10:00:00.123Z.١٢٣-/api/users/12345/orders/987.2025-01-15T10:00:00.123Z\"deadbeef12 ","piiReplacements":0}},{"input":" =","output":{"output":" =","piiReplacements":0}},{"input":"::1@true POST\"1e400 12 _ ghp_0123456789abcdefghij0123456789abcdef _\",true\"","output":{"output":"::1@true POST\"1e400 12 _ {{REDACTED}} _\",true\"","piiReplacements":1}},{"input":"a.1_00012_10.0.0.256=aes_128:\t\n-1e400@é12xoxb-12345-.","output":{"output":"a.1_00012_10.0.0.256=aes_128:\t\n-1e400@é12xoxb-12345-.","piiReplacements":0}},{"input":"eyJabcdefghijk.abcd.\n鲭event 🚀 /deadbeef ,Dž é /x 3fa85f64-5717-4562-b3fc-2c963f66afa6 ,]/::1:INFO/","output":{"output":"{{REDACTED}}\n鲭event 🚀 /deadbeef ,Dž é /x 3fa85f64-5717-4562-b3fc-2c963f66afa6 ,]/::1:INFO/","piiReplacements":1}},{"input":"E1231 23:59:59xoxb-1234567890-abc\n12345678\"0.1🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀/12345678_","output":{"output":"E1231 23:59:59xoxb-1234567890-abc\n12345678\"0.1🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀/12345678_","piiReplacements":0}},{"input":"🚀.host-1.internalWed Jan 15 10:00:00 UTC 2025 fatal 12345678=🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀=I0827 11:39:40.307946 -100 ,Dž\n\",","output":{"output":"🚀.host-1.internalWed Jan 15 10:00:00 UTC 2025 fatal 12345678=🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀=I0827 11:39:40.307946 -100 ,Dž\n\",","piiReplacements":0}},{"input":"user_A1b2\"\t,E1231 23:59:59\n","output":{"output":"user_A1b2\"\t,E1231 23:59:59\n","piiReplacements":0}},{"input":"host-1.internal,3fa85f64-5717-4562-b3fc-2c963f66afa6,user_123.5 =Bearer\u000bab 9007199254740993-user [email protected] logged in/ΣΑΣ ","output":{"output":"host-1.internal,3fa85f64-5717-4562-b3fc-2c963f66afa6,user_123.5 =Bearer\u000bab 9007199254740993-user {{REDACTED}} logged in/ΣΑΣ ","piiReplacements":1}},{"input":"I0827 11:39:40.307946\[email protected]\nDž\nERROR -deploy.sh@2025-01-15 10:00:00,123+0100\"{\"a\":1} @é@example.com ","output":{"output":"I0827 11:39:40.307946\[email protected]\nDž\nERROR -deploy.sh@2025-01-15 10:00:00,123+0100\"{\"a\":1} @é@example.com ","piiReplacements":0}},{"input":"user [email protected] logged in@日本 [email protected]/}_/api/users/12345/orders/987:debug -::1=","output":{"output":"user {{REDACTED}} logged in@日本 ={{REDACTED}}/}_/api/users/12345/orders/987:debug -::1=","piiReplacements":2}},{"input":"/api/users/12345/orders/987-eyJabcdefghijk.abcd.-","output":{"output":"/api/users/12345/orders/987-{{REDACTED}}","piiReplacements":1}},{"input":"message =W1301 10:00:00:12345678-日本語3fa85f64-5717-4562-b3fc-2c963f66afa6/a,user_A1b2_AKIAA1B2C3D4E5F6G7H8/user [email protected] logged in0xDEADbeef:","output":{"output":"message =W1301 10:00:00:12345678-日本語3fa85f64-5717-4562-b3fc-2c963f66afa6/a,user_A1b2_AKIAA1B2C3D4E5F6G7H8/user {{REDACTED}} logged in0xDEADbeef:","piiReplacements":1}},{"input":"xoxp-1234567890\"valueOfxoxb-1234567890-abc \[email protected]🚀 Dž\"token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig/","output":{"output":"{{REDACTED}}\"valueOfxoxb-1234567890-abc \[email protected]🚀 Dž\"token={{REDACTED}}/","piiReplacements":2}},{"input":"eyJabcdefghijk.abcd.\n\r\n@ _{\"a\":1}.","output":{"output":"{{REDACTED}}\n\r\n@ _{\"a\":1}.","piiReplacements":1}},{"input":"gho_short=12345678\"Bearer\u000bab\nwarn=3fa85f64-5717-4562-b3fc-2c963f66afa6=1e-7 \".","output":{"output":"gho_short=12345678\"Bearer\u000bab\nwarn=3fa85f64-5717-4562-b3fc-2c963f66afa6=1e-7 \".","piiReplacements":0}},{"input":"1e+21🚀-ms=12.s[email protected]🚀/999.9999999 -Infinity ,uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6 \"fi:","output":{"output":"1e+21🚀-ms=12.{{REDACTED}}@y.z🚀/999.9999999 -Infinity ,uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6 \"fi:","piiReplacements":1}},{"input":"1-E1231 23:59:59-INFO _","output":{"output":"1-E1231 23:59:59-INFO _","piiReplacements":0}},{"input":"2025-01-15T10:00:00Z ,a\\nb/Jan 5 10:00:00@/api/users/12345/orders/987@4111 1111 1111 1111:deadbeef12=__proto__\u000b\ngho_short/","output":{"output":"2025-01-15T10:00:00Z ,a\\nb/Jan 5 10:00:00@/api/users/12345/orders/987@4111 1111 1111 1111:deadbeef12=__proto__\u000b\ngho_short/","piiReplacements":0}},{"input":"12/libssl.so:192.168.001.001\njob_12345/[email protected],Bearer\tabc,2001:db8::1. aes_128/10.0.0.256:4111 1111 1111 1111,","output":{"output":"12/libssl.so:192.168.001.001\njob_12345/[email protected],Bearer {{REDACTED}},2001:db8::1. aes_128/10.0.0.256:4111 1111 1111 1111,","piiReplacements":1}},{"input":"cus_ABCDEFGHIJKLMN. 12 /api/v1/users/123","output":{"output":"cus_ABCDEFGHIJKLMN. 12 /api/v1/users/123","piiReplacements":0}},{"input":"Bearer\tabc_2001:db8::1 12 [email protected],Bearer\tabc\n\r\[email protected],user [email protected] logged in\n","output":{"output":"Bearer {{REDACTED}}:db8::1 12 [email protected],Bearer {{REDACTED}}\n\r\n{{REDACTED}},user {{REDACTED}} logged in\n","piiReplacements":4}},{"input":"POST _ΣΑΣ/15/Jan/2025:10:00:00 +0000:full -192.168.1.13fa85f64-5717-4562-b3fc-2c963f66afa6=I0827 11:39:40.307946-ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1:","output":{"output":"POST _ΣΑΣ/15/Jan/2025:10:00:00 +0000:full -192.168.1.13fa85f64-5717-4562-b3fc-2c963f66afa6=I0827 11:39:40.307946-{{REDACTED}}:","piiReplacements":1}},{"input":"hasOwnPropertyBearer\tabc:日本-١٢٣\"15/Jan/2025:10:00:00 +0000 12.5abc [1,2]full-١٢٣-W1301 10:00:00\nJan 5 10:00:00 ","output":{"output":"hasOwnPropertyBearer {{REDACTED}}:日本-١٢٣\"15/Jan/2025:10:00:00 +0000 12.5abc [1,2]full-١٢٣-W1301 10:00:00\nJan 5 10:00:00 ","piiReplacements":1}},{"input":"straße\[email protected]🚀\"sk_live_0123456789abcdefghijkl .api.example.com\"","output":{"output":"straße\[email protected]🚀\"{{REDACTED}} .api.example.com\"","piiReplacements":1}},{"input":"\r\n,\tfi=ASIA0000000000000000X.","output":{"output":"\r\n,\tfi=ASIA0000000000000000X.","piiReplacements":0}},{"input":"_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6@I0827 11:39:40.307946@BEARER Kabc_","output":{"output":"_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6@I0827 11:39:40.307946@Bearer {{REDACTED}}","piiReplacements":1}},{"input":"Dž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\n","output":{"output":"Dž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\nDž\n","piiReplacements":0}},{"input":"Bearer\tabc,2025-01-15T10:00:00Z/[email protected][email protected]🚀/","output":{"output":"Bearer {{REDACTED}},2025-01-15T10:00:00Z/{{REDACTED}}[email protected]🚀/","piiReplacements":2}},{"input":"\u000b :١٢٣_100_","output":{"output":"\u000b :١٢٣_100_","piiReplacements":0}},{"input":"Bearer\tabc}sub_Abcdefghijklmnopqrstuvwx.7 日本\"gho_shorteyJabcdefghijk.abcd.,Bearer\tabc@3fa85f64-5717-4562-b3fc-2c963f66afa6-12345678\n","output":{"output":"Bearer {{REDACTED}}}sub_Abcdefghijklmnopqrstuvwx.7 日本\"gho_shorteyJabcdefghijk.abcd.,Bearer {{REDACTED}}@3fa85f64-5717-4562-b3fc-2c963f66afa6-12345678\n","piiReplacements":2}},{"input":"0.000001 /straße:2025-01-15T10:00:00Z12\"192.168.1.1Infinity /AKIAA1B2C3D4E5F6G7H8.4294967295Wed, 15 Jan 2025 12:00:00 GMT.AKIAA1B2C3D4E5F6G7H8/W1301 10:00:00 ","output":{"output":"0.000001 /straße:2025-01-15T10:00:00Z12\"192.168.1.1Infinity /{{REDACTED}}.4294967295Wed, 15 Jan 2025 12:00:00 GMT.{{REDACTED}}/W1301 10:00:00 ","piiReplacements":2}},{"input":"日本語 / ,","output":{"output":"日本語 / ,","piiReplacements":0}},{"input":"0.000001.a.b@ .\t:ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1/Mon Jan 5 10:00:00 2025@straße.user [email protected] logged in:","output":{"output":"0.000001.a.b@ .\t:{{REDACTED}}/Mon Jan 5 10:00:00 2025@straße.user {{REDACTED}} logged in:","piiReplacements":2}},{"input":"ΣΑΣ-0b11🚀 /","output":{"output":"ΣΑΣ-0b11🚀 /","piiReplacements":0}},{"input":"Jan 5 10:00:00 Mon Jan 5 10:00:00 2025/ghp_0123456789abcdefghij0123456789abcdefmessage\nxoxp-1234567890.é@example.com.xoxp-1234567890_}\nconstructorNaN\nDž:","output":{"output":"Jan 5 10:00:00 Mon Jan 5 10:00:00 2025/{{REDACTED}}\n{{REDACTED}}.é@example.com.xoxp-1234567890_}\nconstructorNaN\nDž:","piiReplacements":2}},{"input":"deploy.sh ","output":{"output":"deploy.sh ","piiReplacements":0}},{"input":"ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1/3fa85f64-5717-4562-b3fc-2c963f66afa6ؒ\n-90071992547409921_000 /","output":{"output":"{{REDACTED}}/3fa85f64-5717-4562-b3fc-2c963f66afa6ؒ\n-90071992547409921_000 /","piiReplacements":1}},{"input":"ȥ.I0827 11:39:40.307946-\r\n/cus_ABCDEFGHIJKLMN ","output":{"output":"ȥ.I0827 11:39:40.307946-\r\n/cus_ABCDEFGHIJKLMN ","piiReplacements":0}},{"input":"10 7@[email protected]@NaN xoxb-12345-=١٢٣:true0x10 :ASIA0000000000000000X\nhost-1.internal 15/Jan/2025:10:00:00 +0000\n","output":{"output":"10 7@{{REDACTED}}@NaN xoxb-12345-=١٢٣:true0x10 :ASIA0000000000000000X\nhost-1.internal 15/Jan/2025:10:00:00 +0000\n","piiReplacements":1}},{"input":"x_12340xDEADbeef.","output":{"output":"x_12340xDEADbeef.","piiReplacements":0}},{"input":"xoxb-12345-.valueOf-5. 5e-324@[email protected]@[email protected],abc3fa85f64-5717-4562-b3fc-2c963f66afa6 straße_fi\"[email protected]:","output":{"output":"xoxb-12345-.valueOf-5. 5e-324@{{REDACTED}}@[email protected],abc3fa85f64-5717-4562-b3fc-2c963f66afa6 straße_fi\"{{REDACTED}}:","piiReplacements":2}},{"input":"İstanbul,é@example.com ","output":{"output":"İstanbul,é@example.com ","piiReplacements":0}},{"input":"ms=12\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé @user_A1b2:api.example.com@[email protected].::1-sub_Abcdefghijklmnopqrstuvwx:POSTBearer abc.def-ghi ","output":{"output":"ms=12\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé @user_A1b2:api.example.com@[email protected].::1-sub_Abcdefghijklmnopqrstuvwx:POSTBearer {{REDACTED}} ","piiReplacements":1}},{"input":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx@\nBearer\tabc\"[email protected]@123@api.example.com:3fa85f64-5717-4562-b3fc-2c963f66afa6:abc3fa85f64-5717-4562-b3fc-2c963f66afa6-🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀AKIAIOSFODNN7EXAMPLE ","output":{"output":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx@\nBearer {{REDACTED}}\"{{REDACTED}}@123@api.example.com:3fa85f64-5717-4562-b3fc-2c963f66afa6:abc3fa85f64-5717-4562-b3fc-2c963f66afa6-🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀{{REDACTED}} ","piiReplacements":3}},{"input":" -\\ user [email protected] logged in.","output":{"output":" -\\ user {{REDACTED}} logged in.","piiReplacements":1}},{"input":"Wed Jan 15 10:00:00 UTC 2025 4111 1111 1111 1111.Jan 5 10:00:00_ /","output":{"output":"Wed Jan 15 10:00:00 UTC 2025 4111 1111 1111 1111.Jan 5 10:00:00_ /","piiReplacements":0}},{"input":"ΣΑΣ\né@example.com\nlibssl.so Wed, 15 Jan 2025 12:00:00 GMT \"x_1234,Jan 5 10:00:00@İstanbul:3fa85f64-5717-4562-b3fc-2c963f66afa6@, libssl.so ","output":{"output":"ΣΑΣ\né@example.com\nlibssl.so Wed, 15 Jan 2025 12:00:00 GMT \"x_1234,Jan 5 10:00:00@İstanbul:3fa85f64-5717-4562-b3fc-2c963f66afa6@, libssl.so ","piiReplacements":0}},{"input":"Dž.AKIAA1B2C3D4E5F6G7H8gho_short:a\\nb@null=sub_Abcdefghijklmnopqrstuvwx.","output":{"output":"Dž.AKIAA1B2C3D4E5F6G7H8gho_short:a\\nb@null=sub_Abcdefghijklmnopqrstuvwx.","piiReplacements":0}},{"input":"İstanbul,_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6\t-deadbeef12/Mon Jan 5 10:00:00 2025\n","output":{"output":"İstanbul,_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6\t-deadbeef12/Mon Jan 5 10:00:00 2025\n","piiReplacements":0}},{"input":"{\"a\":1} ,1_000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:[email protected]","output":{"output":"{\"a\":1} ,1_000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:{{REDACTED}}-","piiReplacements":1}},{"input":"15/Jan/2025:10:00:00 +0000 2025-01-15T10:00:00Z12 ERROR1,5Wed, 15 Jan 2025 10:00:00 GMT ΣΑΣ=","output":{"output":"15/Jan/2025:10:00:00 +0000 2025-01-15T10:00:00Z12 ERROR1,5Wed, 15 Jan 2025 10:00:00 GMT ΣΑΣ=","piiReplacements":0}},{"input":"192.168.001.001/s[email protected].İstanbul@ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1.","output":{"output":"192.168.001.001/s[email protected].İstanbul@{{REDACTED}}.","piiReplacements":1}},{"input":"é12/]\"[email protected]🚀.\t@é@example.com\ncus_ABCDEFGHIJKLMN/Mon Jan 5 10:00:00 2025:_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6-","output":{"output":"é12/]\"[email protected]🚀.\t@é@example.com\ncus_ABCDEFGHIJKLMN/Mon Jan 5 10:00:00 2025:_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6-","piiReplacements":0}},{"input":"straße,sub_Abcdefghijklmnopqrstuvwx\"ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1_s[email protected][email protected] eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123 -","output":{"output":"straße,sub_Abcdefghijklmnopqrstuvwx\"{{REDACTED}}={{REDACTED}} {{REDACTED}} -","piiReplacements":3}},{"input":"𗚈.user_A1b22025-01-15 10:00:00,123+0100bearer x.y-z~+/==/I0827 11:39:40.307946=BEARER Kabc,libssl.so:api.example.comapi.example.com\"𑱹,","output":{"output":"𗚈.user_A1b22025-01-15 10:00:00,123+0100Bearer {{REDACTED}}/I0827 11:39:40.307946=Bearer {{REDACTED}},libssl.so:api.example.comapi.example.com\"𑱹,","piiReplacements":2}},{"input":"deploy.sh\na:","output":{"output":"deploy.sh\na:","piiReplacements":0}},{"input":"ms=12\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀.1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1.sk_test_ZZZZZZZZZZZZZZZZZZZ\n","output":{"output":"ms=12\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀.1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.{{REDACTED}}.sk_test_ZZZZZZZZZZZZZZZZZZZ\n","piiReplacements":1}},{"input":"/ [email protected]_Bearer\[email protected]=éwarnuser_123@[/","output":{"output":"/ [email protected]_Bearer {{REDACTED}}@b.c=éwarnuser_123@[/","piiReplacements":1}},{"input":"abc3fa85f64-5717-4562-b3fc-2c963f66afa6=10.0.0.256 ","output":{"output":"abc3fa85f64-5717-4562-b3fc-2c963f66afa6=10.0.0.256 ","piiReplacements":0}},{"input":"Wed, 15 Jan 2025 10:00:00 GMT=user [email protected] logged in ","output":{"output":"Wed, 15 Jan 2025 10:00:00 GMT=user {{REDACTED}} logged in ","piiReplacements":1}},{"input":"\t E1231 23:59:59.g[email protected],/api/users/12345/orders/987 0.1\"","output":{"output":"\t E1231 23:59:59.{{REDACTED}}@b.c,/api/users/12345/orders/987 0.1\"","piiReplacements":1}},{"input":"user_A1b2/]_192.168.1.1日本語\"I0827 11:39:40.307946@user [email protected] logged in/\\12.5=","output":{"output":"user_A1b2/]_192.168.1.1日本語\"I0827 11:39:40.307946@user {{REDACTED}} logged in/\\12.5=","piiReplacements":1}},{"input":"Bearer\tabc\\user.emailINFO.2025-01-15T10:00:00.123Z/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx :[email protected][email protected]\"","output":{"output":"Bearer {{REDACTED}}\\user.emailINFO.2025-01-15T10:00:00.123Z/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx :{{REDACTED}}={{REDACTED}}\"","piiReplacements":3}},{"input":" @a.3fa85f64-5717-4562-b3fc-2c963f66afa6.","output":{"output":" @a.3fa85f64-5717-4562-b3fc-2c963f66afa6.","piiReplacements":0}},{"input":"[email protected]🚀:\t=Wed, 15 Jan 2025 12:00:00 GMT-1_","output":{"output":"[email protected]🚀:\t=Wed, 15 Jan 2025 12:00:00 GMT-1_","piiReplacements":0}},{"input":"123=","output":{"output":"123=","piiReplacements":0}},{"input":"aes_128.","output":{"output":"aes_128.","piiReplacements":0}},{"input":"host-1.internal/é@example.comE1231 23:59:59=user [email protected] logged in.-9007199254740992 ,user.email _deploy.sh,","output":{"output":"host-1.internal/é@example.comE1231 23:59:59=user {{REDACTED}} logged in.-9007199254740992 ,user.email _deploy.sh,","piiReplacements":1}},{"input":"Wed, 15 Jan 2025 10:00:00 GMT:a __defineGetter__=","output":{"output":"Wed, 15 Jan 2025 10:00:00 GMT:a __defineGetter__=","piiReplacements":0}},{"input":"aes_128\"libssl.so@123","output":{"output":"aes_128\"libssl.so@123","piiReplacements":0}},{"input":"Wed, 15 Jan 2025 10:00:00 GMT/ms=12\"deadbeef12.cus_ABCDEFGHIJKLMN@","output":{"output":"Wed, 15 Jan 2025 10:00:00 GMT/ms=12\"deadbeef12.cus_ABCDEFGHIJKLMN@","piiReplacements":0}},{"input":"Dž/2025-01-15 10:00:00,123+0100@Dž,.5 .","output":{"output":"Dž/2025-01-15 10:00:00,123+0100@Dž,.5 .","piiReplacements":0}},{"input":"Bearer\tabc:","output":{"output":"Bearer {{REDACTED}}:","piiReplacements":1}},{"input":"{\"a\":1}-1.5\" /","output":{"output":"{\"a\":1}-1.5\" /","piiReplacements":0}},{"input":"5..Bearer abc.def-ghi,2025-01-15T10:00:00.123Z","output":{"output":"5..Bearer {{REDACTED}},2025-01-15T10:00:00.123Z","piiReplacements":1}},{"input":" /sk_test_ZZZZZZZZZZZZZZZZZZZ\"} user [email protected] logged in=日本語 .I0827 11:39:40.307946=Wed Jan 15 10:00:00 UTC 2025 ","output":{"output":" /sk_test_ZZZZZZZZZZZZZZZZZZZ\"} user {{REDACTED}} logged in=日本語 .I0827 11:39:40.307946=Wed Jan 15 10:00:00 UTC 2025 ","piiReplacements":1}},{"input":"0b11sk_live_0123456789abcdefghijkl\"::1=[\"é12-010o7.12 @2025-01-15 10:00:00,123+0100\n1e+21error\"","output":{"output":"0b11sk_live_0123456789abcdefghijkl\"::1=[\"é12-010o7.12 @2025-01-15 10:00:00,123+0100\n1e+21error\"","piiReplacements":0}},{"input":"3fa85f64-5717-4562-b3fc-2c963f66afa6","output":{"output":"3fa85f64-5717-4562-b3fc-2c963f66afa6","piiReplacements":0}},{"input":"édebug\"Bearer\tabc=fi,user_A1b2-token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig W1301 10:00:00:","output":{"output":"édebug\"Bearer {{REDACTED}}fi,user_A1b2-token={{REDACTED}} W1301 10:00:00:","piiReplacements":2}},{"input":"Bearer\tabc_AKIAA1B2C3D4E5F6G7H8\nASIA0000000000000000X=Wed, 15 Jan 2025 10:00:00 GMT\"Bearer\tabc ","output":{"output":"Bearer {{REDACTED}}\nASIA0000000000000000X=Wed, 15 Jan 2025 10:00:00 GMT\"Bearer {{REDACTED}} ","piiReplacements":2}},{"input":"{/","output":{"output":"{/","piiReplacements":0}},{"input":"I0827 11:39:40.307946/9007199254740994\ntoken=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig@}=z\"sub_Abcdefghijklmnopqrstuvwx,[.\"\" ,","output":{"output":"I0827 11:39:40.307946/9007199254740994\ntoken={{REDACTED}}@}=z\"sub_Abcdefghijklmnopqrstuvwx,[.\"\" ,","piiReplacements":1}},{"input":"]\n0b11,.5-1e400=/api/users/12345/orders/987\njob_12345/0.1/","output":{"output":"]\n0b11,.5-1e400=/api/users/12345/orders/987\njob_12345/0.1/","piiReplacements":0}},{"input":"\\\"","output":{"output":"\\\"","piiReplacements":0}},{"input":"[email protected]+3082.5e-8}/Bearer\u000bab./api/users/12345/orders/987\":/ţ fatal=日本\n","output":{"output":"[email protected]+3082.5e-8}/Bearer\u000bab./api/users/12345/orders/987\":/ţ fatal=日本\n","piiReplacements":0}},{"input":"I0827 11:39:40.307946@Dž {,straße@}.Bearer abc.def-ghi00 ,","output":{"output":"I0827 11:39:40.307946@Dž {,straße@}.Bearer {{REDACTED}} ,","piiReplacements":1}},{"input":"POST 12:sub_Abcdefghijklmnopqrstuvwx warn -0\"-1.ΣΑΣ=","output":{"output":"POST 12:sub_Abcdefghijklmnopqrstuvwx warn -0\"-1.ΣΑΣ=","piiReplacements":0}},{"input":"3fa85f64-5717-4562-b3fc-2c963f66afa6 aes_128{=deadbeef12/fi\n::1 sk_test_ZZZZZZZZZZZZZZZZZZZ\"deploy.sh./api/v1/users/123","output":{"output":"3fa85f64-5717-4562-b3fc-2c963f66afa6 aes_128{=deadbeef12/fi\n::1 sk_test_ZZZZZZZZZZZZZZZZZZZ\"deploy.sh./api/v1/users/123","piiReplacements":0}},{"input":"192.168.001.001 Dž\n","output":{"output":"192.168.001.001 Dž\n","piiReplacements":0}},{"input":"POST \n\\\"Bearer\tabc@","output":{"output":"POST \n\\\"Bearer {{REDACTED}}@","piiReplacements":1}},{"input":"12AKIAIOSFODNN7EXAMPLE/Wed, 15 Jan 2025 10:00:00 GMT@ms=12@token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig.Bearer\u000bab=١٢٣\n","output":{"output":"12AKIAIOSFODNN7EXAMPLE/Wed, 15 Jan 2025 10:00:00 GMT@ms=12@token={{REDACTED}}.Bearer\u000bab=١٢٣\n","piiReplacements":1}},{"input":"-1e400\nİstanbul-POST@Wed Jan 15 10:00:00 UTC 2025\nAKIAA1B2C3D4E5F6G7H8\nghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1_","output":{"output":"-1e400\nİstanbul-POST@Wed Jan 15 10:00:00 UTC 2025\n{{REDACTED}}\nghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1_","piiReplacements":1}},{"input":"api.example.com=0xDEADbeef.İstanbul:0xDEADbeef\"]:15/Jan/2025:10:00:00 +0000INFOGET-\u000b00,xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \"","output":{"output":"api.example.com=0xDEADbeef.İstanbul:0xDEADbeef\"]:15/Jan/2025:10:00:00 +0000INFOGET-\u000b00,xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \"","piiReplacements":0}},{"input":"3fa85f64-5717-4562-b3fc-2c963f66afa6=","output":{"output":"3fa85f64-5717-4562-b3fc-2c963f66afa6=","piiReplacements":0}},{"input":"::1\n] host-1.internal\"-Infinity @E1231 23:59:59@NaN,","output":{"output":"::1\n] host-1.internal\"-Infinity @E1231 23:59:59@NaN,","piiReplacements":0}},{"input":"2025-01-15T10:00:00.123Z deploy.sh-api.example.com_/api/users/12345/orders/987-123= .192.168.001.001_","output":{"output":"2025-01-15T10:00:00.123Z deploy.sh-api.example.com_/api/users/12345/orders/987-123= .192.168.001.001_","piiReplacements":0}},{"input":"[email protected]🚀 xoxp-1234567890\"deadbeef =eyJabcdefghijk.abcd.@Q ,[email protected][email protected]\"","output":{"output":"[email protected]🚀 {{REDACTED}}\"deadbeef ={{REDACTED}}@Q ,a@{{REDACTED}}\"","piiReplacements":3}},{"input":"debug-15/Jan/2025:10:00:00 +0000:\t,4294967295 a @é@example.com\"12 ,b @job_12345 ","output":{"output":"debug-15/Jan/2025:10:00:00 +0000:\t,4294967295 a @é@example.com\"12 ,b @job_12345 ","piiReplacements":0}},{"input":"ΣΑΣ@BEARER Kabclibssl.so,","output":{"output":"ΣΑΣ@Bearer {{REDACTED}},","piiReplacements":1}},{"input":"12345678@ε Infinity\nJ -1e400 _é12\n4294967295 @","output":{"output":"12345678@ε Infinity\nJ -1e400 _é12\n4294967295 @","piiReplacements":0}},{"input":"sub_Abcdefghijklmnopqrstuvwx_NaNuser_123/[email protected]\"Ր\n-3fa85f64-5717-4562-b3fc-2c963f66afa6 ,ASIA0000000000000000X@","output":{"output":"sub_Abcdefghijklmnopqrstuvwx_NaNuser_123/{{REDACTED}}\"Ր\n-3fa85f64-5717-4562-b3fc-2c963f66afa6 ,ASIA0000000000000000X@","piiReplacements":1}},{"input":"4111 1111 1111 1111/\"@","output":{"output":"4111 1111 1111 1111/\"@","piiReplacements":0}},{"input":"192.168.001.001/1e-7 .E1231 23:59:59.","output":{"output":"192.168.001.001/1e-7 .E1231 23:59:59.","piiReplacements":0}},{"input":"M ,[email protected],ASIA0000000000000000X\n","output":{"output":"M ,[email protected],ASIA0000000000000000X\n","piiReplacements":0}},{"input":"\"\"[email protected]:\\/é@example.com:","output":{"output":"\"\"={{REDACTED}}:\\/é@example.com:","piiReplacements":1}},{"input":"192.168.001.001/ ,xoxb-12345-\"","output":{"output":"192.168.001.001/ ,xoxb-12345-\"","piiReplacements":0}},{"input":"ms=12_","output":{"output":"ms=12_","piiReplacements":0}},{"input":"xoxp-1234567890-ASIA0000000000000000X [email protected]/api.example.com 12ghp_0123456789abcdefghij0123456789abcdef-user_A1b2-fi=message -192.168.1.1\nghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1_","output":{"output":"{{REDACTED}} {{REDACTED}}/api.example.com 12ghp_0123456789abcdefghij0123456789abcdef-user_A1b2-fi=message -192.168.1.1\nghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1_","piiReplacements":2}},{"input":"[email protected]=12345678_","output":{"output":"{{REDACTED}}=12345678_","piiReplacements":1}},{"input":"W1301 10:00:00\"🚀:İstanbul,error 1.5 @0xDEADbeef.+5 .10.0.0.256.null_","output":{"output":"W1301 10:00:00\"🚀:İstanbul,error 1.5 @0xDEADbeef.+5 .10.0.0.256.null_","piiReplacements":0}},{"input":"Mon Jan 5 10:00:00 2025\n}deadbeef12:","output":{"output":"Mon Jan 5 10:00:00 2025\n}deadbeef12:","piiReplacements":0}},{"input":"length/0xDEADbeef\n0x10.fatal /é12\n日本 event @:\"job_12345-libssl.so\"","output":{"output":"length/0xDEADbeef\n0x10.fatal /é12\n日本 event @:\"job_12345-libssl.so\"","piiReplacements":0}},{"input":"-Infinity /ASIA0000000000000000X\n\"@__proto__","output":{"output":"-Infinity /ASIA0000000000000000X\n\"@__proto__","piiReplacements":0}},{"input":"ghp_0123456789abcdefghij0123456789abcdef\n5.\"","output":{"output":"{{REDACTED}}\n5.\"","piiReplacements":1}},{"input":"0.1 constructor gho_short_éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé Infinity@fi@𖬓 =","output":{"output":"0.1 constructor gho_short_éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé Infinity@fi@𖬓 =","piiReplacements":0}},{"input":"\r\n日本 :ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1:?.Bearer abc.def-ghi_","output":{"output":"\r\n日本 :{{REDACTED}}:?.Bearer {{REDACTED}}","piiReplacements":2}},{"input":"straße-eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc1230b11 -15/Jan/2025:10:00:00 +0000:15/Jan/2025:10:00:00 +0000-ΣΑΣ@İstanbul:2025-01-15 10:00:00,123+0100 ","output":{"output":"straße-{{REDACTED}} -15/Jan/2025:10:00:00 +0000:15/Jan/2025:10:00:00 +0000-ΣΑΣ@İstanbul:2025-01-15 10:00:00,123+0100 ","piiReplacements":1}},{"input":"0b11\"9007199254740992/1e400-Infinity.日本語 3fa85f64-5717-4562-b3fc-2c963f66afa6 _ώ .deadbeef12@sk_test_ZZZZZZZZZZZZZZZZZZZ@","output":{"output":"0b11\"9007199254740992/1e400-Infinity.日本語 3fa85f64-5717-4562-b3fc-2c963f66afa6 _ώ .deadbeef12@sk_test_ZZZZZZZZZZZZZZZZZZZ@","piiReplacements":0}},{"input":"AKIAA1B2C3D4E5F6G7H8\[email protected]/user_A1b2=2025-01-15T10:00:00.123Z\nfi@null \"__defineGetter__ 2025-01-15T10:00:00Z0x10__proto__\"ѿ -1.5 -Wed, 15 Jan 2025 10:00:00 GMT_","output":{"output":"{{REDACTED}}\n{{REDACTED}}/user_A1b2=2025-01-15T10:00:00.123Z\nfi@null \"__defineGetter__ 2025-01-15T10:00:00Z0x10__proto__\"ѿ -1.5 -Wed, 15 Jan 2025 10:00:00 GMT_","piiReplacements":2}},{"input":"ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1.𐀀-1.5.","output":{"output":"{{REDACTED}}.𐀀-1.5.","piiReplacements":1}},{"input":"3fa85f64-5717-4562-b3fc-2c963f66afa6/api/v1/users/123,\\","output":{"output":"3fa85f64-5717-4562-b3fc-2c963f66afa6/api/v1/users/123,\\","piiReplacements":0}},{"input":"deadbeef12- 12 -","output":{"output":"deadbeef12- 12 -","piiReplacements":0}},{"input":"2025-01-15 10:00:00,123+0100_api.example.com,host-1.internal-192.168.001.001/xoxb-1234567890-abc warn -192.168.1.1 _2025-01-15 10:00:00,123+0100/[email protected]🚀[email protected]/deploy.sh@","output":{"output":"2025-01-15 10:00:00,123+0100_api.example.com,host-1.internal-192.168.001.001/{{REDACTED}} warn -192.168.1.1 _2025-01-15 10:00:00,123+0100/[email protected]🚀-{{REDACTED}}/deploy.sh@","piiReplacements":2}},{"input":",=10.0.0.256=2025-01-15T10:00:00.123Z\nΣΑΣ[email protected]🚀,deploy.sh_","output":{"output":",=10.0.0.256=2025-01-15T10:00:00.123Z\nΣΑΣ[email protected]🚀,deploy.sh_","piiReplacements":0}},{"input":"gho_short-abc3fa85f64-5717-4562-b3fc-2c963f66afa6_0xDEADbeef:","output":{"output":"gho_short-abc3fa85f64-5717-4562-b3fc-2c963f66afa6_0xDEADbeef:","piiReplacements":0}},{"input":"user_A1b2.\\\t 15/Jan/2025:10:00:00 +0000:E1231 23:59:59\n\"quoted\":}=-1 ,1e+213fa85f64-5717-4562-b3fc-2c963f66afa6 🚀,","output":{"output":"user_A1b2.\\\t 15/Jan/2025:10:00:00 +0000:E1231 23:59:59\n\"quoted\":}=-1 ,1e+213fa85f64-5717-4562-b3fc-2c963f66afa6 🚀,","piiReplacements":0}},{"input":"Wed, 15 Jan 2025 10:00:00 GMT:\\-Wed Jan 15 10:00:00 UTC 2025/sk_live_aaaaaaaaaaaaaaaaaaaaaaaa\"Bearer\u000bab./api/v1/users/1233fa85f64-5717-4562-b3fc-2c963f66afa6_deadbeef12,","output":{"output":"Wed, 15 Jan 2025 10:00:00 GMT:\\-Wed Jan 15 10:00:00 UTC 2025/{{REDACTED}}\"Bearer\u000bab./api/v1/users/1233fa85f64-5717-4562-b3fc-2c963f66afa6_deadbeef12,","piiReplacements":1}},{"input":"1e-7\ngho_short ΣΑΣ_[\nlibssl.so\"/api/users/12345/orders/987: _2.5e-80.000001\"日本:","output":{"output":"1e-7\ngho_short ΣΑΣ_[\nlibssl.so\"/api/users/12345/orders/987: _2.5e-80.000001\"日本:","piiReplacements":0}},{"input":"[email protected]🚀:bearer x.y-z~+/==,Wed, 15 Jan 2025 10:00:00 GMT.123456789012345680000 .5\nfi_straße E1231 23:59:59/","output":{"output":"[email protected]🚀:Bearer {{REDACTED}},Wed, 15 Jan 2025 10:00:00 GMT.123456789012345680000 .5\nfi_straße E1231 23:59:59/","piiReplacements":1}},{"input":"192.168.001.001/eyJabcdefghijk.abcd.Wed Jan 15 10:00:00 UTC 2025123\"192.168.001.001 [email protected]\ntoken=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig,x_1234:gho_short.","output":{"output":"192.168.001.001/{{REDACTED}} Jan 15 10:00:00 UTC 2025123\"192.168.001.001 [email protected]\ntoken={{REDACTED}},x_1234:gho_short.","piiReplacements":2}},{"input":"a_0b11http.method/I0827 11:39:40.307946\[email protected]🚀@12345678.","output":{"output":"a_0b11http.method/I0827 11:39:40.307946\[email protected]🚀@12345678.","piiReplacements":0}},{"input":" 12=🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀12.5abc \nabc3fa85f64-5717-4562-b3fc-2c963f66afa6\n[@straße:","output":{"output":" 12=🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀12.5abc \nabc3fa85f64-5717-4562-b3fc-2c963f66afa6\n[@straße:","piiReplacements":0}},{"input":"token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig\naes_128 192.168.001.001 -Infinity \nASIA0000000000000000X-,\"Wed Jan 15 10:00:00 UTC 2025,\r\n :\n","output":{"output":"token={{REDACTED}}\naes_128 192.168.001.001 -Infinity \nASIA0000000000000000X-,\"Wed Jan 15 10:00:00 UTC 2025,\r\n :\n","piiReplacements":1}},{"input":"I0827 11:39:40.307946@","output":{"output":"I0827 11:39:40.307946@","piiReplacements":0}},{"input":"BEARER Kabc\"? 192.168.001.001@12345678Infinity/aes_128 Jan 5 10:00:00 _","output":{"output":"Bearer {{REDACTED}}\"? 192.168.001.001@12345678Infinity/aes_128 Jan 5 10:00:00 _","piiReplacements":1}},{"input":"123/true 1e+21/job_12345@\r\n/🚀\"::1_","output":{"output":"123/true 1e+21/job_12345@\r\n/🚀\"::1_","piiReplacements":0}},{"input":"cus_ABCDEFGHIJKLMN\"api.example.com@deadbeef /","output":{"output":"cus_ABCDEFGHIJKLMN\"api.example.com@deadbeef /","piiReplacements":0}},{"input":"0b11/api/v1/users/123 -","output":{"output":"0b11/api/v1/users/123 -","piiReplacements":0}},{"input":"123\"[1,2]@\\\nstraße:١٢٣@ghp_0123456789abcdefghij0123456789abcdefeyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123@]@","output":{"output":"123\"[1,2]@\\\nstraße:١٢٣@{{REDACTED}}.eyJzdWIiOiIxIn0.abc123@]@","piiReplacements":1}},{"input":"ASIA0000000000000000X@ 12 -","output":{"output":"ASIA0000000000000000X@ 12 -","piiReplacements":0}},{"input":"12345678@Infinity [email protected]_0@3fa85f64-5717-4562-b3fc-2c963f66afa60xDEADbeef-","output":{"output":"12345678@Infinity [email protected]_0@3fa85f64-5717-4562-b3fc-2c963f66afa60xDEADbeef-","piiReplacements":0}},{"input":"Mon Jan 5 10:00:00 2025 10.0.0.256:xoxp-1234567890Bearer\u000bab@Wed, 15 Jan 2025 10:00:00 GMT=","output":{"output":"Mon Jan 5 10:00:00 2025 10.0.0.256:{{REDACTED}}\u000bab@Wed, 15 Jan 2025 10:00:00 GMT=","piiReplacements":1}},{"input":"straße\"[email protected] ١٢٣\n12345678@\t,🚀-","output":{"output":"straße\"{{REDACTED}} ١٢٣\n12345678@\t,🚀-","piiReplacements":1}},{"input":" /\r\n日本\"eyJabcdefghijk.abcd. 2025-01-15T10:00:00.123Z\"sub_Abcdefghijklmnopqrstuvwx\nbearer x.y-z~+/==Infinity2025-01-15T10:00:00Z.,=ASIA0000000000000000X\n","output":{"output":" /\r\n日本\"{{REDACTED}} 2025-01-15T10:00:00.123Z\"sub_Abcdefghijklmnopqrstuvwx\nBearer {{REDACTED}}Infinity2025-01-15T10:00:00Z.,=ASIA0000000000000000X\n","piiReplacements":2}},{"input":"é12/xoxp-1234567890=\\:ΣΑΣ\n","output":{"output":"é12/{{REDACTED}}=\\:ΣΑΣ\n","piiReplacements":1}},{"input":"] \"@user_A1b2. /429496729512.5abc \"\t:job_12345@","output":{"output":"] \"@user_A1b2. /429496729512.5abc \"\t:job_12345@","piiReplacements":0}},{"input":"/api/users/12345/orders/987\"1.7976931348623157e+308 \neyJabcdefghijk.abcd.-ΣΑΣ,1.7976931348623157e+3081e3 12 :NaNK:הconstructor\"","output":{"output":"/api/users/12345/orders/987\"1.7976931348623157e+308 \n{{REDACTED}}ΣΑΣ,1.7976931348623157e+3081e3 12 :NaNK:הconstructor\"","piiReplacements":1}},{"input":"fi/é@example.com\ngho_short-","output":{"output":"fi/é@example.com\ngho_short-","piiReplacements":0}},{"input":"I0827 11:39:40.307946\nİstanbul@}=eyJabcdefghijk.abcd.-","output":{"output":"I0827 11:39:40.307946\nİstanbul@}={{REDACTED}}","piiReplacements":1}},{"input":"3fa85f64-5717-4562-b3fc-2c963f66afa6-fi@L 9007199254740992\"192.168.001.001=sk_live_aaaaaaaaaaaaaaaaaaaaaaaa,host-1.internal","output":{"output":"3fa85f64-5717-4562-b3fc-2c963f66afa6-fi@L 9007199254740992\"192.168.001.001={{REDACTED}},host-1.internal","piiReplacements":1}},{"input":"W1301 10:00:00,192.168.001.001:4111 1111 1111 1111@1,5 𒀑=host-1.internal@日本 3fa85f64-5717-4562-b3fc-2c963f66afa6@","output":{"output":"W1301 10:00:00,192.168.001.001:4111 1111 1111 1111@1,5 𒀑=host-1.internal@日本 3fa85f64-5717-4562-b3fc-2c963f66afa6@","piiReplacements":0}},{"input":"Wed, 15 Jan 2025 10:00:00 GMT\n123456789012345680000_10event-","output":{"output":"Wed, 15 Jan 2025 10:00:00 GMT\n123456789012345680000_10event-","piiReplacements":0}},{"input":"POST-1.5-BEARER Kabc\"BEARER Kabc0x10 ,a -1e400 \nWed Jan 15 10:00:00 UTC 2025","output":{"output":"POST-1.5-Bearer {{REDACTED}}\"Bearer {{REDACTED}} ,a -1e400 \nWed Jan 15 10:00:00 UTC 2025","piiReplacements":2}},{"input":"I0827 11:39:40.307946\n1e3=3fa85f64-5717-4562-b3fc-2c963f66afa6_xoxb-12345-/é12@Ȉ1e+100.","output":{"output":"I0827 11:39:40.307946\n1e3=3fa85f64-5717-4562-b3fc-2c963f66afa6_xoxb-12345-/é12@Ȉ1e+100.","piiReplacements":0}},{"input":"a\\nb3fa85f64-5717-4562-b3fc-2c963f66afa6/","output":{"output":"a\\nb3fa85f64-5717-4562-b3fc-2c963f66afa6/","piiReplacements":0}},{"input":"xoxb-12345-x_1234\"10.0.0.256\n2001:db8::1 _Jan 5 10:00:00/","output":{"output":"xoxb-12345-x_1234\"10.0.0.256\n2001:db8::1 _Jan 5 10:00:00/","piiReplacements":0}},{"input":"BEARER Kabc=.54294967296\n","output":{"output":"Bearer {{REDACTED}}.54294967296\n","piiReplacements":1}},{"input":".5 _1e3_2025-01-15T10:00:00.123Z@:=ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1.","output":{"output":".5 _1e3_2025-01-15T10:00:00.123Z@:={{REDACTED}}.","piiReplacements":1}},{"input":"\"-15/Jan/2025:10:00:00 +0000=x [email protected]🚀straße=","output":{"output":"\"-15/Jan/2025:10:00:00 +0000=x [email protected]🚀straße=","piiReplacements":0}},{"input":"Bearer\tabc@Wed, 15 Jan 2025 10:00:00 GMT_1_000,1e+1004294967295-:","output":{"output":"Bearer {{REDACTED}}@Wed, 15 Jan 2025 10:00:00 GMT_1_000,1e+1004294967295-:","piiReplacements":1}},{"input":"\nsk_test_ZZZZZZZZZZZZZZZZZZZ@AKIAIOSFODNN7EXAMPLE 噺,0b11_70x10_","output":{"output":"\nsk_test_ZZZZZZZZZZZZZZZZZZZ@{{REDACTED}} 噺,0b11_70x10_","piiReplacements":1}},{"input":"123/bearer x.y-z~+/== [email protected]@\\\" :日本語2001:db8::[email protected] x_1234/","output":{"output":"123/Bearer {{REDACTED}} [email protected]@\\\" :日本語2001:db8::[email protected] x_1234/","piiReplacements":1}},{"input":"Bearer abc.def-ghi ,","output":{"output":"Bearer {{REDACTED}} ,","piiReplacements":1}},{"input":"sk_test_ZZZZZZZZZZZZZZZZZZZ_token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig@AKIAA1B2C3D4E5F6G7H8\"api.example.com \r\n 2025-01-15T10:00:00.123Z:","output":{"output":"sk_test_ZZZZZZZZZZZZZZZZZZZ_token={{REDACTED}}@{{REDACTED}}\"api.example.com \r\n 2025-01-15T10:00:00.123Z:","piiReplacements":2}},{"input":"length\\-user [email protected] logged in_ᛊ /","output":{"output":"length\\-user {{REDACTED}} logged in_ᛊ /","piiReplacements":1}},{"input":"debug\"Bearer\u000bab@","output":{"output":"debug\"Bearer\u000bab@","piiReplacements":0}},{"input":"12345678,1e+21.{\"a\":1}\n.. =12 \n0=Wed, 15 Jan 2025 10:00:00 GMT-E1231 23:59:59, -0\"","output":{"output":"12345678,1e+21.{\"a\":1}\n.. =12 \n0=Wed, 15 Jan 2025 10:00:00 GMT-E1231 23:59:59, -0\"","piiReplacements":0}},{"input":"Jan 5 10:00:00\"2025-01-15T10:00:00.123Z/12345678=\":🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀1e400\"ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1\n","output":{"output":"Jan 5 10:00:00\"2025-01-15T10:00:00.123Z/12345678=\":🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀1e400\"{{REDACTED}}\n","piiReplacements":1}},{"input":"x_1234-user_A1b2_12 straßeBearer\u000bab ","output":{"output":"x_1234-user_A1b2_12 straßeBearer\u000bab ","piiReplacements":0}},{"input":"deadbeef12 [/éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé� Bearer\u000bab.E1231 23:59:59/ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1.","output":{"output":"deadbeef12 [/éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé� Bearer\u000bab.E1231 23:59:59/{{REDACTED}}.","piiReplacements":1}},{"input":"\t_ΣΑΣ 0x10 \n15/Jan/2025:10:00:00 +0000:user [email protected] logged in.é,W1301 10:00:00_","output":{"output":"\t_ΣΑΣ 0x10 \n15/Jan/2025:10:00:00 +0000:user {{REDACTED}} logged in.é,W1301 10:00:00_","piiReplacements":1}},{"input":"\"quoted\" 12 /sub_Abcdefghijklmnopqrstuvwx@bearer x.y-z~+/==/[email protected][email protected] \n]-","output":{"output":"\"quoted\" 12 /sub_Abcdefghijklmnopqrstuvwx@Bearer {{REDACTED}}/[email protected]={{REDACTED}}.- \n]-","piiReplacements":2}},{"input":"é@example.com=null.2025-01-15T10:00:00.123Z/fi ASIA0000000000000000X=١٢٣:١٢٣/api/users/12345/orders/987@","output":{"output":"é@example.com=null.2025-01-15T10:00:00.123Z/fi ASIA0000000000000000X=١٢٣:١٢٣/api/users/12345/orders/987@","piiReplacements":0}},{"input":"AKIAA1B2C3D4E5F6G7H8xoxp-1234567890\"/api/users/12345/orders/987\"gho_short:_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6@abc3fa85f64-5717-4562-b3fc-2c963f66afa6_::-","output":{"output":"AKIAA1B2C3D4E5F6G7H8xoxp-1234567890\"/api/users/12345/orders/987\"gho_short:_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6@abc3fa85f64-5717-4562-b3fc-2c963f66afa6_::-","piiReplacements":0}},{"input":"x_1234,a.@١٢٣-忳 \t _\r\n彶 日本","output":{"output":"x_1234,a.@١٢٣-忳 \t _\r\n彶 日本","piiReplacements":0}},{"input":"[email protected]=192.168.001.001 length,[email protected]🚀 ","output":{"output":"{{REDACTED}}=192.168.001.001 length,[email protected]🚀 ","piiReplacements":1}},{"input":"é_user_A1b2/[email protected]\nMon Jan 5 10:00:00 2025@,.","output":{"output":"é_user_A1b2/{{REDACTED}}\nMon Jan 5 10:00:00 2025@,.","piiReplacements":1}},{"input":"🚀user_A1b2-api.example.com ][email protected]_12345/gho_short\"Bearer\u000bab=Bearer abc.def-ghi ","output":{"output":"🚀user_A1b2-api.example.com ][email protected]_12345/gho_short\"Bearer\u000bab=Bearer {{REDACTED}} ","piiReplacements":1}},{"input":"AKIAIOSFODNN7EXAMPLE1e+100 -cus_ABCDEFGHIJKLMN/","output":{"output":"AKIAIOSFODNN7EXAMPLE1e+100 -cus_ABCDEFGHIJKLMN/","piiReplacements":0}},{"input":"🚀@12345678={/\r\n\"","output":{"output":"🚀@12345678={/\r\n\"","piiReplacements":0}},{"input":"sk_test_ZZZZZZZZZZZZZZZZZZZ\ndeploy.sh\nxoxp-1234567890:I0827 11:39:40.307946.[:fi\ngho_short12345678\n🚀-","output":{"output":"sk_test_ZZZZZZZZZZZZZZZZZZZ\ndeploy.sh\n{{REDACTED}}:I0827 11:39:40.307946.[:fi\ngho_short12345678\n🚀-","piiReplacements":1}},{"input":"\t\" user [email protected] logged in.","output":{"output":"\t\" user {{REDACTED}} logged in.","piiReplacements":1}},{"input":"AKIAA1B2C3D4E5F6G7H8job_12345 constructor,Mon Jan 5 10:00:00 2025\"cus_ABCDEFGHIJKLMN.]Bearer\tabc//api/users/12345/orders/987\"","output":{"output":"AKIAA1B2C3D4E5F6G7H8job_12345 constructor,Mon Jan 5 10:00:00 2025\"cus_ABCDEFGHIJKLMN.]Bearer {{REDACTED}}\"","piiReplacements":1}},{"input":"valueOf F [email protected]🚀:\"quoted\"@Jan 5 10:00:00.é12","output":{"output":"valueOf F [email protected]🚀:\"quoted\"@Jan 5 10:00:00.é12","piiReplacements":0}},{"input":"W1301 10:00:00=[:deploy.sh,sub_Abcdefghijklmnopqrstuvwx,é12=[_ڋevent/Ϊ 12345678\"","output":{"output":"W1301 10:00:00=[:deploy.sh,sub_Abcdefghijklmnopqrstuvwx,é12=[_ڋevent/Ϊ 12345678\"","piiReplacements":0}},{"input":"-0:[email protected] 12,","output":{"output":"-0:[email protected] 12,","piiReplacements":0}},{"input":"ghp_0123456789abcdefghij0123456789abcdef Bearer abc.def-ghieyJabcdefghijk.abcd.\r\n/","output":{"output":"{{REDACTED}} Bearer {{REDACTED}}\r\n/","piiReplacements":2}},{"input":"user_A1b2@İstanbul123456789012345680000\naes_128\"{-INFO-{-_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=","output":{"output":"user_A1b2@İstanbul123456789012345680000\naes_128\"{-INFO-{-_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=","piiReplacements":0}},{"input":"Mon Jan 5 10:00:00 2025.15/Jan/2025:10:00:00 +0000\nuser_A1b2@xoxb-1234567890-abc=ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1_}\"","output":{"output":"Mon Jan 5 10:00:00 2025.15/Jan/2025:10:00:00 +0000\nuser_A1b2@{{REDACTED}}=ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1_}\"","piiReplacements":1}},{"input":"\\.job_12345/::[email protected] /日本.]\"_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6:","output":{"output":"\\.job_12345/::{{REDACTED}} /日本.]\"_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6:","piiReplacements":1}},{"input":"{/error{\"a\":1}@𗼔.1e+10012.5abc-Wed, 15 Jan 2025 10:00:00 GMT,9007199254740992\n🚀\nfi-Wed Jan 15 10:00:00 UTC 2025_","output":{"output":"{/error{\"a\":1}@𗼔.1e+10012.5abc-Wed, 15 Jan 2025 10:00:00 GMT,9007199254740992\n🚀\nfi-Wed Jan 15 10:00:00 UTC 2025_","piiReplacements":0}},{"input":"deadbeef12.Wed, 15 Jan 2025 10:00:00 GMT\ngho_short:Mon Jan 5 10:00:00 2025/0xDEADbeef\"0o7 :[email protected]\"123,Dž,","output":{"output":"deadbeef12.Wed, 15 Jan 2025 10:00:00 GMT\ngho_short:Mon Jan 5 10:00:00 2025/0xDEADbeef\"0o7 :{{REDACTED}}\"123,Dž,","piiReplacements":1}},{"input":"xoxp-1234567890\nuser_A1b2:@","output":{"output":"{{REDACTED}}\nuser_A1b2:@","piiReplacements":1}},{"input":"Mon Jan 5 10:00:00 2025,[:aes_128@1e300 \n{_ٝ /api/v1/users/123,[email protected]@Infinity12345678 ","output":{"output":"Mon Jan 5 10:00:00 2025,[:aes_128@1e300 \n{_ٝ /api/v1/users/123,{{REDACTED}}@Infinity12345678 ","piiReplacements":1}},{"input":".5192.168.0.1,[email protected]🚀-ASIA0000000000000000X,Wed, 15 Jan 2025 12:00:00 GMT\n2.5e-8\nASIA0000000000000000X\n,/[.\"quoted\":\r\nﻟ _","output":{"output":".5192.168.0.1,[email protected]🚀-ASIA0000000000000000X,Wed, 15 Jan 2025 12:00:00 GMT\n2.5e-8\nASIA0000000000000000X\n,/[.\"quoted\":\r\nﻟ _","piiReplacements":0}},{"input":"token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig🚀,AKIAA1B2C3D4E5F6G7H8-}\n, user [email protected] logged in\n15/Jan/2025:10:00:00 +0000/W1301 10:00:00=","output":{"output":"token={{REDACTED}}🚀,{{REDACTED}}-}\n, user {{REDACTED}} logged in\n15/Jan/2025:10:00:00 +0000/W1301 10:00:00=","piiReplacements":3}},{"input":"15/Jan/2025:10:00:00 +0000-2001:db8::1/ms=12_˖xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx@é12,fi\[email protected] /","output":{"output":"15/Jan/2025:10:00:00 +0000-2001:db8::1/ms=12_˖xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx@é12,fi\n{{REDACTED}} /","piiReplacements":1}},{"input":"debug \n/api/users/12345/orders/987,:","output":{"output":"debug \n/api/users/12345/orders/987,:","piiReplacements":0}},{"input":"\\valueOf\n}GETGET POST,libssl.so deploy.sh.INFO01\"bearer x.y-z~+/==\"日本\n","output":{"output":"\\valueOf\n}GETGET POST,libssl.so deploy.sh.INFO01\"Bearer {{REDACTED}}\"日本\n","piiReplacements":1}},{"input":"Mon Jan 5 10:00:00 2025\nJan 5 10:00:00@warn-Infinity,日本\n\r\n-0.30000000000000004🚀\n12345678\n","output":{"output":"Mon Jan 5 10:00:00 2025\nJan 5 10:00:00@warn-Infinity,日本\n\r\n-0.30000000000000004🚀\n12345678\n","piiReplacements":0}},{"input":"\"error Bearer\tabc@","output":{"output":"\"error Bearer {{REDACTED}}@","piiReplacements":1}},{"input":"]-냽 ~-","output":{"output":"]-냽 ~-","piiReplacements":0}},{"input":"Dž_\t.","output":{"output":"Dž_\t.","piiReplacements":0}},{"input":"xoxp-1234567890-","output":{"output":"{{REDACTED}}-","piiReplacements":1}},{"input":"x_1234/İstanbul:aes_128@xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n","output":{"output":"x_1234/İstanbul:aes_128@xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n","piiReplacements":0}},{"input":"[\"١٢٣ms=12_🚀-192.168.0.1 /deploy.sh_\r\n@ư\"\\\"token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig,","output":{"output":"[\"١٢٣ms=12_🚀-192.168.0.1 /deploy.sh_\r\n@ư\"\\\"token={{REDACTED}},","piiReplacements":1}},{"input":"Wed Jan 15 10:00:00 UTC 2025/filevel.\"quoted\"msg _Wed Jan 15 10:00:00 UTC 2025=ms=12,Bearer\u000bab\" \ndeadbeef12=abc3fa85f64-5717-4562-b3fc-2c963f66afa6-","output":{"output":"Wed Jan 15 10:00:00 UTC 2025/filevel.\"quoted\"msg _Wed Jan 15 10:00:00 UTC 2025=ms=12,Bearer\u000bab\" \ndeadbeef12=abc3fa85f64-5717-4562-b3fc-2c963f66afa6-","piiReplacements":0}},{"input":"deploy.sh:payloadWed, 15 Jan 2025 10:00:00 GMT,192.168.1.1 éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé=x_1234=:,15/Jan/2025:10:00:00 +0000/日本 ","output":{"output":"deploy.sh:payloadWed, 15 Jan 2025 10:00:00 GMT,192.168.1.1 éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé=x_1234=:,15/Jan/2025:10:00:00 +0000/日本 ","piiReplacements":0}},{"input":"/api/v1/users/123\"libssl.so-G 5. \"user [email protected] logged in=ms=12-straße- 12 Ō=BEARER Kabc=","output":{"output":"/api/v1/users/123\"libssl.so-G 5. \"user {{REDACTED}} logged in=ms=12-straße- 12 Ō=Bearer {{REDACTED}}","piiReplacements":2}},{"input":"Bearer\u000bab@0xDEADbeefsk_test_ZZZZZZZZZZZZZZZZZZZ\"Infinity 12.5-fi=42949672962025-01-15T10:00:00Z_Mon Jan 5 10:00:00 2025.xoxb-12345-\"straße-","output":{"output":"Bearer\u000bab@0xDEADbeefsk_test_ZZZZZZZZZZZZZZZZZZZ\"Infinity 12.5-fi=42949672962025-01-15T10:00:00Z_Mon Jan 5 10:00:00 2025.xoxb-12345-\"straße-","piiReplacements":0}},{"input":":\ncus_ABCDEFGHIJKLMN-4111 1111 1111 1111@15/Jan/2025:10:00:00 +0000\"]:cus_ABCDEFGHIJKLMN-bearer x.y-z~+/==@429496729412\u000b/","output":{"output":":\ncus_ABCDEFGHIJKLMN-4111 1111 1111 1111@15/Jan/2025:10:00:00 +0000\"]:cus_ABCDEFGHIJKLMN-Bearer {{REDACTED}}@429496729412\u000b/","piiReplacements":1}},{"input":"deadbeef12-user_A1b2:bearer x.y-z~+/==,12.5abca\\nb _Dž.-0 a.fi@1e3 日本語 ","output":{"output":"deadbeef12-user_A1b2:Bearer {{REDACTED}},12.5abca\\nb _Dž.-0 a.fi@1e3 日本語 ","piiReplacements":1}},{"input":"123:日本語 酪/\\_,-/api/v1/users/123{\"a\":1} [email protected]\n-0 ERROR.deadbeef12,1,5 :","output":{"output":"123:日本語 酪/\\_,-/api/v1/users/123{\"a\":1} ={{REDACTED}}\n-0 ERROR.deadbeef12,1,5 :","piiReplacements":1}},{"input":"🚀_-9007199254740992\r\n","output":{"output":"🚀_-9007199254740992\r\n","piiReplacements":0}},{"input":"Bearer\u000bab-x_1234\"12345678=","output":{"output":"Bearer\u000bab-x_1234\"12345678=","piiReplacements":0}},{"input":"W1301 10:00:00-4294967295:a\\nb hasOwnProperty12345678.","output":{"output":"W1301 10:00:00-4294967295:a\\nb hasOwnProperty12345678.","piiReplacements":0}},{"input":"-1-fi=fi@INFO-","output":{"output":"-1-fi=fi@INFO-","piiReplacements":0}},{"input":"GETghp_0123456789abcdefghij0123456789abcdef :192.168.001.001\"\\Bearer\tabc\nuuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\n","output":{"output":"GETghp_0123456789abcdefghij0123456789abcdef :192.168.001.001\"\\Bearer {{REDACTED}}\nuuid_3fa85f64-5717-4562-b3fc-2c963f66afa6\n","piiReplacements":1}},{"input":"١٢٣host-1.internal\"","output":{"output":"١٢٣host-1.internal\"","piiReplacements":0}},{"input":"2025-01-15 10:00:00,123+0100\"","output":{"output":"2025-01-15 10:00:00,123+0100\"","piiReplacements":0}},{"input":"Mon Jan 5 10:00:00 2025=","output":{"output":"Mon Jan 5 10:00:00 2025=","piiReplacements":0}},{"input":"10.0.0.256=é@example.com=\t,{[\"10.0.0.256.0xDEADbeef Wed, 15 Jan 2025 10:00:00 GMT-sk_test_ZZZZZZZZZZZZZZZZZZZ ","output":{"output":"10.0.0.256=é@example.com=\t,{[\"10.0.0.256.0xDEADbeef Wed, 15 Jan 2025 10:00:00 GMT-sk_test_ZZZZZZZZZZZZZZZZZZZ ","piiReplacements":0}},{"input":"15/Jan/2025:10:00:00 +0000.token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig@api.example.com:","output":{"output":"15/Jan/2025:10:00:00 +0000.token={{REDACTED}}@api.example.com:","piiReplacements":1}},{"input":"1.5:user [email protected] logged in\"0xDEADbeef ","output":{"output":"1.5:user {{REDACTED}} logged in\"0xDEADbeef ","piiReplacements":1}},{"input":"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 01ERROR\"cus_ABCDEFGHIJKLMN=Bearer\u000bab\nsub_Abcdefghijklmnopqrstuvwx ","output":{"output":"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀 01ERROR\"cus_ABCDEFGHIJKLMN=Bearer\u000bab\nsub_Abcdefghijklmnopqrstuvwx ","piiReplacements":0}},{"input":"straßeBEARER Kabc","output":{"output":"straßeBearer {{REDACTED}}","piiReplacements":1}},{"input":"[email protected] xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx_1234İstanbul\"𖹁0.1\n\n12.5@a12345678-🚀 \nW1301 10:00:00=sub_Abcdefghijklmnopqrstuvwx:","output":{"output":"{{REDACTED}} xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx_1234İstanbul\"𖹁0.1\n\n12.5@a12345678-🚀 \nW1301 10:00:00=sub_Abcdefghijklmnopqrstuvwx:","piiReplacements":1}},{"input":"é@example.com/,_{=bearer x.y-z~+/==ΣΑΣ[email protected]","output":{"output":"é@example.com/,_{=Bearer {{REDACTED}}ΣΑΣ={{REDACTED}}-","piiReplacements":2}},{"input":"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123,","output":{"output":"{{REDACTED}},","piiReplacements":1}},{"input":"0x10 éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé ._12345_3fa85f64-5717-4562-b3fc-2c963f66afa6,AKIAIOSFODNN7EXAMPLE,libssl.soERROR : 12 \ndebugWed, 15 Jan 2025 12:00:00 GMT 3fa85f64-5717-4562-b3fc-2c963f66afa6 \\_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6\"","output":{"output":"0x10 éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé ._12345_3fa85f64-5717-4562-b3fc-2c963f66afa6,{{REDACTED}},libssl.soERROR : 12 \ndebugWed, 15 Jan 2025 12:00:00 GMT 3fa85f64-5717-4562-b3fc-2c963f66afa6 \\_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6\"","piiReplacements":1}},{"input":"ǂERROR,_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6[\n{\"a\":1}Bearer [email protected] 1,5 _BEARER Kabc-12345678=deploy.sh.ERROR日本語=msg :","output":{"output":"ǂERROR,_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6[\n{\"a\":1}Bearer {{REDACTED}}@0.000001 1,5 _Bearer {{REDACTED}}deploy.sh.ERROR日本語=msg :","piiReplacements":2}},{"input":"1e+100 𘇔:,:eyJabcdefghijk.abcd.-token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig-Ƨ1e400 :sk_test_ZZZZZZZZZZZZZZZZZZZ\"bearer x.y-z~+/==:掠xoxb-1234567890-abc","output":{"output":"1e+100 𘇔:,:{{REDACTED}}={{REDACTED}}Ƨ1e400 :sk_test_ZZZZZZZZZZZZZZZZZZZ\"Bearer {{REDACTED}}:掠{{REDACTED}}","piiReplacements":4}},{"input":"} payload -Bearer\u000bab:","output":{"output":"} payload -Bearer\u000bab:","piiReplacements":0}},{"input":"�\t.E1231 23:59:59 3fa85f64-5717-4562-b3fc-2c963f66afa6-\":0 :","output":{"output":"�\t.E1231 23:59:59 3fa85f64-5717-4562-b3fc-2c963f66afa6-\":0 :","piiReplacements":0}},{"input":"日本語payload=15/Jan/2025:10:00:00 +0000 뺮__defineGetter__\"s[email protected]=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig\"","output":{"output":"日本語payload=15/Jan/2025:10:00:00 +0000 뺮__defineGetter__\"{{REDACTED}}@1e400.token={{REDACTED}}\"","piiReplacements":2}},{"input":"2025-01-15T10:00:00.123Z:uuid_3fa85f64-5717-4562-b3fc-2c963f66afa61e3 =ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1_é@example.com@[email protected].","output":{"output":"2025-01-15T10:00:00.123Z:uuid_3fa85f64-5717-4562-b3fc-2c963f66afa61e3 =ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1_é@example.com@{{REDACTED}}.","piiReplacements":1}},{"input":" _user.email\u000b/Jan 5 10:00:00= 12 é@example.com=2001:db8::1-0b11 xoxb-12345-\"","output":{"output":" _user.email\u000b/Jan 5 10:00:00= 12 é@example.com=2001:db8::1-0b11 xoxb-12345-\"","piiReplacements":0}},{"input":"sub_Abcdefghijklmnopqrstuvwx.","output":{"output":"sub_Abcdefghijklmnopqrstuvwx.","piiReplacements":0}},{"input":"host-1.internal.ms=12:/api/users/12345/orders/987,","output":{"output":"host-1.internal.ms=12:/api/users/12345/orders/987,","piiReplacements":0}},{"input":"Mon Jan 5 10:00:00 2025,user [email protected] logged in 12.50\nerror .msgghp_0123456789abcdefghij0123456789abcdef=日本=abc3fa85f64-5717-4562-b3fc-2c963f66afa6.日本 ","output":{"output":"Mon Jan 5 10:00:00 2025,user {{REDACTED}} logged in 12.50\nerror .msgghp_0123456789abcdefghij0123456789abcdef=日本=abc3fa85f64-5717-4562-b3fc-2c963f66afa6.日本 ","piiReplacements":1}},{"input":"\\@AKIAA1B2C3D4E5F6G7H8\"192.168.001.001:🚀,","output":{"output":"\\@{{REDACTED}}\"192.168.001.001:🚀,","piiReplacements":1}},{"input":"123\n12/AKIAA1B2C3D4E5F6G7H8.日本,[email protected] fi@Dž_ 🚀/","output":{"output":"123\n12/{{REDACTED}}.日本,{{REDACTED}} fi@Dž_ 🚀/","piiReplacements":2}},{"input":"Wed, 15 Jan 2025 10:00:00 GMT,aes_128\n_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6x_1234 [email protected].é12-","output":{"output":"Wed, 15 Jan 2025 10:00:00 GMT,aes_128\n_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6x_1234 [email protected].é12-","piiReplacements":0}},{"input":"偣-1e400🚀=sk_test_ZZZZZZZZZZZZZZZZZZZ,}/0xDEADbeefbearer x.y-z~+/==\"-1-aes_128-E1231 23:59:59=","output":{"output":"偣-1e400🚀=sk_test_ZZZZZZZZZZZZZZZZZZZ,}/0xDEADbeefBearer {{REDACTED}}\"-1-aes_128-E1231 23:59:59=","piiReplacements":1}},{"input":"::Bearer\u000bab:AKIAA1B2C3D4E5F6G7H8,5._é12-BEARER Kabc_15/Jan/2025:10:00:00 +0000/api/v1/users/1230fi\n","output":{"output":"::Bearer\u000bab:{{REDACTED}},5._é12-Bearer {{REDACTED}}:10:00:00 +0000/api/v1/users/1230fi\n","piiReplacements":2}},{"input":"AKIAA1B2C3D4E5F6G7H8 x_1234/\r\n\"é/İstanbul,","output":{"output":"{{REDACTED}} x_1234/\r\n\"é/İstanbul,","piiReplacements":1}},{"input":"\\-","output":{"output":"\\-","piiReplacements":0}},{"input":"Bearer\tabc,Infinitya\\nb ,\r\n- payload ꐧ,","output":{"output":"Bearer {{REDACTED}},Infinitya\\nb ,\r\n- payload ꐧ,","piiReplacements":1}},{"input":"2025-01-15T10:00:00.123Z@Bearer\u000bab1e-7,0xDEADbeef","output":{"output":"2025-01-15T10:00:00.123Z@Bearer\u000bab1e-7,0xDEADbeef","piiReplacements":0}},{"input":"1.5_Dž\"","output":{"output":"1.5_Dž\"","piiReplacements":0}},{"input":"::1\"ms=12-\t/🚀/Bearer\tabc@15/Jan/2025:10:00:00 +0000/,0+5.I0827 11:39:40.307946-token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig,","output":{"output":"::1\"ms=12-\t/🚀/Bearer {{REDACTED}}@15/Jan/2025:10:00:00 +0000/,0+5.I0827 11:39:40.307946-token={{REDACTED}},","piiReplacements":2}},{"input":"fi/é12\n🚀-\r\n1_000@é@example.com:\\.gho_short-","output":{"output":"fi/é12\n🚀-\r\n1_000@é@example.com:\\.gho_short-","piiReplacements":0}},{"input":"user [email protected] logged in,[email protected] 123:\r\n_bearer x.y-z~+/==.-1e400 @BEARER Kabc\"E1231 23:59:59 ghp_0123456789abcdefghij0123456789abcdef12-","output":{"output":"user {{REDACTED}} logged in,{{REDACTED}} 123:\r\n_Bearer {{REDACTED}}.-1e400 @Bearer {{REDACTED}}\"E1231 23:59:59 {{REDACTED}}12-","piiReplacements":5}},{"input":"1e400.ΣΑΣ_fi-W1301 10:00:00-valueOf 12\n","output":{"output":"1e400.ΣΑΣ_fi-W1301 10:00:00-valueOf 12\n","piiReplacements":0}},{"input":"{_[=ﮖ =xoxb-12345--x_1234=🚀,","output":{"output":"{_[=ﮖ =xoxb-12345--x_1234=🚀,","piiReplacements":0}},{"input":"bearer x.y-z~+/==_sk_test_ZZZZZZZZZZZZZZZZZZZ: 12 /api/v1/users/123 \r\n\r\n\"","output":{"output":"Bearer {{REDACTED}}_sk_test_ZZZZZZZZZZZZZZZZZZZ: 12 /api/v1/users/123 \r\n\r\n\"","piiReplacements":1}},{"input":"aes_128_W1301 10:00:00_","output":{"output":"aes_128_W1301 10:00:00_","piiReplacements":0}},{"input":"Wed, 15 Jan 2025 12:00:00 GMT host-1.internal/\\=9007199254740993AKIAIOSFODNN7EXAMPLE @/api/v1/users/123 \t\u000b.192.168.001.001 ","output":{"output":"Wed, 15 Jan 2025 12:00:00 GMT host-1.internal/\\=9007199254740993AKIAIOSFODNN7EXAMPLE @/api/v1/users/123 \t\u000b.192.168.001.001 ","piiReplacements":0}},{"input":"cus_ABCDEFGHIJKLMN-::1\"sk_live_aaaaaaaaaaaaaaaaaaaaaaaa\n4111 1111 1111 1111,]:","output":{"output":"cus_ABCDEFGHIJKLMN-::1\"{{REDACTED}}\n4111 1111 1111 1111,]:","piiReplacements":1}},{"input":"BEARER Kabc@","output":{"output":"Bearer {{REDACTED}}@","piiReplacements":1}},{"input":"/api/users/12345/orders/987/0:","output":{"output":"/api/users/12345/orders/987/0:","piiReplacements":0}},{"input":"4111 1111 1111 1111.123,0b11 gho_short xoxb-12345-:aes_128/debugghp_0123456789abcdefghij0123456789abcdef.libssl.so","output":{"output":"4111 1111 1111 1111.123,0b11 gho_short xoxb-12345-:aes_128/debugghp_0123456789abcdefghij0123456789abcdef.libssl.so","piiReplacements":0}},{"input":" @[email protected], gho_short-nullghp_0123456789abcdefghij0123456789abcdef/\"\"","output":{"output":" @{{REDACTED}}, gho_short-nullghp_0123456789abcdefghij0123456789abcdef/\"\"","piiReplacements":1}},{"input":"Wed, 15 Jan 2025 10:00:00 GMT,Dž/","output":{"output":"Wed, 15 Jan 2025 10:00:00 GMT,Dž/","piiReplacements":0}},{"input":"sk_test_ZZZZZZZZZZZZZZZZZZZ:ASIA0000000000000000X_cus_ABCDEFGHIJKLMN_-1e400 12 user_A1b2:eyJabcdefghijk.abcd._","output":{"output":"sk_test_ZZZZZZZZZZZZZZZZZZZ:ASIA0000000000000000X_cus_ABCDEFGHIJKLMN_-1e400 12 user_A1b2:{{REDACTED}}","piiReplacements":1}},{"input":"bearer x.y-z~+/==\"123456789012345680000 .192.168.0.1192.168.1.1_/api/users/12345/orders/987=4294967295 日本語.2025-01-15 10:00:00,123+0100.","output":{"output":"Bearer {{REDACTED}}\"123456789012345680000 .192.168.0.1192.168.1.1_/api/users/12345/orders/987=4294967295 日本語.2025-01-15 10:00:00,123+0100.","piiReplacements":1}},{"input":"sub_Abcdefghijklmnopqrstuvwx/١٢٣ [email protected]=ms=12=4111 1111 1111 1111, [email protected]🚀 123-\u000b deadbeef12,","output":{"output":"sub_Abcdefghijklmnopqrstuvwx/١٢٣ [email protected]=ms=12=4111 1111 1111 1111, [email protected]🚀 123-\u000b deadbeef12,","piiReplacements":0}},{"input":"🚀 \\\né12_é@[email protected]@\\_4111 1111 1111 1111\"","output":{"output":"🚀 \\\né12_é@[email protected]@\\_4111 1111 1111 1111\"","piiReplacements":0}},{"input":"Bearer\tabc\nghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1: :[email protected]🚀 ,/Bearer\tabc\"日本\n","output":{"output":"Bearer {{REDACTED}}\n{{REDACTED}}: :[email protected]🚀 ,/Bearer {{REDACTED}}\"日本\n","piiReplacements":3}},{"input":"12,,/2025-01-15 10:00:00,123+0100=İstanbul,{token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig=libssl.so ","output":{"output":"12,,/2025-01-15 10:00:00,123+0100=İstanbul,{token={{REDACTED}}=libssl.so ","piiReplacements":1}},{"input":"İstanbul=ms=12:deadbeef1215/Jan/2025:10:00:00 +0000:","output":{"output":"İstanbul=ms=12:deadbeef1215/Jan/2025:10:00:00 +0000:","piiReplacements":0}},{"input":"user_A1b2,bearer x.y-z~+/==:xoxp-1234567890 ","output":{"output":"user_A1b2,Bearer {{REDACTED}}:{{REDACTED}} ","piiReplacements":2}},{"input":"123/Kuser_123,:[email protected]🚀,🨱 ,\"-","output":{"output":"123/Kuser_123,:[email protected]🚀,🨱 ,\"-","piiReplacements":0}},{"input":"null:Dž[email protected] fi/user_A1b2,/api/users/12345/orders/987\"a\\nb true_","output":{"output":"null:Dž[email protected] fi/user_A1b2,/api/users/12345/orders/987\"a\\nb true_","piiReplacements":0}},{"input":"بa.b job_12345\n","output":{"output":"بa.b job_12345\n","piiReplacements":0}},{"input":"} 12345678fatal_192.168.1.1 ,sk_live_aaaaaaaaaaaaaaaaaaaaaaaa,libssl.so.\"\"Jan 5 10:00:00/é@example.com\n123\nxoxb-12345-=","output":{"output":"} 12345678fatal_192.168.1.1 ,{{REDACTED}},libssl.so.\"\"Jan 5 10:00:00/é@example.com\n123\nxoxb-12345-=","piiReplacements":1}},{"input":"debugINFO [=ΣΑΣ ","output":{"output":"debugINFO [=ΣΑΣ ","piiReplacements":0}},{"input":"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\[email protected]🚀 fi,2 2025-01-15T10:00:00Z \"job_12345.xoxb-1234567890-abc:0=libssl.so\"_4294967296 [1,2]/","output":{"output":"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\[email protected]🚀 fi,2 2025-01-15T10:00:00Z \"job_12345.{{REDACTED}}:0=libssl.so\"_4294967296 [1,2]/","piiReplacements":1}},{"input":",\nconstructor\"W1301 10:00:[email protected]_15/Jan/2025:10:00:00 +0000,","output":{"output":",\nconstructor\"W1301 10:00:[email protected]_15/Jan/2025:10:00:00 +0000,","piiReplacements":0}},{"input":"🚀_gho_short/10.0.0.256,","output":{"output":"🚀_gho_short/10.0.0.256,","piiReplacements":0}},{"input":"a\\nb .libssl.so\"libssl.so@{ BEARER Kabc.0x10192.168.1.1=token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig\"deadbeef12,[email protected]/debug a","output":{"output":"a\\nb .libssl.so\"libssl.so@{ Bearer {{REDACTED}}token={{REDACTED}}\"deadbeef12,[email protected]/debug a","piiReplacements":2}},{"input":"日本\"BEARER Kabc-\r\n,[email protected].{\nWed Jan 15 10:00:00 UTC 2025\"","output":{"output":"日本\"Bearer {{REDACTED}}\r\n,{{REDACTED}}.{\nWed Jan 15 10:00:00 UTC 2025\"","piiReplacements":2}},{"input":"token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sigeyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc1234294967295,x_1234日本語\r\n ,ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1_","output":{"output":"token={{REDACTED}}.eyJzdWIiOiIxIn0.abc1234294967295,x_1234日本語\r\n ,ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1_","piiReplacements":1}},{"input":",:{_15/Jan/2025:10:00:00 +0000=-:-deadbeef12\nMon Jan 5 10:00:00 2025/ASIA0000000000000000X10.0.0.256\n2025-01-15 10:00:00,123+0100/","output":{"output":",:{_15/Jan/2025:10:00:00 +0000=-:-deadbeef12\nMon Jan 5 10:00:00 2025/ASIA0000000000000000X10.0.0.256\n2025-01-15 10:00:00,123+0100/","piiReplacements":0}},{"input":"{,","output":{"output":"{,","piiReplacements":0}},{"input":"sk_live_aaaaaaaaaaaaaaaaaaaaaaaa=ERROR ϭ,日本 İstanbul,Bearer\u000bab:2025-01-15T10:00:[email protected]/sub_Abcdefghijklmnopqrstuvwx,sk_test_ZZZZZZZZZZZZZZZZZZZ=","output":{"output":"{{REDACTED}}=ERROR ϭ,日本 İstanbul,Bearer\u000bab:2025-01-15T10:00:[email protected]/sub_Abcdefghijklmnopqrstuvwx,sk_test_ZZZZZZZZZZZZZZZZZZZ=","piiReplacements":1}},{"input":"Bearer\u000bab=GET_","output":{"output":"Bearer\u000bab=GET_","piiReplacements":0}},{"input":"1e3@12345678,NaN\t@:. \npayload.valueOf :1e400 W1301 10:00:00/12.5abc\"","output":{"output":"1e3@12345678,NaN\t@:. \npayload.valueOf :1e400 W1301 10:00:00/12.5abc\"","piiReplacements":0}},{"input":"蘭 12 \t I0827 11:39:40.307946 ","output":{"output":"蘭 12 \t I0827 11:39:40.307946 ","piiReplacements":0}},{"input":"\"@aes_128/api/users/12345/orders/987/2025-01-15T10:00:00.123Z-\r\n\"","output":{"output":"\"@aes_128/api/users/12345/orders/987/2025-01-15T10:00:00.123Z-\r\n\"","piiReplacements":0}},{"input":"-Infinity4294967294/ms=12@ΣΑΣ.欓-valueOf @","output":{"output":"-Infinity4294967294/ms=12@ΣΑΣ.欓-valueOf @","piiReplacements":0}},{"input":"][email protected]=Dž[email protected]🚀\" 12Jan 5 10:00:00\"12345678,2025-01-15 10:00:00,123+0100","output":{"output":"]={{REDACTED}}=Dž[email protected]🚀\" 12Jan 5 10:00:00\"12345678,2025-01-15 10:00:00,123+0100","piiReplacements":1}},{"input":"𞟹 null@::1\"\",straß[email protected]{\"a\":1}12aes_128: Y@token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig_١٢٣@","output":{"output":"𞟹 null@::1\"\",straß{{REDACTED}}-{\"a\":1}12aes_128: Y@token={{REDACTED}}١٢٣@","piiReplacements":2}},{"input":"0 .5:straße.日本_,İstanbul@123_user [email protected] logged in ΣΑΣ-k=","output":{"output":"0 .5:straße.日本_,İstanbul@123_user {{REDACTED}} logged in ΣΑΣ-k=","piiReplacements":1}},{"input":"[email protected]🚀-192.168.1.1GET [\"Wed Jan 15 10:00:00 UTC [email protected]@999.9999999INFO=","output":{"output":"[email protected]🚀-192.168.1.1GET [\"Wed Jan 15 10:00:00 UTC {{REDACTED}}@999.9999999INFO=","piiReplacements":1}},{"input":",I0827 11:39:40.307946.sk_live_aaaaaaaaaaaaaaaaaaaaaaaa_","output":{"output":",I0827 11:39:40.307946.sk_live_aaaaaaaaaaaaaaaaaaaaaaaa_","piiReplacements":0}},{"input":"a\\nb\n0o7 POST=","output":{"output":"a\\nb\n0o7 POST=","piiReplacements":0}},{"input":"xoxp-1234567890\ndeadbeef12-é:","output":{"output":"{{REDACTED}}\ndeadbeef12-é:","piiReplacements":1}},{"input":"]\"2025-01-15 10:00:00,123+0100/xoxb-1234567890-abc debug-\t:user_A1b2ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1-999.9999999:\"","output":{"output":"]\"2025-01-15 10:00:00,123+0100/{{REDACTED}} debug-\t:user_A1b2ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1-999.9999999:\"","piiReplacements":1}},{"input":"ms=12\n::1,","output":{"output":"ms=12\n::1,","piiReplacements":0}},{"input":"cus_ABCDEFGHIJKLMN\n__proto__:bearer x.y-z~+/==١٢٣-fatal\"Bearer\u000bab-a-message -fi,3fa85f64-5717-4562-b3fc-2c963f66afa6.","output":{"output":"cus_ABCDEFGHIJKLMN\n__proto__:Bearer {{REDACTED}}١٢٣-fatal\"Bearer\u000bab-a-message -fi,3fa85f64-5717-4562-b3fc-2c963f66afa6.","piiReplacements":1}},{"input":"abc3fa85f64-5717-4562-b3fc-2c963f66afa6\nghp_0123456789abcdefghij0123456789abcdef쫩 Bearer\u000bab\n","output":{"output":"abc3fa85f64-5717-4562-b3fc-2c963f66afa6\n{{REDACTED}}쫩 Bearer\u000bab\n","piiReplacements":1}},{"input":"Wed Jan 15 10:00:00 UTC 2025/3fa85f64-5717-4562-b3fc-2c963f66afa6 ","output":{"output":"Wed Jan 15 10:00:00 UTC 2025/3fa85f64-5717-4562-b3fc-2c963f66afa6 ","piiReplacements":0}},{"input":"1_000 INFO/[1,2]p192.168.001.001=eyJabcdefghijk.abcd.=Bearer\tabc_AKIAIOSFODNN7EXAMPLExxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"1e+21 /","output":{"output":"1_000 INFO/[1,2]p192.168.001.001={{REDACTED}}=Bearer {{REDACTED}}\"1e+21 /","piiReplacements":2}},{"input":"ms=12 ::1,\"\"","output":{"output":"ms=12 ::1,\"\"","piiReplacements":0}},{"input":"\" Wed, 15 Jan 2025 10:00:00 GMT {\"}/,,aes_128,Bearer\u000bab/","output":{"output":"\" Wed, 15 Jan 2025 10:00:00 GMT {\"}/,,aes_128,Bearer\u000bab/","piiReplacements":0}},{"input":"\":AKIAIOSFODNN7EXAMPLE \"é@example.com-api.example.com\nBearer\tabc@5. \n]=sk_live_aaaaaaaaaaaaaaaaaaaaaaaa@","output":{"output":"\":{{REDACTED}} \"é@example.com-api.example.com\nBearer {{REDACTED}}@5. \n]={{REDACTED}}@","piiReplacements":3}},{"input":"4111 1111 1111 1111@","output":{"output":"4111 1111 1111 1111@","piiReplacements":0}},{"input":"ms=12@a\\nb@gho_short:E1231 23:59:59-Wed Jan 15 10:00:00 UTC 2025 ::1-\\\"","output":{"output":"ms=12@a\\nb@gho_short:E1231 23:59:59-Wed Jan 15 10:00:00 UTC 2025 ::1-\\\"","piiReplacements":0}},{"input":"[email protected]\"/api/users/12345/orders/987 fi/ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1","output":{"output":"{{REDACTED}}\"/api/users/12345/orders/987 fi/{{REDACTED}}","piiReplacements":2}},{"input":"E1231 23:59:59\"INFO192.168.1.1=abc3fa85f64-5717-4562-b3fc-2c963f66afa6=debug -1.5@,\n","output":{"output":"E1231 23:59:59\"INFO192.168.1.1=abc3fa85f64-5717-4562-b3fc-2c963f66afa6=debug -1.5@,\n","piiReplacements":0}},{"input":" null:eyJabcdefghijk.abcd.\"12345678\n\t/㫧5e-324_12true\nBEARER Kabc=İstanbul_a\\nb:","output":{"output":" null:{{REDACTED}}\"12345678\n\t/㫧5e-324_12true\nBearer {{REDACTED}}İstanbul_a\\nb:","piiReplacements":2}},{"input":"123\"15/Jan/2025:10:00:00 +0000ASIA0000000000000000X.1e400 /[email protected]🚀١٢٣:/api/v1/users/123𖥉/libssl.so\[email protected]/[email protected] ","output":{"output":"123\"15/Jan/2025:10:00:00 +0000ASIA0000000000000000X.1e400 /[email protected]🚀١٢٣:/api/v1/users/123𖥉/libssl.so\[email protected]/[email protected] ","piiReplacements":0}},{"input":"E1231 23:59:59\"ΣΑΣ event [email protected]:é12 ","output":{"output":"E1231 23:59:59\"ΣΑΣ event {{REDACTED}}:é12 ","piiReplacements":1}},{"input":"é12=Wed Jan 15 10:00:00 UTC 2025 [ }.xoxb-12345-@xoxb-12345-:12345678-deadbeef12:user [email protected] logged in\"","output":{"output":"é12=Wed Jan 15 10:00:00 UTC 2025 [ }.xoxb-12345-@xoxb-12345-:12345678-deadbeef12:user {{REDACTED}} logged in\"","piiReplacements":1}},{"input":"192.168.001.001=","output":{"output":"192.168.001.001=","piiReplacements":0}},{"input":"15/Jan/2025:10:00:00 +0000-a..\n","output":{"output":"15/Jan/2025:10:00:00 +0000-a..\n","piiReplacements":0}},{"input":"Mon Jan 5 10:00:00 20251,5:","output":{"output":"Mon Jan 5 10:00:00 20251,5:","piiReplacements":0}},{"input":"[1,2] 2025-01-15T10:00:00.123Z -1e4002025-01-15T10:00:00Z-eyJabcdefghijk.abcd./","output":{"output":"[1,2] 2025-01-15T10:00:00.123Z -1e4002025-01-15T10:00:00Z-{{REDACTED}}/","piiReplacements":1}},{"input":"2025-01-15T10:00:00.123Z\ndeploy.sh\"abc3fa85f64-5717-4562-b3fc-2c963f66afa6🚀\"é@[email protected]🚀\ncus_ABCDEFGHIJKLMN_12345678:","output":{"output":"2025-01-15T10:00:00.123Z\ndeploy.sh\"abc3fa85f64-5717-4562-b3fc-2c963f66afa6🚀\"é@[email protected]🚀\ncus_ABCDEFGHIJKLMN_12345678:","piiReplacements":0}},{"input":"2025-01-15T10:00:00Z\"é@example.com/-1e400 length =0xDEADbeef@::1/10.0.0.256,","output":{"output":"2025-01-15T10:00:00Z\"é@example.com/-1e400 length =0xDEADbeef@::1/10.0.0.256,","piiReplacements":0}},{"input":"[email protected]\nbearer x.y-z~+/==.job_12345=鹽uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6 10.0.0.256:[.","output":{"output":"{{REDACTED}}\nBearer {{REDACTED}}.job_12345=鹽uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6 10.0.0.256:[.","piiReplacements":2}},{"input":"0x10\"Mon Jan 5 10:00:00 2025-\r\n_.2025-01-15T10:00:00.123Z user [email protected] logged in 2025-01-15T10:00:00.123Z/eyJabcdefghijk.abcd.,\t\\=","output":{"output":"0x10\"Mon Jan 5 10:00:00 2025-\r\n_.2025-01-15T10:00:00.123Z user {{REDACTED}} logged in 2025-01-15T10:00:00.123Z/{{REDACTED}},\t\\=","piiReplacements":2}},{"input":"_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6,\r\n𘫥:I0827 11:39:40.307946_deploy.sh.deploy.sh=deadbeef12,POST̴ \"é@example.com=Mon Jan 5 10:00:00 2025 [email protected]🚀 ","output":{"output":"_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6,\r\n𘫥:I0827 11:39:40.307946_deploy.sh.deploy.sh=deadbeef12,POST̴ \"é@example.com=Mon Jan 5 10:00:00 2025 [email protected]🚀 ","piiReplacements":0}},{"input":"E1231 23:59:59,\\ERROR ,","output":{"output":"E1231 23:59:59,\\ERROR ,","piiReplacements":0}},{"input":"\"","output":{"output":"\"","piiReplacements":0}},{"input":"x@","output":{"output":"x@","piiReplacements":0}},{"input":"[email protected],\r\n,[email protected]/Bearer\tabc/sk_live_aaaaaaaaaaaaaaaaaaaaaaaa:🚀\n,","output":{"output":"-{{REDACTED}},\r\n,{{REDACTED}}/Bearer {{REDACTED}}:🚀\n,","piiReplacements":3}},{"input":"straße,api.example.com bearer x.y-z~+/==\n] Wed Jan 15 10:00:00 UTC 2025\"\".Bearer\tabc:","output":{"output":"straße,api.example.com Bearer {{REDACTED}}\n] Wed Jan 15 10:00:00 UTC 2025\"\".Bearer {{REDACTED}}:","piiReplacements":2}},{"input":"a.b_/api/users/12345/orders/987/token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig-sub_Abcdefghijklmnopqrstuvwx/İstanbul_sk_test_ZZZZZZZZZZZZZZZZZZZ:","output":{"output":"a.b_/api/users/12345/orders/987/token={{REDACTED}}/İstanbul_sk_test_ZZZZZZZZZZZZZZZZZZZ:","piiReplacements":1}},{"input":"hasOwnProperty:00-3fa85f64-5717-4562-b3fc-2c963f66afa6\nBearer abc.def-ghi\":.2025-01-15T10:00:00.123Zghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1_eyJabcdefghijk.abcd.-\\< ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1,","output":{"output":"hasOwnProperty:00-3fa85f64-5717-4562-b3fc-2c963f66afa6\nBearer {{REDACTED}}\":.2025-01-15T10:00:00.123Zghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1_eyJabcdefghijk.abcd.-\\< {{REDACTED}},","piiReplacements":2}},{"input":"W1301 10:00:00.sk_live_0123456789abcdefghijkl NaNjob_12345/ =ghp_0123456789abcdefghij0123456789abcdefAKIAIOSFODNN7EXAMPLE\"Wed, 15 Jan 2025 10:00:00 GMT +5 x_1234\n","output":{"output":"W1301 10:00:00.{{REDACTED}} NaNjob_12345/ ={{REDACTED}}\"Wed, 15 Jan 2025 10:00:00 GMT +5 x_1234\n","piiReplacements":2}},{"input":"ms=12@_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6/straße-3fa85f64-5717-4562-b3fc-2c963f66afa6\nghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1\n","output":{"output":"ms=12@_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6/straße-3fa85f64-5717-4562-b3fc-2c963f66afa6\n{{REDACTED}}\n","piiReplacements":1}},{"input":" 9007199254740994@aes_128@aes_128.4111 1111 1111 1111.user [email protected] logged in\"job_12345@Bearer\u000bab=","output":{"output":" 9007199254740994@aes_128@aes_128.4111 1111 1111 1111.user {{REDACTED}} logged in\"job_12345@Bearer\u000bab=","piiReplacements":1}},{"input":"cus_ABCDEFGHIJKLMN@Bearer\u000bab ","output":{"output":"cus_ABCDEFGHIJKLMN@Bearer\u000bab ","piiReplacements":0}},{"input":"éuuid_3fa85f64-5717-4562-b3fc-2c963f66afa6:🚀:é@example.com:12345678 event:","output":{"output":"éuuid_3fa85f64-5717-4562-b3fc-2c963f66afa6:🚀:é@example.com:12345678 event:","piiReplacements":0}},{"input":"::1,","output":{"output":"::1,","piiReplacements":0}},{"input":"ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1 user [email protected] logged in\n","output":{"output":"{{REDACTED}} user {{REDACTED}} logged in\n","piiReplacements":2}},{"input":"-Infinity é@example.com=Ƈ0b11 @2025-01-15T10:00:00ZInfinity.{_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6.Dž\"","output":{"output":"-Infinity é@example.com=Ƈ0b11 @2025-01-15T10:00:00ZInfinity.{_12345_3fa85f64-5717-4562-b3fc-2c963f66afa6.Dž\"","piiReplacements":0}},{"input":"0xDEADbeef:-1.5 ","output":{"output":"0xDEADbeef:-1.5 ","piiReplacements":0}},{"input":"xoxb-12345-_user [email protected] logged in","output":{"output":"xoxb-12345-_user {{REDACTED}} logged in","piiReplacements":1}},{"input":"2025-01-15 10:00:00,123+0100\":-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.3fa85f64-5717-4562-b3fc-2c963f66afa6=Mon Jan 5 10:00:00 2025\"job_12345-10.0.0.256:","output":{"output":"2025-01-15 10:00:00,123+0100\":-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.3fa85f64-5717-4562-b3fc-2c963f66afa6=Mon Jan 5 10:00:00 2025\"job_12345-10.0.0.256:","piiReplacements":0}},{"input":"NaN-sub_Abcdefghijklmnopqrstuvwx.abc3fa85f64-5717-4562-b3fc-2c963f66afa6:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx@1e400 xoxb-1234567890-abc\ndebug1_000.0 /0@","output":{"output":"NaN-sub_Abcdefghijklmnopqrstuvwx.abc3fa85f64-5717-4562-b3fc-2c963f66afa6:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx@1e400 {{REDACTED}}\ndebug1_000.0 /0@","piiReplacements":1}},{"input":"3fa85f64-5717-4562-b3fc-2c963f66afa6 =\"@[email protected] 竍-Infinity\"\" 🚀 null token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig=token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig,a\\nb 12 -","output":{"output":"3fa85f64-5717-4562-b3fc-2c963f66afa6 =\"@{{REDACTED}} 竍-Infinity\"\" 🚀 null token={{REDACTED}}=token={{REDACTED}},a\\nb 12 -","piiReplacements":3}},{"input":"4111 1111 1111 [email protected]_Mon Jan 5 10:00:00 [email protected] ","output":{"output":"4111 1111 1111 {{REDACTED}}.sh_Mon Jan 5 10:00:00 [email protected] ","piiReplacements":1}},{"input":"İstanbul.é@example.com-","output":{"output":"İstanbul.é@example.com-","piiReplacements":0}},{"input":"Infinity [[1,2]sk_live_aaaaaaaaaaaaaaaaaaaaaaaa Bearer\u000bab/ééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééAKIAIOSFODNN7EXAMPLE_0x10true\nWed Jan 15 10:00:00 UTC 2025_eyJabcdefghijk.abcd.:","output":{"output":"Infinity [[1,2]{{REDACTED}} Bearer\u000bab/ééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééAKIAIOSFODNN7EXAMPLE_0x10true\nWed Jan 15 10:00:00 UTC 2025_eyJabcdefghijk.abcd.:","piiReplacements":1}},{"input":"k+5.warn-1_000_\r\n_ms=12-warn warn-12","output":{"output":"k+5.warn-1_000_\r\n_ms=12-warn warn-12","piiReplacements":0}},{"input":"user [email protected] logged in\n:=bearer x.y-z~+/==\"\\_user [email protected] logged [email protected] \né12","output":{"output":"user {{REDACTED}} logged in\n:=Bearer {{REDACTED}}\"\\_user {{REDACTED}} logged [email protected] \né12","piiReplacements":3}},{"input":"cus_ABCDEFGHIJKLMN=Jan 5 10:00:00\n","output":{"output":"cus_ABCDEFGHIJKLMN=Jan 5 10:00:00\n","piiReplacements":0}},{"input":"\"[email protected]=0o7@Wed Jan 15 10:00:00 UTC 2025:","output":{"output":"\"[email protected]=0o7@Wed Jan 15 10:00:00 UTC 2025:","piiReplacements":0}},{"input":"::1 12 ","output":{"output":"::1 12 ","piiReplacements":0}},{"input":"é12:🚀@","output":{"output":"é12:🚀@","piiReplacements":0}},{"input":"[email protected] [email protected] logged in,POST -cus_ABCDEFGHIJKLMN_.5 =","output":{"output":"{{REDACTED}}-user {{REDACTED}} logged in,POST -cus_ABCDEFGHIJKLMN_.5 =","piiReplacements":2}},{"input":"bearer x.y-z~+/==@token=eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig/ﲩ1 @","output":{"output":"Bearer {{REDACTED}}@token={{REDACTED}}/ﲩ1 @","piiReplacements":2}},{"input":"4294967295","output":{"output":"4294967295","piiReplacements":0}},{"input":"᪱[email protected]🚀\nxoxb-12345-:[\n12345678- 1.7976931348623157e+308 \"libssl.so_host-1.internal=","output":{"output":"᪱[email protected]🚀\nxoxb-12345-:[\n12345678- 1.7976931348623157e+308 \"libssl.so_host-1.internal=","piiReplacements":0}},{"input":"🚀@straße@日本-\"gho_short\né1212,","output":{"output":"🚀@straße@日本-\"gho_short\né1212,","piiReplacements":0}},{"input":"Bearer\u000bab,","output":{"output":"Bearer\u000bab,","piiReplacements":0}},{"input":"\"quoted\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀=","output":{"output":"\"quoted\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀=","piiReplacements":0}},{"input":"straße=192.168.001.001=192.168.001.001_gho_short,cus_ABCDEFGHIJKLMN-\r\n=192.168.001.001_","output":{"output":"straße=192.168.001.001=192.168.001.001_gho_short,cus_ABCDEFGHIJKLMN-\r\n=192.168.001.001_","piiReplacements":0}},{"input":"Wed Jan 15 10:00:00 UTC 2025BEARER Kabc,1e+100_job_12345.K.trueAKIAIOSFODNN7EXAMPLE ,x_1234","output":{"output":"Wed Jan 15 10:00:00 UTC 2025Bearer {{REDACTED}},1e+100_job_12345.K.trueAKIAIOSFODNN7EXAMPLE ,x_1234","piiReplacements":1}},{"input":"4111 1111 1111 1111=İstanbul.abc3fa85f64-5717-4562-b3fc-2c963f66afa6\"[email protected]","output":{"output":"4111 1111 1111 1111=İstanbul.abc3fa85f64-5717-4562-b3fc-2c963f66afa6\"{{REDACTED}}","piiReplacements":1}},{"input":"日本@4111 1111 1111 1111@é libssl.so-x_1234\n{ warna\\nb.","output":{"output":"日本@4111 1111 1111 1111@é libssl.so-x_1234\n{ warna\\nb.","piiReplacements":0}},{"input":"msg é:0b11NaN/","output":{"output":"msg é:0b11NaN/","piiReplacements":0}},{"input":"sk_test_ZZZZZZZZZZZZZZZZZZZ=5. _sk_test_ZZZZZZZZZZZZZZZZZZZ\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx /","output":{"output":"sk_test_ZZZZZZZZZZZZZZZZZZZ=5. _sk_test_ZZZZZZZZZZZZZZZZZZZ\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx /","piiReplacements":0}},{"input":"[email protected] \r\n {,},","output":{"output":"{{REDACTED}} \r\n {,},","piiReplacements":1}},{"input":"İstanbul=","output":{"output":"İstanbul=","piiReplacements":0}},{"input":"Bearer\u000bab-straße/W1301 10:00:00-Jan 5 10:00:00/{-","output":{"output":"Bearer\u000bab-straße/W1301 10:00:00-Jan 5 10:00:00/{-","piiReplacements":0}},{"input":"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé -12 7@s[email protected]\n: ","output":{"output":"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé -12 7@{{REDACTED}}{{REDACTED}}\n: ","piiReplacements":2}},{"input":"gho_short,\t_\r\n [email protected] _","output":{"output":"gho_short,\t_\r\n [email protected] _","piiReplacements":0}},{"input":"x\n١٢٣1.5 1,5/","output":{"output":"x\n١٢٣1.5 1,5/","piiReplacements":0}},{"input":"ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1_straße@cus_ABCDEFGHIJKLMN 1 .日本,-10b11/10.0.0.256\"1e400=sk_test_ZZZZZZZZZZZZZZZZZZZ-","output":{"output":"ghp_A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1_straße@cus_ABCDEFGHIJKLMN 1 .日本,-10b11/10.0.0.256\"1e400=sk_test_ZZZZZZZZZZZZZZZZZZZ-","piiReplacements":0}},{"input":"123 deploy.sh:/api/users/12345/orders/987user [email protected] logged in=warnerror.12.5 | =é@example.com,event_libssl.so\n","output":{"output":"123 deploy.sh:/api/users/12345/orders/987user {{REDACTED}} logged in=warnerror.12.5 | =é@example.com,event_libssl.so\n","piiReplacements":1}},{"input":"Wed Jan 15 10:00:00 UTC 2025_İstanbul.Infinity\\\nA[email protected]","output":{"output":"Wed Jan 15 10:00:00 UTC 2025_İstanbul.Infinity\\\n{{REDACTED}}@api.example.com","piiReplacements":1}},{"input":"job_12345cus_ABCDEFGHIJKLMN.10.0.0.256\"日本語 @","output":{"output":"job_12345cus_ABCDEFGHIJKLMN.10.0.0.256\"日本語 @","piiReplacements":0}}]}diff --git a/rust/logs-ingestion/tests/fixtures/fuzz/regression-inputs.json b/rust/logs-ingestion/tests/fixtures/fuzz/regression-inputs.jsonnew file mode 100644index 000000000000..eb5007269d95--- /dev/null+++ b/rust/logs-ingestion/tests/fixtures/fuzz/regression-inputs.json@@ -0,0 +1 @@+{"numbers": ["403ed2f500000000", "40672c2440000000", "406e162740000000", "4096addf90000000", "409aab1cd0000000", "40a17dfc48000000", "40a219b348000000", "40a82f6668000000", "40af64ed28000000", "40c2109f94000000", "40c2210a84000000", "40c3ec3c54000000", "40c4ce8754000000", "40c5689ce4000000", "40ca810c64000000", "40ce5167d4000000", "40ceade5a4000000", "40d05e3032000000", "40d0b243b2000000", "40d0d1c63a000000", "40d1035212000000", "40d2c2233a000000", "40d5bb538a000000", "40d8f78eaa000000", "40d9f6864a000000", "40da3d304a000000", "40dcc8b74a000000", "40dd4c22ca000000", "40f04729c9000000", "40f38d8461000000", "40f592fc91000000", "40f6e9a549000000", "40f7b0c3d5000000", "40f9caac45000000", "40fa884cfd000000", "40fd4887a1000000", "40fd58f9f1000000", "41012f22de800000", "410187dbce800000", "41029f52d0800000", "410449ef26800000", "4105335104800000", "4106a69efe800000", "4108c6c8a8800000", "4109a18a30800000", "4109e5f3ce800000", "410a068576800000", "410a2fa10c800000", "410d8c445c800000", "410d9f2e12800000", "410fbf3880800000", "412145f2a2400000", "41223c9caf400000", "412273ce7c400000", "4122fbd19c400000", "41232f8751400000", "4123fa00ec400000", "4124523e8d400000", "412467dba1400000", "4125936ff2400000", "412638857d400000", "4127a90337400000", "4128170ebf400000", "4129b9f863400000", "412aed9238400000", "412b82dd21400000", "412ed1b220400000", "412f0b1316400000", "4302399b5699393a", "430d418eb0433392", "431c3c37c8273ac1", "431fbc4cb3726029", "c30d76ba201b3f82"], "dates": ["--12:00:00.1234561970jan2025-13-01-", "-0800", "-0800 1", "-0800 12:00", "-0800 12:00 Jan 1", "-0800 12:00:00", "-0800 12:00:00.123", "-0800 12:00:00.123456", "-0800 12:00:00.1234561970", "-0800GMT12:00:00", "-0800GMT12:00:00.1234561970", "-2025 12:00", "-800 12:00", "0800 12:00", "12:00:00.1231736942400 Jan-2025-1-5+02:00", "12:00:00.1234562025-00-10 02025/01/15pm:", "12:00:00.1234562025/01/15", "12:00:00.1234562025/01/15Z+2+231 ", "2025-02-29T12:00:00.1234561550", "1-12:00:00.1234562025-13-01UT"], "avro": ["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", "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", "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", "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", "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", "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", "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", "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"]}\ No newline at end of filediff --git a/rust/logs-ingestion/tests/fixtures/fuzz/retention.json b/rust/logs-ingestion/tests/fixtures/fuzz/retention.jsonnew file mode 100644index 000000000000..b8d2a5193ac0--- /dev/null+++ b/rust/logs-ingestion/tests/fixtures/fuzz/retention.json@@ -0,0 +1 @@+{"cases":[{"input":{"rules":[{"id":"r0","config":{"retention_days":1,"filter_group":{"type":"AND","values":[]}}}],"records":[{"uuid":"u0","trace_id":{"$bytes":"6d1b1a77333ee3b9f4af305a96f7805a"},"span_id":{"$bytes":"b81c2b3146767a74"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"🚀warn\"quoted\"","severity_text":"Warn","severity_number":12,"service_name":"API","resource_attributes":{"1":"\"true\"","constructor":"0.1","service.name":"1e+21","host":"\"POST\""},"instrumentation_scope":null,"event_name":"","attributes":null,"bytes_uncompressed":671},{"uuid":"u1","trace_id":{"$bytes":"c079b50cd7c4fc6b"},"span_id":null,"trace_flags":null,"timestamp":1736943318354000,"observed_timestamp":1736944633250000,"body":"0 \n","severity_text":"ERRor","severity_number":-1,"service_name":"worker","resource_attributes":{"host":"0.1"},"instrumentation_scope":null,"event_name":"","attributes":{"valueOf":"\"NaN\"","length":"\\"},"bytes_uncompressed":576},{"uuid":"u2","trace_id":{"$bytes":"c3a210be78fcf2c5eada31feb6d118d6"},"span_id":{"$bytes":"2b4895d16e11e251"},"trace_flags":null,"timestamp":1736943599156000,"observed_timestamp":1736944633250000,"body":"ၮ","severity_text":"Warn","severity_number":17,"service_name":"worker","resource_attributes":null,"instrumentation_scope":null,"event_name":"request","attributes":{"__defineGetter__":"\"\\\"a\\\\\\\\nbx\\\"\"","é":"true","kind":"GET"},"bytes_uncompressed":1299},{"uuid":"u3","trace_id":{"$bytes":"b57e9ab59c1914df"},"span_id":{"$bytes":"21b7bc6bbd544f00"},"trace_flags":null,"timestamp":1736943701149000,"observed_timestamp":1736944633250000,"body":"/api/v1/users/123debug韽 hasOwnProperty","severity_text":"","severity_number":-1,"service_name":"web","resource_attributes":{"1":"2.5e-8","a":"null","uuid_3fa85f64-5717-4562-b3fc-2c963f66afa6":"1e+100"},"instrumentation_scope":null,"event_name":"","attributes":{"constructor":"false"},"bytes_uncompressed":1452},{"uuid":"s4","trace_id":{"$bytes":"9037985723acaa859dd8d5971020b7a5"},"span_id":null,"timestamp":1736942673110000,"end_time":1736942673105000,"name":"","kind":9,"status_code":3,"service_name":null,"resource_attributes":null,"attributes":{"日本":"\"\"","http.route":"\"ERROR\"","level":"Infinity"}}]},"output":[null,null,null,null,null]},{"input":{"rules":[{"id":"r0","config":{"retention_days":60,"filter_group":{"type":"AND","values":[{"key":"payload","operator":"bogus","value":4294967295,"type":"span_attribute"},{"key":"status_code","operator":"lt","value":1.7976931348623157e+308,"type":"span_resource_attribute"}]}}},{"id":"r1","config":{"retention_days":60,"filter_group":{"type":"OR","values":[null]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":null,"filter_group":{"type":"AND","values":[{"key":"1","operator":"is_not_set","value":[null],"type":"span_resource_attribute"}]}}},{"id":"r1","config":{"retention_days":2580,"filter_group":{"type":"OR","values":[{"key":"1","operator":"not_regex","value":"k","type":"span_resource_attribute"},{"key":true,"operator":"exact","value":"\"","type":"log_attribute"},null]}}},{"id":"r2","config":{"retention_days":-1,"filter_group":{"type":"OR","values":[{"type":"OR","values":[{"type":"AND","values":[{"type":"OR","values":[{"key":"message","operator":"in","value":"3fa85f64-5717-4562-b3fc-2c963f66afa6","type":"span_resource_attribute"},{"key":"http.method","operator":"bogus","value":"ERROR","type":"log_attribute"},{"key":"kind","operator":"exact","value":"ΣΑΣ","type":"span_resource_attribute"}]}]},{"key":"a","operator":"is_not_set","value":"api","type":"log_resource_attribute"},{"key":"http.method","operator":"gt","value":false,"type":"log"}]},{"key":"name","operator":"regex","value":"(?=x)","type":"log"},{"key":"level","operator":"not_icontains","value":1.7976931348623157e+308,"type":"log_attribute"}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":2580,"filter_group":{"type":"AND","values":[]}}},{"id":"r1","config":{"retention_days":1,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[{"type":"AND","values":[]}]},{"type":"AND","values":[{"type":"OR","values":[{"key":"level","operator":"not_icontains","value":"GET","type":"log_resource_attribute"}]}]}]}]}}},{"id":"r2","config":{"retention_days":60,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"toString","value":["x","api",1e+21],"type":"event"},null,{"key":"toString","operator":"bogus","value":"00","type":"log_resource_attribute"}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":90,"filter_group":{"type":"OR","values":[null]}}},{"id":"r1","config":{"retention_days":1,"filter_group":{"type":"OR","values":[{"type":"AND","values":[{"type":"OR","values":[{"type":"OR","values":[{"type":"AND","values":[{"type":"AND","values":[{"key":"count","operator":"not_regex","value":"a{,5}","type":"event"},{"key":"1","operator":"exact","value":[true,"GET"],"type":"span_attribute"}]}]},{"key":"service.name","operator":"not_icontains","value":{},"type":"event"},{"key":"k8s.pod.name","operator":"gte","value":"AKIAIOSFODNN7EXAMPLE","type":"span_attribute"}]}]}]},{"key":"severity_level","operator":"starts_with","value":1.5,"type":"log_resource_attribute"}]}}},{"id":"r2","config":{"retention_days":60,"filter_group":{"type":"AND","values":[{"key":"status_code","operator":"regex","value":"\\Z","type":"log_resource_attribute"}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":90,"filter_group":{"type":"AND","values":[null]}}},{"id":"r1","config":{"retention_days":60,"filter_group":{"type":"OR","values":[]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":90,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[{"key":"message","value":{},"type":"log_resource_attribute"}]}]},{"key":"url.path","operator":"lte","value":"1e400","type":"log_attribute"},{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[null]}]}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":null,"filter_group":{"type":"OR","values":[]}}},{"id":"r1","config":{"retention_days":null,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"message","operator":"not_regex","type":"span_resource_attribute"},{"key":"count","operator":"starts_with","value":false,"type":"span_resource_attribute"},{"key":"constructor","operator":"is_set","value":"null","type":"event"}]}]}}},{"id":"r2","config":{"retention_days":60,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[null]},{"type":"AND","values":[{"type":"OR","values":[{"key":"severity_text","operator":"gt","value":0.000001,"type":"log"},{"key":5,"operator":"not_regex","value":"(a{100}){11}","type":"span_resource_attribute"}]},{"key":"k8s.pod.name","operator":"in","value":["api"],"type":"log_attribute"}]}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":30,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"OR","values":[{"key":"severity_text","operator":"lt","value":"error"},null]},{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[]}]}]}]}]}}},{"id":"r1","config":{"retention_days":60,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"severity_level","operator":"not_icontains","value":{"a":1}}]}]}}},{"id":"r2","config":{"retention_days":0,"filter_group":{"type":"OR","values":[{"key":"count","operator":"regex","value":"(","type":"log_attribute"}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":-1,"filter_group":{"type":"AND","values":[{"type":"OR","values":[]}]}}}],"records":[{"uuid":"s0","trace_id":{"$bytes":"56203e747aae4fce8f9cf4d6936056ee"},"span_id":{"$bytes":"c1d51c978fa8e53c"},"timestamp":1736942915865000,"end_time":null,"name":"db.query","kind":3,"status_code":-1,"service_name":"api","resource_attributes":{"1":"\"true\"","k8s.pod.name":"4294967294"},"attributes":{"é":"INFO","01":"\"\\\"quoted\\\"\""}},{"uuid":"s1","trace_id":{"$bytes":"092b097cb817895c2a3224539f1e86b1"},"span_id":{"$bytes":"4c68c0f7bf22df83"},"timestamp":1736943706478000,"end_time":1736943706478999,"name":"","kind":9,"status_code":null,"service_name":"worker","resource_attributes":{"a":"2025-01-15T10:00:00Z","constructor":"\"Bearer abc.def-ghi\""},"attributes":{"name":"00","9007199254740993":"\"2001:db8::1 length\""}},{"uuid":"u2","trace_id":{"$bytes":"d647b1ad9deffa95abeb3864562ff854"},"span_id":{"$bytes":"441b3f445b0bb08c"},"trace_flags":null,"timestamp":1736943924124000,"observed_timestamp":1736944633250000,"body":null,"severity_text":"DEBUG","severity_number":1,"service_name":"worker","resource_attributes":{"1":"9007199254740992","constructor":"0.000001","service.name":"1e+21","k8s.pod.name":"12","a":"\"Infinity\""},"instrumentation_scope":null,"event_name":"","attributes":{"kind":"true","payload.x":"\"1,5\""},"bytes_uncompressed":1687},{"uuid":"u3","trace_id":{"$bytes":""},"span_id":{"$bytes":"dce98490de68c0e2"},"trace_flags":null,"timestamp":1736943214342000,"observed_timestamp":1736944633250000,"body":"00 null -0 ","severity_text":"warning","severity_number":1,"service_name":"","resource_attributes":{"0":"\"POST\""},"instrumentation_scope":null,"event_name":"","attributes":null,"bytes_uncompressed":null},{"uuid":"u4","trace_id":{"$bytes":"733cafc70fd4f307"},"span_id":{"$bytes":"605f01d4bb51476e"},"trace_flags":null,"timestamp":1736943749004000,"observed_timestamp":1736944633250000,"body":"0.000001Infinity1e3user.email1e3","severity_text":"fatal","severity_number":null,"service_name":"","resource_attributes":{"service.name":"false","constructor":"\u000b"},"instrumentation_scope":null,"event_name":null,"attributes":{},"bytes_uncompressed":920}]},"output":[null,null,null,null,null]},{"input":{"rules":[{"id":"r0","config":{"retention_days":2580,"filter_group":{"type":"AND","values":"x"}}},{"id":"r1","config":{"retention_days":60,"filter_group":{"type":"AND","values":[{"key":"http.method","operator":"is_not","value":[["n"],null,1e+21],"type":"span_resource_attribute"},null]}}},{"id":"r2","config":{"retention_days":null,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[{"key":"count","operator":"is_not","value":true,"type":"log"},{"key":"1","operator":"not_starts_with","value":1e-7,"type":"log_resource_attribute"},{"key":"kind","operator":"exact","value":-9007199254740992,"type":"log"}]}]}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":60,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"__defineGetter__","operator":"starts_with","value":true,"type":"span_attribute"},{"key":"1","operator":"lte","value":"AKIAIOSFODNN7EXAMPLE","type":"span_attribute"},null]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":2580,"filter_group":{"type":"AND","values":[null]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":90,"filter_group":{"type":"OR","values":[{"key":"missing","operator":"is_set","value":"ς","type":"log_resource_attribute"},{"type":"AND","values":[null]}]}}},{"id":"r1","config":{"retention_days":-1,"filter_group":{"type":"OR","values":[{"key":"toString","operator":"icontains","value":"\"quoted\"","type":"log_resource_attribute"},{"key":"a","operator":"icontains","type":"span_attribute"},{"key":"count","operator":"icontains","value":[["n"],true,true]}]}}},{"id":"r2","config":{"retention_days":-1,"filter_group":{"type":"AND","values":[{"type":"OR","values":[]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":90,"filter_group":{"type":"AND","values":[{"type":"AND","values":[]}]}}}],"records":[{"uuid":"u0","trace_id":{"$bytes":"7b62226c49d0616a4d94c68a59957b13"},"span_id":null,"trace_flags":null,"timestamp":1736944044747000,"observed_timestamp":1736944633250000,"body":"deadbeefvalueOfnull 0 ","severity_text":"WARN","severity_number":9,"service_name":"api","resource_attributes":{"1":"\r\n","\\":"null","a":"0.000001 ","constructor":"\"\\r\\n\"","host":"5.ﳝ"},"instrumentation_scope":null,"event_name":null,"attributes":null,"bytes_uncompressed":1786},{"uuid":"u1","trace_id":{"$bytes":"6be7b74618ae33e2293cc9cbfe565151"},"span_id":{"$bytes":"dd6129a0f670e044"},"trace_flags":null,"timestamp":1736943420303000,"observed_timestamp":1736944633250000,"body":"4294967295 9007199254740992 ɀ","severity_text":"trace","severity_number":5,"service_name":"API","resource_attributes":null,"instrumentation_scope":null,"event_name":"","attributes":{},"bytes_uncompressed":157},{"uuid":"u2","trace_id":{"$bytes":""},"span_id":{"$bytes":"44e0db81071b365a"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"kAKIAIOSFODNN7EXAMPLEPOST 2025-01-15T10:00:00Zhost.example.com","severity_text":"info","severity_number":-1,"service_name":"","resource_attributes":{"1":"\"x\""},"instrumentation_scope":null,"event_name":"","attributes":{"1":"\"INFO\"","payload":"\"\""},"bytes_uncompressed":null},{"uuid":"s3","trace_id":{"$bytes":"9f3defb47d1532070734303508e889db"},"span_id":null,"timestamp":1736942998917000,"end_time":1736942998917999,"name":"GET /a","kind":6,"status_code":-1,"service_name":"api","resource_attributes":{"service.name":"\".5\"","k8s.pod.name":"null","a":"null"},"attributes":{"1":"\"error\"","http.status_code":"false","status_code":"0","payload":"\"debug\""}},{"uuid":"u4","trace_id":{"$bytes":"8a8edea1d19316ac679a207def26f7f3"},"span_id":null,"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"\"1210日本語 ","severity_text":"debug ","severity_number":5,"service_name":"worker","resource_attributes":{},"instrumentation_scope":null,"event_name":"request","attributes":{"path":"\"\\\\\"","http.response.status_code":"\" \""},"bytes_uncompressed":211}]},"output":[null,null,null,null,null]},{"input":{"rules":[{"id":"r0","config":{"retention_days":60,"filter_group":{"type":"AND","values":[null]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":2580,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"message","operator":"is_not","value":1e+100,"type":"log"}]}]}}},{"id":"r1","config":"x"}],"records":[{"uuid":"s0","trace_id":{"$bytes":"b051099b757e5599c8ba56592a256949"},"span_id":null,"timestamp":1736944512582000,"end_time":1736944512577000,"name":"GET /a","kind":0,"status_code":3,"service_name":"worker","resource_attributes":{"a":"\"debug\"","payload":"-1.5"},"attributes":{"é":"a\\nb"}},{"uuid":"u1","trace_id":null,"span_id":{"$bytes":"8b0902cca02697f1"},"trace_flags":null,"timestamp":1736943112865000,"observed_timestamp":1736944633250000,"body":"eventړ","severity_text":null,"severity_number":null,"service_name":null,"resource_attributes":{"1":"\"-0\"","k8s.pod.name":"\"xoxb-1234567890-abc\"","-1":"xoxb-1234567890-abc日本語 12","constructor":"true","a":"\"0x10\""},"instrumentation_scope":null,"event_name":"","attributes":{"count":"\"1_000\"","user.email":".5"},"bytes_uncompressed":null},{"uuid":"s2","trace_id":{"$bytes":"05ca93971777089f8591054055c82f21"},"span_id":{"$bytes":"d19562d6bf275b80"},"timestamp":null,"end_time":1736955512468001,"name":"","kind":null,"status_code":-1,"service_name":null,"resource_attributes":{"k8s.pod.name":"\"\\\"\"","service.name":"\" \""},"attributes":{"K":"100","constructor":"\"debug\"","k8s.pod.name":"Infinity","service.name":"\"999.9999999\""}},{"uuid":"u3","trace_id":{"$bytes":""},"span_id":{"$bytes":"1e6593c62fd4a35a"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"fatal","severity_text":"ERRor","severity_number":12,"service_name":null,"resource_attributes":{"a":"1.7976931348623157e+308","�":"\" 12\"","user.email":"x","k8s.pod.name":"999.9999999","constructor":" "},"instrumentation_scope":null,"event_name":"request","attributes":null,"bytes_uncompressed":null},{"uuid":"u4","trace_id":null,"span_id":{"$bytes":"ffd24d661c91d51c"},"trace_flags":null,"timestamp":1736944469743000,"observed_timestamp":1736944633250000,"body":"debug host.example.com+5𐀀.5 ","severity_text":"INFO","severity_number":9,"service_name":"","resource_attributes":{"constructor":"null","host":"\" 12\""},"instrumentation_scope":null,"event_name":"","attributes":{},"bytes_uncompressed":888}]},"output":[null,2580,null,2580,2580]},{"input":{"rules":[{"id":"r0","config":{"retention_days":60,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":true,"operator":"in","value":"GET","type":"span_attribute"}]}]}}},{"id":"r1","config":{"retention_days":60,"filter_group":{"type":"AND","values":[null]}}},{"id":"r2","config":{"retention_days":null,"filter_group":{"type":"OR","values":[{"key":"k8s.pod.name","operator":"regex","value":"\\pL","type":"log_attribute"},{"key":"severity_text","operator":"not_in","value":{"toString":1},"type":"log"},{"type":"AND","values":[{"type":"AND","values":[{"key":"http.method","operator":"in","value":[1,"GET"],"type":"log_resource_attribute"}]}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":"30","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"http.method","operator":"lt","type":"span_resource_attribute"},{"type":"AND","values":[{"type":"AND","values":[{"key":"ms","value":-9007199254740992,"type":"event"},{"key":"payload","operator":"gte","value":{"toString":1},"type":"log_resource_attribute"}]}]},{"key":"1","operator":"gte","value":["x",{"toString":1}]}]}]}}},{"id":"r1","config":{"retention_days":90,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[null]}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":-1,"filter_group":{"type":"OR","values":[{"key":"service.name","value":true,"type":"event"},{"type":"AND","values":[{"type":"OR","values":[{"key":"name","operator":"in","value":1.5,"type":"span_attribute"},{"key":"missing","operator":"is_not","value":"1e3","type":"log_attribute"}]}]}]}}},{"id":"r1","config":{"retention_days":30,"filter_group":{"type":"AND","values":[null]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":90,"filter_group":{"type":"AND","values":[null]}}},{"id":"r1","config":{"retention_days":90,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"name","operator":"is_set","value":"12.5abc","type":"log_resource_attribute"}]}]}}},{"id":"r2","config":{"retention_days":null,"filter_group":{"type":"OR","values":[]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":30,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[]}]},{"type":"AND","values":[{"type":"OR","values":[{"key":"ms","operator":"is_not","value":123456789012345680000,"type":"span_attribute"},{"key":"a","operator":"gt","value":9007199254740994,"type":"log_attribute"},{"type":"AND","values":[null]}]}]},{"key":"missing","operator":"is_set","value":"0b11","type":"span_resource_attribute"}]}]}}},{"id":"r1","config":{"retention_days":90,"filter_group":{"type":"AND","values":[{"key":"http.method","operator":"gt","value":"0b11","type":"log_attribute"}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":"x"}],"records":[{"uuid":"s0","trace_id":null,"span_id":{"$bytes":"ac5cc1018219ad12"},"timestamp":1736942336300000,"end_time":1736942336301000,"name":"","kind":null,"status_code":2,"service_name":"api","resource_attributes":{"\\":"\"false\""},"attributes":{"kind":"\"a\\\\nb\"","name":"\" 12 \"","constructor":"\"Wed, 15 Jan 2025 12:00:00 GMT\"","http.route":"\"\\\"日本語 12 \\\"\"","http.server.duration_ms":"\"null\""}},{"uuid":"u1","trace_id":{"$bytes":"7c73a98faa1897e2056df643c481afe2"},"span_id":{"$bytes":"574333a67703c04d"},"trace_flags":null,"timestamp":1736944528572000,"observed_timestamp":1736944633250000,"body":"AKIAIOSFODNN7EXAMPLE","severity_text":null,"severity_number":12,"service_name":"API","resource_attributes":null,"instrumentation_scope":null,"event_name":"request","attributes":{"payload.0":"false","constructor":"\"1e3\"","a.b":"\"1_000\""},"bytes_uncompressed":1879},{"uuid":"s2","trace_id":{"$bytes":"ca85a5e02b3f3b685a3e5a13f1fbba6a"},"span_id":{"$bytes":"88009b49dad4bfee"},"timestamp":1736943458493000,"end_time":1736943458494000,"name":"db.query","kind":9,"status_code":3,"service_name":"worker","resource_attributes":{"a":"0.000001","k8s.pod.name":"false","service.name":"true"},"attributes":{"status_code":"true","path":"\"xoxb-1234567890-abc\""}},{"uuid":"u3","trace_id":{"$bytes":"c56332e1cdf57fa6cdaa5b669dbda016"},"span_id":null,"trace_flags":null,"timestamp":1736942884680000,"observed_timestamp":1736944633250000,"body":"Bearer abc.def-ghiNaN 1","severity_text":"info","severity_number":12,"service_name":"api","resource_attributes":null,"instrumentation_scope":null,"event_name":"","attributes":null,"bytes_uncompressed":801},{"uuid":"u4","trace_id":{"$bytes":"1b6faa508ad597156221b16cc2ba2cb0"},"span_id":{"$bytes":"f176e79483ba497e"},"trace_flags":null,"timestamp":1736942764324000,"observed_timestamp":1736944633250000,"body":null,"severity_text":"INFO","severity_number":-1,"service_name":null,"resource_attributes":{"service.name":"false","a.b":"null","a":"\"true\"","constructor":"1,5"},"instrumentation_scope":null,"event_name":null,"attributes":{"http.server.duration_ms":"123456789012345680000","constructor":"null","url.path":"-9007199254740992","http.route":"\"\\\"\"","http.method":"\"xoxb-1234567890-abc\""},"bytes_uncompressed":338}]},"output":[null,null,null,null,null]},{"input":{"rules":[{"id":"r0","config":{"retention_days":0,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[{"key":"__proto__","operator":"not_icontains","value":[true,null,"true"],"type":"event"}]}]},{"key":"k8s.pod.name","operator":"not_in","value":[],"type":"log_attribute"}]}]}}},{"id":"r1","config":{"retention_days":90,"filter_group":{"type":"AND","values":[null]}}},{"id":"r2","config":{"retention_days":1,"filter_group":{"type":"AND","values":[{"type":"OR","values":[]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":2580,"filter_group":{"type":"AND","values":[{"key":"ms","operator":"in","value":"日本語","type":"log"},null]}}},{"id":"r1","config":{"retention_days":90,"filter_group":{"type":"OR","values":[{"key":"k8s.pod.name","operator":"not_regex","value":["a","b"],"type":"span_resource_attribute"},{"type":"AND","values":[{"key":"__proto__","operator":"not_ends_with","value":false,"type":"log"}]},{"type":"OR","values":[{"key":"service_name","operator":"bogus","value":1e+21,"type":"span_resource_attribute"},{"key":"__proto__","operator":"lt","value":1,"type":"log_attribute"}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":-1,"filter_group":{"type":"OR","values":[{"key":"http.method","operator":"not_ends_with","value":100,"type":"log_resource_attribute"}]}}},{"id":"r1","config":{"retention_days":60,"filter_group":{"type":"OR","values":[{"type":"OR","values":[{"type":"AND","values":[{"key":"toString","operator":"lte","value":".5","type":"log"}]},{"type":"AND","values":[null]},{"key":"__defineGetter__","operator":"regex","value":"^\\s*$","type":"span_attribute"}]},{"key":"count","operator":"not_ends_with","value":"false","type":"span_attribute"}]}}},{"id":"r2","config":{"retention_days":90,"filter_group":{"type":"AND","values":[{"key":"count","operator":"is_not_set","value":" 12","type":"log_attribute"},{"key":"__defineGetter__","operator":"gte","value":"12","type":"event"},{"key":"count","operator":"regex","value":true,"type":"span_resource_attribute"}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":90,"filter_group":{"type":"OR","values":[{"type":"OR","values":[{"key":"level","operator":"starts_with","value":"ERROR","type":"log"}]},{"key":"payload","operator":"exact","value":"0b11","type":"span_attribute"},null]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":90,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"count","operator":"regex","value":"[a-z]+","type":"log_attribute"},{"key":"name","operator":"starts_with","value":{},"type":"span_resource_attribute"},{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[{"key":"name","operator":"bogus","value":[[1,2],3]}]},{"type":"AND","values":[{"type":"AND","values":[{"key":"__proto__","value":123456789012345680000,"type":"log_resource_attribute"},{"key":"message","operator":"is_not_set","value":" 12","type":"span_attribute"}]}]},null]}]}]}]}]}]}}},{"id":"r1","config":{"retention_days":0,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"missing","operator":"gte","value":1e+21,"type":"event"},{"key":"url.path","operator":"gte","value":["x",{"toString":1}],"type":"log_attribute"}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":2580,"filter_group":{"type":"OR","values":[{"type":"AND","values":[{"type":"OR","values":[null]}]}]}}},{"id":"r1","config":{"retention_days":2580,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[{"type":"OR","values":[{"key":"missing","operator":"gte","value":false,"type":"log_attribute"}]}]},{"key":"severity_text","operator":"gte","type":"log_attribute"}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":30,"filter_group":{"type":"AND","values":[{"type":"OR","values":[]}]}}}],"records":[{"uuid":"s0","trace_id":{"$bytes":"6c3d200efdfdeade9d524164f6668aea"},"span_id":{"$bytes":"88678f70aed67a51"},"timestamp":1736943177581000,"end_time":null,"name":"","kind":5,"status_code":2,"service_name":"api","resource_attributes":{"k8s.pod.name":"7","service.name":"\"12\"","a":"1.5"},"attributes":null},{"uuid":"u1","trace_id":{"$bytes":"a257c06b0c4b3ac2ad5efa052f9ebe60"},"span_id":{"$bytes":"51008ca85de89d0a"},"trace_flags":null,"timestamp":1736942470053000,"observed_timestamp":1736944633250000,"body":"3fa85f64-5717-4562-b3fc-2c963f66afa6 GET ","severity_text":"debug ","severity_number":9,"service_name":"","resource_attributes":{},"instrumentation_scope":null,"event_name":"","attributes":{"path":"null","user.email":"9007199254740992"},"bytes_uncompressed":null},{"uuid":"s2","trace_id":{"$bytes":"a7bf9c1ce5258a6d54aaccb8bc7457c7"},"span_id":{"$bytes":"d0e8b69f1abc6181"},"timestamp":1736943108988000,"end_time":1736943108989500,"name":"GET /a","kind":0,"status_code":null,"service_name":"worker","resource_attributes":{"a":"[]","service.name":"\"null\""},"attributes":{}},{"uuid":"s3","trace_id":{"$bytes":"eaa5d9dab8103de0b425112d6c8bf5a3"},"span_id":{"$bytes":"28b03af55dc44a89"},"timestamp":1736943651944000,"end_time":1736943659194125,"name":"","kind":4,"status_code":0,"service_name":"worker","resource_attributes":{"2":"7","a":"AKIAIOSFODNN7EXAMPLE","service.name":"\"x\""},"attributes":{"name":"1.5","ms":"\"\\r\\n\"","payload":"null"}},{"uuid":"u4","trace_id":null,"span_id":{"$bytes":"18986dc809ec53cb"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"true-1","severity_text":null,"severity_number":17,"service_name":"web","resource_attributes":{},"instrumentation_scope":null,"event_name":"","attributes":{"http.server.duration_ms":"\"null\"","2025-01-15T10:00:00ZWed, 15 Jan 2025 12:00:00 GMT ":"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123","http.status_code":"[[]]","deadbeef":"\"Wed, 15 Jan 2025 12:00:00 GMT\"","level":"\"2025-01-15T10:00:00Z\"","valueOf":"\"GET\""},"bytes_uncompressed":1587}]},"output":[null,null,null,null,null]},{"input":{"rules":[{"id":"r0","config":{"retention_days":30,"filter_group":{"type":"AND","values":[{"type":"AND","values":[]}]}}},{"id":"r1","config":null}],"records":[{"uuid":"u0","trace_id":{"$bytes":""},"span_id":{"$bytes":"bec9f71d06ef7eb8"},"trace_flags":null,"timestamp":1736942312895000,"observed_timestamp":1736944633250000,"body":"100 🚀","severity_text":"INFO","severity_number":17,"service_name":"web","resource_attributes":null,"instrumentation_scope":null,"event_name":"request","attributes":{"12":"0.30000000000000004","user.email":"null","é":"\"null\""},"bytes_uncompressed":null},{"uuid":"s1","trace_id":null,"span_id":{"$bytes":"ca84f762d61faa03"},"timestamp":1736942982834000,"end_time":1736942990084125,"name":"","kind":4,"status_code":2,"service_name":null,"resource_attributes":{"service.name":"\\ ","a":"\"12\"","\\":"1","k8s.pod.name":"\"12\""},"attributes":{"k":"\"+5\""}},{"uuid":"u2","trace_id":{"$bytes":""},"span_id":null,"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":" 日本lengthé0","severity_text":"INFO","severity_number":null,"service_name":null,"resource_attributes":{},"instrumentation_scope":null,"event_name":"","attributes":{},"bytes_uncompressed":1436},{"uuid":"s3","trace_id":{"$bytes":"a69d2a044de443b6453ea00d8061cce0"},"span_id":null,"timestamp":1736944348966000,"end_time":1736956348966001,"name":null,"kind":1,"status_code":0,"service_name":"api","resource_attributes":{"a":"\"1_000\"","service.name":"\"1.5\""},"attributes":{"__defineGetter__":"\"+5\"","3fa85f64-5717-4562-b3fc-2c963f66afa6":"9007199254740994","message":"true","payload":"וּ\""}},{"uuid":"u4","trace_id":{"$bytes":"976d44aad711b9ad4807b00d77a6ee97"},"span_id":null,"trace_flags":null,"timestamp":1736942705968000,"observed_timestamp":1736944633250000,"body":"xoxb-1234567890-abc 1_000 2025-01-15T10:00:00Z","severity_text":"","severity_number":0,"service_name":"","resource_attributes":{"1.5":"null"},"instrumentation_scope":null,"event_name":"","attributes":{"":"0"},"bytes_uncompressed":null}]},"output":[null,null,null,null,null]},{"input":{"rules":[{"id":"r0","config":{"retention_days":60,"filter_group":{"type":"AND","values":[{"key":"severity_text","operator":"exact","type":"log_attribute"}]}}},{"id":"r1","config":{"retention_days":2580,"filter_group":{"type":"AND","values":[{"type":"AND","values":[null]}]}}},{"id":"r2","config":{"retention_days":null,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[{"key":"constructor","operator":"not_starts_with","value":["x",{"toString":1}]},{"key":"message","operator":"in","value":"a\\nb","type":"log_resource_attribute"},{"key":"level","operator":"in","value":"True","type":"event"}]},{"key":"missing","operator":"lt","value":1e+21,"type":"log"},{"type":"OR","values":[{"key":"service_name","operator":"not_starts_with","value":{"a":1},"type":"log_resource_attribute"}]}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":30,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[null,{"key":"severity_text","operator":"gt","value":[1,"true","true"],"type":"log"}]}]},{"key":"level","operator":"gt","value":["GET","x","x"],"type":"log_resource_attribute"},{"key":"url.path","operator":"not_starts_with","value":[["n"],["n"],"GET"],"type":"log_resource_attribute"}]}]}]}]}}},{"id":"r1","config":{"retention_days":null,"filter_group":{"type":"AND","values":[{"key":"message","operator":"starts_with","value":9007199254740994,"type":"event"},{"key":"severity_level","operator":"not_starts_with","value":42,"type":"event"}]}}},{"id":"r2","config":{"retention_days":-1,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"key":"missing","operator":"in","value":true,"type":"span_resource_attribute"},{"key":"severity_level","operator":"regex","value":"^/api","type":"span_attribute"}]}]}]}]},{"key":"service.name","value":["true"]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":-1,"filter_group":{"type":"AND","values":[{"key":"url.path","operator":"in","value":" 12 ","type":"span_attribute"},{"key":"http.method","operator":"bogus","value":"xoxb-1234567890-abc","type":"span_attribute"}]}}},{"id":"r1","config":{"retention_days":2580,"filter_group":{"type":"OR","values":[{"key":"status_code","operator":"regex","value":"a{,5}"},{"type":"AND","values":[null]},{"key":"severity_level","operator":"not_in","value":"NaN","type":"log_attribute"}]}}},{"id":"r2","config":{"retention_days":0,"filter_group":{"type":"AND","values":[{"key":"status_code","operator":"icontains","value":[true,1e+21],"type":"log_resource_attribute"},{"key":"name","operator":"ends_with","value":"2001:db8::1","type":"log"},{"type":"AND","values":[]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":7,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"severity_text","operator":"starts_with","value":"Infinity","type":"span_resource_attribute"},{"key":"missing","operator":"gte","value":"false","type":"log_resource_attribute"}]}]}}},{"id":"r1","config":{"retention_days":7,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"url.path","operator":"not_in","value":" ","type":"span_attribute"},{"key":"toString","operator":"is_set","value":4294967295,"type":"log_resource_attribute"}]}]}}},{"id":"r2","config":{"retention_days":60,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[]}]},{"key":"name","operator":"gt","value":"192.168.1.1","type":"event"},{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[null]},{"type":"AND","values":[{"key":"1","operator":"gt","value":false,"type":"event"},{"key":"severity_level","operator":"not_regex","value":"^\\s*$","type":"log_attribute"}]},{"type":"AND","values":[{"type":"AND","values":[{"key":"constructor","operator":"is_set","type":"span_resource_attribute"},{"key":"service.name","operator":"is_not","value":[true,null],"type":"log_resource_attribute"}]}]}]}]},{"type":"AND","values":[{"type":"OR","values":[]}]}]}]}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":7,"filter_group":{"type":"AND","values":[{"type":"OR","values":[]}]}}}],"records":[{"uuid":"u0","trace_id":{"$bytes":"f1d316054386ba9f79d5c344b29d0665"},"span_id":{"$bytes":"7409d376e42e6439"},"trace_flags":null,"timestamp":1736942473021000,"observed_timestamp":1736944633250000,"body":" 12 POSTé ","severity_text":"ERROR","severity_number":5,"service_name":"API","resource_attributes":{"4294967294":" /api/v1/users/123999.9999999"},"instrumentation_scope":null,"event_name":"request","attributes":{"k":"2.5e-8","payload.x":"\"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abc123\"","http.route":"true","a":"\"sk_live_0123456789abcdefghijkl\""},"bytes_uncompressed":1628},{"uuid":"s1","trace_id":{"$bytes":"ba485c2e4c3045da11e82961f704fd69"},"span_id":null,"timestamp":null,"end_time":1736942240856125,"name":"GET /a","kind":4,"status_code":0,"service_name":"api","resource_attributes":{"service.name":"NaN100ѷ","a":"1e-7","k8s.pod.name":"null"},"attributes":{"message":"2.5e-8","a.b":"\"fatal\"","constructor":"\"warn\"","kind":"1"}},{"uuid":"u2","trace_id":{"$bytes":"42b4d720892a1a341cd18b7fe6e2ae80"},"span_id":{"$bytes":"24845c0a4364d801"},"trace_flags":null,"timestamp":1736944620521000,"observed_timestamp":1736944633250000,"body":"\"Infinity","severity_text":"fatal","severity_number":-1,"service_name":"API","resource_attributes":{"1":"4294967295","a":"0.1","host":"\"error\""},"instrumentation_scope":null,"event_name":"request","attributes":{"1":"\"[1,2]\"","valueOf":"9007199254740992","status_code":"false"},"bytes_uncompressed":null},{"uuid":"u3","trace_id":{"$bytes":"352fc6fc00334513"},"span_id":{"$bytes":"aad589759b3ad52a"},"trace_flags":null,"timestamp":1736942605015000,"observed_timestamp":1736944633250000,"body":"debug 1e4000","severity_text":"","severity_number":17,"service_name":"api","resource_attributes":{},"instrumentation_scope":null,"event_name":null,"attributes":{"http.server.duration_ms":"null","hasOwnProperty":"\"warn\"","k8s.pod.name":"false","url.path":"0.1","level":"true"},"bytes_uncompressed":null},{"uuid":"s4","trace_id":null,"span_id":{"$bytes":"54840d9fb6187e3f"},"timestamp":1736943932035000,"end_time":1736943932035999,"name":null,"kind":-1,"status_code":-1,"service_name":"worker","resource_attributes":{},"attributes":{"service.name":"false"}}]},"output":[null,null,null,null,null]},{"input":{"rules":[{"id":"r0","config":{"retention_days":2580,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":null,"operator":"gt","value":"GET","type":"log_attribute"}]}]}}},{"id":"r1","config":{"retention_days":"30","filter_group":{"type":"AND","values":[{"type":"OR","values":[]}]}}},{"id":"r2","config":{"retention_days":90,"filter_group":{"type":"AND","values":[{"key":true,"value":"+5","type":"log_resource_attribute"},{"type":"AND","values":[null]},{"key":"severity_level","operator":"lte","value":"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé","type":"log_attribute"}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":-1,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":true,"operator":"icontains","value":["x",["n"]]},{"key":"service_name","operator":"starts_with","value":[1e+21,["n"],null],"type":"log_attribute"}]}]}}}],"records":[{"uuid":"u0","trace_id":null,"span_id":{"$bytes":"827a064799892bf9"},"trace_flags":null,"timestamp":1736942740070000,"observed_timestamp":1736944633250000,"body":"🚀error ","severity_text":"debug ","severity_number":9,"service_name":"API","resource_attributes":{},"instrumentation_scope":null,"event_name":"request","attributes":null,"bytes_uncompressed":560},{"uuid":"s1","trace_id":{"$bytes":"ed9c6ec742da3125a7625f9d1a43ab4a"},"span_id":null,"timestamp":1736942378078000,"end_time":1736942378078999,"name":"db.query","kind":6,"status_code":null,"service_name":"worker","resource_attributes":{"service.name":"10","a":"\"ghp_0123456789abcdefghij0123456789abcdef\"","k8s.pod.name":"1e-7"},"attributes":{"kind":"a\\nb","2001:db8::1":"\"xoxb-1234567890-abc\""}},{"uuid":"u2","trace_id":null,"span_id":{"$bytes":"efd8b41806847fb6"},"trace_flags":null,"timestamp":1736942295376000,"observed_timestamp":1736944633250000,"body":"00true{\"a\":1} \\ 01","severity_text":"","severity_number":5,"service_name":"","resource_attributes":{"1":"\" 12\"","":"2.5e-8"},"instrumentation_scope":null,"event_name":null,"attributes":{"http.response.status_code":"\"1e3\""},"bytes_uncompressed":977},{"uuid":"u3","trace_id":{"$bytes":"3073e7ced960d37ca4029031d94ad657"},"span_id":{"$bytes":"6f1563b0c9a71555"},"trace_flags":null,"timestamp":1736942836648000,"observed_timestamp":1736944633250000,"body":null,"severity_text":"ERRor","severity_number":5,"service_name":"api","resource_attributes":{},"instrumentation_scope":null,"event_name":"request","attributes":{"level":"12.5"},"bytes_uncompressed":null},{"uuid":"u4","trace_id":{"$bytes":"a96f16ce3912bafbf6304a6e06123f06"},"span_id":{"$bytes":"c911c66eed7cd927"},"trace_flags":null,"timestamp":1736944008100000,"observed_timestamp":1736944633250000,"body":null,"severity_text":"WARN","severity_number":-1,"service_name":"worker","resource_attributes":null,"instrumentation_scope":null,"event_name":"","attributes":{},"bytes_uncompressed":312}]},"output":[null,null,null,null,null]},{"input":{"rules":[{"id":"r0","config":{"retention_days":60,"filter_group":{"type":"AND","values":[null]}}},{"id":"r1","config":{"retention_days":1,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[{"type":"OR","values":[]}]},{"key":"level","operator":"ends_with","value":"-1e400","type":"log"}]},{"key":"service_name","operator":"not_starts_with","value":false,"type":"span_resource_attribute"},{"type":"AND","values":[]}]}}},{"id":"r2","config":{"retention_days":null,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":true,"operator":"not_in","value":" 12 ","type":"span_resource_attribute"},{"key":"a","operator":"in","value":5e-324,"type":"log"}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":7,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"a","operator":"exact","value":"","type":"log"}]}]}}}],"records":[{"uuid":"u0","trace_id":{"$bytes":"cc942b80f9048d0e604eca33eb45684c"},"span_id":null,"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":null,"severity_text":null,"severity_number":9,"service_name":"api","resource_attributes":{"10":"\"🚀\"","service.name":"1e-7","a":"12345678GET","k8s.pod.name":"2.5e-8","constructor":"1e-7"},"instrumentation_scope":null,"event_name":"request","attributes":null,"bytes_uncompressed":1826},{"uuid":"s1","trace_id":{"$bytes":"a799fda5f595f340e79a3cb36c62808a"},"span_id":{"$bytes":"969623a8e33dc565"},"timestamp":1736944084137000,"end_time":1736944084138000,"name":"GET /a","kind":3,"status_code":7,"service_name":"api","resource_attributes":{},"attributes":null},{"uuid":"u2","trace_id":{"$bytes":"ed91ef9a9f74cd6bcf62bd1002bbc340"},"span_id":null,"trace_flags":null,"timestamp":1736943099486000,"observed_timestamp":1736944633250000,"body":"\t1e3 ","severity_text":"fatal","severity_number":5,"service_name":"web","resource_attributes":{"service.name":"\"3fa85f64-5717-4562-b3fc-2c963f66afa6\""},"instrumentation_scope":null,"event_name":null,"attributes":{"constructor":"u","duration_ms":"\"a\\\\nb\"","status_code":"0.1"},"bytes_uncompressed":1650},{"uuid":"s3","trace_id":{"$bytes":"ea019d87e4140e2d0442c783bf16575f"},"span_id":{"$bytes":"6e4e86d890ee95b6"},"timestamp":1736942628907000,"end_time":1736954628907001,"name":"GET /a","kind":0,"status_code":0,"service_name":"worker","resource_attributes":null,"attributes":{"service.name":"\".5\"","ms":"\"🚀\""}},{"uuid":"u4","trace_id":{"$bytes":"6c19a3b4ed310fcbb25901f092dca2a0"},"span_id":{"$bytes":"9349fc3c142208c4"},"trace_flags":null,"timestamp":1736942418898000,"observed_timestamp":1736944633250000,"body":"12.5 x","severity_text":"DEBUG","severity_number":1,"service_name":"worker","resource_attributes":{"":"2.5e-8","service.name":"\"\\\"12.5abc\\\\\\\\ true \\\"\"","host":"true","user.email":"1.7976931348623157e+308"},"instrumentation_scope":null,"event_name":"","attributes":{"a.b":"null","日本":"2.5e-8","service.name":"\" \""},"bytes_uncompressed":1419}]},"output":[null,null,null,null,null]},{"input":{"rules":[{"id":"r0","config":{"retention_days":60,"filter_group":{"type":"AND","values":[{"type":"AND","values":[]}]}}},{"id":"r1","config":{"retention_days":30,"filter_group":{"type":"AND","values":[{"type":"OR","values":[null,{"key":"__proto__","operator":"not_icontains","value":[],"type":"span_resource_attribute"}]}]}}},{"id":"r2","config":{"retention_days":14.5,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"severity_level","operator":"icontains","value":[["n"],true],"type":"span_resource_attribute"},{"type":"OR","values":[{"type":"AND","values":[{"type":"OR","values":[{"key":"payload","operator":"is_set","value":42,"type":"log"},{"key":true,"operator":"is_set","value":1e+100}]}]}]},{"key":"kind","operator":"is_not","value":"1e3","type":"event"}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":2580,"filter_group":{"type":"AND","values":[]}}},{"id":"r1","config":{"retention_days":7,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[{"key":"status_code","operator":"is_set","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"key":"severity_text","operator":"not_icontains","value":["api","true"],"type":"span_resource_attribute"}]}]}]}]}]}}},{"id":"r2","config":{"retention_days":90,"filter_group":{"type":"OR","values":[{"type":"AND","values":[null]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":1,"filter_group":{"type":"OR","values":[{"key":5,"operator":"is_not_set","value":null,"type":"log_attribute"}]}}}],"records":[{"uuid":"s0","trace_id":{"$bytes":"9204f41f30cb193863b99e9e8c6161c5"},"span_id":{"$bytes":"6ba8342f61cf168b"},"timestamp":1736943671709000,"end_time":1736943671709001,"name":"GET /a","kind":-1,"status_code":-1,"service_name":null,"resource_attributes":{"k8s.pod.name":"0.3000000000000000400http.method","a":"2.5e-8","level":"\"true\"","service.name":"0o7"},"attributes":{}},{"uuid":"s1","trace_id":{"$bytes":"80a421c54725d3badb27fee4946f1874"},"span_id":{"$bytes":"663f6e14702923c8"},"timestamp":null,"end_time":1736944536991815,"name":"GET /a","kind":2,"status_code":3,"service_name":"api","resource_attributes":{"service.name":"INFO","a":"null"},"attributes":{"count":"\"sk_live_0123456789abcdefghijkléééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\""}},{"uuid":"u2","trace_id":{"$bytes":""},"span_id":null,"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"ahttp.method","severity_text":"DEBUG","severity_number":9,"service_name":"","resource_attributes":{"1":"0.30000000000000004","service.name":"\"日本語\"","host":"1e-7","a":"false"},"instrumentation_scope":null,"event_name":"","attributes":{"01":"\"ERROR\"","":"1"},"bytes_uncompressed":1343},{"uuid":"u3","trace_id":{"$bytes":"9e40aa13634e9f4c0718a0bc357559c8"},"span_id":{"$bytes":"d9706297c6c6ca69"},"trace_flags":null,"timestamp":1736944556449000,"observed_timestamp":1736944633250000,"body":"𐀀","severity_text":"info","severity_number":21,"service_name":"web","resource_attributes":null,"instrumentation_scope":null,"event_name":null,"attributes":{},"bytes_uncompressed":394},{"uuid":"u4","trace_id":null,"span_id":null,"trace_flags":null,"timestamp":1736943297310000,"observed_timestamp":1736944633250000,"body":"debug","severity_text":"trace","severity_number":17,"service_name":"","resource_attributes":{"service.name":"1e+100"},"instrumentation_scope":null,"event_name":"","attributes":{"user.email":"V "},"bytes_uncompressed":null}]},"output":[null,null,null,null,null]},{"input":{"rules":[{"id":"r0","config":{"retention_days":1,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":null,"operator":"not_regex","value":"\\0","type":"span_resource_attribute"},{"type":"AND","values":"x"},{"key":"status_code","operator":"regex","type":"log"}]}]}}},{"id":"r1","config":{"retention_days":2580,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"ms","operator":"regex","value":"\\pL","type":"log_resource_attribute"},{"type":"AND","values":[null]},{"key":"count","operator":"lte","type":"log_resource_attribute"}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":90,"filter_group":{"type":"OR","values":[{"type":"AND","values":[{"type":"AND","values":[{"key":"k8s.pod.name","operator":"bogus","value":"-0","type":"log_attribute"},{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[{"type":"OR","values":[{"key":"missing","operator":"ends_with","value":"0","type":"span_resource_attribute"},{"key":"__defineGetter__","operator":"not_regex","value":"Dž","type":"event"}]}]}]}]}]}]},null]}}},{"id":"r1","config":{"retention_days":"30","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":true,"operator":"exact","value":12.5,"type":"span_resource_attribute"},{"key":"level","value":"null","type":"span_resource_attribute"}]}]}}},{"id":"r2","config":{"retention_days":2580,"filter_group":{"type":"OR","values":[]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":-1,"filter_group":{"type":"AND","values":[{"key":"ms","operator":"not_starts_with","value":7,"type":"event"}]}}},{"id":"r1","config":{"retention_days":1,"filter_group":{"type":"AND","values":[]}}},{"id":"r2","config":{"retention_days":60,"filter_group":{"type":"AND","values":[null]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":2580,"filter_group":{"type":"AND","values":[null]}}},{"id":"r1","config":{"retention_days":2580,"filter_group":{"type":"AND","values":[]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":2580,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"kind","operator":"ends_with","value":2.5e-8,"type":"log_resource_attribute"},null,{"type":"AND","values":[{"type":"AND","values":[{"key":"message","operator":"is_not","value":"\r\n","type":"span_attribute"},{"key":"1","operator":"gte","value":[],"type":"span_attribute"}]}]}]}]}}},{"id":"r1","config":{"retention_days":2581,"filter_group":{"type":"OR","values":[{"type":"OR","values":[{"key":"message","operator":"ends_with","value":"\r\n","type":"log"}]},{"key":"message","operator":"is_set","value":-9007199254740992,"type":"span_resource_attribute"},{"key":"http.method","operator":"lte","value":2.5e-8,"type":"span_attribute"}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":1,"filter_group":{"type":"AND","values":[{"key":"ms","operator":"bogus","value":42,"type":"log_attribute"}]}}}],"records":[{"uuid":"u0","trace_id":{"$bytes":"c23781a68febadbda4da795b0af0ab91"},"span_id":null,"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"12","severity_text":"WARN","severity_number":5,"service_name":"worker","resource_attributes":{"service.name":"\"true\"","constructor":"0"},"instrumentation_scope":null,"event_name":"request","attributes":{"duration_ms":"0.1","k8s.pod.name":"1e+21"},"bytes_uncompressed":70},{"uuid":"u1","trace_id":{"$bytes":"a55c8a45e7a35837"},"span_id":null,"trace_flags":null,"timestamp":1736944503806000,"observed_timestamp":1736944633250000,"body":"1,5","severity_text":"info","severity_number":13,"service_name":null,"resource_attributes":{"k8s.pod.name":"\"1e400\"","\"":"\"\"","a.":"false"},"instrumentation_scope":null,"event_name":"","attributes":{},"bytes_uncompressed":null},{"uuid":"u2","trace_id":{"$bytes":""},"span_id":{"$bytes":"690a8bdfaa2ba046"},"trace_flags":null,"timestamp":1736942950779000,"observed_timestamp":1736944633250000,"body":"INFO4294967295˕4294967295 5.","severity_text":"","severity_number":21,"service_name":null,"resource_attributes":{"1":"0.000001","msg":"12� ","a":"-1.5","constructor":"0.000001"},"instrumentation_scope":null,"event_name":"request","attributes":{},"bytes_uncompressed":1473},{"uuid":"u3","trace_id":{"$bytes":""},"span_id":null,"trace_flags":null,"timestamp":1736942553247000,"observed_timestamp":1736944633250000,"body":"日本語 \"quoted\" 1e400","severity_text":"warning","severity_number":21,"service_name":"API","resource_attributes":null,"instrumentation_scope":null,"event_name":"","attributes":null,"bytes_uncompressed":1358},{"uuid":"s4","trace_id":{"$bytes":"55e283ecd6ffa70124c6d88f0982caed"},"span_id":{"$bytes":"c47db8fa794e6157"},"timestamp":1736943861585000,"end_time":1736943861585000,"name":"","kind":9,"status_code":0,"service_name":null,"resource_attributes":{"k8s.pod.name":"\" 12\"","a":"true","service.name":"null"},"attributes":null}]},"output":[null,null,null,null,null]},{"input":{"rules":[{"id":"r0","config":{"retention_days":30,"filter_group":{"type":"OR","values":[{"type":"AND","values":[{"type":"AND","values":[{"key":"ms","operator":"not_icontains","value":-1.5}]}]},null]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":null,"filter_group":{"type":"AND","values":[]}}},{"id":"r1","config":{"retention_days":null,"filter_group":{"type":"OR","values":[{"type":"AND","values":[{"type":"AND","values":[{"key":"count","operator":"lt","value":{"toString":1},"type":"log_attribute"},null]}]},{"key":"severity_level","operator":"is_not","value":null,"type":"event"},{"key":"__defineGetter__","operator":"is_set","value":[],"type":"span_resource_attribute"}]}}},{"id":"r2","config":{"retention_days":90,"filter_group":{"type":"AND","values":[null]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":60,"filter_group":{"type":"AND","values":[null]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":7,"filter_group":{"type":"OR","values":[{"key":"constructor","operator":"not_regex","value":"^$","type":"event"},{"key":"url.path","operator":"lt","value":true,"type":"log"}]}}},{"id":"r1","config":{"retention_days":-1,"filter_group":{"type":"OR","values":[{"key":"severity_text","value":"xoxb-1234567890-abc","type":"log_resource_attribute"}]}}},{"id":"r2","config":{"retention_days":2580,"filter_group":{"type":"AND","values":[null,{"key":"status_code","value":5e-324,"type":"event"}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":1,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"severity_level","operator":"is_not_set","value":"1,5","type":"span_resource_attribute"},{"key":"a","operator":"not_ends_with","value":-1,"type":"log_resource_attribute"},{"key":"__proto__","operator":"is_set","type":"span_resource_attribute"}]}]}}},{"id":"r1","config":{"retention_days":null,"filter_group":{"type":"OR","values":[{"key":"count","operator":"not_in","value":null,"type":"span_resource_attribute"}]}}},{"id":"r2","config":{"retention_days":60,"filter_group":{"type":"AND","values":[null]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":90,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"kind","operator":"starts_with","value":["GET","x","true"],"type":"log"},null]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":90,"filter_group":{"type":"AND","values":[null]}}},{"id":"r1","config":{"retention_days":0,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"severity_text","operator":"is_not_set","value":["x",{"toString":1}],"type":"log_resource_attribute"},{"type":"AND","values":[{"type":"OR","values":[]}]}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":7,"filter_group":{"type":"AND","values":[{"type":"OR","values":[]}]}}},{"id":"r1","config":{"retention_days":7,"filter_group":{"type":"OR","values":[{"key":"severity_text","operator":"is_not","value":"σ","type":"log_resource_attribute"},{"key":"severity_level","operator":"is_not","value":null,"type":"log"},{"key":"name","operator":"lt","type":"log"}]}}},{"id":"r2","config":{"retention_days":60,"filter_group":{"type":"OR","values":[{"key":"status_code","operator":"is_set","value":"1_000","type":"log_attribute"},{"type":"AND","values":[null]},{"key":"service.name","operator":"is_set","value":null,"type":"log_resource_attribute"}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":30,"filter_group":{"type":"OR","values":[]}}},{"id":"r1","config":{"retention_days":7,"filter_group":{"type":"AND","values":[]}}},{"id":"r2","config":{"retention_days":90,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[null]},{"type":"AND","values":[{"type":"OR","values":[{"key":"kind","operator":"not_regex","value":null,"type":"log"}]}]},{"key":"__proto__","operator":"not_ends_with","value":-9007199254740992,"type":"span_attribute"}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","config":{"retention_days":1,"filter_group":{"type":"AND","values":[{"type":"OR","values":[]}]}}}],"records":[{"uuid":"u0","trace_id":{"$bytes":"9e19960ae87e1d201ebb567899546853"},"span_id":{"$bytes":"7cb4719e6b6ca069"},"trace_flags":null,"timestamp":1736943136732000,"observed_timestamp":1736944633250000,"body":"error\\5. ","severity_text":"ERRor","severity_number":-1,"service_name":null,"resource_attributes":{"1.5":"\"12\""},"instrumentation_scope":null,"event_name":"request","attributes":{"url.path":"7"},"bytes_uncompressed":62},{"uuid":"u1","trace_id":{"$bytes":"5c47000bf8bb8f04"},"span_id":{"$bytes":"1e3f7653826c21fc"},"trace_flags":null,"timestamp":1736942461474000,"observed_timestamp":1736944633250000,"body":"2error0x10","severity_text":"warning","severity_number":21,"service_name":"","resource_attributes":{"constructor":"-1.5","service.name":"\"false\""},"instrumentation_scope":null,"event_name":null,"attributes":{},"bytes_uncompressed":1049},{"uuid":"u2","trace_id":{"$bytes":""},"span_id":{"$bytes":"ea87d09a4d2f9024"},"trace_flags":null,"timestamp":1736943594681000,"observed_timestamp":1736944633250000,"body":"message payload","severity_text":"DEBUG","severity_number":9,"service_name":"api","resource_attributes":{".a":"1e+21","k8s.pod.name":"1e+21","host":"true","a":"9007199254740992","constructor":"\"0o7\""},"instrumentation_scope":null,"event_name":"","attributes":{"01":"9007199254740992 "},"bytes_uncompressed":null},{"uuid":"u3","trace_id":{"$bytes":"00ffb468e47afdc0"},"span_id":{"$bytes":"2a05e7e81ffd9b22"},"trace_flags":null,"timestamp":1736943341358000,"observed_timestamp":1736944633250000,"body":"0","severity_text":"warning","severity_number":21,"service_name":"api","resource_attributes":{"a":"\"{\\\"a.b\\\":[null]}\"","k8s.pod.name":"null"," ":"NaNdebug"},"instrumentation_scope":null,"event_name":"","attributes":{},"bytes_uncompressed":502},{"uuid":"u4","trace_id":{"$bytes":"0d4d86a9d1ac6c71b6ade44474fdaa7f"},"span_id":{"$bytes":"81c53dc6610122a9"},"trace_flags":null,"timestamp":null,"observed_timestamp":1736944633250000,"body":"\n㩊9007199254740994Infinity","severity_text":"Warn","severity_number":12,"service_name":null,"resource_attributes":null,"instrumentation_scope":null,"event_name":null,"attributes":null,"bytes_uncompressed":1064}]},"output":[null,null,null,null,null]}]}diff --git a/rust/logs-ingestion/tests/fixtures/fuzz/sampling.json b/rust/logs-ingestion/tests/fixtures/fuzz/sampling.jsonnew file mode 100644index 000000000000..9131945b49aa--- /dev/null+++ b/rust/logs-ingestion/tests/fixtures/fuzz/sampling.json@@ -0,0 +1 @@+{"cases":[{"input":{"rules":[{"id":"r0","rule_type":"rate_limit","scope_service":null,"scope_path_pattern":"^/api","scope_attribute_filters":[],"config":{"logs_per_second":2000000}},{"id":"r1","rule_type":"path_drop","scope_service":"API","scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"patterns":["\\w+@\\w+","\\Qa.b\\E"],"match_attribute_key":"constructor","always_keep":{"status_gte":500,"latency_ms_gt":0,"attribute_predicates":[{"key":"k8s.pod.name","op":"ne","value":5},{"key":"kind","op":"exists","value":"\"GET\""}]}}},{"id":"r2","rule_type":"path_drop","scope_service":"","scope_path_pattern":".*","scope_attribute_filters":[],"config":{"patterns":"notarray","match_attribute_key":"","filter_group":{"type":"AND","values":[null]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"rate_limit","scope_service":"","scope_path_pattern":"(?=x)","scope_attribute_filters":[],"config":{"logs_per_second":1.5}},{"id":"r1","rule_type":"path_drop","scope_service":"api","scope_path_pattern":"\"/api","scope_attribute_filters":[],"config":{"patterns":["(?=x)","ſ"],"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"status_code","operator":"ends_with","value":"POST","type":"event"},{"type":"AND","values":[{"type":"AND","values":[{"key":"1","operator":"gte","value":null,"type":"log_resource_attribute"},{"type":"AND","values":[null]},{"type":"AND","values":[{"type":"AND","values":[{"key":"__defineGetter__","operator":"exact","value":["x",{"toString":1}]},{"key":"__proto__","operator":"ends_with","value":"2025-01-15T10:00:00Z","type":"span_attribute"}]}]}]}]},{"key":"missing","operator":"gt","value":0,"type":"span_resource_attribute"}]}]}}},{"id":"r2","rule_type":"severity_sampling","scope_service":"API","scope_path_pattern":".*","scope_attribute_filters":[],"config":{"actions":{"DEBUG":null,"WARN":null,"ERROR":{"type":"sample","rate":1}}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":"api","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":["\\pL","\\pL"],"match_attribute_key":"constructor"}},{"id":"r1","rule_type":"path_drop","scope_service":"API","scope_path_pattern":"\"/api","scope_attribute_filters":[],"config":{"patterns":[],"filter_group":{"type":"OR","values":[{"key":"severity_level","operator":"lte","value":true},{"key":"missing","operator":"exact","value":"FALSE","type":"event"},{"type":"AND","values":[null]}]},"always_keep":{"status_gte":400,"latency_ms_gt":-1,"attribute_predicates":[]}}},{"id":"r2","rule_type":"mystery","scope_service":"","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":[5,"^$"],"match_attribute_key":""}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"(?=x)","scope_attribute_filters":[],"config":{"patterns":["a{,5}"],"always_keep":{"status_gte":null,"latency_ms_gt":0,"attribute_predicates":[]}}},{"id":"r1","rule_type":"mystery","scope_service":"API","scope_path_pattern":"\"/api","scope_attribute_filters":[],"config":{"actions":{"INFO":null,"ERROR":{"type":"keep"}},"patterns":["(?P<n>x)","$"],"filter_group":{"type":"AND","values":[]},"always_keep":{"status_gte":400,"latency_ms_gt":1000,"attribute_predicates":[{"key":"é","op":"bogus","value":"\"GET\""}]}}},{"id":"r2","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"","scope_attribute_filters":[],"config":{"patterns":["\\0","[[:alpha:]]"],"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[{"key":"service.name","operator":"gte","value":"12.5abc","type":"event"},{"key":"__defineGetter__","operator":"not_icontains","value":"true"}]},{"key":"http.method","operator":"not_starts_with","value":"Infinity","type":"span_resource_attribute"},{"type":"OR","values":[{"type":"AND","values":[null]}]}]},{"type":"AND","values":[{"key":"message","operator":"exact","value":true,"type":"span_attribute"}]}]}}},{"id":"r3","rule_type":"mystery","scope_service":"","scope_path_pattern":".*","scope_attribute_filters":[],"config":{"patterns":["\\d+"],"match_attribute_key":"url.path"}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"mystery","scope_service":"","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":["é"]}},{"id":"r1","rule_type":"severity_sampling","scope_service":null,"scope_path_pattern":"(?=x)","scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":5},"INFO":null,"WARN":{"type":"sample","rate":0.25},"ERROR":{"type":5}}}},{"id":"r2","rule_type":"path_drop","scope_service":"api","scope_path_pattern":".*","scope_attribute_filters":[],"config":{"actions":{"DEBUG":null,"INFO":{"type":"drop"},"WARN":null},"patterns":["a**"],"filter_group":{"type":"AND","values":[null]}}},{"id":"r3","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"actions":{"INFO":{"type":"drop"},"WARN":{"type":5}},"patterns":["TRUE"],"match_attribute_key":" http.method ","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[{"key":"severity_text","operator":"in","value":"false"},{"key":"name","operator":"bogus","value":"Wed, 15 Jan 2025 12:00:00 GMT","type":"event"},{"key":"http.method","operator":"is_set","value":12.5,"type":"span_attribute"}]}]},{"type":"OR","values":[]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"severity_sampling","scope_service":null,"scope_path_pattern":"(?=x)","scope_attribute_filters":[],"config":{"actions":{"INFO":{"type":"keep"}}}},{"id":"r1","rule_type":"severity_sampling","scope_service":"","scope_path_pattern":"(?=x)","scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"keep"},"INFO":{"type":"keep"},"WARN":{"type":"drop"},"ERROR":null}}},{"id":"r2","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"^/api","scope_attribute_filters":[],"config":{"patterns":["ſ"],"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[{"type":"AND","values":[{"key":"service_name","operator":"bogus","value":" ","type":"log_resource_attribute"}]}]}]}]}}},{"id":"r3","rule_type":"path_drop","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":[],"filter_group":{"type":"AND","values":[null]},"always_keep":{"status_gte":null,"latency_ms_gt":-1,"attribute_predicates":[{"key":"payload","op":"eq","value":"\"x\""},{"key":"01","op":"ne","value":"GET"}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"rate_limit","scope_service":"API","scope_path_pattern":"\"/api","scope_attribute_filters":[],"config":{"actions":{"INFO":{"type":"sample","rate":"0.5"},"ERROR":null},"logs_per_second":2000000,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"status_code","operator":"is_not_set","value":true,"type":"event"},{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[null]},{"key":5,"operator":"lte","value":{"toString":1},"type":"log_attribute"},{"key":"message","value":"3fa85f64-5717-4562-b3fc-2c963f66afa6","type":"log_attribute"}]}]},{"key":"ms","operator":"not_ends_with","value":"0b11","type":"span_attribute"}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"patterns":["\\w+@\\w+"]}},{"id":"r1","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"","scope_attribute_filters":[],"config":{"patterns":[]}},{"id":"r2","rule_type":"rate_limit","scope_service":null,"scope_path_pattern":"^/api","scope_attribute_filters":[],"config":{"logs_per_second":1,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"severity_level","operator":"is_set","value":{},"type":"span_resource_attribute"}]}]}}},{"id":"r3","rule_type":"path_drop","scope_service":"api","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":"notarray","filter_group":{"type":"AND","values":[null]},"always_keep":{"status_gte":"500","latency_ms_gt":1000,"attribute_predicates":[{"key":"service.name","op":"eq"},{"key":"http.status_code","op":"bogus","value":5}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"mystery","scope_service":null,"scope_path_pattern":"^/api","scope_attribute_filters":[],"config":{"patterns":[]}},{"id":"r1","rule_type":"rate_limit","scope_service":null,"scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"logs_per_second":1.5,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[]},{"key":"missing","operator":"not_ends_with","value":["true",true],"type":"span_attribute"},{"type":"OR","values":[{"type":"AND","values":[{"type":"AND","values":[{"key":"message","operator":"gte","value":" 12"},{"key":"payload","operator":"not_starts_with","value":{"a":1},"type":"event"},{"key":"constructor","operator":"not_icontains","value":"[1,2]","type":"span_attribute"}]}]},null,{"type":"OR","values":[{"type":"OR","values":[{"key":null,"operator":"in","type":"log_attribute"}]}]}]}]}]}}},{"id":"r2","rule_type":"mystery","scope_service":"","scope_path_pattern":".*","scope_attribute_filters":[],"config":{"patterns":"notarray","match_attribute_key":" http.method ","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[{"key":"missing","value":[null,null],"type":"event"},{"type":"OR","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[]}]}]}]}]}]}]}]}}},{"id":"r3","rule_type":"path_drop","scope_service":null,"scope_path_pattern":".*","scope_attribute_filters":[],"config":{"patterns":[5,".*"],"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"name","operator":"is_not","value":"[1,2]","type":"log"},{"key":"level","operator":"lte","value":[["n"],["n"]],"type":"log_attribute"},{"key":"service.name","operator":"gt","value":12.5}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":"API","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":["(?P<n>x)","^\\s*$"],"match_attribute_key":"","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"toString","operator":"gt","value":12.5,"type":"log"}]}]}}},{"id":"r1","rule_type":"mystery","scope_service":"API","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":[]}},{"id":"r2","rule_type":"path_drop","scope_service":"","scope_path_pattern":"","scope_attribute_filters":[],"config":{"patterns":"notarray","match_attribute_key":" "}},{"id":"r3","rule_type":"rate_limit","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"sample","rate":-1},"INFO":null,"WARN":{"type":"sample","rate":"0.5"},"ERROR":{"type":"sample","rate":0.25}},"logs_per_second":0,"filter_group":{"type":"AND","values":[null]},"always_keep":{"status_gte":400,"latency_ms_gt":null,"attribute_predicates":[{"key":"__defineGetter__","op":"eq"}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{},"patterns":["("],"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[{"key":"payload","operator":"not_regex","value":"^/api","type":"event","_compiledRegex":{"internalSource":"^\\/api","lastIndex":0,"hasIndices":false,"sticky":false,"unicode":true,"dotAll":true,"multiline":false,"ignoreCase":true,"global":false,"flags":"isu","source":"^\\/api"}},{"key":"service_name","operator":"not_starts_with","value":[],"type":"span_resource_attribute"},{"key":"severity_text","operator":"exact","value":["api"]}]}]}]},"always_keep":{"status_gte":null,"latency_ms_gt":null,"attribute_predicates":[{"key":"http.route","op":"exists"},{"key":"hasOwnProperty","op":"eq"}]}}},{"id":"r1","rule_type":"rate_limit","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"logs_per_second":10,"filter_group":{"type":"AND","values":[{"type":"OR","values":[null]}]},"always_keep":{"status_gte":400,"latency_ms_gt":null,"attribute_predicates":[{"key":"status_code","op":"bogus"},{"key":"severity_text","op":"eq","value":"\"GET\""}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":"api","scope_path_pattern":".*","scope_attribute_filters":[],"config":{"patterns":[],"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[null]},{"key":"url.path","operator":"not_icontains","value":null,"type":"log_resource_attribute"}]}]}}},{"id":"r1","rule_type":"path_drop","scope_service":"API","scope_path_pattern":"\"/api","scope_attribute_filters":[],"config":{"patterns":["true"],"match_attribute_key":" http.method "}},{"id":"r2","rule_type":"rate_limit","scope_service":"","scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"logs_per_second":1.5,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":5,"operator":"gte","value":{"toString":1},"type":"log_attribute"},{"key":"__proto__","value":"12","type":"span_attribute"}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":"api","scope_path_pattern":"\"/api","scope_attribute_filters":[],"config":{"patterns":["é","^"],"match_attribute_key":"constructor","filter_group":{"type":"AND","values":[null]}}},{"id":"r1","rule_type":"mystery","scope_service":"API","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":"notarray","match_attribute_key":""}},{"id":"r2","rule_type":"path_drop","scope_service":"api","scope_path_pattern":".*","scope_attribute_filters":[],"config":{"patterns":"notarray","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"status_code","operator":"starts_with"}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"","scope_attribute_filters":[],"config":{"actions":{"INFO":{"type":"keep"},"WARN":{"type":"drop"}},"patterns":["\\x{1F680}"],"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"severity_text","value":[],"type":"log_resource_attribute"},{"key":"a","operator":"exact","value":"0b11","type":"span_resource_attribute"},{"type":"AND","values":[{"type":"AND","values":[{"key":"ms","operator":"not_in","value":false,"type":"log_attribute"},{"key":"http.method","operator":"not_starts_with","value":["api",true],"type":"span_resource_attribute"},{"key":"severity_level","operator":"icontains","value":".5","type":"log"}]}]}]}]},"always_keep":{"status_gte":"500","latency_ms_gt":1000,"attribute_predicates":[{"key":"http.path","op":"ne","value":"\"GET\""}]}}},{"id":"r1","rule_type":"rate_limit","scope_service":"","scope_path_pattern":"\"/api","scope_attribute_filters":[],"config":{"logs_per_second":1.5,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"message","operator":"icontains","value":["GET"],"type":"span_attribute"},{"type":"AND","values":[{"type":"OR","values":[{"key":"ms","operator":"not_regex","value":"\\x{1F680}","type":"log","_compiledRegex":{"internalSource":"\\x{1F680}","lastIndex":0,"hasIndices":false,"sticky":false,"unicode":true,"dotAll":true,"multiline":false,"ignoreCase":true,"global":false,"flags":"isu","source":"\\x{1F680}"}}]}]}]}]}}},{"id":"r2","rule_type":"rate_limit","scope_service":"API","scope_path_pattern":"\"/api","scope_attribute_filters":[],"config":{"logs_per_second":10,"filter_group":{"type":"OR","values":[{"key":"a","operator":"not_icontains","value":"[1,2]","type":"log_resource_attribute"},{"key":"kind","operator":"not_in","value":true,"type":"span_resource_attribute"},null]}}},{"id":"r3","rule_type":"path_drop","scope_service":"","scope_path_pattern":"\"/api","scope_attribute_filters":[],"config":{"patterns":["ſ"],"match_attribute_key":"","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":5,"operator":"is_not_set","value":9007199254740992}]}]},"always_keep":{"status_gte":"500","latency_ms_gt":0,"attribute_predicates":[{"key":"duration_ms","op":"eq"}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"rate_limit","scope_service":"api","scope_path_pattern":"^/api","scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":5},"INFO":{"type":5},"WARN":null},"logs_per_second":2000000,"always_keep":{"status_gte":400,"latency_ms_gt":-1,"attribute_predicates":[{"key":"a.b","op":"eq","value":5},{"key":"status_code","op":"exists"}]}}},{"id":"r1","rule_type":"rate_limit","scope_service":"","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"drop"},"INFO":{"type":"sample","rate":0.25},"WARN":{"type":5}},"logs_per_second":1.5,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"http.method","operator":"gt","value":[[1,2],3],"type":"span_resource_attribute"},{"key":"status_code","operator":"is_not_set","value":"00"},{"type":"AND","values":[null]}]}]}}},{"id":"r2","rule_type":"severity_sampling","scope_service":null,"scope_path_pattern":"(?=x)","scope_attribute_filters":[],"config":{"actions":{"INFO":null,"ERROR":{"type":"keep"}}}},{"id":"r3","rule_type":"path_drop","scope_service":"API","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"sample","rate":-1},"ERROR":{"type":"sample","rate":-1}},"patterns":["[","é"],"match_attribute_key":5,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"__proto__","operator":"icontains","type":"log_attribute"},{"key":"1","operator":"not_regex","value":"\\bfoo\\b"}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":"","scope_path_pattern":"\"/api","scope_attribute_filters":[],"config":{"patterns":["a**","\\x{1F680}"],"match_attribute_key":"","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"ms","operator":"bogus","value":[],"type":"log"},{"type":"OR","values":[{"key":"http.method","operator":"is_set","value":9007199254740994,"type":"span_attribute"},null]}]}]},"always_keep":{"status_gte":500,"latency_ms_gt":null,"attribute_predicates":[{"key":"severity_text","op":"eq","value":5},{"key":"message","op":"exists"}]}}},{"id":"r1","rule_type":"path_drop","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":[5],"match_attribute_key":"toString","filter_group":{"type":"AND","values":[]}}},{"id":"r2","rule_type":"path_drop","scope_service":"","scope_path_pattern":"^/api","scope_attribute_filters":[],"config":{"patterns":[5,"\\0"],"always_keep":{"status_gte":400,"latency_ms_gt":-1,"attribute_predicates":[{"key":"__defineGetter__","op":"ne","value":"GET"}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"rate_limit","scope_service":"API","scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"logs_per_second":2000000,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[{"type":"OR","values":[{"key":"service.name","operator":"in","value":"[1,2]","type":"log_resource_attribute"},null,{"key":"1","operator":"not_in","value":true}]}]}]}]}]}]}}},{"id":"r1","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"\"/api","scope_attribute_filters":[],"config":{"patterns":"notarray","filter_group":{"type":"OR","values":[{"key":"http.method","operator":"in","value":"Bearer abc.def-ghi","type":"log_resource_attribute"}]},"always_keep":{"status_gte":400,"latency_ms_gt":0,"attribute_predicates":[{"key":"status_code","op":"ne","value":"GET"}]}}},{"id":"r2","rule_type":"rate_limit","scope_service":"API","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":5},"INFO":{"type":"drop"}},"logs_per_second":1.5,"filter_group":{"type":"AND","values":[{"type":"OR","values":[]}]}}},{"id":"r3","rule_type":"rate_limit","scope_service":"","scope_path_pattern":"(?=x)","scope_attribute_filters":[],"config":{"actions":{"INFO":{"type":"keep"},"WARN":{"type":"sample","rate":0.5}},"logs_per_second":1.5}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"rate_limit","scope_service":"API","scope_path_pattern":"^/api","scope_attribute_filters":[],"config":{"logs_per_second":2000000}},{"id":"r1","rule_type":"path_drop","scope_service":"api","scope_path_pattern":".*","scope_attribute_filters":[],"config":{"patterns":[],"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":null,"operator":"gt","value":null,"type":"span_resource_attribute"},{"type":"AND","values":[null]}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"rate_limit","scope_service":null,"scope_path_pattern":"(?=x)","scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"keep"},"INFO":null,"WARN":{"type":5}},"logs_per_second":1,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"status_code","value":"-1e400"}]}]},"always_keep":{"status_gte":400,"latency_ms_gt":-1,"attribute_predicates":[{"key":"payload.x","op":"eq","value":"\"GET\""},{"key":"01","op":"ne"}]}}},{"id":"r1","rule_type":"path_drop","scope_service":"API","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":"notarray","match_attribute_key":5,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"k8s.pod.name","operator":"bogus","value":["x",{"toString":1}],"type":"log_attribute"},{"key":"service_name","operator":"starts_with","value":42,"type":"span_attribute"}]}]},"always_keep":{"status_gte":null,"latency_ms_gt":1000,"attribute_predicates":[{"key":"count","op":"exists","value":"GET"}]}}},{"id":"r2","rule_type":"rate_limit","scope_service":"api","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"logs_per_second":10,"filter_group":{"type":"AND","values":[null]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"mystery","scope_service":"api","scope_path_pattern":".*","scope_attribute_filters":[],"config":{"patterns":"notarray","match_attribute_key":" http.method ","filter_group":{"type":"OR","values":[{"key":"status_code","operator":"ends_with","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","type":"span_resource_attribute"},{"key":"severity_text","operator":"is_not_set","value":["x",{"toString":1}],"type":"event"}]}}},{"id":"r1","rule_type":"rate_limit","scope_service":null,"scope_path_pattern":".*","scope_attribute_filters":[],"config":{"logs_per_second":2000000}},{"id":"r2","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"\"/api","scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"keep"},"INFO":{"type":"sample","rate":"0.5"},"ERROR":{"type":"sample","rate":-1}},"patterns":["é",".*"],"match_attribute_key":"constructor"}},{"id":"r3","rule_type":"rate_limit","scope_service":"","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"logs_per_second":1,"filter_group":{"type":"AND","values":[null]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"severity_sampling","scope_service":"","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"INFO":{"type":"drop"},"WARN":{"type":"drop"},"ERROR":null},"always_keep":{"status_gte":500,"latency_ms_gt":-1,"attribute_predicates":[{"key":"service.name","op":"eq","value":"\"x\""},{"key":"constructor","op":"exists","value":"GET"}]}}},{"id":"r1","rule_type":"severity_sampling","scope_service":"","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"sample","rate":0.25},"WARN":{"type":"keep"}}}},{"id":"r2","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"","scope_attribute_filters":[],"config":{"actions":{"INFO":{"type":"sample","rate":"0.5"},"WARN":null},"patterns":["🚀"],"always_keep":{"status_gte":400,"latency_ms_gt":0,"attribute_predicates":[{"key":"http.response.status_code","op":"ne","value":"GET"}]}}},{"id":"r3","rule_type":"path_drop","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":[],"match_attribute_key":"","filter_group":{"type":"OR","values":[{"key":"k8s.pod.name","operator":"in","value":[1,["n"],["n"]],"type":"log_resource_attribute"},null,{"key":"1","operator":"bogus","value":"NaN","type":"span_resource_attribute"}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":"api","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"drop"},"ERROR":{"type":"sample","rate":0.5}},"patterns":[],"match_attribute_key":" http.method ","filter_group":{"type":"OR","values":[{"key":"level","operator":"regex","value":"[^\\x00-\\x7F]","type":"log"},{"type":"AND","values":[null]},{"type":"AND","values":[]}]}}},{"id":"r1","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"\"/api","scope_attribute_filters":[],"config":{"patterns":"notarray","match_attribute_key":" http.method "}},{"id":"r2","rule_type":"path_drop","scope_service":"API","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":["^$"],"always_keep":{"status_gte":null,"latency_ms_gt":-1,"attribute_predicates":[{"key":"path","op":"ne","value":"\"x\""},{"key":"payload.0","op":"bogus"}]}}},{"id":"r3","rule_type":"path_drop","scope_service":"API","scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"patterns":[],"match_attribute_key":" http.method ","filter_group":{"type":"AND","values":[null]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"mystery","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":"notarray","match_attribute_key":" ","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"OR","values":[{"key":"constructor","operator":"regex","value":"[a-z]+","type":"log_attribute"},{"key":"status_code","operator":"starts_with","value":-1,"type":"log"},{"key":"service_name","operator":"not_in","value":false}]}]}]},"always_keep":{"status_gte":null,"latency_ms_gt":null,"attribute_predicates":[]}}},{"id":"r1","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"","scope_attribute_filters":[],"config":{"patterns":[],"match_attribute_key":" http.method ","filter_group":{"type":"OR","values":[{"key":"payload","operator":"ends_with","value":1,"type":"log_attribute"},null,{"type":"AND","values":[{"type":"OR","values":[{"type":"OR","values":[]}]}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"rate_limit","scope_service":null,"scope_path_pattern":"\"/api","scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"drop"},"INFO":null,"ERROR":{"type":"sample","rate":0.5}},"logs_per_second":0,"filter_group":{"type":"OR","values":[{"key":"missing","operator":"lt","value":[null,true],"type":"log_attribute"},{"type":"AND","values":[{"type":"AND","values":[{"key":"1","operator":"is_set","value":"warn","type":"log_attribute"},{"key":"count","value":{},"type":"event"},{"type":"AND","values":[null]}]}]}]},"always_keep":{"status_gte":"500","latency_ms_gt":null,"attribute_predicates":[{"key":"level","op":"ne","value":5},{"key":"count","op":"ne","value":"\"GET\""}]}}},{"id":"r1","rule_type":"mystery","scope_service":"API","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":[]}},{"id":"r2","rule_type":"mystery","scope_service":"","scope_path_pattern":".*","scope_attribute_filters":[],"config":{"patterns":[],"match_attribute_key":"url.path","always_keep":{"status_gte":null,"latency_ms_gt":null,"attribute_predicates":[{"key":"message","op":"ne","value":5}]}}},{"id":"r3","rule_type":"rate_limit","scope_service":"","scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"logs_per_second":1}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"mystery","scope_service":"API","scope_path_pattern":"(?=x)","scope_attribute_filters":[],"config":{"patterns":["[^\\x00-\\x7F]","é"],"match_attribute_key":"","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[{"type":"OR","values":[{"key":"message","operator":"is_not"},{"key":"__proto__","value":1e-7,"type":"span_resource_attribute"}]}]},{"type":"AND","values":[{"type":"AND","values":[{"key":"service.name","operator":"is_not_set","value":"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀","type":"log_resource_attribute"},{"key":"__proto__","operator":"gt","value":[[1,2],3]}]}]}]}]},"always_keep":{"status_gte":500,"latency_ms_gt":1000,"attribute_predicates":[]}}},{"id":"r1","rule_type":"rate_limit","scope_service":"API","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"logs_per_second":2000000,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[]},{"type":"AND","values":[null]}]}]}}},{"id":"r2","rule_type":"mystery","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":["GET|POST","(?=x)"],"match_attribute_key":"level"}},{"id":"r3","rule_type":"mystery","scope_service":"API","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":[5],"match_attribute_key":"constructor","filter_group":{"type":"AND","values":[{"key":5,"operator":"exact","value":"192.168.1.1","type":"log_resource_attribute"},{"type":"OR","values":[{"type":"AND","values":[{"type":"AND","values":[]}]},{"key":"count","operator":"not_ends_with","value":"[1,2]","type":"log_resource_attribute"}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"mystery","scope_service":"API","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":["true"],"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"http.method","operator":"lte","value":0.000001,"type":"span_attribute"}]}]},"always_keep":{"status_gte":"500","latency_ms_gt":null,"attribute_predicates":[{"key":"valueOf","op":"ne","value":5},{"key":"payload","op":"ne","value":"\"x\""}]}}},{"id":"r1","rule_type":"path_drop","scope_service":"api","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":5},"INFO":{"type":"sample","rate":1.5},"WARN":{"type":5}},"patterns":["true"],"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"toString","operator":"in","value":"ERROR","type":"span_resource_attribute"}]}]}}},{"id":"r2","rule_type":"path_drop","scope_service":"API","scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"patterns":[],"match_attribute_key":"constructor","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"ms","operator":"not_icontains","value":[1],"type":"log"},null]}]}}},{"id":"r3","rule_type":"rate_limit","scope_service":null,"scope_path_pattern":"(?=x)","scope_attribute_filters":[],"config":{"actions":{"INFO":{"type":"keep"}},"logs_per_second":1.5}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"rate_limit","scope_service":"api","scope_path_pattern":".*","scope_attribute_filters":[],"config":{"logs_per_second":2000000,"filter_group":{"type":"AND","values":[{"key":"kind","operator":"is_not","value":"Bearer abc.def-ghi"},{"key":"severity_level","operator":"regex","value":"\\0","type":"event"},null]}}},{"id":"r1","rule_type":"mystery","scope_service":"API","scope_path_pattern":"\"/api","scope_attribute_filters":[],"config":{"patterns":"notarray","match_attribute_key":"constructor","filter_group":{"type":"OR","values":[{"key":"ms","operator":"ends_with","value":["x",1e+21,"GET"],"type":"log_resource_attribute"},{"key":"__defineGetter__","operator":"is_not_set","value":"ς","type":"log_resource_attribute"}]}}},{"id":"r2","rule_type":"rate_limit","scope_service":"","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"logs_per_second":0,"always_keep":{"status_gte":null,"latency_ms_gt":1000,"attribute_predicates":[{"key":"kind","op":"exists","value":"GET"}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"rate_limit","scope_service":"API","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"INFO":{"type":"sample","rate":0.5},"WARN":{"type":"sample","rate":0},"ERROR":{"type":"drop"}},"logs_per_second":1,"always_keep":{"status_gte":"500","latency_ms_gt":1000,"attribute_predicates":[{"key":"http.response.status_code","op":"ne","value":"\"GET\""}]}}},{"id":"r1","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"\"/api","scope_attribute_filters":[],"config":{"patterns":["^","a{2,}"],"match_attribute_key":"constructor","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"a","operator":"lte","value":["x",{"toString":1}],"type":"log"},{"key":"url.path","operator":"is_not_set","value":"ς","type":"span_resource_attribute"},null]}]}}},{"id":"r2","rule_type":"path_drop","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":["\\p{L}+","\\pL"],"filter_group":{"type":"OR","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[]}]}]},{"key":"1","operator":"not_starts_with","value":[[1,2],3]}]},"always_keep":{"status_gte":null,"latency_ms_gt":0,"attribute_predicates":[{"key":"severity_text","op":"exists","value":5},{"key":"http.route","op":"exists","value":"\"GET\""}]}}},{"id":"r3","rule_type":"mystery","scope_service":"api","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":["(?<n>x)"],"filter_group":{"type":"AND","values":[]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":"api","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":"notarray","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"http.method","operator":"lt","value":"12","type":"log"},{"key":"count","operator":"gte","value":[null],"type":"log_resource_attribute"}]}]}}},{"id":"r1","rule_type":"rate_limit","scope_service":null,"scope_path_pattern":".*","scope_attribute_filters":[],"config":{"logs_per_second":1,"always_keep":{"status_gte":400,"latency_ms_gt":1000,"attribute_predicates":[{"key":"duration_ms","op":"ne"},{"key":"a.b","op":"exists","value":"\"x\""}]}}},{"id":"r2","rule_type":"path_drop","scope_service":"api","scope_path_pattern":"(?=x)","scope_attribute_filters":[],"config":{"patterns":["\\","Dž"],"filter_group":{"type":"OR","values":[{"key":"kind","operator":"bogus","value":null,"type":"event"},{"key":"name","operator":"exact","value":"+5","type":"log_resource_attribute"},{"type":"OR","values":[{"type":"OR","values":[{"type":"OR","values":[{"key":"k8s.pod.name","operator":"is_not","value":[1e+21,["n"],1e+21],"type":"log_attribute"},{"key":"service_name","operator":"gt","value":"Wed, 15 Jan 2025 12:00:00 GMT","type":"log_resource_attribute"}]}]},{"key":"http.method","operator":"regex","value":"é","_compiledRegex":{"internalSource":"é","lastIndex":0,"hasIndices":false,"sticky":false,"unicode":true,"dotAll":true,"multiline":false,"ignoreCase":true,"global":false,"flags":"isu","source":"é"}}]}]},"always_keep":{"status_gte":"500","latency_ms_gt":0,"attribute_predicates":[{"key":"http.route","op":"bogus","value":"\"x\""}]}}},{"id":"r3","rule_type":"path_drop","scope_service":"","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"DEBUG":null,"INFO":{"type":"drop"},"WARN":null,"ERROR":null},"patterns":["(?<n>x)"],"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[null]},{"key":"service_name","operator":"is_not","value":-1,"type":"log_resource_attribute"}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"drop"},"INFO":{"type":"sample","rate":1},"WARN":{"type":"drop"}},"patterns":[],"always_keep":{"status_gte":400,"latency_ms_gt":0,"attribute_predicates":[{"key":"🚀","op":"bogus","value":"GET"}]}}},{"id":"r1","rule_type":"mystery","scope_service":"API","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"DEBUG":null},"patterns":["true"],"match_attribute_key":"toString","always_keep":{"status_gte":"500","latency_ms_gt":null,"attribute_predicates":[{"key":"a.b","op":"exists","value":"GET"},{"key":"http.server.duration_ms","op":"eq"}]}}},{"id":"r2","rule_type":"path_drop","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"INFO":{"type":5}},"patterns":["\\d+"],"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[null]},{"key":"k8s.pod.name","operator":"lt","value":[],"type":"event"},{"key":"level","operator":"ends_with","value":100,"type":"log_attribute"}]}]},{"key":"__defineGetter__","operator":"not_in","value":["true","api"],"type":"log_resource_attribute"}]},{"key":"http.method","operator":"lt","value":["x",{"toString":1}],"type":"log_attribute"}]}]}}},{"id":"r3","rule_type":"rate_limit","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"logs_per_second":10}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"DEBUG":null},"patterns":[],"filter_group":{"type":"AND","values":[null]},"always_keep":{"status_gte":"500","latency_ms_gt":1000,"attribute_predicates":[]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"rate_limit","scope_service":"API","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"logs_per_second":1.5,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[{"type":"OR","values":[{"key":"name","operator":"icontains","value":false,"type":"log_resource_attribute"},{"key":"service.name","operator":"gte","value":[[1,2],3],"type":"log_attribute"}]},{"type":"AND","values":[{"type":"OR","values":[{"type":"OR","values":[{"key":"1","operator":"regex","value":"^/api","type":"event","_compiledRegex":{"internalSource":"^\\/api","lastIndex":0,"hasIndices":false,"sticky":false,"unicode":true,"dotAll":true,"multiline":false,"ignoreCase":true,"global":false,"flags":"isu","source":"^\\/api"}}]}]}]},{"type":"AND","values":[{"type":"AND","values":[{"key":"__defineGetter__","operator":"exact","value":false}]}]}]}]},{"key":"kind","operator":"exact","value":[[1,2],3],"type":"event"},{"key":"service.name","operator":"icontains","value":" ","type":"event"}]}]}}},{"id":"r1","rule_type":"path_drop","scope_service":"","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":["a**","("],"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"name","operator":"icontains","value":"AKIAIOSFODNN7EXAMPLE","type":"event"},{"key":"__defineGetter__","operator":"regex","value":"ſ","type":"log","_compiledRegex":{"internalSource":"ſ","lastIndex":0,"hasIndices":false,"sticky":false,"unicode":true,"dotAll":true,"multiline":false,"ignoreCase":true,"global":false,"flags":"isu","source":"ſ"}}]}]}}},{"id":"r2","rule_type":"rate_limit","scope_service":null,"scope_path_pattern":"^/api","scope_attribute_filters":[],"config":{"logs_per_second":0,"filter_group":{"type":"AND","values":[{"type":"AND","values":[null]},{"type":"AND","values":[]},{"key":"severity_level","operator":"is_not","value":["GET","true","api"],"type":"event"}]}}},{"id":"r3","rule_type":"severity_sampling","scope_service":"API","scope_path_pattern":"^/api","scope_attribute_filters":[],"config":{"actions":{"ERROR":{"type":"keep"}}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"mystery","scope_service":"api","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":[],"match_attribute_key":"","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"count","operator":"starts_with","value":["api"],"type":"log"}]}]},"always_keep":{"status_gte":400,"latency_ms_gt":1000,"attribute_predicates":[]}}},{"id":"r1","rule_type":"severity_sampling","scope_service":null,"scope_path_pattern":"(?=x)","scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"sample","rate":0.5},"INFO":{"type":"drop"}},"always_keep":{"status_gte":400,"latency_ms_gt":0,"attribute_predicates":[{"key":"duration_ms","op":"eq","value":5},{"key":"kind","op":"exists","value":"GET"}]}}},{"id":"r2","rule_type":"rate_limit","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"logs_per_second":10,"filter_group":{"type":"AND","values":[null]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"mystery","scope_service":"","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":["^$","(a{100}){11}"]}},{"id":"r1","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"^/api","scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"sample","rate":"0.5"},"INFO":null,"WARN":null},"patterns":["[[:alpha:]]"],"filter_group":{"type":"AND","values":[{"type":"AND","values":[null,{"key":"constructor","operator":"gt","value":"","type":"log_resource_attribute"}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"rate_limit","scope_service":"api","scope_path_pattern":"^/api","scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"keep"},"INFO":{"type":"keep"},"WARN":{"type":5},"ERROR":{"type":"keep"}},"logs_per_second":2000000,"filter_group":{"type":"AND","values":[{"type":"OR","values":[]}]},"always_keep":{"status_gte":null,"latency_ms_gt":null,"attribute_predicates":[{"key":"http.server.duration_ms","op":"eq"},{"key":"duration_ms","op":"eq","value":"GET"}]}}},{"id":"r1","rule_type":"rate_limit","scope_service":"API","scope_path_pattern":".*","scope_attribute_filters":[],"config":{"logs_per_second":0,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"__proto__","operator":"gt","value":[],"type":"log"},{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[]}]}]},{"type":"AND","values":[null]}]},{"type":"AND","values":[{"key":"service_name","operator":"lte","value":"{\"a\":1}","type":"log_attribute"},{"type":"AND","values":[{"type":"AND","values":[{"key":"kind","operator":"gt","value":[true,"x"],"type":"span_resource_attribute"},{"key":"1","operator":"not_regex","value":"\\0","type":"span_attribute"}]}]},{"type":"AND","values":[]}]},{"key":"service_name","operator":"not_icontains","value":"\u000b","type":"event"}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"patterns":["(?P<n>x)"],"match_attribute_key":"url.path","filter_group":{"type":"AND","values":[{"type":"AND","values":[null]},{"key":"a","operator":"regex","value":"Dž"},{"type":"AND","values":[]}]}}},{"id":"r1","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"(?=x)","scope_attribute_filters":[],"config":{"patterns":["true","TRUE"],"match_attribute_key":"url.path","filter_group":{"type":"AND","values":[{"key":"http.method","operator":"bogus","value":"True"},{"type":"AND","values":[{"type":"OR","values":[]}]},{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"key":"url.path","operator":"is_set","value":["GET"],"type":"log_resource_attribute"}]}]}]}]},{"key":"constructor","operator":"ends_with","value":"12","type":"event"},{"key":"toString","operator":"not_icontains","value":[1,"x"],"type":"span_resource_attribute"}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":"API","scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"patterns":["a{,5}"],"filter_group":{"type":"AND","values":[{"key":"missing","value":"5.","type":"log"},{"key":"missing","operator":"gte","value":[true,["n"]],"type":"event"},{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"key":"a","operator":"regex","value":"\\w+@\\w+","type":"event"}]}]},null]}]}}},{"id":"r1","rule_type":"mystery","scope_service":"","scope_path_pattern":"","scope_attribute_filters":[],"config":{"patterns":[],"match_attribute_key":"url.path"}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"rate_limit","scope_service":"API","scope_path_pattern":".*","scope_attribute_filters":[],"config":{"actions":{"INFO":{"type":5},"WARN":{"type":"sample","rate":0.25}},"logs_per_second":1,"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[null,{"type":"AND","values":[{"type":"OR","values":[{"type":"OR","values":[{"key":"name","operator":"not_icontains","value":false}]},{"key":5,"operator":"not_icontains","value":[[1,2],3]}]}]}]}]}]}}},{"id":"r1","rule_type":"mystery","scope_service":"","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":["(?i)error"],"match_attribute_key":" http.method ","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[{"type":"AND","values":[{"key":"toString","value":[null],"type":"log_resource_attribute"},{"key":"1","operator":"not_ends_with","value":[[1,2],3],"type":"log_resource_attribute"},{"key":"http.method","operator":"not_regex","value":"a{,5}"}]}]},{"key":"severity_text","operator":"bogus","value":"Infinity","type":"event"}]}]}}},{"id":"r2","rule_type":"path_drop","scope_service":"","scope_path_pattern":"","scope_attribute_filters":[],"config":{"actions":{"WARN":{"type":"drop"},"ERROR":{"type":"sample","rate":0.25}},"patterns":["\\bfoo\\b","^/api"]}},{"id":"r3","rule_type":"severity_sampling","scope_service":"api","scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":5},"ERROR":{"type":"keep"}}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":"","scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"patterns":["^"],"match_attribute_key":"","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"k8s.pod.name","operator":"not_in","value":"3fa85f64-5717-4562-b3fc-2c963f66afa6","type":"log"},{"key":"service.name","operator":"ends_with","value":{"toString":1},"type":"log_attribute"},{"type":"AND","values":[{"type":"AND","values":[]}]}]}]},"always_keep":{"status_gte":400,"latency_ms_gt":0,"attribute_predicates":[{"key":"valueOf","op":"ne","value":5}]}}},{"id":"r1","rule_type":"mystery","scope_service":null,"scope_path_pattern":"","scope_attribute_filters":[],"config":{"patterns":["a{,5}","🚀"],"filter_group":{"type":"AND","values":[{"key":"a","operator":"gt","value":[],"type":"event"}]},"always_keep":{"status_gte":500,"latency_ms_gt":-1,"attribute_predicates":[{"key":"0","op":"eq","value":5}]}}},{"id":"r2","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"(?=x)","scope_attribute_filters":[],"config":{"patterns":["(?P<n>x)","(?=x)"],"filter_group":{"type":"AND","values":[null]}}},{"id":"r3","rule_type":"severity_sampling","scope_service":"api","scope_path_pattern":"^/api","scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"sample","rate":-1},"WARN":{"type":5},"ERROR":{"type":5}}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":"api","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":["TRUE"],"filter_group":{"type":"AND","values":[null]}}},{"id":"r1","rule_type":"mystery","scope_service":"api","scope_path_pattern":".*","scope_attribute_filters":[],"config":{"actions":{"INFO":{"type":"drop"},"ERROR":{"type":"keep"}},"patterns":["(?=x)","\\Z"],"match_attribute_key":" ","filter_group":{"type":"OR","values":[{"key":"missing","operator":"not_ends_with","value":[null],"type":"log"},{"key":"level","operator":"ends_with","type":"log_resource_attribute"}]},"always_keep":{"status_gte":null,"latency_ms_gt":0,"attribute_predicates":[{"key":"1","op":"ne","value":"GET"}]}}},{"id":"r2","rule_type":"mystery","scope_service":null,"scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":5},"INFO":{"type":5}},"patterns":[],"match_attribute_key":" ","always_keep":{"status_gte":500,"latency_ms_gt":null,"attribute_predicates":[{"key":"🚀","op":"ne","value":5},{"key":"user.email","op":"ne"}]}}},{"id":"r3","rule_type":"path_drop","scope_service":"","scope_path_pattern":".*","scope_attribute_filters":[],"config":{"patterns":["^\\s*$","^/api"],"filter_group":{"type":"AND","values":[]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"","scope_attribute_filters":[],"config":{"patterns":[],"match_attribute_key":"toString","filter_group":{"type":"OR","values":[{"key":"service_name","operator":"not_regex","value":".*","type":"log_resource_attribute"},{"key":"url.path","operator":"lte","value":-9007199254740992,"type":"span_resource_attribute"},null]}}},{"id":"r1","rule_type":"rate_limit","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"logs_per_second":1.5,"always_keep":{"status_gte":"500","latency_ms_gt":null,"attribute_predicates":[{"key":"01","op":"bogus","value":"\"GET\""}]}}},{"id":"r2","rule_type":"severity_sampling","scope_service":null,"scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"keep"},"WARN":{"type":"sample","rate":0.5}}}},{"id":"r3","rule_type":"mystery","scope_service":"","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":["[a-z]+"],"match_attribute_key":"level","filter_group":{"type":"AND","values":[{"key":"missing","operator":"is_not","value":"True","type":"span_attribute"},{"key":"severity_text","operator":"not_regex","value":"\\w+@\\w+","type":"span_attribute"}]},"always_keep":{"status_gte":null,"latency_ms_gt":1000,"attribute_predicates":[{"key":"duration_ms","op":"exists","value":5},{"key":"kind","op":"exists","value":"GET"}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":"","scope_path_pattern":".*","scope_attribute_filters":[],"config":{"patterns":"notarray","filter_group":{"type":"AND","values":[{"type":"AND","values":[{"key":"service.name","operator":"not_ends_with","value":"GET","type":"event"}]}]}}},{"id":"r1","rule_type":"path_drop","scope_service":"api","scope_path_pattern":".*","scope_attribute_filters":[],"config":{"patterns":[],"always_keep":{"status_gte":"500","latency_ms_gt":1000,"attribute_predicates":[{"key":"http.path","op":"bogus","value":5}]}}},{"id":"r2","rule_type":"path_drop","scope_service":"","scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"patterns":["^$","é"],"filter_group":{"type":"AND","values":[null]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"rate_limit","scope_service":null,"scope_path_pattern":"","scope_attribute_filters":[],"config":{"logs_per_second":1.5,"filter_group":{"type":"OR","values":[{"type":"AND","values":[null]}]}}},{"id":"r1","rule_type":"mystery","scope_service":"API","scope_path_pattern":"(?=x)","scope_attribute_filters":[],"config":{"patterns":"notarray","filter_group":{"type":"OR","values":[{"key":"service.name","operator":"ends_with","value":false}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":"api","scope_path_pattern":".*","scope_attribute_filters":[],"config":{"patterns":[],"filter_group":{"type":"AND","values":[null]}}},{"id":"r1","rule_type":"rate_limit","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"sample","rate":0},"INFO":{"type":"keep"},"ERROR":{"type":"drop"}},"logs_per_second":2000000,"filter_group":{"type":"AND","values":[]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"rate_limit","scope_service":"","scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"logs_per_second":10,"filter_group":{"type":"AND","values":[null,{"type":"AND","values":[{"type":"AND","values":[]}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"severity_sampling","scope_service":"api","scope_path_pattern":"\"/api","scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"drop"},"INFO":{"type":5},"WARN":{"type":"drop"},"ERROR":{"type":"keep"}}}},{"id":"r1","rule_type":"path_drop","scope_service":"API","scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"patterns":[],"filter_group":{"type":"AND","values":[{"type":"OR","values":[]}]},"always_keep":{"status_gte":null,"latency_ms_gt":null,"attribute_predicates":[{"key":"valueOf","op":"eq","value":"GET"}]}}},{"id":"r2","rule_type":"path_drop","scope_service":"","scope_path_pattern":"","scope_attribute_filters":[],"config":{"patterns":[],"filter_group":{"type":"AND","values":[null]}}},{"id":"r3","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"","scope_attribute_filters":[],"config":{"actions":{"INFO":{"type":"drop"},"ERROR":{"type":"sample","rate":-1}},"patterns":["\\Z"],"filter_group":{"type":"OR","values":[{"type":"AND","values":[]}]},"always_keep":{"status_gte":400,"latency_ms_gt":1000,"attribute_predicates":[{"key":"valueOf","op":"exists","value":"GET"}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"severity_sampling","scope_service":"","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"drop"},"INFO":{"type":"sample","rate":"0.5"},"WARN":{"type":"drop"}}}},{"id":"r1","rule_type":"mystery","scope_service":"","scope_path_pattern":"^/api","scope_attribute_filters":[],"config":{"patterns":["TRUE"],"filter_group":{"type":"AND","values":[{"type":"OR","values":[{"key":"status_code","operator":"in","value":[],"type":"event"}]}]}}},{"id":"r2","rule_type":"rate_limit","scope_service":"","scope_path_pattern":"^/api","scope_attribute_filters":[],"config":{"logs_per_second":0,"filter_group":{"type":"AND","values":[null]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"rate_limit","scope_service":null,"scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"logs_per_second":1,"filter_group":{"type":"OR","values":[{"key":"missing","operator":"lt","value":"ERROR","type":"span_attribute"},{"key":"service_name","operator":"not_regex","value":"Dž","type":"event"},null]}}},{"id":"r1","rule_type":"severity_sampling","scope_service":null,"scope_path_pattern":".*","scope_attribute_filters":[],"config":{"actions":{"ERROR":{"type":"drop"}}}},{"id":"r2","rule_type":"path_drop","scope_service":"api","scope_path_pattern":"","scope_attribute_filters":[],"config":{"patterns":[],"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"type":"OR","values":[{"key":"missing","operator":"not_icontains","value":"null","type":"span_attribute"}]}]}]}]}]},{"type":"AND","values":"x"},{"type":"OR","values":[{"type":"OR","values":[{"type":"OR","values":[{"key":"kind","operator":"gt","value":{},"type":"log"}]},{"key":"toString","operator":"not_in","value":"FALSE"},{"key":"url.path","operator":"lte","value":["GET"]}]}]}]}]}}},{"id":"r3","rule_type":"path_drop","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":[]}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":"api","scope_path_pattern":"(?=x)","scope_attribute_filters":[],"config":{"patterns":["("],"match_attribute_key":" ","filter_group":{"type":"AND","values":[{"type":"AND","values":[null]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"rate_limit","scope_service":"API","scope_path_pattern":"","scope_attribute_filters":[],"config":{"logs_per_second":1,"filter_group":{"type":"AND","values":[{"type":"AND","values":[{"type":"AND","values":[{"key":"ms","operator":"not_in","value":{"a":1},"type":"log"},{"type":"AND","values":[]}]},{"type":"AND","values":[null]},{"key":"http.method","operator":"lt","value":"0","type":"log"}]}]}}},{"id":"r1","rule_type":"path_drop","scope_service":"","scope_path_pattern":"\"/api","scope_attribute_filters":[],"config":{"patterns":[]}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"actions":{"INFO":{"type":5},"ERROR":{"type":"drop"}},"patterns":"notarray","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[null]}]},{"key":"a","operator":"not_regex","value":"\\","type":"log"},{"key":true,"operator":"gte","value":1.7976931348623157e+308,"type":"log_attribute"}]}}},{"id":"r1","rule_type":"path_drop","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":[5,".*"],"match_attribute_key":"","filter_group":{"type":"AND","values":[{"type":"OR","values":[]}]}}},{"id":"r2","rule_type":"mystery","scope_service":"API","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":["k","[^\\x00-\\x7F]"],"match_attribute_key":" ","filter_group":{"type":"OR","values":[{"key":"level","operator":"exact","value":"\\","type":"log_resource_attribute"},{"key":"__defineGetter__","value":0.30000000000000004,"type":"log"},{"type":"AND","values":[{"type":"AND","values":[{"key":"missing","operator":"ends_with","value":[],"type":"log_attribute"}]}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":"api","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"keep"},"INFO":{"type":"drop"},"WARN":{"type":"keep"}},"patterns":["🚀","[a-z]+"],"filter_group":{"type":"OR","values":[{"key":"severity_level","operator":"is_not","value":"a\\nb","type":"event"},{"type":"AND","values":[{"type":"AND","values":[{"key":"__proto__","operator":"bogus","value":["x",{"toString":1}],"type":"span_attribute"}]}]},{"type":"AND","values":[{"key":"ms","operator":"not_regex","value":null,"type":"span_attribute"},{"type":"AND","values":[{"type":"AND","values":[{"key":"ms","operator":"is_not_set","value":"true","type":"span_resource_attribute"},null,{"type":"OR","values":[]}]}]},{"key":"severity_level","operator":"ends_with","value":" ","type":"event"}]}]}}},{"id":"r1","rule_type":"rate_limit","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":5},"INFO":{"type":"drop"},"ERROR":{"type":"sample","rate":0.25}},"logs_per_second":2000000,"filter_group":{"type":"AND","values":[{"type":"OR","values":[]}]}}},{"id":"r2","rule_type":"severity_sampling","scope_service":null,"scope_path_pattern":"(?=x)","scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":5},"WARN":{"type":"drop"}}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":"","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":["true"],"match_attribute_key":"toString","filter_group":{"type":"AND","values":[{"type":"OR","values":[{"type":"AND","values":[null]},{"type":"AND","values":[]}]}]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"path_drop","scope_service":"API","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"WARN":{"type":5}},"patterns":"notarray","filter_group":{"type":"AND","values":[null]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"severity_sampling","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"DEBUG":{"type":"keep"},"WARN":{"type":"drop"},"ERROR":{"type":"sample","rate":0.5}}}},{"id":"r1","rule_type":"path_drop","scope_service":null,"scope_path_pattern":"(?=x)","scope_attribute_filters":[],"config":{"patterns":["Dž"],"filter_group":{"type":"AND","values":[null]},"always_keep":{"status_gte":500,"latency_ms_gt":1000,"attribute_predicates":[{"key":"count","op":"exists","value":"\"GET\""}]}}},{"id":"r2","rule_type":"mystery","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":[],"match_attribute_key":"toString","always_keep":{"status_gte":null,"latency_ms_gt":1000,"attribute_predicates":[]}}}],"records":[]},"output":{"compile_error":true}},{"input":{"rules":[{"id":"r0","rule_type":"mystery","scope_service":null,"scope_path_pattern":null,"scope_attribute_filters":[],"config":{"patterns":["🚀","TRUE"]}},{"id":"r1","rule_type":"path_drop","scope_service":"","scope_path_pattern":null,"scope_attribute_filters":[],"config":{"actions":{"INFO":{"type":"sample","rate":"0.5"},"WARN":null,"ERROR":{"type":5}},"patterns":[],"match_attribute_key":" "}},{"id":"r2","rule_type":"path_drop","scope_service":"API","scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"patterns":["(","\\p{L}+"],"match_attribute_key":"level","filter_group":{"type":"AND","values":[null]},"always_keep":{"status_gte":"500","latency_ms_gt":0,"attribute_predicates":[{"key":"01","op":"bogus","value":"\"GET\""}]}}},{"id":"r3","rule_type":"severity_sampling","scope_service":"api","scope_path_pattern":"\\d","scope_attribute_filters":[],"config":{"actions":{"DEBUG":null,"INFO":{"type":"keep"},"WARN":{"type":"keep"},"ERROR":{"type":5}}}}],"records":[]},"output":{"compile_error":true}}]}diff --git a/rust/logs-ingestion/tests/fixtures/input-decodes.json b/rust/logs-ingestion/tests/fixtures/input-decodes.jsonnew file mode 100644index 000000000000..4728acc9f3e1--- /dev/null+++ b/rust/logs-ingestion/tests/fixtures/input-decodes.json@@ -0,0 +1,1985 @@+{+ "codecs.json": [+ {+ "error": "unknown codec: null"+ },+ {+ "error": "unknown codec: null"+ },+ {+ "error": "unknown codec: deflate"+ },+ {+ "error": "unknown codec: deflate"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "753390aba6e901906c2819e3202b75aa8366082284c0ad3e358d1c24e6607546"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "b7e565b40c207ab8ee88414195c92623b4519180c28a9e7d59d4c8890b4c5fdb"+ }+ ],+ "faults-dependency.json": [+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "6a6d42e40178ddab42afb13180370a1599f4516a611d61129cde6218532cf924"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "ea7fd565a3bb98e2a2403c405c2d16056ab9c8b0a6d07cb6346e986fb67db031"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "aaf8aee83d56fc8bf9243dc4b2eb377c6f8fda8ef71de3a81f1d02cd6aa8c5ce"+ }+ ],+ "faults-dlq-down.json": [+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "db825edfa5cac78fc725e47227cc64c801ce9f683197506a1f807e5bca13dc27"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "e95120fbdbb228000c612c49a0d4102a9bdbf44c4d63c694a2dabbdf55472ada"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "69113e43263bf940b5073794479297d9fb77df608657cc33285aeee29b69dfe4"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "b6bb19720f61809c306f3f57a16de163fe7967f1611b346d8d35a5d0876649d4"+ }+ ],+ "faults-kafka-delivery.json": [+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "e9989bdfc6668d19d05a20a61b3efb9814e2a9d05ab58ef3766860d6eafbf32b"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "6c7919c8d6224c803ffc1b44f68e78e882e406061df847c78b593c4e8f0fdf47"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "bd8ea24db890499eabe2abe8c774fa73f7f938f728d482e6e5a12af05d318b08"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "20a8b747fd09c8f48673140431b93e8d8cec99b4ba1ecbb8ce919748951350ff"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "361373cfba5b907cc3441f4f51260ffc5663ea85b9d81433603d4d9294460dae"+ }+ ],+ "faults-team-by-id.json": [+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "70b266c4b83590a0c94c2f98e0df510de24132734f169a947e543a85c27525a7"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "14d96c41f06360ea8a55cb4f9e41d015cb1d12ddf3257b42f84bab95aa8959b3"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "cb6aba39688ea28a027a94ee695055d69b70769b483a5cf25fbc3a8b49ed3cea"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "3994b676150ead8fa09f103ad9984576270f20a498ff655211eb5766f39fd891"+ }+ ],+ "faults-transient.json": [+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "c6df3f13ac4c1909ea85c48897f6393f5a729a21ebddd5135bda0cd0e90663f3"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "fb5b52c355d3dca0052ba105b4ca30b5340981ee4e42fc44a95b4b14b0c342a4"+ }+ ],+ "faults.json": [+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "ca1c2318fd32be0d710fd122d8e483e274419a74b613851c07c7b7b49b964f8f"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "512bf63898430d2d70fd1f5a47fb326e298ccbbcdd9dd918519c3395121b390f"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "687073eda6ff4a328395a151eacfbb73c2dbcc60480beb7b9d40697475cf8253"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "20946b752a2e142e8b7d3b455ab9e44d2807126a13a3f12496bf17b46711e032"+ }+ ],+ "fuzz.json": [+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "63d94d4a4cbbe9f6e906ba43510aa36d4102b782d76b285c3f10912d8ce17490"+ },+ {+ "codec": "zstandard",+ "count": 7,+ "sha256": "dac4d45b77b2a18a3cee70ba0fb8e9e94769f58d2884864ac133351dd78223e6"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "347889404929a919378913d2571845740ce316d1bd76953d38e2f88d4e083f86"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "2fae27423ccbc9ea06bcb62dd4df3fcf382778dc106bd065ba7ccb1eb937c771"+ },+ {+ "codec": "zstandard",+ "count": 7,+ "sha256": "ec8a468693183279718601ad7e680a1074678406d903a221bf39544c2b193c64"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "6a605005801f1c798e6c249f52756f2d9d50b84a1f9238ff68e2d538e876ce19"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "1340f3e4937bc3835605eb01d4d993260e185fb0ecbbd8bbb5542dbc49f42a5a"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "0f97c73af1c02f3b12083dc9f8d00bf42e0cf3398f05832b1323b1dd88811ea9"+ },+ {+ "codec": "zstandard",+ "count": 7,+ "sha256": "4442907e4a6728df769f43abb14392037171186ba7d1da898e97486b212a12f1"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "f2d53d58a4af29942d7a3d7f155d8a90a4a683d8bfe6c8b3657a60b75adb9cb5"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "e3a178f95e5cc132b77aa0194668dea522420547067c9128c19724c195fbc0b3"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "dd636c43bc5eb8ccc78da24a5f66963920bfdefa1821efc747a498a9abe7d759"+ },+ {+ "codec": "zstandard",+ "count": 7,+ "sha256": "2b8fe83e97d6594167d04aedf05c72cb41221ff318781378d812c6ca4fcc43d1"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "f8555bda9190975419bf678a9db11e5d5ed4e081119e574bdc3af67597b1978b"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "7a11ca218c139bbed5c8fdd2bb1ec1dc2eeae144f4fd38a747578dc66fe316b1"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "1084337834f3086e9a7e16ebd4bf1b6d57c90704a405d088be1ee293be97bed2"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "cbb1252a4e577e5c75df7978c2d49268d2e1f09c816115e15698d096b4c1559f"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "c1dd7b5729a733bb5ebe3c5ac89d4411e4c7024d014a83753a47d7e9748dc554"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "e2d88c2fb70bd309a699acda0bf0b0f92545b2e33ff3380e506149fd28caa4cb"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "349af24e1bd3c32e68aef5d04b10a3714f9796fcce181b1ed5511c67547ad92a"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "f0894fc7c11bd0826064f640605b74774393092ac7372b2fdc1cf0360b8971d3"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "c9ebf69abe85789591cb07ca1a70ba2534cae59738fdb628cdb9c04d08b749fe"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "8ca10189ba5ab4adbdae7ad457392f6a1b80759ef8d86e3dbda5fd5e2aa67653"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "3460f16055a664343923cfa38b69ec75c646a823faea21659960f18581d37e6a"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "b95fcfcfef6247b45f0006900d3b9477aeb1a65c1ecf55b8ea03b7da73a302c3"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "054ff74a3f84a07ea57bd095a6014c6d2bf88c8e1d6596c6fdbd9cd276bd891c"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "cd8ebd1837f92fb9f12b5160144bd20f976621e584cb60b07dfecf3f4cab6813"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "74fa1b94fc0ba259efabb977723f59233908962da572f50017f1106d94f0b8a1"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "699c919d9ede184aecef2878401bf5f3e10aa675986163a50403c7f022aa597e"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "b6cf225e63dc0ec19af478a8003ecc3bd824617bf6a04c2e30b690a9c28069eb"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "424d03b9a8c6eda11d8adcb669994046b1b846103c7582628c7046370e149734"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "f35b9a77f8dfea8da32703f1c3cb856570c6a6caaa9d1d880f13c2e6ba3c3c56"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "18bc9f238b1b42998119997c5b0de5fc125b5e640ae8c97580d85019c8d053b1"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "79a0bf6f46a0bc27b6614e0c407d648bf0fde3e50c1d9ce5b4fcc25e2defd828"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "b8acd75a6bf640ab962bebd28dd249a6557aa5a4b4c23e0546bff49adc4caa58"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "ad36cab734408e0f065c8b773964447d13e5680a09e1178e9e66622c2129d415"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "c1dc0b50986ae26754d40d795c9d0825a848e0a08d9bec640de0b58d009ca9d8"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "2f0356c9b6e0f83796aaa7f54a879e4c2b36fe0a5d02ebf65c91c1695b3d491c"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "3cd4c89671da3907e5b19c25b0c19e6b804451d2770579120b4850819ebfb447"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "f4f9e58f03fcbd110a107f270c0a4618d5edd46a88db0495ad241f5ccec04826"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "de0f076aa2615194852f5a7fb235cb85f6a0df510b2b50de1f16b5788af17943"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "c5a49a269ca0626c43f573cf5259effe41e746dcb078dc0eaa0e9025e16eb499"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "27e8368cf25d4ab8153c9e3ab0d900718c4345d43005df4cef7e0bbb398fdedd"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "35a70e6694eed9905d8e6c50071a18fef8c7c56a7d9f9831cd5a1b8f343465c8"+ },+ {+ "codec": "zstandard",+ "count": 7,+ "sha256": "b2e9d2b80a4abb1749616c7805b7c155a07f624416d20466e539ce5853ec41c3"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "7069edb2fd6bfe9b7e5f5b23a3085373525ab0910942d4e40691791a9c375c42"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "5595673e40314cd7bd46cb32e9bde8d1b560956c60ece85a6cde9681834021fa"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "02de16ac4e51434b65842a6cac5388af7aa42178c9790a740841af333823c01c"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "6227dbd3452fece31f379af3000f2a95787be9f031d80df357984fbde050e316"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "c7352573530c1257372f804fad17f2b3c7f531f732192533d45557c31b558b9b"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "0480d107717063b8ec67013a502bcabfd8409d06467b5ae172f2a91035a03fb6"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "1868ae04fbddb96f268307343d37c7634d0b6375f476782a8c58e136a7b97964"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "59504a4cf8607d7adde4f878afed57d4fffcd715d36b94de0d109c8394f54d8d"+ },+ {+ "codec": "zstandard",+ "count": 7,+ "sha256": "b886e72ebb4236d5394adc1bbaeac81ae53a849b41587dfc62cb7dd4cf41b929"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "10396dea91a32037153796965f839a406883bea7b25d10faaeb3be976d0e07a6"+ },+ {+ "codec": "zstandard",+ "count": 7,+ "sha256": "1a49f37866d35cbafcf9cb243637b9ff3e5187df80ccda2417b884566cb926f2"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "9e0236f80151c5b4f464a72dd3b645797c27a9024b8dd80a8616d2908c634b34"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "8740d3da23a0df8e6c865e736fc4f1db84c05807b233bde5b8f09f56c9418704"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "2fe776ed8e4a0322d9d9cb64710637eb3e1751121239116e9a8c430ea4b80eec"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "52c3f9bd9a706a1562ad8d8115646a6fad025f359aa592ca0a3a67e068d24065"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "e3870fd834187e867c53e222338b6aae0855a6b87d6e0f66ee960e204edc6009"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "daa86702c60294a3bc8c4de528aa5da219e329ed9fa9924877830acaa9e19f83"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "40f1c84085937375d9386b763a309c9f5fa5fffb42b424e75e262fe92480105c"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "000538aa3c5ebf57be18469d6346b939a3af37fe8ab07e4c692b025636f3018f"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "c88dc617d266d26d76c8c506c6dee18c9d46d70d82756083654b7951e4d94a6c"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "95524eb93a1b7ed3d026b3d2f9bda81de591006d0ce626b32ff38bf395ed2166"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "0bc2f43cffc340fc8aa5b9aecf9028b9adf3bc6fe51b7cdb2f23710198d80fe1"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "5d4e81778b10e76c34e641e21248e6fed81c6e824cf7d58d10c1293144492d4b"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "97d0c9d17062810d9387d5ab5274d9823a215a77b07dba861ba9856d0fe3e113"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "03aa0b9a7012d9aa57a7690e3c774370f9cfa1c01a245c43b79930d05eee4812"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "c823a3255410ff03ac10296a3dfd8148d659ba74ba612720031795852132c597"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "6c4abe4e136de00bbdd616aa1b5cca898a0dac4e6e7cafa58bdbbb038b2e6f76"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "b788ca3914600840c923513e9aa18eddae76f6c943f39bf51ae9e7c7edc9ce63"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "78c1f5350742c9587a68dffb581bd162d6432030728713323a2959bae7d8ef90"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "61e053ed4d07d89b47c47818ac5bcb95fabc396258336e6bb2979c8084c06dd7"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "e00cc2208e647681d134befee63b219b9d620e97e11363a5fef8fa8d786fb444"+ },+ {+ "codec": "zstandard",+ "count": 7,+ "sha256": "08ffd74793a027f3584a959a944d93785534ad8568ca0901a06575a7417900b2"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "71190dff73b5c631f799f078d90cb94c629c79108189eb63b4de992cad82748c"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "cb3af4db4ca015513b5cc676137411b6e1941613eed7245a56d3ddaba49f794c"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "6916dec2fef84e0bae7000bce9847bf3df1ee9ac0a374206a5297e07a03da5c9"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "941b95f2d9f6ada6ef4d2b34403405ad7e5942089f556402007b041f086fb303"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "65b31ed3ac7dc5922bdd62c0b3f3c3675ccfc1b1eb31480221a93753b98ddc9d"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "e43710d4d10f7ec77822b0ab9d1df5ddf1362e0c185bca91e0b94b57379a182e"+ },+ {+ "codec": "zstandard",+ "count": 7,+ "sha256": "d26b83c5f2453135de0bfc62d8d92fc92cec63274d9b599a57df5a43515d7d37"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "dc5afd2149a0aa7c0659af0aa290421d4df56f3eac7270a50d0f1c95c2a70512"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "bb5f07865002c0ba43be9a13cf1dd8e3974034e586a488c0eeca4d73bd4907d5"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "7aa17a2ae95fc9a464baf3056057376376984bbe0bf44240abe955320a3e5e3d"+ },+ {+ "codec": "zstandard",+ "count": 7,+ "sha256": "9325f220471c50ea66d5f4390892f56577c8bcbcf68812de531e90deee15c252"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "375fc816abfb977f62e2ac8b5bd551c72d7d39df9fe2612099149920272f59a5"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "2e405b7dd78f432fd477c2970554bf681315d42c107566ce0bd971003514adcd"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "b4ba06d85fe159dd126492e28e32004ff34c38b3e0e66977b541f830f718c5b2"+ },+ {+ "codec": "zstandard",+ "count": 7,+ "sha256": "132acb84a114722216e415e5e52847d47ae0c476805ec14e18c2f47c06be634c"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "164ecddbe1e9b23444b5b1ad98df13c0f1ec35b610b03a3819880768d0f5dfdd"+ },+ {+ "codec": "zstandard",+ "count": 7,+ "sha256": "463e884bfc89e4d80797d5c330bc6d1ab1dc4d641a3eaae54d85b3461768d2c5"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "c442dac2f86fc5296cc74c98683a5b62e218b5330e2a7a43a83f9b73d2823fed"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "7552b8434b4016e0640ae949512148ae53b166b0a38827ee28a5b02b8cbe7df5"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "cc7ec1f668d6ff0279639f14f0a22e77d2b8285beb14448cd98b2efd2570709f"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "ef0e5039fd274276cd999ad9a21cc5bceb144e43239476a5dd9d9553af7b7fc0"+ },+ {+ "codec": "zstandard",+ "count": 7,+ "sha256": "5670ff34b17c0896006e07fcc0169c8ca80f10ff137431c1b2939ef04beeab22"+ },+ {+ "codec": "zstandard",+ "count": 7,+ "sha256": "5894710fdb4b3b7982d344eba7410fcc84c329e3339a523da68d9b1afaabfa95"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "cbef13d3e64f1c818e0d8ef6c53563cc195126c10cedc38e550a7f52dab7489a"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "93fef75cd5212d926394bef7cc2ea267c646b561c6e5b85881e4314182b12796"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "46e66b9aa2d85fee6302ef20c1858db8ac0351e630efef24bdd65e337ffb42af"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "3003582c8661b83c3b94839277162af0d88636bafb878957ecb82950e69c1abc"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "429e24b220566f7f381bc3be2c8ab57d1bd43ff2e748f8af94755c84ece6202b"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "bb01f398480ccf9198f56e934cdedbb5ec4bc0a3661adf4fa1d039b5ba54435c"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "8e9752adcd7ba9e61623ffd24e08e62250e6630fb3caeb73ab071ff2bad5a8be"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "3623a665ce3cdd120ceac0a5a34e951bd538d1ab294ceccfe023eacef1e4bc81"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "b815160d856dadfa06133eea7e026d61cee6fcb28fb9ff601fe5e98ce8dff550"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "ce10216400dba492f9acebf44152a8b9cd14eb83c39e24c39f600efe9f4e31a1"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "ad5c783ac5a3b40100be85429890de56f28fc2e3af18d4b9e8bf91ff35b40c86"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "b304107fea08b67623aedef57ade2a970a36700076284db550cb7ca38129d6d6"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "d78fddbd0f15830a1bb990ce8e2147e4c177e92dc70a0d71e98bab8584dc4bd1"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "64237cb612828fee5eaf595b5bff59831d1114b953b362b92f2c0221f2bfd5b3"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "0fd7ca5ca895b6a694ee9880df64db89b48a90fb138cd61732e2fb5b4ad2bcb9"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "c9fd84cd65ae3bd2191670290d832382126df8d3861790b46451416fb37890c4"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "f1c517c698ba5322f9cdca0f074df772d2e3e1030698420c20a48e30b120e547"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "8ce8b27bffa4bf72281b6a12783b4344c4687d04e38aa792237d3e813947c55d"+ },+ {+ "codec": "zstandard",+ "count": 7,+ "sha256": "78b455e10e33154be87926e2da5148447e32b6d0cf40d0f9a3163011d4ef7b73"+ },+ {+ "codec": "zstandard",+ "count": 7,+ "sha256": "5453b32e082fae9e885f870ea40f62dfa96accb14f7de8f0469246d324fa10fd"+ }+ ],+ "gates.json": [+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "0ecc9105bb06376f79b70588685c3425f9d2562b9fa46d4977fe03c21a62f68e"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "09f7663c2fa5476bb8bce6b27ae38649aecd95c7b7f667f4c7485d73be128867"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "88e3a2519b9b3b897a61ae98835cf35d2e5610b743409d4a5ca83a8ae1d2a9e9"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "904a6f0f12ccffece9451b7a1941de164ca2558a96ca5cc227a602a2ed59d344"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "fa152e314abd79e044eb2c608a4e2e87708780e9313bd58b7f14bd3b5f9f85f7"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "8d29b2eda9b366bacc690da2654d3d76c1767a0d3be2aac5298bae994f1bbd19"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "c81ad26fe6f7c9be23f4a74ba4298e91752a215621d85fba25eee04b6e8675e7"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "cbeb77e9a4dad2cd923b4773f8bdf52f8e0ac844361e06716952c710503713b7"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "b9a29d164be107a5bdba952c05bb10e03896180a20aa91bcbb658dd33d3cf0c3"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "d38c9ed68e744b992e8d3978904ad933b1bfd18cf9e21ad99869ef8ea625c3c2"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "22539ef96fdece6e12611ebe400db5d76ba25bd565a5823bab3f512e883f5dd5"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "799a4b3e896f5c142309ef9746050e29d07015bd87887fbefef9001db0cd757a"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "60d920de38c4a1c341023756e31ee51a9cb875a4f1c8477fea7b4e0d2d9824d8"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "03ba759d17351074fde05cd1e6c704dabee9d39eec0717718c3784f534794f8a"+ }+ ],+ "internal-logs.json": [+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "7e88387a72abbb10ea60efccb3566ca2a693d04fc4abfb2a99644831a6b799ee"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "26f84e0951715ce25e4095e0540579f81f51225b787a4264c4feb5b6b745ee3d"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "c274cc7026b538f11d0f2c7db4bcbeee4158467d42499b3853de19d35bb67e31"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "45b6c674c5b7916df41ccce62025deb42c4520a61fb47611b07531e1dfd509a5"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "8103efd19dad0209a890f98ee3d757025bb89b44afacea27239a6fab98dafe7b"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "93e863766f790bbbd7b762c30a9d37613fd013ca184a68f85f59f36fad14ff93"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "536c7cd440aac1a50ee3ededfe3097b69068b6f0e3ada30a95b0fc5497c6816e"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "038d8c5eea56b06ac06d9b58478d2993443685ff77d7c7877c94d3331353c490"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "d5d501b615231853ec15243e71352736068351cb28f896af994dd79dab8c9c92"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "acdbcf8521f61331898d2dcc3a4db0d7574c0b246237a28ba075c65e3136190e"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "8ec2f93ad92cffbab45bff1d27a554c823357b986c7c87cc8513efbfc7f735b1"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "e2eeb3510579f058ddd352387226035fb773e4a68d2ef248cbd66cc08cd23605"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "a84fe075be9afaa55c22cd0af5bd2511bc45b7f18ab79a4cec513619a67e2b1f"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "c6a69c421a72f0285f02d9670ecdc795437cf0bab9bef4cebe5852c27bc81bf2"+ }+ ],+ "json-attribute.json": [+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "5c3ab4a431848938c120d07e02725b912406b31fa5f13cbdf7a6bbbb5243b118"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "7d37852325b331d695f32945878452c64f3f0b39ea8f0f561c138f06fcad1e1f"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "e809283c1da8308e2da8b04f108843afea0a998e602c3b9bae80a96ffb38c60a"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "07c78c11cf4492b24094c7e639d024f00514e6fd0603c4591fb6868a5903dfff"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "3c1af2ee5b3e739cfeec9d603aca6cde3a16d292b23299fed99644ed87bbd9d0"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "47027e69c8f5c89f7fc777e942c3c8b92afd7fa6d38ab88db8db27317334d0b2"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "31b7391670c5a69c927fdb1461c93376e92ccb137b4eb5a9e51039c6e992207a"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "fcc2ebb6af2367551dd5e1a587b78d33835bd13d20ece57167c87ba7ad07baaa"+ }+ ],+ "metric-rules.json": [+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "8375476cc41da85b19e4404317ff75bb1ba5cd38805f905cc601db3d74f69bfc"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "dfcb619cc89a243ea919c80263e2fca31649710ab4144001add922f9aec3e8bf"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "339e8ce4efd977b6eaf073b2b12ac04caf58501baca218791581616e7841871e"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "60fefa3a82188c6581e72e51f3533ef014b7cfe548f66b8a625ce24f4f40dcd2"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "9099606ebb30bbf0ef101ce7e079a8d19b36aaf922171e5fc27bf3799ba31fa5"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "ada00231ab9b922a962e05836221844580a2788e719cf6c70661daec50af308d"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "4d5a717be2604d2bc2e4a95e5ff4a0420dfa08ed0ff9cd7bfe68032214622ec6"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "7c2ce2dde62c340876d755bcf5199b90576e83e1fcef3473c43e9b0c5cb3f350"+ },+ {+ "codec": "zstandard",+ "count": 7,+ "sha256": "589715a9bcf46b9fcbea62b635e79bb08868728af51cced97bed60ef818fa145"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "bba6003bc8db352be3afafb1cbb8044c9bf2a5abc216e74bc47f60e4209189ae"+ }+ ],+ "normalize.json": [+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "2842e3953d22a70646f744d8e19f38b165b2b898fa1583491234932eee057707"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "48af5a899bcbf75716dd4c1b7b5548ebea8218d1fce04d5e730e0809fe5e5250"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "9696137e68557c036e1ba60489b26ae395a436f1bd09c8389525417e343370d9"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "efb343a3dff9d6d97cc924f68af468d57f4be09877b8e6994ac93a154cc91fd6"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "20d023ac8aa38fee6156822e6b835e076cd444d66fb9ce10af14b8cda9f4954c"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "b06c7c1f25407779b859baedaa6058c54c96a9d4b09c7cd80c5d7e4549f3ce54"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "8e8ab61eb9558c527b7535101c1f7f5bce0f57adc8a4de85d463dffb95a8fde1"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "0ec7ab212ddac0676cb4b2c23c21ade3901308507ae65a8b318577fc4b29e06a"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "33dbfe7b5cebf47ebe2a100e374cdb941f5b43a30ad1390c13410919bcbfdae3"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "2946210949a9d9d864dd87f1f2dc8d105181272c4dd1eb1904ee880c61ce34da"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "3496c782c6e074c52b2e5d6d507c3e02bb0b6d111b559bcbf6d8393e351ea2c9"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "03b6c1d2ae2ce3a3dc449a7844c7112263622f62768be7ccf7a452fca2ed96f2"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "276e36a7b0494cdbf0bad854ca2d385cd636d6b56da16db056d9e46b4ba8a81f"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "97712ebbaee90c5d1ab20b8fa1ec401e797faf8554a53950766b12c39f174f85"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "8d2feb2ec85c48afa2b0b33c4c55adcf45640024ba91d6c09235e7b2b615bd14"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "964bad5e7f322358c55a4f212a1d3054faf33b803dfcf93ad2a319d92085e12a"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "eb59bde1d97b9e68370dcabc563beccad2e8805801714c4f0271843d1a124c58"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "906629aac40bf9611854661fe2ef43799353064e4182489d10b11d8deca0f614"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "1e6196f919534a3b290c403727acc8f69d3df28d4e655842d80b45c05df90bfc"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "f52ac04725e0715368cbdba40edc4e8e790cf0f3e9033d809cfc26db29b3614a"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "91de81794b0adb88866ed94ae20e164bac3048515c76c890a2eaeb2d65e6a746"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "ed9012f33fbece6d58e9285e4cdf48eeaba91cf482509d6da480eb8ceea9bdb5"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "49ab50a76df7ead894ca7043464fd3f6296dd834174883b64d8b0a239b3d0b7d"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "954bfe61fcf62758bfa9481e5cd4667380e58de058156ebd7cbdf86fedc5fa6f"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "bb6bbffbd91db77daa370e577fe64d26eda4e717303de0631663f85afb1d8569"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "f45b5c5308a8ff7a9e091fb84268a55f3754f68a582e299fc7a6fa03153a2be6"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "385ee1a461af2ea942157c366823cef18a69ab12ca7ba0b63f2ae6cf632bc540"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "f776aaf0d9dac6e6e5597af2c7fe80b972721c8e77c7c6c80bb451ad1e1da62b"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "dbea45a6dd057bb61d34b4db1149febd026e7f9422792dd32ebd47d9c7a78a89"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "8b6ffa4320d1092d94c9418e510e08cc611893067726c866ccb1fc39a01ce1f4"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "9554600770a2b4b1c28f1a5614fef0abe29957add5c6148181cef191d91b1b27"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "660c9413bc2a4c1e5c00b11c58ee535bb75db50c828f4f7e079c085b3592e72a"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "6c5db4aa426de5b4535cc2266906232da6ad8cc2558d86fed1f1463f3688bc4a"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "43e6710b3dcc5349747a5fe3a33edc204a8bb6e6b174c673c56c772722bc3c4f"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "1597da14a63e3191c27b9332488ee19b53e1e6e05ab7868b8394905dccfaefdf"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "892213597180e84bd95a1e4f1c03086e9d3f188e9e4530056ce7fcb097b48f32"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "89cbb4e70cc389605c426f360fa0aa56ea2eecd0a3bdbc59c54628e00e691546"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "e04cb64cee792542ec47b261a1bf29598b2e759c8b965edeb587fe564f0475d2"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "269ae9d79d0dfde02b6381d9cffd5b46ed8bc2b6702d3322001c7b7d10931a2c"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "eb515bcc56eae92b6044b8a7626e07788529d0441df491c04495ce4cd6d2332b"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "5a96bdbf871d79be40826c849f03414259f92214bc91e2e6c66b568252724e97"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "727461517acb3382ad53771df1eaf015ac15bd483fd3a95927f01517ca1c2ff0"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "c38ab71b88a05d8c2e117399b316e8a11e6f9e287c54be42d0547a40a21691cb"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "adaad7ae2ba83af756ec996118216021b4f614c00f5750c5a1a3d1d9dfabb3e9"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "221c8c7312da0eb021daa96a822b72190d3c52859ea5c439bef2a182e2a549e9"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "006193e3e24b3471da2a5164a7adffdf81fa23332803efb78267c61894e153a5"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "5a05834b10a9ae01babdf69aa3b83bf4d94aa33071fc3cf49f3f778e17300f53"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "58e956d1c29b51d5debf0dfb472cd637fbfbfbdf676b6c713972d134809a5a64"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "e2049c55131480e77ea9c94db74eb5a66ee4c381331948f01d4651a6800bed0f"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "92d01ea834ab749a137ed46556a471abb6af3428ffd4e4383c3e45717b96e8a3"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "2d7029422543758b338dc2db7f733c1356294abf15839b770fdd3ad29cbff937"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "65d2250676ccf63e2571b9fbd749c2255d41ec3cfd16dd2d8e93aefc4d927be1"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "ba38273838fd9610119dd8184661ede50ad8de4a9b652c42b42684dc6a795c65"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "bd1d2f10140246b7535d90643c046359e65f388c6bca5c682e39c9f3f57585b0"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "8503b58d2594bab6f496836ac8390f30011d5f808e8c5039db28736723b7d200"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "2d8b3494826dc8523e4672ea8d9b40ccd8b3a2b713f6a53a070dacdb42a23bae"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "8a1125650f3405e5b39f7d261df609b1e621ebf6b90737f623382c0c8fe6090a"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "876966725eeed75197d98544fa68479e538db3f93d80a4a7ce91bb77ee2ddb0d"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "a6a9c643493dbd6ac0c52ecfa4110ea51e8f1e1b73e446bb317011c333e44bf8"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "dda24345fe27103a39dd976be07525e1fe2bdde7a4c429575a698ca8fd3b1f49"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "fd89f5f077ee7b73aee96120688d1ef66d87a2e41a63c1ebc1d580a96dd6ca77"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "d70118af938a6cfadd84954e4f431e20580ae64d02c04951fb073fd767e9b7ac"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "fc5f6531f34abdda66128c4678ddc6881009d5518e328bc3cca7774d17698254"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "bc1a63329ee8c2c93ab99c43ea05d1f136a7d3dff93e2f10ef2e6e68711065ce"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "0b2269bc0980f3563f0026788e17e03233c703832a812303ac9ab08d5a92e7a1"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "3854f6498ab2aa611ebdf72937756ea687857c7a6e89aa8648ed7124684bbeb9"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "62b50180418fea5cabc4016c959a6fe68d3a5ec95705caf6c8e6195ed7ac0d7a"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "853acb00a997a3f7eb0e9cfbabc464a80ffc782d56392f35ac8db33f5c67a85f"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "54c2c60a57af0db437a7e1964d9010dae8f717b2e9de41da68c89c414491a92b"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "1aecd85faa88e8b4dae3b14f22aad8182fe471887dbf6d0b13ab46ce0f0910c5"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "0839f6717046b3aadab699431af61e046afa04a029a54413f29a9d8aec053258"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "5dccb982a316f3538dd375ffb0ed60b6bd5ecc414d8a8478a32359fc38055d86"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "8f5d934f9457ed6fcf281a7434dd5c7b4a817893f25dab6e5b651d61edefe285"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "dacb87cff7422ff1072620296ee4e449f2663407e5e62ef61ac504fc5b0f1e42"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "016c08864bdb7385c65e6c5ece2d32ef717701e64e735c15ed47d2f3e061431e"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "1b3f32d13dcbf12bfcd2949112fbe3df03c43aac46b9b43f2ab69023c3c26918"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "5f86640d342303b5001d1f6693b1823b52681650d171743f4af8cd5017ff3335"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "380fd8f9d18149fe663f4e23e3beec921aac690ded648e0c01e5596f0e7ed81f"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "ab02bdbeed7d38ba1be8ae04d6fbdc8ebdf666046890135f70e9649bcf888ab1"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "682a676a89d39c69008715c3656d1bb9c01ef9abe43528b3c5e258510ab7fc37"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "c6974292242cc900f2fc43d07678541152bbe3f3c84880d4575dc5ed50027bcd"+ }+ ],+ "parse-failures.json": [+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "8e00ee8f8ddba170a81d0f8e74d3ce0b5fa9ab2ac86a5e9ba9c2eca56eeae8b1"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "dd68c350a23aac5cc1ccad479f747e335b88417900d98d9f5bbc3f8252fe67d8"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "accf62cef13d410e074a53950e65bd8c308bfec34cd31f55aa1fc38150c9f1aa"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "4a19d612947b410f521637dc66b769f6d1df450b5beeb5cb8bac7ae774015de6"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "a5624fd9b4630a73f16d9bd69c088a954c4b52feb6b564234fdaab286a1494fb"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "37fc5afb15fbe62b6af6c3ac5f2ce8dfc125ff911947cc7a85fadb255067d5c5"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "88207fb9089713244ee6baabfef81d8c3be10677efd79255e5b643104b96a22c"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "c05ea9de5f41ab5e54383fd6b0d42b5db1099f32fb66576c2c50b4b4c9b100e4"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "b0d77cb7443ca784824e98386c6c1a3bc777afff0c33a38bcc311d9954d3bfba"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "1d20313d8e573286e227b907bcfa1304627cede7f17d05cd02e5c5c13a29e380"+ },+ {+ "error": "invalid magic bytes"+ },+ {+ "error": "invalid magic bytes"+ },+ {+ "error": "No metadata found"+ },+ null,+ null,+ {+ "error": "No metadata found"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "db73eeaf1906a719084b8a647ebbb636c9e2b398f7c442b7fd9d7219a4538854"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "663ca6d9fd7af1d2c7acaaeffad8dfd430e50ff220859f204a942741333a8d49"+ }+ ],+ "passthrough.json": [+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "2563a4ca41957a720fabc03c27456df5c88ccc0f2f58a88a489d70a3fad0fb67"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "e0726089c9a3f0dccf3c0fb36b12115e135e222dde24618a6d1fd39ab1263d13"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "5ba0a1eed1463b1a244a9ecff490f04d25893405157d167a3edd33b2fb7682ad"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "fea2ae5b68ee75b2d1877a4edaee83d0e7fc6f2ccfaa99a2f2ef634738eca643"+ }+ ],+ "pattern-masking-no-cache.json": [+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "f67b0786871664075eaffed20f70298177e29b7f50a1dfcbdaa2f1156489cb0e"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "eabf71c573f102b6760edfa5297915d9aabe130084fa5d1f4280ce37c4717651"+ }+ ],+ "pattern-masking-outage.json": [+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "cfdfb4739dda1063d16f2e412a928c6e6229de3b4ec223004275c12641e2348b"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "2a403dd60814fcb97dcc4e740e7301069a0f76158bd0b7c4f269b17b37899fbd"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "a0f56cd60bdb5d2312706bef02c65d161821fed7e360b400de3a886dd686e3a5"+ }+ ],+ "pattern-masking.json": [+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "0412ff30f2c1a5ee3513544f4f62983e7e58cb0e3434e4b3fb135c33aaa4877b"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "7de54668ab24592fff48c86a24d2d962ecdd9c0f20c7c8389c7e30bc8308dc3a"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "8fe46e7093823cda247a8bcaa4ae0ea3aa4f42835db66ce47582d297cb624ff2"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "4420527da9e8c944ff09f428ef130d4e79374598c7564a19dd04a91a5ea15515"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "a19d2a8856d13ead048822cf9e4a05b5499de73b9603f8719cffd63ba83bbea6"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "adf75c52fceb36d7212cdc6c3863a0ccae0b0662e1205dc3de7514d6357f9c2a"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "035fd99bddca19c1d03c8eac277761e01f0ca4c5ff51d7672a7d765cecbc3f0a"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "32df6731332ebe22f1ad77ad064fd50cba70fbf8903574ddf6be6c5b4655cd5e"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "f2f87f950b5e839252179ae038feafd0edc388f4c65409b8bcfb68e223738058"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "492225df6de98cfa01a3bbbc3d861d0fe234f07d8820f84c9f800c10cec30778"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "d17063f7f076b68fb8cd0ed545f66ef7c6bf0174412ee7c271d3320296ebda33"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "62685a01bb50697e90dc831bc6f111988877f6c43ebc66b342a7c4eae7626b92"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "9d7d73cd532729958ffc71f7045ab895220ee14b32b5231d8cff3761067a87e4"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "fe884d1e7dae5f387a94da0e57338beee7a053777515927fa74443473ceb689d"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "713be66813aee8827e0c8ed0797dbf07a3e353e3e05f2efc1fababc7d0bd4706"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "353fb0ef34e18ec2262f83b3932ce3ef3f74edbec01bee70d24c30902149474f"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "ca57d19aaf5f5fe9622f173ad1ac7123d7a21b9aec4fa9aa948970c504da97b2"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "75d1e59c28a841f9275c7d0f51916f3af40d0d7b4a709b3228ef5b5f73319566"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "6e61fc2ed345af0ff40360cecea1313c40fdffbb196f3154466e52d0ff040ede"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "eaead1110546883dc814b77421c1e21db4701039e506202043cbcfbb9cf353db"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "d2871c1ec34dd9538549f6d6dfa2eb9a5b11fd27a1e15898f667da8e3436c43f"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "28bbd8cf441e18727d37741a2714b52322057d39b3e6e71a22ce7b05e3d03479"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "cb86b689db41bc097e5d21362ff33010c11a9e833f671be5b3d117944d0c2923"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "7596548bcf14f5e2f19f81bdfb46c90fe929059b6b38a9a5e5cda6039f490dc0"+ }+ ],+ "retention.json": [+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "de266cb47217d36780e02639f43649d579200024fb04059b2a6a496ebbcec10c"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "d422f4417b0057b448a832939be3562ae613bed2a43b064d1e621d1ec7e38073"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "a111295e32a090839308d07ae38e9cd2c536250f40b3f7c917558075ffe92f44"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "e7c51d7cf60cb64c370df8e3639d57abd5cee0b0894ed47753da6249b6b1e3da"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "b5da15bb347c21e77c7f977587b5daca3e199f7a38b5d092cb28d9bc4b1a086b"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "218ebaf4dcd59b962392bbc0425c3913ebc037fc2027b3fdf03575af88ec26b8"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "b1ead4cff482492b477b805ec4f367bfb596d78dc6cfefd50c1c7147751b368a"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "09d82ab1141130944b90655b3fd2ea1c435cd72db72e245e1a25a51e7c6e0b7d"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "2a73d6b744858af40cc00883dd92b7ec46191ed32a48d7dd8e10f47e69ea945b"+ },+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "2fa25f7e7cd3acd06d1834a9ece4abb424460326b0dfe3f7f8e19c9fad8ef130"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "9016f057a276f80816f997a78515941c058690ea1151d173420f68adfde28dff"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "d581ae0b24df507d9061b8f61d21a33aba278654fee4ba8064410384d7e07008"+ }+ ],+ "sampling-rate-limit.json": [+ {+ "codec": "zstandard",+ "count": 6,+ "sha256": "eadc01b453a6b23ed86716f9f1b21e17cb5094f5b3cc151854107b0355fe155d"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "20d33b87561d1a1b379046a0ffd1800fb1cb90f420e7841cf9a5f6cb56c217e7"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "e2d1010d68eaff41cba1cf3be906dd929d189ae378fd2d14f1f0630a525c2bd4"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "61cc420eef15ac511b665500ab48e192b9b1ca63386ede4f1b22568bb868b6e8"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "722db2d153beec8eac0b6abf5c27f848b278fd7a5e7caaa02d5d1ade87fcfef4"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "aa39a74db83596646d058d1a6039fbbe7f3e97e24929c15c8dd84ec3bec3635a"+ }+ ],+ "sampling.json": [+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "ed2dc1a18e30240046fc9f7c11d4f9d18514632ac9907dd27a7c43cfc6257714"+ },+ {+ "codec": "zstandard",+ "count": 7,+ "sha256": "946d14566495080e9c4ec0b55bcc236ee041e5fcf946a604a2333a8d6337da26"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "550d7dc80f65a74a8f69956875437d44b8bfb868b4788dd3890a971a2106886f"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "cb9d611733a055822ec2cc0c09ffbaef84f55eeaaf39768c27c38e205cfe862d"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "4db3f4f34cd2816178f9d64c394556ea3d462b64a4f812a465e283b859d06178"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "3f77a1f03d236ae7c51abf6e76c6dec0098241893bb236daec7e15c2f90c75c8"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "53d05a40c6e6557f32f2126afb2e8ed33be88c0423c19c26e61676a30fbc1740"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "86c632cc958fc29205e45ee14c23d6a5e6177ebd541aa4166cac7bd17b3c8a16"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "ac2f7f53850aa66c39fca34479b6e707158592f1402b67624f1b48ceed4a6eaf"+ },+ {+ "codec": "zstandard",+ "count": 8,+ "sha256": "bce5e0c2322c03cdf6d5d995cc269d8dc11562fd34b1dca65ebebdba1adf5b09"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "4ed46a9a459749fdf1281390c24ffc39aa6bae0c58b70edc703c1c84c93de486"+ },+ {+ "codec": "zstandard",+ "count": 1,+ "sha256": "74fe7edfac8799dc57c04723e509675fb502bfe022dfe3d2ccbdf2e06aa6d814"+ },+ {+ "codec": "zstandard",+ "count": 5,+ "sha256": "46aa896163046ea1556e0f160be0f140fb84a22a516be3643412837704fa90c7"+ },+ {+ "codec": "zstandard",+ "count": 7,+ "sha256": "739901df1d1f8b6f93dae3e6cb063db5342741c9db1666e96adda9bfdc3fe97c"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "86e9eb15de8c2b131241f08cc17f27831fe180a8834d5006dd6923fa2abe0286"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "d89cf3f9f102f192e4aefc02a43f05a83480ccbccbc0aa1c3e22ba839a5491ae"+ },+ {+ "codec": "zstandard",+ "count": 3,+ "sha256": "feb5b5d5f9ef4359ee6012918bfc0616ff866ef7663c6ae1a2ee43cedce27dd2"+ }+ ],+ "traces-no-config-cache.json": [+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "f957f025ade6e5702707c2898d771beed8d2a25a58be73a63be8e4562418be12"+ }+ ],+ "traces.json": [+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "9cd290889471aaf67911d5191400ecc46f1a8ecec586da7c904d2184bd18d7f5"+ },+ {+ "codec": "zstandard",+ "count": 4,+ "sha256": "2fa80cf068b2a52bf8c5ecafb21acf7fa79602e74226a89584be8d7075d0efaa"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "a87a0a022fce863d55c19be7a29f0017b9913cfdce96a9e2df34e82cd0e8d658"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "79546fb8bf8e069752963914e0dc76492c6e6825948bb4cf369122f039ebb54f"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "3f7ff1f6aa4099147e99a7b5645f746e31429f46a181ce4e7aff8b6a38e166e8"+ },+ {+ "codec": "zstandard",+ "count": 2,+ "sha256": "29b4d55e38e0100baf83753c94f1cd58f5c2e720a91a5067e64fe95f57459f62"+ }+ ],+ "edges": [+ {+ "name": "valid",+ "value_b64": "T2JqAQQWYXZyby5zY2hlbWHwBnsidHlwZSI6InJlY29yZCIsIm5hbWUiOiJFZGdlIiwiZmllbGRzIjpbeyJuYW1lIjoicyIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdfSx7Im5hbWUiOiJsIiwidHlwZSI6WyJudWxsIiwibG9uZyJdfSx7Im5hbWUiOiJtIiwidHlwZSI6WyJudWxsIix7InR5cGUiOiJtYXAiLCJ2YWx1ZXMiOiJzdHJpbmcifV19LHsibmFtZSI6ImEiLCJ0eXBlIjp7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoiaW50In19LHsibmFtZSI6ImIiLCJ0eXBlIjoiYm9vbGVhbiJ9LHsibmFtZSI6ImQiLCJ0eXBlIjoiZG91YmxlIn0seyJuYW1lIjoiZiIsInR5cGUiOiJmbG9hdCJ9LHsibmFtZSI6ImUiLCJ0eXBlIjp7InR5cGUiOiJlbnVtIiwibmFtZSI6IkUiLCJzeW1ib2xzIjpbIkEiLCJCIl19fSx7Im5hbWUiOiJ4IiwidHlwZSI6eyJ0eXBlIjoiZml4ZWQiLCJuYW1lIjoiWCIsInNpemUiOjJ9fV19FGF2cm8uY29kZWMSenN0YW5kYXJkAAcHBwcHBwcHBwcHBwcHBwcEigEotS/9IGTlAQAUAwIKcm93IDACgMD6q63vlQYCBAIxBm9uZQJrAnYABgIDBgABmpm5PwAAwD8CAQIxAoIDAAAcVc1pAJ4HBwcHBwcHBwcHBwcHBwcHAnYotS/9IDKRAQACCnJvdyAyAoTA+qut75UGAgQCMQZvbmUCawJ2AAYCAwYAAZqZmZmZmbk/AADAPwIBAgcHBwcHBwcHBwcHBwcHBwc=",+ "result": {+ "codec": "zstandard",+ "count": 3,+ "sha256": "945a96e0c019aa0e95ef774a082232d84e25a97b230eb02bf9f6cf3903f87345"+ }+ },+ {+ "name": "truncated-last-block",+ "value_b64": "T2JqAQQWYXZyby5zY2hlbWHwBnsidHlwZSI6InJlY29yZCIsIm5hbWUiOiJFZGdlIiwiZmllbGRzIjpbeyJuYW1lIjoicyIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdfSx7Im5hbWUiOiJsIiwidHlwZSI6WyJudWxsIiwibG9uZyJdfSx7Im5hbWUiOiJtIiwidHlwZSI6WyJudWxsIix7InR5cGUiOiJtYXAiLCJ2YWx1ZXMiOiJzdHJpbmcifV19LHsibmFtZSI6ImEiLCJ0eXBlIjp7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoiaW50In19LHsibmFtZSI6ImIiLCJ0eXBlIjoiYm9vbGVhbiJ9LHsibmFtZSI6ImQiLCJ0eXBlIjoiZG91YmxlIn0seyJuYW1lIjoiZiIsInR5cGUiOiJmbG9hdCJ9LHsibmFtZSI6ImUiLCJ0eXBlIjp7InR5cGUiOiJlbnVtIiwibmFtZSI6IkUiLCJzeW1ib2xzIjpbIkEiLCJCIl19fSx7Im5hbWUiOiJ4IiwidHlwZSI6eyJ0eXBlIjoiZml4ZWQiLCJuYW1lIjoiWCIsInNpemUiOjJ9fV19FGF2cm8uY29kZWMSenN0YW5kYXJkAAcHBwcHBwcHBwcHBwcHBwcEigEotS/9IGTlAQAUAwIKcm93IDACgMD6q63vlQYCBAIxBm9uZQJrAnYABgIDBgABmpm5PwAAwD8CAQIxAoIDAAAcVc1pAJ4HBwcHBwcHBwcHBwcHBwcHAnYotS/9IDKRAQACCnJvdyAyAoTA+qut75UGAgQCMQZvbmUCawJ2AAYCAwYAAZqZmZmZmbk/AADAPwIBAgcHBwcHBwcHBwcH",+ "result": {+ "codec": "zstandard",+ "count": 2,+ "sha256": "6c011e18e5695370e7a9d8e03739262294629edc01e0da21ae982b1e0af31f4b"+ }+ },+ {+ "name": "truncated-in-header",+ "value_b64": "T2JqAQQWYXZyby5zY2hlbWHwBnsidHlwZSI6InJl",+ "result": {+ "error": "No metadata found"+ }+ },+ {+ "name": "three-bytes",+ "value_b64": "T2Jq",+ "result": {+ "error": "No metadata found"+ }+ },+ {+ "name": "bad-sync-second-block",+ "value_b64": "T2JqAQQWYXZyby5zY2hlbWHwBnsidHlwZSI6InJlY29yZCIsIm5hbWUiOiJFZGdlIiwiZmllbGRzIjpbeyJuYW1lIjoicyIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdfSx7Im5hbWUiOiJsIiwidHlwZSI6WyJudWxsIiwibG9uZyJdfSx7Im5hbWUiOiJtIiwidHlwZSI6WyJudWxsIix7InR5cGUiOiJtYXAiLCJ2YWx1ZXMiOiJzdHJpbmcifV19LHsibmFtZSI6ImEiLCJ0eXBlIjp7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoiaW50In19LHsibmFtZSI6ImIiLCJ0eXBlIjoiYm9vbGVhbiJ9LHsibmFtZSI6ImQiLCJ0eXBlIjoiZG91YmxlIn0seyJuYW1lIjoiZiIsInR5cGUiOiJmbG9hdCJ9LHsibmFtZSI6ImUiLCJ0eXBlIjp7InR5cGUiOiJlbnVtIiwibmFtZSI6IkUiLCJzeW1ib2xzIjpbIkEiLCJCIl19fSx7Im5hbWUiOiJ4IiwidHlwZSI6eyJ0eXBlIjoiZml4ZWQiLCJuYW1lIjoiWCIsInNpemUiOjJ9fV19FGF2cm8uY29kZWMSenN0YW5kYXJkAAcHBwcHBwcHBwcHBwcHBwcEigEotS/9IGTlAQAUAwIKcm93IDACgMD6q63vlQYCBAIxBm9uZQJrAnYABgIDBgABmpm5PwAAwD8CAQIxAoIDAAAcVc1pAJ4HBwcHBwcHBwcHBwcHBwcHAnYotS/9IDKRAQACCnJvdyAyAoTA+qut75UGAgQCMQZvbmUCawJ2AAYCAwYAAZqZmZmZmbk/AADAPwIBAgkJCQkJCQkJCQkJCQkJCQk=",+ "result": {+ "error": "invalid sync marker"+ }+ },+ {+ "name": "bad-zstd",+ "value_b64": "T2JqAQQWYXZyby5zY2hlbWHwBnsidHlwZSI6InJlY29yZCIsIm5hbWUiOiJFZGdlIiwiZmllbGRzIjpbeyJuYW1lIjoicyIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdfSx7Im5hbWUiOiJsIiwidHlwZSI6WyJudWxsIiwibG9uZyJdfSx7Im5hbWUiOiJtIiwidHlwZSI6WyJudWxsIix7InR5cGUiOiJtYXAiLCJ2YWx1ZXMiOiJzdHJpbmcifV19LHsibmFtZSI6ImEiLCJ0eXBlIjp7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoiaW50In19LHsibmFtZSI6ImIiLCJ0eXBlIjoiYm9vbGVhbiJ9LHsibmFtZSI6ImQiLCJ0eXBlIjoiZG91YmxlIn0seyJuYW1lIjoiZiIsInR5cGUiOiJmbG9hdCJ9LHsibmFtZSI6ImUiLCJ0eXBlIjp7InR5cGUiOiJlbnVtIiwibmFtZSI6IkUiLCJzeW1ib2xzIjpbIkEiLCJCIl19fSx7Im5hbWUiOiJ4IiwidHlwZSI6eyJ0eXBlIjoiZml4ZWQiLCJuYW1lIjoiWCIsInNpemUiOjJ9fV19FGF2cm8uY29kZWMSenN0YW5kYXJkAAcHBwcHBwcHBwcHBwcHBwcCHm5vdCB6c3RkIGF0IGFsbAcHBwcHBwcHBwcHBwcHBwc=",+ "result": {+ "error": "zstandard codec decompression error"+ }+ },+ {+ "name": "count-past-data",+ "value_b64": "T2JqAQQWYXZyby5zY2hlbWHwBnsidHlwZSI6InJlY29yZCIsIm5hbWUiOiJFZGdlIiwiZmllbGRzIjpbeyJuYW1lIjoicyIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdfSx7Im5hbWUiOiJsIiwidHlwZSI6WyJudWxsIiwibG9uZyJdfSx7Im5hbWUiOiJtIiwidHlwZSI6WyJudWxsIix7InR5cGUiOiJtYXAiLCJ2YWx1ZXMiOiJzdHJpbmcifV19LHsibmFtZSI6ImEiLCJ0eXBlIjp7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoiaW50In19LHsibmFtZSI6ImIiLCJ0eXBlIjoiYm9vbGVhbiJ9LHsibmFtZSI6ImQiLCJ0eXBlIjoiZG91YmxlIn0seyJuYW1lIjoiZiIsInR5cGUiOiJmbG9hdCJ9LHsibmFtZSI6ImUiLCJ0eXBlIjp7InR5cGUiOiJlbnVtIiwibmFtZSI6IkUiLCJzeW1ib2xzIjpbIkEiLCJCIl19fSx7Im5hbWUiOiJ4IiwidHlwZSI6eyJ0eXBlIjoiZml4ZWQiLCJuYW1lIjoiWCIsInNpemUiOjJ9fV19FGF2cm8uY29kZWMSenN0YW5kYXJkAAcHBwcHBwcHBwcHBwcHBwcGigEotS/9IGTlAQAUAwIKcm93IDACgMD6q63vlQYCBAIxBm9uZQJrAnYABgIDBgABmpm5PwAAwD8CAQIxAoIDAAAcVc1pAJ4HBwcHBwcHBwcHBwcHBwcH",+ "result": {+ "error": "truncated block"+ }+ },+ {+ "name": "count-below-data",+ "value_b64": "T2JqAQQWYXZyby5zY2hlbWHwBnsidHlwZSI6InJlY29yZCIsIm5hbWUiOiJFZGdlIiwiZmllbGRzIjpbeyJuYW1lIjoicyIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdfSx7Im5hbWUiOiJsIiwidHlwZSI6WyJudWxsIiwibG9uZyJdfSx7Im5hbWUiOiJtIiwidHlwZSI6WyJudWxsIix7InR5cGUiOiJtYXAiLCJ2YWx1ZXMiOiJzdHJpbmcifV19LHsibmFtZSI6ImEiLCJ0eXBlIjp7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoiaW50In19LHsibmFtZSI6ImIiLCJ0eXBlIjoiYm9vbGVhbiJ9LHsibmFtZSI6ImQiLCJ0eXBlIjoiZG91YmxlIn0seyJuYW1lIjoiZiIsInR5cGUiOiJmbG9hdCJ9LHsibmFtZSI6ImUiLCJ0eXBlIjp7InR5cGUiOiJlbnVtIiwibmFtZSI6IkUiLCJzeW1ib2xzIjpbIkEiLCJCIl19fSx7Im5hbWUiOiJ4IiwidHlwZSI6eyJ0eXBlIjoiZml4ZWQiLCJuYW1lIjoiWCIsInNpemUiOjJ9fV19FGF2cm8uY29kZWMSenN0YW5kYXJkAAcHBwcHBwcHBwcHBwcHBwcCigEotS/9IGTlAQAUAwIKcm93IDACgMD6q63vlQYCBAIxBm9uZQJrAnYABgIDBgABmpm5PwAAwD8CAQIxAoIDAAAcVc1pAJ4HBwcHBwcHBwcHBwcHBwcH",+ "result": {+ "codec": "zstandard",+ "count": 1,+ "sha256": "ac281ff843940d1e06d5fd035ae41e901460bac3e30c506b5f32aa2679659541"+ }+ },+ {+ "name": "zero-count-block",+ "value_b64": "T2JqAQQWYXZyby5zY2hlbWHwBnsidHlwZSI6InJlY29yZCIsIm5hbWUiOiJFZGdlIiwiZmllbGRzIjpbeyJuYW1lIjoicyIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdfSx7Im5hbWUiOiJsIiwidHlwZSI6WyJudWxsIiwibG9uZyJdfSx7Im5hbWUiOiJtIiwidHlwZSI6WyJudWxsIix7InR5cGUiOiJtYXAiLCJ2YWx1ZXMiOiJzdHJpbmcifV19LHsibmFtZSI6ImEiLCJ0eXBlIjp7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoiaW50In19LHsibmFtZSI6ImIiLCJ0eXBlIjoiYm9vbGVhbiJ9LHsibmFtZSI6ImQiLCJ0eXBlIjoiZG91YmxlIn0seyJuYW1lIjoiZiIsInR5cGUiOiJmbG9hdCJ9LHsibmFtZSI6ImUiLCJ0eXBlIjp7InR5cGUiOiJlbnVtIiwibmFtZSI6IkUiLCJzeW1ib2xzIjpbIkEiLCJCIl19fSx7Im5hbWUiOiJ4IiwidHlwZSI6eyJ0eXBlIjoiZml4ZWQiLCJuYW1lIjoiWCIsInNpemUiOjJ9fV19FGF2cm8uY29kZWMSenN0YW5kYXJkAAcHBwcHBwcHBwcHBwcHBwcAigEotS/9IGTlAQAUAwIKcm93IDACgMD6q63vlQYCBAIxBm9uZQJrAnYABgIDBgABmpm5PwAAwD8CAQIxAoIDAAAcVc1pAJ4HBwcHBwcHBwcHBwcHBwcHAnYotS/9IDKRAQACCnJvdyAzAobA+qut75UGAgQCMQZvbmUCawJ2AAYCAwYAAZqZmZmZmbk/AADAPwIBAgcHBwcHBwcHBwcHBwcHBwc=",+ "result": {+ "codec": "zstandard",+ "count": 1,+ "sha256": "4b8ddd6560180f5bf625dfb4c236b4fcbc3ccb1d35147c8296356312136ce6bf"+ }+ },+ {+ "name": "bad-union-index",+ "value_b64": "T2JqAQQWYXZyby5zY2hlbWHwBnsidHlwZSI6InJlY29yZCIsIm5hbWUiOiJFZGdlIiwiZmllbGRzIjpbeyJuYW1lIjoicyIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdfSx7Im5hbWUiOiJsIiwidHlwZSI6WyJudWxsIiwibG9uZyJdfSx7Im5hbWUiOiJtIiwidHlwZSI6WyJudWxsIix7InR5cGUiOiJtYXAiLCJ2YWx1ZXMiOiJzdHJpbmcifV19LHsibmFtZSI6ImEiLCJ0eXBlIjp7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoiaW50In19LHsibmFtZSI6ImIiLCJ0eXBlIjoiYm9vbGVhbiJ9LHsibmFtZSI6ImQiLCJ0eXBlIjoiZG91YmxlIn0seyJuYW1lIjoiZiIsInR5cGUiOiJmbG9hdCJ9LHsibmFtZSI6ImUiLCJ0eXBlIjp7InR5cGUiOiJlbnVtIiwibmFtZSI6IkUiLCJzeW1ib2xzIjpbIkEiLCJCIl19fSx7Im5hbWUiOiJ4IiwidHlwZSI6eyJ0eXBlIjoiZml4ZWQiLCJuYW1lIjoiWCIsInNpemUiOjJ9fV19FGF2cm8uY29kZWMSenN0YW5kYXJkAAcHBwcHBwcHBwcHBwcHBwcCeCi1L/0gM5kBAAoCCnJvdyAwAoDA+qut75UGAgQCMQZvbmUCawJ2AAYCAwYAAZqZmZmZmbk/AADAPwIBAgcHBwcHBwcHBwcHBwcHBwc=",+ "result": {+ "error": "invalid union index: 5"+ }+ },+ {+ "name": "unsafe-long",+ "value_b64": "T2JqAQQWYXZyby5zY2hlbWHwBnsidHlwZSI6InJlY29yZCIsIm5hbWUiOiJFZGdlIiwiZmllbGRzIjpbeyJuYW1lIjoicyIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdfSx7Im5hbWUiOiJsIiwidHlwZSI6WyJudWxsIiwibG9uZyJdfSx7Im5hbWUiOiJtIiwidHlwZSI6WyJudWxsIix7InR5cGUiOiJtYXAiLCJ2YWx1ZXMiOiJzdHJpbmcifV19LHsibmFtZSI6ImEiLCJ0eXBlIjp7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoiaW50In19LHsibmFtZSI6ImIiLCJ0eXBlIjoiYm9vbGVhbiJ9LHsibmFtZSI6ImQiLCJ0eXBlIjoiZG91YmxlIn0seyJuYW1lIjoiZiIsInR5cGUiOiJmbG9hdCJ9LHsibmFtZSI6ImUiLCJ0eXBlIjp7InR5cGUiOiJlbnVtIiwibmFtZSI6IkUiLCJzeW1ib2xzIjpbIkEiLCJCIl19fSx7Im5hbWUiOiJ4IiwidHlwZSI6eyJ0eXBlIjoiZml4ZWQiLCJuYW1lIjoiWCIsInNpemUiOjJ9fV19FGF2cm8uY29kZWMSenN0YW5kYXJkAAcHBwcHBwcHBwcHBwcHBwcCdCi1L/0gMYkBAAACgICAgICAgIAgre+VBgIEAjEGb25lAmsCdgAGAgMGAAGamZmZmZm5PwAAwD8CAQIHBwcHBwcHBwcHBwcHBwcH",+ "result": {+ "error": "potential precision loss"+ }+ },+ {+ "name": "bad-enum-index",+ "value_b64": "T2JqAQQWYXZyby5zY2hlbWHMAXsidHlwZSI6InJlY29yZCIsIm5hbWUiOiJSIiwiZmllbGRzIjpbeyJuYW1lIjoiZSIsInR5cGUiOnsidHlwZSI6ImVudW0iLCJuYW1lIjoiRSIsInN5bWJvbHMiOlsiQSJdfX1dfRRhdnJvLmNvZGVjEnpzdGFuZGFyZAAHBwcHBwcHBwcHBwcHBwcHAhQotS/9IAEJAAAGBwcHBwcHBwcHBwcHBwcHBw==",+ "result": {+ "error": "invalid E enum index: 3"+ }+ },+ {+ "name": "invalid-utf8",+ "value_b64": "T2JqAQQWYXZyby5zY2hlbWGIAXsidHlwZSI6InJlY29yZCIsIm5hbWUiOiJVIiwiZmllbGRzIjpbeyJuYW1lIjoicyIsInR5cGUiOiJzdHJpbmcifV19FGF2cm8uY29kZWMSenN0YW5kYXJkAAcHBwcHBwcHBwcHBwcHBwcCICi1L/0gBzkAAAxh/+KCYu0HBwcHBwcHBwcHBwcHBwcH",+ "result": {+ "codec": "zstandard",+ "count": 1,+ "sha256": "15674230269a6470664dc93cbeedd0a17f280bea294311e1c7885f932958e532"+ }+ },+ {+ "name": "map-proto-and-dups",+ "value_b64": "T2JqAQQWYXZyby5zY2hlbWG4AXsidHlwZSI6InJlY29yZCIsIm5hbWUiOiJNIiwiZmllbGRzIjpbeyJuYW1lIjoibSIsInR5cGUiOnsidHlwZSI6Im1hcCIsInZhbHVlcyI6InN0cmluZyJ9fV19FGF2cm8uY29kZWMSenN0YW5kYXJkAAcHBwcHBwcHBwcHBwcHBwcCVii1L/0gIhEBAAXGARJfX3Byb3RvX18CcAZkdXACMQZkdXACMgIEMTACdAAHBwcHBwcHBwcHBwcHBwcH",+ "result": {+ "codec": "zstandard",+ "count": 1,+ "sha256": "3f89d54bfc659ff10c152191fd28434084a589bb4d1b3b390e2dab767835aa89"+ }+ },+ {+ "name": "trailing-garbage",+ "value_b64": "T2JqAQQWYXZyby5zY2hlbWHwBnsidHlwZSI6InJlY29yZCIsIm5hbWUiOiJFZGdlIiwiZmllbGRzIjpbeyJuYW1lIjoicyIsInR5cGUiOlsibnVsbCIsInN0cmluZyJdfSx7Im5hbWUiOiJsIiwidHlwZSI6WyJudWxsIiwibG9uZyJdfSx7Im5hbWUiOiJtIiwidHlwZSI6WyJudWxsIix7InR5cGUiOiJtYXAiLCJ2YWx1ZXMiOiJzdHJpbmcifV19LHsibmFtZSI6ImEiLCJ0eXBlIjp7InR5cGUiOiJhcnJheSIsIml0ZW1zIjoiaW50In19LHsibmFtZSI6ImIiLCJ0eXBlIjoiYm9vbGVhbiJ9LHsibmFtZSI6ImQiLCJ0eXBlIjoiZG91YmxlIn0seyJuYW1lIjoiZiIsInR5cGUiOiJmbG9hdCJ9LHsibmFtZSI6ImUiLCJ0eXBlIjp7InR5cGUiOiJlbnVtIiwibmFtZSI6IkUiLCJzeW1ib2xzIjpbIkEiLCJCIl19fSx7Im5hbWUiOiJ4IiwidHlwZSI6eyJ0eXBlIjoiZml4ZWQiLCJuYW1lIjoiWCIsInNpemUiOjJ9fV19FGF2cm8uY29kZWMSenN0YW5kYXJkAAcHBwcHBwcHBwcHBwcHBwcEigEotS/9IGTlAQAUAwIKcm93IDACgMD6q63vlQYCBAIxBm9uZQJrAnYABgIDBgABmpm5PwAAwD8CAQIxAoIDAAAcVc1pAJ4HBwcHBwcHBwcHBwcHBwcHAnYotS/9IDKRAQACCnJvdyAyAoTA+qut75UGAgQCMQZvbmUCawJ2AAYCAwYAAZqZmZmZmbk/AADAPwIBAgcHBwcHBwcHBwcHBwcHBwcBAgM=",+ "result": {+ "codec": "zstandard",+ "count": 3,+ "sha256": "945a96e0c019aa0e95ef774a082232d84e25a97b230eb02bf9f6cf3903f87345"+ }+ }+ ]+}diff --git a/rust/logs-ingestion/tests/fixtures/metric-rules-reference.json b/rust/logs-ingestion/tests/fixtures/metric-rules-reference.jsonnew file mode 100644index 000000000000..f9d85cf6d6f5--- /dev/null+++ b/rust/logs-ingestion/tests/fixtures/metric-rules-reference.json@@ -0,0 +1,1943 @@+{+ "compile_rows": [+ {+ "id": "a",+ "metric_name": "",+ "filter_group": null,+ "value_attribute": null,+ "group_by": []+ },+ {+ "id": "b",+ "metric_name": 5,+ "filter_group": null,+ "value_attribute": null,+ "group_by": []+ },+ {+ "id": "c",+ "filter_group": null,+ "value_attribute": null,+ "group_by": []+ },+ {+ "id": "d",+ "metric_name": "d",+ "source": "SPANS",+ "value_attribute": "",+ "group_by": [+ "severity_text",+ 1,+ "",+ null,+ "event_name"+ ]+ },+ {+ "id": "e",+ "metric_name": "e",+ "source": "spans",+ "value_attribute": "duration_ms",+ "group_by": [+ "kind",+ "name",+ "status_code",+ "service_name",+ "attributes.a",+ "attributes.b"+ ]+ },+ {+ "id": "f",+ "metric_name": "f",+ "source": "spans",+ "value_attribute": 7,+ "group_by": [+ "severity_text"+ ]+ },+ {+ "id": "g",+ "metric_name": "g",+ "value_attribute": "x",+ "group_by": [+ "name"+ ]+ },+ {+ "id": "h",+ "metric_name": "h",+ "value_attribute": "duration_ms",+ "group_by": []+ },+ {+ "id": "i",+ "metric_name": "i",+ "value_attribute": "attributes.\ud800",+ "group_by": [+ "resource_attributes.\udc00",+ "attributes."+ ]+ },+ {+ "id": "j",+ "metric_name": "j",+ "value_attribute": null,+ "group_by": "service_name"+ },+ {+ "id": "k",+ "metric_name": "k",+ "source": "spans",+ "value_attribute": null,+ "group_by": [+ "event_name"+ ]+ }+ ],+ "compile": [+ {+ "id": "d",+ "metric_name": "d",+ "source": "logs",+ "value_attribute": null,+ "group_by": [+ "severity_text",+ "event_name"+ ]+ },+ {+ "id": "e",+ "metric_name": "e",+ "source": "spans",+ "value_attribute": "duration_ms",+ "group_by": [+ "kind",+ "name",+ "status_code",+ "service_name",+ "attributes.a"+ ]+ },+ {+ "id": "i",+ "metric_name": "i",+ "source": "logs",+ "value_attribute": "attributes.\ud800",+ "group_by": [+ "resource_attributes.\udc00",+ "attributes."+ ]+ },+ {+ "id": "j",+ "metric_name": "j",+ "source": "logs",+ "value_attribute": null,+ "group_by": []+ }+ ],+ "hmac_key_hex": "0b30557a9fc4e90e33587da2c7ec11365b80a5caef14395e83a8cdf2173c6186",+ "labels": [+ {+ "attribute": "\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"",+ "length": 256,+ "label_key": "[\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"]"+ },+ {+ "attribute": "\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"",+ "length": 256,+ "label_key": "[\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"]"+ },+ {+ "attribute": "\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx🚀\"",+ "length": 256,+ "label_key": "[\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\\ud83d\"]"+ },+ {+ "attribute": "\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx🚀\"",+ "length": 256,+ "label_key": "[\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx🚀\"]"+ },+ {+ "attribute": "\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx🚀y\"",+ "length": 256,+ "label_key": "[\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx🚀\"]"+ },+ {+ "attribute": "\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"",+ "length": 256,+ "label_key": "[\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"]"+ },+ {+ "attribute": "\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"",+ "length": 256,+ "label_key": "[\"🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"]"+ },+ {+ "attribute": "\"a🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"",+ "length": 256,+ "label_key": "[\"a🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\\ud83d\"]"+ },+ {+ "attribute": "\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"",+ "length": 256,+ "label_key": "[\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"]"+ },+ {+ "attribute": "\"日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本\"",+ "length": 256,+ "label_key": "[\"日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本日本\"]"+ },+ {+ "attribute": "\"\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\"",+ "length": 256,+ "label_key": "[\"\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\\ud83d\"]"+ },+ {+ "attribute": "\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\\udc00z\"",+ "length": 256,+ "label_key": "[\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\\udc00\"]"+ },+ {+ "attribute": "raw-🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀",+ "length": 256,+ "label_key": "[\"raw-🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀\"]"+ }+ ],+ "id_to_hex": [+ {+ "input_hex": "0112233445566778899aabbccddeef00",+ "expected_bytes": 16,+ "output": "0112233445566778899aabbccddeef00"+ },+ {+ "input_hex": "fffefdfcfbfaf9f8",+ "expected_bytes": 8,+ "output": "fffefdfcfbfaf9f8"+ },+ {+ "input_hex": "00000000000000000000000000000000",+ "expected_bytes": 16,+ "output": null+ },+ {+ "input_hex": "",+ "expected_bytes": 16,+ "output": null+ },+ {+ "input_hex": "4152496a4e4556575a33694a6d7175387a64377641413d3d",+ "expected_bytes": 16,+ "output": "0112233445566778899aabbccddeef00"+ },+ {+ "input_hex": "4152496a4e4556575a33694a6d7175387a6437764141",+ "expected_bytes": 16,+ "output": "0112233445566778899aabbccddeef00"+ },+ {+ "input_hex": "2f2f37392f5076362b66673d",+ "expected_bytes": 8,+ "output": "fffefdfcfbfaf9f8"+ },+ {+ "input_hex": "5f5f37395f5076362d66673d",+ "expected_bytes": 8,+ "output": "fffefdfcfbfaf9f8"+ },+ {+ "input_hex": "204152496a4e4556575a330a2a694a6d7175387a64377641413d3d",+ "expected_bytes": 16,+ "output": "0112233445566778899aabbccddeef00"+ },+ {+ "input_hex": "4152496a4e4556573d5a33694a6d7175387a64377641413d3d",+ "expected_bytes": 16,+ "output": null+ },+ {+ "input_hex": "414141414141414141414141414141414141414141413d3d",+ "expected_bytes": 16,+ "output": null+ },+ {+ "input_hex": "4152496a4e4556575a33694a6d7175387a64377641413d3d41414141",+ "expected_bytes": 16,+ "output": "0112233445566778899aabbccddeef00"+ },+ {+ "input_hex": "c1d2c9eacec5d6d7dab3e9caedf1f5b8fae4b7f6c1c1bdbd",+ "expected_bytes": 16,+ "output": "0112233445566778899aabbccddeef00"+ },+ {+ "input_hex": "41514944424155474277674a4367734d44513450",+ "expected_bytes": 16,+ "output": null+ },+ {+ "input_hex": "6e6f742062617365363420617420616c6c2121",+ "expected_bytes": 16,+ "output": null+ },+ {+ "input_hex": "0112233445566778899aabbccddeef",+ "expected_bytes": 16,+ "output": null+ }+ ],+ "label_hashes": [+ {+ "label_key": "[]",+ "hash": 59966496679625+ },+ {+ "label_key": "[\"\"]",+ "hash": 273217511290766+ },+ {+ "label_key": "[\"api\",\"ERROR\"]",+ "hash": 253038246542535+ },+ {+ "label_key": "[\"\\ud83dx\"]",+ "hash": 88575327074555+ },+ {+ "label_key": "[\"🚀🚀🚀\"]",+ "hash": 92551814109060+ }+ ],+ "admission": [+ {+ "name": "per rule cap",+ "caps": [+ 2,+ 10,+ 100+ ],+ "calls": [+ [+ 1,+ "r",+ "[\"a\"]",+ 1736944633250+ ],+ [+ 1,+ "r",+ "[\"b\"]",+ 1736944633250+ ],+ [+ 1,+ "r",+ "[\"c\"]",+ 1736944633250+ ],+ [+ 1,+ "r",+ "[\"a\"]",+ 1736944633250+ ],+ [+ 1,+ "r2",+ "[\"c\"]",+ 1736944633250+ ],+ [+ 2,+ "r",+ "[\"c\"]",+ 1736944633250+ ]+ ],+ "results": [+ true,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "name": "per team cap survives other rules",+ "caps": [+ 10,+ 3,+ 100+ ],+ "calls": [+ [+ 1,+ "r1",+ "[\"a\"]",+ 1736944633250+ ],+ [+ 1,+ "r2",+ "[\"a\"]",+ 1736944633250+ ],+ [+ 1,+ "r3",+ "[\"a\"]",+ 1736944633250+ ],+ [+ 1,+ "r4",+ "[\"a\"]",+ 1736944633250+ ],+ [+ 1,+ "r1",+ "[\"a\"]",+ 1736944633250+ ],+ [+ 2,+ "r1",+ "[\"a\"]",+ 1736944633250+ ]+ ],+ "results": [+ true,+ true,+ true,+ false,+ true,+ true+ ]+ },+ {+ "name": "total cap",+ "caps": [+ 10,+ 10,+ 2+ ],+ "calls": [+ [+ 1,+ "r",+ "[\"a\"]",+ 1736944633250+ ],+ [+ 2,+ "r",+ "[\"a\"]",+ 1736944633250+ ],+ [+ 3,+ "r",+ "[\"a\"]",+ 1736944633250+ ],+ [+ 1,+ "r",+ "[\"a\"]",+ 1736944633250+ ]+ ],+ "results": [+ true,+ true,+ false,+ true+ ]+ },+ {+ "name": "window rollover",+ "caps": [+ 1,+ 1,+ 1+ ],+ "calls": [+ [+ 1,+ "r",+ "[\"a\"]",+ 1736945999999+ ],+ [+ 1,+ "r",+ "[\"b\"]",+ 1736945999999+ ],+ [+ 1,+ "r",+ "[\"b\"]",+ 1736946000000+ ],+ [+ 1,+ "r",+ "[\"a\"]",+ 1736946000001+ ],+ [+ 1,+ "r",+ "[\"a\"]",+ 1736942400001.5+ ],+ [+ 1,+ "r",+ "[\"a\"]",+ 1736942400002+ ],+ [+ 1,+ "r",+ "[\"b\"]",+ 1736949600000.25+ ]+ ],+ "results": [+ true,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "name": "team and rule ids share a key space",+ "caps": [+ 1,+ 10,+ 100+ ],+ "calls": [+ [+ 1,+ "2:r",+ "[\"a\"]",+ 1736944633250+ ],+ [+ 12,+ "r",+ "[\"a\"]",+ 1736944633250+ ],+ [+ 1,+ "2:r",+ "[\"b\"]",+ 1736944633250+ ]+ ],+ "results": [+ true,+ true,+ false+ ]+ }+ ],+ "payloads": [+ {+ "rows": [+ {+ "id": "d",+ "metric_name": "span.ms",+ "source": "spans",+ "filter_group": null,+ "value_attribute": "duration_ms",+ "group_by": [+ "service_name",+ "kind",+ "name",+ "status_code"+ ]+ },+ {+ "id": "h",+ "metric_name": "span.attr",+ "source": "spans",+ "filter_group": null,+ "value_attribute": "attributes.ms",+ "group_by": [+ "resource_attributes.k8s.pod.name",+ "attributes.http.method"+ ]+ },+ {+ "id": "c",+ "metric_name": "span.count",+ "source": "spans",+ "filter_group": null,+ "value_attribute": null,+ "group_by": []+ }+ ],+ "defaults": null,+ "now_ms": 1736944633250,+ "records": [+ {+ "uuid": "s0",+ "trace_id": null,+ "span_id": null,+ "timestamp": 1736944633250000,+ "end_time": 1736944633251500,+ "name": "GET /a",+ "kind": 1,+ "status_code": 0,+ "service_name": "api",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-0\""+ },+ "attributes": {+ "ms": "12.5",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s1",+ "trace_id": {+ "$bytes": "1f202122232425262728292a2b2c2d2e"+ },+ "span_id": {+ "$bytes": "0102030405060708"+ },+ "timestamp": 1736944632250000,+ "end_time": 1736944632250000,+ "name": "db.query",+ "kind": 2,+ "status_code": 1,+ "service_name": "worker",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-1\""+ },+ "attributes": {+ "ms": "\" 3e2ms\"",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s2",+ "trace_id": {+ "$bytes": "3e3f404142434445464748494a4b4c4d"+ },+ "span_id": null,+ "timestamp": 1736944631250000,+ "end_time": 1736944638500125,+ "name": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",+ "kind": 3,+ "status_code": 2,+ "service_name": null,+ "resource_attributes": {+ "k8s.pod.name": "\"pod-0\""+ },+ "attributes": {+ "ms": "\"x\"",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s3",+ "trace_id": null,+ "span_id": {+ "$bytes": "030405060708090a"+ },+ "timestamp": 1736944630250000,+ "end_time": 1736944630250250,+ "name": "",+ "kind": 9,+ "status_code": 7,+ "service_name": "api",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-1\""+ },+ "attributes": {+ "ms": "-4",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s4",+ "trace_id": {+ "$bytes": "7c7d7e7f808182838485868788898a8b"+ },+ "span_id": null,+ "timestamp": 1736944629250000,+ "end_time": 1736956629250001,+ "name": "GET /a",+ "kind": null,+ "status_code": null,+ "service_name": "worker",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-0\""+ },+ "attributes": {+ "ms": "\"Infinity\"",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s5",+ "trace_id": {+ "$bytes": "9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aa"+ },+ "span_id": {+ "$bytes": "05060708090a0b0c"+ },+ "timestamp": 1736944628250000,+ "end_time": 1736944628251500,+ "name": "db.query",+ "kind": 1,+ "status_code": 0,+ "service_name": null,+ "resource_attributes": {+ "k8s.pod.name": "\"pod-1\""+ },+ "attributes": {+ "ms": "0.1",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s6",+ "trace_id": null,+ "span_id": null,+ "timestamp": 1736944627250000,+ "end_time": 1736944627250000,+ "name": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",+ "kind": 2,+ "status_code": 1,+ "service_name": "api",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-0\""+ },+ "attributes": {+ "ms": "\"1e400\"",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s7",+ "trace_id": {+ "$bytes": "d9dadbdcdddedfe0e1e2e3e4e5e6e7e8"+ },+ "span_id": {+ "$bytes": "0708090a0b0c0d0e"+ },+ "timestamp": 1736944626250000,+ "end_time": 1736944633500125,+ "name": "",+ "kind": 3,+ "status_code": 2,+ "service_name": "worker",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-1\""+ },+ "attributes": {+ "ms": "12.5",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s8",+ "trace_id": {+ "$bytes": "f8f9fafbfcfdfeff0001020304050607"+ },+ "span_id": null,+ "timestamp": 1736944625250000,+ "end_time": 1736944625250250,+ "name": "GET /a",+ "kind": 9,+ "status_code": 7,+ "service_name": null,+ "resource_attributes": {+ "k8s.pod.name": "\"pod-0\""+ },+ "attributes": {+ "ms": "\" 3e2ms\"",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s9",+ "trace_id": null,+ "span_id": {+ "$bytes": "090a0b0c0d0e0f10"+ },+ "timestamp": 1736944624250000,+ "end_time": 1736956624250001,+ "name": "db.query",+ "kind": null,+ "status_code": null,+ "service_name": "api",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-1\""+ },+ "attributes": {+ "ms": "\"x\"",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s10",+ "trace_id": {+ "$bytes": "363738393a3b3c3d3e3f404142434445"+ },+ "span_id": null,+ "timestamp": 1736944623250000,+ "end_time": 1736944623251500,+ "name": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",+ "kind": 1,+ "status_code": 0,+ "service_name": "worker",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-0\""+ },+ "attributes": {+ "ms": "-4",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s11",+ "trace_id": {+ "$bytes": "55565758595a5b5c5d5e5f6061626364"+ },+ "span_id": {+ "$bytes": "0b0c0d0e0f101112"+ },+ "timestamp": 1736944622250000,+ "end_time": 1736944622250000,+ "name": "",+ "kind": 2,+ "status_code": 1,+ "service_name": null,+ "resource_attributes": {+ "k8s.pod.name": "\"pod-1\""+ },+ "attributes": {+ "ms": "\"Infinity\"",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s12",+ "trace_id": null,+ "span_id": null,+ "timestamp": 1736944621250000,+ "end_time": 1736944628500125,+ "name": "GET /a",+ "kind": 3,+ "status_code": 2,+ "service_name": "api",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-0\""+ },+ "attributes": {+ "ms": "0.1",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s13",+ "trace_id": {+ "$bytes": "939495969798999a9b9c9d9e9fa0a1a2"+ },+ "span_id": {+ "$bytes": "0d0e0f1011121314"+ },+ "timestamp": 1736944620250000,+ "end_time": 1736944620250250,+ "name": "db.query",+ "kind": 9,+ "status_code": 7,+ "service_name": "worker",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-1\""+ },+ "attributes": {+ "ms": "\"1e400\"",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s14",+ "trace_id": {+ "$bytes": "b2b3b4b5b6b7b8b9babbbcbdbebfc0c1"+ },+ "span_id": null,+ "timestamp": 1736944619250000,+ "end_time": 1736956619250001,+ "name": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",+ "kind": null,+ "status_code": null,+ "service_name": null,+ "resource_attributes": {+ "k8s.pod.name": "\"pod-0\""+ },+ "attributes": {+ "ms": "12.5",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s15",+ "trace_id": null,+ "span_id": {+ "$bytes": "0f10111213141516"+ },+ "timestamp": 1736944618250000,+ "end_time": 1736944618251500,+ "name": "",+ "kind": 1,+ "status_code": 0,+ "service_name": "api",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-1\""+ },+ "attributes": {+ "ms": "\" 3e2ms\"",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s16",+ "trace_id": {+ "$bytes": "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"+ },+ "span_id": null,+ "timestamp": 1736944617250000,+ "end_time": 1736944617250000,+ "name": "GET /a",+ "kind": 2,+ "status_code": 1,+ "service_name": "worker",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-0\""+ },+ "attributes": {+ "ms": "\"x\"",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s17",+ "trace_id": {+ "$bytes": "0f101112131415161718191a1b1c1d1e"+ },+ "span_id": {+ "$bytes": "1112131415161718"+ },+ "timestamp": 1736944616250000,+ "end_time": 1736944623500125,+ "name": "db.query",+ "kind": 3,+ "status_code": 2,+ "service_name": null,+ "resource_attributes": {+ "k8s.pod.name": "\"pod-1\""+ },+ "attributes": {+ "ms": "-4",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s18",+ "trace_id": null,+ "span_id": null,+ "timestamp": 1736944615250000,+ "end_time": 1736944615250250,+ "name": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",+ "kind": 9,+ "status_code": 7,+ "service_name": "api",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-0\""+ },+ "attributes": {+ "ms": "\"Infinity\"",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s19",+ "trace_id": {+ "$bytes": "4d4e4f505152535455565758595a5b5c"+ },+ "span_id": {+ "$bytes": "131415161718191a"+ },+ "timestamp": 1736944614250000,+ "end_time": 1736956614250001,+ "name": "",+ "kind": null,+ "status_code": null,+ "service_name": "worker",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-1\""+ },+ "attributes": {+ "ms": "0.1",+ "http.method": "\"GET\""+ }+ }+ ],+ "payload_json": "{\"resourceMetrics\":[{\"resource\":{\"attributes\":[{\"key\":\"service.name\",\"value\":{\"stringValue\":\"api\"}}]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"span.ms\",\"unit\":\"ms\",\"histogram\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"INTERNAL\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"GET /a\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"UNSET\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"count\":1,\"sum\":1.5,\"bucketCounts\":[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"9\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"7\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"count\":1,\"sum\":0.25,\"bucketCounts\":[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"SERVER\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"OK\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"count\":1,\"sum\":0,\"bucketCounts\":[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"db.query\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"count\":1,\"sum\":12000000.001,\"bucketCounts\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"CLIENT\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"GET /a\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"ERROR\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"count\":1,\"sum\":7250.125,\"bucketCounts\":[0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"INTERNAL\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"UNSET\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"count\":1,\"sum\":1.5,\"bucketCounts\":[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"9\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"7\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"count\":1,\"sum\":0.25,\"bucketCounts\":[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]}],\"aggregationTemporality\":1}}]}]},{\"resource\":{\"attributes\":[{\"key\":\"service.name\",\"value\":{\"stringValue\":\"worker\"}}]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"span.ms\",\"unit\":\"ms\",\"histogram\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"SERVER\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"db.query\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"OK\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":0,\"traceId\":\"1f202122232425262728292a2b2c2d2e\",\"spanId\":\"0102030405060708\"}],\"count\":1,\"sum\":0,\"bucketCounts\":[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"GET /a\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":12000000.001,\"traceId\":\"7c7d7e7f808182838485868788898a8b\"}],\"count\":1,\"sum\":12000000.001,\"bucketCounts\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"CLIENT\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"ERROR\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":7250.125,\"traceId\":\"d9dadbdcdddedfe0e1e2e3e4e5e6e7e8\",\"spanId\":\"0708090a0b0c0d0e\"}],\"count\":1,\"sum\":7250.125,\"bucketCounts\":[0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"INTERNAL\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"UNSET\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1.5,\"traceId\":\"363738393a3b3c3d3e3f404142434445\"}],\"count\":1,\"sum\":1.5,\"bucketCounts\":[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"9\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"db.query\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"7\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":0.25,\"traceId\":\"939495969798999a9b9c9d9e9fa0a1a2\",\"spanId\":\"0d0e0f1011121314\"}],\"count\":1,\"sum\":0.25,\"bucketCounts\":[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"SERVER\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"GET /a\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"OK\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":0,\"traceId\":\"f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\"}],\"count\":1,\"sum\":0,\"bucketCounts\":[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":12000000.001,\"traceId\":\"4d4e4f505152535455565758595a5b5c\",\"spanId\":\"131415161718191a\"}],\"count\":1,\"sum\":12000000.001,\"bucketCounts\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]}],\"aggregationTemporality\":1}}]}]},{\"resource\":{\"attributes\":[]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"span.ms\",\"unit\":\"ms\",\"histogram\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"CLIENT\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"ERROR\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":7250.125,\"traceId\":\"3e3f404142434445464748494a4b4c4d\"}],\"count\":1,\"sum\":7250.125,\"bucketCounts\":[0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"INTERNAL\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"db.query\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"UNSET\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1.5,\"traceId\":\"9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aa\",\"spanId\":\"05060708090a0b0c\"}],\"count\":1,\"sum\":1.5,\"bucketCounts\":[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"9\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"GET /a\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"7\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":0.25,\"traceId\":\"f8f9fafbfcfdfeff0001020304050607\"}],\"count\":1,\"sum\":0.25,\"bucketCounts\":[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"SERVER\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"OK\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":0,\"traceId\":\"55565758595a5b5c5d5e5f6061626364\",\"spanId\":\"0b0c0d0e0f101112\"}],\"count\":1,\"sum\":0,\"bucketCounts\":[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":12000000.001,\"traceId\":\"b2b3b4b5b6b7b8b9babbbcbdbebfc0c1\"}],\"count\":1,\"sum\":12000000.001,\"bucketCounts\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"CLIENT\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"db.query\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"ERROR\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":7250.125,\"traceId\":\"0f101112131415161718191a1b1c1d1e\",\"spanId\":\"1112131415161718\"}],\"count\":1,\"sum\":7250.125,\"bucketCounts\":[0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]}],\"aggregationTemporality\":1}},{\"name\":\"span.attr\",\"histogram\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"k8s.pod.name\",\"value\":{\"stringValue\":\"pod-0\"}},{\"key\":\"http.method\",\"value\":{\"stringValue\":\"GET\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":321.1,\"traceId\":\"f8f9fafbfcfdfeff0001020304050607\"}],\"count\":5,\"sum\":321.1,\"bucketCounts\":[1,1,0,2,0,0,0,0,1,0,0,0,0,0,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"k8s.pod.name\",\"value\":{\"stringValue\":\"pod-1\"}},{\"key\":\"http.method\",\"value\":{\"stringValue\":\"GET\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":604.7,\"traceId\":\"1f202122232425262728292a2b2c2d2e\",\"spanId\":\"0102030405060708\"}],\"count\":7,\"sum\":604.7,\"bucketCounts\":[2,2,0,1,0,0,0,0,2,0,0,0,0,0,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]}],\"aggregationTemporality\":1}},{\"name\":\"span.count\",\"sum\":{\"dataPoints\":[{\"attributes\":[],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":20,\"traceId\":\"1f202122232425262728292a2b2c2d2e\",\"spanId\":\"0102030405060708\"}],\"asDouble\":20}],\"aggregationTemporality\":1,\"isMonotonic\":true}}]}]}]}",+ "value_skipped": 8,+ "eval_errors": 0,+ "series_overflow": {},+ "threw": null+ },+ {+ "rows": [+ {+ "id": "u",+ "metric_name": "by.user",+ "filter_group": null,+ "value_attribute": null,+ "group_by": [+ "service_name",+ "attributes.user",+ "severity_text"+ ]+ },+ {+ "id": "v",+ "metric_name": "posthog.log.records",+ "filter_group": null,+ "value_attribute": "attributes.ms",+ "group_by": [+ "attributes.user"+ ]+ },+ {+ "id": "u",+ "metric_name": "same.id",+ "filter_group": null,+ "value_attribute": null,+ "group_by": [+ "event_name"+ ]+ }+ ],+ "defaults": "logs",+ "now_ms": 1736944633250,+ "records": [+ {+ "uuid": "l0",+ "trace_id": null,+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": null,+ "service_name": "api",+ "severity_text": "INFO",+ "event_name": null,+ "attributes": {+ "ms": "0",+ "user": "\"deny\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l1",+ "trace_id": {+ "$bytes": "4152496a4e4556575a33694a6d7175387a64377641413d3d"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736944573250000,+ "service_name": "web",+ "severity_text": "ERROR",+ "event_name": null,+ "attributes": {+ "ms": "997.5",+ "user": "\"u1\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l2",+ "trace_id": {+ "$bytes": "00000000000000000000000000000000"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736943373250000,+ "service_name": "api",+ "severity_text": null,+ "event_name": null,+ "attributes": {+ "ms": "1995",+ "user": "\"u2\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l3",+ "trace_id": null,+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": null,+ "service_name": "web",+ "severity_text": "INFO",+ "event_name": null,+ "attributes": {+ "ms": "2992.5",+ "user": "\"u3\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l4",+ "trace_id": {+ "$bytes": "4152496a4e4556575a33694a6d7175387a64377641413d3d"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736944573250000,+ "service_name": "api",+ "severity_text": "ERROR",+ "event_name": null,+ "attributes": {+ "ms": "3990",+ "user": "\"deny\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l5",+ "trace_id": {+ "$bytes": "00000000000000000000000000000000"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736943373250000,+ "service_name": "web",+ "severity_text": null,+ "event_name": null,+ "attributes": {+ "ms": "4987.5",+ "user": "\"u0\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l6",+ "trace_id": null,+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": null,+ "service_name": "api",+ "severity_text": "INFO",+ "event_name": null,+ "attributes": {+ "ms": "5985",+ "user": "\"u1\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l7",+ "trace_id": {+ "$bytes": "4152496a4e4556575a33694a6d7175387a64377641413d3d"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736944573250000,+ "service_name": "web",+ "severity_text": "ERROR",+ "event_name": null,+ "attributes": {+ "ms": "6982.5",+ "user": "\"u2\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l8",+ "trace_id": {+ "$bytes": "00000000000000000000000000000000"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736943373250000,+ "service_name": "api",+ "severity_text": null,+ "event_name": null,+ "attributes": {+ "ms": "7980",+ "user": "\"deny\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l9",+ "trace_id": null,+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": null,+ "service_name": "web",+ "severity_text": "INFO",+ "event_name": null,+ "attributes": {+ "ms": "8977.5",+ "user": "\"u4\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l10",+ "trace_id": {+ "$bytes": "4152496a4e4556575a33694a6d7175387a64377641413d3d"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736944573250000,+ "service_name": "api",+ "severity_text": "ERROR",+ "event_name": null,+ "attributes": {+ "ms": "9975",+ "user": "\"u0\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l11",+ "trace_id": {+ "$bytes": "00000000000000000000000000000000"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736943373250000,+ "service_name": "web",+ "severity_text": null,+ "event_name": null,+ "attributes": {+ "ms": "10972.5",+ "user": "\"u1\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l12",+ "trace_id": null,+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": null,+ "service_name": "api",+ "severity_text": "INFO",+ "event_name": null,+ "attributes": {+ "ms": "11970",+ "user": "\"deny\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l13",+ "trace_id": {+ "$bytes": "4152496a4e4556575a33694a6d7175387a64377641413d3d"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736944573250000,+ "service_name": "web",+ "severity_text": "ERROR",+ "event_name": null,+ "attributes": {+ "ms": "12967.5",+ "user": "\"u3\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l14",+ "trace_id": {+ "$bytes": "00000000000000000000000000000000"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736943373250000,+ "service_name": "api",+ "severity_text": null,+ "event_name": null,+ "attributes": {+ "ms": "13965",+ "user": "\"u4\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l15",+ "trace_id": null,+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": null,+ "service_name": "web",+ "severity_text": "INFO",+ "event_name": null,+ "attributes": {+ "ms": "14962.5",+ "user": "\"u0\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l16",+ "trace_id": {+ "$bytes": "4152496a4e4556575a33694a6d7175387a64377641413d3d"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736944573250000,+ "service_name": "api",+ "severity_text": "ERROR",+ "event_name": null,+ "attributes": {+ "ms": "15960",+ "user": "\"deny\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l17",+ "trace_id": {+ "$bytes": "00000000000000000000000000000000"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736943373250000,+ "service_name": "web",+ "severity_text": null,+ "event_name": null,+ "attributes": {+ "ms": "16957.5",+ "user": "\"u2\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l18",+ "trace_id": null,+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": null,+ "service_name": "api",+ "severity_text": "INFO",+ "event_name": null,+ "attributes": {+ "ms": "17955",+ "user": "\"u3\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l19",+ "trace_id": {+ "$bytes": "4152496a4e4556575a33694a6d7175387a64377641413d3d"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736944573250000,+ "service_name": "web",+ "severity_text": "ERROR",+ "event_name": null,+ "attributes": {+ "ms": "18952.5",+ "user": "\"u4\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l20",+ "trace_id": {+ "$bytes": "00000000000000000000000000000000"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736943373250000,+ "service_name": "api",+ "severity_text": null,+ "event_name": null,+ "attributes": {+ "ms": "19950",+ "user": "\"deny\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l21",+ "trace_id": null,+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": null,+ "service_name": "web",+ "severity_text": "INFO",+ "event_name": null,+ "attributes": {+ "ms": "20947.5",+ "user": "\"u1\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l22",+ "trace_id": {+ "$bytes": "4152496a4e4556575a33694a6d7175387a64377641413d3d"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736944573250000,+ "service_name": "api",+ "severity_text": "ERROR",+ "event_name": null,+ "attributes": {+ "ms": "21945",+ "user": "\"u2\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l23",+ "trace_id": {+ "$bytes": "00000000000000000000000000000000"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736943373250000,+ "service_name": "web",+ "severity_text": null,+ "event_name": null,+ "attributes": {+ "ms": "22942.5",+ "user": "\"u3\""+ },+ "resource_attributes": null+ }+ ],+ "payload_json": "{\"resourceMetrics\":[{\"resource\":{\"attributes\":[]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"by.user\",\"sum\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"otel.metric.overflow\",\"value\":{\"boolValue\":true}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":4,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"asDouble\":4},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":16,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"asDouble\":16},{\"attributes\":[{\"key\":\"otel.metric.overflow\",\"value\":{\"boolValue\":true}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":4,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"asDouble\":4},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":16,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"asDouble\":16},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u1\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"ERROR\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u3\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"INFO\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u1\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"INFO\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u2\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"ERROR\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u4\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"INFO\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u0\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"ERROR\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u3\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"ERROR\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u0\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"INFO\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u3\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"INFO\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u4\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"ERROR\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u1\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"INFO\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u2\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"ERROR\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"asDouble\":1}],\"aggregationTemporality\":1,\"isMonotonic\":true}},{\"name\":\"posthog.log.records\",\"histogram\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"otel.metric.overflow\",\"value\":{\"boolValue\":true}},{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":31920,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"count\":4,\"sum\":31920,\"bucketCounts\":[1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,2],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"user\",\"value\":{\"stringValue\":\"u1\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":27930,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"count\":3,\"sum\":27930,\"bucketCounts\":[0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"user\",\"value\":{\"stringValue\":\"u3\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":33915,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"count\":3,\"sum\":33915,\"bucketCounts\":[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,2],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"user\",\"value\":{\"stringValue\":\"u2\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":28927.5,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"count\":2,\"sum\":28927.5,\"bucketCounts\":[0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"user\",\"value\":{\"stringValue\":\"u4\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":27930,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"count\":2,\"sum\":27930,\"bucketCounts\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"user\",\"value\":{\"stringValue\":\"u0\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":24937.5,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"count\":2,\"sum\":24937.5,\"bucketCounts\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]}],\"aggregationTemporality\":1}}]}]},{\"resource\":{\"attributes\":[{\"key\":\"service.name\",\"value\":{\"stringValue\":\"web\"}}]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"by.user\",\"sum\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u1\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"ERROR\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u3\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"INFO\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u2\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"ERROR\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u4\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"INFO\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u3\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"ERROR\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u0\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"INFO\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u4\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"ERROR\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u1\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"INFO\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1}],\"aggregationTemporality\":1,\"isMonotonic\":true}}]}]},{\"resource\":{\"attributes\":[{\"key\":\"service.name\",\"value\":{\"stringValue\":\"api\"}}]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"by.user\",\"sum\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u1\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"INFO\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u0\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"ERROR\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u3\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"INFO\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1},{\"attributes\":[{\"key\":\"user\",\"value\":{\"stringValue\":\"u2\"}},{\"key\":\"severity_text\",\"value\":{\"stringValue\":\"ERROR\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"asDouble\":1}],\"aggregationTemporality\":1,\"isMonotonic\":true}}]}]}]}",+ "value_skipped": 0,+ "eval_errors": 0,+ "series_overflow": {+ "u": 4,+ "v": 4+ },+ "threw": null+ },+ {+ "rows": [+ {+ "id": "n",+ "metric_name": "none",+ "filter_group": null,+ "value_attribute": "attributes.missing",+ "group_by": []+ }+ ],+ "defaults": null,+ "now_ms": 1736944633250,+ "records": [+ {+ "uuid": "l0",+ "trace_id": null,+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": null,+ "service_name": "api",+ "severity_text": "INFO",+ "event_name": null,+ "attributes": {+ "ms": "0",+ "user": "\"deny\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l1",+ "trace_id": {+ "$bytes": "4152496a4e4556575a33694a6d7175387a64377641413d3d"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736944573250000,+ "service_name": "web",+ "severity_text": "ERROR",+ "event_name": null,+ "attributes": {+ "ms": "997.5",+ "user": "\"u1\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l2",+ "trace_id": {+ "$bytes": "00000000000000000000000000000000"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736943373250000,+ "service_name": "api",+ "severity_text": null,+ "event_name": null,+ "attributes": {+ "ms": "1995",+ "user": "\"u2\""+ },+ "resource_attributes": null+ }+ ],+ "payload_json": null,+ "value_skipped": 2,+ "eval_errors": 0,+ "series_overflow": {},+ "threw": null+ },+ {+ "rows": [+ {+ "id": "p",+ "metric_name": "proto",+ "filter_group": null,+ "value_attribute": "attributes.valueOf",+ "group_by": []+ },+ {+ "id": "q",+ "metric_name": "proto.labels",+ "filter_group": null,+ "value_attribute": null,+ "group_by": [+ "attributes.constructor",+ "attributes.__proto__",+ "attributes.toString",+ "resource_attributes.__proto__"+ ]+ }+ ],+ "defaults": null,+ "now_ms": 1736944633250,+ "records": [+ {+ "uuid": "l0",+ "trace_id": null,+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": null,+ "service_name": "api",+ "severity_text": "INFO",+ "event_name": null,+ "attributes": {+ "ms": "0",+ "user": "\"deny\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l1",+ "trace_id": {+ "$bytes": "4152496a4e4556575a33694a6d7175387a64377641413d3d"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736944573250000,+ "service_name": "web",+ "severity_text": "ERROR",+ "event_name": null,+ "attributes": {+ "ms": "997.5",+ "user": "\"u1\""+ },+ "resource_attributes": {+ "a": "\"b\""+ }+ },+ {+ "uuid": "l2",+ "trace_id": {+ "$bytes": "00000000000000000000000000000000"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736943373250000,+ "service_name": "api",+ "severity_text": null,+ "event_name": null,+ "attributes": {+ "ms": "1995",+ "user": "\"u2\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l3",+ "trace_id": null,+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": null,+ "service_name": "web",+ "severity_text": "INFO",+ "event_name": null,+ "attributes": {+ "ms": "2992.5",+ "user": "\"u3\""+ },+ "resource_attributes": {+ "a": "\"b\""+ }+ }+ ],+ "payload_json": "{\"resourceMetrics\":[{\"resource\":{\"attributes\":[]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"proto.labels\",\"sum\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"constructor\",\"value\":{}},{\"key\":\"__proto__\",\"value\":{\"stringValue\":{}}},{\"key\":\"toString\",\"value\":{}},{\"key\":\"__proto__\",\"value\":{\"stringValue\":\"\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1},{\"attributes\":[{\"key\":\"constructor\",\"value\":{}},{\"key\":\"__proto__\",\"value\":{\"stringValue\":{}}},{\"key\":\"toString\",\"value\":{}},{\"key\":\"__proto__\",\"value\":{\"stringValue\":{}}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":2,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"asDouble\":2}],\"aggregationTemporality\":1,\"isMonotonic\":true}}]}]}]}",+ "value_skipped": 3,+ "eval_errors": 0,+ "series_overflow": {},+ "threw": null+ },+ {+ "rows": [+ {+ "id": "ok",+ "metric_name": "ok",+ "filter_group": null,+ "value_attribute": null,+ "group_by": []+ },+ {+ "id": "t",+ "metric_name": "throws",+ "filter_group": null,+ "value_attribute": null,+ "group_by": [+ "attributes.__defineGetter__"+ ]+ }+ ],+ "defaults": null,+ "now_ms": 1736944633250,+ "records": [+ {+ "uuid": "l1",+ "trace_id": {+ "$bytes": "4152496a4e4556575a33694a6d7175387a64377641413d3d"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736944573250000,+ "service_name": "web",+ "severity_text": "ERROR",+ "event_name": null,+ "attributes": {+ "ms": "997.5",+ "user": "\"u1\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l4",+ "trace_id": {+ "$bytes": "4152496a4e4556575a33694a6d7175387a64377641413d3d"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736944573250000,+ "service_name": "api",+ "severity_text": "ERROR",+ "event_name": null,+ "attributes": {+ "ms": "3990",+ "user": "\"deny\""+ },+ "resource_attributes": null+ },+ {+ "uuid": "l7",+ "trace_id": {+ "$bytes": "4152496a4e4556575a33694a6d7175387a64377641413d3d"+ },+ "span_id": {+ "$bytes": "fffefdfcfbfaf9f8"+ },+ "timestamp": 1736944573250000,+ "service_name": "web",+ "severity_text": "ERROR",+ "event_name": null,+ "attributes": {+ "ms": "6982.5",+ "user": "\"u2\""+ },+ "resource_attributes": null+ }+ ],+ "payload_json": "{\"resourceMetrics\":[{\"resource\":{\"attributes\":[]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"ok\",\"sum\":{\"dataPoints\":[{\"attributes\":[],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":1,\"traceId\":\"0112233445566778899aabbccddeef00\",\"spanId\":\"fffefdfcfbfaf9f8\"}],\"asDouble\":1}],\"aggregationTemporality\":1,\"isMonotonic\":true}}]}]}]}",+ "value_skipped": 0,+ "eval_errors": 0,+ "series_overflow": {},+ "threw": "TypeError: value.startsWith is not a function"+ },+ {+ "rows": [],+ "defaults": "spans",+ "now_ms": 1736944633250,+ "records": [+ {+ "uuid": "s0",+ "trace_id": null,+ "span_id": null,+ "timestamp": 1736944633250000,+ "end_time": 1736944633251500,+ "name": "GET /a",+ "kind": 1,+ "status_code": 0,+ "service_name": "api",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-0\""+ },+ "attributes": {+ "ms": "12.5",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s1",+ "trace_id": {+ "$bytes": "1f202122232425262728292a2b2c2d2e"+ },+ "span_id": {+ "$bytes": "0102030405060708"+ },+ "timestamp": 1736944632250000,+ "end_time": 1736944632250000,+ "name": "db.query",+ "kind": 2,+ "status_code": 1,+ "service_name": "worker",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-1\""+ },+ "attributes": {+ "ms": "\" 3e2ms\"",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s2",+ "trace_id": {+ "$bytes": "3e3f404142434445464748494a4b4c4d"+ },+ "span_id": null,+ "timestamp": 1736944631250000,+ "end_time": 1736944638500125,+ "name": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",+ "kind": 3,+ "status_code": 2,+ "service_name": null,+ "resource_attributes": {+ "k8s.pod.name": "\"pod-0\""+ },+ "attributes": {+ "ms": "\"x\"",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s3",+ "trace_id": null,+ "span_id": {+ "$bytes": "030405060708090a"+ },+ "timestamp": 1736944630250000,+ "end_time": 1736944630250250,+ "name": "",+ "kind": 9,+ "status_code": 7,+ "service_name": "api",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-1\""+ },+ "attributes": {+ "ms": "-4",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s4",+ "trace_id": {+ "$bytes": "7c7d7e7f808182838485868788898a8b"+ },+ "span_id": null,+ "timestamp": 1736944629250000,+ "end_time": 1736956629250001,+ "name": "GET /a",+ "kind": null,+ "status_code": null,+ "service_name": "worker",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-0\""+ },+ "attributes": {+ "ms": "\"Infinity\"",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s5",+ "trace_id": {+ "$bytes": "9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aa"+ },+ "span_id": {+ "$bytes": "05060708090a0b0c"+ },+ "timestamp": 1736944628250000,+ "end_time": 1736944628251500,+ "name": "db.query",+ "kind": 1,+ "status_code": 0,+ "service_name": null,+ "resource_attributes": {+ "k8s.pod.name": "\"pod-1\""+ },+ "attributes": {+ "ms": "0.1",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s6",+ "trace_id": null,+ "span_id": null,+ "timestamp": 1736944627250000,+ "end_time": 1736944627250000,+ "name": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",+ "kind": 2,+ "status_code": 1,+ "service_name": "api",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-0\""+ },+ "attributes": {+ "ms": "\"1e400\"",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s7",+ "trace_id": {+ "$bytes": "d9dadbdcdddedfe0e1e2e3e4e5e6e7e8"+ },+ "span_id": {+ "$bytes": "0708090a0b0c0d0e"+ },+ "timestamp": 1736944626250000,+ "end_time": 1736944633500125,+ "name": "",+ "kind": 3,+ "status_code": 2,+ "service_name": "worker",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-1\""+ },+ "attributes": {+ "ms": "12.5",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s8",+ "trace_id": {+ "$bytes": "f8f9fafbfcfdfeff0001020304050607"+ },+ "span_id": null,+ "timestamp": 1736944625250000,+ "end_time": 1736944625250250,+ "name": "GET /a",+ "kind": 9,+ "status_code": 7,+ "service_name": null,+ "resource_attributes": {+ "k8s.pod.name": "\"pod-0\""+ },+ "attributes": {+ "ms": "\" 3e2ms\"",+ "http.method": "\"GET\""+ }+ },+ {+ "uuid": "s9",+ "trace_id": null,+ "span_id": {+ "$bytes": "090a0b0c0d0e0f10"+ },+ "timestamp": 1736944624250000,+ "end_time": 1736956624250001,+ "name": "db.query",+ "kind": null,+ "status_code": null,+ "service_name": "api",+ "resource_attributes": {+ "k8s.pod.name": "\"pod-1\""+ },+ "attributes": {+ "ms": "\"x\"",+ "http.method": "\"GET\""+ }+ }+ ],+ "payload_json": "{\"resourceMetrics\":[{\"resource\":{\"attributes\":[{\"key\":\"service.name\",\"value\":{\"stringValue\":\"worker\"}}]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"posthog.span.duration\",\"unit\":\"ms\",\"histogram\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"SERVER\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"db.query\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"OK\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":0,\"traceId\":\"1f202122232425262728292a2b2c2d2e\",\"spanId\":\"0102030405060708\"}],\"count\":1,\"sum\":0,\"bucketCounts\":[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"CLIENT\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"ERROR\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":7250.125,\"traceId\":\"d9dadbdcdddedfe0e1e2e3e4e5e6e7e8\",\"spanId\":\"0708090a0b0c0d0e\"}],\"count\":1,\"sum\":7250.125,\"bucketCounts\":[0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]}],\"aggregationTemporality\":1}}]}]},{\"resource\":{\"attributes\":[]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"posthog.span.duration\",\"unit\":\"ms\",\"histogram\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"CLIENT\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"ERROR\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":7250.125,\"traceId\":\"3e3f404142434445464748494a4b4c4d\"}],\"count\":1,\"sum\":7250.125,\"bucketCounts\":[0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"9\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"GET /a\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"7\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"exemplars\":[{\"filteredAttributes\":[],\"timeUnixNano\":\"1736944630000000000\",\"asDouble\":0.25,\"traceId\":\"f8f9fafbfcfdfeff0001020304050607\"}],\"count\":1,\"sum\":0.25,\"bucketCounts\":[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]}],\"aggregationTemporality\":1}}]}]},{\"resource\":{\"attributes\":[{\"key\":\"service.name\",\"value\":{\"stringValue\":\"api\"}}]},\"scopeMetrics\":[{\"scope\":{\"name\":\"posthog/logs-metric-rules\"},\"metrics\":[{\"name\":\"posthog.span.duration\",\"unit\":\"ms\",\"histogram\":{\"dataPoints\":[{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"9\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"7\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"count\":1,\"sum\":0.25,\"bucketCounts\":[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]},{\"attributes\":[{\"key\":\"posthog.bucket_layout\",\"value\":{\"stringValue\":\"otel_default_v1\"}},{\"key\":\"kind\",\"value\":{\"stringValue\":\"SERVER\"}},{\"key\":\"name\",\"value\":{\"stringValue\":\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"}},{\"key\":\"status_code\",\"value\":{\"stringValue\":\"OK\"}}],\"startTimeUnixNano\":\"1736944620000000000\",\"timeUnixNano\":\"1736944630000000000\",\"count\":1,\"sum\":0,\"bucketCounts\":[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"explicitBounds\":[0,5,10,25,50,75,100,250,500,750,1000,2500,5000,7500,10000]}],\"aggregationTemporality\":1}}]}]}]}",+ "value_skipped": 0,+ "eval_errors": 0,+ "series_overflow": {},+ "threw": null+ }+ ]+}diff --git a/rust/logs-ingestion/tests/fixtures/rate-limiter-reference.json b/rust/logs-ingestion/tests/fixtures/rate-limiter-reference.jsonnew file mode 100644index 000000000000..d1bc6eb3fca7--- /dev/null+++ b/rust/logs-ingestion/tests/fixtures/rate-limiter-reference.json@@ -0,0 +1,1188 @@+{+ "keyPatterns": [+ "@posthog-test/logs-parity-rl*",+ "@posthog-test/logs-sampling-rate/tokens/987654321/*"+ ],+ "keyedLimiters": {+ "v3": {+ "name": "logs-parity-rl-keyed-v3",+ "scriptVersion": "v3",+ "ttlSeconds": 600+ },+ "v2": {+ "name": "logs-parity-rl-keyed-v2",+ "scriptVersion": "v2",+ "ttlSeconds": 600+ },+ "grouped": {+ "name": "logs-parity-rl-grouped",+ "scriptVersion": "v3",+ "ttlSeconds": 600+ }+ },+ "logsLimiters": {+ "all": {+ "name": "logs-parity-rl-logs-all",+ "config": {+ "LOGS_LIMITER_ENABLED_TEAMS": "*",+ "LOGS_LIMITER_DISABLED_FOR_TEAMS": "3, x",+ "LOGS_LIMITER_BUCKET_SIZE_KB": 10,+ "LOGS_LIMITER_REFILL_RATE_KB_PER_SECOND": 2,+ "LOGS_LIMITER_TTL_SECONDS": 600,+ "LOGS_LIMITER_TEAM_BUCKET_SIZE_KB": "2:25, 4 : 3, bad:1",+ "LOGS_LIMITER_TEAM_REFILL_RATE_KB_PER_SECOND": "2:5"+ }+ },+ "listed": {+ "name": "logs-parity-rl-logs-listed",+ "config": {+ "LOGS_LIMITER_ENABLED_TEAMS": "1,2",+ "LOGS_LIMITER_DISABLED_FOR_TEAMS": "",+ "LOGS_LIMITER_BUCKET_SIZE_KB": 4,+ "LOGS_LIMITER_REFILL_RATE_KB_PER_SECOND": 1,+ "LOGS_LIMITER_TTL_SECONDS": 600,+ "LOGS_LIMITER_TEAM_BUCKET_SIZE_KB": "",+ "LOGS_LIMITER_TEAM_REFILL_RATE_KB_PER_SECOND": ""+ }+ }+ },+ "samplingRules": [+ {+ "id": "drop-health",+ "rule_type": "path_drop",+ "scope_service": null,+ "scope_path_pattern": null,+ "scope_attribute_filters": [],+ "config": {+ "patterns": [+ "healthz"+ ],+ "match_attribute_key": "url.path"+ }+ },+ {+ "id": "rl-records",+ "rule_type": "rate_limit",+ "scope_service": "api",+ "scope_path_pattern": null,+ "scope_attribute_filters": [],+ "config": {+ "logs_per_second": 2,+ "burst_logs": 3+ }+ },+ {+ "id": "rl-bytes",+ "rule_type": "rate_limit",+ "scope_service": null,+ "scope_path_pattern": null,+ "scope_attribute_filters": [],+ "config": {+ "kb_per_second": 1,+ "burst_kb": 1+ }+ }+ ],+ "shas": {+ "v2": "f8b27ea6a3f4823cc6710f72abd856ec83221998",+ "v3": "25df07199ef89fa96971f5bc0fb79695b6030d64"+ },+ "steps": [+ {+ "kind": "keyed",+ "limiter": "v3",+ "method": "many",+ "nowMs": 1736942400000,+ "requests": [+ {+ "id": "a",+ "cost": 3,+ "bucketSize": 10,+ "refillRate": 1,+ "now": 1736942400+ },+ {+ "id": "b",+ "cost": 15,+ "bucketSize": 10,+ "refillRate": 1,+ "now": 1736942400+ },+ {+ "id": "c",+ "cost": 2.5,+ "bucketSize": 7.5,+ "refillRate": 0.5,+ "now": 1736942400+ }+ ],+ "output": [+ [+ "a",+ {+ "tokensBefore": 10,+ "tokens": 7,+ "isRateLimited": false+ }+ ],+ [+ "b",+ {+ "tokensBefore": 10,+ "tokens": -1,+ "isRateLimited": true+ }+ ],+ [+ "c",+ {+ "tokensBefore": 7,+ "tokens": 5,+ "isRateLimited": false+ }+ ]+ ]+ },+ {+ "kind": "keyed",+ "limiter": "v3",+ "method": "many",+ "nowMs": 1736942400000,+ "requests": [+ {+ "id": "a",+ "cost": 8,+ "bucketSize": 10,+ "refillRate": 1,+ "now": 1736942401+ },+ {+ "id": "b",+ "cost": 10,+ "bucketSize": 10,+ "refillRate": 1,+ "now": 1736942401+ },+ {+ "id": "c",+ "cost": 1,+ "bucketSize": 7.5,+ "refillRate": 0.5,+ "now": 1736942403+ }+ ],+ "output": [+ [+ "a",+ {+ "tokensBefore": 8,+ "tokens": 0,+ "isRateLimited": true+ }+ ],+ [+ "b",+ {+ "tokensBefore": 1,+ "tokens": -1,+ "isRateLimited": true+ }+ ],+ [+ "c",+ {+ "tokensBefore": 6,+ "tokens": 5,+ "isRateLimited": false+ }+ ]+ ]+ },+ {+ "kind": "keyed",+ "limiter": "v3",+ "method": "many",+ "nowMs": 1736942400000,+ "requests": [+ {+ "id": "a",+ "cost": 1,+ "bucketSize": 10,+ "refillRate": 1,+ "now": 1736942395+ },+ {+ "id": "a",+ "cost": 1,+ "bucketSize": 10,+ "refillRate": 1,+ "now": 1736942500+ },+ {+ "id": "c",+ "cost": 0.25,+ "bucketSize": 7.5,+ "refillRate": 0.5,+ "now": 1736942404+ }+ ],+ "output": [+ [+ "a",+ {+ "tokensBefore": 0,+ "tokens": -1,+ "isRateLimited": true+ }+ ],+ [+ "a",+ {+ "tokensBefore": 99,+ "tokens": 10,+ "isRateLimited": false+ }+ ],+ [+ "c",+ {+ "tokensBefore": 6,+ "tokens": 5,+ "isRateLimited": false+ }+ ]+ ]+ },+ {+ "kind": "keyed",+ "limiter": "v3",+ "method": "many",+ "nowMs": 1736942600500,+ "requests": [+ {+ "id": "a",+ "cost": 50,+ "bucketSize": 10,+ "refillRate": 1+ },+ {+ "id": "d",+ "cost": 1e-7,+ "bucketSize": 1e+21,+ "refillRate": 3+ }+ ],+ "output": [+ [+ "a",+ {+ "tokensBefore": 111,+ "tokens": 10,+ "isRateLimited": false+ }+ ],+ [+ "d",+ {+ "tokensBefore": -9223372036854778000,+ "tokens": -9223372036854778000,+ "isRateLimited": true+ }+ ]+ ]+ },+ {+ "kind": "keyed",+ "limiter": "v2",+ "method": "many",+ "nowMs": 1736942400000,+ "requests": [+ {+ "id": "a",+ "cost": 3,+ "bucketSize": 10,+ "refillRate": 1,+ "now": 1736942400+ },+ {+ "id": "b",+ "cost": 15,+ "bucketSize": 10,+ "refillRate": 1,+ "now": 1736942400+ },+ {+ "id": "c",+ "cost": 2.5,+ "bucketSize": 7.5,+ "refillRate": 0.5,+ "now": 1736942400+ }+ ],+ "output": [+ [+ "a",+ {+ "tokensBefore": 10,+ "tokens": 7,+ "isRateLimited": false+ }+ ],+ [+ "b",+ {+ "tokensBefore": 10,+ "tokens": -1,+ "isRateLimited": true+ }+ ],+ [+ "c",+ {+ "tokensBefore": 7,+ "tokens": 5,+ "isRateLimited": false+ }+ ]+ ]+ },+ {+ "kind": "keyed",+ "limiter": "v2",+ "method": "many",+ "nowMs": 1736942400000,+ "requests": [+ {+ "id": "a",+ "cost": 8,+ "bucketSize": 10,+ "refillRate": 1,+ "now": 1736942401+ },+ {+ "id": "b",+ "cost": 10,+ "bucketSize": 10,+ "refillRate": 1,+ "now": 1736942401+ },+ {+ "id": "c",+ "cost": 6,+ "bucketSize": 7.5,+ "refillRate": 0.5,+ "now": 1736942403+ },+ {+ "id": "a",+ "cost": 1,+ "bucketSize": 10,+ "refillRate": 1,+ "now": 1736942395+ }+ ],+ "output": [+ [+ "a",+ {+ "tokensBefore": 8,+ "tokens": 0,+ "isRateLimited": true+ }+ ],+ [+ "b",+ {+ "tokensBefore": 11,+ "tokens": 1,+ "isRateLimited": false+ }+ ],+ [+ "c",+ {+ "tokensBefore": 6,+ "tokens": 0,+ "isRateLimited": true+ }+ ],+ [+ "a",+ {+ "tokensBefore": 0,+ "tokens": -1,+ "isRateLimited": true+ }+ ]+ ]+ },+ {+ "kind": "keyed",+ "limiter": "grouped",+ "method": "grouped",+ "nowMs": 1736942400000,+ "requests": [+ {+ "id": "x",+ "cost": 2,+ "bucketSize": 5,+ "refillRate": 1,+ "now": 1736942400+ },+ {+ "id": "y",+ "cost": 4,+ "bucketSize": 3,+ "refillRate": 1,+ "now": 1736942400+ },+ {+ "id": "x",+ "cost": 3,+ "bucketSize": 99,+ "refillRate": 50,+ "now": 1736942450+ },+ {+ "id": "x",+ "cost": 1,+ "now": 1736942400+ },+ {+ "id": "y",+ "cost": 1+ }+ ],+ "output": [+ [+ "x",+ {+ "tokensBefore": 5,+ "tokens": 3,+ "isRateLimited": false+ }+ ],+ [+ "y",+ {+ "tokensBefore": 3,+ "tokens": -1,+ "isRateLimited": true+ }+ ],+ [+ "x",+ {+ "tokensBefore": 3,+ "tokens": 0,+ "isRateLimited": false+ }+ ],+ [+ "x",+ {+ "tokensBefore": 0,+ "tokens": -1,+ "isRateLimited": true+ }+ ],+ [+ "y",+ {+ "tokensBefore": 3,+ "tokens": 2,+ "isRateLimited": false+ }+ ]+ ]+ },+ {+ "kind": "keyed",+ "limiter": "grouped",+ "method": "grouped",+ "nowMs": 1736942402000,+ "requests": [+ {+ "id": "x",+ "cost": 1,+ "bucketSize": 5,+ "refillRate": 1+ },+ {+ "id": "x",+ "cost": 1,+ "bucketSize": 5,+ "refillRate": 1+ },+ {+ "id": "y",+ "cost": 0.5,+ "bucketSize": 3,+ "refillRate": 1+ },+ {+ "id": "x",+ "cost": 1,+ "bucketSize": 5,+ "refillRate": 1+ }+ ],+ "output": [+ [+ "x",+ {+ "tokensBefore": 2,+ "tokens": 1,+ "isRateLimited": false+ }+ ],+ [+ "x",+ {+ "tokensBefore": 1,+ "tokens": 0,+ "isRateLimited": false+ }+ ],+ [+ "y",+ {+ "tokensBefore": 2,+ "tokens": 1.5,+ "isRateLimited": false+ }+ ],+ [+ "x",+ {+ "tokensBefore": 0,+ "tokens": -1,+ "isRateLimited": true+ }+ ]+ ]+ },+ {+ "kind": "logs",+ "limiter": "all",+ "nowMs": 1736942400000,+ "messages": [+ {+ "teamId": 1,+ "bytesUncompressed": 4000,+ "createdAt": "2025-01-15T12:00:00.000Z"+ },+ {+ "teamId": 1,+ "bytesUncompressed": 4001,+ "createdAt": "2025-01-15T12:00:00.400Z"+ },+ {+ "teamId": 1,+ "bytesUncompressed": 3000,+ "createdAt": "2025-01-15T11:59:57.000Z"+ },+ {+ "teamId": 2,+ "bytesUncompressed": 20000,+ "createdAt": "2025-01-15T12:00:00.000Z"+ },+ {+ "teamId": 2,+ "bytesUncompressed": 6000,+ "createdAt": "Wed, 15 Jan 2025 12:00:01 GMT"+ },+ {+ "teamId": 3,+ "bytesUncompressed": 99000,+ "createdAt": null+ },+ {+ "teamId": 3,+ "bytesUncompressed": 99000,+ "createdAt": "not a date"+ },+ {+ "teamId": 4,+ "bytesUncompressed": 1,+ "createdAt": "2025-01-15T12:00:00.500Z"+ },+ {+ "teamId": 4,+ "bytesUncompressed": 2500,+ "createdAt": "2025-01-15T12:00:00.500Z"+ },+ {+ "teamId": 1,+ "bytesUncompressed": 1,+ "createdAt": "2025-01-15T12:00:00.000Z"+ }+ ],+ "output": {+ "allowed": [+ 0,+ 1,+ 3,+ 5,+ 6,+ 7,+ 9+ ],+ "dropped": [+ 2,+ 4,+ 8+ ]+ }+ },+ {+ "kind": "logs",+ "limiter": "all",+ "nowMs": 1736942400000,+ "messages": [+ {+ "teamId": 1,+ "bytesUncompressed": 3500,+ "createdAt": "2025-01-15T12:00:02.000Z"+ },+ {+ "teamId": 1,+ "bytesUncompressed": 1500,+ "createdAt": "2025-01-15T12:00:01.000Z"+ },+ {+ "teamId": 2,+ "bytesUncompressed": 10000,+ "createdAt": "2025-01-15T12:00:01.000Z"+ },+ {+ "teamId": 4,+ "bytesUncompressed": 999,+ "createdAt": "2025-01-15T12:00:09.000Z"+ }+ ],+ "output": {+ "allowed": [+ 0,+ 1,+ 2,+ 3+ ],+ "dropped": []+ }+ },+ {+ "kind": "logs",+ "limiter": "listed",+ "nowMs": 1736942400000,+ "messages": [+ {+ "teamId": 1,+ "bytesUncompressed": 3000,+ "createdAt": "2025-01-15T12:00:00.000Z"+ },+ {+ "teamId": 1,+ "bytesUncompressed": 1000,+ "createdAt": "2025-01-15T12:00:00.000Z"+ },+ {+ "teamId": 2,+ "bytesUncompressed": 5000,+ "createdAt": "2025-01-15T12:00:00.000Z"+ },+ {+ "teamId": 5,+ "bytesUncompressed": 1000000000,+ "createdAt": ""+ },+ {+ "teamId": 1,+ "bytesUncompressed": 1,+ "createdAt": "2025-01-15T12:00:00.000Z"+ }+ ],+ "output": {+ "allowed": [+ 0,+ 1,+ 3+ ],+ "dropped": [+ 2,+ 4+ ]+ }+ },+ {+ "kind": "sampling",+ "nowMs": 1736942400000,+ "teamId": 987654321,+ "headerBytes": 0,+ "records": [+ {+ "uuid": "r0",+ "trace_id": {+ "$bytes": "0102030405060708090a0b0c0d0e0f10"+ },+ "span_id": null,+ "trace_flags": null,+ "timestamp": 1736942400000000,+ "observed_timestamp": 1736942400000000,+ "body": "request handled",+ "severity_text": "INFO",+ "severity_number": 9,+ "service_name": "api",+ "resource_attributes": {+ "service.name": "\"api\""+ },+ "instrumentation_scope": null,+ "event_name": null,+ "attributes": {+ "url.path": "\"/api/items\""+ },+ "bytes_uncompressed": 200+ },+ {+ "uuid": "r1",+ "trace_id": {+ "$bytes": "0102030405060708090a0b0c0d0e0f10"+ },+ "span_id": null,+ "trace_flags": null,+ "timestamp": 1736942400000000,+ "observed_timestamp": 1736942400000000,+ "body": "request handled",+ "severity_text": "INFO",+ "severity_number": 9,+ "service_name": "api",+ "resource_attributes": {+ "service.name": "\"api\""+ },+ "instrumentation_scope": null,+ "event_name": null,+ "attributes": {+ "url.path": "\"/healthz\""+ },+ "bytes_uncompressed": 200+ },+ {+ "uuid": "r2",+ "trace_id": {+ "$bytes": "0102030405060708090a0b0c0d0e0f10"+ },+ "span_id": null,+ "trace_flags": null,+ "timestamp": 1736942400000000,+ "observed_timestamp": 1736942400000000,+ "body": "request handled",+ "severity_text": "INFO",+ "severity_number": 9,+ "service_name": "api",+ "resource_attributes": {+ "service.name": "\"api\""+ },+ "instrumentation_scope": null,+ "event_name": null,+ "attributes": {+ "url.path": "\"/api/items\""+ },+ "bytes_uncompressed": 200+ },+ {+ "uuid": "r3",+ "trace_id": {+ "$bytes": "0102030405060708090a0b0c0d0e0f10"+ },+ "span_id": null,+ "trace_flags": null,+ "timestamp": 1736942400000000,+ "observed_timestamp": 1736942400000000,+ "body": "request handled",+ "severity_text": "INFO",+ "severity_number": 9,+ "service_name": "worker",+ "resource_attributes": {+ "service.name": "\"api\""+ },+ "instrumentation_scope": null,+ "event_name": null,+ "attributes": {+ "url.path": "\"/api/items\""+ },+ "bytes_uncompressed": 400+ },+ {+ "uuid": "r4",+ "trace_id": {+ "$bytes": "0102030405060708090a0b0c0d0e0f10"+ },+ "span_id": null,+ "trace_flags": null,+ "timestamp": 1736942400000000,+ "observed_timestamp": 1736942400000000,+ "body": "request handled",+ "severity_text": "INFO",+ "severity_number": 9,+ "service_name": "api",+ "resource_attributes": {+ "service.name": "\"api\""+ },+ "instrumentation_scope": null,+ "event_name": null,+ "attributes": {+ "url.path": "\"/api/items\""+ },+ "bytes_uncompressed": 200+ },+ {+ "uuid": "r5",+ "trace_id": {+ "$bytes": "0102030405060708090a0b0c0d0e0f10"+ },+ "span_id": null,+ "trace_flags": null,+ "timestamp": 1736942400000000,+ "observed_timestamp": 1736942400000000,+ "body": "request handled",+ "severity_text": "INFO",+ "severity_number": 9,+ "service_name": "worker",+ "resource_attributes": {+ "service.name": "\"api\""+ },+ "instrumentation_scope": null,+ "event_name": null,+ "attributes": {+ "url.path": "\"/api/items\""+ },+ "bytes_uncompressed": 500+ },+ {+ "uuid": "r6",+ "trace_id": {+ "$bytes": "0102030405060708090a0b0c0d0e0f10"+ },+ "span_id": null,+ "trace_flags": null,+ "timestamp": 1736942400000000,+ "observed_timestamp": 1736942400000000,+ "body": "request handled",+ "severity_text": "INFO",+ "severity_number": 9,+ "service_name": "api",+ "resource_attributes": {+ "service.name": "\"api\""+ },+ "instrumentation_scope": null,+ "event_name": null,+ "attributes": {+ "url.path": "\"/api/items\""+ },+ "bytes_uncompressed": 200+ },+ {+ "uuid": "r7",+ "trace_id": {+ "$bytes": "0102030405060708090a0b0c0d0e0f10"+ },+ "span_id": null,+ "trace_flags": null,+ "timestamp": 1736942400000000,+ "observed_timestamp": 1736942400000000,+ "body": "request handled",+ "severity_text": "INFO",+ "severity_number": 9,+ "service_name": "worker",+ "resource_attributes": {+ "service.name": "\"api\""+ },+ "instrumentation_scope": null,+ "event_name": null,+ "attributes": {+ "url.path": "\"/api/items\""+ },+ "bytes_uncompressed": null+ },+ {+ "uuid": "r8",+ "trace_id": {+ "$bytes": "0102030405060708090a0b0c0d0e0f10"+ },+ "span_id": null,+ "trace_flags": null,+ "timestamp": 1736942400000000,+ "observed_timestamp": 1736942400000000,+ "body": "request handled",+ "severity_text": "INFO",+ "severity_number": 9,+ "service_name": "worker",+ "resource_attributes": {+ "service.name": "\"api\""+ },+ "instrumentation_scope": null,+ "event_name": null,+ "attributes": {+ "url.path": "\"/api/items\""+ },+ "bytes_uncompressed": 300+ }+ ],+ "output": {+ "kept": [+ "r0",+ "r2",+ "r3",+ "r4",+ "r5",+ "r7"+ ],+ "recordsDropped": 3,+ "recordsDroppedByRuleId": [+ [+ "drop-health",+ 1+ ],+ [+ "rl-records",+ 1+ ],+ [+ "rl-bytes",+ 1+ ]+ ],+ "bytesDropped": 700,+ "bytesDroppedByRuleId": [+ [+ "drop-health",+ 200+ ],+ [+ "rl-records",+ 200+ ],+ [+ "rl-bytes",+ 300+ ]+ ],+ "contentBytesDropped": 120.66666666666666,+ "contentBytesTotal": 366,+ "droppedBy": "sampling"+ }+ },+ {+ "kind": "sampling",+ "nowMs": 1736942401400,+ "teamId": 987654321,+ "headerBytes": 2500,+ "records": [+ {+ "uuid": "s0",+ "trace_id": {+ "$bytes": "0102030405060708090a0b0c0d0e0f10"+ },+ "span_id": null,+ "trace_flags": null,+ "timestamp": 1736942400000000,+ "observed_timestamp": 1736942400000000,+ "body": "request handled",+ "severity_text": "INFO",+ "severity_number": 9,+ "service_name": "api",+ "resource_attributes": {+ "service.name": "\"api\""+ },+ "instrumentation_scope": null,+ "event_name": null,+ "attributes": {+ "url.path": "\"/api/items\""+ },+ "bytes_uncompressed": 200+ },+ {+ "uuid": "s1",+ "trace_id": {+ "$bytes": "0102030405060708090a0b0c0d0e0f10"+ },+ "span_id": null,+ "trace_flags": null,+ "timestamp": 1736942400000000,+ "observed_timestamp": 1736942400000000,+ "body": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",+ "severity_text": "INFO",+ "severity_number": 9,+ "service_name": "worker",+ "resource_attributes": {+ "service.name": "\"api\""+ },+ "instrumentation_scope": null,+ "event_name": null,+ "attributes": {+ "url.path": "\"/api/items\""+ },+ "bytes_uncompressed": 200+ },+ {+ "uuid": "s2",+ "trace_id": {+ "$bytes": "0102030405060708090a0b0c0d0e0f10"+ },+ "span_id": null,+ "trace_flags": null,+ "timestamp": 1736942400000000,+ "observed_timestamp": 1736942400000000,+ "body": "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy",+ "severity_text": "INFO",+ "severity_number": 9,+ "service_name": "worker",+ "resource_attributes": null,+ "instrumentation_scope": null,+ "event_name": null,+ "attributes": {+ "url.path": "\"/api/items\""+ },+ "bytes_uncompressed": 200+ },+ {+ "uuid": "s3",+ "trace_id": {+ "$bytes": "0102030405060708090a0b0c0d0e0f10"+ },+ "span_id": null,+ "trace_flags": null,+ "timestamp": 1736942400000000,+ "observed_timestamp": 1736942400000000,+ "body": "request handled",+ "severity_text": "INFO",+ "severity_number": 9,+ "service_name": "api",+ "resource_attributes": {+ "service.name": "\"api\""+ },+ "instrumentation_scope": null,+ "event_name": null,+ "attributes": {+ "url.path": "\"/api/items\""+ },+ "bytes_uncompressed": 200+ },+ {+ "uuid": "s4",+ "trace_id": {+ "$bytes": "0102030405060708090a0b0c0d0e0f10"+ },+ "span_id": null,+ "trace_flags": null,+ "timestamp": 1736942400000000,+ "observed_timestamp": 1736942400000000,+ "body": "request handled",+ "severity_text": "INFO",+ "severity_number": 9,+ "service_name": "worker",+ "resource_attributes": {+ "service.name": "\"api\""+ },+ "instrumentation_scope": "scope@1",+ "event_name": null,+ "attributes": {+ "url.path": "\"/api/items\""+ },+ "bytes_uncompressed": 200+ }+ ],+ "output": {+ "kept": [+ "s0",+ "s2",+ "s3",+ "s4"+ ],+ "recordsDropped": 1,+ "recordsDroppedByRuleId": [+ [+ "rl-bytes",+ 1+ ]+ ],+ "bytesDropped": 200,+ "bytesDroppedByRuleId": [+ [+ "rl-bytes",+ 200+ ]+ ],+ "contentBytesDropped": 328.25,+ "contentBytesTotal": 589,+ "droppedBy": "sampling"+ }+ }+ ],+ "finalState": {+ "@posthog-test/logs-parity-rl-grouped/tokens/x": {+ "ts": "1736942402",+ "pool": "0"+ },+ "@posthog-test/logs-parity-rl-grouped/tokens/y": {+ "ts": "1736942402",+ "pool": "1.5"+ },+ "@posthog-test/logs-parity-rl-keyed-v2/tokens/a": {+ "ts": "1736942401",+ "pool": "0"+ },+ "@posthog-test/logs-parity-rl-keyed-v2/tokens/b": {+ "ts": "1736942401",+ "pool": "1"+ },+ "@posthog-test/logs-parity-rl-keyed-v2/tokens/c": {+ "ts": "1736942403",+ "pool": "0.5"+ },+ "@posthog-test/logs-parity-rl-keyed-v3/tokens/a": {+ "ts": "1736942601",+ "pool": "10"+ },+ "@posthog-test/logs-parity-rl-keyed-v3/tokens/b": {+ "ts": "1736942401",+ "pool": "0"+ },+ "@posthog-test/logs-parity-rl-keyed-v3/tokens/c": {+ "ts": "1736942404",+ "pool": "5.75"+ },+ "@posthog-test/logs-parity-rl-keyed-v3/tokens/d": {+ "ts": "1736942601",+ "pool": "1e+21"+ },+ "@posthog-test/logs-parity-rl-logs-all/tokens/1": {+ "ts": "1736942402",+ "pool": "8"+ },+ "@posthog-test/logs-parity-rl-logs-all/tokens/2": {+ "ts": "1736942401",+ "pool": "15"+ },+ "@posthog-test/logs-parity-rl-logs-all/tokens/4": {+ "ts": "1736942409",+ "pool": "3"+ },+ "@posthog-test/logs-parity-rl-logs-listed/tokens/1": {+ "ts": "1736942400",+ "pool": "4"+ },+ "@posthog-test/logs-parity-rl-logs-listed/tokens/2": {+ "ts": "1736942400",+ "pool": "4"+ },+ "@posthog-test/logs-sampling-rate/tokens/987654321/rl-bytes": {+ "ts": "1736942401",+ "pool": "0"+ },+ "@posthog-test/logs-sampling-rate/tokens/987654321/rl-records": {+ "ts": "1736942401",+ "pool": "0"+ }+ }+}diff --git a/rust/logs-ingestion/tests/fixtures/re2-reference.json b/rust/logs-ingestion/tests/fixtures/re2-reference.jsonnew file mode 100644index 000000000000..2ad81ebd84fb--- /dev/null+++ b/rust/logs-ingestion/tests/fixtures/re2-reference.json@@ -0,0 +1,20518 @@+{+ "inputs": [+ "",+ "a",+ "A",+ "aa",+ "ab",+ "abc",+ "b",+ "x",+ "GET /api/v1/items",+ "POST /api",+ "/healthz",+ "HEALTHZ",+ "token=abc",+ "a{,5}",+ "{\"a\"",+ "a{01}",+ "<",+ ">",+ "[]",+ "a]",+ "&",+ "-",+ ".",+ "~",+ "\u0000",+ "\n",+ "S",+ "a.b",+ "axb",+ "α",+ "π日",+ "é",+ "É",+ "😀",+ "٣",+ "K",+ "k",+ "K",+ "ſ",+ "s",+ "ß",+ "ẞ",+ "Σ",+ "σ",+ "ς",+ "\u000b",+ " ",+ "\t",+ "\f",+ "\r\n",+ "word",+ "a word here",+ "_",+ "123-45-6789",+ "[email protected]",+ "",+ "",+ "",+ "x\ud83d",+ "�",+ "a�",+ "P",+ "/path/",+ "/",+ "\\",+ "ab\nb",+ " ",+ "abcabc",+ "ERROR here",+ "aaaa"+ ],+ "cases": [+ {+ "pattern": "",+ "flags": "is",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "",+ "flags": "",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "a",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "a",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "^(GET|POST) /api",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "^(GET|POST) /api",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "(?=lookahead)",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?=lookahead)",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?!x)",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?!x)",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?<=x)",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?<=x)",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?<!x)",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?<!x)",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "HEALTHZ|token=",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "HEALTHZ|token=",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "a{,5}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "a{,5}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "{\"a\"",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "{\"a\"",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "a{01}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "a{01}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "a{1,2}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "a{1,2}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "a{2,}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true+ ]+ },+ {+ "pattern": "a{2,}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true+ ]+ },+ {+ "pattern": "a{2,1}",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "a{2,1}",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "a{1000}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "a{1000}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "a{1001}",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "a{1001}",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(a{100}){10}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "(a{100}){10}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "(a{100}){11}",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(a{100}){11}",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "((a){10}){100}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "((a){10}){100}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "((a){10}){101}",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "((a){10}){101}",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(a{2}|b{500}){2}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true+ ]+ },+ {+ "pattern": "(a{2}|b{500}){2}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true+ ]+ },+ {+ "pattern": "(?:a{1000})*",+ "flags": "is",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "(?:a{1000})*",+ "flags": "",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "a**",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "a**",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "a+*",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "a+*",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "a*?",+ "flags": "is",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "a*?",+ "flags": "",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "a??",+ "flags": "is",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "a??",+ "flags": "",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "a???",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "a???",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "a{1,2}{3}",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "a{1,2}{3}",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "a{1,2}?",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "a{1,2}?",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "\\<",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\<",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\>",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\>",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "[a[b]]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "[a[b]]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "[a&&b]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "[a&&b]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "[a--b]",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "[a--b]",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "[--a]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "[--a]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "[a~~b]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "[a~~b]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "\\0",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\0",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\12",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\12",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\123",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\123",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\1",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\1",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\8",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\8",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\Z",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\Z",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\z",+ "flags": "is",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\z",+ "flags": "",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\A",+ "flags": "is",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\A",+ "flags": "",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\Qa.b\\E",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\Qa.b\\E",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\Qa.b",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\Qa.b",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\Q\\E*",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\Q\\E*",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?x)a b",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?x)a b",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?#c)",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?#c)",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?i)abc",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false+ ]+ },+ {+ "pattern": "(?i)abc",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false+ ]+ },+ {+ "pattern": "(?-i)abc",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false+ ]+ },+ {+ "pattern": "(?-i)abc",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false+ ]+ },+ {+ "pattern": "(?i-s:a.)",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "(?i-s:a.)",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "(?ii)a",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "(?ii)a",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "(?i-)a",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?i-)a",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?-)a",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?-)a",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?)",+ "flags": "is",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "(?)",+ "flags": "",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "(?:)",+ "flags": "is",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "(?:)",+ "flags": "",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "(?U)a+",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "(?U)a+",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "(?m)^b$",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "(?m)^b$",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "(?s).",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "(?s).",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\p{Greek}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\p{Greek}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\p{greek}",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\p{greek}",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\p{^Greek}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\p{^Greek}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\P{^Greek}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\P{^Greek}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\pL",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\pL",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\PL",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false+ ]+ },+ {+ "pattern": "\\PL",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false+ ]+ },+ {+ "pattern": "\\p{L}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\p{L}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\p{Cn}",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\p{Cn}",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\p{C}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\p{C}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\p{Cs}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\p{Cs}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\P{Cs}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\P{Cs}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\p{Any}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\p{Any}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\p{Lowercase_Letter}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\p{Lowercase_Letter}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\p{Script=Latin}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\p{Script=Latin}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\p{sc=Han}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\p{sc=Han}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\p{Han}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\p{Han}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "[\\p{L}\\d]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "[\\p{L}\\d]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "[^\\pL]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false+ ]+ },+ {+ "pattern": "[^\\pL]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false+ ]+ },+ {+ "pattern": "\\pN",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\pN",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\w",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\w",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\W",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false+ ]+ },+ {+ "pattern": "\\W",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false+ ]+ },+ {+ "pattern": "\\s",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false+ ]+ },+ {+ "pattern": "\\s",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false+ ]+ },+ {+ "pattern": "\\S",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\S",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\d",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\d",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\D",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\D",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\b",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\b",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\B",+ "flags": "is",+ "compiles": true,+ "results": [+ true,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\B",+ "flags": "",+ "compiles": true,+ "results": [+ true,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\bword\\b",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\bword\\b",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "[\\w-]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "[\\w-]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "[\\d-z]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ false,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "[\\d-z]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "[a-\\d]",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "[a-\\d]",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "[z-a]",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "[z-a]",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "[]a]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "[]a]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "[^]a]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false+ ]+ },+ {+ "pattern": "[^]a]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false+ ]+ },+ {+ "pattern": "[a-]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "[a-]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "[-a]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "[-a]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "[[:alpha:]]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "[[:alpha:]]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "[[:^alpha:]]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false+ ]+ },+ {+ "pattern": "[[:^alpha:]]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false+ ]+ },+ {+ "pattern": "[[:word:]]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "[[:word:]]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "[[:space:]]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false+ ]+ },+ {+ "pattern": "[[:space:]]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false+ ]+ },+ {+ "pattern": "[[:punct:]]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "[[:punct:]]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "[[:foo:]]",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "[[:foo:]]",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "[[:alpha:]",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "[[:alpha:]",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "[a",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "[a",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "a]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "a]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "(",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": ")",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": ")",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(a",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(a",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "a)",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "a)",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "*",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "*",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "a|*",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "a|*",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(*)",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(*)",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "^*",+ "flags": "is",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "^*",+ "flags": "",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "$*",+ "flags": "is",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "$*",+ "flags": "",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\b+",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\b+",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\e",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\e",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\y",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\y",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\é",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\é",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\x41",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "\\x41",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\x{41}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "\\x{41}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\x{110000}",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\x{110000}",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\x{D800}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\x{D800}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\x{}",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\x{}",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\x4",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\x4",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\C",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\C",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\uZZZZ",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\uZZZZ",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\u0041",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "\\u0041",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\u00411",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\u00411",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\u{1F600}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\u{1F600}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\cJ",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\cJ",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\cj",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\cj",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?<n>a)",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "(?<n>a)",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "(?P<n>a)",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "(?P<n>a)",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "(?P<1a>a)",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "(?P<1a>a)",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "(?P<a>x)(?P<a>y)",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?P<a>x)(?P<a>y)",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?P<a-b>x)",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?P<a-b>x)",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?P=n)",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?P=n)",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?<n",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "(?<n",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "[(?<a]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "[(?<a]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "/path/",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "/path/",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\/",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\/",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\\\",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\\\",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\",+ "flags": "is",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "\\",+ "flags": "",+ "compiles": false,+ "results": []+ },+ {+ "pattern": "a(?i)*",+ "flags": "is",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "a(?i)*",+ "flags": "",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "(?i)k",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "(?i)k",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "(?i)\\w",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "(?i)\\w",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "(?i)\\W",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false+ ]+ },+ {+ "pattern": "(?i)\\W",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false+ ]+ },+ {+ "pattern": "(?i)[^k]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "(?i)[^k]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "(?i)ß",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "(?i)ß",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "(?i)σ",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "(?i)σ",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "x\ud83d",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "x\ud83d",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "[\ud83d]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "[\ud83d]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "a[^\ud83d]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "a[^\ud83d]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ true,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ false,+ true+ ]+ },+ {+ "pattern": "😀",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "😀",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": ".",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": ".",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "^.$",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ false,+ true,+ false,+ true,+ true,+ false,+ true,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "^.$",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ true,+ true,+ false,+ true,+ false,+ true,+ false,+ true,+ true,+ false,+ true,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "^...$",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "^...$",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "é",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "é",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "(?i)É",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "(?i)É",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "^\\s+$",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "^\\s+$",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "[\\s]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false+ ]+ },+ {+ "pattern": "[\\s]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ true,+ false+ ]+ },+ {+ "pattern": "\\S+@\\S+",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\S+@\\S+",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "^/api/v[0-9]+",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "^/api/v[0-9]+",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "/healthz",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "/healthz",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "GET",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "GET",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "^$",+ "flags": "is",+ "compiles": true,+ "results": [+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "^$",+ "flags": "",+ "compiles": true,+ "results": [+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": ".*",+ "flags": "is",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": ".*",+ "flags": "",+ "compiles": true,+ "results": [+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "(a|b)*c",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false+ ]+ },+ {+ "pattern": "(a|b)*c",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false+ ]+ },+ {+ "pattern": "(?i)ERROR|WARN",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false+ ]+ },+ {+ "pattern": "(?i)ERROR|WARN",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false+ ]+ },+ {+ "pattern": "\\d{3}-\\d{2}-\\d{4}",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\d{3}-\\d{2}-\\d{4}",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "[[:^space:]]+",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "[[:^space:]]+",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "\\v",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\v",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\a",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\a",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\f",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\f",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\t\\n\\r",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "\\t\\n\\r",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "[\\x00-\\x7F]+",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "[\\x00-\\x7F]+",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ false,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ true,+ true,+ true+ ]+ },+ {+ "pattern": "[^\\x00-\\x7F]",+ "flags": "is",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false+ ]+ },+ {+ "pattern": "[^\\x00-\\x7F]",+ "flags": "",+ "compiles": true,+ "results": [+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ true,+ false,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ false,+ true,+ true,+ true,+ true,+ true,+ true,+ false,+ false,+ false,+ false,+ false,+ true,+ false,+ false,+ false+ ]+ }+ ]+}diff --git a/rust/logs-ingestion/tests/module_vectors.rs b/rust/logs-ingestion/tests/module_vectors.rsnew file mode 100644index 000000000000..c8e8caff6edb--- /dev/null+++ b/rust/logs-ingestion/tests/module_vectors.rs@@ -0,0 +1,86 @@+mod common;++use common::{cases, get, string};+use logs_ingestion::attribute_value::{decode_log_attribute_value, encode_log_attribute_value};+use logs_ingestion::body_parse::{parse_log_body_for_ingestion, LogBodyParseResult};+use logs_ingestion::js::{date_parse, JsObject, JsValue};++#[test]+fn date_parse_matches_v8() {+ let cases = cases("date_parse");+ assert!(!cases.is_empty());+ for (input, output) in cases {+ let text = match &input {+ JsValue::Null => String::new(),+ other => string(other),+ };+ let expected = match output {+ JsValue::Number(n) => Some(n),+ _ => None,+ };+ assert_eq!(date_parse(&text), expected, "Date.parse({text:?})");+ }+}++#[test]+fn attribute_value_codec_matches_node() {+ let cases = cases("attribute_value");+ assert!(cases.len() > 100);+ for (input, output) in cases {+ let input = string(&input);+ assert_eq!(+ decode_log_attribute_value(&input),+ *get(&output, "decoded").as_js_string().unwrap(),+ "decode {input:?}"+ );+ assert_eq!(+ encode_log_attribute_value(&input),+ string(get(&output, "encoded")),+ "encode {input:?}"+ );+ }+}++fn body_parse_to_js(result: LogBodyParseResult) -> JsValue {+ let mut o = JsObject::new();+ match result {+ LogBodyParseResult::Empty => o.insert_str("kind", JsValue::string("empty")),+ LogBodyParseResult::InvalidJson { raw } => {+ o.insert_str("kind", JsValue::string("invalid_json"));+ o.insert_str("raw", JsValue::string(&raw));+ }+ LogBodyParseResult::JsonObjectOrArray { value } => {+ o.insert_str("kind", JsValue::string("json_object_or_array"));+ o.insert_str("value", value);+ }+ LogBodyParseResult::JsonString { value } => {+ o.insert_str("kind", JsValue::string("json_string"));+ o.insert_str("value", JsValue::String(value));+ }+ LogBodyParseResult::JsonPrimitive { parsed } => {+ o.insert_str("kind", JsValue::string("json_primitive"));+ o.insert_str("parsed", parsed);+ }+ }+ JsValue::Object(o)+}++#[test]+fn body_parse_matches_node() {+ let cases = cases("body_parse");+ assert!(cases.len() > 40);+ for (input, output) in cases {+ let body = match &input {+ JsValue::Null => None,+ other => Some(string(other)),+ };+ let actual = body_parse_to_js(parse_log_body_for_ingestion(body.as_deref()));+ // Compared with key order: the vectors keep JavaScript's order, and so does JsObject.+ assert_eq!(+ actual,+ output,+ "body {:?}",+ body.map(|b| b.chars().take(80).collect::<String>())+ );+ }+}diff --git a/rust/logs-ingestion/tests/module_vectors_metrics.rs b/rust/logs-ingestion/tests/module_vectors_metrics.rsnew file mode 100644index 000000000000..3520c9a3ace4--- /dev/null+++ b/rust/logs-ingestion/tests/module_vectors_metrics.rs@@ -0,0 +1,380 @@+use std::cmp::Ordering;+use std::path::PathBuf;+use std::sync::Arc;++use logs_ingestion::avro::{AvroMap, AvroValue};+use logs_ingestion::js::{json_parse, json_stringify, JsObject, JsString, JsValue};+use logs_ingestion::metric_rules::{+ build_metric_rules_otlp_payload, compile_metric_rules, id_to_hex, resolve_label_value,+ tally_records, with_default_metric_rules, BatchTallies, LabelValue, MetricRuleRow,+ MetricRuleSource, MetricSeriesAdmission,+};+use logs_ingestion::record::LogRecord;++fn load(path: PathBuf) -> JsValue {+ let text = std::fs::read_to_string(&path).unwrap_or_else(|e| panic!("read {path:?}: {e}"));+ json_parse(&text).unwrap_or_else(|e| panic!("parse {path:?}: {e}"))+}++fn get<'a>(value: &'a JsValue, key: &str) -> &'a JsValue {+ match value {+ JsValue::Object(o) => o.get(key).unwrap_or_else(|| panic!("missing key {key}")),+ _ => panic!("not an object looking up {key}"),+ }+}++fn array(value: &JsValue) -> &[JsValue] {+ match value {+ JsValue::Array(items) => items,+ other => panic!("not an array: {other:?}"),+ }+}++fn object(value: &JsValue) -> &JsObject {+ match value {+ JsValue::Object(o) => o,+ other => panic!("not an object: {other:?}"),+ }+}++fn number(value: &JsValue) -> f64 {+ match value {+ JsValue::Number(n) => *n,+ other => panic!("not a number: {other:?}"),+ }+}++fn js_string(value: &JsValue) -> JsString {+ value.as_js_string().expect("a string").clone()+}++/// The default JavaScript sort: by UTF-16 code units.+fn js_sort_cmp(a: &JsString, b: &JsString) -> Ordering {+ let units = |s: &JsString| -> Vec<u16> {+ let mut out = Vec::new();+ for unit in s.chars_or_surrogates() {+ match unit.as_char() {+ Ok(c) => {+ let mut buf = [0u16; 2];+ out.extend_from_slice(c.encode_utf16(&mut buf));+ }+ Err(surrogate) => out.push(surrogate),+ }+ }+ out+ };+ units(a).cmp(&units(b))+}++/// Keys sorted, then assigned to a new object, which lists array-index keys first again.+fn canonicalize(value: &JsValue) -> JsValue {+ match value {+ JsValue::Array(items) => JsValue::Array(items.iter().map(canonicalize).collect()),+ JsValue::Object(o) => {+ let mut keys: Vec<JsString> = o.keys().collect();+ keys.sort_by(js_sort_cmp);+ let mut out = JsObject::new();+ for key in keys {+ let v = canonicalize(o.get(&key.to_utf8_lossy()).expect("own key"));+ out.insert(key, v);+ }+ JsValue::Object(out)+ }+ other => other.clone(),+ }+}++fn record_from_json(value: &JsValue) -> LogRecord {+ let to_avro = |v: &JsValue| -> AvroValue {+ match v {+ JsValue::Null => AvroValue::Null,+ JsValue::Bool(b) => AvroValue::Boolean(*b),+ JsValue::Number(n) => AvroValue::Long(*n as i64),+ JsValue::String(s) => AvroValue::String(s.to_utf8_lossy().into_owned()),+ JsValue::Object(o) => match o.get("$bytes") {+ Some(JsValue::String(hex)) => {+ AvroValue::Bytes(hex::decode(hex.to_utf8_lossy().as_bytes()).unwrap())+ }+ _ => {+ let mut map = AvroMap::new();+ for (k, v) in o.iter() {+ let JsValue::String(s) = v else {+ panic!("map value {v:?}")+ };+ map.assign(+ k.to_utf8_lossy().into_owned(),+ AvroValue::String(s.to_utf8_lossy().into_owned()),+ );+ }+ AvroValue::Map(map)+ }+ },+ JsValue::Array(_) => panic!("unexpected array in a record"),+ }+ };+ let fields = object(value)+ .iter()+ .map(|(k, v)| (Arc::from(&*k.to_utf8_lossy()), to_avro(v)))+ .collect();+ LogRecord::from_value(AvroValue::Record(fields))+}++#[test]+fn metric_tally_matches_node() {+ let file = load(+ PathBuf::from(env!("CARGO_MANIFEST_DIR"))+ .join("../../nodejs/src/logs/parity/fixtures/modules/metric_tally.json"),+ );+ let cases = array(get(&file, "cases"));+ assert!(!cases.is_empty());+ let mut passed = 0;+ for (index, case) in cases.iter().enumerate() {+ let input = get(case, "input");+ let expected = get(case, "output");+ let rows: Vec<MetricRuleRow> = array(get(input, "rules"))+ .iter()+ .map(|r| MetricRuleRow::from_js(object(r)))+ .collect();+ let with_defaults = matches!(get(input, "with_default_rules"), JsValue::Bool(true));+ let now_ms = number(get(input, "now_ms"));+ let records: Vec<LogRecord> = array(get(input, "records"))+ .iter()+ .map(record_from_json)+ .collect();++ let mut rules = compile_metric_rules(&rows).expect("compiles");+ if with_defaults {+ rules = with_default_metric_rules(rules, MetricRuleSource::Logs);+ }+ let mut tallies = BatchTallies::new();+ let mut admit = |_: &str, _: &str| true;+ tally_records(&rules, &records, &mut tallies, now_ms, Some(&mut admit)).expect("no throw");+ let overflow: u64 = tallies.series_overflow.values().sum();++ let mut actual = JsObject::new();+ let payload = build_metric_rules_otlp_payload(&rules, &tallies, now_ms);+ actual.insert_str(+ "payload",+ payload.as_ref().map(canonicalize).unwrap_or(JsValue::Null),+ );+ actual.insert_str(+ "value_skipped",+ JsValue::Number(tallies.value_skipped as f64),+ );+ actual.insert_str("eval_errors", JsValue::Number(tallies.eval_errors as f64));+ actual.insert_str("series_overflow", JsValue::Number(overflow as f64));+ let actual = JsValue::Object(actual);+ assert_eq!(+ json_stringify(&actual),+ json_stringify(expected),+ "case {index} (rules {}, defaults {with_defaults})",+ json_stringify(get(input, "rules"))+ );+ passed += 1;+ }+ assert_eq!(passed, cases.len());+}++fn reference() -> JsValue {+ load(+ PathBuf::from(env!("CARGO_MANIFEST_DIR"))+ .join("tests/fixtures/metric-rules-reference.json"),+ )+}++#[test]+fn label_truncation_matches_node() {+ let fixture = reference();+ let cases = array(get(&fixture, "labels"));+ assert!(!cases.is_empty());+ for case in cases {+ let attribute = js_string(get(case, "attribute"));+ let mut map = AvroMap::new();+ map.assign(+ "v".to_string(),+ AvroValue::String(attribute.to_utf8_lossy().into_owned()),+ );+ let record = LogRecord::from_value(AvroValue::Record(vec![(+ Arc::from("attributes"),+ AvroValue::Map(map),+ )]));+ let label = resolve_label_value(&JsString::from("attributes.v"), &record).unwrap();+ let LabelValue::String(label) = label else {+ panic!("not a string label")+ };+ assert_eq!(label.utf16_len() as f64, number(get(case, "length")));+ // The label key is what reaches JSON, so compare it as Node wrote it.+ let key = json_stringify(&JsValue::Array(vec![JsValue::String(label)]));+ assert_eq!(+ key,+ js_string(get(case, "label_key")).to_utf8_lossy(),+ "{attribute:?}"+ );+ }+}++#[test]+fn id_to_hex_matches_node() {+ let fixture = reference();+ for case in array(get(&fixture, "id_to_hex")) {+ let input =+ hex::decode(js_string(get(case, "input_hex")).to_utf8_lossy().as_bytes()).unwrap();+ let expected_bytes = number(get(case, "expected_bytes")) as usize;+ let expected = match get(case, "output") {+ JsValue::Null => None,+ v => Some(js_string(v).to_utf8_lossy().into_owned()),+ };+ let buffer = if input.is_empty() {+ None+ } else {+ Some(&input[..])+ };+ assert_eq!(id_to_hex(buffer, expected_bytes), expected, "{input:02x?}");+ }+}++fn hash_key(fixture: &JsValue) -> [u8; 32] {+ let bytes = hex::decode(+ js_string(get(fixture, "hmac_key_hex"))+ .to_utf8_lossy()+ .as_bytes(),+ )+ .unwrap();+ bytes.try_into().unwrap()+}++#[test]+fn label_hash_matches_node() {+ let fixture = reference();+ let admission = MetricSeriesAdmission::with_hash_key(1, 1, 1, hash_key(&fixture));+ for case in array(get(&fixture, "label_hashes")) {+ let label_key = js_string(get(case, "label_key"))+ .to_utf8_lossy()+ .into_owned();+ assert_eq!(+ admission.hash_label_key(&label_key) as f64,+ number(get(case, "hash")),+ "{label_key}"+ );+ }+}++#[test]+fn series_admission_matches_node() {+ let fixture = reference();+ let scenarios = array(get(&fixture, "admission"));+ assert!(!scenarios.is_empty());+ for scenario in scenarios {+ let caps: Vec<usize> = array(get(scenario, "caps"))+ .iter()+ .map(|c| number(c) as usize)+ .collect();+ let mut admission =+ MetricSeriesAdmission::with_hash_key(caps[0], caps[1], caps[2], hash_key(&fixture));+ let calls = array(get(scenario, "calls"));+ let results = array(get(scenario, "results"));+ for (i, call) in calls.iter().enumerate() {+ let call = array(call);+ let team_id = number(&call[0]) as i64;+ let rule_id = js_string(&call[1]).to_utf8_lossy().into_owned();+ let label_key = js_string(&call[2]).to_utf8_lossy().into_owned();+ let now_ms = number(&call[3]);+ let actual = admission.admit(team_id, &rule_id, &label_key, now_ms);+ assert_eq!(+ JsValue::Bool(actual),+ results[i],+ "{} call {i}: {team_id} {rule_id} {label_key} {now_ms}",+ json_stringify(get(scenario, "name"))+ );+ }+ }+}++#[test]+fn payload_bytes_match_node() {+ let fixture = reference();+ let cases = array(get(&fixture, "payloads"));+ assert!(!cases.is_empty());+ for (index, case) in cases.iter().enumerate() {+ let rows: Vec<MetricRuleRow> = array(get(case, "rows"))+ .iter()+ .map(|r| MetricRuleRow::from_js(object(r)))+ .collect();+ let mut rules = compile_metric_rules(&rows).expect("compiles");+ match get(case, "defaults") {+ JsValue::String(s) if *s == "logs" => {+ rules = with_default_metric_rules(rules, MetricRuleSource::Logs)+ }+ JsValue::String(_) => rules = with_default_metric_rules(rules, MetricRuleSource::Spans),+ _ => {}+ }+ let records: Vec<LogRecord> = array(get(case, "records"))+ .iter()+ .map(record_from_json)+ .collect();+ let now_ms = number(get(case, "now_ms"));+ let mut tallies = BatchTallies::new();+ let mut admit = |_: &str, label_key: &str| !label_key.contains("deny");+ let threw = tally_records(&rules, &records, &mut tallies, now_ms, Some(&mut admit))+ .err()+ .map(|e| JsValue::string(&e.to_string()))+ .unwrap_or(JsValue::Null);+ assert_eq!(threw, *get(case, "threw"), "threw {index}");++ let payload =+ build_metric_rules_otlp_payload(&rules, &tallies, now_ms).map(|p| json_stringify(&p));+ let expected = match get(case, "payload_json") {+ JsValue::Null => None,+ v => Some(js_string(v).to_utf8_lossy().into_owned()),+ };+ assert_eq!(payload, expected, "payload {index}");+ assert_eq!(+ tallies.value_skipped as f64,+ number(get(case, "value_skipped")),+ "value_skipped {index}"+ );+ assert_eq!(+ tallies.eval_errors as f64,+ number(get(case, "eval_errors")),+ "eval_errors {index}"+ );+ let mut overflow = JsObject::new();+ for (rule_id, count) in tallies.series_overflow.iter() {+ overflow.insert_str(rule_id, JsValue::Number(*count as f64));+ }+ assert_eq!(+ JsValue::Object(overflow),+ *get(case, "series_overflow"),+ "series_overflow {index}"+ );+ }+}++#[test]+fn compile_row_validation_matches_node() {+ let fixture = reference();+ let rows: Vec<MetricRuleRow> = array(get(&fixture, "compile_rows"))+ .iter()+ .map(|r| MetricRuleRow::from_js(object(r)))+ .collect();+ let compiled: Vec<JsValue> = compile_metric_rules(&rows)+ .unwrap()+ .into_iter()+ .map(|r| {+ let mut o = JsObject::new();+ o.insert_str("id", JsValue::string(&r.id));+ o.insert_str("metric_name", JsValue::String(r.metric_name));+ o.insert_str("source", JsValue::string(r.source.as_str()));+ o.insert_str(+ "value_attribute",+ r.value_attribute.map_or(JsValue::Null, JsValue::String),+ );+ o.insert_str(+ "group_by",+ JsValue::Array(r.group_by.into_iter().map(JsValue::String).collect()),+ );+ JsValue::Object(o)+ })+ .collect();+ assert_eq!(JsValue::Array(compiled), *get(&fixture, "compile"));+}diff --git a/rust/logs-ingestion/tests/module_vectors_normalize.rs b/rust/logs-ingestion/tests/module_vectors_normalize.rsnew file mode 100644index 000000000000..b07eb821f4a3--- /dev/null+++ b/rust/logs-ingestion/tests/module_vectors_normalize.rs@@ -0,0 +1,199 @@+//! Replays the `pii_scrub`, `pattern` and `normalize` vectors that Node recorded in+//! `nodejs/src/logs/parity/fixtures/modules` (see `logs-module-parity.test.ts`).++mod common;++use std::sync::Arc;++use common::{array, cases, get, string, try_get};+use logs_ingestion::avro::{AvroMap, AvroValue};+use logs_ingestion::js::{JsObject, JsString, JsValue};+use logs_ingestion::normalize::{transform_decoded_log_records_in_place, LogsSettings};+use logs_ingestion::pattern::build_log_pattern;+use logs_ingestion::pii::scrub_plain_string_with_stats;+use logs_ingestion::record::LogRecord;++fn number(value: &JsValue) -> f64 {+ match value {+ JsValue::Number(n) => *n,+ other => panic!("not a number: {other:?}"),+ }+}++fn short(text: &str) -> String {+ text.chars().take(80).collect()+}++#[test]+fn pii_scrub_matches_node() {+ let cases = cases("pii_scrub");+ assert_eq!(cases.len(), 44);+ for (input, output) in cases {+ let input = string(&input);+ let (scrubbed, n) = scrub_plain_string_with_stats(&input);+ assert_eq!(+ scrubbed,+ string(get(&output, "output")),+ "{:?}",+ short(&input)+ );+ assert_eq!(+ n as f64,+ number(get(&output, "piiReplacements")),+ "{:?}",+ short(&input)+ );+ }+}++#[test]+fn pattern_matches_node() {+ let cases = cases("pattern");+ assert_eq!(cases.len(), 132);+ for (input, output) in cases {+ let body = string(get(&input, "body"));+ let keys: Vec<String> = array(get(&input, "keys")).iter().map(string).collect();+ let keys: Vec<&str> = keys.iter().map(String::as_str).collect();+ let result = build_log_pattern(Some(&body), &keys);+ let ctx = format!("{:?} keys {keys:?}", short(&body));++ assert_eq!(+ JsString::from(result.pattern.as_str()),+ *get(&output, "pattern").as_js_string().unwrap(),+ "pattern {ctx}"+ );+ assert_eq!(+ result.body_kind.as_str(),+ string(get(&output, "bodyKind")),+ "kind {ctx}"+ );+ assert_eq!(+ JsValue::Bool(result.input_capped),+ *get(&output, "inputCapped"),+ "capped {ctx}"+ );+ assert_eq!(+ result.masked_length as f64,+ number(get(&output, "maskedLength")),+ "len {ctx}"+ );+ assert_eq!(+ result.json_key_count.map(|n| n as f64),+ try_get(&output, "jsonKeyCount").map(number),+ "key count {ctx}"+ );+ let fires: Vec<f64> = array(get(&output, "ruleFires"))+ .iter()+ .map(number)+ .collect();+ let actual: Vec<f64> = result.rule_fires.iter().map(|&n| n as f64).collect();+ assert_eq!(actual, fires, "rule fires {ctx}");+ }+}++fn settings_from_js(value: &JsValue) -> LogsSettings {+ let bool_of = |key: &str| match try_get(value, key) {+ Some(JsValue::Bool(b)) => Some(*b),+ None => None,+ other => panic!("{key}: {other:?}"),+ };+ LogsSettings {+ json_parse_logs: bool_of("json_parse_logs"),+ pii_scrub_logs: bool_of("pii_scrub_logs"),+ json_parse_logs_attribute_key: try_get(value, "json_parse_logs_attribute_key").map(string),+ ..LogsSettings::default()+ }+}++fn hex_decode(text: &str) -> Vec<u8> {+ (0..text.len())+ .step_by(2)+ .map(|i| u8::from_str_radix(&text[i..i + 2], 16).unwrap())+ .collect()+}++fn avro_from_js(value: &JsValue) -> AvroValue {+ match value {+ JsValue::Null => AvroValue::Null,+ JsValue::Bool(b) => AvroValue::Boolean(*b),+ JsValue::Number(n) => AvroValue::Long(*n as i64),+ JsValue::String(s) => AvroValue::String(s.to_string()),+ JsValue::Object(o) => {+ if let Some(JsValue::String(hex)) = o.get("$bytes") {+ return AvroValue::Bytes(hex_decode(&hex.to_string()));+ }+ let mut map = AvroMap::new();+ for (k, v) in o.iter() {+ map.define(k.to_string(), avro_from_js(v));+ }+ AvroValue::Map(map)+ }+ JsValue::Array(_) => panic!("records hold no arrays"),+ }+}++/// The harness's `recordToJson`: bytes as `{ $bytes: hex }`, map key order kept.+fn avro_to_js(value: &AvroValue) -> JsValue {+ match value {+ AvroValue::Null => JsValue::Null,+ AvroValue::Boolean(b) => JsValue::Bool(*b),+ AvroValue::Int(n) | AvroValue::Long(n) => JsValue::Number(*n as f64),+ AvroValue::Float(f) | AvroValue::Double(f) => JsValue::Number(*f),+ AvroValue::String(s) | AvroValue::Enum(s) => JsValue::string(s),+ AvroValue::Bytes(b) | AvroValue::Fixed(b) => {+ let mut o = JsObject::new();+ let hex: String = b.iter().map(|x| format!("{x:02x}")).collect();+ o.insert_str("$bytes", JsValue::string(&hex));+ JsValue::Object(o)+ }+ AvroValue::Map(m) => {+ let mut o = JsObject::new();+ for (k, v) in m.iter() {+ o.insert_str(k, avro_to_js(v));+ }+ JsValue::Object(o)+ }+ other => panic!("unexpected record value {other:?}"),+ }+}++fn record_from_js(value: &JsValue) -> LogRecord {+ let JsValue::Object(o) = value else {+ panic!("record is not an object");+ };+ let fields = o+ .iter()+ .map(|(k, v)| (Arc::from(k.to_string().as_str()), avro_from_js(v)))+ .collect();+ LogRecord::from_value(AvroValue::Record(fields))+}++fn record_to_js(record: &LogRecord) -> JsValue {+ let mut o = JsObject::new();+ for (k, v) in record.fields.iter().chain(record.extra.iter()) {+ o.insert_str(k, avro_to_js(v));+ }+ JsValue::Object(o)+}++#[test]+fn normalize_matches_node() {+ let cases = cases("normalize");+ assert_eq!(cases.len(), 209);+ for (i, (input, output)) in cases.into_iter().enumerate() {+ let settings = settings_from_js(get(&input, "settings"));+ let mut records = vec![record_from_js(get(&input, "record"))];+ let pii = transform_decoded_log_records_in_place(&mut records, &settings);+ // Compared with key order: the attribute order is what flatten eviction depends on.+ assert_eq!(+ record_to_js(&records[0]),+ *get(&output, "record"),+ "case {i} settings {settings:?}"+ );+ assert_eq!(+ pii.pii_replacements as f64,+ number(get(&output, "pii_replacements")),+ "case {i}"+ );+ }+}diff --git a/rust/logs-ingestion/tests/module_vectors_rules.rs b/rust/logs-ingestion/tests/module_vectors_rules.rsnew file mode 100644index 000000000000..b54800fb71cf--- /dev/null+++ b/rust/logs-ingestion/tests/module_vectors_rules.rs@@ -0,0 +1,222 @@+//! The inputs mirror `buildCases` in `nodejs/src/logs/parity/logs-module-parity.test.ts`.++use std::collections::HashMap;+use std::path::PathBuf;+use std::sync::Arc;++use logs_ingestion::avro::{AvroMap, AvroValue};+use logs_ingestion::content_weights::measure_content_weights;+use logs_ingestion::internal_logs::{+ sign_internal_logs, InternalLogsVerifier, InternalSourcePolicy,+};+use logs_ingestion::js::{json_parse, JsValue};+use logs_ingestion::record::LogRecord;+use logs_ingestion::retention::{+ compile_retention_rule_set, evaluate_retention_days, RetentionRuleRow,+};+use logs_ingestion::sampling::{compile_rule_set, evaluate_log_record, SamplingRuleRow};++/// `Date.UTC(2025, 0, 15, 12, 37, 13, 250)`.+const NOW_MS: f64 = 1_736_944_633_250.0;++fn cases(name: &str) -> Vec<(JsValue, JsValue)> {+ let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))+ .join("../../nodejs/src/logs/parity/fixtures/modules")+ .join(format!("{name}.json"));+ let file = json_parse(&std::fs::read_to_string(&path).unwrap()).unwrap();+ arr(get(&file, "cases"))+ .iter()+ .map(|c| (get(c, "input").clone(), get(c, "output").clone()))+ .collect()+}++fn get<'a>(v: &'a JsValue, key: &str) -> &'a JsValue {+ match v {+ JsValue::Object(o) => o.get(key).unwrap_or_else(|| panic!("missing {key}")),+ _ => panic!("not an object looking up {key}"),+ }+}++fn arr(v: &JsValue) -> &[JsValue] {+ match v {+ JsValue::Array(a) => a,+ other => panic!("not an array: {other:?}"),+ }+}++fn opt_string(v: &JsValue) -> Option<String> {+ match v {+ JsValue::Null => None,+ JsValue::String(s) => Some(s.to_string()),+ other => panic!("not a string or null: {other:?}"),+ }+}++fn record_from_json(v: &JsValue) -> LogRecord {+ let JsValue::Object(o) = v else {+ panic!("record is not an object")+ };+ let fields = o+ .iter()+ .map(|(k, v)| (Arc::from(k.to_string().as_str()), avro_from_json(v)))+ .collect();+ LogRecord::from_value(AvroValue::Record(fields))+}++fn avro_from_json(v: &JsValue) -> AvroValue {+ match v {+ JsValue::Null => AvroValue::Null,+ JsValue::Bool(b) => AvroValue::Boolean(*b),+ JsValue::Number(x) if x.fract() == 0.0 => AvroValue::Long(*x as i64),+ JsValue::Number(x) => AvroValue::Double(*x),+ JsValue::String(x) => AvroValue::String(x.to_utf8_lossy().into_owned()),+ JsValue::Object(o) => {+ if let Some(JsValue::String(hex)) = o.get("$bytes") {+ return AvroValue::Bytes(hex::decode(hex.to_string()).unwrap());+ }+ let mut map = AvroMap::new();+ for (k, v) in o.iter() {+ map.assign(k.to_string(), avro_from_json(v));+ }+ AvroValue::Map(map)+ }+ JsValue::Array(items) => AvroValue::Array(items.iter().map(avro_from_json).collect()),+ }+}++fn sampling_row(r: &JsValue) -> SamplingRuleRow {+ SamplingRuleRow {+ id: opt_string(get(r, "id")).unwrap(),+ rule_type: opt_string(get(r, "rule_type")).unwrap(),+ scope_service: opt_string(get(r, "scope_service")),+ scope_path_pattern: opt_string(get(r, "scope_path_pattern")),+ scope_attribute_filters: get(r, "scope_attribute_filters").clone(),+ config: get(r, "config").clone(),+ version: None,+ }+}++#[test]+fn sampling_evaluate_matches_node() {+ let cases = cases("sampling_evaluate");+ assert_eq!(cases.len(), 360);+ for (i, (input, output)) in cases.iter().enumerate() {+ let rows: Vec<SamplingRuleRow> =+ arr(get(input, "rules")).iter().map(sampling_row).collect();+ let rule_set = compile_rule_set(&rows).unwrap();+ let record = record_from_json(get(input, "record"));+ let result = evaluate_log_record(Some(&rule_set), &record).unwrap();+ assert_eq!(+ result.decision.as_str(),+ opt_string(get(output, "decision")).unwrap(),+ "case {i}"+ );+ assert_eq!(+ result.rule_id,+ opt_string(get(output, "ruleId")),+ "case {i}"+ );+ }+}++#[test]+fn retention_evaluate_matches_node() {+ let cases = cases("retention_evaluate");+ assert_eq!(cases.len(), 475);+ for (i, (input, output)) in cases.iter().enumerate() {+ let rows: Vec<RetentionRuleRow> = arr(get(input, "rules"))+ .iter()+ .map(|r| RetentionRuleRow {+ id: opt_string(get(r, "id")).unwrap(),+ config: get(r, "config").clone(),+ version: None,+ })+ .collect();+ let rule_set = compile_retention_rule_set(&rows).unwrap();+ let record = record_from_json(get(input, "record"));+ let expected = match output {+ JsValue::Null => None,+ JsValue::Number(n) => Some(*n as i64),+ other => panic!("unexpected output {other:?}"),+ };+ assert_eq!(+ evaluate_retention_days(Some(&rule_set), &record).unwrap(),+ expected,+ "case {i}"+ );+ }+}++#[test]+fn content_weights_match_node() {+ let cases = cases("content_weights");+ assert_eq!(cases.len(), 3);+ for (i, (input, output)) in cases.iter().enumerate() {+ let records: Vec<LogRecord> = arr(input).iter().map(record_from_json).collect();+ let expected: Vec<f64> = arr(output)+ .iter()+ .map(|v| match v {+ JsValue::Number(n) => *n,+ other => panic!("not a number: {other:?}"),+ })+ .collect();+ // Exact f64 equality: the shared resource bytes divide into fractional weights.+ assert_eq!(measure_content_weights(&records), expected, "case {i}");+ }+}++#[test]+fn internal_verify_matches_node() {+ let verifier = InternalLogsVerifier::new(+ "k1,k0",+ "1,2",+ HashMap::from([+ (+ "hog_flow".to_string(),+ InternalSourcePolicy {+ billed: false,+ team_rules: false,+ },+ ),+ (+ "billed_src".to_string(),+ InternalSourcePolicy {+ billed: true,+ team_rules: true,+ },+ ),+ ]),+ );+ let cases = cases("internal_verify");+ assert_eq!(cases.len(), 16);+ for (i, (input, output)) in cases.iter().enumerate() {+ let signature = opt_string(get(input, "signature"));+ let team_id = match get(input, "team_id") {+ JsValue::Number(n) => *n as i64,+ other => panic!("team_id {other:?}"),+ };+ let created_at = opt_string(get(input, "created_at"));+ let actual = verifier.verify(signature.as_deref(), team_id, created_at.as_deref());+ let expected = match output {+ JsValue::Null => None,+ o => Some((+ opt_string(get(o, "source")).unwrap(),+ get(o, "billed") == &JsValue::Bool(true),+ get(o, "teamRules") == &JsValue::Bool(true),+ )),+ };+ assert_eq!(+ actual.map(|a| (a.source, a.billed, a.team_rules)),+ expected,+ "case {i}: {signature:?}"+ );+ }+ // The signer gives the bytes Node signed for case 1: key k1, team 1, two seconds before NOW.+ let signed = sign_internal_logs("k1", "hog_flow", 1, NOW_MS - 2000.0).unwrap();+ assert_eq!(Some(signed), opt_string(get(&cases[1].0, "signature")));+ let signed_old_key = sign_internal_logs("k0", "hog_flow", 1, NOW_MS - 2000.0).unwrap();+ assert_eq!(+ Some(signed_old_key),+ opt_string(get(&cases[2].0, "signature"))+ );+}diff --git a/rust/logs-ingestion/tests/parity_corpus.rs b/rust/logs-ingestion/tests/parity_corpus.rsnew file mode 100644index 000000000000..c2ee5730174c--- /dev/null+++ b/rust/logs-ingestion/tests/parity_corpus.rs@@ -0,0 +1,427 @@+mod common;++use std::sync::Arc;++use common::{array, canonical, get, js_sort_cmp, load_json, scenarios_dir, string};+use ingestion_framework::KafkaMessage;+use logs_ingestion::avro::decode_container;+use logs_ingestion::js::{json_parse, json_stringify, JsObject, JsString, JsValue};+use logs_ingestion::pipeline::errors::error_name;+use logs_ingestion::pipeline::scenario::{+ build_scenario_consumer, kafka_message, PinnedClock, UsageRow,+};+use logs_ingestion::rate_limiter::{RedisTokenBucket, TokenBucketRedis};+use sha2::{Digest, Sha256};++const REDIS_URL: &str = "redis://127.0.0.1:6379";++fn obj(entries: Vec<(&str, JsValue)>) -> JsValue {+ let mut o = JsObject::new();+ for (k, v) in entries {+ o.insert_str(k, v);+ }+ JsValue::Object(o)+}++fn num(n: f64) -> JsValue {+ JsValue::Number(n)+}++/// Keys sorted, then assigned to an object, as `canonicalizeAvroValue` does.+fn sort_keys(value: &JsValue) -> JsValue {+ match value {+ JsValue::Array(items) => JsValue::Array(items.iter().map(sort_keys).collect()),+ JsValue::Object(o) => {+ let mut entries: Vec<(String, JsValue)> = o+ .iter()+ .map(|(k, v)| (k.to_utf8_lossy().into_owned(), sort_keys(v)))+ .collect();+ entries.sort_by(|(a, _), (b, _)| js_sort_cmp(a, b));+ let mut out = JsObject::new();+ for (k, v) in entries {+ out.insert(JsString::from(k), v);+ }+ JsValue::Object(out)+ }+ other => other.clone(),+ }+}++/// Kept equal to `UNORDERED_METRIC_ARRAYS` in `parity-harness.ts`. A histogram's bucket arrays are positional.+const UNORDERED_METRIC_ARRAYS: [&str; 7] = [+ "resourceMetrics",+ "scopeMetrics",+ "metrics",+ "dataPoints",+ "attributes",+ "exemplars",+ "filteredAttributes",+];++fn sort_arrays(value: &JsValue) -> JsValue {+ sort_arrays_under(value, None)+}++fn sort_arrays_under(value: &JsValue, key: Option<&str>) -> JsValue {+ match value {+ JsValue::Array(items) => {+ let mut items: Vec<JsValue> = items+ .iter()+ .map(|item| sort_arrays_under(item, None))+ .collect();+ if key.is_some_and(|key| UNORDERED_METRIC_ARRAYS.contains(&key)) {+ items.sort_by(|a, b| js_sort_cmp(&json_stringify(a), &json_stringify(b)));+ }+ JsValue::Array(items)+ }+ JsValue::Object(o) => {+ let mut out = JsObject::new();+ for (k, v) in o.iter() {+ out.insert(k.clone(), sort_arrays_under(v, k.as_str()));+ }+ JsValue::Object(out)+ }+ other => other.clone(),+ }+}++fn schema_and_codec(buffer: &[u8]) -> Option<(JsValue, String)> {+ let container = decode_container(buffer).ok()?;+ Some((json_parse(&container.schema_json).ok()?, container.codec))+}++fn canonical_value(+ output: &str,+ value: Option<&[u8]>,+ inputs: &[(Vec<u8>, usize, usize)],+) -> JsValue {+ let Some(value) = value else {+ return obj(vec![("kind", JsValue::string("null"))]);+ };+ if let Some((_, batch, index)) = inputs.iter().find(|(bytes, _, _)| bytes == value) {+ return obj(vec![+ ("kind", JsValue::string("passthrough")),+ ("batch", num(*batch as f64)),+ ("index", num(*index as f64)),+ ]);+ }+ if output == "logs" && value.starts_with(b"Obj\x01") {+ if let Ok(container) = decode_container(value) {+ let (schema, codec) = schema_and_codec(value).unwrap();+ return obj(vec![+ ("kind", JsValue::string("avro")),+ ("schema", schema),+ ("codec", JsValue::string(&codec)),+ (+ "records",+ JsValue::Array(container.records.iter().map(canonical).collect()),+ ),+ ]);+ }+ }+ if output == "app_metrics" {+ let raw = String::from_utf8_lossy(value).into_owned();+ let json = sort_keys(&json_parse(&raw).unwrap());+ return obj(vec![+ ("kind", JsValue::string("json")),+ ("raw", JsValue::string(&raw)),+ ("json", json),+ ]);+ }+ let sha: String = Sha256::digest(value)+ .iter()+ .map(|b| format!("{b:02x}"))+ .collect();+ obj(vec![+ ("kind", JsValue::string("bytes")),+ ("sha256", JsValue::string(&sha)),+ ("length", num(value.len() as f64)),+ ])+}++fn sorted_texts(values: impl IntoIterator<Item = JsValue>) -> Vec<String> {+ let mut texts: Vec<String> = values.into_iter().map(|v| json_stringify(&v)).collect();+ texts.sort_by(|a, b| js_sort_cmp(a, b));+ texts+}++fn diff(scenario: &str, what: &str, expected: &[String], actual: &[String]) -> Option<String> {+ if expected == actual {+ return None;+ }+ let mut missing: Vec<&String> = Vec::new();+ let mut extra: Vec<&String> = actual.iter().collect();+ for e in expected {+ match extra.iter().position(|a| *a == e) {+ Some(i) => {+ extra.remove(i);+ }+ None => missing.push(e),+ }+ }+ let clip = |s: &str| s.chars().take(1500).collect::<String>();+ let mut out = format!(+ "\n== {scenario}: {what}: {} only in Node, {} only in Rust\n",+ missing.len(),+ extra.len()+ );+ for m in missing.iter().take(5) {+ out += &format!(" node: {}\n", clip(m));+ }+ for e in extra.iter().take(5) {+ out += &format!(" rust: {}\n", clip(e));+ }+ if missing.is_empty() && extra.is_empty() {+ out += " same items, different order\n";+ }+ Some(out)+}++fn usage_texts(rows: Vec<UsageRow>) -> Vec<String> {+ let as_js = |r: &UsageRow, record_id: JsValue| {+ obj(vec![+ ("batch", num(r.batch as f64)),+ ("team_id", num(r.team_id as f64)),+ ("metric", JsValue::string(&r.metric)),+ ("quantity", num(r.quantity)),+ ("unit", JsValue::string(&r.unit)),+ ("record_id", record_id),+ ])+ };+ let mut rows = rows;+ rows.sort_by(|a, b| {+ js_sort_cmp(+ &json_stringify(&as_js(a, JsValue::string(""))),+ &json_stringify(&as_js(b, JsValue::string(""))),+ )+ });+ let mut groups: Vec<String> = Vec::new();+ rows.iter()+ .map(|r| {+ let group = match groups.iter().position(|g| *g == r.record_id) {+ Some(i) => i,+ None => {+ groups.push(r.record_id.clone());+ groups.len() - 1+ }+ };+ let mut v = as_js(r, JsValue::Null);+ if let JsValue::Object(o) = &mut v {+ o.remove("record_id");+ o.insert_str("record_group", num(group as f64));+ }+ json_stringify(&v)+ })+ .collect()+}++async fn run_scenario(+ path: &std::path::Path,+ redis: Arc<dyn TokenBucketRedis>,+ conn: &mut redis::aio::MultiplexedConnection,+) -> Option<String> {+ let fixture = load_json(&path.to_path_buf());+ let scenario = get(&fixture, "scenario");+ let expected = get(&fixture, "expected");+ let name = string(get(scenario, "name"));+ let _: () = redis::cmd("FLUSHDB").query_async(conn).await.unwrap();++ let clock = PinnedClock::new(0.0);+ let harness = build_scenario_consumer(scenario, redis, clock.clock(), false);+ let batches: Vec<Vec<KafkaMessage>> = array(get(scenario, "batches"))+ .iter()+ .map(|b| array(b).iter().map(kafka_message).collect())+ .collect();+ let mut inputs: Vec<(Vec<u8>, usize, usize)> = Vec::new();+ for (b, batch) in batches.iter().enumerate() {+ for (i, m) in batch.iter().enumerate() {+ if let Some(v) = &m.value {+ inputs.push((v.to_vec(), b, i));+ }+ }+ }+ let clocks = array(get(scenario, "batch_now_ms"));+ let mut batch_results = Vec::new();+ for (b, batch) in batches.into_iter().enumerate() {+ harness+ .outputs+ .current_batch+ .store(b as u64, std::sync::atomic::Ordering::SeqCst);+ if let JsValue::Number(ms) = &clocks[b] {+ clock.set(*ms);+ }+ let result = match harness.consumer.process_kafka_batch(batch).await {+ Ok(processed) => match processed.background_task {+ Some(task) => task.await,+ None => Ok(()),+ },+ Err(e) => Err(e),+ };+ batch_results.push(obj(vec![(+ "error",+ match result {+ Ok(()) => JsValue::Null,+ Err(e) => JsValue::string(&error_name(&e)),+ },+ )]));+ }++ let mut problems = String::new();+ let mut check = |what: &str, expected: Vec<String>, actual: Vec<String>| {+ if let Some(d) = diff(&name, what, &expected, &actual) {+ problems += &d;+ }+ };+ check(+ "batches",+ array(get(expected, "batches"))+ .iter()+ .map(json_stringify)+ .collect(),+ batch_results.iter().map(json_stringify).collect(),+ );++ let captured = harness.outputs.captured.lock().unwrap().clone();+ let actual_outputs = captured.iter().map(|c| {+ let mut headers: Vec<(String, String)> = c.message.headers.iter().cloned().collect();+ headers.sort_by(|a, b| js_sort_cmp(&a.0, &b.0));+ let mut h = JsObject::new();+ for (k, v) in headers {+ h.insert(JsString::from(k), JsValue::string(&v));+ }+ obj(vec![+ ("batch", num(c.batch as f64)),+ ("output", JsValue::string(&c.output)),+ (+ "key",+ match &c.message.key {+ Some(k) => JsValue::string(&String::from_utf8_lossy(k)),+ None => JsValue::Null,+ },+ ),+ ("headers", JsValue::Object(h)),+ (+ "value",+ canonical_value(&c.output, c.message.value.as_deref(), &inputs),+ ),+ ])+ });+ // The output order is not a contract, so compare per output kind as multisets.+ let expected_outputs = array(get(expected, "outputs")).to_vec();+ for kind in ["logs", "logs_dlq", "app_metrics"] {+ let pick = |v: &JsValue| matches!(get(v, "output"), JsValue::String(s) if *s == kind);+ check(+ &format!("outputs[{kind}]"),+ sorted_texts(expected_outputs.iter().filter(|v| pick(v)).cloned()),+ sorted_texts(actual_outputs.clone().filter(|v| pick(v))),+ );+ }++ let recorded = &harness.recorded;+ check(+ "metric_emits",+ sorted_texts(array(get(expected, "metric_emits")).iter().cloned()),+ sorted_texts(+ recorded+ .metric_emits+ .lock()+ .unwrap()+ .iter()+ .map(|(token, team, payload)| {+ obj(vec![+ ("token", JsValue::string(token)),+ ("team_id", num(*team as f64)),+ ("payload", sort_arrays(&sort_keys(payload))),+ ])+ }),+ ),+ );+ check(+ "usage_records",+ array(get(expected, "usage_records"))+ .iter()+ .map(json_stringify)+ .collect(),+ usage_texts(recorded.usage_rows.lock().unwrap().clone()),+ );+ check(+ "teams_ingested",+ array(get(expected, "teams_ingested"))+ .iter()+ .map(json_stringify)+ .collect(),+ recorded+ .teams_ingested+ .lock()+ .unwrap()+ .iter()+ .map(|ids| {+ json_stringify(&JsValue::Array(+ ids.iter().map(|t| num(*t as f64)).collect(),+ ))+ })+ .collect(),+ );+ let mut quota: Vec<String> = recorded+ .quota_checks+ .lock()+ .unwrap()+ .iter()+ .map(|(t, r)| {+ json_stringify(&JsValue::Array(vec![+ JsValue::string(t),+ JsValue::string(r),+ ]))+ })+ .collect();+ quota.sort_by(|a, b| js_sort_cmp(a, b));+ check(+ "quota_checks",+ array(get(expected, "quota_checks"))+ .iter()+ .map(json_stringify)+ .collect(),+ quota,+ );+ (!problems.is_empty()).then_some(problems)+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn rust_consumer_reproduces_the_node_parity_corpus() {+ let client = redis::Client::open(REDIS_URL).unwrap();+ let mut conn = match client.get_multiplexed_async_connection().await {+ Ok(c) => c,+ Err(e) => {+ eprintln!("skipping: no Redis at {REDIS_URL}: {e}");+ return;+ }+ };+ let redis: Arc<dyn TokenBucketRedis> = Arc::new(RedisTokenBucket::new(conn.clone()));+ let only = std::env::var("PARITY_SCENARIO").ok();+ let mut paths: Vec<_> = std::fs::read_dir(scenarios_dir())+ .unwrap()+ .map(|e| e.unwrap().path())+ .filter(|p| p.extension().is_some_and(|e| e == "json"))+ .filter(|p| {+ only.as_ref()+ .is_none_or(|o| p.file_stem().unwrap().to_string_lossy() == *o)+ })+ .collect();+ paths.sort();+ assert!(!paths.is_empty());+ let mut failures = String::new();+ let mut passed = Vec::new();+ for path in &paths {+ match run_scenario(path, redis.clone(), &mut conn).await {+ Some(problems) => failures += &problems,+ None => passed.push(path.file_stem().unwrap().to_string_lossy().into_owned()),+ }+ }+ eprintln!(+ "parity passed: {}/{} {:?}",+ passed.len(),+ paths.len(),+ passed+ );+ assert!(failures.is_empty(), "{failures}");+}diff --git a/rust/logs-ingestion/tests/rate_limiter_redis.rs b/rust/logs-ingestion/tests/rate_limiter_redis.rsnew file mode 100644index 000000000000..99d81ac5fbea--- /dev/null+++ b/rust/logs-ingestion/tests/rate_limiter_redis.rs@@ -0,0 +1,397 @@+use std::collections::HashMap;+use std::path::PathBuf;+use std::sync::atomic::{AtomicU64, Ordering};+use std::sync::Arc;++use logs_ingestion::avro::{AvroMap, AvroValue};+use logs_ingestion::content_weights::run_pipeline_stages;+use logs_ingestion::js::{json_parse, JsValue};+use logs_ingestion::rate_limiter::{+ token_bucket_v2, token_bucket_v3, Clock, KeyRoot, KeyedRateLimitRequest, KeyedRateLimiter,+ KeyedRateLimiterConfig, LogsRateLimiter, LogsRateLimiterConfig, RateLimitedMessage,+ RedisTokenBucket, ScriptVersion, TokenBucketRedis,+};+use logs_ingestion::record::LogRecord;+use logs_ingestion::sampling::{compile_rule_set, LogsSamplingService, SamplingRuleRow};++const REDIS_URL: &str = "redis://127.0.0.1:6379";++fn get<'a>(v: &'a JsValue, key: &str) -> &'a JsValue {+ match v {+ JsValue::Object(o) => o.get(key).unwrap_or_else(|| panic!("missing {key}")),+ _ => panic!("not an object looking up {key}"),+ }+}++fn opt<'a>(v: &'a JsValue, key: &str) -> Option<&'a JsValue> {+ match v {+ JsValue::Object(o) => o.get(key),+ _ => None,+ }+}++fn arr(v: &JsValue) -> &[JsValue] {+ match v {+ JsValue::Array(a) => a,+ other => panic!("not an array: {other:?}"),+ }+}++fn s(v: &JsValue) -> String {+ match v {+ JsValue::String(x) => x.to_string(),+ other => panic!("not a string: {other:?}"),+ }+}++fn n(v: &JsValue) -> f64 {+ match v {+ JsValue::Number(x) => *x,+ other => panic!("not a number: {other:?}"),+ }+}++fn opt_n(v: &JsValue, key: &str) -> Option<f64> {+ opt(v, key).map(n)+}++fn record_from_json(v: &JsValue) -> LogRecord {+ let JsValue::Object(o) = v else {+ panic!("record is not an object")+ };+ let fields = o+ .iter()+ .map(|(k, v)| (Arc::from(k.to_string().as_str()), avro_from_json(v)))+ .collect();+ LogRecord::from_value(AvroValue::Record(fields))+}++fn avro_from_json(v: &JsValue) -> AvroValue {+ match v {+ JsValue::Null => AvroValue::Null,+ JsValue::Bool(b) => AvroValue::Boolean(*b),+ JsValue::Number(x) if x.fract() == 0.0 => AvroValue::Long(*x as i64),+ JsValue::Number(x) => AvroValue::Double(*x),+ JsValue::String(x) => AvroValue::String(x.to_utf8_lossy().into_owned()),+ JsValue::Object(o) => {+ if let Some(JsValue::String(hex)) = o.get("$bytes") {+ return AvroValue::Bytes(hex::decode(hex.to_string()).unwrap());+ }+ let mut map = AvroMap::new();+ for (k, v) in o.iter() {+ map.assign(k.to_string(), avro_from_json(v));+ }+ AvroValue::Map(map)+ }+ JsValue::Array(items) => AvroValue::Array(items.iter().map(avro_from_json).collect()),+ }+}++struct Msg {+ team: i64,+ bytes: f64,+ created_at: Option<Vec<u8>>,+}++impl RateLimitedMessage for Msg {+ fn team_id(&self) -> i64 {+ self.team+ }+ fn bytes_uncompressed(&self) -> f64 {+ self.bytes+ }+ fn created_at_header(&self) -> Option<&[u8]> {+ self.created_at.as_deref()+ }+}++async fn keys_matching(+ conn: &mut redis::aio::MultiplexedConnection,+ patterns: &[String],+) -> Vec<String> {+ let mut keys = Vec::new();+ for pattern in patterns {+ let found: Vec<String> = redis::cmd("KEYS")+ .arg(pattern)+ .query_async(conn)+ .await+ .unwrap();+ keys.extend(found);+ }+ keys+}++#[tokio::test]+async fn rate_limiters_match_node_against_redis() {+ let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))+ .join("tests/fixtures/rate-limiter-reference.json");+ let fixture = json_parse(&std::fs::read_to_string(path).unwrap()).unwrap();++ let client = redis::Client::open(REDIS_URL).unwrap();+ let mut conn = match client.get_multiplexed_async_connection().await {+ Ok(c) => c,+ Err(e) => {+ eprintln!("skipping: no Redis at {REDIS_URL}: {e}");+ return;+ }+ };++ assert_eq!(s(get(get(&fixture, "shas"), "v2")), token_bucket_v2().sha);+ assert_eq!(s(get(get(&fixture, "shas"), "v3")), token_bucket_v3().sha);++ let patterns: Vec<String> = arr(get(&fixture, "keyPatterns")).iter().map(s).collect();+ let stale = keys_matching(&mut conn, &patterns).await;+ if !stale.is_empty() {+ let _: () = redis::cmd("DEL")+ .arg(&stale)+ .query_async(&mut conn)+ .await+ .unwrap();+ }++ let now_bits = Arc::new(AtomicU64::new(0));+ let clock: Clock = {+ let now_bits = now_bits.clone();+ Arc::new(move || f64::from_bits(now_bits.load(Ordering::SeqCst)))+ };+ let set_now = |ms: f64| now_bits.store(ms.to_bits(), Ordering::SeqCst);+ let redis: Arc<dyn TokenBucketRedis> = Arc::new(RedisTokenBucket::new(conn.clone()));++ let mut keyed: HashMap<String, KeyedRateLimiter> = HashMap::new();+ if let JsValue::Object(limiters) = get(&fixture, "keyedLimiters") {+ for (name, cfg) in limiters.iter() {+ let mut config = KeyedRateLimiterConfig::new(&s(get(cfg, "name")), KeyRoot::Test);+ config.ttl_seconds = opt_n(cfg, "ttlSeconds");+ config.script_version = if s(get(cfg, "scriptVersion")) == "v3" {+ ScriptVersion::V3+ } else {+ ScriptVersion::V2+ };+ keyed.insert(+ name.to_string(),+ KeyedRateLimiter::with_clock(config, redis.clone(), clock.clone()),+ );+ }+ }++ let mut logs: HashMap<String, LogsRateLimiter> = HashMap::new();+ if let JsValue::Object(limiters) = get(&fixture, "logsLimiters") {+ for (name, entry) in limiters.iter() {+ let c = get(entry, "config");+ let config = LogsRateLimiterConfig {+ team_bucket_size_kb: s(get(c, "LOGS_LIMITER_TEAM_BUCKET_SIZE_KB")),+ team_refill_rate_kb_per_second: s(get(+ c,+ "LOGS_LIMITER_TEAM_REFILL_RATE_KB_PER_SECOND",+ )),+ disabled_for_teams: s(get(c, "LOGS_LIMITER_DISABLED_FOR_TEAMS")),+ enabled_teams: s(get(c, "LOGS_LIMITER_ENABLED_TEAMS")),+ bucket_size_kb: n(get(c, "LOGS_LIMITER_BUCKET_SIZE_KB")),+ refill_rate_kb_per_second: n(get(c, "LOGS_LIMITER_REFILL_RATE_KB_PER_SECOND")),+ ttl_seconds: n(get(c, "LOGS_LIMITER_TTL_SECONDS")),+ };+ logs.insert(+ name.to_string(),+ LogsRateLimiter::new(+ config,+ redis.clone(),+ &s(get(entry, "name")),+ KeyRoot::Test,+ clock.clone(),+ ),+ );+ }+ }++ let rows: Vec<SamplingRuleRow> = arr(get(&fixture, "samplingRules"))+ .iter()+ .map(|r| SamplingRuleRow {+ id: s(get(r, "id")),+ rule_type: s(get(r, "rule_type")),+ scope_service: match get(r, "scope_service") {+ JsValue::Null => None,+ v => Some(s(v)),+ },+ scope_path_pattern: match get(r, "scope_path_pattern") {+ JsValue::Null => None,+ v => Some(s(v)),+ },+ scope_attribute_filters: get(r, "scope_attribute_filters").clone(),+ config: get(r, "config").clone(),+ version: None,+ })+ .collect();+ let rule_set = Arc::new(compile_rule_set(&rows).unwrap());+ let sampling = Arc::new(LogsSamplingService::new(+ redis.clone(),+ 600.0,+ KeyRoot::Test,+ clock.clone(),+ ));++ for (i, step) in arr(get(&fixture, "steps")).iter().enumerate() {+ set_now(n(get(step, "nowMs")));+ let expected = get(step, "output");+ match s(get(step, "kind")).as_str() {+ "keyed" => {+ let limiter = &keyed[&s(get(step, "limiter"))];+ let requests: Vec<KeyedRateLimitRequest> = arr(get(step, "requests"))+ .iter()+ .map(|r| KeyedRateLimitRequest {+ id: s(get(r, "id")),+ cost: n(get(r, "cost")),+ bucket_size: opt_n(r, "bucketSize"),+ refill_rate: opt_n(r, "refillRate"),+ ttl_seconds: opt_n(r, "ttlSeconds"),+ now: opt_n(r, "now"),+ })+ .collect();+ let out = if s(get(step, "method")) == "many" {+ limiter.rate_limit_many(&requests).await.unwrap()+ } else {+ limiter.rate_limit_grouped(&requests).await.unwrap()+ };+ let expected: Vec<(String, f64, f64, bool)> = arr(expected)+ .iter()+ .map(|pair| {+ let [id, r] = arr(pair) else { panic!("pair") };+ let JsValue::Bool(limited) = get(r, "isRateLimited") else {+ panic!("bool")+ };+ (+ s(id),+ n(get(r, "tokensBefore")),+ n(get(r, "tokens")),+ *limited,+ )+ })+ .collect();+ let actual: Vec<(String, f64, f64, bool)> = out+ .into_iter()+ .map(|(id, r)| (id, r.tokens_before, r.tokens, r.is_rate_limited))+ .collect();+ assert_eq!(actual, expected, "step {i}");+ }+ "logs" => {+ let limiter = &logs[&s(get(step, "limiter"))];+ let messages: Vec<(usize, Msg)> = arr(get(step, "messages"))+ .iter()+ .enumerate()+ .map(|(index, m)| {+ let created_at = match get(m, "createdAt") {+ JsValue::Null => None,+ v => Some(s(v).into_bytes()),+ };+ let msg = Msg {+ team: n(get(m, "teamId")) as i64,+ bytes: n(get(m, "bytesUncompressed")),+ created_at,+ };+ (index, msg)+ })+ .collect();+ struct Indexed(usize, Msg);+ impl RateLimitedMessage for Indexed {+ fn team_id(&self) -> i64 {+ self.1.team_id()+ }+ fn bytes_uncompressed(&self) -> f64 {+ self.1.bytes_uncompressed()+ }+ fn created_at_header(&self) -> Option<&[u8]> {+ self.1.created_at_header()+ }+ }+ let result = limiter+ .filter_messages(messages.into_iter().map(|(i, m)| Indexed(i, m)).collect())+ .await+ .unwrap();+ let indices =+ |v: &JsValue| arr(v).iter().map(|x| n(x) as usize).collect::<Vec<_>>();+ assert_eq!(+ result.allowed.iter().map(|m| m.0).collect::<Vec<_>>(),+ indices(get(expected, "allowed")),+ "step {i} allowed"+ );+ assert_eq!(+ result.dropped.iter().map(|m| m.0).collect::<Vec<_>>(),+ indices(get(expected, "dropped")),+ "step {i} dropped"+ );+ }+ "sampling" => {+ let records: Vec<LogRecord> = arr(get(step, "records"))+ .iter()+ .map(record_from_json)+ .collect();+ let team = n(get(step, "teamId")) as i64;+ let stage = sampling.make_sampling_stage(+ rule_set.clone(),+ Some(team),+ n(get(step, "headerBytes")),+ );+ let (kept, stats) = run_pipeline_stages(records, &[stage]).await.unwrap();+ let kept: Vec<String> =+ kept.iter().map(|r| r.uuid().unwrap().to_string()).collect();+ let expected_kept: Vec<String> = arr(get(expected, "kept")).iter().map(s).collect();+ assert_eq!(kept, expected_kept, "step {i} kept");+ let pairs = |v: &JsValue| {+ arr(v)+ .iter()+ .map(|p| {+ let [k, v] = arr(p) else { panic!("pair") };+ (s(k), n(v))+ })+ .collect::<Vec<_>>()+ };+ assert_eq!(+ stats.stage.records_dropped,+ n(get(expected, "recordsDropped"))+ );+ assert_eq!(+ stats.stage.records_dropped_by_rule_id.0,+ pairs(get(expected, "recordsDroppedByRuleId"))+ );+ assert_eq!(stats.stage.bytes_dropped, n(get(expected, "bytesDropped")));+ assert_eq!(+ stats.stage.bytes_dropped_by_rule_id.0,+ pairs(get(expected, "bytesDroppedByRuleId"))+ );+ assert_eq!(+ stats.stage.content_bytes_dropped,+ n(get(expected, "contentBytesDropped"))+ );+ assert_eq!(+ stats.content_bytes_total,+ n(get(expected, "contentBytesTotal"))+ );+ let dropped_by = match get(expected, "droppedBy") {+ JsValue::Null => None,+ v => Some(s(v)),+ };+ assert_eq!(stats.dropped_by, dropped_by, "step {i} droppedBy");+ }+ other => panic!("unknown step kind {other}"),+ }+ }++ let mut keys = keys_matching(&mut conn, &patterns).await;+ keys.sort();+ let JsValue::Object(expected_state) = get(&fixture, "finalState") else {+ panic!("finalState")+ };+ let expected_keys: Vec<String> = expected_state.keys().map(|k| k.to_string()).collect();+ assert_eq!(keys, expected_keys);+ for key in keys {+ let actual: HashMap<String, String> = redis::cmd("HGETALL")+ .arg(&key)+ .query_async(&mut conn)+ .await+ .unwrap();+ let expected: HashMap<String, String> = match expected_state.get(&key) {+ Some(JsValue::Object(o)) => o.iter().map(|(k, v)| (k.to_string(), s(v))).collect(),+ _ => panic!("state for {key}"),+ };+ assert_eq!(actual, expected, "bucket state of {key}");+ }+}diff --git a/rust/logs-ingestion/tests/re2_parity.rs b/rust/logs-ingestion/tests/re2_parity.rsnew file mode 100644index 000000000000..e1f9fe938b2a--- /dev/null+++ b/rust/logs-ingestion/tests/re2_parity.rs@@ -0,0 +1,59 @@+use std::path::PathBuf;++use logs_ingestion::js::{json_parse, JsValue};+use logs_ingestion::property_filter::re2::Re2;++fn get<'a>(v: &'a JsValue, key: &str) -> &'a JsValue {+ match v {+ JsValue::Object(o) => o.get(key).unwrap_or_else(|| panic!("missing {key}")),+ _ => panic!("not an object looking up {key}"),+ }+}++fn arr(v: &JsValue) -> &[JsValue] {+ match v {+ JsValue::Array(a) => a,+ other => panic!("not an array: {other:?}"),+ }+}++#[test]+fn re2_port_matches_node_re2() {+ let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/re2-reference.json");+ let fixture = json_parse(&std::fs::read_to_string(path).unwrap()).unwrap();+ // node-re2 writes a lone surrogate in the input as U+FFFD.+ let inputs: Vec<String> = arr(get(&fixture, "inputs"))+ .iter()+ .map(|v| v.as_js_string().unwrap().to_utf8_lossy().into_owned())+ .collect();+ let mut failures = Vec::new();+ let cases = arr(get(&fixture, "cases"));+ for case in cases {+ let pattern = get(case, "pattern").as_js_string().unwrap();+ let flags = get(case, "flags").as_js_string().unwrap().to_string();+ let compiles = get(case, "compiles") == &JsValue::Bool(true);+ let re = Re2::new(pattern.bytes_wtf8(), &flags);+ if re.is_ok() != compiles {+ failures.push(format!(+ "{pattern:?}/{flags}: compiles {} in Rust, {compiles} in node-re2 ({:?})",+ re.is_ok(),+ re.err()+ ));+ continue;+ }+ let Ok(re) = re else { continue };+ for (input, expected) in inputs.iter().zip(arr(get(case, "results"))) {+ let actual = re.test(input);+ if JsValue::Bool(actual) != *expected {+ failures.push(format!("{pattern:?}/{flags} on {input:?}: Rust {actual}"));+ }+ }+ }+ assert!(cases.len() > 300);+ assert!(+ failures.is_empty(),+ "{} mismatches:\n{}",+ failures.len(),+ failures.join("\n")+ );+}