Как читать explain:
COLLSCAN против IXSCAN

journal.drop()
journal.insert_many(events.find())

info = journal.find({"service": "payments", "status": {"$gte": 500}}).explain()
print("разделы ответа:", list(info))
print("выбранный план:", info["queryPlanner"]["winningPlan"]["stage"])

stats = info["executionStats"]
print("nReturned:        ", stats["nReturned"])
print("totalKeysExamined:", stats["totalKeysExamined"])
print("totalDocsExamined:", stats["totalDocsExamined"])

journal.drop();
std::vector<bsoncxx::document::value> all;
for (auto&& doc : events.find(make_document())) all.emplace_back(doc);
journal.insert_many(all);

auto info = sandbox.run_command(make_document(
    kvp("explain", make_document(
        kvp("find", "events"),
        kvp("filter", make_document(kvp("service", "payments"), kvp("status", make_document(kvp("$gte", 500))))))),
    kvp("verbosity", "executionStats")));

std::cout << "разделы ответа:";
for (auto&& field : info.view()) std::cout << " " << field.key();
std::cout << std::endl;
std::cout << "выбранный план: " << info.view()["queryPlanner"]["winningPlan"]["stage"].get_string().value << std::endl;

auto stats = info.view()["executionStats"];
std::cout << "nReturned:         " << stats["nReturned"].get_int32().value << std::endl;
std::cout << "totalKeysExamined: " << stats["totalKeysExamined"].get_int32().value << std::endl;
std::cout << "totalDocsExamined: " << stats["totalDocsExamined"].get_int32().value << std::endl;

journal.Drop(ctx)
var all []bson.D
cursor, _ := events.Find(ctx, bson.D{})
cursor.All(ctx, &all)
docs := make([]any, len(all))
for i := range all {
    docs[i] = all[i]
}
journal.InsertMany(ctx, docs)

var info bson.Raw
sandbox.RunCommand(ctx, bson.D{
    {Key: "explain", Value: bson.D{
        {Key: "find", Value: "events"},
        {Key: "filter", Value: bson.D{{Key: "service", Value: "payments"}, {Key: "status", Value: bson.D{{Key: "$gte", Value: 500}}}}}}},
    {Key: "verbosity", Value: "executionStats"}}).Decode(&info)

elements, _ := info.Elements()
keys := []string{}
for _, el := range elements {
    keys = append(keys, el.Key())
}
fmt.Println("разделы ответа:", keys)
fmt.Println("выбранный план:", info.Lookup("queryPlanner", "winningPlan", "stage").StringValue())

stats := info.Lookup("executionStats").Document()
fmt.Println("nReturned:        ", stats.Lookup("nReturned").AsInt64())
fmt.Println("totalKeysExamined:", stats.Lookup("totalKeysExamined").AsInt64())
fmt.Println("totalDocsExamined:", stats.Lookup("totalDocsExamined").AsInt64())

journal.drop
journal.insert_many(events.find.to_a)

info = journal.find({ "service" => "payments", "status" => { "$gte" => 500 } }).explain
puts "разделы ответа: " + info.keys.to_s
puts "выбранный план: " + info["queryPlanner"]["winningPlan"]["stage"]

stats = info["executionStats"]
puts "nReturned:         #{stats["nReturned"]}"
puts "totalKeysExamined: #{stats["totalKeysExamined"]}"
puts "totalDocsExamined: #{stats["totalDocsExamined"]}"

def summary(coll, **find):
    """План и счётчики explain одной строкой: стадии | вернул | ключей | документов."""
    info = coll.database.command("explain", {"find": coll.name, **find}, verbosity="executionStats")
    stage = info["queryPlanner"]["winningPlan"]
    stage = stage.get("queryPlan", stage)     # MongoDB 7 кладёт план во вложенное поле
    steps = []
    while stage:
        steps.append(stage["stage"] + (" " + stage["indexName"] if "indexName" in stage else ""))
        stage = stage.get("inputStage")
    stats = info["executionStats"]
    return (" → ".join(steps) + f" | вернул {stats['nReturned']}"
            + f" | ключей {stats['totalKeysExamined']} | документов {stats['totalDocsExamined']}")

// summary — план и счётчики explain одной строкой: стадии | вернул | ключей | документов.
std::string summary(mongocxx::database& db, const std::string& coll, bsoncxx::document::view find) {
    bsoncxx::builder::basic::document cmd;
    cmd.append(kvp("find", coll));
    for (auto&& field : find) cmd.append(kvp(field.key(), field.get_value()));
    auto res = db.run_command(make_document(kvp("explain", cmd.view()), kvp("verbosity", "executionStats")));
    auto stage = res.view()["queryPlanner"]["winningPlan"].get_document().value;
    if (stage["queryPlan"]) stage = stage["queryPlan"].get_document().value;   // MongoDB 7 кладёт план во вложенное поле
    std::string steps;
    while (true) {
        steps += std::string{stage["stage"].get_string().value};
        if (stage["indexName"]) steps += " " + std::string{stage["indexName"].get_string().value};
        if (!stage["inputStage"]) break;
        steps += " → ";
        stage = stage["inputStage"].get_document().value;
    }
    auto stats = res.view()["executionStats"].get_document().value;
    auto number = [&](const char* name) {
        auto value = stats[name];
        return std::to_string(value.type() == bsoncxx::type::k_int64 ? value.get_int64().value : value.get_int32().value);
    };
    return steps + " | вернул " + number("nReturned") + " | ключей " + number("totalKeysExamined")
         + " | документов " + number("totalDocsExamined");
}

// summary — план и счётчики explain одной строкой: стадии | вернул | ключей | документов.
func summary(coll *mongo.Collection, find bson.D) string {
    cmd := append(bson.D{{Key: "find", Value: coll.Name()}}, find...)
    var res bson.Raw
    coll.Database().RunCommand(context.Background(),
        bson.D{{Key: "explain", Value: cmd}, {Key: "verbosity", Value: "executionStats"}}).Decode(&res)
    stage := res.Lookup("queryPlanner", "winningPlan").Document()
    if inner, ok := stage.Lookup("queryPlan").DocumentOK(); ok { // MongoDB 7 кладёт план во вложенное поле
        stage = inner
    }
    steps := []string{}
    for {
        step := stage.Lookup("stage").StringValue()
        if name, ok := stage.Lookup("indexName").StringValueOK(); ok {
            step += " " + name
        }
        steps = append(steps, step)
        next, ok := stage.Lookup("inputStage").DocumentOK()
        if !ok {
            break
        }
        stage = next
    }
    stats := res.Lookup("executionStats").Document()
    return fmt.Sprintf("%s | вернул %d | ключей %d | документов %d", strings.Join(steps, " → "),
        stats.Lookup("nReturned").AsInt64(), stats.Lookup("totalKeysExamined").AsInt64(),
        stats.Lookup("totalDocsExamined").AsInt64())
}

# План и счётчики explain одной строкой: стадии | вернул | ключей | документов.
def summary(coll, find)
  info = coll.database.command(explain: { find: coll.name }.merge(find), verbosity: "executionStats").first
  stage = info["queryPlanner"]["winningPlan"]
  stage = stage["queryPlan"] || stage     # MongoDB 7 кладёт план во вложенное поле
  steps = []
  while stage
    steps << stage["stage"] + (stage["indexName"] ? " " + stage["indexName"] : "")
    stage = stage["inputStage"]
  end
  stats = info["executionStats"]
  steps.join(" → ") + " | вернул #{stats["nReturned"]}" +
    " | ключей #{stats["totalKeysExamined"]} | документов #{stats["totalDocsExamined"]}"
end

journal.create_index("service")
journal.create_index([("service", 1), ("status", 1)])

filtr = {"service": "payments", "status": {"$gte": 500}}
print("выбран:", summary(journal, filter=filtr))

info = journal.find(filtr).explain()
for rejected in info["queryPlanner"]["rejectedPlans"]:
    stage = rejected.get("queryPlan", rejected)
    while "inputStage" in stage:
        stage = stage["inputStage"]
    print("отклонён план по индексу", stage["indexName"])

journal.create_index(make_document(kvp("service", 1)));
journal.create_index(make_document(kvp("service", 1), kvp("status", 1)));

auto filtr = make_document(kvp("service", "payments"), kvp("status", make_document(kvp("$gte", 500))));
std::cout << "выбран: " << summary(sandbox, "events", make_document(kvp("filter", filtr.view()))) << std::endl;

auto info = sandbox.run_command(make_document(
    kvp("explain", make_document(kvp("find", "events"), kvp("filter", filtr.view()))),
    kvp("verbosity", "executionStats")));
for (auto&& plan : info.view()["queryPlanner"]["rejectedPlans"].get_array().value) {
    auto stage = plan.get_document().value;
    if (stage["queryPlan"]) stage = stage["queryPlan"].get_document().value;
    while (stage["inputStage"]) stage = stage["inputStage"].get_document().value;
    std::cout << "отклонён план по индексу " << stage["indexName"].get_string().value << std::endl;
}

journal.Indexes().CreateOne(ctx, mongo.IndexModel{Keys: bson.D{{Key: "service", Value: 1}}})
journal.Indexes().CreateOne(ctx, mongo.IndexModel{Keys: bson.D{{Key: "service", Value: 1}, {Key: "status", Value: 1}}})

filtr := bson.D{{Key: "service", Value: "payments"}, {Key: "status", Value: bson.D{{Key: "$gte", Value: 500}}}}
fmt.Println("выбран:", summary(journal, bson.D{{Key: "filter", Value: filtr}}))

var info bson.Raw
sandbox.RunCommand(ctx, bson.D{
    {Key: "explain", Value: bson.D{{Key: "find", Value: "events"}, {Key: "filter", Value: filtr}}},
    {Key: "verbosity", Value: "executionStats"}}).Decode(&info)
rejected, _ := info.Lookup("queryPlanner", "rejectedPlans").Array().Values()
for _, plan := range rejected {
    stage := plan.Document()
    if inner, ok := stage.Lookup("queryPlan").DocumentOK(); ok {
        stage = inner
    }
    for {
        next, ok := stage.Lookup("inputStage").DocumentOK()
        if !ok {
            break
        }
        stage = next
    }
    fmt.Println("отклонён план по индексу", stage.Lookup("indexName").StringValue())
}

journal.indexes.create_one({ "service" => 1 })
journal.indexes.create_one({ "service" => 1, "status" => 1 })

filtr = { "service" => "payments", "status" => { "$gte" => 500 } }
puts "выбран: " + summary(journal, filter: filtr)

info = journal.find(filtr).explain
info["queryPlanner"]["rejectedPlans"].each do |rejected|
  stage = rejected["queryPlan"] || rejected
  stage = stage["inputStage"] while stage["inputStage"]
  puts "отклонён план по индексу " + stage["indexName"]
end

filtr = {"service": "payments", "status": {"$gte": 500}}
print("service_1_status_1:", summary(journal, filter=filtr, hint="service_1_status_1"))
print("service_1:         ", summary(journal, filter=filtr, hint="service_1"))
print("без индекса:       ", summary(journal, filter=filtr, hint={"$natural": 1}))

auto filtr = make_document(kvp("service", "payments"), kvp("status", make_document(kvp("$gte", 500))));
std::cout << "service_1_status_1: "
          << summary(sandbox, "events", make_document(kvp("filter", filtr.view()), kvp("hint", "service_1_status_1"))) << std::endl;
std::cout << "service_1:          "
          << summary(sandbox, "events", make_document(kvp("filter", filtr.view()), kvp("hint", "service_1"))) << std::endl;
std::cout << "без индекса:        "
          << summary(sandbox, "events", make_document(kvp("filter", filtr.view()), kvp("hint", make_document(kvp("$natural", 1))))) << std::endl;

filtr := bson.D{{Key: "service", Value: "payments"}, {Key: "status", Value: bson.D{{Key: "$gte", Value: 500}}}}
fmt.Println("service_1_status_1:", summary(journal, bson.D{{Key: "filter", Value: filtr}, {Key: "hint", Value: "service_1_status_1"}}))
fmt.Println("service_1:         ", summary(journal, bson.D{{Key: "filter", Value: filtr}, {Key: "hint", Value: "service_1"}}))
fmt.Println("без индекса:       ", summary(journal, bson.D{{Key: "filter", Value: filtr}, {Key: "hint", Value: bson.D{{Key: "$natural", Value: 1}}}}))

filtr = { "service" => "payments", "status" => { "$gte" => 500 } }
puts "service_1_status_1: " + summary(journal, filter: filtr, hint: "service_1_status_1")
puts "service_1:          " + summary(journal, filter: filtr, hint: "service_1")
puts "без индекса:        " + summary(journal, filter: filtr, hint: { "$natural" => 1 })

filtr = {"service": "payments", "status": {"$gte": 500}}
print("все поля:        ", summary(journal, filter=filtr))
print("service и status:", summary(journal, filter=filtr, projection={"_id": 0, "service": 1, "status": 1}))
print("и ещё ts:        ", summary(journal, filter=filtr, projection={"_id": 0, "service": 1, "status": 1, "ts": 1}))

auto filtr = make_document(kvp("service", "payments"), kvp("status", make_document(kvp("$gte", 500))));
std::cout << "все поля:         " << summary(sandbox, "events", make_document(kvp("filter", filtr.view()))) << std::endl;
std::cout << "service и status: "
          << summary(sandbox, "events", make_document(kvp("filter", filtr.view()),
                     kvp("projection", make_document(kvp("_id", 0), kvp("service", 1), kvp("status", 1))))) << std::endl;
std::cout << "и ещё ts:         "
          << summary(sandbox, "events", make_document(kvp("filter", filtr.view()),
                     kvp("projection", make_document(kvp("_id", 0), kvp("service", 1), kvp("status", 1), kvp("ts", 1))))) << std::endl;

filtr := bson.D{{Key: "service", Value: "payments"}, {Key: "status", Value: bson.D{{Key: "$gte", Value: 500}}}}
fmt.Println("все поля:        ", summary(journal, bson.D{{Key: "filter", Value: filtr}}))
fmt.Println("service и status:", summary(journal, bson.D{{Key: "filter", Value: filtr},
    {Key: "projection", Value: bson.D{{Key: "_id", Value: 0}, {Key: "service", Value: 1}, {Key: "status", Value: 1}}}}))
fmt.Println("и ещё ts:        ", summary(journal, bson.D{{Key: "filter", Value: filtr},
    {Key: "projection", Value: bson.D{{Key: "_id", Value: 0}, {Key: "service", Value: 1}, {Key: "status", Value: 1}, {Key: "ts", Value: 1}}}}))

filtr = { "service" => "payments", "status" => { "$gte" => 500 } }
puts "все поля:         " + summary(journal, filter: filtr)
puts "service и status: " + summary(journal, filter: filtr, projection: { "_id" => 0, "service" => 1, "status" => 1 })
puts "и ещё ts:         " + summary(journal, filter: filtr, projection: { "_id" => 0, "service" => 1, "status" => 1, "ts" => 1 })

journal.drop_index("service_1")
last = {"filter": {"service": "payments"}, "sort": {"ts": -1}, "limit": 10}
print("до индекса по ts:   ", summary(journal, **last))

print("создан индекс:", journal.create_index([("service", 1), ("ts", -1)]))
print("после индекса по ts:", summary(journal, **last))

journal.indexes().drop_one("service_1");
auto last = make_document(
    kvp("filter", make_document(kvp("service", "payments"))),
    kvp("sort", make_document(kvp("ts", -1))),
    kvp("limit", 10));
std::cout << "до индекса по ts:    " << summary(sandbox, "events", last.view()) << std::endl;

auto created = journal.create_index(make_document(kvp("service", 1), kvp("ts", -1)));
std::cout << "создан индекс: " << created.view()["name"].get_string().value << std::endl;
std::cout << "после индекса по ts: " << summary(sandbox, "events", last.view()) << std::endl;

journal.Indexes().DropOne(ctx, "service_1")
last := bson.D{
    {Key: "filter", Value: bson.D{{Key: "service", Value: "payments"}}},
    {Key: "sort", Value: bson.D{{Key: "ts", Value: -1}}},
    {Key: "limit", Value: 10}}
fmt.Println("до индекса по ts:   ", summary(journal, last))

name, _ := journal.Indexes().CreateOne(ctx, mongo.IndexModel{Keys: bson.D{{Key: "service", Value: 1}, {Key: "ts", Value: -1}}})
fmt.Println("создан индекс:", name)
fmt.Println("после индекса по ts:", summary(journal, last))

journal.indexes.drop_one("service_1")
last = { filter: { "service" => "payments" }, sort: { "ts" => -1 }, limit: 10 }
puts "до индекса по ts:    " + summary(journal, last)

journal.indexes.create_one({ "service" => 1, "ts" => -1 })
puts "создан индекс: " + journal.indexes.get({ "service" => 1, "ts" => -1 })["name"]
puts "после индекса по ts: " + summary(journal, last)

journal.create_index([("service", 1), ("ts", -1), ("status", 1)])
errors_last = {"filter": {"service": "payments", "status": {"$gte": 500}}, "sort": {"ts": -1}, "limit": 5}

for name in ["service_1_status_1", "service_1_ts_-1", "service_1_ts_-1_status_1"]:
    print(name.ljust(24), summary(journal, **errors_last, hint=name))

journal.create_index(make_document(kvp("service", 1), kvp("ts", -1), kvp("status", 1)));

for (std::string name : {"service_1_status_1", "service_1_ts_-1", "service_1_ts_-1_status_1"}) {
    auto find = make_document(
        kvp("filter", make_document(kvp("service", "payments"), kvp("status", make_document(kvp("$gte", 500))))),
        kvp("sort", make_document(kvp("ts", -1))),
        kvp("limit", 5),
        kvp("hint", name));
    std::cout << name << std::string(25 - name.size(), ' ') << summary(sandbox, "events", find.view()) << std::endl;
}

journal.Indexes().CreateOne(ctx, mongo.IndexModel{
    Keys: bson.D{{Key: "service", Value: 1}, {Key: "ts", Value: -1}, {Key: "status", Value: 1}}})
errorsLast := bson.D{
    {Key: "filter", Value: bson.D{{Key: "service", Value: "payments"}, {Key: "status", Value: bson.D{{Key: "$gte", Value: 500}}}}},
    {Key: "sort", Value: bson.D{{Key: "ts", Value: -1}}},
    {Key: "limit", Value: 5}}

for _, name := range []string{"service_1_status_1", "service_1_ts_-1", "service_1_ts_-1_status_1"} {
    find := append(bson.D{{Key: "hint", Value: name}}, errorsLast...)
    fmt.Printf("%-24s %s\n", name, summary(journal, find))
}

journal.indexes.create_one({ "service" => 1, "ts" => -1, "status" => 1 })
errors_last = { filter: { "service" => "payments", "status" => { "$gte" => 500 } }, sort: { "ts" => -1 }, limit: 5 }

["service_1_status_1", "service_1_ts_-1", "service_1_ts_-1_status_1"].each do |name|
  puts name.ljust(24) + " " + summary(journal, errors_last.merge(hint: name))
end