Known Issues
5279 tracked MongoDB server issues from Jira with status, affected versions, and resolution details.
SERVER-134626ClosedFixed
Add test verifying PQS maxEstimatedScanBytes: -1 exempts a query shape from maxEstimatedScanBytes
h3. Background
{{maxEstimatedScanBytes}} rejects queries at plan time when the plan requires an unbounded COLLSCAN on a collection whose data size exceeds a configured byte threshold. Query Settings (PQS) can override this threshold per query shape via {{queryKnobs.maxEstimatedScanBytes}}. Existing coverage in {{jstests/noPassthrough/query/max_estimated_scan_bytes.js}} tests that PQS can lower or raise the threshold for a specific shape, but there was no coverage confirming that setting the PQS
Fixed Versions
9.1.0-rc09.1.0-rc1025
SERVER-137600ClosedFixed
Fix race condition on resume token test
In resume_after_against_oplog.js, there's a race between reading the oplog and reading it again such that an oplog entry written between those 2 reads - even one written by an internal process - changes the resume token. Fix the test to tolerate that possibility.
Fixed Versions
9.1.0-rc09.1.0-rc1025
SERVER-136185ClosedFixed
Rename compact hash agg debug name to compact_group and remove optimizedClose
Rename to compact_group in debug output, remove optimized close boolean.
Fixed Versions
9.1.0-rc09.1.0-rc1025
SERVER-138059ClosedWon't Do
Test for deadlocks around the critical section with concurrent reshardings
Several operations can enter their critical sections at the same time, on shards that play different roles for each of them. Waiting between the operations must not form a cycle.
Scenarios:
* drive N operations into their critical sections together, both through the commit monitor and through manual commitReshardCollection
* crossed roles: shard S1 is a donor for A and a recipient for B, and shard S2 is the reverse; both operations enter the critical section at the same time
* one operation is
SERVER-138058ClosedWon't Do
Test commands that look up resharding state machines while multiple reshardings run concurrently
Several commands find "the" resharding operation by namespace or by operation id. With several operations running, each lookup must find the right one.
Cover, with N operations in progress:
* abortReshardCollection
* commitReshardCollection
* the cleanup command
* the matching moveCollection and unshardCollection forms
* the internal coordinator-to-participant commands
Assert:
* each command acts only on the operation for its namespace
* the other operations are unaffected
* a command on a nam
SERVER-138057ClosedWon't Do
Test aborting a subset or all of N concurrent reshardings
An abort of one operation must not affect any other operation.
Run N reshardings and abort:
* one operation, using abortReshardCollection
* one operation, by timing out its critical section
* all operations
Do this at different phases: cloning, applying, and in the critical section.
Assert:
* the operations that weren't aborted commit with correct data
* aborted operations clean up their own temp collections, buffers and state, and leave the other operations' state alone
* the aborted collect
SERVER-138056ClosedWon't Do
Test stepup/stepdown of a subset or all of N concurrent reshardings
Each operation must survive failovers on its own, and a failover that affects one operation must not affect the others.
Run N reshardings with overlapping donors and recipients, then step down:
* a shard involved in only one operation (subset)
* a shard that is a donor for A and a recipient for B, during cloning and again during applying
* the config server primary, while N coordinators are running (all)
Run these at different phases: cloning, applying, and in or near the critical section.
As
CSHARP-5856Backlog
Unified test runner should clean up databases/collections between test runs
h2. Problem
The unified test runner ({{UnifiedTestRunner}}) creates fresh driver objects (clients, databases) for each test run, but does NOT drop the underlying MongoDB databases and collections. This causes test pollution where collections created by one test variant persist and affect subsequent test variants.
h2. Impact
This particularly affects tests that assume collections don't exist:
* {{create_collection.json}} test fails intermittently on MongoDB < 7.0 (error 48 "collection a
Components
Unified Test Runner
CSHARP-5178Backlog
.NET/C# Driver Support for Unity
{panel:bgColor=#fafbfc}
h3. *Summary*
_There are untapped opportunities in the games industry, specifically Multiplayer games that we haven’t explored well. Adding support for Unity in our C# Driver for Game Servers and enterprise apps can help us unlock new revenue opportunities and a potential tech partnership with Unity._
h3. *Motivation*
h4. Who is the affected end user?
All Unity developers intending to use MongoDB in their Unity applications
h4. How does this affect the end user?
SERVER-136814ClosedDuplicate
make coordinator pool usage in resharding non-blocking
The coordinator runs a delta collector for both a recipient and a donor per resharding operation. those collectors block for the duration of the critical section, pinning 2 threads per resharding operation. there is additional blocking work during the critical section, such as sendCommandToShards round-trips: these are the refresh, abort and establish-participant calls, plus the document-count calls, and each blocks one pool thread for its round trip.
If the delta collectors can be made to ru
CSHARP-4443Backlog
Support LINQ queries against all 3 possible representations of Dictionaries
For example, a `Dictionary<string, int>` could be represented in 3 ways:
Corresponding to `Documents`, `ArrayOfArrays` and `ArrayOfDocuments`.
We should support queries against all 3 representations.
Components
LINQLINQ3
CSHARP-3230Backlog
Improve Serialization
{panel:title=Epic Summary|borderStyle=dashed|borderColor=#ccc|titleBGColor=#239eb0|bgColor=#c2d2c2}
*Summary*
1) Assess all our currently open serialization items
2) Close out old, gone away, or won't fix items
3) Create a rollup of the seralization asks that we will/should fix and attach them to this epic
*Motivation*
We have many users who have opened serialization bugs or feature requests over the years, and our backlog has grown fairly unwieldy as a result. Some of these asks are re
Components
Serialization
SERVER-138055ClosedWon't Do
Test moveCollection running in the background during one or more reshardings
moveCollection is built on resharding, so with concurrency turned on it can run alongside reshardings of other collections.
Scenarios:
* start a resharding of A, then move an unrelated collection C onto a shard that is a donor or recipient for A
* move C while several reshardings are running, with overlapping donors and recipients
* move C while A is in its critical section, and start a resharding of A while C is in its critical section
* try to reshard or move a namespace that already has an o
SERVER-138054ClosedWon't Do
Test that collection cloning retries and completes when another resharding's donor enters its critical section
Before a donor enters its critical section, it aborts every unprepared transaction on that shard. This includes the clone transactions of other resharding operations on the same shard. That's correct, but those clones have to restart.
Use one shard as the recipient for A and a donor for B. Pause A's collection clone partway through. Drive B to the point where its donors abort unprepared transactions, then release A.
Assert that A's clone restarts, completes, and that the temp collection contai
SERVER-138053ClosedWon't Do
Test transactions split across oplog batch boundaries during concurrent reshardings
Each operation fetches and applies in its own batches. A transaction can be cut across a batch boundary in one operation and not in the other. Resuming in the middle of such a transaction must not lose or duplicate any of its entries.
Set the fetcher and applier batch sizes to 1. While both operations are applying, run small, large and prepared transactions that write to A and B. Pause one operation's fetcher partway through a transaction. Then make it resume, once with a recipient stepdown and
SERVER-138052ClosedWon't Do
Test concurrent resharding transaction cloners writing to a shared recipient
Each resharding operation copies its donors' full session history to the recipient, with no filter by collection. When two operations do this at the same time, they write overlapping session state. The end state must be correct.
Scenarios:
* *Different snapshots:* run retryable writes on L at txnNumbers 8 and 9 between the start of A and the start of B, so each operation's cloner sees a different latest txnNumber. Force each cloner to go first in turn. L should end at txnNumber 9, retrying 7 ge
CSHARP-6212Investigating
readPreferenceTags values containing ',' or ':' do not round-trip through the connection string
h2. Description
{{ConnectionString.ExtractOptions}} percent-decodes the entire option value before {{ParseReadPreferenceTagSets}} splits it on "," and then ":". Any escaping of the separator characters is undone before the separators are used, so a tag name or value containing "," or ":" cannot survive a round-trip through the connection string. Depending on the characters involved the result is either an exception or a silently different tag set.
The emitted form is correct and unambiguou
SERVER-138051ClosedWon't Do
Test retryable write history in the recipient's shared config.transactions with concurrent resharding oplog appliers
Concurrent reshardings onto the same recipient all write retry history into that recipient's single config.transactions collection. Retries must give correct results, with no duplicate writes, however the two operations' writes interleave.
Scenarios:
* *One retryable batch across A and B:* a retryable insertMany on L with one statement going to A and one to B. Force each operator to record history first in turn. Retrying returns both original results, and the recipient has one linked history ch
SERVER-138050ClosedWon't Do
Test that concurrent reshardings sharing donors and recipients only fetch and apply their own collection's writes
Reshard A and B at the same time, using the same donor shards and the same recipient shard. Writes to both collections are then tagged with the same destination recipient. Each operation must still fetch and apply only its own collection's writes.
While both operations are cloning and applying, run:
* inserts, updates and deletes on A and B
* multi-document transactions and retryable batches that write to both A and B
* bulkWrite across A and B, ordered and unordered, inside and outside a trans