mongodb-data-service 21.11.0 → 21.15.0

package/lib/data-service.js

@@ -2,28 +2,50 @@
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("util");
 const async_1 = __importDefault(require("async"));
-const debug_1 = __importDefault(require("debug"));
+const compass_logging_1 = __importDefault(require("@mongodb-js/compass-logging"));
 const events_1 = require("events");
 const lodash_1 = require("lodash");
+const mongodb_connection_string_url_1 = __importDefault(require("mongodb-connection-string-url"));
 const instance_detail_helper_1 = require("./instance-detail-helper");
-const legacy_connect_1 = __importDefault(require("./legacy-connect"));
+const redact_1 = require("./redact");
+const connect_mongo_client_1 = __importDefault(require("./connect-mongo-client"));
+const get_port_1 = __importDefault(require("get-port"));
+const run_command_1 = require("./run-command");
 const { fetch: getIndexes } = require('mongodb-index-model');
 const parseNamespace = require('mongodb-ns');
-const debug = debug_1.default('mongodb-data-service:data-service');
+const { log, mongoLogId, debug } = (0, compass_logging_1.default)('COMPASS-DATA-SERVICE');
+function uniqueBy(values, key) {
+    return Array.from(new Map(values.map((val) => [val[key], val])).values());
+}
+let id = 0;
 class DataService extends events_1.EventEmitter {
-    constructor(model) {
+    constructor(connectionOptions) {
         super();
-        this.lastSeenTopology = null;
         this._isConnecting = false;
-        this._tunnel = null;
+        this._lastSeenTopology = null;
         this._isWritable = false;
         this._isMongos = false;
-        this.model = model;
+        this._id = id++;
+        this._connectionOptions = connectionOptions;
     }
     getMongoClientConnectionOptions() {
         return this._mongoClientConnectionOptions;
     }
+    _logCtx() {
+        return `Connection ${this._id}`;
+    }
+    getConnectionOptions() {
+        return this._connectionOptions;
+    }
+    getConnectionString() {
+        return new mongodb_connection_string_url_1.default(this._connectionOptions.connectionString);
+    }
+    getReadPreference() {
+        return this._initializedClient.readPreference;
+    }
     collection(ns, options, callback) {
         async_1.default.parallel({
             stats: this.collectionStats.bind(this, this._databaseName(ns), this._collectionName(ns)),
@@ -51,16 +73,27 @@ class DataService extends events_1.EventEmitter {
         });
     }
     collectionStats(databaseName, collectionName, callback) {
-        const db = this.mongoClient.db(databaseName);
+        const logop = this._startLogOp(mongoLogId(1001000031), 'Fetching collection info', { ns: `${databaseName}.${collectionName}` });
+        const db = this._initializedClient.db(databaseName);
         db.command({ collStats: collectionName, verbose: true }, (error, data) => {
+            logop(error);
             if (error && !error.message.includes('is a view, not a collection')) {
                 return callback(this._translateMessage(error));
             }
             callback(null, this._buildCollectionStats(databaseName, collectionName, data || {}));
         });
     }
+    async collectionInfo(dbName, collName) {
+        try {
+            const [collInfo] = await this.listCollections(dbName, { name: collName });
+            return collInfo !== null && collInfo !== void 0 ? collInfo : null;
+        }
+        catch (err) {
+            throw this._translateMessage(err);
+        }
+    }
     command(databaseName, comm, callback) {
-        const db = this.mongoClient.db(databaseName);
+        const db = this._initializedClient.db(databaseName);
         db.command(comm, (error, result) => {
             if (error) {
                 return callback(this._translateMessage(error));
@@ -74,64 +107,152 @@ class DataService extends events_1.EventEmitter {
     isMongos() {
         return this._isMongos;
     }
-    listCollections(databaseName, filter, callback) {
-        const db = this.mongoClient.db(databaseName);
-        db.listCollections(filter, {}).toArray((error, data) => {
-            if (error) {
-                return callback(this._translateMessage(error));
+    async connectionStatus() {
+        const logop = this._startLogOp(mongoLogId(1001000100), 'Running connectionStatus');
+        try {
+            const adminDb = this._initializedClient.db('admin');
+            const result = await (0, run_command_1.runCommand)(adminDb, {
+                connectionStatus: 1,
+                showPrivileges: true,
+            });
+            logop(null);
+            return result;
+        }
+        catch (e) {
+            logop(e);
+            throw e;
+        }
+    }
+    async _getPrivilegesOrFallback(privileges = null) {
+        if (privileges) {
+            return privileges;
+        }
+        const { authInfo: { authenticatedUserPrivileges }, } = await this.connectionStatus();
+        return authenticatedUserPrivileges;
+    }
+    async listCollections(databaseName, filter = {}, { nameOnly, privileges = null, } = {}) {
+        const logop = this._startLogOp(mongoLogId(1001000032), 'Running listCollections', { db: databaseName, nameOnly: nameOnly !== null && nameOnly !== void 0 ? nameOnly : false });
+        const db = this._initializedClient.db(databaseName);
+        const listCollections = async () => {
+            try {
+                return await db.listCollections(filter, { nameOnly }).toArray();
             }
-            callback(null, data);
-        });
+            catch (err) {
+                log.warn(mongoLogId(1001000099), this._logCtx(), 'Failed to run listCollections', { message: err.message });
+                return [];
+            }
+        };
+        const getCollectionsFromPrivileges = async () => {
+            const databases = (0, instance_detail_helper_1.getPrivilegesByDatabaseAndCollection)(await this._getPrivilegesOrFallback(privileges), ['find']);
+            return Object.keys(databases[databaseName] || {})
+                .filter(Boolean)
+                .map((name) => ({ name }));
+        };
+        try {
+            const [listedCollections, collectionsFromPrivileges] = await Promise.all([
+                listCollections(),
+                getCollectionsFromPrivileges(),
+            ]);
+            const collections = uniqueBy([...collectionsFromPrivileges, ...listedCollections], 'name').map((coll) => (0, instance_detail_helper_1.adaptCollectionInfo)({ db: databaseName, ...coll }));
+            logop(null, { collectionsCount: collections.length });
+            return collections;
+        }
+        catch (err) {
+            logop(err);
+            throw err;
+        }
     }
-    listDatabases(callback) {
-        this.mongoClient.db('admin').command({
-            listDatabases: 1,
-        }, {
-            readPreference: this.model.readPreference,
-        }, (error, result) => {
-            if (error) {
-                return callback(this._translateMessage(error));
+    async listDatabases({ nameOnly, privileges = null, } = {}) {
+        const logop = this._startLogOp(mongoLogId(1001000033), 'Running listDatabases', { nameOnly: nameOnly !== null && nameOnly !== void 0 ? nameOnly : false });
+        const adminDb = this._initializedClient.db('admin');
+        const listDatabases = async () => {
+            try {
+                const { databases } = await (0, run_command_1.runCommand)(adminDb, {
+                    listDatabases: 1,
+                    nameOnly,
+                });
+                return databases;
             }
-            callback(null, result === null || result === void 0 ? void 0 : result.databases);
-        });
+            catch (err) {
+                log.warn(mongoLogId(1001000098), this._logCtx(), 'Failed to run listDatabases', { message: err.message });
+                return [];
+            }
+        };
+        const getDatabasesFromPrivileges = async () => {
+            const databases = (0, instance_detail_helper_1.getPrivilegesByDatabaseAndCollection)(await this._getPrivilegesOrFallback(privileges), ['find']);
+            return Object.keys(databases)
+                .filter(Boolean)
+                .map((name) => ({ name }));
+        };
+        try {
+            const [listedDatabases, databasesFromPrivileges] = await Promise.all([
+                listDatabases(),
+                getDatabasesFromPrivileges(),
+            ]);
+            const databases = uniqueBy([...databasesFromPrivileges, ...listedDatabases], 'name').map((db) => {
+                return { _id: db.name, name: db.name, ...(0, instance_detail_helper_1.adaptDatabaseInfo)(db) };
+            });
+            logop(null, { databasesCount: databases.length });
+            return databases;
+        }
+        catch (err) {
+            logop(err);
+            throw err;
+        }
     }
-    connect(done) {
-        debug('connecting...');
+    async connect() {
+        if (this._client) {
+            debug('already connected');
+            return;
+        }
         if (this._isConnecting) {
-            setImmediate(() => {
-                done(new Error('Connect method has been called more than once without disconnecting.'));
-            });
+            debug('connect method called more than once');
             return;
         }
+        debug('connecting...');
         this._isConnecting = true;
-        legacy_connect_1.default(this.model, this.setupListeners.bind(this), (err, client, tunnel, connectionOptions) => {
-            if (err) {
-                this._isConnecting = false;
-                return done(this._translateMessage(err));
-            }
+        log.info(mongoLogId(1001000014), this._logCtx(), 'Connecting', {
+            url: (0, redact_1.redactConnectionString)(this._connectionOptions.connectionString),
+        });
+        try {
+            const tunnelLocalPort = this._connectionOptions.sshTunnel
+                ? await (0, get_port_1.default)()
+                : 0;
+            const [client, tunnel, connectionOptions] = await (0, connect_mongo_client_1.default)(this._connectionOptions, this.setupListeners.bind(this), tunnelLocalPort);
+            const attr = {
+                isWritable: this.isWritable(),
+                isMongos: this.isMongos(),
+            };
+            log.info(mongoLogId(1001000015), this._logCtx(), 'Connected', attr);
+            debug('connected!', attr);
             this._client = client;
             this._tunnel = tunnel;
             this._mongoClientConnectionOptions = connectionOptions;
-            debug('connected!', {
-                isWritable: this.isWritable(),
-                isMongos: this.isMongos(),
-            });
-            this._database = this._client.db(this.model.ns || 'admin');
-            done(null, this);
-            this.emit('readable');
-        });
-        return;
+        }
+        finally {
+            this._isConnecting = false;
+        }
     }
     estimatedCount(ns, options, callback) {
-        this._collection(ns).estimatedDocumentCount(options, (err, result) => callback(err, result));
+        const logop = this._startLogOp(mongoLogId(1001000034), 'Running estimatedCount', { ns });
+        this._collection(ns).estimatedDocumentCount(options, (err, result) => {
+            logop(err, result);
+            callback(err, result);
+        });
     }
     count(ns, filter, options, callback) {
-        this._collection(ns).countDocuments(filter, options, (err, result) => callback(err, result));
+        const logop = this._startLogOp(mongoLogId(1001000035), 'Running countDocuments', { ns });
+        this._collection(ns).countDocuments(filter, options, (err, result) => {
+            logop(err, result);
+            callback(err, result);
+        });
     }
     createCollection(ns, options, callback) {
         const collectionName = this._collectionName(ns);
-        const db = this.mongoClient.db(this._databaseName(ns));
+        const db = this._initializedClient.db(this._databaseName(ns));
+        const logop = this._startLogOp(mongoLogId(1001000036), 'Running createCollection', { ns, options });
         db.createCollection(collectionName, options, (error, result) => {
+            logop(error);
             if (error) {
                 return callback(this._translateMessage(error));
             }
@@ -139,7 +260,9 @@ class DataService extends events_1.EventEmitter {
         });
     }
     createIndex(ns, spec, options, callback) {
+        const logop = this._startLogOp(mongoLogId(1001000037), 'Running createIndex', { ns, spec, options });
         this._collection(ns).createIndex(spec, options, (error, result) => {
+            logop(error);
             if (error) {
                 return callback(this._translateMessage(error));
             }
@@ -147,18 +270,17 @@ class DataService extends events_1.EventEmitter {
         });
     }
     database(name, options, callback) {
-        async_1.default.parallel({
-            stats: this.databaseStats.bind(this, name),
-            collections: this.collections.bind(this, name),
-        }, (error, db) => {
-            if (error) {
-                return callback(this._translateMessage(error));
-            }
-            callback(null, this._buildDatabaseDetail(name, db));
+        const asyncColls = (0, util_1.promisify)(this.collections.bind(this));
+        void Promise.all([this.databaseStats(name), asyncColls(name)]).then(([stats, collections]) => {
+            callback(null, this._buildDatabaseDetail(name, { stats, collections }));
+        }, (err) => {
+            callback(this._translateMessage(err));
         });
     }
     deleteOne(ns, filter, options, callback) {
+        const logop = this._startLogOp(mongoLogId(1001000038), 'Running deleteOne', { ns });
         this._collection(ns).deleteOne(filter, options, (error, result) => {
+            logop(error, result);
             if (error) {
                 return callback(this._translateMessage(error));
             }
@@ -166,37 +288,31 @@ class DataService extends events_1.EventEmitter {
         });
     }
     deleteMany(ns, filter, options, callback) {
+        const logop = this._startLogOp(mongoLogId(1001000039), 'Running deleteMany', { ns });
         this._collection(ns).deleteMany(filter, options, (error, result) => {
+            logop(error, result);
             if (error) {
                 return callback(this._translateMessage(error));
             }
             callback(null, result);
         });
     }
-    disconnect(callback) {
-        if (!this._client) {
-            setImmediate(() => {
-                callback(null);
-            });
-            return;
+    async disconnect() {
+        var _a, _b;
+        log.info(mongoLogId(1001000016), this._logCtx(), 'Disconnecting');
+        try {
+            await ((_a = this._client) === null || _a === void 0 ? void 0 : _a.close(true).catch((err) => debug('failed to close MongoClient', err)));
+            await ((_b = this._tunnel) === null || _b === void 0 ? void 0 : _b.close().catch((err) => debug('failed to close tunnel', err)));
+        }
+        finally {
+            this._cleanup();
+            log.info(mongoLogId(1001000017), this._logCtx(), 'Fully closed');
         }
-        this._client.close(true, (err) => {
-            if (this._tunnel) {
-                debug('mongo client closed. shutting down ssh tunnel');
-                this._tunnel.close().finally(() => {
-                    this._cleanup();
-                    debug('ssh tunnel stopped');
-                    callback(err);
-                });
-            }
-            else {
-                this._cleanup();
-                return callback(err);
-            }
-        });
     }
     dropCollection(ns, callback) {
+        const logop = this._startLogOp(mongoLogId(1001000059), 'Running dropCollection', { ns });
         this._collection(ns).drop((error, result) => {
+            logop(error, result);
             if (error) {
                 return callback(this._translateMessage(error));
             }
@@ -204,9 +320,11 @@ class DataService extends events_1.EventEmitter {
         });
     }
     dropDatabase(name, callback) {
-        this.mongoClient
+        const logop = this._startLogOp(mongoLogId(1001000040), 'Running dropDatabase', { db: name });
+        this._initializedClient
             .db(this._databaseName(name))
             .dropDatabase((error, result) => {
+            logop(error, result);
             if (error) {
                 return callback(this._translateMessage(error));
             }
@@ -214,7 +332,9 @@ class DataService extends events_1.EventEmitter {
         });
     }
     dropIndex(ns, name, callback) {
+        const logop = this._startLogOp(mongoLogId(1001000060), 'Running dropIndex', { ns, name });
         this._collection(ns).dropIndex(name, (error, result) => {
+            logop(error, result);
             if (error) {
                 return callback(this._translateMessage(error));
             }
@@ -222,20 +342,28 @@ class DataService extends events_1.EventEmitter {
         });
     }
     aggregate(ns, pipeline, options, callback) {
+        log.info(mongoLogId(1001000041), this._logCtx(), 'Running aggregation', {
+            ns,
+            stages: pipeline.map((stage) => Object.keys(stage)[0]),
+        });
         if (typeof options === 'function') {
             callback = options;
             options = undefined;
         }
         const cursor = this._collection(ns).aggregate(pipeline, options);
-        if (lodash_1.isFunction(callback)) {
+        if ((0, lodash_1.isFunction)(callback)) {
             process.nextTick(callback, null, cursor);
             return;
         }
         return cursor;
     }
     find(ns, filter, options, callback) {
+        const logop = this._startLogOp(mongoLogId(1001000042), 'Running find', {
+            ns,
+        });
         const cursor = this._collection(ns).find(filter, options);
         cursor.toArray((error, documents) => {
+            logop(error);
             if (error) {
                 return callback(this._translateMessage(error));
             }
@@ -243,10 +371,13 @@ class DataService extends events_1.EventEmitter {
         });
     }
     fetch(ns, filter, options) {
+        const logop = this._startLogOp(mongoLogId(1001000043), 'Running raw find', { ns });
         return this._collection(ns).find(filter, options);
     }
     findOneAndReplace(ns, filter, replacement, options, callback) {
+        const logop = this._startLogOp(mongoLogId(1001000044), 'Running findOneAndReplace', { ns });
         this._collection(ns).findOneAndReplace(filter, replacement, options, (error, result) => {
+            logop(error);
             if (error) {
                 return callback(this._translateMessage(error));
             }
@@ -254,7 +385,9 @@ class DataService extends events_1.EventEmitter {
         });
     }
     findOneAndUpdate(ns, filter, update, options, callback) {
+        const logop = this._startLogOp(mongoLogId(1001000045), 'Running findOneAndUpdate', { ns });
         this._collection(ns).findOneAndUpdate(filter, update, options, (error, result) => {
+            logop(error);
             if (error) {
                 return callback(this._translateMessage(error));
             }
@@ -262,9 +395,11 @@ class DataService extends events_1.EventEmitter {
         });
     }
     explain(ns, filter, options, callback) {
+        const logop = this._startLogOp(mongoLogId(1001000046), 'Running find explain', { ns });
         this._collection(ns)
             .find(filter, options)
             .explain((error, explanation) => {
+            logop(error);
             if (error) {
                 return callback(this._translateMessage(error));
             }
@@ -272,29 +407,34 @@ class DataService extends events_1.EventEmitter {
         });
     }
     indexes(ns, options, callback) {
-        getIndexes(this.mongoClient, ns, (error, data) => {
+        const logop = this._startLogOp(mongoLogId(1001000047), 'Listing indexes', { ns });
+        getIndexes(this._initializedClient, ns, (error, data) => {
+            logop(error);
             if (error) {
                 return callback(this._translateMessage(error));
             }
             callback(null, data);
         });
     }
-    instance(options, callback) {
-        instance_detail_helper_1.getInstance(this.mongoClient, this.db, ((error, instanceData) => {
-            if (error) {
-                return callback(this._translateMessage(error));
-            }
-            const instance = {
-                ...instanceData,
-                _id: `${this.model.hostname}:${this.model.port}`,
-                hostname: this.model.hostname,
-                port: this.model.port,
-            };
-            callback(null, instance);
-        }));
+    async instance() {
+        try {
+            const instanceData = await (0, instance_detail_helper_1.getInstance)(this._initializedClient);
+            log.info(mongoLogId(1001000024), this._logCtx(), 'Fetched instance information', {
+                serverVersion: instanceData.build.version,
+                genuineMongoDB: instanceData.genuineMongoDB,
+                dataLake: instanceData.dataLake,
+                featureCompatibilityVersion: instanceData.featureCompatibilityVersion,
+            });
+            return instanceData;
+        }
+        catch (err) {
+            throw this._translateMessage(err);
+        }
     }
     insertOne(ns, doc, options, callback) {
+        const logop = this._startLogOp(mongoLogId(1001000048), 'Running insertOne', { ns });
         this._collection(ns).insertOne(doc, options, (error, result) => {
+            logop(error, { acknowledged: result === null || result === void 0 ? void 0 : result.acknowledged });
             if (error) {
                 return callback(this._translateMessage(error));
             }
@@ -302,7 +442,12 @@ class DataService extends events_1.EventEmitter {
         });
     }
     insertMany(ns, docs, options, callback) {
+        const logop = this._startLogOp(mongoLogId(1001000049), 'Running insertOne', { ns });
         this._collection(ns).insertMany(docs, options, (error, result) => {
+            logop(error, {
+                acknowledged: result === null || result === void 0 ? void 0 : result.acknowledged,
+                insertedCount: result === null || result === void 0 ? void 0 : result.insertedCount,
+            });
             if (error) {
                 return callback(this._translateMessage(error));
             }
@@ -313,13 +458,15 @@ class DataService extends events_1.EventEmitter {
         return this._collection(ns).insertMany(docs, options);
     }
     updateCollection(ns, flags, callback) {
+        const logop = this._startLogOp(mongoLogId(1001000050), 'Running updateCollection', { ns });
         const collectionName = this._collectionName(ns);
-        const db = this.mongoClient.db(this._databaseName(ns));
+        const db = this._initializedClient.db(this._databaseName(ns));
         const command = {
             collMod: collectionName,
             ...flags,
         };
         db.command(command, (error, result) => {
+            logop(error, result);
             if (error) {
                 return callback(this._translateMessage(error));
             }
@@ -327,7 +474,9 @@ class DataService extends events_1.EventEmitter {
         });
     }
     updateOne(ns, filter, update, options, callback) {
+        const logop = this._startLogOp(mongoLogId(1001000051), 'Running updateOne', { ns });
         this._collection(ns).updateOne(filter, update, options, (error, result) => {
+            logop(error, result);
             if (error) {
                 return callback(this._translateMessage(error));
             }
@@ -335,7 +484,9 @@ class DataService extends events_1.EventEmitter {
         });
     }
     updateMany(ns, filter, update, options, callback) {
+        const logop = this._startLogOp(mongoLogId(1001000052), 'Running updateMany', { ns });
         this._collection(ns).updateMany(filter, update, options, (error, result) => {
+            logop(error, result);
             if (error) {
                 return callback(this._translateMessage(error));
             }
@@ -343,14 +494,18 @@ class DataService extends events_1.EventEmitter {
         });
     }
     currentOp(includeAll, callback) {
-        this.mongoClient
+        const logop = this._startLogOp(mongoLogId(1001000053), 'Running currentOp');
+        this._initializedClient
             .db('admin')
             .command({ currentOp: 1, $all: includeAll }, (error, result) => {
+            logop(error);
             if (error) {
-                this.mongoClient
+                const logop = this._startLogOp(mongoLogId(1001000054), 'Searching $cmd.sys.inprog manually');
+                this._initializedClient
                     .db('admin')
                     .collection('$cmd.sys.inprog')
                     .findOne({ $all: includeAll }, (error2, result2) => {
+                    logop(error2);
                     if (error2) {
                         return callback(this._translateMessage(error2));
                     }
@@ -362,10 +517,12 @@ class DataService extends events_1.EventEmitter {
         });
     }
     getLastSeenTopology() {
-        return this.lastSeenTopology;
+        return this._lastSeenTopology;
     }
     serverstats(callback) {
-        this.db.admin().serverStatus((error, result) => {
+        const logop = this._startLogOp(mongoLogId(1001000061), 'Running serverStats');
+        this._defaultDb.admin().serverStatus((error, result) => {
+            logop(error);
             if (error) {
                 return callback(this._translateMessage(error));
             }
@@ -373,7 +530,9 @@ class DataService extends events_1.EventEmitter {
         });
     }
     top(callback) {
-        this.db.admin().command({ top: 1 }, (error, result) => {
+        const logop = this._startLogOp(mongoLogId(1001000062), 'Running top');
+        this._defaultDb.admin().command({ top: 1 }, (error, result) => {
+            logop(error);
             if (error) {
                 return callback(this._translateMessage(error));
             }
@@ -383,9 +542,16 @@ class DataService extends events_1.EventEmitter {
     createView(name, sourceNs, pipeline, options, callback) {
         options.viewOn = this._collectionName(sourceNs);
         options.pipeline = pipeline;
-        this.mongoClient
+        const logop = this._startLogOp(mongoLogId(1001000055), 'Running createView', {
+            name,
+            sourceNs,
+            stages: pipeline.map((stage) => Object.keys(stage)[0]),
+            options,
+        });
+        this._initializedClient
             .db(this._databaseName(sourceNs))
             .createCollection(name, options, (error, result) => {
+            logop(error, result);
             if (error) {
                 return callback(this._translateMessage(error));
             }
@@ -399,8 +565,15 @@ class DataService extends events_1.EventEmitter {
             collMod: name,
             ...options,
         };
-        const db = this.mongoClient.db(this._databaseName(sourceNs));
+        const db = this._initializedClient.db(this._databaseName(sourceNs));
+        const logop = this._startLogOp(mongoLogId(1001000056), 'Running updateView', {
+            name,
+            sourceNs,
+            stages: pipeline.map((stage) => Object.keys(stage)[0]),
+            options,
+        });
         db.command(command, (error, result) => {
+            logop(error, result);
             if (error) {
                 return callback(this._translateMessage(error));
             }
@@ -433,11 +606,13 @@ class DataService extends events_1.EventEmitter {
         });
     }
     startSession() {
-        return this.mongoClient.startSession();
+        return this._initializedClient.startSession();
     }
-    killSession(session) {
-        return this.mongoClient.db('admin').command({
-            killSessions: [session.id],
+    killSessions(sessions) {
+        return this._initializedClient.db('admin').command({
+            killSessions: Array.isArray(sessions)
+                ? sessions.map((s) => s.id)
+                : [sessions.id],
         });
     }
     isConnected() {
@@ -446,71 +621,146 @@ class DataService extends events_1.EventEmitter {
     setupListeners(client) {
         this._client = client;
         if (client) {
-            client.on('status', (...args) => {
-                debug('status', args);
-                this.emit('status', args[0]);
-            });
             client.on('serverDescriptionChanged', (evt) => {
-                debug('serverDescriptionChanged', evt);
+                var _a;
+                log.info(mongoLogId(1001000018), this._logCtx(), 'Server description changed', {
+                    address: evt.address,
+                    error: (_a = evt.newDescription.error) !== null && _a !== void 0 ? _a : null,
+                    previousType: evt.previousDescription.type,
+                    newType: evt.newDescription.type,
+                });
                 this.emit('serverDescriptionChanged', evt);
             });
-            client.on('serverOpening', (...args) => {
-                debug('serverOpening', args);
-                this.emit('serverOpening', args[0]);
+            client.on('serverOpening', (evt) => {
+                log.info(mongoLogId(1001000019), this._logCtx(), 'Server opening', {
+                    address: evt.address,
+                });
+                this.emit('serverOpening', evt);
             });
-            client.on('serverClosed', (...args) => {
-                debug('serverClosed', args);
-                this.emit('serverClosed', args[0]);
+            client.on('serverClosed', (evt) => {
+                log.info(mongoLogId(1001000020), this._logCtx(), 'Server closed', {
+                    address: evt.address,
+                });
+                this.emit('serverClosed', evt);
             });
-            client.on('topologyOpening', (...args) => {
-                debug('topologyOpening', args);
-                this.emit('topologyOpening', args[0]);
+            client.on('topologyOpening', (evt) => {
+                this.emit('topologyOpening', evt);
             });
-            client.on('topologyClosed', (...args) => {
-                debug('topologyClosed', args);
-                this.emit('topologyClosed', args[0]);
+            client.on('topologyClosed', (evt) => {
+                this.emit('topologyClosed', evt);
             });
-            client.on('topologyDescriptionChanged', (...args) => {
-                debug('topologyDescriptionChanged', args);
-                this._isWritable = this.checkIsWritable(args[0]);
-                this._isMongos = this.checkIsMongos(args[0]);
-                debug('updated to', {
+            client.on('topologyDescriptionChanged', (evt) => {
+                this._isWritable = this._checkIsWritable(evt);
+                this._isMongos = this._checkIsMongos(evt);
+                const attr = {
                     isWritable: this.isWritable(),
                     isMongos: this.isMongos(),
-                });
-                this.lastSeenTopology = args[0].newDescription;
-                this.emit('topologyDescriptionChanged', args[0]);
+                    previousType: evt.previousDescription.type,
+                    newType: evt.newDescription.type,
+                };
+                log.info(mongoLogId(1001000021), this._logCtx(), 'Topology description changed', attr);
+                this._lastSeenTopology = evt.newDescription;
+                this.emit('topologyDescriptionChanged', evt);
             });
-            client.on('serverHeartbeatSucceeded', (...args) => {
-                debug('serverHeartbeatSucceeded', args);
-                this.emit('serverHeartbeatSucceeded', args[0]);
+            const heartbeatStatusMap = new Map();
+            const isSignificantDurationChange = (before, after) => {
+                before = Math.max(before, 200);
+                after = Math.max(after, 200);
+                return Math.abs(Math.log2(before / after)) >= 1;
+            };
+            client.on('serverHeartbeatSucceeded', (evt) => {
+                const previousStatus = heartbeatStatusMap.get(evt.connectionId);
+                if (!previousStatus ||
+                    previousStatus.failure ||
+                    isSignificantDurationChange(previousStatus.duration, evt.duration)) {
+                    heartbeatStatusMap.set(evt.connectionId, {
+                        failure: null,
+                        duration: evt.duration,
+                    });
+                    log.write({
+                        s: 'D2',
+                        id: mongoLogId(1001000022),
+                        ctx: this._logCtx(),
+                        msg: 'Server heartbeat succeeded',
+                        attr: {
+                            connectionId: evt.connectionId,
+                            duration: evt.duration,
+                        },
+                    });
+                }
+                this.emit('serverHeartbeatSucceeded', evt);
+            });
+            client.on('serverHeartbeatFailed', (evt) => {
+                const previousStatus = heartbeatStatusMap.get(evt.connectionId);
+                if (!previousStatus ||
+                    !previousStatus.failure ||
+                    isSignificantDurationChange(previousStatus.duration, evt.duration)) {
+                    heartbeatStatusMap.set(evt.connectionId, {
+                        failure: evt.failure.message,
+                        duration: evt.duration,
+                    });
+                    log.warn(mongoLogId(1001000023), this._logCtx(), 'Server heartbeat failed', {
+                        connectionId: evt.connectionId,
+                        duration: evt.duration,
+                        failure: evt.failure.message,
+                    });
+                }
+                this.emit('serverHeartbeatFailed', evt);
             });
-            client.on('serverHeartbeatFailed', (...args) => {
-                debug('serverHeartbeatFailed', args);
-                this.emit('serverHeartbeatFailed', args[0]);
+            client.on('commandSucceeded', (evt) => {
+                const { address, connectionId, duration, commandName } = evt;
+                log.write({
+                    s: 'D2',
+                    id: mongoLogId(1001000029),
+                    ctx: this._logCtx(),
+                    msg: 'Driver command succeeded',
+                    attr: {
+                        address,
+                        serverConnectionId: connectionId,
+                        duration,
+                        commandName,
+                    },
+                });
+            });
+            client.on('commandFailed', (evt) => {
+                const { address, connectionId, duration, commandName, failure } = evt;
+                log.write({
+                    s: 'D1',
+                    id: mongoLogId(1001000030),
+                    ctx: this._logCtx(),
+                    msg: 'Driver command failed',
+                    attr: {
+                        address,
+                        serverConnectionId: connectionId,
+                        duration,
+                        commandName,
+                        failure: failure.message,
+                    },
+                });
             });
         }
     }
-    get mongoClient() {
+    get _initializedClient() {
         if (!this._client) {
             throw new Error('client not yet initialized');
         }
         return this._client;
     }
-    get db() {
-        if (!this._database) {
-            throw new Error('database not yet initialized');
-        }
-        return this._database;
+    get _defaultDb() {
+        return this._initializedClient.db();
     }
-    databaseStats(name, callback) {
-        const db = this.mongoClient.db(name);
-        db.command({ dbStats: 1 }, (error, data) => {
-            if (error) {
-                return callback(this._translateMessage(error));
-            }
-            callback(null, this._buildDatabaseStats(data || {}));
-        });
+    async databaseStats(name) {
+        const logop = this._startLogOp(mongoLogId(1001000057), 'Running databaseStats', { db: name });
+        try {
+            const db = this._initializedClient.db(name);
+            const stats = await (0, run_command_1.runCommand)(db, { dbStats: 1 });
+            const normalized = (0, instance_detail_helper_1.adaptDatabaseInfo)(stats);
+            return { name, ...normalized };
+        }
+        catch (err) {
+            logop(err);
+            throw this._translateMessage(err);
+        }
     }
     _buildCollectionDetail(ns, data) {
         return {
@@ -522,6 +772,7 @@ class DataService extends events_1.EventEmitter {
         };
     }
     _buildCollectionStats(databaseName, collectionName, data) {
+        var _a, _b, _c, _d, _e, _f;
         return {
             ns: databaseName + '.' + collectionName,
             name: collectionName,
@@ -530,11 +781,13 @@ class DataService extends events_1.EventEmitter {
             max: data.max,
             is_power_of_two: data.userFlags === 1,
             index_sizes: data.indexSizes,
-            document_count: data.count,
+            document_count: (_a = data.count) !== null && _a !== void 0 ? _a : 0,
             document_size: data.size,
-            storage_size: data.storageSize,
-            index_count: data.nindexes,
-            index_size: data.totalIndexSize,
+            avg_document_size: (_b = data.avgObjSize) !== null && _b !== void 0 ? _b : 0,
+            storage_size: (_c = data.storageSize) !== null && _c !== void 0 ? _c : 0,
+            free_storage_size: (_d = data.freeStorageSize) !== null && _d !== void 0 ? _d : 0,
+            index_count: (_e = data.nindexes) !== null && _e !== void 0 ? _e : 0,
+            index_size: (_f = data.totalIndexSize) !== null && _f !== void 0 ? _f : 0,
             padding_factor: data.paddingFactor,
             extent_count: data.numExtents,
             extent_last_size: data.lastExtentSize,
@@ -553,30 +806,17 @@ class DataService extends events_1.EventEmitter {
             collections: db.collections,
         };
     }
-    _buildDatabaseStats(data) {
-        return {
-            document_count: data.objects,
-            document_size: data.dataSize,
-            storage_size: data.storageSize,
-            index_count: data.indexes,
-            index_size: data.indexSize,
-            extent_count: data.numExtents,
-            file_size: data.fileSize,
-            ns_size: data.nsSizeMB * 1024 * 1024,
-        };
-    }
     _collection(ns) {
-        return this.mongoClient
+        return this._initializedClient
             .db(this._databaseName(ns))
             .collection(this._collectionName(ns));
     }
     _collectionNames(databaseName, callback) {
-        this.listCollections(databaseName, {}, (error, collections) => {
-            if (error) {
-                return callback(this._translateMessage(error));
-            }
+        this.listCollections(databaseName, {}, { nameOnly: true }).then((collections) => {
             const names = collections === null || collections === void 0 ? void 0 : collections.map((c) => c.name);
             callback(null, names);
+        }, (error) => {
+            callback(this._translateMessage(error));
         });
     }
     _collectionName(ns) {
@@ -585,10 +825,10 @@ class DataService extends events_1.EventEmitter {
     _databaseName(ns) {
         return parseNamespace(ns).database;
     }
-    checkIsWritable(evt) {
+    _checkIsWritable(evt) {
         return [...evt.newDescription.servers.values()].some((server) => server.isWritable);
     }
-    checkIsMongos(evt) {
+    _checkIsMongos(evt) {
         return evt.newDescription.type === 'Sharded';
     }
     _translateMessage(error) {
@@ -601,14 +841,39 @@ class DataService extends events_1.EventEmitter {
         return error;
     }
     _cleanup() {
+        if (this._client) {
+            this._client.removeAllListeners();
+        }
         this._client = undefined;
-        this._database = undefined;
+        this._tunnel = undefined;
         this._mongoClientConnectionOptions = undefined;
-        this._tunnel = null;
         this._isWritable = false;
         this._isMongos = false;
         this._isConnecting = false;
     }
+    _startLogOp(logId, op, attr = {}) {
+        return (error, result) => {
+            if (error) {
+                const { message } = this._translateMessage(error);
+                log.error(mongoLogId(1001000058), this._logCtx(), 'Failed to perform data service operation', {
+                    op,
+                    message,
+                    ...attr,
+                });
+            }
+            else {
+                if (result) {
+                    attr = { ...attr, result };
+                }
+                if (Object.keys(attr).length > 0) {
+                    log.info(logId, this._logCtx(), op, attr);
+                }
+                else {
+                    log.info(logId, this._logCtx(), op);
+                }
+            }
+        };
+    }
 }
-module.exports = DataService;
+exports.default = DataService;
 //# sourceMappingURL=data-service.js.map