mirror of
https://github.com/mongodb/mongo.git
synced 2024-12-01 09:32:32 +01:00
102 lines
3.5 KiB
C++
102 lines
3.5 KiB
C++
// top.h : DB usage monitor.
|
|
//
|
|
|
|
/**
|
|
* Copyright (C) 2009 10gen Inc.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License, version 3,
|
|
* as published by the Free Software Foundation.
|
|
*
|
|
* 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
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
namespace mongo {
|
|
|
|
// No two functions of this class may be called concurrently.
|
|
class Top {
|
|
public:
|
|
typedef boost::posix_time::ptime T;
|
|
typedef boost::posix_time::time_duration D;
|
|
static void clientStart( const char *client ) {
|
|
clientStop();
|
|
currentStart_ = currentTime();
|
|
current_ = client;
|
|
}
|
|
static void clientStop() {
|
|
if ( currentStart_ == T() )
|
|
return;
|
|
D d = currentTime() - currentStart_;
|
|
size_t dot = current_.rfind( "." );
|
|
if ( dot == string::npos || dot != current_.length() - 1 )
|
|
recordUsage( current_, d );
|
|
while( dot != string::npos ) {
|
|
current_ = current_.substr( 0, dot );
|
|
recordUsage( current_, d );
|
|
dot = current_.rfind( "." );
|
|
}
|
|
currentStart_ = T();
|
|
}
|
|
struct Usage { string ns; D time; double pct; };
|
|
static void usage( vector< Usage > &res ) {
|
|
multimap< D, string, more > sorted;
|
|
for( map< string, D >::iterator i = snapshot_.begin(); i != snapshot_.end(); ++i )
|
|
sorted.insert( make_pair( i->second, i->first ) );
|
|
for( multimap< D, string, more >::iterator i = sorted.begin(); i != sorted.end(); ++i ) {
|
|
Usage u;
|
|
u.ns = i->second;
|
|
u.time = totalUsage_[ u.ns ];
|
|
u.pct = snapshotDuration_ != D() ? 100.0 * i->first.ticks() / snapshotDuration_.ticks() : 0;
|
|
res.push_back( u );
|
|
}
|
|
for( map< string, D >::iterator i = totalUsage_.begin(); i != totalUsage_.end(); ++i ) {
|
|
if ( snapshot_.count( i->first ) != 0 )
|
|
continue;
|
|
Usage u;
|
|
u.ns = i->first;
|
|
u.time = i->second;
|
|
u.pct = 0;
|
|
res.push_back( u );
|
|
}
|
|
}
|
|
static void completeSnapshot() {
|
|
if ( &snapshot_ == &snapshotA_ ) {
|
|
snapshot_ = snapshotB_;
|
|
nextSnapshot_ = snapshotA_;
|
|
} else {
|
|
snapshot_ = snapshotA_;
|
|
nextSnapshot_ = snapshotB_;
|
|
}
|
|
snapshotDuration_ = currentTime() - snapshotStart_;
|
|
snapshotStart_ = currentTime();
|
|
nextSnapshot_.clear();
|
|
}
|
|
private:
|
|
typedef map< string, D > UsageMap;
|
|
static T currentTime() {
|
|
return boost::posix_time::microsec_clock::universal_time();
|
|
}
|
|
static void recordUsage( const string &client, D duration ) {
|
|
totalUsage_[ client ] += duration;
|
|
nextSnapshot_[ client ] += duration;
|
|
}
|
|
struct more { bool operator()( const D &a, const D &b ) { return a > b; } };
|
|
static string current_;
|
|
static T currentStart_;
|
|
static T snapshotStart_;
|
|
static D snapshotDuration_;
|
|
static UsageMap totalUsage_;
|
|
static UsageMap snapshotA_;
|
|
static UsageMap snapshotB_;
|
|
static UsageMap &snapshot_;
|
|
static UsageMap &nextSnapshot_;
|
|
};
|
|
|
|
} // namespace mongo
|