class TestCassandraJolokiaCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config('CassandraJolokiaCollector', {})

        self.collector = CassandraJolokiaCollector(config, None)
        self.collector.list_request = list_request

    def test_import(self):
        self.assertTrue(CassandraJolokiaCollector)

    @patch.object(Collector, 'flush')
    def test_should_create_dimension(self, publish_mock):
        def se(url):
            return self.getFixture("metrics.json")

        patch_urlopen = patch('urllib2.urlopen', Mock(side_effect=se))

        with patch_urlopen:
            self.collector.collect()
        self.assertEquals(len(self.collector.payload), 3828)

        metrics = find_metric(self.collector.payload, "org.apache.cassandra.metrics.ColumnFamily.LiveSSTableCount")
        self.assertNotEqual(len(metrics), 0)
        metric = find_by_dimension(metrics, "type", "compaction_history")
        self.assertEquals(metric["type"], "GAUGE")

    @patch.object(Collector, 'flush')
    def test_should_create_type(self, publish_mock):
        def se(url):
            return self.getFixture("metrics.json")

        patch_urlopen = patch('urllib2.urlopen', Mock(side_effect=se))

        with patch_urlopen:
            self.collector.collect()
        self.assertEquals(len(self.collector.payload), 3828)

        metrics = find_metric(self.collector.payload, "org.apache.cassandra.metrics.ColumnFamily.CoordinatorReadLatency.count")
        self.assertNotEqual(len(metrics), 0)
        metric = find_by_dimension(metrics, "keyspace", "OpsCenter")
        self.assertEquals(metric["type"], "CUMCOUNTER")
Beispiel #2
0
    def setUp(self):
        config = get_collector_config('CassandraJolokiaCollector', {})

        self.collector = CassandraJolokiaCollector(config, None)
Beispiel #3
0
class TestCassandraJolokiaCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config('CassandraJolokiaCollector', {})

        self.collector = CassandraJolokiaCollector(config, None)

    # Used for all the tests so the expected numbers are all the same.
    def fixture_values_a(self):
        values = [0] * 92
        values[30:56] = [
            3, 3, 1, 1, 8, 5, 6, 1, 6, 5, 3, 8, 9, 10, 7, 8, 7, 5, 5, 5, 3, 3,
            2, 2, 2
        ]
        return values

    def empty_fixture_values(self):
        return [0] * 91

    def expected_percentiles_for_fixture_a(self, percentile_key):
        return {
            'p25': 192.0,
            'p50': 398.0,
            'p75': 824.0,
            'p95': 2050.0,
            'p99': 2952.0
        }[percentile_key]

    def test_import(self):
        self.assertTrue(CassandraJolokiaCollector)

    def test_should_compute_percentiles_accurately(self):
        ninety_offsets = self.collector.create_offsets(90)
        percentile_value = self.collector.compute_percentile(
            ninety_offsets, self.fixture_values_a(), 50)
        self.assertEqual(percentile_value, 398.0)

    def test_should_compute_percentiles_accurately_when_empty(self):
        ninety_offsets = self.collector.create_offsets(90)
        self.assertEqual(
            self.collector.compute_percentile(ninety_offsets,
                                              self.empty_fixture_values(), 50),
            0.0)
        self.assertEqual(
            self.collector.compute_percentile(ninety_offsets,
                                              self.empty_fixture_values(), 95),
            0.0)
        self.assertEqual(
            self.collector.compute_percentile(ninety_offsets,
                                              self.empty_fixture_values(), 99),
            0.0)

    @patch.object(Collector, 'publish')
    def test_should_not_collect_non_histogram_attributes(self, publish_mock):
        self.collector.interpret_bean_with_list('RecentReadLatencyMicros',
                                                self.fixture_values_a())
        self.assertPublishedMany(publish_mock, {})

    @patch.object(Collector, 'publish')
    def test_should_collect_metrics_histogram_attributes(self, publish_mock):
        self.collector.interpret_bean_with_list(
            'RecentReadLatencyHistogramMicros', self.fixture_values_a())
        self.assertPublishedMany(
            publish_mock, {
                'RecentReadLatencyHistogramMicros.p50':
                self.expected_percentiles_for_fixture_a('p50'),
                'RecentReadLatencyHistogramMicros.p95':
                self.expected_percentiles_for_fixture_a('p95'),
                'RecentReadLatencyHistogramMicros.p99':
                self.expected_percentiles_for_fixture_a('p99')
            })

    @patch.object(Collector, 'publish')
    def test_should_respect_percentiles_config(self, publish_mock):
        self.collector.update_config({'percentiles': '25,75'})
        self.collector.interpret_bean_with_list(
            'RecentReadLatencyHistogramMicros', self.fixture_values_a())
        self.assertPublishedMany(
            publish_mock, {
                'RecentReadLatencyHistogramMicros.p25':
                self.expected_percentiles_for_fixture_a('p25'),
                'RecentReadLatencyHistogramMicros.p75':
                self.expected_percentiles_for_fixture_a('p75'),
            })

    @patch.object(Collector, 'publish')
    def test_should_respect_histogram_regex_config(self, publish_mock):
        self.collector.update_config({'histogram_regex': '^WackyMetric'})
        self.collector.interpret_bean_with_list('WackyMetricSeventeen',
                                                self.fixture_values_a())
        self.assertPublishedMany(
            publish_mock, {
                'WackyMetricSeventeen.p50':
                self.expected_percentiles_for_fixture_a('p50'),
                'WackyMetricSeventeen.p95':
                self.expected_percentiles_for_fixture_a('p95'),
                'WackyMetricSeventeen.p99':
                self.expected_percentiles_for_fixture_a('p99')
            })
    def setUp(self):
        config = get_collector_config('CassandraJolokiaCollector', {})

        self.collector = CassandraJolokiaCollector(config, None)
        self.collector.list_request = list_request
Beispiel #5
0
class TestCassandraJolokiaCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config('CassandraJolokiaCollector', {})

        self.collector = CassandraJolokiaCollector(config, None)

    def test_import(self):
        self.assertTrue(CassandraJolokiaCollector)

    @patch.object(Collector, 'flush')
    def test_should_create_dimension(self, publish_mock):
        self.collector.list_request = list_request

        def se(url):
            return self.getFixture("metrics.json")

        patch_urlopen = patch('urllib2.urlopen', Mock(side_effect=se))

        with patch_urlopen:
            self.collector.collect()
        self.assertEquals(len(self.collector.payload), 3827)

        metrics = find_metric(self.collector.payload, "org.apache.cassandra.metrics.ColumnFamily.LiveSSTableCount")
        self.assertNotEqual(len(metrics), 0)
        metric = find_by_dimension(metrics, "type", "compaction_history")
        self.assertEquals(metric["type"], "GAUGE")

        pending_task = find_metric(self.collector.payload,
                                   "org.apache.cassandra.metrics.CommitLog4.2.PendingTasks")
        self.assertNotEqual(len(pending_task), 0)

    def test_patch_host_list_should_filter_out_non_cassandra_hosts(self):
        data = {
            "services": {
                "service1": { "host": "10.0.0.1" },
                "cassandra_1.dc": { "host": "10.0.0.2"}
            }
        }
        with patch("__builtin__.open", mock_open(read_data=json.dumps(data))):
            hosts = self.collector.read_host_list()
        self.assertEqual(
            hosts,
            {
                'cassandra_1': { 'host': '10.0.0.2', 'port': self.collector.config['port'] }
            }
        )

    @patch.object(Collector, 'flush')
    def test_should_have_cassandra_cluster_dimension_in_multi_hosts_mode(self, publish_mock):
        self.collector.list_request = list_request
        self.collector.config['multiple_hosts_mode'] = True
        self.collector.read_host_list = read_host_list

        def se(url):
            return self.getFixture("metrics.json")

        patch_urlopen = patch('urllib2.urlopen', Mock(side_effect=se))

        with patch_urlopen:
            self.collector.collect()
        self.collector.config['multiple_hosts_mode'] = False
        self.assertEquals(len(self.collector.payload), 3827 * 2)

        metrics = find_metric(self.collector.payload, "org.apache.cassandra.metrics.ColumnFamily.LiveSSTableCount")
        self.assertNotEqual(len(metrics), 0)
        metric = find_by_dimension(metrics, "cassandra_cluster", "cass_1")
        self.assertEquals(metric["type"], "GAUGE")
        metric = find_by_dimension(metrics, "cassandra_cluster", "cass_2")
        self.assertEquals(metric["type"], "GAUGE")

    @patch.object(Collector, 'flush')
    def test_should_create_type(self, publish_mock):
        self.collector.list_request = list_request
        def se(url):
            return self.getFixture("metrics.json")

        patch_urlopen = patch('urllib2.urlopen', Mock(side_effect=se))

        with patch_urlopen:
            self.collector.collect()
        self.assertEquals(len(self.collector.payload), 3827)

        metrics = find_metric(self.collector.payload, "org.apache.cassandra.metrics.ColumnFamily.CoordinatorReadLatency.count")
        self.assertNotEqual(len(metrics), 0)
        metric = find_by_dimension(metrics, "keyspace", "OpsCenter")
        self.assertEquals(metric["type"], "CUMCOUNTER")

    @patch.object(Collector, 'flush')
    def test_mbean_blacklisting(self, publish_mock):
        def se(url):
            if url.find("org.apache.cassandra.metrics") > 0:
                return self.getFixture("metrics.json")
            elif url.find("list/org.apache.cassandra.db") > 0:
                return self.getFixture("cas_db.json")
            elif url.find("org.apache.cassandra.db:type=StorageService") > 0:
                return Exception('storage service should be blacklisted')
            elif url.find("list?ifModifiedSince") > 0:
                return self.getFixture("cas_list.json")
            else:
                return self.getFixture("storage_proc.json")
        patch_urlopen = patch('urllib2.urlopen', Mock(side_effect=se))
        self.collector.config['mbean_blacklist'] = [
            'org.apache.cassandra.db:type=StorageService'
        ]

        with patch_urlopen:
            self.collector.collect()
        metrics = find_metric(self.collector.payload, "org.apache.cassandra.db.StorageProxy.cascontentiontimeout")
        self.assertNotEqual(len(metrics), 0)
class TestCassandraJolokiaCollector(CollectorTestCase):

    def setUp(self):
        config = get_collector_config('CassandraJolokiaCollector', {})

        self.collector = CassandraJolokiaCollector(config, None)

    # Used for all the tests so the expected numbers are all the same.
    def fixture_a(self):
        values = [0] * 92
        values[30:56] = [3, 3, 1, 1, 8, 5, 6, 1, 6, 5, 3, 8, 9, 10, 7, 8, 7, 5,
                         5, 5, 3, 3, 2, 2, 2]
        return values

    def empty_fixture_values(self):
        return [0] * 91

    def expected_fixture_a_p(self, percentile_key):
        return {
            'p25': 192.0,
            'p50': 398.0,
            'p75': 824.0,
            'p95': 2050.0,
            'p99': 2952.0
        }[percentile_key]

    def test_import(self):
        self.assertTrue(CassandraJolokiaCollector)

    def test_should_compute_percentiles_accurately(self):
        ninety_offsets = self.collector.create_offsets(90)
        percentile_value = self.collector.compute_percentile(
            ninety_offsets, self.fixture_a(), 50)
        self.assertEqual(percentile_value, 398.0)

    def test_should_compute_percentiles_accurately_when_empty(self):
        ninety_offsets = self.collector.create_offsets(90)
        self.assertEqual(self.collector.compute_percentile(
            ninety_offsets, self.empty_fixture_values(), 50), 0.0)
        self.assertEqual(self.collector.compute_percentile(
            ninety_offsets, self.empty_fixture_values(), 95), 0.0)
        self.assertEqual(self.collector.compute_percentile(
            ninety_offsets, self.empty_fixture_values(), 99), 0.0)

    @patch.object(Collector, 'publish')
    def test_should_not_collect_non_histogram_attributes(self, publish_mock):
        self.collector.interpret_bean_with_list(
            'RecentReadLatencyMicros', self.fixture_a())
        self.assertPublishedMany(publish_mock, {})

    @patch.object(Collector, 'publish')
    def test_should_collect_metrics_histogram_attributes(self, publish_mock):
        self.collector.interpret_bean_with_list(
            'RecentReadLatencyHistogramMicros', self.fixture_a())
        self.assertPublishedMany(publish_mock, {
            'RecentReadLatencyHistogramMicros.p50':
            self.expected_fixture_a_p('p50'),
            'RecentReadLatencyHistogramMicros.p95':
            self.expected_fixture_a_p('p95'),
            'RecentReadLatencyHistogramMicros.p99':
            self.expected_fixture_a_p('p99')
        })

    @patch.object(Collector, 'publish')
    # db:columnfamily=HintsColumnFamily,keyspace=system,type=ColumnFamilies:
    def test_should_escape_histogram_attributes(self, publish_mock):
        test_bean = ','.join([
            'db:columnfamily=HintsColumnFamily',
            'keyspace=system',
            'type=ColumnFamilies:RecentReadLatencyHistogramMicros'
        ])
        self.collector.interpret_bean_with_list(test_bean, self.fixture_a())

        expected_base = '.'.join([
            'db.columnfamily_HintsColumnFamily',
            'keyspace_system',
            'type_ColumnFamilies',
            'RecentReadLatencyHistogramMicros'
        ])
        self.assertPublishedMany(publish_mock, {
            '.'.join([expected_base, 'p50']): self.expected_fixture_a_p('p50'),
            '.'.join([expected_base, 'p95']): self.expected_fixture_a_p('p95'),
            '.'.join([expected_base, 'p99']): self.expected_fixture_a_p('p99')
        })

    @patch.object(Collector, 'publish')
    def test_should_respect_percentiles_config(self, publish_mock):
        self.collector.update_config({
            'percentiles': ['25', '75']
        })
        self.collector.interpret_bean_with_list(
            'RecentReadLatencyHistogramMicros', self.fixture_a())
        self.assertPublishedMany(publish_mock, {
            'RecentReadLatencyHistogramMicros.p25':
            self.expected_fixture_a_p('p25'),
            'RecentReadLatencyHistogramMicros.p75':
            self.expected_fixture_a_p('p75'),
        })

    @patch.object(Collector, 'publish')
    def test_should_respect_histogram_regex_config(self, publish_mock):
        self.collector.update_config({
            'histogram_regex': '^WackyMetric'
        })
        self.collector.interpret_bean_with_list(
            'WackyMetricSeventeen', self.fixture_a())
        self.assertPublishedMany(publish_mock, {
            'WackyMetricSeventeen.p50':
            self.expected_fixture_a_p('p50'),
            'WackyMetricSeventeen.p95':
            self.expected_fixture_a_p('p95'),
            'WackyMetricSeventeen.p99':
            self.expected_fixture_a_p('p99')
        })
class TestCassandraJolokiaCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config('CassandraJolokiaCollector', {})

        self.collector = CassandraJolokiaCollector(config, None)

    def test_import(self):
        self.assertTrue(CassandraJolokiaCollector)

    @patch.object(Collector, 'flush')
    def test_should_create_dimension(self, publish_mock):
        self.collector.list_request = list_request

        def se(url):
            return self.getFixture("metrics.json")

        patch_urlopen = patch('urllib2.urlopen', Mock(side_effect=se))

        with patch_urlopen:
            self.collector.collect()
        self.assertEquals(len(self.collector.payload), 3827)

        metrics = find_metric(self.collector.payload, "org.apache.cassandra.metrics.ColumnFamily.LiveSSTableCount")
        self.assertNotEqual(len(metrics), 0)
        metric = find_by_dimension(metrics, "type", "compaction_history")
        self.assertEquals(metric["type"], "GAUGE")

        pending_task = find_metric(self.collector.payload,
                                   "org.apache.cassandra.metrics.CommitLog4.2.PendingTasks")
        self.assertNotEqual(len(pending_task), 0)

    @patch.object(Collector, 'flush')
    def test_should_create_type(self, publish_mock):
        self.collector.list_request = list_request
        def se(url):
            return self.getFixture("metrics.json")

        patch_urlopen = patch('urllib2.urlopen', Mock(side_effect=se))

        with patch_urlopen:
            self.collector.collect()
        self.assertEquals(len(self.collector.payload), 3827)

        metrics = find_metric(self.collector.payload, "org.apache.cassandra.metrics.ColumnFamily.CoordinatorReadLatency.count")
        self.assertNotEqual(len(metrics), 0)
        metric = find_by_dimension(metrics, "keyspace", "OpsCenter")
        self.assertEquals(metric["type"], "CUMCOUNTER")

    @patch.object(Collector, 'flush')
    def test_mbean_blacklisting(self, publish_mock):
        def se(url):
            if url.find("org.apache.cassandra.metrics") > 0:
                return self.getFixture("metrics.json")
            elif url.find("list/org.apache.cassandra.db") > 0:
                return self.getFixture("cas_db.json")
            elif url.find("org.apache.cassandra.db:type=StorageService") > 0:
                return Exception('storage service should be blacklisted')
            elif url.find("list?ifModifiedSince") > 0:
                return self.getFixture("cas_list.json")
            else:
                return self.getFixture("storage_proc.json")
        patch_urlopen = patch('urllib2.urlopen', Mock(side_effect=se))
        self.collector.config['mbean_blacklist'] = [
            'org.apache.cassandra.db:type=StorageService'
        ]

        with patch_urlopen:
            self.collector.collect()
        metrics = find_metric(self.collector.payload, "org.apache.cassandra.db.StorageProxy.cascontentiontimeout")
        self.assertNotEqual(len(metrics), 0)
Beispiel #8
0
class TestCassandraJolokiaCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config('CassandraJolokiaCollector', {})

        self.collector = CassandraJolokiaCollector(config, None)

    def test_import(self):
        self.assertTrue(CassandraJolokiaCollector)

    @patch.object(Collector, 'flush')
    def test_should_create_dimension(self, publish_mock):
        self.collector.list_request = list_request

        def se(url):
            return self.getFixture("metrics.json")

        patch_urlopen = patch('urllib2.urlopen', Mock(side_effect=se))

        with patch_urlopen:
            self.collector.collect()
        self.assertEquals(len(self.collector.payload), 3827)

        metrics = find_metric(
            self.collector.payload,
            "org.apache.cassandra.metrics.ColumnFamily.LiveSSTableCount")
        self.assertNotEqual(len(metrics), 0)
        metric = find_by_dimension(metrics, "type", "compaction_history")
        self.assertEquals(metric["type"], "GAUGE")

        pending_task = find_metric(
            self.collector.payload,
            "org.apache.cassandra.metrics.CommitLog4.2.PendingTasks")
        self.assertNotEqual(len(pending_task), 0)

    @patch.object(Collector, 'flush')
    def test_should_create_type(self, publish_mock):
        self.collector.list_request = list_request

        def se(url):
            return self.getFixture("metrics.json")

        patch_urlopen = patch('urllib2.urlopen', Mock(side_effect=se))

        with patch_urlopen:
            self.collector.collect()
        self.assertEquals(len(self.collector.payload), 3827)

        metrics = find_metric(
            self.collector.payload,
            "org.apache.cassandra.metrics.ColumnFamily.CoordinatorReadLatency.count"
        )
        self.assertNotEqual(len(metrics), 0)
        metric = find_by_dimension(metrics, "keyspace", "OpsCenter")
        self.assertEquals(metric["type"], "CUMCOUNTER")

    @patch.object(Collector, 'flush')
    def test_mbean_blacklisting(self, publish_mock):
        def se(url):
            if url.find("org.apache.cassandra.metrics") > 0:
                return self.getFixture("metrics.json")
            elif url.find("list/org.apache.cassandra.db") > 0:
                return self.getFixture("cas_db.json")
            elif url.find("org.apache.cassandra.db:type=StorageService") > 0:
                return Exception('storage service should be blacklisted')
            elif url.find("list?ifModifiedSince") > 0:
                return self.getFixture("cas_list.json")
            else:
                return self.getFixture("storage_proc.json")

        patch_urlopen = patch('urllib2.urlopen', Mock(side_effect=se))
        self.collector.config['mbean_blacklist'] = [
            'org.apache.cassandra.db:type=StorageService'
        ]

        with patch_urlopen:
            self.collector.collect()
        metrics = find_metric(
            self.collector.payload,
            "org.apache.cassandra.db.StorageProxy.cascontentiontimeout")
        self.assertNotEqual(len(metrics), 0)
class TestCassandraJolokiaCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config('CassandraJolokiaCollector', {})

        self.collector = CassandraJolokiaCollector(config, None)

    # Used for all the tests so the expected numbers are all the same.
    def fixture_values_a(self):
        return [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,3,1,1,8,5,6,1,6,5,3,8,9,10,7,8,7,5,5,5,3,3,2,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]

    def empty_fixture_values(self):
        return [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]

    def expected_percentiles_for_fixture_a(self, percentile_key):
        return {
            'p25': 192.0,
            'p50': 398.0,
            'p75': 824.0,
            'p95': 2050.0,
            'p99': 2952.0
        }[percentile_key]

    def test_import(self):
        self.assertTrue(CassandraJolokiaCollector)

    def test_should_compute_percentiles_accurately(self):
        ninety_offsets = self.collector.create_offsets(90)
        percentile_value = self.collector.compute_percentile(ninety_offsets, self.fixture_values_a(), 50)
        self.assertEqual(percentile_value, 398.0)

    def test_should_compute_percentiles_accurately_when_empty(self):
        ninety_offsets = self.collector.create_offsets(90)
        self.assertEqual(self.collector.compute_percentile(ninety_offsets, self.empty_fixture_values(), 50), 0.0)
        self.assertEqual(self.collector.compute_percentile(ninety_offsets, self.empty_fixture_values(), 95), 0.0)
        self.assertEqual(self.collector.compute_percentile(ninety_offsets, self.empty_fixture_values(), 99), 0.0)

    @patch.object(Collector, 'publish')
    def test_should_not_collect_non_histogram_attributes(self, publish_mock):
        self.collector.interpret_bean_with_list('RecentReadLatencyMicros', self.fixture_values_a())
        self.assertPublishedMany(publish_mock, {})

    @patch.object(Collector, 'publish')
    def test_should_collect_metrics_histogram_attributes(self, publish_mock):
        self.collector.interpret_bean_with_list('RecentReadLatencyHistogramMicros', self.fixture_values_a())
        self.assertPublishedMany(publish_mock, {
            'RecentReadLatencyHistogramMicros.p50': self.expected_percentiles_for_fixture_a('p50'),
            'RecentReadLatencyHistogramMicros.p95': self.expected_percentiles_for_fixture_a('p95'),
            'RecentReadLatencyHistogramMicros.p99': self.expected_percentiles_for_fixture_a('p99')
        })

    @patch.object(Collector, 'publish')
    def test_should_respect_percentiles_config(self, publish_mock):
        self.collector.update_config({
            'percentiles': '25,75'
        })
        self.collector.interpret_bean_with_list('RecentReadLatencyHistogramMicros', self.fixture_values_a())
        self.assertPublishedMany(publish_mock, {
            'RecentReadLatencyHistogramMicros.p25': self.expected_percentiles_for_fixture_a('p25'),
            'RecentReadLatencyHistogramMicros.p75': self.expected_percentiles_for_fixture_a('p75'),
        })

    @patch.object(Collector, 'publish')
    def test_should_respect_histogram_regex_config(self, publish_mock):
        self.collector.update_config({
            'histogram_regex': '^WackyMetric'
        })
        self.collector.interpret_bean_with_list('WackyMetricSeventeen', self.fixture_values_a())
        self.assertPublishedMany(publish_mock, {
            'WackyMetricSeventeen.p50': self.expected_percentiles_for_fixture_a('p50'),
            'WackyMetricSeventeen.p95': self.expected_percentiles_for_fixture_a('p95'),
            'WackyMetricSeventeen.p99': self.expected_percentiles_for_fixture_a('p99')
        })
class TestCassandraJolokiaCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config('CassandraJolokiaCollector', {})

        self.collector = CassandraJolokiaCollector(config, None)

    def test_import(self):
        self.assertTrue(CassandraJolokiaCollector)

    @patch.object(Collector, 'flush')
    def test_should_create_dimension(self, publish_mock):
        self.collector.list_request = list_request

        def se(url):
            return self.getFixture("metrics.json")

        patch_urlopen = patch('urllib2.urlopen', Mock(side_effect=se))

        with patch_urlopen:
            self.collector.collect()
        self.assertEquals(len(self.collector.payload), 3827)

        metrics = find_metric(
            self.collector.payload,
            "org.apache.cassandra.metrics.ColumnFamily.LiveSSTableCount")
        self.assertNotEqual(len(metrics), 0)
        metric = find_by_dimension(metrics, "type", "compaction_history")
        self.assertEquals(metric["type"], "GAUGE")

        pending_task = find_metric(
            self.collector.payload,
            "org.apache.cassandra.metrics.CommitLog4.2.PendingTasks")
        self.assertNotEqual(len(pending_task), 0)

    @patch.object(Collector, 'flush')
    def test_should_create_custom_dimension(self, flush_mock):
        dims = {'localhost': {'dim1': 'v1', 'dim2': 'v2'}}
        self.collector.list_request = list_request
        self.collector.dimension_reader = TestDimensionReader(dims)

        def se(url):
            return self.getFixture("metrics.json")

        patch_urlopen = patch('urllib2.urlopen', Mock(side_effect=se))
        patch_urlopen.start()
        self.collector.collect()
        patch_urlopen.stop()
        self.collector.dimension_readers = CompositeDimensionReader()

        expected_dims = dims['localhost']
        for payload in self.collector.payload:
            actual_dims = payload['dimensions']
            self.assertTrue(dimensions_contain(actual_dims, expected_dims))

    @patch.object(Collector, 'flush')
    def test_should_have_cassandra_instance_dimension_in_kubernetes_mode(
            self, publish_mock):
        self.collector.config.update({
            'mode': 'kubernetes',
            'spec': {
                'dimensions': {
                    'kubernetes': {
                        'cassandra_instance': {
                            'paasta.yelp.com/instance': '.*'
                        }
                    }
                },
                'label_selector': {
                    "yelp.com/paasta_service": "cassandra-operator"
                }
            }
        })
        self.collector.list_request = list_request
        self.collector.process_config()

        def se(url):
            return self.getFixture("metrics.json")

        def kubelet_se():
            return json.loads(self.getFixture('pods.json').getvalue()), None

        with patch('urllib2.urlopen', Mock(side_effect=se)):
            with patch("kubernetes.Kubelet.list_pods",
                       Mock(side_effect=kubelet_se)):
                self.collector.collect()

        metrics = find_metric(
            self.collector.payload,
            "org.apache.cassandra.metrics.ColumnFamily.LiveSSTableCount")
        self.assertNotEqual(len(metrics), 0)
        metric = find_by_dimension(metrics, "cassandra_instance", "main")
        self.assertEquals(metric["type"], "GAUGE")
        metric = find_by_dimension(metrics, "cassandra_instance", "main")
        self.assertEquals(metric["type"], "GAUGE")

    @patch.object(Collector, 'flush')
    def test_should_have_cassandra_instance_dimension_in_nerve_mode(
            self, publish_mock):
        self.collector.config.update({
            'mode': 'nerve',
            'spec': {
                'dimensions': {
                    'nerve': {
                        'cassandra_cluster': '^cassandra_([\\w_-]+).',
                        'cassandra_instance':
                        '^cassandra_[\\w_-]+.([\\w_-]+).',
                    }
                },
                'host_id_regex': '^cassandra_[\\w_-]+'
            }
        })
        self.collector.list_request = list_request
        self.collector.process_config()

        def se(url):
            return self.getFixture("metrics.json")

        def nerve_se():
            return json.loads(self.getFixture('nerve.json').getvalue()), None

        with patch('urllib2.urlopen', Mock(side_effect=se)):
            with patch("nerve.read", Mock(side_effect=nerve_se)):
                self.collector.collect()

        metrics = find_metric(
            self.collector.payload,
            "org.apache.cassandra.metrics.ColumnFamily.LiveSSTableCount")
        self.assertNotEqual(len(metrics), 0)
        metric = find_by_dimension(metrics, "cassandra_cluster", "dev")
        self.assertEquals(metric["type"], "GAUGE")
        metric = find_by_dimension(metrics, "cassandra_instance", "main")
        self.assertEquals(metric["type"], "GAUGE")

    @patch.object(Collector, 'flush')
    def test_should_create_type(self, publish_mock):
        self.collector.list_request = list_request

        def se(url):
            return self.getFixture("metrics.json")

        patch_urlopen = patch('urllib2.urlopen', Mock(side_effect=se))

        with patch_urlopen:
            self.collector.collect()
        self.assertEquals(len(self.collector.payload), 3827)

        metrics = find_metric(
            self.collector.payload,
            "org.apache.cassandra.metrics.ColumnFamily.CoordinatorReadLatency.count"
        )
        self.assertNotEqual(len(metrics), 0)
        metric = find_by_dimension(metrics, "keyspace", "OpsCenter")
        self.assertEquals(metric["type"], "CUMCOUNTER")

    @patch.object(Collector, 'flush')
    def test_mbean_blacklisting(self, publish_mock):
        def se(url):
            if url.find("org.apache.cassandra.metrics") > 0:
                return self.getFixture("metrics.json")
            elif url.find("list/org.apache.cassandra.db") > 0:
                return self.getFixture("cas_db.json")
            elif url.find("org.apache.cassandra.db:type=StorageService") > 0:
                return Exception('storage service should be blacklisted')
            elif url.find("list?ifModifiedSince") > 0:
                return self.getFixture("cas_list.json")
            else:
                return self.getFixture("storage_proc.json")

        patch_urlopen = patch('urllib2.urlopen', Mock(side_effect=se))
        self.collector.config['mbean_blacklist'] = [
            'org.apache.cassandra.db:type=StorageService'
        ]

        with patch_urlopen:
            self.collector.collect()
        metrics = find_metric(
            self.collector.payload,
            "org.apache.cassandra.db.StorageProxy.cascontentiontimeout")
        self.assertNotEqual(len(metrics), 0)