Mirrors/uBlock
1
0
Fork 0
mirror of https://github.com/gorhill/uBlock.git synced 2024-10-06 09:37:12 +02:00
Code Issues Releases Wiki Activity

code review: simplify needlessly complicated logger buffering code

Browse Source
This commit is contained in:
gorhill 2017-12-01 16:42:33 -05:00
parent 88853070a1
commit faad68f37b
No known key found for this signature in database
GPG Key ID: 25E1490B761470C2
1 changed files with 56 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

207
src/js/logger.js
View File

@ -1,7 +1,7 @@
/*******************************************************************************
uBlock - a browser extension to block requests.
Copyright (C) 2015 Raymond Hill
Copyright (C) 2015-2017 Raymond Hill
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -26,162 +26,67 @@
µBlock.logger = (function() {
/******************************************************************************/
/******************************************************************************/
var LogEntry = function(args) {
this.init(args);
};
var LogEntry = function(args) {
this.init(args);
};
LogEntry.prototype.init = function(args) {
this.tstamp = Date.now();
this.tab = args[0] || '';
this.cat = args[1] || '';
this.d0 = args[2];
this.d1 = args[3];
this.d2 = args[4];
this.d3 = args[5];
this.d4 = args[6];
};
/******************************************************************************/
var buffer = null;
var lastReadTime = 0;
var writePtr = 0;
LogEntry.prototype.init = function(args) {
this.tstamp = Date.now();
this.tab = args[0] || '';
this.cat = args[1] || '';
this.d0 = args[2];
this.d1 = args[3];
this.d2 = args[4];
this.d3 = args[5];
this.d4 = args[6];
};
// After 60 seconds without being read, a buffer will be considered
// unused, and thus removed from memory.
var logBufferObsoleteAfter = 60 * 1000;
/******************************************************************************/
/******************************************************************************/
var LogBuffer = function() {
this.lastReadTime = 0;
this.size = 50;
this.buffer = new Array(this.size);
this.readPtr = 0;
this.writePtr = 0;
};
/******************************************************************************/
LogBuffer.prototype.clearBuffer = function(beg, end) {
for ( var i = beg; i < end; i++ ) {
this.buffer[i] = null;
}
};
/******************************************************************************/
LogBuffer.prototype.writeOne = function(args) {
// Reusing log entry = less memory churning
var entry = this.buffer[this.writePtr];
if ( entry instanceof LogEntry === false ) {
this.buffer[this.writePtr] = new LogEntry(args);
} else {
entry.init(args);
}
this.writePtr += 1;
if ( this.writePtr === this.size ) {
this.writePtr = 0;
}
// Grow the buffer between 1.5x-2x the current size
if ( this.writePtr === this.readPtr ) {
var toMove = this.buffer.slice(0, this.writePtr);
// https://github.com/gorhill/uBlock/issues/391
// "The slice() method returns a shallow copy of a portion of an
// "array into a new array object."
// "shallow" => since we reuse entries, we need to remove the copied
// entries to prevent single instance of LogEntry being used in
// more than one slot.
this.clearBuffer(0, this.writePtr);
var minSize = Math.ceil(this.size * 1.5);
this.size += toMove.length;
if ( this.size < minSize ) {
this.buffer = this.buffer.concat(toMove, new Array(minSize - this.size));
this.writePtr = this.size;
} else {
this.buffer = this.buffer.concat(toMove);
this.writePtr = 0;
var janitor = function() {
if (
buffer !== null &&
lastReadTime < (Date.now() - logBufferObsoleteAfter)
) {
buffer = null;
writePtr = 0;
vAPI.messaging.broadcast({ what: 'loggerDisabled' });
}
this.size = this.buffer.length;
}
};
if ( buffer !== null ) {
vAPI.setTimeout(janitor, logBufferObsoleteAfter);
}
};
/******************************************************************************/
LogBuffer.prototype.readAll = function() {
var out;
if ( this.readPtr < this.writePtr ) {
out = this.buffer.slice(this.readPtr, this.writePtr);
} else if ( this.writePtr < this.readPtr ) {
out = this.buffer.slice(this.readPtr).concat(this.buffer.slice(0, this.writePtr));
} else {
out = [];
}
this.readPtr = this.writePtr;
this.lastReadTime = Date.now();
return out;
};
/******************************************************************************/
/******************************************************************************/
// Tab id to log buffer instances
var logBuffer = null;
// After 60 seconds without being read, a buffer will be considered unused, and
// thus removed from memory.
var logBufferObsoleteAfter = 60 * 1000;
/******************************************************************************/
var janitor = function() {
if (
logBuffer !== null &&
logBuffer.lastReadTime < (Date.now() - logBufferObsoleteAfter)
) {
api.writeOne = writeOneNoop;
logBuffer = null;
vAPI.messaging.broadcast({ what: 'loggerDisabled' });
}
if ( logBuffer !== null ) {
vAPI.setTimeout(janitor, logBufferObsoleteAfter);
}
};
/******************************************************************************/
var writeOneNoop = function() {
};
var writeOne = function() {
logBuffer.writeOne(arguments);
};
/******************************************************************************/
var readAll = function() {
if ( logBuffer === null ) {
api.writeOne = writeOne;
logBuffer = new LogBuffer();
vAPI.setTimeout(janitor, logBufferObsoleteAfter);
}
return logBuffer.readAll();
};
/******************************************************************************/
var isEnabled = function() {
return logBuffer !== null;
};
/******************************************************************************/
var api = {
writeOne: writeOneNoop,
readAll: readAll,
isEnabled: isEnabled
};
return api;
/******************************************************************************/
/******************************************************************************/
return {
writeOne: function() {
if ( buffer === null ) { return; }
if ( writePtr === buffer.length ) {
buffer.push(new LogEntry(arguments));
} else {
buffer[writePtr].init(arguments);
}
writePtr += 1;
},
readAll: function() {
if ( buffer === null ) {
buffer = [];
vAPI.setTimeout(janitor, logBufferObsoleteAfter);
}
var out = buffer.slice(0, writePtr);
writePtr = 0;
lastReadTime = Date.now();
return out;
},
isEnabled: function() {
return buffer !== null;
}
};
})();