feat(rivet-engine): udb key parser #3457

NathanFlurry · 2025-11-13T01:33:38Z

No description provided.

vercel · 2025-11-13T01:33:44Z

Deployment failed with the following error:

Too many requests - try again in 3 minutes (more than 120, code: "api-deployments-flood-pro").

Learn More: https://vercel.com/docs/limits#rate-limits

NathanFlurry · 2025-11-13T01:33:57Z

How to use the Graphite Merge Queue

Add the label merge-queue to this PR to add it to the merge queue.

You must have a Graphite account in order to use the merge queue. Sign up using this link.

_{An organization admin has enabled the Graphite Merge Queue in this repository.} _{Please do not merge from GitHub as this will restart CI on PRs being processed by the merge queue.}

This stack of pull requests is managed by Graphite. Learn more about stacking.

claude · 2025-11-13T01:44:47Z

PR Review: UDB Key Parser

Thanks for this contribution! This adds a useful CLI utility for decoding UniversalDB keys and parsing transaction conflict logs.

Strengths

Clear Purpose - The tool provides valuable debugging utilities for UDB keys and transaction conflicts
Good Error Handling - Proper use of anyhow::Context for error messages with helpful context
Follows Project Conventions - Uses anyhow::* imports correctly, structured logging in transaction_conflict_tracker.rs follows the pattern, hard tabs for formatting

Code Quality Observations

udb_keys.rs:

Line 36-38 - Redundant code, can simplify by returning decode_array(array) directly
Line 54-61 - Using match when ? operator would suffice
Line 84 - Consider using HashMap at the top-level imports instead of inline per CLAUDE.md
Logfmt Parser (lines 83-117) - The hand-rolled logfmt parser is fragile. Consider using a logfmt parsing crate like logfmt or logfmt-parse for robustness
Line 77 - Using contains() for log detection is inefficient for large files

transaction_conflict_tracker.rs:

Excellent Addition - The structured logging at lines 67-79 perfectly complements the new parser tool
Follows conventions - Lowercase message with structured fields

Potential Issues

Memory Concern - parse_conflicts() loads entire log files line-by-line, fields HashMap is recreated for every line
Error Recovery - When decoding fails, errors are printed but parsing continues (appropriate for debugging tool)
No Input Validation - The --file parameter doesn't check if file exists before attempting to open

Test Coverage

Missing unit tests for the new functionality. Consider adding:

Tests for decode_array() with valid and invalid JSON
Tests for decode_from_logfmt() with various input formats
Tests for the logfmt parser with edge cases

Performance Considerations

File reading is buffered (good)
String allocations in logfmt parser acceptable for CLI tool
Consider adding --limit flag to stop after N conflicts for very large logs

Security

No security concerns for a local debugging tool
File access is properly handled with error context

Minor Suggestions

Documentation - Add doc comments for public functions
CLI UX - Consider adding --verbose flag
Output Format - Consider adding --json output format

Test Script Changes

The changes to scripts/tests/actor_spam.ts and scripts/tests/utils.ts look good - making the key parameter optional is sensible.

Conclusion

This is a solid debugging utility that will be valuable for troubleshooting transaction conflicts. Main recommendations:

Add unit tests for the core parsing logic
Consider using a logfmt parsing library for robustness
Simplify error handling in a few places
Add top-level imports per project conventions

The transaction conflict logging addition is excellent and will make this tool very useful in production debugging scenarios.

Recommendation: Approve with minor improvements suggested above. The tool is functional and follows most project conventions.

vercel · 2025-11-13T02:47:16Z

The latest updates on your projects. Learn more about Vercel for GitHub.

Project	Deployment	Preview	Comments	Updated (UTC)
rivetkit-serverless	Error			Nov 13, 2025 10:28pm

3 Skipped Deployments

Project	Deployment	Preview	Updated (UTC)
rivet-cloud	Ignored		Nov 13, 2025 10:28pm
rivet-inspector	Ignored	Preview	Nov 13, 2025 10:28pm
rivet-site	Ignored	Preview	Nov 13, 2025 10:28pm

claude · 2025-11-13T03:02:03Z

PR Review: feat(rivet-engine): udb key parser

Summary

This PR adds a UDB key parsing utility for debugging and analyzing UniversalDB transaction conflicts. The implementation includes a CLI tool to decode UDB keys from byte arrays and parse transaction conflict logs.

Code Quality & Best Practices

Positive Aspects

Good use of structured error handling with anyhow::Context
Clear CLI interface with well-documented subcommands
Proper separation of concerns (decode vs parse functionality)
Good code organization following existing patterns

Issues & Suggestions

1. Import Pattern Inconsistency (Critical per CLAUDE.md)

Location: engine/packages/engine/src/commands/udb_keys.rs:6

The code uses: use anyhow::{Context, Result, bail};

But according to CLAUDE.md, the pattern should be: use anyhow::*;

Recommendation: Change to wildcard import to match project conventions.

2. Manual Logfmt Parser (Code Quality)

Location: engine/packages/engine/src/commands/udb_keys.rs:83-117

The manual logfmt parsing implementation is error-prone and doesn't handle edge cases properly:

Doesn't handle escaped equals signs in values
Doesn't handle quotes within quoted values
May have issues with complex nested structures

Recommendation: Consider using a proper logfmt parsing library (e.g., logfmt crate) instead of manual parsing.

3. Structured Logging Enhancement

Location: engine/packages/universaldb/src/driver/rocksdb/transaction_conflict_tracker.rs:67-79

The structured logging addition is excellent and follows CLAUDE.md guidelines! The use of ? debug formatting for byte arrays and separate fields for versions is correct.

Test Coverage

No tests detected for the new udb_keys module.

Recommendations:

Add unit tests for the decode_array function with various byte patterns
Add tests for the logfmt parser with edge cases
Add integration tests with sample log files
Test error cases (malformed JSON, invalid byte arrays, etc.)

Overall Assessment

Strengths:

Well-structured debugging utility
Good use of existing SimpleTuple infrastructure
Helpful transaction conflict logging enhancement
Clear CLI interface

Areas for Improvement:

Fix import patterns per CLAUDE.md conventions
Consider using a proper logfmt parsing library
Add comprehensive test coverage
Minor refactoring for more idiomatic Rust

Recommendation: Approve with minor changes

The core functionality is solid and will be valuable for debugging. The suggested improvements would enhance robustness and maintainability, but none are blocking issues.

claude · 2025-11-13T03:26:50Z

PR Review: UDB Key Parser

I've reviewed this PR and have the following feedback:

Positive Aspects

✅ Good Feature Addition: The UDB key parser provides a valuable debugging tool for analyzing transaction conflicts and decoding UniversalDB keys.

✅ Code Organization: The new command is well-integrated into the existing CLI structure, following the established patterns in the codebase.

✅ Documentation: Good use of doc comments on the CLI arguments explaining usage.

✅ Error Handling: Proper use of anyhow::Context for adding context to error messages throughout the code.

✅ Logging Enhancement: The addition of structured logging in transaction_conflict_tracker.rs:67-79 is excellent - it logs all the necessary information to debug conflicts.

Issues and Concerns

1. Logfmt Parser Implementation (Medium Priority)

The hand-rolled logfmt parser in udb_keys.rs:83-116 has potential bugs:

Line 92: The condition for handling quotes doesn't handle escaped quotes within quoted values
Line 90-111: The parser doesn't properly handle edge cases like values containing = characters inside quotes, empty values, or trailing spaces in keys

Recommendation: Consider using a proper logfmt parsing library like logfmt or logfmt-rs instead of a hand-rolled parser. If you must use a custom parser, add unit tests covering edge cases.

2. Missing Tests (High Priority)

The new module has zero test coverage. Given this is a debugging/operational tool, tests are important to ensure it correctly parses the logs it's meant to parse.

Recommendation: Add tests for decode_array(), decode_from_logfmt(), parse_conflicts() with sample log files, and logfmt parser edge cases.

3. Error Recovery in parse_conflicts() (Low Priority)

In udb_keys.rs:149-171, if decoding fails for one key, the error is printed but processing continues. This is good for robustness, but there's no indication in the summary output that some keys failed to decode.

Recommendation: Track failed decodes and include a count in the final summary.

4. Synchronous I/O in Async Context (Medium Priority)

The execute() method at lib.rs:52 calls opts.execute() which is synchronous, while all other command executors are async. The udb_keys command does synchronous file I/O in parse_conflicts().

Recommendation: For consistency with other commands, consider making execute() async and using tokio::fs for file operations.

5. Test Script Changes (Question)

The changes to scripts/tests/actor_spam.ts and scripts/tests/utils.ts seem unrelated to the UDB key parser feature. Are these changes intentional for this PR, or should they be in a separate commit/PR?

Security Considerations

✅ No security concerns identified. The tool only reads local log files, decodes data but doesn't modify any state, and uses safe parsing with proper error handling.

Performance Considerations

✅ Performance is appropriate for a CLI debugging tool - the logfmt parser processes line-by-line which is good for large files.

Recommendations Summary

Must Fix Before Merge:

Add tests for the new module (especially the logfmt parser)
Either fix the logfmt parser bugs or use a proper library

Should Fix:

Track and report failed key decodes in summary
Clarify why test script changes are included in this PR

Nice to Have:

Make the command async for consistency
Add test fixtures with sample conflict logs

Overall, this is a useful debugging feature, but needs test coverage before merging.

claude · 2025-11-13T21:12:34Z

PR Review: feat(rivet-engine): udb key parser

Summary

This PR adds a new CLI utility for debugging UniversalDB (UDB) keys by decoding byte arrays and parsing transaction conflict logs. The implementation is well-structured and follows Rust best practices with good error handling.

Code Quality ✅

Strengths:

Clean separation of concerns with dedicated functions for each subcommand
Proper error handling using anyhow::Context with descriptive error messages
Good use of existing infrastructure (SimpleTuple from util::udb)
Follows repository conventions (imports match CLAUDE.md guidance)
Structured logging added for transaction conflicts follows the project's tracing patterns

Code Organization:

The new command integrates well into the existing command structure
Uses workspace dependencies appropriately (anyhow, clap, serde_json)

Potential Issues ⚠️

Logfmt Parser Implementation (Medium Priority)
- Lines 84-115 in udb_keys.rs: The logfmt parser is hand-rolled and may not handle all edge cases
- Doesn't handle escaped quotes within quoted values
- Doesn't handle equals signs within values properly
- Recommendation: Consider using a proper logfmt parsing library like logfmt crate, or add more robust parsing logic with comprehensive edge case handling
Memory Safety in Log Parsing (Low Priority)
- Line 73-170: Reading entire log files line-by-line is fine for small files, but may be inefficient for very large log files
- Recommendation: Consider adding a note in the help text about this, or implementing pagination/streaming for very large files
Error Recovery (Low Priority)
- Lines 146-169: When decoding fails for a conflict range, the error is printed inline but processing continues
- This is actually good behavior, but could be more explicit
- Recommendation: Consider adding a counter for decode failures and reporting at the end
Type Safety (Low Priority)
- The SimpleTuple type from util/udb.rs is reused here, which is good for consistency
- However, the error handling when unpacking fails in decode_array could be more specific about what went wrong
- Recommendation: Consider adding more context about expected format when decode fails

Testing Concerns 🧪

Major Gap: No Tests

There are no tests for the new udb_keys command functionality
The logfmt parser especially needs unit tests given its complexity
Recommendation: Add unit tests for:
- decode_array() with various byte array formats
- decode_from_logfmt() with edge cases (empty arrays, malformed JSON, etc.)
- The logfmt parser with various input formats, escaped characters, and edge cases
- parse_conflicts() with sample log files (could use test fixtures)

Example test structure:

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_decode_array_valid() {
        let result = decode_array("[1, 2, 3]");
        assert!(result.is_ok());
    }

    #[test]
    fn test_decode_array_invalid_json() {
        let result = decode_array("not json");
        assert!(result.is_err());
    }

    #[test]
    fn test_logfmt_parser_basic() {
        // Test basic key=value parsing
    }

    #[test]
    fn test_logfmt_parser_quoted_values() {
        // Test quoted values with spaces
    }

    #[test]
    fn test_logfmt_parser_escaped_quotes() {
        // Test escaped quotes within quoted values
    }
}

Performance Considerations ⚡

The file reading uses BufReader which is good for I/O efficiency
The logfmt parsing allocates new strings for each field, which is acceptable for debugging tools
No obvious performance issues for a debugging utility

Security Considerations 🔒

File path input is properly validated by fs::File::open
JSON parsing uses serde_json which is safe
No obvious security vulnerabilities
However, consider:
- Recommendation: Add file size limits or warnings for very large log files to prevent memory exhaustion

Minor Observations

Inconsistent spacing in output (line 119): Using UTF-8 box drawing characters is nice for visual separation, but ensure they render properly in all terminal environments
Transaction conflict logging enhancement (transaction_conflict_tracker.rs:67-77):
- Great addition for debugging
- Follows structured logging patterns correctly per CLAUDE.md
- Uses lowercase messages as per convention ✅
- Uses ? debug formatting for byte arrays which is appropriate
Test utility changes (actor_spam.ts, utils.ts):
- The changes to make key optional are fine
- Consider documenting why withKey: false is needed in some test cases

Recommendations Summary

High Priority:

Add comprehensive unit tests for the parsing logic

Medium Priority:
2. Improve logfmt parser robustness or use a library
3. Add error handling documentation/counters

Low Priority:
4. Add file size warnings for large log files
5. Document test utility changes

Verdict

This is solid debugging utility that will be valuable for troubleshooting UDB transaction conflicts. The main gap is test coverage. I'd recommend adding tests before merging, especially for the logfmt parser since it handles user input and has complex parsing logic.

The logging enhancement to transaction_conflict_tracker.rs is excellent and will make these debug tools much more useful.

Suggested Action: Add unit tests for the parsing functions, then approve for merge.

graphite-app · 2025-11-13T21:34:18Z

Merge activity

Nov 13, 9:34 PM UTC: The Graphite merge queue removed this pull request due to downstack failures on PR #3441.
Nov 13, 9:34 PM UTC: NathanFlurry added this pull request to the Graphite merge queue.
Nov 13, 9:37 PM UTC: The Graphite merge queue removed this pull request due to downstack failures on PR #3441.
Nov 13, 9:38 PM UTC: NathanFlurry added this pull request to the Graphite merge queue.
Nov 13, 9:43 PM UTC: NathanFlurry added this pull request to the Graphite merge queue.
Nov 13, 9:43 PM UTC: The Graphite merge queue removed this pull request due to downstack failures on PR #3441.
Nov 13, 10:05 PM UTC: NathanFlurry added this pull request to the Graphite merge queue.
Nov 13, 10:05 PM UTC: The Graphite merge queue removed this pull request due to downstack failures on PR #3441.
Nov 13, 10:11 PM UTC: NathanFlurry added this pull request to the Graphite merge queue.
Nov 13, 10:12 PM UTC: The Graphite merge queue removed this pull request due to downstack failures on PR #3442.

claude · 2025-11-13T21:41:34Z

Code Review

This PR adds a new UDB key parser utility for debugging transaction conflicts. The implementation is generally solid, but I've identified several areas for improvement:

Strengths ✅

Clear Purpose: The tool addresses a real debugging need for transaction conflicts
Good Logging Integration: The transaction conflict tracker logging (lines 67-79 in transaction_conflict_tracker.rs) follows the structured logging patterns from CLAUDE.md
Proper Error Handling: Uses anyhow::Result and .with_context() appropriately
Command Structure: Well-organized CLI subcommands with good documentation

Issues & Recommendations 🔍

1. Manual logfmt Parsing (High Priority)

Location: udb_keys.rs:83-117

The manual logfmt parser is fragile and error-prone:

Doesn't handle escaped quotes properly
No handling of backslash escapes
Edge cases with malformed input could cause silent failures

Recommendation: Use an existing logfmt parsing library like logfmt crate:

use logfmt::parse;

let fields: HashMap<String, String> = parse(&line)
    .filter_map(Result::ok)
    .map(|(k, v)| (k.to_string(), v.to_string()))
    .collect();

2. Import Style Inconsistency

Location: udb_keys.rs:1-9

The imports should be at the top of the file and follow the crate's import patterns. According to CLAUDE.md:

Always add imports at the top of the file inside of inline within the function.

Current code is correct, but ensure all necessary imports are included (currently missing std::collections::HashMap which is implicitly used via fully qualified path).

3. Error Context Could Be More Specific

Location: udb_keys.rs:195

.with_context(|| "Failed to decode key")?;

This should include the actual value being decoded for better debugging:

.with_context(|| format!("failed to decode key from bytes: {}", value))?;

Note: Following CLAUDE.md convention of lowercase messages.

4. Missing Unit Tests

Recommendation: Add tests for:

decode_array() with various input formats
decode_from_logfmt() with edge cases (empty arrays, malformed JSON)
The logfmt parser with escaped characters

Example test structure:

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_decode_array_valid() {
        let result = decode_array("[20, 21, 1, 21, 2]");
        assert!(result.is_ok());
    }

    #[test]
    fn test_decode_array_invalid_json() {
        let result = decode_array("not json");
        assert!(result.is_err());
    }
}

5. Code Duplication

Locations: udb_keys.rs:48-64 and udb_keys.rs:185-200

Both decode_array() and decode_from_logfmt() have very similar logic. Consider extracting:

fn decode_tuple_from_json(json_str: &str) -> Result<SimpleTuple> {
    let bytes: Vec<u8> = serde_json::from_str(json_str)
        .with_context(|| format!("failed to parse array as JSON: {}", json_str))?;
    
    universaldb::tuple::unpack::<SimpleTuple>(&bytes)
        .with_context(|| format!("failed to decode key from bytes: {}", json_str))
}

6. Magic Numbers in Formatting

Location: udb_keys.rs:120-122

The separator characters (═) are hardcoded. Consider using a constant:

const SEPARATOR: &str = "═══════════════════════════════════════════════════════════";
println!("\n{}", SEPARATOR);

Minor Issues 📝

Unused bail! macro style: Line 59 uses bail! which is fine, but ensure it is imported from anyhow (it is)
Test script changes: The changes to actor_spam.ts and utils.ts are minor but good - adding the withKey parameter provides flexibility for testing. The default value true maintains backward compatibility.
Transaction conflict logging: The structured logging is excellent and follows patterns correctly with ?cr1_start syntax for debug formatting.

Security Considerations 🔒

No security concerns identified. The tool:

Only reads local log files (user provides path)
Doesn't write to disk except stdout
Input validation is present (JSON parsing, file opening)

Performance Considerations ⚡

File reading: Uses BufReader - good for large files ✅
String allocations: The manual parser does many small allocations. Using a proper logfmt library would be more efficient
Regex consideration: For production use with large log files, consider using regex crate for field extraction instead of manual parsing

Suggested Next Steps

Replace manual logfmt parser with a proper library
Add unit tests covering edge cases
Extract common decoding logic to reduce duplication
Improve error messages with more context
Consider adding integration tests using the existing test infrastructure

Overall Assessment

This is a useful debugging tool with a solid foundation. The main concern is the manual logfmt parser which could lead to bugs. With the suggested improvements, this will be a valuable addition to the debugging toolkit.

Recommendation: Approve with changes requested for the logfmt parsing issue.

… provided

claude · 2025-11-13T22:32:08Z

Code Review

Thank you for this PR! This is a useful debugging utility for analyzing UDB keys and transaction conflicts. Below is my detailed feedback:

Positive Aspects

Useful debugging tool - This addresses a real need for inspecting and understanding transaction conflicts in production logs
Good command structure - The clap-based CLI structure is consistent with the rest of the codebase
Enhanced logging - The added structured logging provides valuable debugging information

Issues Found

Critical Issues

Logfmt parser is fragile and incorrect (udb_keys.rs:83-117)
- The hand-rolled logfmt parser doesn't handle many edge cases: escaped characters within quoted values, empty values, values with = signs inside quotes, multiple consecutive spaces
- Recommendation: Use a proper logfmt parsing library like logfmt crate instead of hand-rolling a parser
Silent error handling (udb_keys.rs:149-171)
- Errors are printed but execution continues, potentially hiding important issues
- Recommendation: Consider collecting errors and reporting a summary, or make it more obvious when decoding fails

Moderate Issues

Inefficient string building (udb_keys.rs:90-111)
- Using String::push in a loop is less efficient
- Recommendation: Consider using a proper parser
Missing error context
- When decoding fails, the error messages could be more helpful
- Recommendation: Add more context about what was being decoded
Hardcoded message matching (udb_keys.rs:77)
- This is brittle - if the log message format changes, the parser breaks
- Recommendation: Consider making this configurable or using a regex pattern

Minor Issues

Inconsistent error handling patterns
- decode_array uses bail! after matching on Err
- decode_from_logfmt uses .with_context()
- Recommendation: Use ? directly in decode_array for consistency
Test file changes seem unrelated (scripts/tests/)
- The changes to add an optional withKey parameter appear unrelated to the UDB key parser
- Recommendation: Consider moving these changes to a separate PR
Missing documentation
- The new command would benefit from usage examples
- Recommendation: Add examples to the doc comments

Code Style

Formatting alignment follows the codebase style well with hard tabs ✓
Import organization is proper ✓
Error handling patterns generally follow the anyhow pattern ✓

Suggestions for Improvement

Add unit tests for decode_array, logfmt parser edge cases, and error handling paths
Consider streaming for large files
Add usage examples in command help

Security & Performance

No security issues identified ✓
File reading is appropriately buffered ✓
Line-by-line processing is memory efficient ✓

Recommendation

Request Changes - The hand-rolled logfmt parser is the main concern. Please consider using a proper parsing library to ensure robustness. The other issues are minor and can be addressed in follow-up work if needed.

claude · 2025-11-13T22:32:42Z

PR Review: feat(rivet-engine): udb key parser

Summary

This PR adds a new CLI utility for parsing and decoding UniversalDB keys, with special support for analyzing transaction conflict logs.

Code Quality & Best Practices

Strengths:

Good use of structured logging with tracing
Proper error handling with anyhow::Context
Clear separation of concerns
Leverages existing SimpleTuple infrastructure

Issues Found:

1. Custom Logfmt Parser is Fragile (Medium Priority)

Location: engine/packages/engine/src/commands/udb_keys.rs:83-116

The hand-rolled logfmt parser has issues:

Doesn't handle escaped quotes properly
May fail on edge cases with nested quotes
Consider using a proper logfmt parsing library

2. Missing Error Recovery (Low Priority)

Location: engine/packages/engine/src/commands/udb_keys.rs:73

If reader.lines() encounters invalid UTF-8, parsing stops. Consider skipping invalid lines and continuing.

3. Performance: Repeated String Allocations (Low Priority)

Location: engine/packages/engine/src/commands/udb_keys.rs:98-99

Using clone() on every field insertion creates unnecessary allocations. Consider using std::mem::take().

Test Coverage

Missing:

No unit tests for decode_array()
No unit tests for parse_conflicts()
No unit tests for the logfmt parser
No integration tests for CLI commands

Recommendations:

Add unit tests for the logfmt parser with edge cases
Add tests for decode_array with various tuple types
Add tests for decode_from_logfmt error paths

Additional Observations

The transaction conflict logging enhancement (transaction_conflict_tracker.rs:67-79) is excellent and follows CLAUDE.md guidelines perfectly. Minor suggestion: Consider if this should be tracing::warn! instead of info! since conflicts may indicate contention issues.

Verdict

This is a solid utility addition. Main concerns:

Custom logfmt parser fragility - highest priority
Missing test coverage - important for a parsing tool
Minor error handling improvements

Recommended Actions

Before Merge:

Add basic unit tests for the logfmt parser
Consider using a logfmt library or add extensive parser tests

Future Improvements:

Add comprehensive test suite
Document the expected logfmt format

Overall: Good work on this debugging utility! The structured logging enhancement is particularly valuable.

NathanFlurry mentioned this pull request Nov 13, 2025

chore(website): flatten actors docs structure #3280

Open

NicholasKissel mentioned this pull request Nov 13, 2025

chore: create branch for v3 website changes on v2 #3304

Open

NathanFlurry requested a review from MasterPtato November 13, 2025 02:45

NathanFlurry force-pushed the 11-12-feat_rivet-engine_udb_key_parser branch from 72318fc to cc00181 Compare November 13, 2025 02:47

vercel bot had a problem deploying to Preview – rivetkit-serverless November 13, 2025 02:47 Failure

NathanFlurry force-pushed the 11-11-fix_rivetkit_fix_zod_not_validating_body_if_content-type_header_not_provided branch from 6cb921c to b49dcfa Compare November 13, 2025 03:24

NathanFlurry force-pushed the 11-12-feat_rivet-engine_udb_key_parser branch from cc00181 to 3777832 Compare November 13, 2025 03:24

vercel bot had a problem deploying to Preview – rivetkit-serverless November 13, 2025 03:24 Failure

This was referenced Nov 13, 2025

chore(rivetkit-typescript): remove dependency on node modules #3460

Merged

chore(rivetkit): switch dynamic node imports to use require #3461

Merged

MasterPtato mentioned this pull request Nov 13, 2025

fix: improve sigterm handling for the entire runtime #3443

Merged

NathanFlurry mentioned this pull request Nov 13, 2025

feat(gateway): websocket hibernation #3400

Merged

This was referenced Nov 13, 2025

fix(pb): dont immediately reallocate actors on runner stopping #3413

Merged

fix(guard): dont send open msg for hibernating ws, hibernating ws keepalive #3449

Merged

NathanFlurry mentioned this pull request Nov 13, 2025

chore(gas): rename wake sub to bump sub #3408

Merged

jog1t mentioned this pull request Nov 13, 2025

refactor: performance improvements for inspector #3452

Draft

MasterPtato approved these changes Nov 13, 2025

View reviewed changes

NathanFlurry force-pushed the 11-12-feat_rivet-engine_udb_key_parser branch from 4a21d4f to b2a85f4 Compare November 13, 2025 20:53

vercel bot had a problem deploying to Preview – rivetkit-serverless November 13, 2025 20:54 Failure

NathanFlurry mentioned this pull request Nov 13, 2025

chore(rivetkit): implement new hibernating ws protocol #3464

Open

NathanFlurry force-pushed the 11-11-fix_rivetkit_fix_zod_not_validating_body_if_content-type_header_not_provided branch from 0449f4b to ec9ddfa Compare November 13, 2025 21:39

NathanFlurry force-pushed the 11-12-feat_rivet-engine_udb_key_parser branch from b2a85f4 to 43a2a61 Compare November 13, 2025 21:39

vercel bot had a problem deploying to Preview – rivetkit-serverless November 13, 2025 21:40 Failure

NathanFlurry mentioned this pull request Nov 13, 2025

feat(cloudflare-workers): add createInlineClient #3466

Open

NathanFlurry added 5 commits November 13, 2025 14:27

chore(rivetkit-typescript): remove dependency on node modules

ec6a9cb

chore(rivetkit): switch dynamic node imports to use require

3ece7ec

fix(rivetkit): fix onError handler not working

18c686e

fix(rivetkit): fix zod not validating body if content-type header not…

3c2f399

… provided

feat(rivet-engine): udb key parser

6c6242e

NathanFlurry force-pushed the 11-12-feat_rivet-engine_udb_key_parser branch from 43a2a61 to 6c6242e Compare November 13, 2025 22:27

NathanFlurry force-pushed the 11-11-fix_rivetkit_fix_zod_not_validating_body_if_content-type_header_not_provided branch from ec9ddfa to 3c2f399 Compare November 13, 2025 22:27

vercel bot had a problem deploying to Preview – rivetkit-serverless November 13, 2025 22:28 Failure

Base automatically changed from 11-11-fix_rivetkit_fix_zod_not_validating_body_if_content-type_header_not_provided to main November 13, 2025 22:33

NathanFlurry merged commit e857af3 into main Nov 13, 2025
8 of 14 checks passed

NathanFlurry deleted the 11-12-feat_rivet-engine_udb_key_parser branch November 13, 2025 22:34

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

feat(rivet-engine): udb key parser #3457

feat(rivet-engine): udb key parser #3457

Uh oh!

NathanFlurry commented Nov 13, 2025

Uh oh!

vercel bot commented Nov 13, 2025

Uh oh!

NathanFlurry commented Nov 13, 2025 •

edited

Loading

Uh oh!

claude bot commented Nov 13, 2025

Uh oh!

vercel bot commented Nov 13, 2025 •

edited

Loading

Uh oh!

claude bot commented Nov 13, 2025

Uh oh!

claude bot commented Nov 13, 2025

Uh oh!

claude bot commented Nov 13, 2025

Uh oh!

graphite-app bot commented Nov 13, 2025 •

edited

Loading

Uh oh!

claude bot commented Nov 13, 2025

Uh oh!

claude bot commented Nov 13, 2025

Uh oh!

claude bot commented Nov 13, 2025

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

feat(rivet-engine): udb key parser #3457

feat(rivet-engine): udb key parser #3457

Uh oh!

Conversation

NathanFlurry commented Nov 13, 2025

Uh oh!

vercel bot commented Nov 13, 2025

Uh oh!

NathanFlurry commented Nov 13, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

How to use the Graphite Merge Queue

Uh oh!

claude bot commented Nov 13, 2025

PR Review: UDB Key Parser

Strengths

Code Quality Observations

Potential Issues

Test Coverage

Performance Considerations

Security

Minor Suggestions

Test Script Changes

Conclusion

Uh oh!

vercel bot commented Nov 13, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

claude bot commented Nov 13, 2025

PR Review: feat(rivet-engine): udb key parser

Summary

Code Quality & Best Practices

Positive Aspects

Issues & Suggestions

1. Import Pattern Inconsistency (Critical per CLAUDE.md)

2. Manual Logfmt Parser (Code Quality)

3. Structured Logging Enhancement

Test Coverage

Overall Assessment

Uh oh!

claude bot commented Nov 13, 2025

PR Review: UDB Key Parser

Positive Aspects

Issues and Concerns

1. Logfmt Parser Implementation (Medium Priority)

2. Missing Tests (High Priority)

3. Error Recovery in parse_conflicts() (Low Priority)

4. Synchronous I/O in Async Context (Medium Priority)

5. Test Script Changes (Question)

Security Considerations

Performance Considerations

Recommendations Summary

Uh oh!

claude bot commented Nov 13, 2025

PR Review: feat(rivet-engine): udb key parser

Summary

Code Quality ✅

Potential Issues ⚠️

Testing Concerns 🧪

Performance Considerations ⚡

Security Considerations 🔒

Minor Observations

Recommendations Summary

Verdict

Uh oh!

graphite-app bot commented Nov 13, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Merge activity

Uh oh!

claude bot commented Nov 13, 2025

Code Review

Strengths ✅

Issues & Recommendations 🔍

1. Manual logfmt Parsing (High Priority)

2. Import Style Inconsistency

3. Error Context Could Be More Specific

4. Missing Unit Tests

5. Code Duplication

6. Magic Numbers in Formatting

Minor Issues 📝

Security Considerations 🔒

NathanFlurry commented Nov 13, 2025 •

edited

Loading

vercel bot commented Nov 13, 2025 •

edited

Loading

graphite-app bot commented Nov 13, 2025 •

edited

Loading