예제 #1
0
 def setUp(self):
     self.sample_aggregation_rule = AggregationRule(r'^carbon.foo',
                                                    r'carbon.foo.sum',
                                                    'sum', 1)
     self.sample_overwriting_aggregation_rule = \
         AggregationRule(r'^carbon.foo', r'carbon.foo', 'sum', 1)
     self.processor = AggregationProcessor()
예제 #2
0
def _bench_aggregator(name):
    print "== %s ==" % name
    max_intervals = settings['MAX_AGGREGATION_INTERVALS']
    now = time.time() - (max_intervals * FREQUENCY)

    buf = None
    for n in [1, 1000, 10000, 100000, 1000000, 10000000]:
        count = 0
        processor = AggregationProcessor()
        processor.process(METRIC, (now, 1))

        def _process():
            processor.process(METRIC, (now + _process.i, 1))
            if (_process.i % FREQUENCY) == 0 and buf is not None:
                buf.compute_values()
            _process.i += 1
        _process.i = 0

        if buf is None:
            buf = BufferManager.get_buffer(METRIC_AGGR, 1, None)

        t = timeit.timeit(_process, number=n)
        buf.close()
        print_stats(n, t)
    print ""
예제 #3
0
def _bench_aggregator(name):
    print("== %s ==" % name)
    max_intervals = settings['MAX_AGGREGATION_INTERVALS']
    now = time.time() - (max_intervals * FREQUENCY)

    buf = None
    for n in [1, 1000, 10000, 100000, 1000000, 10000000]:
        processor = AggregationProcessor()
        processor.process(METRIC, (now, 1))

        def _process():
            processor.process(METRIC, (now + _process.i, 1))
            if (_process.i % FREQUENCY) == 0 and buf is not None:
                buf.compute_values()
            _process.i += 1

        _process.i = 0

        if buf is None:
            buf = BufferManager.get_buffer(METRIC_AGGR, 1, None)

        t = timeit.timeit(_process, number=n)
        buf.close()
        print_stats(n, t)
    print("")
예제 #4
0
class AggregationProcessorTest(TestCase):
    def setUp(self):
        self.sample_aggregation_rule = AggregationRule(r'^carbon.foo',
                                                       r'carbon.foo.sum',
                                                       'sum', 1)
        self.sample_overwriting_aggregation_rule = \
            AggregationRule(r'^carbon.foo', r'carbon.foo', 'sum', 1)
        self.processor = AggregationProcessor()

    def tearDown(self):
        instrumentation.stats.clear()
        BufferManager.clear()
        RuleManager.clear()

    def test_registers_plugin(self):
        self.assertTrue('aggregate' in Processor.plugins)

    def test_process_increments_datapoints_metric(self):
        list(self.processor.process('carbon.foo', (0, 0)))
        self.assertEqual(1, instrumentation.stats['datapointsReceived'])

    def test_unaggregated_metrics_pass_through_when_no_rules(self):
        result = list(self.processor.process('carbon.foo', (0, 0)))
        self.assertEqual([('carbon.foo', (0, 0))], result)

    def test_unaggregated_metrics_pass_through(self):
        RuleManager.rules = [self.sample_aggregation_rule]
        result = list(self.processor.process('carbon.foo', (0, 0)))
        self.assertEqual([('carbon.foo', (0, 0))], result)

    def test_aggregation_rule_checked(self):
        RuleManager.rules = [self.sample_aggregation_rule]
        with patch.object(self.sample_aggregation_rule,
                          'get_aggregate_metric'):
            list(self.processor.process('carbon.foo', (0, 0)))
            self.sample_aggregation_rule.get_aggregate_metric.assert_called_once_with(
                'carbon.foo')

    def test_new_buffer_configured(self):
        RuleManager.rules = [self.sample_aggregation_rule]
        list(self.processor.process('carbon.foo', (0, 0)))
        values_buffer = BufferManager.get_buffer('carbon.foo.sum')

        self.assertTrue(values_buffer.configured)
        self.assertEqual(1, values_buffer.aggregation_frequency)
        self.assertEqual(sum, values_buffer.aggregation_func)

    def test_buffer_receives_value(self):
        RuleManager.rules = [self.sample_aggregation_rule]
        list(self.processor.process('carbon.foo', (0, 0)))
        values_buffer = BufferManager.get_buffer('carbon.foo.sum')

        self.assertEqual([0], values_buffer.interval_buffers[0].values)

    def test_metric_not_passed_through_when_aggregate_overwrites(self):
        RuleManager.rules = [self.sample_overwriting_aggregation_rule]
        result = list(self.processor.process('carbon.foo', (0, 0)))

        self.assertEqual([], result)
class AggregationProcessorTest(TestCase):
  def setUp(self):
    self.sample_aggregation_rule = AggregationRule(r'^carbon.foo', r'carbon.foo.sum', 'sum', 1)
    self.sample_overwriting_aggregation_rule = \
        AggregationRule(r'^carbon.foo', r'carbon.foo', 'sum', 1)
    self.processor = AggregationProcessor()

  def tearDown(self):
    instrumentation.stats.clear()
    BufferManager.clear()
    RuleManager.clear()

  def test_registers_plugin(self):
    self.assertTrue('aggregate' in Processor.plugins)

  def test_process_increments_datapoints_metric(self):
    list(self.processor.process('carbon.foo', (0, 0)))
    self.assertEqual(1, instrumentation.stats['datapointsReceived'])

  def test_unaggregated_metrics_pass_through_when_no_rules(self):
    result = list(self.processor.process('carbon.foo', (0, 0)))
    self.assertEqual([('carbon.foo', (0, 0))], result)

  def test_unaggregated_metrics_pass_through(self):
    RuleManager.rules = [self.sample_aggregation_rule]
    result = list(self.processor.process('carbon.foo', (0, 0)))
    self.assertEqual([('carbon.foo', (0, 0))], result)

  def test_aggregation_rule_checked(self):
    RuleManager.rules = [self.sample_aggregation_rule]
    with patch.object(self.sample_aggregation_rule, 'get_aggregate_metric'):
      list(self.processor.process('carbon.foo', (0, 0)))
      self.sample_aggregation_rule.get_aggregate_metric.assert_called_once_with('carbon.foo')

  def test_new_buffer_configured(self):
    RuleManager.rules = [self.sample_aggregation_rule]
    list(self.processor.process('carbon.foo', (0, 0)))
    values_buffer = BufferManager.get_buffer('carbon.foo.sum')

    self.assertTrue(values_buffer.configured)
    self.assertEqual(1, values_buffer.aggregation_frequency)
    self.assertEqual(sum, values_buffer.aggregation_func)

  def test_buffer_receives_value(self):
    RuleManager.rules = [self.sample_aggregation_rule]
    list(self.processor.process('carbon.foo', (0, 0)))
    values_buffer = BufferManager.get_buffer('carbon.foo.sum')

    self.assertEqual([0], values_buffer.interval_buffers[0].values)

  def test_metric_not_passed_through_when_aggregate_overwrites(self):
    RuleManager.rules = [self.sample_overwriting_aggregation_rule]
    result = list(self.processor.process('carbon.foo', (0, 0)))

    self.assertEqual([], result)
 def setUp(self):
   self.sample_aggregation_rule = AggregationRule(r'^carbon.foo', r'carbon.foo.sum', 'sum', 1)
   self.sample_overwriting_aggregation_rule = \
       AggregationRule(r'^carbon.foo', r'carbon.foo', 'sum', 1)
   self.processor = AggregationProcessor()
예제 #7
0
class AggregationProcessorTest(TestCase):
    def setUp(self):
        self.sample_rewrite_rule = RewriteRule(r'^(carbon.foo)', r'\1.bar')
        self.sample_aggregation_rule = AggregationRule(r'^carbon.foo',
                                                       r'carbon.foo.sum',
                                                       'sum', 1)
        self.sample_overwriting_aggregation_rule = \
            AggregationRule(r'^carbon.foo', r'carbon.foo', 'sum', 1)
        self.processor = AggregationProcessor()

    def tearDown(self):
        instrumentation.stats.clear()
        BufferManager.clear()
        RuleManager.clear()
        RewriteRuleManager.clear()

    def test_registers_plugin(self):
        self.assertTrue('aggregate' in Processor.plugins)

    def test_process_increments_datapoints_metric(self):
        list(self.processor.process('carbon.foo', (0, 0)))
        self.assertEqual(1, instrumentation.stats['datapointsReceived'])

    def test_pre_rules_applied(self):
        RewriteRuleManager.rulesets[PRE] = [self.sample_rewrite_rule]
        result = list(self.processor.process('carbon.foo', (0, 0)))
        self.assertEqual('carbon.foo.bar', result[0][0])

    def test_post_rules_applied(self):
        RewriteRuleManager.rulesets[POST] = [self.sample_rewrite_rule]
        result = list(self.processor.process('carbon.foo', (0, 0)))
        self.assertEqual('carbon.foo.bar', result[0][0])

    def test_unaggregated_metrics_pass_through_when_no_rules(self):
        result = list(self.processor.process('carbon.foo', (0, 0)))
        self.assertEqual([('carbon.foo', (0, 0))], result)

    def test_unaggregated_metrics_pass_through(self):
        RuleManager.rules = [self.sample_aggregation_rule]
        result = list(self.processor.process('carbon.foo', (0, 0)))
        self.assertEqual([('carbon.foo', (0, 0))], result)

    def test_aggregation_rule_checked(self):
        RuleManager.rules = [self.sample_aggregation_rule]
        with patch.object(self.sample_aggregation_rule,
                          'get_aggregate_metric'):
            list(self.processor.process('carbon.foo', (0, 0)))
            self.sample_aggregation_rule.get_aggregate_metric.assert_called_once_with(
                'carbon.foo')

    def test_pre_rewrite_then_aggregation_rule(self):
        RewriteRuleManager.rulesets[PRE] = [self.sample_rewrite_rule]
        RuleManager.rules = [self.sample_aggregation_rule]
        apply_mock = Mock(
            side_effect=['carbon.foo.rewrite', 'carbon.foo.rewrite.aggregate'])

        with patch.object(self.sample_rewrite_rule, 'apply', apply_mock):
            with patch.object(self.sample_aggregation_rule,
                              'get_aggregate_metric', apply_mock):
                list(self.processor.process('carbon.foo', (0, 0)))

        # Pre rewrite gets metric as passed in and transforms before aggregation rule called
        self.assertEqual([call('carbon.foo'),
                          call('carbon.foo.rewrite')],
                         apply_mock.call_args_list)

    def test_aggregation_rule_then_post_rewrite(self):
        RuleManager.rules = [self.sample_aggregation_rule]
        RewriteRuleManager.rulesets[POST] = [self.sample_rewrite_rule]
        apply_mock = Mock(side_effect=[
            'carbon.foo.aggregate', 'carbon.foo.aggregate.rewrite'
        ])

        with patch.object(self.sample_rewrite_rule, 'apply', apply_mock):
            with patch.object(self.sample_aggregation_rule,
                              'get_aggregate_metric', apply_mock):
                list(self.processor.process('carbon.foo', (0, 0)))
        # Aggregation rule gets metric as passed in and so does post rewrite (due to no pre)
        self.assertEqual(
            [call('carbon.foo'), call('carbon.foo')],
            apply_mock.call_args_list)

    def test_pre_rewrite_then_post_rewrite(self):
        RewriteRuleManager.rulesets[PRE] = [self.sample_rewrite_rule]
        RewriteRuleManager.rulesets[POST] = [self.sample_rewrite_rule]
        apply_mock = Mock(
            side_effect=['carbon.foo.rewrite', 'carbon.foo.rewrite.rewrite'])

        with patch.object(self.sample_rewrite_rule, 'apply', apply_mock):
            list(self.processor.process('carbon.foo', (0, 0)))

        # Pre rewrite gets metric as passed in and transforms before post rewrite called
        self.assertEqual([call('carbon.foo'),
                          call('carbon.foo.rewrite')],
                         apply_mock.call_args_list)

    def test_new_buffer_configured(self):
        RuleManager.rules = [self.sample_aggregation_rule]
        list(self.processor.process('carbon.foo', (0, 0)))
        values_buffer = BufferManager.get_buffer('carbon.foo.sum')

        self.assertTrue(values_buffer.configured)
        self.assertEqual(1, values_buffer.aggregation_frequency)
        self.assertEqual(sum, values_buffer.aggregation_func)

    def test_buffer_receives_value(self):
        RuleManager.rules = [self.sample_aggregation_rule]
        list(self.processor.process('carbon.foo', (0, 0)))
        values_buffer = BufferManager.get_buffer('carbon.foo.sum')

        self.assertEqual([0], values_buffer.interval_buffers[0].values)

    def test_metric_not_passed_through_when_aggregate_overwrites(self):
        RuleManager.rules = [self.sample_overwriting_aggregation_rule]
        result = list(self.processor.process('carbon.foo', (0, 0)))

        self.assertEqual([], result)
class AggregationProcessorTest(TestCase):
  def setUp(self):
    self.sample_rewrite_rule = RewriteRule(r'^(carbon.foo)', r'\1.bar')
    self.sample_aggregation_rule = AggregationRule(r'^carbon.foo', r'carbon.foo.sum', 'sum', 1)
    self.sample_overwriting_aggregation_rule = \
        AggregationRule(r'^carbon.foo', r'carbon.foo', 'sum', 1)
    self.processor = AggregationProcessor()

  def tearDown(self):
    instrumentation.stats.clear()
    BufferManager.clear()
    RuleManager.clear()
    RewriteRuleManager.clear()

  def test_registers_plugin(self):
    self.assertTrue('aggregate' in Processor.plugins)

  def test_process_increments_datapoints_metric(self):
    list(self.processor.process('carbon.foo', (0, 0)))
    self.assertEqual(1, instrumentation.stats['datapointsReceived'])

  def test_pre_rules_applied(self):
    RewriteRuleManager.rulesets[PRE] = [self.sample_rewrite_rule]
    result = list(self.processor.process('carbon.foo', (0, 0)))
    self.assertEqual('carbon.foo.bar', result[0][0])

  def test_post_rules_applied(self):
    RewriteRuleManager.rulesets[POST] = [self.sample_rewrite_rule]
    result = list(self.processor.process('carbon.foo', (0, 0)))
    self.assertEqual('carbon.foo.bar', result[0][0])

  def test_unaggregated_metrics_pass_through_when_no_rules(self):
    result = list(self.processor.process('carbon.foo', (0, 0)))
    self.assertEqual([('carbon.foo', (0, 0))], result)

  def test_unaggregated_metrics_pass_through(self):
    RuleManager.rules = [self.sample_aggregation_rule]
    result = list(self.processor.process('carbon.foo', (0, 0)))
    self.assertEqual([('carbon.foo', (0, 0))], result)

  def test_aggregation_rule_checked(self):
    RuleManager.rules = [self.sample_aggregation_rule]
    with patch.object(self.sample_aggregation_rule, 'get_aggregate_metric'):
      list(self.processor.process('carbon.foo', (0, 0)))
      self.sample_aggregation_rule.get_aggregate_metric.assert_called_once_with('carbon.foo')

  def test_pre_rewrite_then_aggregation_rule(self):
    RewriteRuleManager.rulesets[PRE] = [self.sample_rewrite_rule]
    RuleManager.rules = [self.sample_aggregation_rule]
    apply_mock = Mock(side_effect=['carbon.foo.rewrite', 'carbon.foo.rewrite.aggregate'])

    with patch.object(self.sample_rewrite_rule, 'apply', apply_mock):
      with patch.object(self.sample_aggregation_rule, 'get_aggregate_metric', apply_mock):
        list(self.processor.process('carbon.foo', (0, 0)))

    # Pre rewrite gets metric as passed in and transforms before aggregation rule called
    self.assertEqual([call('carbon.foo'), call('carbon.foo.rewrite')], apply_mock.call_args_list)

  def test_aggregation_rule_then_post_rewrite(self):
    RuleManager.rules = [self.sample_aggregation_rule]
    RewriteRuleManager.rulesets[POST] = [self.sample_rewrite_rule]
    apply_mock = Mock(side_effect=['carbon.foo.aggregate', 'carbon.foo.aggregate.rewrite'])

    with patch.object(self.sample_rewrite_rule, 'apply', apply_mock):
      with patch.object(self.sample_aggregation_rule, 'get_aggregate_metric', apply_mock):
        list(self.processor.process('carbon.foo', (0, 0)))
    # Aggregation rule gets metric as passed in and so does post rewrite (due to no pre)
    self.assertEqual([call('carbon.foo'), call('carbon.foo')], apply_mock.call_args_list)

  def test_pre_rewrite_then_post_rewrite(self):
    RewriteRuleManager.rulesets[PRE] = [self.sample_rewrite_rule]
    RewriteRuleManager.rulesets[POST] = [self.sample_rewrite_rule]
    apply_mock = Mock(side_effect=['carbon.foo.rewrite', 'carbon.foo.rewrite.rewrite'])

    with patch.object(self.sample_rewrite_rule, 'apply', apply_mock):
      list(self.processor.process('carbon.foo', (0, 0)))

    # Pre rewrite gets metric as passed in and transforms before post rewrite called
    self.assertEqual([call('carbon.foo'), call('carbon.foo.rewrite')], apply_mock.call_args_list)

  def test_new_buffer_configured(self):
    RuleManager.rules = [self.sample_aggregation_rule]
    list(self.processor.process('carbon.foo', (0, 0)))
    values_buffer = BufferManager.get_buffer('carbon.foo.sum')

    self.assertTrue(values_buffer.configured)
    self.assertEqual(1, values_buffer.aggregation_frequency)
    self.assertEqual(sum, values_buffer.aggregation_func)

  def test_buffer_receives_value(self):
    RuleManager.rules = [self.sample_aggregation_rule]
    list(self.processor.process('carbon.foo', (0, 0)))
    values_buffer = BufferManager.get_buffer('carbon.foo.sum')

    self.assertEqual([0], values_buffer.interval_buffers[0].values)

  def test_metric_not_passed_through_when_aggregate_overwrites(self):
    RuleManager.rules = [self.sample_overwriting_aggregation_rule]
    result = list(self.processor.process('carbon.foo', (0, 0)))

    self.assertEqual([], result)