The Tor Browser: toolkit/components/telemetry/histogram

toolkit/components/telemetry/histogram_tools.py@129ffea94266 (annotated)

toolkit/components/telemetry/histogram_tools.py

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 import json
 import math
 import re
 from collections import OrderedDict
 def table_dispatch(kind, table, body):
     """Call body with table[kind] if it exists.  Raise an error otherwise."""
     if kind in table:
         return body(table[kind])
     else:
         raise BaseException, "don't know how to handle a histogram of kind %s" % kind
 class DefinitionException(BaseException):
     pass
 def check_numeric_limits(dmin, dmax, n_buckets):
     if type(dmin) != int:
         raise DefinitionException, "minimum is not a number"
     if type(dmax) != int:
         raise DefinitionException, "maximum is not a number"
     if type(n_buckets) != int:
         raise DefinitionException, "number of buckets is not a number"
 def linear_buckets(dmin, dmax, n_buckets):
     check_numeric_limits(dmin, dmax, n_buckets)
     ret_array = [0] * n_buckets
     dmin = float(dmin)
     dmax = float(dmax)
     for i in range(1, n_buckets):
         linear_range = (dmin * (n_buckets - 1 - i) + dmax * (i - 1)) / (n_buckets - 2)
         ret_array[i] = int(linear_range + 0.5)
     return ret_array
 def exponential_buckets(dmin, dmax, n_buckets):
     check_numeric_limits(dmin, dmax, n_buckets)
     log_max = math.log(dmax);
     bucket_index = 2;
     ret_array = [0] * n_buckets
     current = dmin
     ret_array[1] = current
     for bucket_index in range(2, n_buckets):
         log_current = math.log(current)
         log_ratio = (log_max - log_current) / (n_buckets - bucket_index)
         log_next = log_current + log_ratio
         next_value = int(math.floor(math.exp(log_next) + 0.5))
         if next_value > current:
             current = next_value
         else:
             current = current + 1
         ret_array[bucket_index] = current
     return ret_array
 always_allowed_keys = ['kind', 'description', 'cpp_guard', 'expires_in_version']
 class Histogram:
     """A class for representing a histogram definition."""
     def __init__(self, name, definition):
         """Initialize a histogram named name with the given definition.
 definition is a dict-like object that must contain at least the keys:
  - 'kind': The kind of histogram.  Must be one of 'boolean', 'flag',
    'enumerated', 'linear', or 'exponential'.
  - 'description': A textual description of the histogram.
 The key 'cpp_guard' is optional; if present, it denotes a preprocessor
 symbol that should guard C/C++ definitions associated with the histogram."""
         self.verify_attributes(name, definition)
         self._name = name
         self._description = definition['description']
         self._kind = definition['kind']
         self._cpp_guard = definition.get('cpp_guard')
         self._extended_statistics_ok = definition.get('extended_statistics_ok', False)
         self._expiration = definition.get('expires_in_version')
         self.compute_bucket_parameters(definition)
         table = { 'boolean': 'BOOLEAN',
                   'flag': 'FLAG',
                   'enumerated': 'LINEAR',
                   'linear': 'LINEAR',
                   'exponential': 'EXPONENTIAL' }
         table_dispatch(self.kind(), table,
                        lambda k: self._set_nsITelemetry_kind(k))
     def name(self):
         """Return the name of the histogram."""
         return self._name
     def description(self):
         """Return the description of the histogram."""
         return self._description
     def kind(self):
         """Return the kind of the histogram.
 Will be one of 'boolean', 'flag', 'enumerated', 'linear', or 'exponential'."""
         return self._kind
     def expiration(self):
         """Return the expiration version of the histogram."""
         return self._expiration
     def nsITelemetry_kind(self):
         """Return the nsITelemetry constant corresponding to the kind of
 the histogram."""
         return self._nsITelemetry_kind
     def _set_nsITelemetry_kind(self, kind):
         self._nsITelemetry_kind = "nsITelemetry::HISTOGRAM_%s" % kind
     def low(self):
         """Return the lower bound of the histogram.  May be a string."""
         return self._low
     def high(self):
         """Return the high bound of the histogram.  May be a string."""
         return self._high
     def n_buckets(self):
         """Return the number of buckets in the histogram.  May be a string."""
         return self._n_buckets
     def cpp_guard(self):
         """Return the preprocessor symbol that should guard C/C++ definitions
 associated with the histogram.  Returns None if no guarding is necessary."""
         return self._cpp_guard
     def extended_statistics_ok(self):
         """Return True if gathering extended statistics for this histogram
 is enabled."""
         return self._extended_statistics_ok
     def ranges(self):
         """Return an array of lower bounds for each bucket in the histogram."""
         table = { 'boolean': linear_buckets,
                   'flag': linear_buckets,
                   'enumerated': linear_buckets,
                   'linear': linear_buckets,
                   'exponential': exponential_buckets }
         return table_dispatch(self.kind(), table,
                               lambda p: p(self.low(), self.high(), self.n_buckets()))
     def compute_bucket_parameters(self, definition):
         table = {
             'boolean': Histogram.boolean_flag_bucket_parameters,
             'flag': Histogram.boolean_flag_bucket_parameters,
             'enumerated': Histogram.enumerated_bucket_parameters,
             'linear': Histogram.linear_bucket_parameters,
             'exponential': Histogram.exponential_bucket_parameters
             }
         table_dispatch(self.kind(), table,
                        lambda p: self.set_bucket_parameters(*p(definition)))
     def verify_attributes(self, name, definition):
         global always_allowed_keys
         general_keys = always_allowed_keys + ['low', 'high', 'n_buckets']
         table = {
             'boolean': always_allowed_keys,
             'flag': always_allowed_keys,
             'enumerated': always_allowed_keys + ['n_values'],
             'linear': general_keys,
             'exponential': general_keys + ['extended_statistics_ok']
             }
         table_dispatch(definition['kind'], table,
                        lambda allowed_keys: Histogram.check_keys(name, definition, allowed_keys))
         Histogram.check_expiration(name, definition)
     @staticmethod
     def check_expiration(name, definition):
         expiration = definition.get('expires_in_version')
         if not expiration:
             return
         if re.match(r'^[1-9][0-9]*$', expiration):
             expiration = expiration + ".0a1"
         elif re.match(r'^[1-9][0-9]*\.0$', expiration):
             expiration = expiration + "a1"
         definition['expires_in_version'] = expiration
     @staticmethod
     def check_keys(name, definition, allowed_keys):
         for key in definition.iterkeys():
             if key not in allowed_keys:
                 raise KeyError, '%s not permitted for %s' % (key, name)
     def set_bucket_parameters(self, low, high, n_buckets):
         def try_to_coerce_to_number(v):
             try:
                 return eval(v, {})
             except:
                 return v
         self._low = try_to_coerce_to_number(low)
         self._high = try_to_coerce_to_number(high)
         self._n_buckets = try_to_coerce_to_number(n_buckets)
     @staticmethod
     def boolean_flag_bucket_parameters(definition):
         return (1, 2, 3)
     @staticmethod
     def linear_bucket_parameters(definition):
         return (definition.get('low', 1),
                 definition['high'],
                 definition['n_buckets'])
     @staticmethod
     def enumerated_bucket_parameters(definition):
         n_values = definition['n_values']
         return (1, n_values, "%s+1" % n_values)
     @staticmethod
     def exponential_bucket_parameters(definition):
         return (definition.get('low', 1),
                 definition['high'],
                 definition['n_buckets'])
 def from_file(filename):
     """Return an iterator that provides a sequence of Histograms for
 the histograms defined in filename.
     """
     with open(filename, 'r') as f:
         histograms = json.load(f, object_pairs_hook=OrderedDict)
         for (name, definition) in histograms.iteritems():
             yield Histogram(name, definition)

The Tor Browser / annotate

toolkit/components/telemetry/histogram_tools.py@129ffea94266 (annotated)

toolkit/components/telemetry/histogram_tools.py