Exemplo n.º 1
0
class TestRabbitMQCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config(
            "RabbitMQCollector", {"host": "localhost:55672", "user": "******", "password": "******"}
        )
        self.collector = RabbitMQCollector(config, None)

    @patch("pyrabbit.api.Client")
    @patch.object(Collector, "publish")
    def test_should_publish_nested_keys(self, publish_mock, client_mock):
        client = Mock()
        queue_data = {"more_keys": {"nested_key": 1}, "key": 2, "string": "str", "name": "test_queue"}
        overview_data = {"more_keys": {"nested_key": 3}, "key": 4, "string": "string"}
        client_mock.return_value = client
        client.get_queues.return_value = [queue_data]
        client.get_overview.return_value = overview_data

        self.collector.collect()

        client.get_queues.assert_called_once_with()
        client.get_overview.assert_called_once_with()
        self.assertPublishedMany(
            publish_mock,
            {
                "queues.test_queue.more_keys.nested_key": 1,
                "queues.test_queue.key": 2,
                "more_keys.nested_key": 3,
                "key": 4,
            },
        )
Exemplo n.º 2
0
 def setUp(self):
     config = get_collector_config('RabbitMQCollector', {
         'host': 'localhost:55672',
         'user': '******',
         'password': '******'
     })
     self.collector = RabbitMQCollector(config, None)
Exemplo n.º 3
0
class TestRabbitMQCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config('RabbitMQCollector', {
            'host': 'localhost:55672',
            'user': '******',
            'password': '******'
        })
        self.collector = RabbitMQCollector(config, None)

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

    @run_only_if_pyrabbit_is_available
    @patch('pyrabbit.api.Client')
    @patch.object(Collector, 'publish')
    def test_should_publish_nested_keys(self, publish_mock, client_mock):
        client = Mock()
        vhost_data = [
            {
                'name': 'localhost'
            },
        ]
        queue_data = {
            'more_keys': {
                'nested_key': 1
            },
            'key': 2,
            'string': 'str',
            'name': 'test_queue'
        }
        overview_data = {
            'more_keys': {
                'nested_key': 3
            },
            'key': 4,
            'string': 'string',
        }
        client_mock.return_value = client
        client.get_all_vhosts.return_value = vhost_data
        client.get_queues.return_value = [queue_data]
        client.get_overview.return_value = overview_data

        self.collector.collect()

        client.get_all_vhosts.assert_called_once_with()
        client.get_queues.assert_called_once_with(vhost='localhost')
        client.get_overview.assert_called_once_with()
        metrics = {
            'queues.test_queue.more_keys.nested_key': 1,
            'queues.test_queue.key': 2,
            'more_keys.nested_key': 3,
            'key': 4
        }

        self.setDocExample(collector=self.collector.__class__.__name__,
                           metrics=metrics,
                           defaultpath=self.collector.config['path'])
        self.assertPublishedMany(publish_mock, metrics)
Exemplo n.º 4
0
 def setUp(self):
     config = get_collector_config('RabbitMQCollector', {
         'host': 'localhost:55672',
         'user': '******',
         'password': '******',
         'queues_ignored': '^ignored',
         'cluster': True,
     })
     self.collector = RabbitMQCollector(config, None)
Exemplo n.º 5
0
class TestRabbitMQCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config('RabbitMQCollector', {
            'host': 'localhost:55672',
            'user': '******',
            'password': '******'
        })
        self.collector = RabbitMQCollector(config, None)

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

    @run_only_if_pyrabbit_is_available
    @patch('pyrabbit.api.Client')
    @patch.object(Collector, 'publish')
    def test_should_publish_nested_keys(self, publish_mock, client_mock):
        client = Mock()
        vhost_data = [
            {'name': 'localhost'},
        ]
        queue_data = {
            'more_keys': {'nested_key': 1},
            'key': 2,
            'string': 'str',
            'name': 'test_queue'
        }
        overview_data = {
            'more_keys': {'nested_key': 3},
            'key': 4,
            'string': 'string',
        }
        client_mock.return_value = client
        client.get_all_vhosts.return_value = vhost_data
        client.get_queues.return_value = [queue_data]
        client.get_overview.return_value = overview_data

        self.collector.collect()

        client.get_all_vhosts.assert_called_once_with()
        client.get_queues.assert_called_once_with(vhost='localhost')
        client.get_overview.assert_called_once_with()
        metrics = {
            'queues.test_queue.more_keys.nested_key': 1,
            'queues.test_queue.key': 2,
            'more_keys.nested_key': 3,
            'key': 4
        }

        self.setDocExample(collector=self.collector.__class__.__name__,
                           metrics=metrics,
                           defaultpath=self.collector.config['path'])
        self.assertPublishedMany(publish_mock, metrics)
Exemplo n.º 6
0
 def setUp(self):
     config = get_collector_config('RabbitMQCollector', {
         'host': 'localhost:55672',
         'user': '******',
         'password': '******'
     })
     self.collector = RabbitMQCollector(config, None)
Exemplo n.º 7
0
 def setUp(self):
     config = get_collector_config('RabbitMQCollector', {
         'host': 'localhost:55672',
         'user': '******',
         'password': '******',
         'queues_ignored': '^ignored',
         'cluster': True,
     })
     self.collector = RabbitMQCollector(config, None)
Exemplo n.º 8
0
class TestRabbitMQCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config('RabbitMQCollector', {
            'host': 'localhost:55672',
            'user': '******',
            'password': '******'
        })
        self.collector = RabbitMQCollector(config, None)

    @patch('pyrabbit.api.Client')
    @patch.object(Collector, 'publish')
    def test_should_publish_nested_keys(self, publish_mock, client_mock):
        client = Mock()
        queue_data = {
            'more_keys': {
                'nested_key': 1
            },
            'key': 2,
            'string': 'str',
            'name': 'test_queue'
        }
        overview_data = {
            'more_keys': {
                'nested_key': 3
            },
            'key': 4,
            'string': 'string',
        }
        client_mock.return_value = client
        client.get_queues.return_value = [queue_data]
        client.get_overview.return_value = overview_data

        self.collector.collect()

        client.get_queues.assert_called_once_with()
        client.get_overview.assert_called_once_with()
        self.assertPublishedMany(
            publish_mock, {
                'queues.test_queue.more_keys.nested_key': 1,
                'queues.test_queue.key': 2,
                'more_keys.nested_key': 3,
                'key': 4
            })
class TestRabbitMQCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config(
            'RabbitMQCollector', {
                'host': 'localhost:55672',
                'user': '******',
                'password': '******',
                'queues_ignored': [
                    '^ignored',
                ],
                'cluster': True,
            })
        self.collector = RabbitMQCollector(config, None)

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

    def http_mock(self, path, method):
        overview_data = {
            'node': 'rabbit@localhost',
        }
        node_health = {
            'fd_used': 1,
            'fd_total': 2,
            'mem_used': 2,
            'mem_limit': 4,
            'sockets_used': 1,
            'sockets_total': 2,
            'disk_free_limit': 1,
            'disk_free': 1,
            'proc_used': 1,
            'proc_total': 1,
            'partitions': [],
        }
        nodes = [1, 2, 3]
        if path == 'overview':
            return overview_data
        elif path == 'nodes/rabbit@localhost':
            return node_health
        elif path == 'nodes':
            return nodes

    @run_only_if_pyrabbit_is_available
    @patch('pyrabbit.api.Client')
    @patch('pyrabbit.http.HTTPClient')
    @patch.object(Collector, 'publish')
    def test_should_publish_nested_keys(self, publish_mock, httpclient,
                                        client_mock):
        client = Mock()
        queue_data = [
            {
                'more_keys': {
                    'nested_key': 1
                },
                'key': 2,
                'string': 'str',
                'name': 'test_queue'
            },
            {
                'name': 'ignored',
                'more_keys': {
                    'nested_key': 1
                },
                'key': 2,
                'string': 'str',
            },
        ]
        overview_data = {
            'more_keys': {
                'nested_key': 3
            },
            'key': 4,
            'string': 'string',
        }
        client_mock.return_value = client
        client.get_queues.return_value = [queue_data]
        client.get_overview.return_value = overview_data

        httpclient = Mock()
        httpclient.do_call.return_value = self.http_mock

        self.collector.collect()

        client.get_queues.assert_called_once_with(None)
        client.get_overview.assert_called_once_with()
        httpclient.do_call.assert_called_once_with('nodes', 'GET')

        metrics = {
            'queues.test_queue.more_keys.nested_key': 1,
            'queues.test_queue.key': 2,
            'more_keys.nested_key': 3,
            'key': 4,
            'health.fd_used': 1,
            'health.fd_total': 2,
            'health.mem_used': 2,
            'health.mem_limit': 4,
            'health.sockets_used': 1,
            'health.sockets_total': 2,
            'health.disk_free_limit': 1,
            'health.disk_free': 1,
            'health.proc_used': 1,
            'health.proc_total': 1,
            'cluster.partitions': 0,
            'cluster.nodes': 3
        }

        self.setDocExample(collector=self.collector.__class__.__name__,
                           metrics=metrics,
                           defaultpath=self.collector.config['path'])
        self.assertPublishedMany(publish_mock, metrics)
Exemplo n.º 10
0
class TestRabbitMQCollector(CollectorTestCase):

    def setUp(self):
        config = get_collector_config('RabbitMQCollector', {
            'host': 'localhost:55672',
            'user': '******',
            'password': '******',
            'queues_ignored': '^ignored',
            'cluster': True,
        })
        self.collector = RabbitMQCollector(config, None)

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

    @patch('rabbitmq.RabbitMQClient')
    @patch.object(Collector, 'publish')
    def test_should_publish_nested_keys(self, publish_mock, client_mock):
        client = Mock()
        queue_data = [{
            'more_keys': {'nested_key': 1},
            'key': 2,
            'string': 'str',
            'name': 'test_queue'
        }, {
            'name': 'ignored',
            'more_keys': {'nested_key': 1},
            'key': 2,
            'string': 'str',
        }]
        overview_data = {
            'node': 'rabbit@localhost',
            'more_keys': {'nested_key': 3},
            'key': 4,
            'string': 'string',
        }
        node_health = {
            'fd_used': 1,
            'fd_total': 2,
            'mem_used': 2,
            'mem_limit': 4,
            'sockets_used': 1,
            'sockets_total': 2,
            'disk_free_limit': 1,
            'disk_free': 1,
            'proc_used': 1,
            'proc_total': 1,
            'partitions': [],
        }
        client_mock.return_value = client
        client.get_queues.return_value = queue_data
        client.get_overview.return_value = overview_data
        client.get_nodes.return_value = [1, 2, 3]
        client.get_node.return_value = node_health

        self.collector.collect()

        client.get_queues.assert_called_once_with(None)
        client.get_nodes.assert_called_once_with()
        client.get_node.assert_called_once_with('rabbit@localhost')

        metrics = {
            'queues.test_queue.more_keys.nested_key': 1,
            'queues.test_queue.key': 2,
            'more_keys.nested_key': 3,
            'key': 4,
            'health.fd_used': 1,
            'health.fd_total': 2,
            'health.mem_used': 2,
            'health.mem_limit': 4,
            'health.sockets_used': 1,
            'health.sockets_total': 2,
            'health.disk_free_limit': 1,
            'health.disk_free': 1,
            'health.proc_used': 1,
            'health.proc_total': 1,
            'cluster.partitions': 0,
            'cluster.nodes': 3
        }

        self.setDocExample(collector=self.collector.__class__.__name__,
                           metrics=metrics,
                           defaultpath=self.collector.config['path'])
        self.assertPublishedMany(publish_mock, metrics)

    @patch('rabbitmq.RabbitMQClient')
    @patch.object(Collector, 'publish')
    def test_opt_should_replace_dots(self, publish_mock, client_mock):
        self.collector.config['replace_dot'] = '_'
        client = Mock()
        queue_data = [{
            'more_keys': {'nested_key': 1},
            'key': 2,
            'string': 'str',
            'name': 'test.queue'
        }, {
            'name': 'ignored',
            'more_keys': {'nested_key': 1},
            'key': 2,
            'string': 'str',
        }]
        overview_data = {
            'node': 'rabbit@localhost',
            'more_keys': {'nested_key': 3},
            'key': 4,
            'string': 'string',
        }
        node_health = {
            'fd_used': 1,
            'fd_total': 2,
            'mem_used': 2,
            'mem_limit': 4,
            'sockets_used': 1,
            'sockets_total': 2,
            'disk_free_limit': 1,
            'disk_free': 1,
            'proc_used': 1,
            'proc_total': 1,
            'partitions': [],
        }
        client_mock.return_value = client
        client.get_queues.return_value = queue_data
        client.get_overview.return_value = overview_data
        client.get_nodes.return_value = [1, 2, 3]
        client.get_node.return_value = node_health

        self.collector.collect()

        metrics = {
            'queues.test_queue.more_keys.nested_key': 1,
            'queues.test_queue.key': 2,
            'more_keys.nested_key': 3,
            'key': 4,
            'health.fd_used': 1,
            'health.fd_total': 2,
            'health.mem_used': 2,
            'health.mem_limit': 4,
            'health.sockets_used': 1,
            'health.sockets_total': 2,
            'health.disk_free_limit': 1,
            'health.disk_free': 1,
            'health.proc_used': 1,
            'health.proc_total': 1,
            'cluster.partitions': 0,
            'cluster.nodes': 3
        }

        self.setDocExample(collector=self.collector.__class__.__name__,
                           metrics=metrics,
                           defaultpath=self.collector.config['path'])
        self.assertPublishedMany(publish_mock, metrics)

        self.collector.config['replace_dot'] = False
Exemplo n.º 11
0
class TestRabbitMQCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config('RabbitMQCollector', {
            'host': 'localhost:55672',
            'user': '******',
            'password': '******',
            'queues_ignored': ['^ignored', ],
            'cluster': True,
        })
        self.collector = RabbitMQCollector(config, None)

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

    def http_mock(self, path, method):
        overview_data = {
            'node': 'rabbit@localhost',
        }
        node_health = {
            'fd_used': 1,
            'fd_total': 2,
            'mem_used': 2,
            'mem_limit': 4,
            'sockets_used': 1,
            'sockets_total': 2,
            'disk_free_limit': 1,
            'disk_free': 1,
            'proc_used': 1,
            'proc_total': 1,
            'partitions': [],
        }
        nodes = [1, 2, 3]
        if path == 'overview':
            return overview_data
        elif path == 'nodes/rabbit@localhost':
            return node_health
        elif path == 'nodes':
            return nodes

    @run_only_if_pyrabbit_is_available
    @patch('pyrabbit.api.Client')
    @patch('pyrabbit.http.HTTPClient')
    @patch.object(Collector, 'publish')
    def test_should_publish_nested_keys(self, publish_mock, httpclient,
                                        client_mock):
        client = Mock()
        queue_data = [{
            'more_keys': {'nested_key': 1},
            'key': 2,
            'string': 'str',
            'name': 'test_queue'
            },
            {
                'name': 'ignored',
                'more_keys': {'nested_key': 1},
                'key': 2,
                'string': 'str',
            },
        ]
        overview_data = {
            'more_keys': {'nested_key': 3},
            'key': 4,
            'string': 'string',
        }
        client_mock.return_value = client
        client.get_queues.return_value = [queue_data]
        client.get_overview.return_value = overview_data

        httpclient = Mock()
        httpclient.do_call.return_value = self.http_mock

        self.collector.collect()

        client.get_queues.assert_called_once_with(None)
        client.get_overview.assert_called_once_with()
        httpclient.do_call.assert_called_once_with('nodes', 'GET')

        metrics = {
            'queues.test_queue.more_keys.nested_key': 1,
            'queues.test_queue.key': 2,
            'more_keys.nested_key': 3,
            'key': 4,
            'health.fd_used': 1,
            'health.fd_total': 2,
            'health.mem_used': 2,
            'health.mem_limit': 4,
            'health.sockets_used': 1,
            'health.sockets_total': 2,
            'health.disk_free_limit': 1,
            'health.disk_free': 1,
            'health.proc_used': 1,
            'health.proc_total': 1,
            'cluster.partitions': 0,
            'cluster.nodes': 3
        }

        self.setDocExample(collector=self.collector.__class__.__name__,
                           metrics=metrics,
                           defaultpath=self.collector.config['path'])
        self.assertPublishedMany(publish_mock, metrics)
Exemplo n.º 12
0
class TestRabbitMQCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config(
            'RabbitMQCollector', {
                'host': 'localhost:55672',
                'user': '******',
                'password': '******',
                'queues_ignored': '^ignored',
                'cluster': True,
            })
        self.collector = RabbitMQCollector(config, None)

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

    @patch('rabbitmq.RabbitMQClient')
    @patch.object(Collector, 'publish')
    def test_should_publish_nested_keys(self, publish_mock, client_mock):
        client = Mock()
        queue_data = [{
            'more_keys': {
                'nested_key': 1
            },
            'key': 2,
            'string': 'str',
            'name': 'test_queue'
        }, {
            'name': 'ignored',
            'more_keys': {
                'nested_key': 1
            },
            'key': 2,
            'string': 'str',
        }]
        overview_data = {
            'node': 'rabbit@localhost',
            'more_keys': {
                'nested_key': 3
            },
            'key': 4,
            'string': 'string',
        }
        node_health = {
            'fd_used': 1,
            'fd_total': 2,
            'mem_used': 2,
            'mem_limit': 4,
            'sockets_used': 1,
            'sockets_total': 2,
            'disk_free_limit': 1,
            'disk_free': 1,
            'proc_used': 1,
            'proc_total': 1,
            'partitions': [],
        }
        client_mock.return_value = client
        client.get_queues.return_value = queue_data
        client.get_overview.return_value = overview_data
        client.get_nodes.return_value = [1, 2, 3]
        client.get_node.return_value = node_health
        client.get_vhost_names.return_value = ['/']

        self.collector.collect()

        client.get_queues.assert_called_once_with('/')
        client.get_queue.assert_not_called()
        client.get_nodes.assert_called_once_with()
        client.get_node.assert_called_once_with('rabbit@localhost')
        client.get_vhost_names.assert_called_once_with()

        metrics = {
            'queues.test_queue.more_keys.nested_key': 1,
            'queues.test_queue.key': 2,
            'more_keys.nested_key': 3,
            'key': 4,
            'health.fd_used': 1,
            'health.fd_total': 2,
            'health.mem_used': 2,
            'health.mem_limit': 4,
            'health.sockets_used': 1,
            'health.sockets_total': 2,
            'health.disk_free_limit': 1,
            'health.disk_free': 1,
            'health.proc_used': 1,
            'health.proc_total': 1,
            'cluster.partitions': 0,
            'cluster.nodes': 3
        }

        self.setDocExample(collector=self.collector.__class__.__name__,
                           metrics=metrics,
                           defaultpath=self.collector.config['path'])
        self.assertPublishedMany(publish_mock, metrics)

    @patch('rabbitmq.RabbitMQClient')
    @patch.object(Collector, 'publish')
    def test_opt_should_replace_dots(self, publish_mock, client_mock):
        self.collector.config['replace_dot'] = '_'
        client = Mock()
        queue_data = [{
            'more_keys': {
                'nested_key': 1
            },
            'key': 2,
            'string': 'str',
            'name': 'test.queue'
        }, {
            'name': 'ignored',
            'more_keys': {
                'nested_key': 1
            },
            'key': 2,
            'string': 'str',
        }]
        overview_data = {
            'node': 'rabbit@localhost',
            'more_keys': {
                'nested_key': 3
            },
            'key': 4,
            'string': 'string',
        }
        node_health = {
            'fd_used': 1,
            'fd_total': 2,
            'mem_used': 2,
            'mem_limit': 4,
            'sockets_used': 1,
            'sockets_total': 2,
            'disk_free_limit': 1,
            'disk_free': 1,
            'proc_used': 1,
            'proc_total': 1,
            'partitions': [],
        }
        client_mock.return_value = client
        client.get_queues.return_value = queue_data
        client.get_overview.return_value = overview_data
        client.get_nodes.return_value = [1, 2, 3]
        client.get_node.return_value = node_health
        client.get_vhost_names.return_value = ['/']

        self.collector.collect()

        metrics = {
            'queues.test_queue.more_keys.nested_key': 1,
            'queues.test_queue.key': 2,
            'more_keys.nested_key': 3,
            'key': 4,
            'health.fd_used': 1,
            'health.fd_total': 2,
            'health.mem_used': 2,
            'health.mem_limit': 4,
            'health.sockets_used': 1,
            'health.sockets_total': 2,
            'health.disk_free_limit': 1,
            'health.disk_free': 1,
            'health.proc_used': 1,
            'health.proc_total': 1,
            'cluster.partitions': 0,
            'cluster.nodes': 3
        }

        self.setDocExample(collector=self.collector.__class__.__name__,
                           metrics=metrics,
                           defaultpath=self.collector.config['path'])
        self.assertPublishedMany(publish_mock, metrics)

        self.collector.config['replace_dot'] = False

    @patch('rabbitmq.RabbitMQClient')
    @patch.object(Collector, 'publish')
    def test_opt_should_replace_slashes(self, publish_mock, client_mock):
        self.collector.config['replace_slash'] = '_'
        client = Mock()
        queue_data = [{
            'more_keys': {
                'nested_key': 1
            },
            'key': 2,
            'string': 'str',
            'name': 'test/queue'
        }, {
            'name': 'ignored',
            'more_keys': {
                'nested_key': 1
            },
            'key': 2,
            'string': 'str',
        }]
        overview_data = {
            'node': 'rabbit@localhost',
            'more_keys': {
                'nested_key': 3
            },
            'key': 4,
            'string': 'string',
        }
        node_health = {
            'fd_used': 1,
            'fd_total': 2,
            'mem_used': 2,
            'mem_limit': 4,
            'sockets_used': 1,
            'sockets_total': 2,
            'disk_free_limit': 1,
            'disk_free': 1,
            'proc_used': 1,
            'proc_total': 1,
            'partitions': [],
        }
        client_mock.return_value = client
        client.get_queues.return_value = queue_data
        client.get_overview.return_value = overview_data
        client.get_nodes.return_value = [1, 2, 3]
        client.get_node.return_value = node_health
        client.get_vhost_names.return_value = ['/']

        self.collector.collect()

        metrics = {
            'queues.test_queue.more_keys.nested_key': 1,
            'queues.test_queue.key': 2,
            'more_keys.nested_key': 3,
            'key': 4,
            'health.fd_used': 1,
            'health.fd_total': 2,
            'health.mem_used': 2,
            'health.mem_limit': 4,
            'health.sockets_used': 1,
            'health.sockets_total': 2,
            'health.disk_free_limit': 1,
            'health.disk_free': 1,
            'health.proc_used': 1,
            'health.proc_total': 1,
            'cluster.partitions': 0,
            'cluster.nodes': 3
        }

        self.setDocExample(collector=self.collector.__class__.__name__,
                           metrics=metrics,
                           defaultpath=self.collector.config['path'])
        self.assertPublishedMany(publish_mock, metrics)

        self.collector.config['replace_slash'] = False

    @patch('rabbitmq.RabbitMQClient')
    @patch.object(Collector, 'publish')
    def test_opt_individual_queues(self, publish_mock, client_mock):
        self.collector.config['query_individual_queues'] = True
        self.collector.config['queues'] = 'queue1 queue2 queue3 queue4'
        client = Mock()
        queue_data = {
            'vhost1': {
                'queue1': {
                    'name': 'queue1',
                    'key': 1,
                    'string': 'str',
                },
                'queue2': {
                    'name': 'queue2',
                    'key': 2,
                    'string': 'str',
                },
                'ignored': {
                    'name': 'ignored',
                    'key': 3,
                    'string': 'str',
                },
            },
            'vhost2': {
                'queue3': {
                    'name': 'queue3',
                    'key': 4,
                    'string': 'str',
                },
                'queue4': {
                    'name': 'queue4',
                    'key': 5,
                    'string': 'str',
                },
                'ignored': {
                    'name': 'ignored',
                    'key': 6,
                    'string': 'str',
                }
            }
        }
        overview_data = {
            'node': 'rabbit@localhost',
        }
        node_health = {
            'fd_used': 1,
            'fd_total': 2,
            'mem_used': 2,
            'mem_limit': 4,
            'sockets_used': 1,
            'sockets_total': 2,
            'disk_free_limit': 1,
            'disk_free': 1,
            'proc_used': 1,
            'proc_total': 1,
            'partitions': [],
        }
        client_mock.return_value = client
        client.get_queue.side_effect = lambda v, q: queue_data.get(v).get(q)
        client.get_overview.return_value = overview_data
        client.get_nodes.return_value = [1, 2, 3]
        client.get_node.return_value = node_health
        client.get_vhost_names.return_value = ['vhost1', 'vhost2']

        self.collector.collect()

        client.get_queues.assert_not_called()
        client.get_nodes.assert_called_once_with()
        client.get_node.assert_called_once_with('rabbit@localhost')
        client.get_vhost_names.assert_called_once_with()
        client.get_queue.assert_has_calls([
            call('vhost1', 'queue1'),
            call('vhost1', 'queue2'),
            call('vhost2', 'queue3'),
            call('vhost2', 'queue4'),
        ],
                                          any_order=True)

        metrics = {
            'queues.queue1.key': 1,
            'queues.queue2.key': 2,
            'queues.queue3.key': 4,
            'queues.queue4.key': 5,
            'health.fd_used': 1,
            'health.fd_total': 2,
            'health.mem_used': 2,
            'health.mem_limit': 4,
            'health.sockets_used': 1,
            'health.sockets_total': 2,
            'health.disk_free_limit': 1,
            'health.disk_free': 1,
            'health.proc_used': 1,
            'health.proc_total': 1,
            'cluster.partitions': 0,
            'cluster.nodes': 3
        }

        self.assertPublishedMany(publish_mock, metrics)

        self.collector.config['query_individual_queues'] = False
        self.collector.config['queues'] = ''

    @patch('rabbitmq.RabbitMQClient')
    @patch.object(Collector, 'publish')
    def test_opt_vhost_individual_queues(self, publish_mock, client_mock):
        self.collector.config['query_individual_queues'] = True
        self.collector.config['vhosts'] = {
            'vhost1': 'queue1 queue2',
            'vhost2': 'queue3 queue4'
        }
        client = Mock()
        queue_data = {
            'vhost1': {
                'queue1': {
                    'name': 'queue1',
                    'key': 1,
                    'string': 'str',
                },
                'queue2': {
                    'name': 'queue2',
                    'key': 2,
                    'string': 'str',
                },
                'ignored': {
                    'name': 'ignored',
                    'key': 3,
                    'string': 'str',
                },
            },
            'vhost2': {
                'queue3': {
                    'name': 'queue3',
                    'key': 4,
                    'string': 'str',
                },
                'queue4': {
                    'name': 'queue4',
                    'key': 5,
                    'string': 'str',
                },
                'ignored': {
                    'name': 'ignored',
                    'key': 6,
                    'string': 'str',
                }
            }
        }
        overview_data = {
            'node': 'rabbit@localhost',
        }
        node_health = {
            'fd_used': 1,
            'fd_total': 2,
            'mem_used': 2,
            'mem_limit': 4,
            'sockets_used': 1,
            'sockets_total': 2,
            'disk_free_limit': 1,
            'disk_free': 1,
            'proc_used': 1,
            'proc_total': 1,
            'partitions': [],
        }
        client_mock.return_value = client
        client.get_queue.side_effect = lambda v, q: queue_data.get(v).get(q)
        client.get_overview.return_value = overview_data
        client.get_nodes.return_value = [1, 2, 3]
        client.get_node.return_value = node_health
        client.get_vhost_names.return_value = ['vhost1', 'vhost2']

        self.collector.collect()

        client.get_queues.assert_not_called()
        client.get_nodes.assert_called_once_with()
        client.get_node.assert_called_once_with('rabbit@localhost')
        client.get_vhost_names.assert_called_once_with()
        client.get_queue.assert_has_calls([
            call('vhost1', 'queue1'),
            call('vhost1', 'queue2'),
            call('vhost2', 'queue3'),
            call('vhost2', 'queue4'),
        ],
                                          any_order=True)

        metrics = {
            'vhosts.vhost1.queues.queue1.key': 1,
            'vhosts.vhost1.queues.queue2.key': 2,
            'vhosts.vhost2.queues.queue3.key': 4,
            'vhosts.vhost2.queues.queue4.key': 5,
            'health.fd_used': 1,
            'health.fd_total': 2,
            'health.mem_used': 2,
            'health.mem_limit': 4,
            'health.sockets_used': 1,
            'health.sockets_total': 2,
            'health.disk_free_limit': 1,
            'health.disk_free': 1,
            'health.proc_used': 1,
            'health.proc_total': 1,
            'cluster.partitions': 0,
            'cluster.nodes': 3
        }

        self.assertPublishedMany(publish_mock, metrics)

        self.collector.config['query_individual_queues'] = False
        del self.collector.config['vhosts']
Exemplo n.º 13
0
class TestRabbitMQCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config(
            'RabbitMQCollector', {
                'host': 'localhost:55672',
                'user': '******',
                'password': '******',
                'queues_ignored': '^ignored',
                'cluster': True,
            })
        self.collector = RabbitMQCollector(config, None)

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

    @patch('rabbitmq.RabbitMQClient')
    @patch.object(Collector, 'publish')
    def test_should_publish_nested_keys(self, publish_mock, client_mock):
        client = Mock()
        queue_data = [{
            'more_keys': {
                'nested_key': 1
            },
            'key': 2,
            'string': 'str',
            'name': 'test_queue'
        }, {
            'name': 'ignored',
            'more_keys': {
                'nested_key': 1
            },
            'key': 2,
            'string': 'str',
        }]
        overview_data = {
            'node': 'rabbit@localhost',
            'more_keys': {
                'nested_key': 3
            },
            'key': 4,
            'string': 'string',
        }
        node_health = {
            'fd_used': 1,
            'fd_total': 2,
            'mem_used': 2,
            'mem_limit': 4,
            'sockets_used': 1,
            'sockets_total': 2,
            'disk_free_limit': 1,
            'disk_free': 1,
            'proc_used': 1,
            'proc_total': 1,
            'partitions': [],
        }
        client_mock.return_value = client
        client.get_queues.return_value = queue_data
        client.get_overview.return_value = overview_data
        client.get_nodes.return_value = [1, 2, 3]
        client.get_node.return_value = node_health

        self.collector.collect()

        client.get_queues.assert_called_once_with(None)
        client.get_nodes.assert_called_once_with()
        client.get_node.assert_called_once_with('rabbit@localhost')

        metrics = {
            'queues.test_queue.more_keys.nested_key': 1,
            'queues.test_queue.key': 2,
            'more_keys.nested_key': 3,
            'key': 4,
            'health.fd_used': 1,
            'health.fd_total': 2,
            'health.mem_used': 2,
            'health.mem_limit': 4,
            'health.sockets_used': 1,
            'health.sockets_total': 2,
            'health.disk_free_limit': 1,
            'health.disk_free': 1,
            'health.proc_used': 1,
            'health.proc_total': 1,
            'cluster.partitions': 0,
            'cluster.nodes': 3
        }

        self.setDocExample(collector=self.collector.__class__.__name__,
                           metrics=metrics,
                           defaultpath=self.collector.config['path'])
        self.assertPublishedMany(publish_mock, metrics)

    @patch('rabbitmq.RabbitMQClient')
    @patch.object(Collector, 'publish')
    def test_opt_should_replace_dots(self, publish_mock, client_mock):
        self.collector.config['replace_dot'] = '_'
        client = Mock()
        queue_data = [{
            'more_keys': {
                'nested_key': 1
            },
            'key': 2,
            'string': 'str',
            'name': 'test.queue'
        }, {
            'name': 'ignored',
            'more_keys': {
                'nested_key': 1
            },
            'key': 2,
            'string': 'str',
        }]
        overview_data = {
            'node': 'rabbit@localhost',
            'more_keys': {
                'nested_key': 3
            },
            'key': 4,
            'string': 'string',
        }
        node_health = {
            'fd_used': 1,
            'fd_total': 2,
            'mem_used': 2,
            'mem_limit': 4,
            'sockets_used': 1,
            'sockets_total': 2,
            'disk_free_limit': 1,
            'disk_free': 1,
            'proc_used': 1,
            'proc_total': 1,
            'partitions': [],
        }
        client_mock.return_value = client
        client.get_queues.return_value = queue_data
        client.get_overview.return_value = overview_data
        client.get_nodes.return_value = [1, 2, 3]
        client.get_node.return_value = node_health

        self.collector.collect()

        metrics = {
            'queues.test_queue.more_keys.nested_key': 1,
            'queues.test_queue.key': 2,
            'more_keys.nested_key': 3,
            'key': 4,
            'health.fd_used': 1,
            'health.fd_total': 2,
            'health.mem_used': 2,
            'health.mem_limit': 4,
            'health.sockets_used': 1,
            'health.sockets_total': 2,
            'health.disk_free_limit': 1,
            'health.disk_free': 1,
            'health.proc_used': 1,
            'health.proc_total': 1,
            'cluster.partitions': 0,
            'cluster.nodes': 3
        }

        self.setDocExample(collector=self.collector.__class__.__name__,
                           metrics=metrics,
                           defaultpath=self.collector.config['path'])
        self.assertPublishedMany(publish_mock, metrics)

        self.collector.config['replace_dot'] = False
Exemplo n.º 14
0
class TestRabbitMQCollector(CollectorTestCase):

    def setUp(self):
        config = get_collector_config('RabbitMQCollector', {
            'host': 'localhost:55672',
            'user': '******',
            'password': '******',
            'queues_ignored': '^ignored',
            'cluster': True,
        })
        self.collector = RabbitMQCollector(config, None)

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

    @patch('rabbitmq.RabbitMQClient')
    @patch.object(Collector, 'publish')
    def test_should_publish_nested_keys(self, publish_mock, client_mock):
        client = Mock()
        queue_data = [{
            'more_keys': {'nested_key': 1},
            'key': 2,
            'string': 'str',
            'name': 'test_queue'
        }, {
            'name': 'ignored',
            'more_keys': {'nested_key': 1},
            'key': 2,
            'string': 'str',
        }]
        overview_data = {
            'node': 'rabbit@localhost',
            'more_keys': {'nested_key': 3},
            'key': 4,
            'string': 'string',
        }
        node_health = {
            'fd_used': 1,
            'fd_total': 2,
            'mem_used': 2,
            'mem_limit': 4,
            'sockets_used': 1,
            'sockets_total': 2,
            'disk_free_limit': 1,
            'disk_free': 1,
            'proc_used': 1,
            'proc_total': 1,
            'partitions': [],
        }
        client_mock.return_value = client
        client.get_queues.return_value = queue_data
        client.get_overview.return_value = overview_data
        client.get_nodes.return_value = [1, 2, 3]
        client.get_node.return_value = node_health
        client.get_vhost_names.return_value = ['/']

        self.collector.collect()

        client.get_queues.assert_called_once_with('/')
        client.get_queue.assert_not_called()
        client.get_nodes.assert_called_once_with()
        client.get_node.assert_called_once_with('rabbit@localhost')
        client.get_vhost_names.assert_called_once_with()

        metrics = {
            'queues.test_queue.more_keys.nested_key': 1,
            'queues.test_queue.key': 2,
            'more_keys.nested_key': 3,
            'key': 4,
            'health.fd_used': 1,
            'health.fd_total': 2,
            'health.mem_used': 2,
            'health.mem_limit': 4,
            'health.sockets_used': 1,
            'health.sockets_total': 2,
            'health.disk_free_limit': 1,
            'health.disk_free': 1,
            'health.proc_used': 1,
            'health.proc_total': 1,
            'cluster.partitions': 0,
            'cluster.nodes': 3
        }

        self.setDocExample(collector=self.collector.__class__.__name__,
                           metrics=metrics,
                           defaultpath=self.collector.config['path'])
        self.assertPublishedMany(publish_mock, metrics)

    @patch('rabbitmq.RabbitMQClient')
    @patch.object(Collector, 'publish')
    def test_opt_should_replace_dots(self, publish_mock, client_mock):
        self.collector.config['replace_dot'] = '_'
        client = Mock()
        queue_data = [{
            'more_keys': {'nested_key': 1},
            'key': 2,
            'string': 'str',
            'name': 'test.queue'
        }, {
            'name': 'ignored',
            'more_keys': {'nested_key': 1},
            'key': 2,
            'string': 'str',
        }]
        overview_data = {
            'node': 'rabbit@localhost',
            'more_keys': {'nested_key': 3},
            'key': 4,
            'string': 'string',
        }
        node_health = {
            'fd_used': 1,
            'fd_total': 2,
            'mem_used': 2,
            'mem_limit': 4,
            'sockets_used': 1,
            'sockets_total': 2,
            'disk_free_limit': 1,
            'disk_free': 1,
            'proc_used': 1,
            'proc_total': 1,
            'partitions': [],
        }
        client_mock.return_value = client
        client.get_queues.return_value = queue_data
        client.get_overview.return_value = overview_data
        client.get_nodes.return_value = [1, 2, 3]
        client.get_node.return_value = node_health
        client.get_vhost_names.return_value = ['/']

        self.collector.collect()

        metrics = {
            'queues.test_queue.more_keys.nested_key': 1,
            'queues.test_queue.key': 2,
            'more_keys.nested_key': 3,
            'key': 4,
            'health.fd_used': 1,
            'health.fd_total': 2,
            'health.mem_used': 2,
            'health.mem_limit': 4,
            'health.sockets_used': 1,
            'health.sockets_total': 2,
            'health.disk_free_limit': 1,
            'health.disk_free': 1,
            'health.proc_used': 1,
            'health.proc_total': 1,
            'cluster.partitions': 0,
            'cluster.nodes': 3
        }

        self.setDocExample(collector=self.collector.__class__.__name__,
                           metrics=metrics,
                           defaultpath=self.collector.config['path'])
        self.assertPublishedMany(publish_mock, metrics)

        self.collector.config['replace_dot'] = False

    @patch('rabbitmq.RabbitMQClient')
    @patch.object(Collector, 'publish')
    def test_opt_should_replace_slashes(self, publish_mock, client_mock):
        self.collector.config['replace_slash'] = '_'
        client = Mock()
        queue_data = [{
            'more_keys': {'nested_key': 1},
            'key': 2,
            'string': 'str',
            'name': 'test/queue'
        }, {
            'name': 'ignored',
            'more_keys': {'nested_key': 1},
            'key': 2,
            'string': 'str',
        }]
        overview_data = {
            'node': 'rabbit@localhost',
            'more_keys': {'nested_key': 3},
            'key': 4,
            'string': 'string',
        }
        node_health = {
            'fd_used': 1,
            'fd_total': 2,
            'mem_used': 2,
            'mem_limit': 4,
            'sockets_used': 1,
            'sockets_total': 2,
            'disk_free_limit': 1,
            'disk_free': 1,
            'proc_used': 1,
            'proc_total': 1,
            'partitions': [],
        }
        client_mock.return_value = client
        client.get_queues.return_value = queue_data
        client.get_overview.return_value = overview_data
        client.get_nodes.return_value = [1, 2, 3]
        client.get_node.return_value = node_health
        client.get_vhost_names.return_value = ['/']

        self.collector.collect()

        metrics = {
            'queues.test_queue.more_keys.nested_key': 1,
            'queues.test_queue.key': 2,
            'more_keys.nested_key': 3,
            'key': 4,
            'health.fd_used': 1,
            'health.fd_total': 2,
            'health.mem_used': 2,
            'health.mem_limit': 4,
            'health.sockets_used': 1,
            'health.sockets_total': 2,
            'health.disk_free_limit': 1,
            'health.disk_free': 1,
            'health.proc_used': 1,
            'health.proc_total': 1,
            'cluster.partitions': 0,
            'cluster.nodes': 3
        }

        self.setDocExample(collector=self.collector.__class__.__name__,
                           metrics=metrics,
                           defaultpath=self.collector.config['path'])
        self.assertPublishedMany(publish_mock, metrics)

        self.collector.config['replace_slash'] = False

    @patch('rabbitmq.RabbitMQClient')
    @patch.object(Collector, 'publish')
    def test_opt_individual_queues(self, publish_mock, client_mock):
        self.collector.config['query_individual_queues'] = True
        self.collector.config['queues'] = 'queue1 queue2 queue3 queue4'
        client = Mock()
        queue_data = {
            'vhost1': {
                'queue1': {
                    'name': 'queue1',
                    'key': 1,
                    'string': 'str',
                },
                'queue2': {
                    'name': 'queue2',
                    'key': 2,
                    'string': 'str',
                },
                'ignored': {
                    'name': 'ignored',
                    'key': 3,
                    'string': 'str',
                },
            },
            'vhost2': {
                'queue3': {
                    'name': 'queue3',
                    'key': 4,
                    'string': 'str',
                },
                'queue4': {
                    'name': 'queue4',
                    'key': 5,
                    'string': 'str',
                },
                'ignored': {
                    'name': 'ignored',
                    'key': 6,
                    'string': 'str',
                }
            }
        }
        overview_data = {
            'node': 'rabbit@localhost',
        }
        node_health = {
            'fd_used': 1,
            'fd_total': 2,
            'mem_used': 2,
            'mem_limit': 4,
            'sockets_used': 1,
            'sockets_total': 2,
            'disk_free_limit': 1,
            'disk_free': 1,
            'proc_used': 1,
            'proc_total': 1,
            'partitions': [],
        }
        client_mock.return_value = client
        client.get_queue.side_effect = lambda v, q: queue_data.get(v).get(q)
        client.get_overview.return_value = overview_data
        client.get_nodes.return_value = [1, 2, 3]
        client.get_node.return_value = node_health
        client.get_vhost_names.return_value = ['vhost1', 'vhost2']

        self.collector.collect()

        client.get_queues.assert_not_called()
        client.get_nodes.assert_called_once_with()
        client.get_node.assert_called_once_with('rabbit@localhost')
        client.get_vhost_names.assert_called_once_with()
        client.get_queue.assert_has_calls([
            call('vhost1', 'queue1'),
            call('vhost1', 'queue2'),
            call('vhost2', 'queue3'),
            call('vhost2', 'queue4'),
        ], any_order=True)

        metrics = {
            'queues.queue1.key': 1,
            'queues.queue2.key': 2,
            'queues.queue3.key': 4,
            'queues.queue4.key': 5,
            'health.fd_used': 1,
            'health.fd_total': 2,
            'health.mem_used': 2,
            'health.mem_limit': 4,
            'health.sockets_used': 1,
            'health.sockets_total': 2,
            'health.disk_free_limit': 1,
            'health.disk_free': 1,
            'health.proc_used': 1,
            'health.proc_total': 1,
            'cluster.partitions': 0,
            'cluster.nodes': 3
        }

        self.assertPublishedMany(publish_mock, metrics)

        self.collector.config['query_individual_queues'] = False
        self.collector.config['queues'] = ''

    @patch('rabbitmq.RabbitMQClient')
    @patch.object(Collector, 'publish')
    def test_opt_vhost_individual_queues(self, publish_mock, client_mock):
        self.collector.config['query_individual_queues'] = True
        self.collector.config['vhosts'] = {
            'vhost1': 'queue1 queue2',
            'vhost2': 'queue3 queue4'
        }
        client = Mock()
        queue_data = {
            'vhost1': {
                'queue1': {
                    'name': 'queue1',
                    'key': 1,
                    'string': 'str',
                },
                'queue2': {
                    'name': 'queue2',
                    'key': 2,
                    'string': 'str',
                },
                'ignored': {
                    'name': 'ignored',
                    'key': 3,
                    'string': 'str',
                },
            },
            'vhost2': {
                'queue3': {
                    'name': 'queue3',
                    'key': 4,
                    'string': 'str',
                },
                'queue4': {
                    'name': 'queue4',
                    'key': 5,
                    'string': 'str',
                },
                'ignored': {
                    'name': 'ignored',
                    'key': 6,
                    'string': 'str',
                }
            }
        }
        overview_data = {
            'node': 'rabbit@localhost',
        }
        node_health = {
            'fd_used': 1,
            'fd_total': 2,
            'mem_used': 2,
            'mem_limit': 4,
            'sockets_used': 1,
            'sockets_total': 2,
            'disk_free_limit': 1,
            'disk_free': 1,
            'proc_used': 1,
            'proc_total': 1,
            'partitions': [],
        }
        client_mock.return_value = client
        client.get_queue.side_effect = lambda v, q: queue_data.get(v).get(q)
        client.get_overview.return_value = overview_data
        client.get_nodes.return_value = [1, 2, 3]
        client.get_node.return_value = node_health
        client.get_vhost_names.return_value = ['vhost1', 'vhost2']

        self.collector.collect()

        client.get_queues.assert_not_called()
        client.get_nodes.assert_called_once_with()
        client.get_node.assert_called_once_with('rabbit@localhost')
        client.get_vhost_names.assert_called_once_with()
        client.get_queue.assert_has_calls([
            call('vhost1', 'queue1'),
            call('vhost1', 'queue2'),
            call('vhost2', 'queue3'),
            call('vhost2', 'queue4'),
        ], any_order=True)

        metrics = {
            'vhosts.vhost1.queues.queue1.key': 1,
            'vhosts.vhost1.queues.queue2.key': 2,
            'vhosts.vhost2.queues.queue3.key': 4,
            'vhosts.vhost2.queues.queue4.key': 5,
            'health.fd_used': 1,
            'health.fd_total': 2,
            'health.mem_used': 2,
            'health.mem_limit': 4,
            'health.sockets_used': 1,
            'health.sockets_total': 2,
            'health.disk_free_limit': 1,
            'health.disk_free': 1,
            'health.proc_used': 1,
            'health.proc_total': 1,
            'cluster.partitions': 0,
            'cluster.nodes': 3
        }

        self.assertPublishedMany(publish_mock, metrics)

        self.collector.config['query_individual_queues'] = False
        del self.collector.config['vhosts']
Exemplo n.º 15
0
 def setUp(self):
     config = get_collector_config(
         "RabbitMQCollector", {"host": "localhost:55672", "user": "******", "password": "******"}
     )
     self.collector = RabbitMQCollector(config, None)