1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
|
// @file curop.h
/**
* Copyright (C) 2018-present MongoDB, Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the Server Side Public License, version 1,
* as published by MongoDB, Inc.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* Server Side Public License for more details.
*
* You should have received a copy of the Server Side Public License
* along with this program. If not, see
* <http://www.mongodb.com/licensing/server-side-public-license>.
*
* As a special exception, the copyright holders give permission to link the
* code of portions of this program with the OpenSSL library under certain
* conditions as described in each individual source file and distribute
* linked combinations including the program with the OpenSSL library. You
* must comply with the Server Side Public License in all respects for
* all of the code used other than as permitted herein. If you modify file(s)
* with this exception, you may extend this exception to your version of the
* file(s), but you are not obligated to do so. If you do not wish to do so,
* delete this exception statement from your version. If you delete this
* exception statement from all source files in the program, then also delete
* it in the license file.
*/
#pragma once
#include "mongo/base/disallow_copying.h"
#include "mongo/db/clientcursor.h"
#include "mongo/db/commands.h"
#include "mongo/db/cursor_id.h"
#include "mongo/db/operation_context.h"
#include "mongo/db/server_options.h"
#include "mongo/platform/atomic_word.h"
#include "mongo/util/progress_meter.h"
#include "mongo/util/time_support.h"
namespace mongo {
class Client;
class CurOp;
class OperationContext;
struct PlanSummaryStats;
/* lifespan is different than CurOp because of recursives with DBDirectClient */
class OpDebug {
public:
/**
* Holds counters for execution statistics that are meaningful both for multi-statement
* transactions and for individual operations outside of a transaction.
*/
class AdditiveMetrics {
public:
/**
* Adds all the fields of another AdditiveMetrics object together with the fields of this
* AdditiveMetrics instance.
*/
void add(const AdditiveMetrics& otherMetrics);
/**
* Returns true if the AdditiveMetrics object we are comparing has the same field values as
* this AdditiveMetrics instance.
*/
bool equals(const AdditiveMetrics& otherMetrics);
/**
* Increments writeConflicts by n.
*/
void incrementWriteConflicts(long long n);
/**
* Increments keysInserted by n.
*/
void incrementKeysInserted(long long n);
/**
* Increments keysDeleted by n.
*/
void incrementKeysDeleted(long long n);
/**
* Increments ninserted by n.
*/
void incrementNinserted(long long n);
/**
* Increments prepareReadConflicts by n.
*/
void incrementPrepareReadConflicts(long long n);
/**
* Generates a string showing all non-empty fields. For every non-empty field field1,
* field2, ..., with corresponding values value1, value2, ..., we will output a string in
* the format: "<field1>:<value1> <field2>:<value2> ...".
*/
std::string report() const;
boost::optional<long long> keysExamined;
boost::optional<long long> docsExamined;
// Number of records that match the query.
boost::optional<long long> nMatched;
// Number of records written (no no-ops).
boost::optional<long long> nModified;
boost::optional<long long> ninserted;
boost::optional<long long> ndeleted;
// Number of index keys inserted.
boost::optional<long long> keysInserted;
// Number of index keys removed.
boost::optional<long long> keysDeleted;
// Number of read conflicts caused by a prepared transaction.
boost::optional<long long> prepareReadConflicts;
boost::optional<long long> writeConflicts;
};
OpDebug() = default;
std::string report(Client* client,
const CurOp& curop,
const SingleThreadedLockStats* lockStats) const;
/**
* Appends information about the current operation to "builder"
*
* @param curop reference to the CurOp that owns this OpDebug
* @param lockStats lockStats object containing locking information about the operation
*/
void append(const CurOp& curop,
const SingleThreadedLockStats& lockStats,
BSONObjBuilder& builder) const;
/**
* Copies relevant plan summary metrics to this OpDebug instance.
*/
void setPlanSummaryMetrics(const PlanSummaryStats& planSummaryStats);
// -------------------
// basic options
// _networkOp represents the network-level op code: OP_QUERY, OP_GET_MORE, OP_MSG, etc.
NetworkOp networkOp{opInvalid}; // only set this through setNetworkOp_inlock() to keep synced
// _logicalOp is the logical operation type, ie 'dbQuery' regardless of whether this is an
// OP_QUERY find, a find command using OP_QUERY, or a find command using OP_MSG.
// Similarly, the return value will be dbGetMore for both OP_GET_MORE and getMore command.
LogicalOp logicalOp{LogicalOp::opInvalid}; // only set this through setNetworkOp_inlock()
bool iscommand{false};
// detailed options
long long cursorid{-1};
long long ntoreturn{-1};
long long ntoskip{-1};
bool exhaust{false};
bool hasSortStage{false}; // true if the query plan involves an in-memory sort
bool usedDisk{false}; // true if the given query used disk
// True if the plan came from the multi-planner (not from the plan cache and not a query with a
// single solution).
bool fromMultiPlanner{false};
// True if a replan was triggered during the execution of this operation.
bool replanned{false};
bool fastmodinsert{false}; // upsert of an $operation. builds a default object
bool upsert{false}; // true if the update actually did an insert
bool cursorExhausted{
false}; // true if the cursor has been closed at end a find/getMore operation
BSONObj execStats; // Owned here.
// The hash of the PlanCache key for the query being run. This may change depending on what
// indexes are present.
boost::optional<uint32_t> planCacheKey;
// The hash of the query's "stable" key. This represents the query's shape.
boost::optional<uint32_t> queryHash;
// Details of any error (whether from an exception or a command returning failure).
Status errInfo = Status::OK();
// response info
long long executionTimeMicros{0};
long long nreturned{-1};
int responseLength{-1};
// Shard targeting info.
int nShards{-1};
// Stores additive metrics.
AdditiveMetrics additiveMetrics;
// Stores storage statistics.
std::shared_ptr<StorageStats> storageStats;
};
/**
* Container for data used to report information about an OperationContext.
*
* Every OperationContext in a server with CurOp support has a stack of CurOp
* objects. The entry at the top of the stack is used to record timing and
* resource statistics for the executing operation or suboperation.
*
* All of the accessor methods on CurOp may be called by the thread executing
* the associated OperationContext at any time, or by other threads that have
* locked the context's owning Client object.
*
* The mutator methods on CurOp whose names end _inlock may only be called by the thread
* executing the associated OperationContext and Client, and only when that thread has also
* locked the Client object. All other mutators may only be called by the thread executing
* CurOp, but do not require holding the Client lock. The exception to this is the kill()
* method, which is self-synchronizing.
*
* The OpDebug member of a CurOp, accessed via the debug() accessor should *only* be accessed
* from the thread executing an operation, and as a result its fields may be accessed without
* any synchronization.
*/
class CurOp {
MONGO_DISALLOW_COPYING(CurOp);
public:
static CurOp* get(const OperationContext* opCtx);
static CurOp* get(const OperationContext& opCtx);
/**
* Writes a report of the operation being executed by the given client to the supplied
* BSONObjBuilder, in a format suitable for display in currentOp. Does not include a lockInfo
* report, since this may be called in either a mongoD or mongoS context and the latter does not
* supply lock stats. The client must be locked before calling this method.
*/
static void reportCurrentOpForClient(OperationContext* opCtx,
Client* client,
bool truncateOps,
BSONObjBuilder* infoBuilder);
/**
* Serializes the fields of a GenericCursor which do not appear elsewhere in the currentOp
* output. If 'maxQuerySize' is given, truncates the cursor's originatingCommand but preserves
* the comment.
*/
static BSONObj truncateAndSerializeGenericCursor(GenericCursor* cursor,
boost::optional<size_t> maxQuerySize);
/**
* Constructs a nested CurOp at the top of the given "opCtx"'s CurOp stack.
*/
explicit CurOp(OperationContext* opCtx);
~CurOp();
/**
* Fills out CurOp and OpDebug with basic info common to all commands. We require the NetworkOp
* in order to distinguish which protocol delivered this request, e.g. OP_QUERY or OP_MSG. This
* is set early in the request processing backend and does not typically need to be called
* thereafter. Locks the client as needed to apply the specified settings.
*/
void setGenericOpRequestDetails(OperationContext* opCtx,
const NamespaceString& nss,
const Command* command,
BSONObj cmdObj,
NetworkOp op);
/**
* Marks the operation end time, records the length of the client response if a valid response
* exists, and then - subject to the current values of slowMs and sampleRate - logs this CurOp
* to file under the given LogComponent. Returns 'true' if, in addition to being logged, this
* operation should also be profiled.
*/
bool completeAndLogOperation(OperationContext* opCtx,
logger::LogComponent logComponent,
boost::optional<size_t> responseLength = boost::none,
boost::optional<long long> slowMsOverride = boost::none,
bool forceLog = false);
bool haveOpDescription() const {
return !_opDescription.isEmpty();
}
/**
* The BSONObj returned may not be owned by CurOp. Callers should call getOwned() if they plan
* to reference beyond the lifetime of this CurOp instance.
*/
BSONObj opDescription() const {
return _opDescription;
}
/**
* Returns an owned BSONObj representing the original command. Used only by the getMore
* command.
*/
BSONObj originatingCommand() const {
return _originatingCommand;
}
void enter_inlock(const char* ns, boost::optional<int> dbProfileLevel);
/**
* Sets the type of the current network operation.
*/
void setNetworkOp_inlock(NetworkOp op) {
_networkOp = op;
_debug.networkOp = op;
}
/**
* Sets the type of the current logical operation.
*/
void setLogicalOp_inlock(LogicalOp op) {
_logicalOp = op;
_debug.logicalOp = op;
}
/**
* Marks the current operation as being a command.
*/
void markCommand_inlock() {
_isCommand = true;
}
/**
* Returns a structure containing data used for profiling, accessed only by a thread
* currently executing the operation context associated with this CurOp.
*/
OpDebug& debug() {
return _debug;
}
/**
* Gets the name of the namespace on which the current operation operates.
*/
std::string getNS() const {
return _ns;
}
/**
* Returns true if the elapsed time of this operation is such that it should be profiled or
* profile level is set to 2. Uses total time if the operation is done, current elapsed time
* otherwise. The argument shouldSample prevents slow diagnostic logging at profile 1
* when set to false.
*/
bool shouldDBProfile(bool shouldSample = true) {
// Profile level 2 should override any sample rate or slowms settings.
if (_dbprofile >= 2)
return true;
if (!shouldSample || _dbprofile <= 0)
return false;
return elapsedTimeExcludingPauses() >= Milliseconds{serverGlobalParams.slowMS};
}
/**
* Raises the profiling level for this operation to "dbProfileLevel" if it was previously
* less than "dbProfileLevel".
*
* This belongs on OpDebug, and so does not have the _inlock suffix.
*/
void raiseDbProfileLevel(int dbProfileLevel);
/**
* Gets the network operation type. No lock is required if called by the thread executing
* the operation, but the lock must be held if called from another thread.
*/
NetworkOp getNetworkOp() const {
return _networkOp;
}
/**
* Gets the logical operation type. No lock is required if called by the thread executing
* the operation, but the lock must be held if called from another thread.
*/
LogicalOp getLogicalOp() const {
return _logicalOp;
}
/**
* Returns true if this CurOp represents a non-command OP_QUERY request.
*/
bool isLegacyQuery() const {
return _networkOp == NetworkOp::dbQuery && !isCommand();
}
/**
* Returns true if the current operation is known to be a command.
*/
bool isCommand() const {
return _isCommand;
}
//
// Methods for getting/setting elapsed time. Note that the observed elapsed time may be
// negative, if the system time has been reset during the course of this operation.
//
void ensureStarted();
bool isStarted() const {
return _start > 0;
}
long long startTime() { // micros
ensureStarted();
return _start;
}
void done() {
_end = curTimeMicros64();
}
bool isDone() const {
return _end > 0;
}
/**
* Stops the operation latency timer from "ticking". Time spent paused is not included in the
* latencies returned by elapsedTimeExcludingPauses().
*
* Illegal to call if either the CurOp has not been started, or the CurOp is already in a paused
* state.
*/
void pauseTimer() {
invariant(isStarted());
invariant(_lastPauseTime == 0);
_lastPauseTime = curTimeMicros64();
}
/**
* Starts the operation latency timer "ticking" again. Illegal to call if the CurOp has not been
* started and then subsequently paused.
*/
void resumeTimer() {
invariant(isStarted());
invariant(_lastPauseTime > 0);
_totalPausedDuration +=
Microseconds{static_cast<long long>(curTimeMicros64()) - _lastPauseTime};
_lastPauseTime = 0;
}
/**
* If this op has been marked as done(), returns the wall clock duration between being marked as
* started with ensureStarted() and the call to done().
*
* Otherwise, returns the wall clock duration between the start time and now.
*
* If this op has not yet been started, returns 0.
*/
Microseconds elapsedTimeTotal() {
if (!isStarted()) {
return Microseconds{0};
}
if (!_end) {
return Microseconds{static_cast<long long>(curTimeMicros64() - startTime())};
} else {
return Microseconds{static_cast<long long>(_end - startTime())};
}
}
/**
* Returns the total elapsed duration minus any time spent in a paused state. See
* elapsedTimeTotal() for the definition of the total duration and pause/resumeTimer() for
* details on pausing.
*
* If this op has not yet been started, returns 0.
*
* Illegal to call while the timer is paused.
*/
Microseconds elapsedTimeExcludingPauses() {
invariant(!_lastPauseTime);
if (!isStarted()) {
return Microseconds{0};
}
return elapsedTimeTotal() - _totalPausedDuration;
}
/**
* 'opDescription' must be either an owned BSONObj or guaranteed to outlive the OperationContext
* it is associated with.
*/
void setOpDescription_inlock(const BSONObj& opDescription) {
_opDescription = opDescription;
}
/**
* Sets the original command object.
*/
void setOriginatingCommand_inlock(const BSONObj& commandObj) {
_originatingCommand = commandObj.getOwned();
}
const Command* getCommand() const {
return _command;
}
void setCommand_inlock(const Command* command) {
_command = command;
}
/**
* Returns whether the current operation is a read, write, or command.
*/
Command::ReadWriteType getReadWriteType() const;
/**
* Appends information about this CurOp to "builder". If "truncateOps" is true, appends a string
* summary of any objects which exceed the threshold size. If truncateOps is false, append the
* entire object.
*
* If called from a thread other than the one executing the operation associated with this
* CurOp, it is necessary to lock the associated Client object before executing this method.
*/
void reportState(BSONObjBuilder* builder, bool truncateOps = false);
/**
* Sets the message for this CurOp.
*/
void setMessage_inlock(StringData message);
/**
* Sets the message and the progress meter for this CurOp.
*
* While it is necessary to hold the lock while this method executes, the
* "hit" and "finished" methods of ProgressMeter may be called safely from
* the thread executing the operation without locking the Client.
*/
ProgressMeter& setProgress_inlock(StringData name,
unsigned long long progressMeterTotal = 0,
int secondsBetween = 3);
/**
* Gets the message for this CurOp.
*/
const std::string& getMessage() const {
return _message;
}
const ProgressMeter& getProgressMeter() {
return _progressMeter;
}
CurOp* parent() const {
return _parent;
}
boost::optional<GenericCursor> getGenericCursor_inlock() const {
return _genericCursor;
}
void yielded(int numYields = 1) {
_numYields += numYields;
} // Should be _inlock()?
/**
* Returns the number of times yielded() was called. Callers on threads other
* than the one executing the operation must lock the client.
*/
int numYields() const {
return _numYields;
}
/**
* this should be used very sparingly
* generally the Context should set this up
* but sometimes you want to do it ahead of time
*/
void setNS_inlock(StringData ns);
StringData getPlanSummary() const {
return _planSummary;
}
void setPlanSummary_inlock(StringData summary) {
_planSummary = summary.toString();
}
void setPlanSummary_inlock(std::string summary) {
_planSummary = std::move(summary);
}
void setGenericCursor_inlock(GenericCursor gc);
const boost::optional<SingleThreadedLockStats> getLockStatsBase() {
return _lockStatsBase;
}
private:
class CurOpStack;
static const OperationContext::Decoration<CurOpStack> _curopStack;
CurOp(OperationContext*, CurOpStack*);
CurOpStack* _stack;
CurOp* _parent{nullptr};
const Command* _command{nullptr};
// The time at which this CurOp instance was marked as started.
long long _start{0};
// The time at which this CurOp instance was marked as done.
long long _end{0};
// The time at which this CurOp instance had its timer paused, or 0 if the timer is not
// currently paused.
long long _lastPauseTime{0};
// The cumulative duration for which the timer has been paused.
Microseconds _totalPausedDuration{0};
// _networkOp represents the network-level op code: OP_QUERY, OP_GET_MORE, OP_MSG, etc.
NetworkOp _networkOp{opInvalid}; // only set this through setNetworkOp_inlock() to keep synced
// _logicalOp is the logical operation type, ie 'dbQuery' regardless of whether this is an
// OP_QUERY find, a find command using OP_QUERY, or a find command using OP_MSG.
// Similarly, the return value will be dbGetMore for both OP_GET_MORE and getMore command.
LogicalOp _logicalOp{LogicalOp::opInvalid}; // only set this through setNetworkOp_inlock()
bool _isCommand{false};
int _dbprofile{0}; // 0=off, 1=slow, 2=all
std::string _ns;
BSONObj _opDescription;
BSONObj _originatingCommand; // Used by getMore to display original command.
OpDebug _debug;
std::string _message;
ProgressMeter _progressMeter;
int _numYields{0};
// A GenericCursor containing information about the active cursor for a getMore operation.
boost::optional<GenericCursor> _genericCursor;
std::string _planSummary;
boost::optional<SingleThreadedLockStats>
_lockStatsBase; // This is the snapshot of lock stats taken when curOp is constructed.
};
/**
* Upconverts a legacy query object such that it matches the format of the find command.
*/
BSONObj upconvertQueryEntry(const BSONObj& query,
const NamespaceString& nss,
int ntoreturn,
int ntoskip);
/**
* Generates a getMore command object from the specified namespace, cursor ID and batchsize.
*/
BSONObj upconvertGetMoreEntry(const NamespaceString& nss, CursorId cursorId, int ntoreturn);
} // namespace mongo
|