Issue 394 - hit statistics tool data collection

lib/filterHits.js

 /*
- * This file is part of Adblock Plus <http://adblockplus.org/>,
- * Copyright (C) 2006-2014 Eyeo GmbH
+ * This file is part of Adblock Plus <https://adblockplus.org/>,
+ * Copyright (C) 2006-2016 Eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus 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 General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+let {Services} = Cu.import("resource://gre/modules/Services.jsm", null);
+let {FileUtils} = Cu.import("resource://gre/modules/FileUtils.jsm", null);
+let {setTimeout, clearTimeout} = Cu.import("resource://gre/modules/Timer.jsm", null);
+
 let {IO} = require("io");
-let {Utils} = require("utils");
 let {Prefs} = require("prefs");
-let {TimeLine} = require("timeline");
-let {Filter} = require("filterClasses");
+let {Downloader, Downloadable, MILLIS_IN_SECOND, MILLIS_IN_MINUTE, 
+  MILLIS_IN_HOUR, MILLIS_IN_DAY} = require("downloader");
+let {FilterNotifier} = require("filterNotifier");
+let {DownloadableSubscription} = require("subscriptionClasses");
+
+const CHECK_INTERVAL = MILLIS_IN_HOUR;
+const INITIAL_DELAY = MILLIS_IN_MINUTE * 2;
+const PUSH_INTERVAL = MILLIS_IN_DAY * 7;
 
 /**
- * This class reads filter hits statistics from disk, manages them in memory and writes them back.W
+ * The value of storage statement normal execution constant 
+ * @type Number
+ */
+const REASON_FINISHED = Components.interfaces.mozIStorageStatementCallback.REASON_FINISHED;
+
+/**
+ * This class collects filter hits statistics in a SQLite database
+ * and sends them to the server when user opt-in for that
  * @class
  */
 let FilterHits = exports.FilterHits =
 {
-  statistics: {},
-  
-  _loading: false,
-  _saving: false,
-  _needsSave: false,
-  
-  /**
-   * File that the filter hits statistics has been loaded from and should be saved to
-   * @type nsIFile
-   */
-  get filterHitsFile()
-  {
-    let file = null;
-    if (!file)
-    {
-      // Place the file in the data dir
-      file = IO.resolveFilePath(Prefs.data_directory);
-      if (file)
-        file.append("filter-hits.ini");
-    }
-    if (!file)
-    {
-      // Data directory pref misconfigured? Try the default value
-      try
-      {
-        file = IO.resolveFilePath(Services.prefs.getDefaultBranch("extensions.adblockplus.").getCharPref("data_directory"));
-        if (file)
-          file.append("filter-hits.ini");
-      } catch(e) {}
-    }
-
-    if (!file)
-      Cu.reportError("Adblock Plus: Failed to resolve filter-hits file");
-
-    this.__defineGetter__("filterHitsFile", function() file);
-    return this.filterHitsFile;
-  },
-  
-  /**
-   * Increases the filter hit count by one
+  /**
+   * Used to prevent timers running in parallel
+   * @type Number
+   */
+  _prefToggleTimeout: 0,
+
+  get connection()
+  {
+    if (!this.storageFile)
+      return null;
+
+    let connection = Services.storage.openDatabase(this.storageFile);
+    if (!connection.tableExists("filtersubscriptions"))
+    {
+      connection.executeSimpleSQL("CREATE TABLE filtersubscriptions " +
+        "(id INTEGER, subscriptions TEXT, PRIMARY KEY" +
+        "(id), UNIQUE(subscriptions))");
+    }
+    if (!connection.tableExists("filterhits"))
+    {
+      connection.executeSimpleSQL("CREATE TABLE filterhits (filter TEXT, " +
+        "host TEXT, thirdParty INTEGER, hitCount INTEGER, lastHit INTEGER, " +
+        "subscriptions INTEGER NOT NULL, PRIMARY KEY(filter, host, " +
+        "thirdParty), FOREIGN KEY(subscriptions) REFERENCES "+
+        "filtersubscriptions(id))");
+    }
+    Object.defineProperty(this, "connection",
+    {
+      value: connection
+    });
+    return connection;
+  },
+
+  /**
+   * @return nsIFile SQLite database file with filter hits data
+   */
+  get storageFile()
+  {
+    let file = IO.resolveFilePath(Prefs.data_directory);
+    if (file)
+      file.append("adblockplus.sqlite");
+
+    Object.defineProperty(this, "storageFile", 
+    {
+      value: file
+    });
+    return file;
+  },
+
+  /**
+   * Called on module startup.
+   */
+  init: function()
+  {
+    if (!Prefs.sendstats_status.lastPush)
+    {
+      Prefs.sendstats_status.lastPush = Date.now();
+      this._saveFilterHitPrefs();
+    }
+    Prefs.addListener(name =>
+    {
+      if (name == "sendstats")
+      {
+        if (this._prefToggleTimeout)
+          clearTimeout(this._prefToggleTimeout);
+        this._prefToggleTimeout = setTimeout(() =>
+        {
+          if (!Prefs.sendstats)
+            this.resetFilterHits();
+        }, 1000);
+      }
+    });
+
+    let downloader = new Downloader(this._getDownloadables.bind(this), 
+      INITIAL_DELAY, CHECK_INTERVAL);
+    downloader.onExpirationChange = this._onExpirationChange.bind(this);
+    downloader.generateRequestData = this._generateFilterHitsData.bind(this);
+    downloader.onDownloadSuccess = this._onDownloadSuccess.bind(this);
+    downloader.validResponses.push(204);
+    onShutdown.add(() => downloader.cancel());
+  },
+
+  /**
+   * Yields a Downloadable instance for the filter hits push.
+   */
+  _getDownloadables: function*()
+  {
+    let downloadable = new Downloadable(Prefs.sendstats_url);
+    if (Prefs.sendstats_status.lastError)
+      downloadable.lastError = Prefs.sendstats_status.lastError;
+    if (Prefs.sendstats_status.lastCheck)
+      downloadable.lastCheck = Prefs.sendstats_status.lastCheck;
+    if (Prefs.sendstats_status.lastPush)
+    {
+      downloadable.softExpiration = Prefs.sendstats_status.lastPush + PUSH_INTERVAL;

[saroyanm, 2016/04/06 15:15:45]

I'm not sure regarding this, should we specify softExpiration ?
BTW why do we have softExpiration ? What it suppose to do ?

+      downloadable.hardExpiration = Prefs.sendstats_status.lastPush + PUSH_INTERVAL;
+    }
+    yield downloadable;
+  },
+
+  _onExpirationChange: function(downloadable)
+  {
+    Prefs.sendstats_status.lastCheck = downloadable.lastCheck;
+    this._saveFilterHitPrefs();
+  },
+
+  _saveFilterHitPrefs: function()
+  {
+    Prefs.sendstats_status = JSON.parse(JSON.stringify(Prefs.sendstats_status));
+  },
+
+  _onDownloadSuccess: function(downloadable, responseText, errorCallback, redirectCallback)
+  {
+    Prefs.sendstats_status.lastError = 0;
+    Prefs.sendstats_status.lastPush = Date.now();
+    this._saveFilterHitPrefs();
+  },
+
+  /**
+   * Increases the filter hit count
    * @param {Filter} filter
-   * @param {Window} window  Window that the match originated in (required to get host name)
-   */
-  increaseFilterHits: function(filter, wnd)
-  {
-    if (!filter.text)
+   * @param {String} host 
+   */
+  increaseFilterHits: function(filter, host, thirdParty)
+  {
+    let subscriptions = filter.subscriptions;
+    let downloadableSubscriptions = [];
+    for (let i = 0; i < subscriptions.length; i++)
+    {
+      if (subscriptions[i] instanceof DownloadableSubscription)
+        downloadableSubscriptions.push(subscriptions[i].url);
+    }
+
+    if (downloadableSubscriptions.length == 0)
       return;
-    
-    if (filter.text in this.statistics)
-      this.statistics[filter.text].statsHitCount++;
-    else
-      this.statistics[filter.text] = {statsHitCount:1, lastHit: 0, domainsCount:{}, 
-                                      thirdParty: false, subscriptions: []};
-    
-    let increaseHits = function(filterStats)
-    {
-      if (filter.lastHit)
-        filterStats.lastHit = filter.lastHit;
-    
-      if (filter.subscriptions)
-      {
-        for (let i = 0; i < filter.subscriptions.length; i++)
+
+    if (!this.connection)
+      return;
+
+    let statements = [];
+    let filterSubscriptions = JSON.stringify(downloadableSubscriptions);
+    let subscriptionStatement = this.connection.createStatement("INSERT OR " +
+      "IGNORE INTO filtersubscriptions (subscriptions) VALUES " +
+      "(:subscriptions)");
+    subscriptionStatement.params.subscriptions = filterSubscriptions;
+    statements.push(subscriptionStatement);
+    let filterHitStatement = this.connection.createStatement("INSERT OR " +
+      "REPLACE INTO filterhits (filter, host, thirdParty, hitCount, lastHit, " +
+      "subscriptions) VALUES (:filter, :host, :thirdParty, COALESCE ((SELECT " +
+      "hitCount  FROM filterhits WHERE filter=:filter AND host=:host AND " +
+      "thirdParty=:thirdParty), 0) + 1, :lastHit, (SELECT id " +
+      "FROM filtersubscriptions WHERE subscriptions=:subscriptions))");
+    filterHitStatement.params.filter = filter.text;
+    filterHitStatement.params.host = host;
+    filterHitStatement.params.lastHit = roundToHours(filter.lastHit);
+    filterHitStatement.params.thirdParty = thirdParty;
+    filterHitStatement.params.subscriptions = filterSubscriptions;
+    statements.push(filterHitStatement);
+
+    this.connection.executeAsync(statements, statements.length,
+    {
+      handleError: (error) =>
+      {
+        Cu.reportError("Error updating filter hits: " + error.message);
+      },
+      handleCompletion: (reason) =>
+      {
+        if (reason != REASON_FINISHED)
+          Cu.reportError("Updating filter hits canceled or aborted: " + reason);
+      }
+    });
+  },
+
+  /**
+   * Remove all local collected filter hits data
+   */
+  resetFilterHits: function()
+  {
+    if (!this.connection)
+      return;
+
+    this.connection.executeSimpleSQL("DELETE FROM filterhits");
+    this.connection.executeSimpleSQL("DELETE FROM filtersubscriptions");
+  },
+
+  _generateFilterHitsData: function(downloadable)
+  {
+    return {
+      then: (resolve) =>
+      {
+        if (!this.connection)
+          return;
+
+        let statement = this.connection.createStatement("SELECT filterhits.*, " +
+        "filtersubscriptions.subscriptions FROM filterhits LEFT JOIN " +
+        "filtersubscriptions filtersubscriptions ON " +
+        "filterhits.subscriptions=filtersubscriptions.id");
+        statement.executeAsync(
         {
-          if (filterStats.subscriptions.indexOf(filter.subscriptions[i]._title) == -1)
-            filterStats.subscriptions.push(filter.subscriptions[i]._title);
-        }
+          handleResult: (result) =>
+          {
+            let filters = Object.create(null);
+            for (let row = result.getNextRow(); row;
+                 row = result.getNextRow())
+            {
+              let filterText = row.getResultByName("filter");
+              let host = row.getResultByName("host");
+              let matchType = (row.getResultByName("thirdParty") ? 
+                                "thirdParty" : "firstParty");
+              let hitCount = row.getResultByName("hitCount");
+              let lastHit = row.getResultByName("lastHit");
+              let subscriptions = row.getResultByName("subscriptions");
+              
+              if (!(filterText in filters))
+               filters[filterText] = Object.create(null);
+              
+              let filter = filters[filterText];
+              filter.subscriptions = subscriptions;
+              filter[matchType] = Object.create(null);
+              filter[matchType][host] = {"hits": hitCount, latest: lastHit};
+            }
+            resolve({timeSincePush: roundToHours(Date.now() -
+              Prefs.sendstats_status.lastPush), "filters": filters});
+          },
+          handleError: (error) =>
+          {
+            Prefs.sendstats_status.lastError = Date.now();
+            this._saveFilterHitPrefs();
+            Cu.reportError("Error loading filter hits:" + error.message);
+          },
+          handleCompletion: (reason) =>
+          {
+            if (reason != REASON_FINISHED)
+            {
+              Prefs.sendstats_status.lastError = Date.now();
+              this._saveFilterHitPrefs();
+              Cu.reportError("Loading of filter hits canceled or aborted: " + 
+                reason);
+            }
+          }
+        });
       }
-      
-      if (filter.thirdParty)
-        filterStats.thirdParty = true;
-        
-      // Get hostname from window object
-      let wndLocation = Utils.getOriginWindow(wnd).location.href;
-      let host = Utils.unwrapURL(wndLocation).host;
-      
-      if (host in filterStats.domainsCount)
-        filterStats.domainsCount[host]++;
-      else
-        filterStats.domainsCount[host] = 1;
-    };
-    
-    increaseHits(this.statistics[filter.text]);
-  },
-  
-  /**
-   * send filter hits statistics to ABP sever and reset filter hits count
-   */
-  sendFilterHitsToServer: function()
-  {
-    //TODO implement ajax request to server sending this.statistics
-    //clear statics on 200 response
-    this.resetFilterHits();
-    this.saveFilterHitsToDisk();
-  },
-  
-  /**
-   * Loads Filter hit statistics from the disk
-   */
-  loadFilterHitsFromDisk: function()
-  {
-    if (this._loading)
-      return;
-
-    let sourceFile = FilterHits.filterHitsFile;
-    if (!sourceFile)
-      return;
-
-    TimeLine.enter("Entered FilterHits.loadFilterHitsFromDisk()");
-    this._loading = true;
-
-    let readFile = function()
-    {
-      TimeLine.enter("FilterHits.loadFilterHitsFromDisk() -> readFile()");
-      let parser = new FilterHitsParser();
-      IO.readFromFile(sourceFile, true, parser, function(e)
-      {
-        TimeLine.enter("FilterHits.loadFilterHitsFromDisk() read callback");
-        if (e)
-          Cu.reportError(e);
-
-        doneReading(parser);
-      }.bind(this), "FilterHitsRead");
-
-      TimeLine.leave("FilterHits.loadFilterHitsFromDisk() <- readFile()", "FilterHitsRead");
-    }.bind(this);
-
-    var doneReading = function(parser)
-    {
-      FilterHits.statistics = parser.statistics;
-      this._loading = false;
-      TimeLine.leave("FilterHits.loadFilterHitsFromDisk() read callback done");
-    }.bind(this);
-    
-    IO.statFile(sourceFile, function(e, statData)
-    {
-      if (!e && statData.exists)
-        readFile(sourceFile);
-    });
-    TimeLine.leave("FilterHits.loadFilterHitsFromDisk() done");
-  },
-  
-  /**
-   * Stringify filter hits statistics object
-   */
-  _generateFilterHitData: function()
-  {
-    yield JSON.stringify(FilterHits.statistics);
-  },
-  
-  /**
-   * Save Filters hit statistics to the disk
-   */
-  saveFilterHitsToDisk: function()
-  {
-    let targetFile = FilterHits.filterHitsFile;
-    if (!targetFile)
-      return;
-
-    if (this._saving)
-    {
-      this._needsSave = true;
-      return;
-    }
-    TimeLine.enter("Entered FilterHits.saveFilterHitsToDisk()");
-    // Make sure the file's parent directory exists
-    try {
-      targetFile.parent.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
-    } catch (e) {}
-
-    let writeStats = function()
-    {
-      TimeLine.enter("FilterHits.saveFilterHitsToDisk() -> writeStats()");
-      IO.writeToFile(targetFile, true, this._generateFilterHitData(), function(e)
-      {
-        TimeLine.enter("FilterHits.saveFilterHitsToDisk() write callback");
-        this._saving = false;
-
-        if (e)
-          Cu.reportError(e);
-
-        if (this._needsSave)
-        {
-          this._needsSave = false;
-          this.saveFilterHitsToDisk();
-        }
-        TimeLine.leave("FilterHits.saveFilterHitsToDisk() write callback done");
-      }.bind(this), "FilterHitsWriteStats");
-      TimeLine.leave("FilterHits.saveFilterHitsToDisk() -> writeStats()", "FilterStorageWriteStats");
-    }.bind(this);
-
-    this._saving = true;
-    writeStats();
-    TimeLine.leave("FilterHits.saveFilterHitsToDisk() done");
-  }
+    }
+  },
 };
 
-/**
- * IO.readFromFile() listener to parse filter-hits data.
- * @constructor
- */
-function FilterHitsParser()
+function roundToHours(timestamp)
 {
-  this.statistics = {__proto__: null};
+  return Math.round(timestamp / MILLIS_IN_HOUR) *
+      (MILLIS_IN_HOUR / MILLIS_IN_SECOND);
 }
-FilterHitsParser.prototype =
-{
-  process: function(val)
-  {
-    if (val === null)
-       return;
-    this.statistics = JSON.parse(val);
-  }
-};
+
+FilterHits.init();