Skip to content
TheChatArchiveThe Chat Archive
gpt-5.6-sol· openaiHugging Face ibragim-bad/swe_rebench_07_2026_trajectories

ISSUE DESCRIPTION gRPC ManagedChannelImpl log messages contain unsubstituted…

  1. User

    ISSUE DESCRIPTION

    gRPC ManagedChannelImpl log messages contain unsubstituted placeholders Affected version: ArcadeDB server 26.4.2 Component: logging — bridge between gRPC's java.util.logging and the server's SLF4J/Logback backend

    Summary

    Some WARNING messages emitted by gRPC's ManagedChannelImpl are written to the ArcadeDB server log with the original MessageFormat placeholders ({0}, {1}) left literal instead of being substituted with the actual values.

    Example

    2026-05-21 06:53:11.234 WARNI [ManagedChannelImpl] [{0}] Failed to resolve name. status={1} 2026-05-21 06:53:11.234 WARNI [ManagedChannelImpl] [{0}] Failed to resolve name. status={1}

    Expected (illustrative):

    WARNI [ManagedChannelImpl] [channel-7] Failed to resolve name. status=UNAVAILABLE: Unable to resolve host vcc-superx-arcadedb-2.…

    Root cause (suspected)

    gRPC's internal loggers use java.util.logging with MessageFormat-style placeholders. The bridge that forwards JUL records to the ArcadeDB logging backend (SLF4J/Logback) is not translating {0}, {1} parameters into the SLF4J {} style, so the parameter array is dropped and the raw template ends up in the log file. Confirmation: the same logical event is also logged elsewhere (via GrpcLogAppender / AppendLogResponseHandler) with the full formatted message, so the data exists — it's just lost on the ManagedChannelImpl path.

    Impact

    Low severity but operationally annoying — these log lines carry zero information, so anyone scanning logs for the actual channel and gRPC status gets a stream of [{0}] Failed to resolve name. status={1} that they then have to correlate with neighbouring lines.

    Suggested fix

    Either:

    • Install SLF4JBridgeHandler (org.slf4j:jul-to-slf4j) and ensure it translates JUL LogRecord.parameters via MessageFormat.format(...) before delegating to SLF4J; or
    • Configure a JUL Handler for the io.grpc logger that uses a SimpleFormatter-compatible formatter so parameters are substituted before the message reaches the SLF4J side.

    Environment

    • ArcadeDB 26.4.2, default packaging
    • Logs viewed via kubectl logs; same behaviour observed across all 3 HA pods

    ADDITIONAL ADVICE

    Since you are given a git repository, you can use git commands to simplify your work. For example, if you made a mistake and want to revert your changes, you can use git checkout <file> to restore the file to its original state. You can also reset all changes in the repository using git reset --hard command. Additionally, you can use git stash and git stash pop to temporarily save your changes and restore them later. Finally, you can see the changes that you've made (which will be submitted when you call submit) using git status or git diff commands. However you don't need to use git add or git commit before submitting your changes. In fact, submit only submits currently unstaged changes because it uses git diff to get the changes that need to be submitted.

    CHECKLIST

    Before submitting your solution, please go over the following checklist and make sure you've done everything:

    • If an error was reported in the issue description, I have successfully reproduced it.
    • If an error was reported in the issue description, I have confirmed that my fix resolves the error.
    • I have thought about edge cases and made sure my fix handles them as well.
    • I have run existing tests in the repository that might have been affected by the change I made and confirmed that they pass. I want you to list every bullet from this checklist and write your reasoning for why you think you did it or didn't need to.

    Repository has been uploaded and your shell is currently at the repository root. Time to solve the issue!

    (Current directory: /arcadedb, current file: none) bash-$

  2. Assistant

    I’ll first locate the logging bridge and its tests/dependencies, then reproduce the formatting loss with the smallest relevant test path before changing implementation. After the fix, I’ll run focused and broader tests and inspect the final diff.

  3. Assistant

    ripgrep is unavailable, so I’ll use grep to search Java sources and Maven descriptors for the bridge implementation and related dependencies.

  4. Assistant

    The repository’s core logger itself wraps JUL, while the reported server backend likely supplies a separate Logger implementation. I’ll inspect all logger classes and server-side registrations, plus formatter behavior, to identify exactly where JUL parameters disappear.

  5. Assistant

    LogFormatter is the likely faulty bridge endpoint: it formats LogRecord.parameters using Java’s %-style String.formatted, whereas external JUL producers such as gRPC use MessageFormat ({0}). ArcadeDB-originated messages are preformatted before becoming LogRecords, explaining why only gRPC is affected. I’ll inspect configuration and tests around this formatter, and confirm the bug with a standalone LogRecord invocation.

  6. Assistant

    The standalone reproduction could not run because this checkout has not yet built engine, but source inspection establishes the defect: LogFormatter bypasses java.util.logging.Formatter.formatMessage, the standard method that performs resource-bundle lookup and MessageFormat parameter substitution. Before editing, I’ll check whether any repository code depends on the formatter’s nonstandard %s handling and inspect AnsiLogFormatter, which likely shares this path.

  7. Assistant

    Both production handlers are affected: file output uses LogFormatter, while kubectl logs uses AnsiLogFormatter, and both duplicate the same incorrect % formatting. Repository callers of ArcadeDB’s own API are safe because DefaultLogger resolves % placeholders before creating JUL records; direct JUL parameter records should follow JUL’s {n} contract. I’ll update both formatters to call inherited formatMessage(LogRecord), which also correctly handles localization and safely falls back for malformed patterns.

  8. Assistant

    Python is also unavailable, so no files were changed. I’ll apply the same focused substitutions using the repository’s replace utility, then validate whitespace and inspect the diff.

  9. Assistant

    The diff now routes both output paths through standard JUL formatting with no dependency changes. Next I’ll compile and run the focused engine test suite; once classes exist, I’ll run a temporary JShell reproduction against both formatters, including a malformed/no-placeholder edge case.

  10. Assistant

    The Maven wrapper requires HOME, which this environment leaves unset; no compile or tests ran. I’ll rerun with a temporary home and a concise focused command.

  11. Assistant

    Compilation succeeded and all four existing LoggerTest cases passed. I’ll now directly compare the former algorithm (String.formatted(parameters)) with both corrected production formatters using the reported template, and verify that records without parameters and invalid MessageFormat text remain usable.

  12. Assistant

    The direct reproduction confirms the old code emits literal {0}/{1}, while both corrected console and file formatters substitute the channel and status. Literal and malformed messages also remain intact. I’ll perform final repository checks for unintended generated changes, review the complete diff, and run the engine formatting/validation phase if one is configured.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.