On the morning of November 13, nine calls to our server failed in a row. Our logs for that morning had zero errors in them. No 5xx all day. Both of those things were true at once, and it took us most of that day to understand how. I build Since, which tracks the packages, AI models, APIs and runtime
s your code depends on, tells you and your coding agent what changed and when it breaks, and opens the fix pull request. One way people use it is as a connector inside an AI assistant: the assistant calls Since's tools (check_code, whats_changed) over MCP, the protocol assistants use to call tools. This is the story of that connector going quiet for two and a half hours, and of what "no errors" turned out to mean. Every morning a job of ours uses the connector to check open source repositories for code that is about to break.
On November 13, from 6:14 to about 8:50 AM MST, every signed-in call through the connector failed. Nine tries, none answered. The client showed us a small zoo of messages: "The connector's server returned an error" (4 times) "Tool execution failed" (3) "Connection closed" (1) "Tool call timed out waiting for server response" (1) Five different words for "no". This is the part that made it hard.
While the connector was failing, the job checked everything around it: The health endpoint answered {"ok":true}. The public calendar answered 200 in under a second. An unsigned POST to the MCP endpoint answered 401 in 0.2 seconds, with the right sign-in message. A public scan page loaded. The assistant's own settings listed the connector as "connected", with 3 tools, the whole time. Then, at 8:54 AM, a call worked. Every call after it worked too. Nobody had changed anything.
An outage that heals itself and leaves no error is the worst kind. You can't fix what you can't see, and it's very tempting to write "transient" in the notes and move on. The job that hit this can't read production logs, so it wrote down what it saw and said plainly what it didn't know: "whether the fault is in Since's signed-in MCP path or in the client's connection to it." My first instinct was the second one. It's the client's side.
Our health check is green, our other endpoints answer, the unsigned path answers instantly. The server is fine. That instinct was built entirely on the error log being empty. And the error log was empty because of what we had decided counts as an error.
When I stopped searching for errors and just counted every status line on that path, the pattern was right there. Every call from that assistant's connector went like this: POST /mcp 400 POST /mcp 200 Every single one. Refused first, then accepted. Not only during the bad stretch: all day, before 8:54 and after it.
A 400 isn't an error in most logging setups. It's the client's fault by definition, so it gets logged at info level and nobody looks at it. Which is how our server was refusing every first attempt from a client we very much want to work, and our monitoring called that a clean day. Here's the kind of count that would have found it in a minute.
The log below is made up, in the shape of ours: from collections import Counter # A made-up log in the shape of ours: one line per request. log = """\ POST /mcp 400 POST /mcp 200 POST /mcp 400 POST /mcp 200 GET /v1/calendar 200 POST /mcp 400 POST /mcp 200 GET /healthz 200 """ lines = [l.split() for l in log.splitlines()] print(Counter((path, status) for _, path, status in lines)) # What came right before each success on the same path? before = Counter() for prev, cur in zip(lines, lines[1:]): if cur[1] == prev[1] and cur[2] == "200": before[prev[2]] += 1 print("status before a 200 on the same path:", dict(before)) What it printed: Counter({('/mcp', '400'): 3, ('/mcp', '200'): 3, ('/v1/calendar', '200'): 1, ('/healthz', '200'): 1}) status before a 200 on the same path: {'400': 3} Half the calls on one path are refusals, and every success follows one. No error anywhere.
MCP has dated protocol revisions. Our server spoke two of them, 2025-06-18 and 2025-11-25, both of which open with a handshake. The connector spoke a newer one, 2026-07-28, which is stateless and skips the handshake. So every call arrived in a revision our server didn't speak.
The server said 400, the client fell back to an older revision, and the second try worked. Every call depended on the client being polite enough to retry. The part I'm least proud of: this wasn't an accident. We had decided not to build that revision yet.
We even had a test that pinned it as unsupported. The test passed every day. It was checking that we refused, which we did, perfectly. And when we refused, we did it badly.
The refusal wasn't in the shape that revision defines, a discovery method it expects was missing, and nothing logged why a request was refused. So the only trace was a bare 400 in an info line. Once I was reading status lines instead of error lines, a second pattern showed up: 192 failed health checks in 7 days. Every one of them happened during a public scan.
A scan read a repository's files in one long stretch on the server's main thread. Locally, that stretch took 6.9 seconds for one repository. In production one call held it for 23 seconds. The health check has 5 seconds to answer.
While it fails, connections get dropped for every caller, not just the one scanning. "Connection closed." "Timed out waiting for server response." Two of our five words for "no". Here's the honest bit. I don't know for certain which of the two caused that morning. The refusal-then-fallback was there all day, including the hours after 8:54 when every call worked. The dropped connections were there during scans, and our morning job runs scans. Either one alone could produce some of those nine failures. Both together explain them better than either does.
I'd love to give you a clean root cause. What I have is two real defects that the error log hid, found in the same hour by reading the same lines differently. So we fixed both, the same day: The server now speaks the 2026-07-28 revision in full, beside the two older ones. A version it doesn't speak gets the error code the spec defines for that.
And every refusal logs its reason, like MCP request refused reason=no_credential. A scan hands the thread back as it reads. The longest hold we measured went from 6.9 seconds to 0.3 seconds, with the same findings in the same time. Released November 13 at 5:40 PM MST.
Within the hour, the connector's calls in the log went from 400 then 200 to 200 and 200. No refusal. Three things, and none of them is a tool. A refusal is a failure you've agreed to call normal.
Some 400s really are the client's fault. Some are your server refusing a client you care about, every time, and depending on it to recover. You can't tell them apart if you never count them. Count statuses by path, over the bad window and over a normal one.
The bad morning and a good afternoon looked the same in our error log. They didn't look the same in a count of every status on every path. That comparison takes minutes, and it's now the first step when something fails quietly. Look at what comes right before each success.
A 200 that always follows a 400 isn't a success. It's a retry that happens to work today. And one thing about protocols: a dependency's protocol moves just like a model or a package does. We decided to defer a revision, which was fine.
What we didn't do was write down what would tell us it was now needed. The answer was "a client we care about starts speaking it", and that signal was sitting in our logs as a bare 400. "No errors logged" is a statement about your logging, not about your system. When something fails and the error log is empty, don't conclude the problem is on the other side.
Go read the lines you decided weren't worth reading. What's the longest a problem has hidden from you in a log level you'd stopped looking at? I'm Nabil. I build Since, which tracks what your code depends on and tells you before it breaks.
Key Takeaways #
- •One way people use it is as a connector inside an AI assistant: the assistant calls Since's tools (check_code, whats_changed) over MCP, the protocol assistants use to call tools.
- •This story was reported by Dev.to , covering developments in thedev space.
- •AI advancements continue to reshape industries — read the full article on Dev.to for complete coverage.
📖 Continue reading the full article: