Added new statistics charts & new admin panel

Author: fancoder

README.md

@@ -282,6 +282,63 @@ Explanation for each field:
     "host": "127.0.0.1",
     "port": 6379
 }
+
+/* Monitoring RPC services. Statistics will be displayed in Admin panel */
+"monitoring": {
+    "daemon": {
+        "checkInterval": 60, //interval of sending rpcMethod request
+        "rpcMethod": "getblockcount" //RPC method name
+    },
+    "wallet": {
+        "checkInterval": 60,
+        "rpcMethod": "getbalance"
+    }
+
+/* Collect pool statistics to display in frontend charts  */
+"charts": {
+    "pool": {
+        "hashrate": {
+            "enabled": true, //enable data collection and chart displaying in frontend
+            "updateInterval": 60, //how often to get current value
+            "stepInterval": 1800, //chart step interval calculated as average of all updated values
+            "maximumPeriod": 86400 //chart maximum periods (chart points number = maximumPeriod / stepInterval = 48)
+        },
+        "workers": {
+            "enabled": true,
+            "updateInterval": 60,
+            "stepInterval": 1800, //chart step interval calculated as maximum of all updated values
+            "maximumPeriod": 86400
+        },
+        "difficulty": {
+            "enabled": true,
+            "updateInterval": 1800,
+            "stepInterval": 10800,
+            "maximumPeriod": 604800
+        },
+        "price": { //USD price of one currency coin received from cryptonator.com/api
+            "enabled": true,
+            "updateInterval": 1800,
+            "stepInterval": 10800,
+            "maximumPeriod": 604800
+        },
+        "profit": { //Reward * Rate / Difficulty
+            "enabled": true,
+            "updateInterval": 1800,
+            "stepInterval": 10800,
+            "maximumPeriod": 604800
+        }
+    },
+    "user": { //chart data displayed in user stats block
+        "hashrate": {
+            "enabled": true,
+            "updateInterval": 180,
+            "stepInterval": 1800,
+            "maximumPeriod": 86400
+        },
+        "payments": { //payment chart uses all user payments data stored in DB
+            "enabled": true
+        }
+    }
 ```
 
 #### 3) [Optional] Configure cryptonote-easy-miner for your pool

config.json

@@ -1,6 +1,7 @@
 {
     "coin": "monero",
     "symbol": "XMR",
+    "coinUnits": 1000000000000,
 
     "logging": {
         "files": {
@@ -113,5 +114,62 @@
     "redis": {
         "host": "127.0.0.1",
         "port": 6379
+    },
+
+    "monitoring": {
+        "daemon": {
+            "checkInterval": 60,
+            "rpcMethod": "getblockcount"
+        },
+        "wallet": {
+            "checkInterval": 60,
+            "rpcMethod": "getbalance"
+        }
+    },
+
+    "charts": {
+        "pool": {
+            "hashrate": {
+                "enabled": true,
+                "updateInterval": 60,
+                "stepInterval": 1800,
+                "maximumPeriod": 86400
+            },
+            "workers": {
+                "enabled": true,
+                "updateInterval": 60,
+                "stepInterval": 1800,
+                "maximumPeriod": 86400
+            },
+            "difficulty": {
+                "enabled": true,
+                "updateInterval": 1800,
+                "stepInterval": 10800,
+                "maximumPeriod": 604800
+            },
+            "price": {
+                "enabled": true,
+                "updateInterval": 1800,
+                "stepInterval": 10800,
+                "maximumPeriod": 604800
+            },
+            "profit": {
+                "enabled": true,
+                "updateInterval": 1800,
+                "stepInterval": 10800,
+                "maximumPeriod": 604800
+            }
+        },
+        "user": {
+            "hashrate": {
+                "enabled": true,
+                "updateInterval": 180,
+                "stepInterval": 1800,
+                "maximumPeriod": 86400
+            },
+            "payments": {
+                "enabled": true
+            }
+        }
     }
 }

init.js

@@ -30,6 +30,10 @@ if (cluster.isWorker){
         case 'cli':
             require('./lib/cli.js');
             break
+        case 'chartsDataCollector':
+            require('./lib/chartsDataCollector.js');
+            break
+
     }
     return;
 }
@@ -40,7 +44,7 @@ require('./lib/exceptionWriter.js')(logSystem);
 
 var singleModule = (function(){
 
-    var validModules = ['pool', 'api', 'unlocker', 'payments'];
+    var validModules = ['pool', 'api', 'unlocker', 'payments', 'chartsDataCollector'];
 
     for (var i = 0; i < process.argv.length; i++){
         if (process.argv[i].indexOf('-module=') === 0){
@@ -75,13 +79,17 @@ var singleModule = (function(){
                 case 'api':
                     spawnApi();
                     break;
+                case 'chartsDataCollector':
+                    spawnChartsDataCollector();
+                    break;
             }
         }
         else{
             spawnPoolWorkers();
             spawnBlockUnlocker();
             spawnPaymentProcessor();
             spawnApi();
+            spawnChartsDataCollector();
         }
 
         spawnCli();
@@ -228,4 +236,18 @@ function spawnApi(){
 
 function spawnCli(){
 
-}
+}
+
+function spawnChartsDataCollector(){
+    if (!config.charts) return;
+
+    var worker = cluster.fork({
+        workerType: 'chartsDataCollector'
+    });
+    worker.on('exit', function(code, signal){
+        log('error', logSystem, 'chartsDataCollector died, spawning replacement...');
+        setTimeout(function(){
+            spawnChartsDataCollector();
+        }, 2000);
+    });
+}

lib/api.js

@@ -6,6 +6,8 @@ var zlib = require('zlib');
 var async = require('async');
 
 var apiInterfaces = require('./apiInterfaces.js')(config.daemon, config.wallet);
+var charts = require('./charts.js');
+var authSid = Math.round(Math.random() * 10000000000) + '' + Math.round(Math.random() * 10000000000);
 
 var logSystem = 'api';
 require('./exceptionWriter.js')(logSystem);
@@ -28,6 +30,7 @@ var currentStats = "";
 var currentStatsCompressed = "";
 
 var minerStats = {};
+var minersHashrate = {};
 
 var liveConnections = {};
 var addressConnections = {};
@@ -67,18 +70,20 @@ function collectStats(){
                 var hashrates = replies[1];
 
                 minerStats = {};
+                minersHashrate = {};
 
                 for (var i = 0; i < hashrates.length; i++){
                     var hashParts = hashrates[i].split(':');
-                    minerStats[hashParts[1]] = (minerStats[hashParts[1]] || 0) + parseInt(hashParts[0]);
+                    minersHashrate[hashParts[1]] = (minerStats[hashParts[1]] || 0) + parseInt(hashParts[0]);
                 }
 
                 var totalShares = 0;
 
-                for (var miner in minerStats){
-                    var shares = minerStats[miner];
+                for (var miner in minersHashrate){
+                    var shares = minersHashrate[miner];
                     totalShares += shares;
-                    minerStats[miner] = getReadableHashRateString(shares / config.api.hashrateWindow);
+                    minersHashrate[miner] = Math.round(shares / config.api.hashrateWindow);
+                    minerStats[miner] = getReadableHashRateString(minersHashrate[miner]);
                 }
 
                 data.miners = Object.keys(minerStats).length;
@@ -133,7 +138,8 @@ function collectStats(){
                 minPaymentThreshold: config.payments.minPayment,
                 denominationUnit: config.payments.denomination
             });
-        }
+        },
+        charts: charts.getPoolChartsData
     }, function(error, results){
 
         log('info', logSystem, 'Stat collection finished: %d ms redis, %d ms daemon', [redisFinished - startTime, daemonFinished - startTime]);
@@ -237,7 +243,13 @@ function handleMinerStats(urlParts, response){
             }
             var stats = replies[0];
             stats.hashrate = minerStats[address];
-            response.end(JSON.stringify({stats: stats, payments: replies[1]}));
+            charts.getUserChartsData(address, replies[1], function(error, chartsData) {
+                response.end(JSON.stringify({
+                    stats: stats,
+                    payments: replies[1],
+                    charts: chartsData
+                }));
+            });
         });
     }
 }
@@ -307,25 +319,59 @@ function handleGetBlocks(urlParts, response){
     });
 }
 
+function handleGetMinersHashrate(response) {
+    var reply = JSON.stringify({
+        minersHashrate: minersHashrate
+    });
+    response.writeHead("200", {
+        'Access-Control-Allow-Origin': '*',
+        'Cache-Control': 'no-cache',
+        'Content-Type': 'application/json',
+        'Content-Length': reply.length
+    });
+    response.end(reply);
+}
 
-collectStats();
+function parseCookies(request) {
+    var list = {},
+        rc = request.headers.cookie;
+    rc && rc.split(';').forEach(function(cookie) {
+        var parts = cookie.split('=');
+        list[parts.shift().trim()] = unescape(parts.join('='));
+    });
+    return list;
+}
 
 function authorize(request, response){
+    if(request.connection.remoteAddress == '127.0.0.1') {
+        return true;
+    }
 
     response.setHeader('Access-Control-Allow-Origin', '*');
 
+    var cookies = parseCookies(request);
+    if(cookies.sid && cookies.sid == authSid) {
+        return true;
+    }
+
     var sentPass = url.parse(request.url, true).query.password;
 
+
     if (sentPass !== config.api.password){
         response.statusCode = 401;
         response.end('invalid password');
         return;
     }
 
+    log('warn', logSystem, 'Admin authorized');
     response.statusCode = 200;
+
+    var cookieExpire = new Date( new Date().getTime() + 60*60*24*1000);
+    response.setHeader('Set-Cookie', 'sid=' + authSid + '; path=/; expires=' + cookieExpire.toUTCString());
     response.setHeader('Cache-Control', 'no-cache');
     response.setHeader('Content-Type', 'application/json');
 
+
     return true;
 }
 
@@ -406,6 +452,149 @@ function handleAdminStats(response){
 
 }
 
+
+function handleAdminUsers(response){
+    async.waterfall([
+        // get workers Redis keys
+        function(callback) {
+            redisClient.keys(config.coin + ':workers:*', callback);
+        },
+        // get workers data
+        function(workerKeys, callback) {
+            var redisCommands = workerKeys.map(function(k) {
+                return ['hmget', k, 'balance', 'paid', 'lastShare', 'hashes'];
+            });
+            redisClient.multi(redisCommands).exec(function(error, redisData) {
+                var workersData = {};
+                var addressLength = config.poolServer.poolAddress.length;
+                for(var i in redisData) {
+                    var address = workerKeys[i].substr(-addressLength);
+                    var data = redisData[i];
+                    workersData[address] = {
+                        pending: data[0] / config.coinUnits,
+                        paid: data[1] / config.coinUnits,
+                        lastShare: data[2],
+                        hashes: data[3],
+                        hashrate: minersHashrate[address] ? minersHashrate[address] : 0
+                    };
+                }
+                callback(null, workersData);
+            });
+        }
+    ], function(error, workersData) {
+            if(error) {
+                response.end(JSON.stringify({error: 'error collecting users stats'}));
+                return;
+            }
+            response.end(JSON.stringify(workersData));
+        }
+    );
+}
+
+
+function handleAdminMonitoring(response) {
+    response.writeHead("200", {
+        'Access-Control-Allow-Origin': '*',
+        'Cache-Control': 'no-cache',
+        'Content-Type': 'application/json'
+    });
+    async.parallel({
+        monitoring: getMonitoringData,
+        logs: getLogFiles
+    }, function(error, result) {
+        response.end(JSON.stringify(result));
+    });
+}
+
+function handleAdminLog(urlParts, response){
+    var file = urlParts.query.file;
+    var filePath = config.logging.files.directory + '/' + file;
+    if(!file.match(/^\w+\.log$/)) {
+        response.end('wrong log file');
+    }
+    response.writeHead(200, {
+        'Content-Type': 'text/plain',
+        'Cache-Control': 'no-cache',
+        'Content-Length': fs.statSync(filePath).size
+    });
+    fs.createReadStream(filePath).pipe(response)
+}
+
+
+function startRpcMonitoring(rpc, module, method, interval) {
+    setInterval(function() {
+        rpc(method, {}, function(error, response) {
+            var stat = {
+                lastCheck: new Date() / 1000 | 0,
+                lastStatus: error ? 'fail' : 'ok',
+                lastResponse: JSON.stringify(error ? error : response)
+            };
+            if(error) {
+                stat.lastFail = stat.lastCheck;
+                stat.lastFailResponse = stat.lastResponse;
+            }
+            var key = getMonitoringDataKey(module);
+            var redisCommands = [];
+            for(var property in stat) {
+                redisCommands.push(['hset', key, property, stat[property]]);
+            }
+            redisClient.multi(redisCommands).exec();
+        });
+    }, interval * 1000);
+}
+
+function getMonitoringDataKey(module) {
+    return config.coin + ':status:' + module;
+}
+
+function initMonitoring() {
+    var modulesRpc = {
+        daemon: apiInterfaces.rpcDaemon,
+        wallet: apiInterfaces.rpcWallet
+    };
+    for(var module in config.monitoring) {
+        var settings = config.monitoring[module];
+        if(settings.checkInterval) {
+            startRpcMonitoring(modulesRpc[module], module, settings.rpcMethod, settings.checkInterval);
+        }
+    }
+}
+
+
+
+function getMonitoringData(callback) {
+    var modules = Object.keys(config.monitoring);
+    var redisCommands = [];
+    for(var i in modules) {
+        redisCommands.push(['hgetall', getMonitoringDataKey(modules[i])])
+    }
+    redisClient.multi(redisCommands).exec(function(error, results) {
+        var stats = {};
+        for(var i in modules) {
+            if(results[i]) {
+                stats[modules[i]] = results[i];
+            }
+        }
+        callback(error, stats);
+    });
+}
+
+function getLogFiles(callback) {
+    var dir = config.logging.files.directory;
+    fs.readdir(dir, function(error, files) {
+        var logs = {};
+        for(var i in files) {
+            var file = files[i];
+            var stats = fs.statSync(dir + '/' + file);
+            logs[file] = {
+                size: stats.size,
+                changed: Date.parse(stats.mtime) / 1000 | 0
+            }
+        }
+        callback(error, logs);
+    });
+}
+
 var server = http.createServer(function(request, response){
 
     if (request.method.toUpperCase() === "OPTIONS"){
@@ -426,12 +615,13 @@ var server = http.createServer(function(request, response){
 
     switch(urlParts.pathname){
         case '/stats':
-            var reply = currentStatsCompressed;
+            var deflate = request.headers['accept-encoding'] && request.headers['accept-encoding'].indexOf('deflate') != -1;
+            var reply = deflate ? currentStatsCompressed : currentStats;
             response.writeHead("200", {
                 'Access-Control-Allow-Origin': '*',
                 'Cache-Control': 'no-cache',
                 'Content-Type': 'application/json',
-                'Content-Encoding': 'deflate',
+                'Content-Encoding': deflate ? 'deflate' : '',
                 'Content-Length': reply.length
             });
             response.end(reply);
@@ -462,21 +652,45 @@ var server = http.createServer(function(request, response){
         case '/admin_stats':
             if (!authorize(request, response))
                 return;
-            log('warn', logSystem, 'Admin authorized');
             handleAdminStats(response);
             break;
+        case '/admin_monitoring':
+            if(!authorize(request, response)) {
+                return;
+            }
+            handleAdminMonitoring(response);
+            break;
+        case '/admin_log':
+            if(!authorize(request, response)) {
+                return;
+            }
+            handleAdminLog(urlParts, response);
+            break;
+        case '/admin_users':
+            if(!authorize(request, response)) {
+                return;
+            }
+            handleAdminUsers(response);
+            break;
+
+        case '/miners_hashrate':
+            if (!authorize(request, response))
+                return;
+            handleGetMinersHashrate(response);
+            break;
+
         default:
             response.writeHead(404, {
                 'Access-Control-Allow-Origin': '*'
             });
             response.end('Invalid API call');
             break;
     }
-
-
 });
 
+collectStats();
+initMonitoring();
 
 server.listen(config.api.port, function(){
     log('info', logSystem, 'API started & listening on port %d', [config.api.port]);
-});
+});

lib/apiInterfaces.js

@@ -1,20 +1,22 @@
 var http = require('http');
+var https = require('https');
 
-function jsonHttpRequest(host, port, data, callback){
+function jsonHttpRequest(host, port, data, callback, path){
+    path = path || '/json_rpc';
 
     var options = {
         hostname: host,
         port: port,
-        path: '/json_rpc',
-        method: 'POST',
+        path: path,
+        method: data ? 'POST' : 'GET',
         headers: {
             'Content-Length': data.length,
             'Content-Type': 'application/json',
             'Accept': 'application/json'
         }
     };
 
-    var req = http.request(options, function(res){
+    var req = (port == 443 ? https : http).request(options, function(res){
         var replyData = '';
         res.setEncoding('utf8');
         res.on('data', function(chunk){
@@ -72,7 +74,7 @@ function batchRpc(host, port, array, callback){
 }
 
 
-module.exports = function(daemonConfig, walletConfig){
+module.exports = function(daemonConfig, walletConfig, poolApiConfig){
     return {
         batchRpcDaemon: function(batchArray, callback){
             batchRpc(daemonConfig.host, daemonConfig.port, batchArray, callback);
@@ -82,6 +84,10 @@ module.exports = function(daemonConfig, walletConfig){
         },
         rpcWallet: function(method, params, callback){
             rpc(walletConfig.host, walletConfig.port, method, params, callback);
-        }
+        },
+        pool: function(method, callback){
+            jsonHttpRequest('127.0.0.1', poolApiConfig.port, '', callback, method);
+        },
+        jsonHttpRequest: jsonHttpRequest
     }
-};
+};

lib/blockUnlocker.js

@@ -1,6 +1,6 @@
 var async = require('async');
 
-var apiInterfaces = require('./apiInterfaces.js')(config.daemon, config.wallet);
+var apiInterfaces = require('./apiInterfaces.js')(config.daemon, config.wallet, config.api);
 
 var logSystem = 'unlocker';
 require('./exceptionWriter.js')(logSystem);

lib/charts.js

@@ -0,0 +1,240 @@
+var fs = require('fs');
+var async = require('async');
+var http = require('http');
+var apiInterfaces = require('./apiInterfaces.js')(config.daemon, config.wallet, config.api);
+
+var logSystem = 'charts';
+require('./exceptionWriter.js')(logSystem);
+
+log('info', logSystem, 'Started');
+
+function startDataCollectors() {
+    async.each(Object.keys(config.charts.pool), function(chartName) {
+        var settings = config.charts.pool[chartName];
+        if(settings.enabled) {
+            setInterval(function() {
+                collectPoolStatWithInterval(chartName, settings);
+            }, settings.updateInterval * 1000);
+        }
+    });
+
+    var settings = config.charts.user.hashrate;
+    if(settings.enabled) {
+        setInterval(function() {
+            collectUsersHashrate('hashrate', settings);
+        }, settings.updateInterval * 1000)
+    }
+}
+
+function getChartDataFromRedis(chartName, callback) {
+    redisClient.get(getStatsRedisKey(chartName), function(error, data) {
+        callback(data ? JSON.parse(data) : []);
+    });
+}
+
+function getUserHashrateChartData(address, callback) {
+    getChartDataFromRedis('hashrate:' + address, callback);
+}
+
+function convertPaymentsDataToChart(paymentsData) {
+    var data = [];
+    if(paymentsData && paymentsData.length) {
+        for(var i = 0; paymentsData[i]; i += 2) {
+            data.push([+paymentsData[i + 1], paymentsData[i].split(':')[1] / config.coinUnits]);
+        }
+    }
+    return data;
+}
+
+function getUserChartsData(address, paymentsData, callback) {
+    var stats = {};
+    var chartsFuncs = {
+        hashrate: function(callback) {
+            getUserHashrateChartData(address, function(data) {
+                callback(null, data);
+            });
+        },
+
+        payments: function(callback) {
+            callback(null, convertPaymentsDataToChart(paymentsData));
+        }
+    };
+    for(var chartName in chartsFuncs) {
+        if(!config.charts.user[chartName].enabled) {
+            delete chartsFuncs[chartName];
+        }
+    }
+    async.parallel(chartsFuncs, callback);
+}
+
+function getStatsRedisKey(chartName) {
+    return config.coin + ':charts:' + chartName;
+}
+
+var chartStatFuncs = {
+    hashrate: getPoolHashrate,
+    workers: getPoolWorkers,
+    difficulty: getNetworkDifficulty,
+    price: getCoinPrice,
+    profit: getCoinProfit
+};
+
+var statValueHandler = {
+    avg: function(set, value) {
+        set[1] = (set[1] * set[2] + value) / (set[2] + 1);
+    },
+    round: function(set, value) {
+        statValueHandler.avg(set, value);
+        set[1] = Math.round(set[1]);
+    },
+    max: function(set, value) {
+        if(value > set[1]) {
+            set[1] = value;
+        }
+    }
+};
+
+var preSaveFunctions = {
+    hashrate: statValueHandler.avg,
+    workers: statValueHandler.max,
+    difficulty: statValueHandler.round,
+    price: statValueHandler.avg,
+    profit: statValueHandler.avg
+};
+
+function storeCollectedValues(chartName, values, settings) {
+    for(var i in values) {
+        storeCollectedValue(chartName + ':' + i, values[i], settings);
+    }
+}
+
+function storeCollectedValue(chartName, value, settings) {
+    var now = new Date() / 1000 | 0;
+    getChartDataFromRedis(chartName, function(sets) {
+        var lastSet = sets[sets.length - 1]; // [time, avgValue, updatesCount]
+        if(!lastSet || now - lastSet[0] > settings.stepInterval) {
+            lastSet = [now, value, 1];
+            sets.push(lastSet);
+            while(now - sets[0][0] > settings.maximumPeriod) { // clear old sets
+                sets.shift();
+            }
+        }
+        else {
+            preSaveFunctions[chartName]
+                ? preSaveFunctions[chartName](lastSet, value)
+                : statValueHandler.round(lastSet, value);
+            lastSet[2]++;
+        }
+        redisClient.set(getStatsRedisKey(chartName), JSON.stringify(sets));
+        log('info', logSystem, chartName + ' chart collected value ' + value + '. Total sets count ' + sets.length);
+        log('info', logSystem, chartName + ' data: ' + JSON.stringify(sets));
+    });
+}
+
+function collectPoolStatWithInterval(chartName, settings) {
+    async.waterfall([
+        chartStatFuncs[chartName],
+        function(value, callback) {
+            storeCollectedValue(chartName, value, settings, callback);
+        }
+    ]);
+}
+
+function getPoolStats(callback) {
+    apiInterfaces.pool('/stats', callback);
+}
+
+function getPoolHashrate(callback) {
+    getPoolStats(function(error, stats) {
+        callback(error, stats.pool ? Math.round(stats.pool.hashrate) : null);
+    });
+}
+
+function getPoolWorkers(callback) {
+    getPoolStats(function(error, stats) {
+        callback(error, stats.pool ? stats.pool.miners : null);
+    });
+}
+
+function getNetworkDifficulty(callback) {
+    getPoolStats(function(error, stats) {
+        callback(error, stats.pool ? stats.network.difficulty : null);
+    });
+}
+
+function getUsersHashrates(callback) {
+    apiInterfaces.pool('/miners_hashrate', function(error, data) {
+        callback(data.minersHashrate);
+    });
+}
+
+function collectUsersHashrate(chartName, settings) {
+    var redisBaseKey = getStatsRedisKey(chartName) + ':';
+    redisClient.keys(redisBaseKey + '*', function(keys) {
+        var hashrates = {};
+        for(var i in keys) {
+            hashrates[keys[i].substr(keys[i].length)] = 0;
+        }
+        getUsersHashrates(function(newHashrates) {
+            for(var address in newHashrates) {
+                hashrates[address] = newHashrates[address];
+            }
+            storeCollectedValues(chartName, hashrates, settings);
+        });
+    });
+}
+
+function getCoinPrice(callback) {
+    apiInterfaces.jsonHttpRequest('www.cryptonator.com', 443, '', function(error, response) {
+        callback(response.error ? response.error : error, response.success ? +response.ticker.price : null);
+    }, '/api/ticker/' + config.symbol.toLowerCase() + '-usd');
+}
+
+function getCoinProfit(callback) {
+    getCoinPrice(function(error, price) {
+        if(error) {
+            callback(error);
+            return;
+        }
+        getPoolStats(function(error, stats) {
+            if(error) {
+                callback(error);
+                return;
+            }
+            callback(null, stats.network.reward * price / stats.network.difficulty / config.coinUnits);
+        });
+    });
+}
+
+function getPoolChartsData(callback) {
+    var chartsNames = [];
+    var redisKeys = [];
+    for(var chartName in config.charts.pool) {
+        if(config.charts.pool[chartName].enabled) {
+            chartsNames.push(chartName);
+            redisKeys.push(getStatsRedisKey(chartName));
+        }
+    }
+    if(redisKeys.length) {
+        redisClient.mget(redisKeys, function(error, data) {
+            var stats = {};
+            if(data) {
+                for(var i in data) {
+                    if(data[i]) {
+                        stats[chartsNames[i]] = JSON.parse(data[i]);
+                    }
+                }
+            }
+            callback(error, stats);
+        });
+    }
+    else {
+        callback(null, {});
+    }
+}
+
+module.exports = {
+    startDataCollectors: startDataCollectors,
+    getUserChartsData: getUserChartsData,
+    getPoolChartsData: getPoolChartsData
+};

lib/chartsDataCollector.js

@@ -0,0 +1,11 @@
+var fs = require('fs');
+var async = require('async');
+var http = require('http');
+var charts = require('./charts.js');
+
+var logSystem = 'chartsDataCollector';
+require('./exceptionWriter.js')(logSystem);
+
+log('info', logSystem, 'Started');
+
+charts.startDataCollectors();

lib/paymentProcessor.js

@@ -2,7 +2,7 @@ var fs = require('fs');
 
 var async = require('async');
 
-var apiInterfaces = require('./apiInterfaces.js')(config.daemon, config.wallet);
+var apiInterfaces = require('./apiInterfaces.js')(config.daemon, config.wallet, config.api);
 
 
 var logSystem = 'payments';

lib/pool.js

@@ -13,7 +13,7 @@ var threadId = '(Thread ' + process.env.forkId + ') ';
 var logSystem = 'pool';
 require('./exceptionWriter.js')(logSystem);
 
-var apiInterfaces = require('./apiInterfaces.js')(config.daemon, config.wallet);
+var apiInterfaces = require('./apiInterfaces.js')(config.daemon, config.wallet, config.api);
 var utils = require('./utils.js');
 
 var log = function(severity, system, text, data){

website/admin.html

@@ -387,7 +387,7 @@ a.list-group-item:last-child {
   cursor: pointer;
 }
 .usersList tr > th:first-child {
-  width: 50%;
+  width: 40%;
 }
 strong,
 b {

website/custom.css

@@ -9,9 +9,8 @@
 
 
     <script src="//cdnjs.cloudflare.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
-
     <script src="//cdnjs.cloudflare.com/ajax/libs/jquery-timeago/1.4.0/jquery.timeago.min.js"></script>
-
+    <script src="http://cdnjs.cloudflare.com/ajax/libs/jquery-sparklines/2.1.2/jquery.sparkline.min.js"></script>
     <link href="//netdna.bootstrapcdn.com/bootstrap/3.1.1/css/bootstrap.min.css" rel="stylesheet">
     <script src="//netdna.bootstrapcdn.com/bootstrap/3.1.1/js/bootstrap.min.js"></script>
 
@@ -27,7 +26,7 @@
             text-transform: capitalize;
         }
         body {
-            padding-top: 90px;
+            padding-top: 65px;
             padding-bottom: 80px;
             overflow-y: scroll;
         }
@@ -120,6 +119,10 @@
         }
     };
 
+    function getTransactionUrl(id) {
+        return transactionExplorer.replace('{symbol}', lastStats.config.symbol.toLowerCase()).replace('{id}', id);
+    }
+    
     $.fn.update = function(txt){
         var el = this[0];
         if (el.textContent !== txt)

website/index.html

@@ -0,0 +1,130 @@
+<!-- ///  define Handlebars template  /// -->
+<script id="monitoringInfo" type="text/x-handlebars-template">
+	<div class="tab-pane active" id="rpcLog">
+		<div class="row">
+			<div class="col-sm-6">
+				<h3>Daemon</h3>
+				<ul class="list-unstyled">
+					<li><strong>Last check:</strong> {{monitoringDaemon.lastCheck}}</li>
+					<li><strong>Last status:</strong>
+						<span id="daemonStatus">{{monitoringDaemon.lastStatus}}</span>
+					</li>
+					<li><strong>Last response:</strong>
+						<pre>{{monitoringDaemon.lastResponse}}</pre>
+					</li>
+					<li><strong>Last fail:</strong>
+						<span>{{monitoringDaemon.lastFail}}</span>
+					</li>
+					<li><strong>Last fail response:</strong>
+						<pre>{{monitoringDaemon.lastFailResponse}}</pre>
+					</li>
+				</ul>
+			</div>
+			<div class="col-sm-6">
+				<h3>Wallet</h3>
+				<ul class="list-unstyled">
+					<li><strong>Last check:</strong> {{monitoringWallet.lastCheck}}</li>
+					<li><strong>Last status:</strong>
+						<span id="walletStatus">{{monitoringWallet.lastStatus}}</span>
+					</li>
+					<li><strong>Last response:</strong>
+						<pre>{{monitoringWallet.lastResponse}}</pre>
+					</li>
+					<li><strong>Last fail:</strong>
+						<span>{{monitoringWallet.lastFail}}</span>
+					</li>
+					<li><strong>Last fail response:</strong>
+						<pre>{{monitoringWallet.lastFailResponse}}</span></pre>
+				</ul>
+			</div>
+		</div>
+
+		<h3>Logs</h3>
+
+		<table class="table table-hover table-striped logList" id="logTable">
+			<thead>
+			<tr>
+				<th class="sort">Name <i class="fa fa-sort"></i></th>
+				<th class="sort">Modified <i class="fa fa-sort"></i></th>
+				<th class="sort">Size <i class="fa fa-sort"></i></th>
+			</tr>
+			</thead>
+			<tbody>
+			{{#each logs}}
+			<tr>
+				<td data-sort="{{@key}}"><a href="{{this.link}}" target="_blank">{{@key}}</a></td>
+				<td data-sort="{{this.changed}}">{{this.changed}}</td>
+				<td data-sort="{{this.size}}">{{this.size}} bytes</td>
+			</tr>
+			{{/each}}
+			</tbody>
+		</table>
+	</div>
+</script>
+
+
+<script>
+	function getCheckTime(timestamp) {
+		return timestamp ? $.timeago(new Date(timestamp * 1000).toISOString()) : null;
+	}
+
+	function monitoringInfoParse(data) {
+		var monitoringDaemon = {
+			lastCheck: getCheckTime(data['monitoring'].daemon.lastCheck) || 'never',
+			lastStatus: data['monitoring'].daemon.lastStatus || '',
+			lastFail: getCheckTime(data['monitoring'].daemon.lastFail) || 'never',
+			lastFailResponse: data['monitoring'].daemon.lastFailResponse || ' ',
+			lastResponse: data['monitoring'].daemon.lastResponse || ' '
+		};
+		var monitoringWallet = {
+			lastCheck: getCheckTime(data['monitoring'].wallet.lastCheck) || 'never',
+			lastStatus: data['monitoring'].wallet.lastStatus || '',
+			lastFail: getCheckTime(data['monitoring'].wallet.lastFail) || 'never',
+			lastFailResponse: data['monitoring'].wallet.lastFailResponse || ' ',
+			lastResponse: data['monitoring'].wallet.lastResponse || ' '
+		};
+		var properData = {};
+
+		for(var prop in data) {
+			if(data.hasOwnProperty('logs')) {
+				properData['logs'] = data['logs'];
+				for(var log in data['logs']) {
+					properData['logs'][log].changed = Date(data['logs'][log].changed * 1000);
+					data['logs'][log].link = api + '/admin_log?file=' + log + '&password=' + docCookies.getItem('password');
+				}
+			}
+		}
+		properData['monitoringDaemon'] = monitoringDaemon;
+		properData['monitoringWallet'] = monitoringWallet;
+
+		return properData;
+	}
+
+	function renderLogInfo() {
+		$.ajax({
+			url: api + '/admin_monitoring',
+			data: {password: docCookies.getItem('password')},
+			cache: false,
+			dataType: 'json',
+			success: function(data) {
+				renderTemplate(monitoringInfoParse(data), '#monitoringInfo', '#monitoringInfoView');
+
+				$('#daemonStatus').addClass(data['monitoring'].daemon.lastStatus == 'ok' ? 'text-success' : 'text-danger');
+				$('#walletStatus').addClass(data['monitoring'].wallet.lastStatus == 'ok' ? 'text-success' : 'text-danger');
+
+				$('#logTable th.sort').on('click', sortTable);
+			}
+		});
+	}
+
+	$(function() {
+		renderLogInfo();
+	});
+</script>
+
+<div class="adminMonitor">
+	<!-- Tab panes -->
+	<div class="tab-content">
+		<div id="monitoringInfoView"></div>
+	</div>
+</div>

website/pages/admin/monitoring.html

@@ -0,0 +1,90 @@
+<script>
+	var formatLuck = function(difficulty, shares) {
+		if(difficulty <= shares) {
+			var percent = (100 - Math.round(difficulty / shares * 100)) * -1;
+			return '<span class="luckBad">' + percent + '%</span>';
+		}
+		else {
+			var percent = 100 - Math.round(shares / difficulty * 100);
+			return '<span class="luckGood">' + percent + '%</span>';
+		}
+	};
+
+	function getStats(promptPassword) {
+
+		var password = docCookies.getItem('password');
+
+		if(!password || promptPassword) {
+			password = prompt('Enter admin password');
+		}
+
+		$('#loading').show();
+		$.ajax({
+			url: api + '/admin_stats',
+			data: {password: password},
+			success: function(data) {
+				docCookies.setItem('password', password, Infinity);
+				$('#loading').hide();
+				renderData(data);
+			},
+			error: function(e) {
+				docCookies.removeItem('password');
+				getStats(true);
+			}
+		});
+	}
+
+	function renderData(data) {
+		$('#totalOwed').text(getReadableCoins(data.totalOwed));
+		$('#totalPaid').text(getReadableCoins(data.totalPaid));
+		$('#totalMined').text(getReadableCoins(data.totalRevenue));
+		$('#profit').text(getReadableCoins(data.totalRevenue - data.totalOwed - data.totalPaid));
+		$('#averageLuck').html(formatLuck(data.totalDiff, data.totalShares));
+		$('#orphanPercent').text((data.blocksOrphaned / data.blocksUnlocked * 100).toFixed(2));
+		$('#registeredAddresses').text(data.totalWorkers);
+	}
+
+	$(function() {
+		getStats();
+	});
+</script>
+<!-- <h4>Stats</h4>
+<dl class="dl-horizontal" id="statsHolder">
+    <dt>Total Owed</dt><dd id="totalOwed">...</dd>
+    <dt>Total Paid</dt><dd id="totalPaid">...</dd>
+    <dt>Total Mined</dt><dd id="totalMined">...</dd>
+    <dt>Profit (before tx fees)</dt><dd id="profit">...</dd>
+    <dt>Average Luck</dt><dd id="averageLuck">...</dd>
+    <dt>Orphan Percent</dt><dd id="orphanPercent">...</dd>
+    <dt>Registered Addresses</dt><dd id="registeredAddresses">...</dd>
+</dl> -->
+<div class="row adminStats">
+	<div class="col-sm-3 color1">
+		<h4>Total Owed</h4>
+		<span class="statValue" id="totalOwed">...</span>
+	</div>
+	<div class="col-sm-3 color2">
+		<h4>Total Paid</h4>
+		<span class="statValue" id="totalPaid">...</span>
+	</div>
+	<div class="col-sm-3 color3">
+		<h4>Total Mined</h4>
+		<span class="statValue" id="totalMined">...</span>
+	</div>
+	<div class="col-sm-3 color4">
+		<h4>Profit (before tx fees)</h4>
+		<span class="statValue" id="profit">...</span>
+	</div>
+	<div class="col-sm-4 color5">
+		<h4>Average Luck</h4>
+		<span class="statValue lead" id="averageLuck">...</span>
+	</div>
+	<div class="col-sm-4 color6">
+		<h4>Orphan Percent</h4>
+		<span class="statValue lead" id="orphanPercent">...</span>
+	</div>
+	<div class="col-sm-4 color7">
+		<h4>Registered Addresses</h4>
+		<span class="statValue lead" id="registeredAddresses">...</span>
+	</div>
+</div>

website/pages/admin/statistics.html

@@ -0,0 +1,77 @@
+<style>
+	td {
+		text-align: center
+	}
+</style>
+<!-- ///  define Handlebars template  /// -->
+<script id="usersListTable" type="text/x-handlebars-template">
+	{{#each users}}
+	<tr>
+		<td><a href="./?wallet={{this.number}}">{{this.number}}</a></td>
+		<td data-sort="{{this.wallet.hashrate}}">{{this.readableHashrate}}</td>
+		<td data-sort="{{this.wallet.hashes}}">{{this.readableHashes}}</td>
+		<td data-sort="{{this.wallet.pending}}">{{this.wallet.pending}}</td>
+		<td data-sort="{{this.wallet.paid}}">{{this.wallet.paid}}</td>
+		<td data-sort="{{this.wallet.lastShare}}">{{this.timeago}}</td>
+	</tr>
+	{{/each}}
+</script>
+
+<script>
+	function parseUsers(wallets) {
+		var walletsArray = [],
+			properObject = {};
+		for(var wallet in wallets) {
+			if(wallets.hasOwnProperty(wallet)) {
+				walletsArray.push({
+					number: wallet,
+					wallet: wallets[wallet],
+					timeago: $.timeago(new Date(wallets[wallet].lastShare * 1000).toISOString()),
+					readableHashrate: getReadableHashRateString(wallets[wallet].hashrate) + '/s',
+					readableHashes: getReadableHashRateString(wallets[wallet].hashes)
+				});
+			}
+		}
+		properObject['users'] = walletsArray.sort(function(a, b) {
+			return a.wallet.hashrate - b.wallet.hashrate
+		}).reverse();
+
+		return properObject;
+	}
+
+	function cretaUserTable() {
+		$.ajax({
+			url: api + '/admin_users',
+			data: {password: docCookies.getItem('password')},
+			cache: false,
+			dataType: 'json',
+			success: function(data) {
+				renderTemplate(parseUsers(data), '#usersListTable', '#template');
+			}
+		});
+	}
+
+	$(function() {
+		$('[data-toggle="tooltip"]').tooltip();
+		$('.usersList th.sort').on('click', sortTable);
+		cretaUserTable();
+	});
+
+</script>
+<div class="table-responsive">
+	<table class="table table-hover table-striped usersList">
+		<thead>
+		<tr>
+			<th>Wallet</th>
+			<th class="sort" style="width:10%;">Hashrate <i class="fa fa-sort"></i></th>
+			<th class="sort" style="width:10%;">Hashes <i class="fa fa-sort"></i></th>
+			<th class="sort" style="width:16%;">Pending <i class="fa fa-sort"></i></th>
+			<th class="sort" style="width:10%;">Paid <i class="fa fa-sort"></i></th>
+			<th class="sort" style="width:14%;">Last share <i class="fa fa-sort"></i></th>
+		</tr>
+		</thead>
+		<tbody id="template">
+
+		</tbody>
+	</table>
+</div>