Skip to content

fix: manual marshaling, consumer->provider (do not merge) #2175

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
Tomelia1999 wants to merge 1 commit into
base: main
Choose a base branch
from
Open

fix: manual marshaling, consumer->provider (do not merge) #2175

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
75 changes: 75 additions & 0 deletions protocol/chainlib/chainproxy/rpcInterfaceMessages/jsonRPCMessage.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -90,6 +90,81 @@ func ConvertJsonRPCMsg(rpcMsg *rpcclient.JsonrpcMessage) (*JsonrpcMessage, error
return msg, nil
}

// MarshalWithRawResult builds the JSON response manually without re-encoding the Result field.
// This is critical for large responses like debug_traceTransaction where Result can be 100MB+.
//
// Why this matters:
// - json.Marshal() on a struct with json.RawMessage triggers go-json's compact operations
// - compactString is called for EVERY string in the Result, causing 3-4x memory overhead
// - For a 100MB trace response, this creates 400MB+ peak memory usage
//
// By manually constructing the JSON, we:
// 1. Avoid all compact operations (compactString, compactValue, compactArray, compactObject)
// 2. Reduce memory usage by 50-70%
// 3. Prevent OOM on concurrent large responses
func (jm *JsonrpcMessage) MarshalWithRawResult() ([]byte, error) {
// For error responses or empty results, use standard marshal (small payloads)
if jm.Error != nil || len(jm.Result) == 0 {
return json.Marshal(jm)
}

// Pre-calculate buffer size to avoid reallocations
// JSON format: {"jsonrpc":"2.0","id":XXX,"result":YYY}
// Base overhead: ~30 bytes for structure
estimatedSize := 30 + len(jm.ID) + len(jm.Result)

buf := make([]byte, 0, estimatedSize)
buf = append(buf, `{"jsonrpc":"2.0","id":`...)

if len(jm.ID) > 0 {
buf = append(buf, jm.ID...)
} else {
buf = append(buf, "null"...)
}

buf = append(buf, `,"result":`...)
buf = append(buf, jm.Result...) // Direct byte copy - NO re-encoding!
buf = append(buf, '}')

return buf, nil
}

// MarshalBatchWithRawResults marshals a batch of JSON-RPC messages without re-encoding Result fields.
// This provides the same memory optimization as MarshalWithRawResult but for batch responses.
func MarshalBatchWithRawResults(msgs []JsonrpcMessage) ([]byte, error) {
if len(msgs) == 0 {
return []byte("[]"), nil
}

// Estimate total size: brackets + commas + all messages
totalSize := 2 // for [ and ]
for i := range msgs {
totalSize += 30 + len(msgs[i].ID) + len(msgs[i].Result)
if i > 0 {
totalSize++ // comma
}
}

buf := make([]byte, 0, totalSize)
buf = append(buf, '[')

for i := range msgs {
if i > 0 {
buf = append(buf, ',')
}

// Use individual message serialization
msgBytes, err := msgs[i].MarshalWithRawResult()
if err != nil {
return nil, err
}
buf = append(buf, msgBytes...)
}

buf = append(buf, ']')
return buf, nil
}

func ConvertBatchElement(batchElement rpcclient.BatchElemWithId) (JsonrpcMessage, error) {
var JsonError *rpcclient.JsonError
var ok bool
Expand Down
10 changes: 8 additions & 2 deletions protocol/chainlib/jsonRPC.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -685,7 +685,10 @@ func (cp *JrpcChainProxy) sendBatchMessage(ctx context.Context, nodeMessage *rpc
batch[idx].Result = nil
}

retData, err := json.Marshal(replyMsgs)
// Use MarshalBatchWithRawResults to avoid go-json's expensive compact operations.
// This bypasses compactString/compactValue which cause 3-4x memory overhead
// for large responses like debug_traceTransaction.
retData, err := rpcInterfaceMessages.MarshalBatchWithRawResults(replyMsgs)
if err != nil {
return nil, err
}
Expand Down Expand Up @@ -807,7 +810,10 @@ func (cp *JrpcChainProxy) SendNodeMsg(ctx context.Context, ch chan interface{},
rpcMessage.Result = nil
rpcMessage = nil

retData, err := json.Marshal(replyMsg)
// Use MarshalWithRawResult to avoid go-json's expensive compact operations.
// This bypasses compactString/compactValue which cause 3-4x memory overhead
// for large responses like debug_traceTransaction.
retData, err := replyMsg.MarshalWithRawResult()
if err != nil {
return nil, "", nil, err
}
Expand Down
Loading