1 files changed, 84 insertions, 26 deletions

diff --git a/db/stats/counters.cpp b/db/stats/counters.cpp
index a2d4cfb..889e8a8 100644
--- a/db/stats/counters.cpp
+++ b/db/stats/counters.cpp
@@ -22,7 +22,7 @@
 
 namespace mongo {
 
-    OpCounters::OpCounters(){
+    OpCounters::OpCounters() {
         int zero = 0;
 
         BSONObjBuilder b;
@@ -42,16 +42,16 @@ namespace mongo {
         _command = (AtomicUInt*)_obj["command"].value();
     }
 
-    void OpCounters::gotOp( int op , bool isCommand ){
-        switch ( op ){
+    void OpCounters::gotOp( int op , bool isCommand ) {
+        switch ( op ) {
         case dbInsert: /*gotInsert();*/ break; // need to handle multi-insert
-        case dbQuery: 
+        case dbQuery:
             if ( isCommand )
                 gotCommand();
-            else 
-                gotQuery(); 
+            else
+                gotQuery();
             break;
-            
+
         case dbUpdate: gotUpdate(); break;
         case dbDelete: gotDelete(); break;
         case dbGetMore: gotGetMore(); break;
@@ -62,24 +62,48 @@ namespace mongo {
         default: log() << "OpCounters::gotOp unknown op: " << op << endl;
         }
     }
-    
-    IndexCounters::IndexCounters(){
+
+    BSONObj& OpCounters::getObj() {
+        const unsigned MAX = 1 << 30;
+        RARELY {
+            bool wrap =
+            _insert->get() > MAX ||
+            _query->get() > MAX ||
+            _update->get() > MAX ||
+            _delete->get() > MAX ||
+            _getmore->get() > MAX ||
+            _command->get() > MAX;
+
+            if ( wrap ) {
+                _insert->zero();
+                _query->zero();
+                _update->zero();
+                _delete->zero();
+                _getmore->zero();
+                _command->zero();
+            }
+
+        }
+        return _obj;
+    }
+
+    IndexCounters::IndexCounters() {
         _memSupported = _pi.blockCheckSupported();
-        
+
         _btreeMemHits = 0;
         _btreeMemMisses = 0;
         _btreeAccesses = 0;
-        
-        
+
+
         _maxAllowed = ( numeric_limits< long long >::max() ) / 2;
         _resets = 0;
 
         _sampling = 0;
         _samplingrate = 100;
     }
-    
-    void IndexCounters::append( BSONObjBuilder& b ){
-        if ( ! _memSupported ){
+
+    void IndexCounters::append( BSONObjBuilder& b ) {
+        if ( ! _memSupported ) {
             b.append( "note" , "not supported on this platform" );
             return;
         }
@@ -90,33 +114,33 @@ namespace mongo {
         bb.appendNumber( "misses" , _btreeMemMisses );
 
         bb.append( "resets" , _resets );
-        
+
         bb.append( "missRatio" , (_btreeAccesses ? (_btreeMemMisses / (double)_btreeAccesses) : 0) );
-        
+
         bb.done();
-        
-        if ( _btreeAccesses > _maxAllowed ){
+
+        if ( _btreeAccesses > _maxAllowed ) {
             _btreeAccesses = 0;
             _btreeMemMisses = 0;
             _btreeMemHits = 0;
             _resets++;
         }
     }
-    
+
     FlushCounters::FlushCounters()
         : _total_time(0)
         , _flushes(0)
         , _last()
     {}
 
-    void FlushCounters::flushed(int ms){
+    void FlushCounters::flushed(int ms) {
         _flushes++;
         _total_time += ms;
         _last_time = ms;
         _last = jsTime();
     }
 
-    void FlushCounters::append( BSONObjBuilder& b ){
+    void FlushCounters::append( BSONObjBuilder& b ) {
         b.appendNumber( "flushes" , _flushes );
         b.appendNumber( "total_ms" , _total_time );
         b.appendNumber( "average_ms" , (_flushes ? (_total_time / double(_flushes)) : 0.0) );
@@ -125,25 +149,59 @@ namespace mongo {
     }
 
 
-    void GenericCounter::hit( const string& name , int count ){
+    void GenericCounter::hit( const string& name , int count ) {
         scoped_lock lk( _mutex );
         _counts[name]++;
     }
-    
+
     BSONObj GenericCounter::getObj() {
         BSONObjBuilder b(128);
         {
             mongo::mutex::scoped_lock lk( _mutex );
-            for ( map<string,long long>::iterator i=_counts.begin(); i!=_counts.end(); i++ ){
+            for ( map<string,long long>::iterator i=_counts.begin(); i!=_counts.end(); i++ ) {
                 b.appendNumber( i->first , i->second );
             }
         }
         return b.obj();
     }
 
-    
+
+    void NetworkCounter::hit( long long bytesIn , long long bytesOut ) {
+        const long long MAX = 1ULL << 60;
+
+        // don't care about the race as its just a counter
+        bool overflow = _bytesIn > MAX || _bytesOut > MAX;
+
+        if ( overflow ) {
+            _lock.lock();
+            _overflows++;
+            _bytesIn = bytesIn;
+            _bytesOut = bytesOut;
+            _requests = 1;
+            _lock.unlock();
+        }
+        else {
+            _lock.lock();
+            _bytesIn += bytesIn;
+            _bytesOut += bytesOut;
+            _requests++;
+            _lock.unlock();
+        }
+    }
+
+    void NetworkCounter::append( BSONObjBuilder& b ) {
+        _lock.lock();
+        b.appendNumber( "bytesIn" , _bytesIn );
+        b.appendNumber( "bytesOut" , _bytesOut );
+        b.appendNumber( "numRequests" , _requests );
+        _lock.unlock();
+    }
+
 
     OpCounters globalOpCounters;
+    OpCounters replOpCounters;
     IndexCounters globalIndexCounters;
     FlushCounters globalFlushCounters;
+    NetworkCounter networkCounter;
+
 }