Exemplo n.º 1
0
    def test_key_naming_when_using_instances(self, publish_mock):

        config_data = {
            'instances':
            ['nick1@host1:1111', 'nick2@:2222', 'nick3@host3', 'bla']
        }
        get_info_data = {
            'total_connections_received': 200,
            'total_commands_processed': 100,
        }
        expected_calls = [
            call('nick1.process.connections_received',
                 200,
                 precision=0,
                 metric_type='GAUGE'),
            call('nick1.process.commands_processed',
                 100,
                 precision=0,
                 metric_type='GAUGE'),
            call('nick2.process.connections_received',
                 200,
                 precision=0,
                 metric_type='GAUGE'),
            call('nick2.process.commands_processed',
                 100,
                 precision=0,
                 metric_type='GAUGE'),
            call('nick3.process.connections_received',
                 200,
                 precision=0,
                 metric_type='GAUGE'),
            call('nick3.process.commands_processed',
                 100,
                 precision=0,
                 metric_type='GAUGE'),
            call('6379.process.connections_received',
                 200,
                 precision=0,
                 metric_type='GAUGE'),
            call('6379.process.commands_processed',
                 100,
                 precision=0,
                 metric_type='GAUGE'),
        ]

        config = get_collector_config('RedisCollector', config_data)
        collector = RedisCollector(config, None)

        patch_c = patch.object(RedisCollector, '_get_info',
                               Mock(return_value=get_info_data))

        patch_c.start()
        collector.collect()
        patch_c.stop()

        self.assertEqual(publish_mock.call_count, len(expected_calls))
        for exp_call in expected_calls:
            # Test expected calls 1 by 1,
            # because self.instances is a dict (=random order)
            publish_mock.assert_has_calls(exp_call)
Exemplo n.º 2
0
    def setUp(self):
        config = get_collector_config('RedisCollector', {
            'interval': '1',
            'databases': 1,
        })

        self.collector = RedisCollector(config, None)
Exemplo n.º 3
0
    def test_key_naming_when_using_instances(self, publish_mock):

        config_data = {
            'instances': [
                'nick1@host1:1111',
                'nick2@:2222',
                'nick3@host3',
                'nick4@host4:3333/@password',
                'bla'
            ]
        }
        get_info_data = {
            'total_connections_received': 200,
            'total_commands_processed': 100,
        }
        expected_calls = [
            call('nick1.process.connections_received', 200, precision=0,
                 metric_type='GAUGE'),
            call('nick1.process.commands_processed', 100, precision=0,
                 metric_type='GAUGE'),
            call('nick2.process.connections_received', 200, precision=0,
                 metric_type='GAUGE'),
            call('nick2.process.commands_processed', 100, precision=0,
                 metric_type='GAUGE'),
            call('nick3.process.connections_received', 200, precision=0,
                 metric_type='GAUGE'),
            call('nick3.process.commands_processed', 100, precision=0,
                 metric_type='GAUGE'),
            call('nick4.process.connections_received', 200, precision=0,
                 metric_type='GAUGE'),
            call('nick4.process.commands_processed', 100, precision=0,
                 metric_type='GAUGE'),
            call('6379.process.connections_received', 200, precision=0,
                 metric_type='GAUGE'),
            call('6379.process.commands_processed', 100, precision=0,
                 metric_type='GAUGE'),
        ]

        config = get_collector_config('RedisCollector', config_data)
        collector = RedisCollector(config, None)

        patch_c = patch.object(RedisCollector, '_get_info',
                               Mock(return_value=get_info_data))

        patch_c.start()
        collector.collect()
        patch_c.stop()

        self.assertEqual(publish_mock.call_count, len(expected_calls))
        for exp_call in expected_calls:
            # Test expected calls 1 by 1,
            # because self.instances is a dict (=random order)
            publish_mock.assert_has_calls(exp_call)
Exemplo n.º 4
0
    def setUp(self):
        config = get_collector_config('RedisCollector', {
            'interval': '1',
            'databases': 1,
        })

        self.collector = RedisCollector(config, None)
Exemplo n.º 5
0
    def test_process_config_with_instances(self, publish_mock):

        config_data = {
            'instances': [
                'nick1@host1:1111', 'nick2@:2222', 'nick3@host3',
                'nick4@host4:3333/@pass/word', 'bla'
            ]
        }

        expected_processed_config = {
            'nick2': ('localhost', 2222, None, None),
            'nick3': ('host3', 6379, None, None),
            'nick1': ('host1', 1111, None, None),
            'nick4': ('host4', 3333, None, '@pass/word'),
            '6379': ('bla', 6379, None, None)
        }

        config = get_collector_config('RedisCollector', config_data)
        collector = RedisCollector(config, None)

        self.assertEqual(collector.instances, expected_processed_config)
Exemplo n.º 6
0
class TestRedisCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config('RedisCollector', {
            'interval': '1',
            'databases': 1,
        })

        self.collector = RedisCollector(config, None)

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

    @run_only_if_redis_is_available
    @patch.object(Collector, 'publish')
    def test_real_data(self, publish_mock):

        data_1 = {'pubsub_channels': 0,
                  'used_memory_peak_human': '700.71K',
                  'bgrewriteaof_in_progress': 0,
                  'connected_slaves': 0,
                  'uptime_in_days': 0,
                  'multiplexing_api': 'epoll',
                  'lru_clock': 954113,
                  'last_save_time': 1351718385,
                  'redis_version': '2.4.10',
                  'redis_git_sha1': 0,
                  'gcc_version': '4.4.6',
                  'connected_clients': 1,
                  'keyspace_misses': 0,
                  'used_memory': 726144,
                  'vm_enabled': 0,
                  'used_cpu_user_children': '0.00',
                  'used_memory_peak': 717528,
                  'role': 'master',
                  'total_commands_processed': 1,
                  'latest_fork_usec': 0,
                  'loading': 0,
                  'used_memory_rss': 7254016,
                  'total_connections_received': 1,
                  'pubsub_patterns': 0,
                  'aof_enabled': 0,
                  'used_cpu_sys': '0.02',
                  'used_memory_human': '709.12K',
                  'used_cpu_sys_children': '0.00',
                  'blocked_clients': 0,
                  'used_cpu_user': '******',
                  'client_biggest_input_buf': 0,
                  'arch_bits': 64,
                  'mem_fragmentation_ratio': '9.99',
                  'expired_keys': 0,
                  'evicted_keys': 0,
                  'bgsave_in_progress': 0,
                  'client_longest_output_list': 0,
                  'mem_allocator': 'jemalloc-2.2.5',
                  'process_id': 3020,
                  'uptime_in_seconds': 32,
                  'changes_since_last_save': 0,
                  'redis_git_dirty': 0,
                  'keyspace_hits': 0
                  }
        data_2 = {'pubsub_channels': 1,
                  'used_memory_peak_human': '1700.71K',
                  'bgrewriteaof_in_progress': 4,
                  'connected_slaves': 2,
                  'master_last_io_seconds_ago': 7,
                  'uptime_in_days': 1,
                  'multiplexing_api': 'epoll',
                  'lru_clock': 5954113,
                  'last_save_time': 51351718385,
                  'redis_version': '2.4.10',
                  'redis_git_sha1': 0,
                  'gcc_version': '4.4.6',
                  'connected_clients': 100,
                  'keyspace_misses': 670,
                  'used_memory': 1726144,
                  'vm_enabled': 0,
                  'used_cpu_user_children': '2.00',
                  'used_memory_peak': 1717528,
                  'role': 'master',
                  'total_commands_processed': 19764,
                  'latest_fork_usec': 8,
                  'loading': 0,
                  'used_memory_rss': 17254016,
                  'total_connections_received': 18764,
                  'pubsub_patterns': 0,
                  'aof_enabled': 0,
                  'used_cpu_sys': '0.05',
                  'used_memory_human': '1709.12K',
                  'used_cpu_sys_children': '0.09',
                  'blocked_clients': 8,
                  'used_cpu_user': '******',
                  'client_biggest_input_buf': 40,
                  'arch_bits': 64,
                  'mem_fragmentation_ratio': '0.99',
                  'expired_keys': 0,
                  'evicted_keys': 0,
                  'bgsave_in_progress': 0,
                  'client_longest_output_list': 0,
                  'mem_allocator': 'jemalloc-2.2.5',
                  'process_id': 3020,
                  'uptime_in_seconds': 95732,
                  'changes_since_last_save': 759,
                  'redis_git_dirty': 0,
                  'keyspace_hits': 5700
                  }

        patch_collector = patch.object(RedisCollector, '_get_info',
                                       Mock(return_value=data_1))
        patch_time = patch('time.time', Mock(return_value=10))

        patch_collector.start()
        patch_time.start()
        self.collector.collect()
        patch_collector.stop()
        patch_time.stop()

        self.assertPublishedMany(publish_mock, {})

        patch_collector = patch.object(RedisCollector, '_get_info',
                                       Mock(return_value=data_2))
        patch_time = patch('time.time', Mock(return_value=20))

        patch_collector.start()
        patch_time.start()
        self.collector.collect()
        patch_collector.stop()
        patch_time.stop()

        metrics = {'6379.process.uptime': 95732,
                   '6379.pubsub.channels': 1,
                   '6379.slaves.connected': 2,
                   '6379.slaves.last_io': 7,
                   '6379.process.connections_received': 18764,
                   '6379.clients.longest_output_list': 0,
                   '6379.process.commands_processed': 19764,
                   '6379.last_save.changes_since': 759,
                   '6379.memory.external_view': 17254016,
                   '6379.memory.fragmentation_ratio': 0.99,
                   '6379.last_save.time': 51351718385,
                   '6379.clients.connected': 100,
                   '6379.clients.blocked': 8,
                   '6379.pubsub.patterns': 0,
                   '6379.cpu.parent.user': 0.09,
                   '6379.last_save.time_since': -51351718365,
                   '6379.memory.internal_view': 1726144,
                   '6379.cpu.parent.sys': 0.05,
                   '6379.keyspace.misses': 670,
                   '6379.keys.expired': 0,
                   '6379.keys.evicted': 0,
                   '6379.keyspace.hits': 5700,
                   }

        self.assertPublishedMany(publish_mock, metrics)

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

    @run_only_if_redis_is_available
    @patch.object(Collector, 'publish')
    def test_hostport_or_instance_config(self, publish_mock):

        testcases = {
            'default': {
                'config': {},  # test default settings
                'calls': [call('6379', 'localhost', 6379, None, None)],
            },
            'host_set': {
                'config': {'host': 'myhost'},
                'calls': [call('6379', 'myhost', 6379, None, None)],
            },
            'port_set': {
                'config': {'port': 5005},
                'calls': [call('5005', 'localhost', 5005, None, None)],
            },
            'hostport_set': {
                'config': {'host': 'megahost', 'port': 5005},
                'calls': [call('5005', 'megahost', 5005, None, None)],
            },
            'portauth_set': {
                'config': {'port': 5005, 'auth': 'pass'},
                'calls': [call('5005', 'localhost', 5005, None, 'pass')],
            },
            'unix_socket_host_set': {
                'config': {'host': 'unix:/var/run/redis/myhost.sock'},
                'calls': [call('myhost', 'localhost', 6379,
                               '/var/run/redis/myhost.sock', None)],
            },
            'instance_1_host': {
                'config': {'instances': ['nick@myhost']},
                'calls': [call('nick', 'myhost', 6379, None, None)],
            },
            'unix_socket_instance_1_host': {
                'config': {'instances': [
                    'nick@unix:/var/run/redis/myhost.sock'
                ]},
                'calls': [call('nick', 'localhost', 6379,
                               '/var/run/redis/myhost.sock', None)],
            },
            'unix_socket_instance_1_hostauth': {
                'config': {'instances': [
                    'nick@unix:/var/run/redis/myhost.sock:/pass'
                ]},
                'calls': [call('nick', 'localhost', 6379,
                               '/var/run/redis/myhost.sock', 'pass')],
            },
            'instance_1_port': {
                'config': {'instances': ['nick@:9191']},
                'calls': [call('nick', 'localhost', 9191, None, None)],
            },
            'instance_1_hostport': {
                'config': {'instances': ['nick@host1:8765']},
                'calls': [call('nick', 'host1', 8765, None, None)],
            },
            'instance_2': {
                'config': {'instances': [
                    'foo@hostX',
                    'bar@:1000/pass',
                    'unix:/var/run/redis/myhost.sock:1/pass'
                ]},
                'calls': [
                    call('foo', 'hostX', 6379, None, None),
                    call('bar', 'localhost', 1000, None, 'pass'),
                    call('myhost', 'localhost', 6379,
                         '/var/run/redis/myhost.sock', 'pass'),
                ],
            },
            'old_and_new': {
                'config': {
                    'host': 'myhost',
                    'port': 1234,
                    'instances': [
                        'foo@hostX',
                        'bar@:1000',
                        'hostonly',
                        ':1234'
                    ]
                },
                'calls': [
                    call('foo', 'hostX', 6379, None, None),
                    call('bar', 'localhost', 1000, None, None),
                    call('6379', 'hostonly', 6379, None, None),
                    call('1234', 'localhost', 1234, None, None),
                ],
            },
        }

        for testname, data in testcases.items():
            config = get_collector_config('RedisCollector', data['config'])

            collector = RedisCollector(config, None)

            mock = Mock(return_value={}, name=testname)
            patch_c = patch.object(RedisCollector, 'collect_instance', mock)

            patch_c.start()
            collector.collect()
            patch_c.stop()

            expected_call_count = len(data['calls'])
            self.assertEqual(mock.call_count, expected_call_count,
                             msg='[%s] mock.calls=%d != expected_calls=%d' %
                             (testname, mock.call_count, expected_call_count))
            for exp_call in data['calls']:
                # Test expected calls 1 by 1,
                # because self.instances is a dict (=random order)
                mock.assert_has_calls(exp_call)

    @run_only_if_redis_is_available
    @patch.object(Collector, 'publish')
    def test_key_naming_when_using_instances(self, publish_mock):

        config_data = {
            'instances': [
                'nick1@host1:1111',
                'nick2@:2222',
                'nick3@host3',
                'nick4@host4:3333/@password',
                'bla'
            ]
        }
        get_info_data = {
            'total_connections_received': 200,
            'total_commands_processed': 100,
        }
        expected_calls = [
            call('nick1.process.connections_received', 200, precision=0,
                 metric_type='GAUGE'),
            call('nick1.process.commands_processed', 100, precision=0,
                 metric_type='GAUGE'),
            call('nick2.process.connections_received', 200, precision=0,
                 metric_type='GAUGE'),
            call('nick2.process.commands_processed', 100, precision=0,
                 metric_type='GAUGE'),
            call('nick3.process.connections_received', 200, precision=0,
                 metric_type='GAUGE'),
            call('nick3.process.commands_processed', 100, precision=0,
                 metric_type='GAUGE'),
            call('nick4.process.connections_received', 200, precision=0,
                 metric_type='GAUGE'),
            call('nick4.process.commands_processed', 100, precision=0,
                 metric_type='GAUGE'),
            call('6379.process.connections_received', 200, precision=0,
                 metric_type='GAUGE'),
            call('6379.process.commands_processed', 100, precision=0,
                 metric_type='GAUGE'),
        ]

        config = get_collector_config('RedisCollector', config_data)
        collector = RedisCollector(config, None)

        patch_c = patch.object(RedisCollector, '_get_info',
                               Mock(return_value=get_info_data))

        patch_c.start()
        collector.collect()
        patch_c.stop()

        self.assertEqual(publish_mock.call_count, len(expected_calls))
        for exp_call in expected_calls:
            # Test expected calls 1 by 1,
            # because self.instances is a dict (=random order)
            publish_mock.assert_has_calls(exp_call)
Exemplo n.º 7
0
    def test_hostport_or_instance_config(self, publish_mock):

        testcases = {
            'default': {
                'config': {},  # test default settings
                'calls': [call('6379', 'localhost', 6379, None, None)],
            },
            'host_set': {
                'config': {'host': 'myhost'},
                'calls': [call('6379', 'myhost', 6379, None, None)],
            },
            'port_set': {
                'config': {'port': 5005},
                'calls': [call('5005', 'localhost', 5005, None, None)],
            },
            'hostport_set': {
                'config': {'host': 'megahost', 'port': 5005},
                'calls': [call('5005', 'megahost', 5005, None, None)],
            },
            'portauth_set': {
                'config': {'port': 5005, 'auth': 'pass'},
                'calls': [call('5005', 'localhost', 5005, None, 'pass')],
            },
            'unix_socket_host_set': {
                'config': {'host': 'unix:/var/run/redis/myhost.sock'},
                'calls': [call('myhost', 'localhost', 6379,
                               '/var/run/redis/myhost.sock', None)],
            },
            'instance_1_host': {
                'config': {'instances': ['nick@myhost']},
                'calls': [call('nick', 'myhost', 6379, None, None)],
            },
            'unix_socket_instance_1_host': {
                'config': {'instances': [
                    'nick@unix:/var/run/redis/myhost.sock'
                ]},
                'calls': [call('nick', 'localhost', 6379,
                               '/var/run/redis/myhost.sock', None)],
            },
            'unix_socket_instance_1_hostauth': {
                'config': {'instances': [
                    'nick@unix:/var/run/redis/myhost.sock:/pass'
                ]},
                'calls': [call('nick', 'localhost', 6379,
                               '/var/run/redis/myhost.sock', 'pass')],
            },
            'instance_1_port': {
                'config': {'instances': ['nick@:9191']},
                'calls': [call('nick', 'localhost', 9191, None, None)],
            },
            'instance_1_hostport': {
                'config': {'instances': ['nick@host1:8765']},
                'calls': [call('nick', 'host1', 8765, None, None)],
            },
            'instance_2': {
                'config': {'instances': [
                    'foo@hostX',
                    'bar@:1000/pass',
                    'unix:/var/run/redis/myhost.sock:1/pass'
                ]},
                'calls': [
                    call('foo', 'hostX', 6379, None, None),
                    call('bar', 'localhost', 1000, None, 'pass'),
                    call('myhost', 'localhost', 6379,
                         '/var/run/redis/myhost.sock', 'pass'),
                ],
            },
            'old_and_new': {
                'config': {
                    'host': 'myhost',
                    'port': 1234,
                    'instances': [
                        'foo@hostX',
                        'bar@:1000',
                        'hostonly',
                        ':1234'
                    ]
                },
                'calls': [
                    call('foo', 'hostX', 6379, None, None),
                    call('bar', 'localhost', 1000, None, None),
                    call('6379', 'hostonly', 6379, None, None),
                    call('1234', 'localhost', 1234, None, None),
                ],
            },
        }

        for testname, data in testcases.items():
            config = get_collector_config('RedisCollector', data['config'])

            collector = RedisCollector(config, None)

            mock = Mock(return_value={}, name=testname)
            patch_c = patch.object(RedisCollector, 'collect_instance', mock)

            patch_c.start()
            collector.collect()
            patch_c.stop()

            expected_call_count = len(data['calls'])
            self.assertEqual(mock.call_count, expected_call_count,
                             msg='[%s] mock.calls=%d != expected_calls=%d' %
                             (testname, mock.call_count, expected_call_count))
            for exp_call in data['calls']:
                # Test expected calls 1 by 1,
                # because self.instances is a dict (=random order)
                mock.assert_has_calls(exp_call)
Exemplo n.º 8
0
class TestRedisCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config('RedisCollector', {
            'interval': '1',
            'databases': 1,
        })

        self.collector = RedisCollector(config, None)

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

    @run_only_if_redis_is_available
    @patch.object(Collector, 'publish')
    def test_real_data(self, publish_mock):

        data_1 = {'pubsub_channels': 0,
                  'used_memory_peak_human': '700.71K',
                  'bgrewriteaof_in_progress': 0,
                  'connected_slaves': 0,
                  'uptime_in_days': 0,
                  'multiplexing_api': 'epoll',
                  'lru_clock': 954113,
                  'last_save_time': 1351718385,
                  'redis_version': '2.4.10',
                  'redis_git_sha1': 0,
                  'gcc_version': '4.4.6',
                  'connected_clients': 1,
                  'keyspace_misses': 0,
                  'used_memory': 726144,
                  'vm_enabled': 0,
                  'used_cpu_user_children': '0.00',
                  'used_memory_peak': 717528,
                  'role': 'master',
                  'total_commands_processed': 1,
                  'latest_fork_usec': 0,
                  'loading': 0,
                  'used_memory_rss': 7254016,
                  'total_connections_received': 1,
                  'pubsub_patterns': 0,
                  'aof_enabled': 0,
                  'used_cpu_sys': '0.02',
                  'used_memory_human': '709.12K',
                  'used_cpu_sys_children': '0.00',
                  'blocked_clients': 0,
                  'used_cpu_user': '******',
                  'client_biggest_input_buf': 0,
                  'arch_bits': 64,
                  'mem_fragmentation_ratio': '9.99',
                  'expired_keys': 0,
                  'evicted_keys': 0,
                  'bgsave_in_progress': 0,
                  'client_longest_output_list': 0,
                  'mem_allocator': 'jemalloc-2.2.5',
                  'process_id': 3020,
                  'uptime_in_seconds': 32,
                  'changes_since_last_save': 0,
                  'redis_git_dirty': 0,
                  'keyspace_hits': 0
                  }
        data_2 = {'pubsub_channels': 1,
                  'used_memory_peak_human': '1700.71K',
                  'bgrewriteaof_in_progress': 4,
                  'connected_slaves': 2,
                  'uptime_in_days': 1,
                  'multiplexing_api': 'epoll',
                  'lru_clock': 5954113,
                  'last_save_time': 51351718385,
                  'redis_version': '2.4.10',
                  'redis_git_sha1': 0,
                  'gcc_version': '4.4.6',
                  'connected_clients': 100,
                  'keyspace_misses': 670,
                  'used_memory': 1726144,
                  'vm_enabled': 0,
                  'used_cpu_user_children': '2.00',
                  'used_memory_peak': 1717528,
                  'role': 'master',
                  'total_commands_processed': 19764,
                  'latest_fork_usec': 8,
                  'loading': 0,
                  'used_memory_rss': 17254016,
                  'total_connections_received': 18764,
                  'pubsub_patterns': 0,
                  'aof_enabled': 0,
                  'used_cpu_sys': '0.05',
                  'used_memory_human': '1709.12K',
                  'used_cpu_sys_children': '0.09',
                  'blocked_clients': 8,
                  'used_cpu_user': '******',
                  'client_biggest_input_buf': 40,
                  'arch_bits': 64,
                  'mem_fragmentation_ratio': '0.99',
                  'expired_keys': 0,
                  'evicted_keys': 0,
                  'bgsave_in_progress': 0,
                  'client_longest_output_list': 0,
                  'mem_allocator': 'jemalloc-2.2.5',
                  'process_id': 3020,
                  'uptime_in_seconds': 95732,
                  'changes_since_last_save': 759,
                  'redis_git_dirty': 0,
                  'keyspace_hits': 5700
                  }

        patch_collector = patch.object(RedisCollector, '_get_info',
                                       Mock(return_value=data_1))
        patch_time = patch('time.time', Mock(return_value=10))

        patch_collector.start()
        patch_time.start()
        self.collector.collect()
        patch_collector.stop()
        patch_time.stop()

        self.assertPublishedMany(publish_mock, {})

        patch_collector = patch.object(RedisCollector, '_get_info',
                                       Mock(return_value=data_2))
        patch_time = patch('time.time', Mock(return_value=20))

        patch_collector.start()
        patch_time.start()
        self.collector.collect()
        patch_collector.stop()
        patch_time.stop()

        metrics = {'6379.process.uptime': 95732,
                   '6379.pubsub.channels': 1,
                   '6379.slaves.connected': 2,
                   '6379.process.connections_received': 18764,
                   '6379.clients.longest_output_list': 0,
                   '6379.process.commands_processed': 19764,
                   '6379.last_save.changes_since': 759,
                   '6379.memory.external_view': 17254016,
                   '6379.memory.fragmentation_ratio': 0.99,
                   '6379.last_save.time': 51351718385,
                   '6379.clients.connected': 100,
                   '6379.clients.blocked': 8,
                   '6379.pubsub.patterns': 0,
                   '6379.cpu.parent.user': 0.09,
                   '6379.last_save.time_since': -51351718365,
                   '6379.memory.internal_view': 1726144,
                   '6379.cpu.parent.sys': 0.05,
                   '6379.keyspace.misses': 670,
                   '6379.keys.expired': 0,
                   '6379.keys.evicted': 0,
                   '6379.keyspace.hits': 5700,
                   }

        self.assertPublishedMany(publish_mock, metrics)

        self.setDocExample(collector=self.collector.__class__.__name__,
                           metrics=metrics,
                           defaultpath=self.collector.config['path'])
Exemplo n.º 9
0
class TestRedisCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config('RedisCollector', {
            'interval': '1',
            'databases': 1,
        })

        self.collector = RedisCollector(config, None)

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

    @run_only_if_redis_is_available
    @patch.object(Collector, 'publish')
    def test_real_data(self, publish_mock):

        data_1 = {'pubsub_channels': 0,
                  'used_memory_peak_human': '700.71K',
                  'bgrewriteaof_in_progress': 0,
                  'connected_slaves': 0,
                  'uptime_in_days': 0,
                  'multiplexing_api': 'epoll',
                  'lru_clock': 954113,
                  'last_save_time': 1351718385,
                  'redis_version': '2.4.10',
                  'redis_git_sha1': 0,
                  'gcc_version': '4.4.6',
                  'connected_clients': 1,
                  'keyspace_misses': 0,
                  'used_memory': 726144,
                  'vm_enabled': 0,
                  'used_cpu_user_children': '0.00',
                  'used_memory_peak': 717528,
                  'role': 'master',
                  'total_commands_processed': 1,
                  'latest_fork_usec': 0,
                  'loading': 0,
                  'used_memory_rss': 7254016,
                  'total_connections_received': 1,
                  'pubsub_patterns': 0,
                  'aof_enabled': 0,
                  'used_cpu_sys': '0.02',
                  'used_memory_human': '709.12K',
                  'used_cpu_sys_children': '0.00',
                  'blocked_clients': 0,
                  'used_cpu_user': '******',
                  'client_biggest_input_buf': 0,
                  'arch_bits': 64,
                  'mem_fragmentation_ratio': '9.99',
                  'expired_keys': 0,
                  'evicted_keys': 0,
                  'bgsave_in_progress': 0,
                  'client_longest_output_list': 0,
                  'mem_allocator': 'jemalloc-2.2.5',
                  'process_id': 3020,
                  'uptime_in_seconds': 32,
                  'changes_since_last_save': 0,
                  'redis_git_dirty': 0,
                  'keyspace_hits': 0
                  }
        data_2 = {'pubsub_channels': 1,
                  'used_memory_peak_human': '1700.71K',
                  'bgrewriteaof_in_progress': 4,
                  'connected_slaves': 2,
                  'uptime_in_days': 1,
                  'multiplexing_api': 'epoll',
                  'lru_clock': 5954113,
                  'last_save_time': 51351718385,
                  'redis_version': '2.4.10',
                  'redis_git_sha1': 0,
                  'gcc_version': '4.4.6',
                  'connected_clients': 100,
                  'keyspace_misses': 670,
                  'used_memory': 1726144,
                  'vm_enabled': 0,
                  'used_cpu_user_children': '2.00',
                  'used_memory_peak': 1717528,
                  'role': 'master',
                  'total_commands_processed': 19764,
                  'latest_fork_usec': 8,
                  'loading': 0,
                  'used_memory_rss': 17254016,
                  'total_connections_received': 18764,
                  'pubsub_patterns': 0,
                  'aof_enabled': 0,
                  'used_cpu_sys': '0.05',
                  'used_memory_human': '1709.12K',
                  'used_cpu_sys_children': '0.09',
                  'blocked_clients': 8,
                  'used_cpu_user': '******',
                  'client_biggest_input_buf': 40,
                  'arch_bits': 64,
                  'mem_fragmentation_ratio': '0.99',
                  'expired_keys': 0,
                  'evicted_keys': 0,
                  'bgsave_in_progress': 0,
                  'client_longest_output_list': 0,
                  'mem_allocator': 'jemalloc-2.2.5',
                  'process_id': 3020,
                  'uptime_in_seconds': 95732,
                  'changes_since_last_save': 759,
                  'redis_git_dirty': 0,
                  'keyspace_hits': 5700
                  }

        patch_collector = patch.object(RedisCollector, '_get_info',
                                       Mock(return_value=data_1))
        patch_time = patch('time.time', Mock(return_value=10))

        patch_collector.start()
        patch_time.start()
        self.collector.collect()
        patch_collector.stop()
        patch_time.stop()

        self.assertPublishedMany(publish_mock, {})

        patch_collector = patch.object(RedisCollector, '_get_info',
                                       Mock(return_value=data_2))
        patch_time = patch('time.time', Mock(return_value=20))

        patch_collector.start()
        patch_time.start()
        self.collector.collect()
        patch_collector.stop()
        patch_time.stop()

        metrics = {'6379.process.uptime': 95732,
                   '6379.pubsub.channels': 1,
                   '6379.slaves.connected': 2,
                   '6379.process.connections_received': 18764,
                   '6379.clients.longest_output_list': 0,
                   '6379.process.commands_processed': 19764,
                   '6379.last_save.changes_since': 759,
                   '6379.memory.external_view': 17254016,
                   '6379.memory.fragmentation_ratio': 0.99,
                   '6379.last_save.time': 51351718385,
                   '6379.clients.connected': 100,
                   '6379.clients.blocked': 8,
                   '6379.pubsub.patterns': 0,
                   '6379.cpu.parent.user': 0.09,
                   '6379.last_save.time_since': -51351718365,
                   '6379.memory.internal_view': 1726144,
                   '6379.cpu.parent.sys': 0.05,
                   '6379.keyspace.misses': 670,
                   '6379.keys.expired': 0,
                   '6379.keys.evicted': 0,
                   '6379.keyspace.hits': 5700,
                   }

        self.assertPublishedMany(publish_mock, metrics)

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

    @run_only_if_redis_is_available
    @patch.object(Collector, 'publish')
    def test_hostport_or_instance_config(self, publish_mock):

        testcases = {
            'default': {
                'config': {},  # test default settings
                'calls': [call('6379', 'localhost', 6379, None, None)],
            },
            'host_set': {
                'config': {'host': 'myhost'},
                'calls': [call('6379', 'myhost', 6379, None, None)],
            },
            'port_set': {
                'config': {'port': 5005},
                'calls': [call('5005', 'localhost', 5005, None, None)],
            },
            'hostport_set': {
                'config': {'host': 'megahost', 'port': 5005},
                'calls': [call('5005', 'megahost', 5005, None, None)],
            },
            'portauth_set': {
                'config': {'port': 5005, 'auth': 'pass'},
                'calls': [call('5005', 'localhost', 5005, None, 'pass')],
            },
            'unix_socket_host_set': {
                'config': {'host': 'unix:/var/run/redis/myhost.sock'},
                'calls': [call('myhost', 'localhost', 6379,
                               '/var/run/redis/myhost.sock', None)],
            },
            'instance_1_host': {
                'config': {'instances': ['nick@myhost']},
                'calls': [call('nick', 'myhost', 6379, None, None)],
            },
            'unix_socket_instance_1_host': {
                'config': {'instances': [
                    'nick@unix:/var/run/redis/myhost.sock'
                ]},
                'calls': [call('nick', 'localhost', 6379,
                               '/var/run/redis/myhost.sock', None)],
            },
            'unix_socket_instance_1_hostauth': {
                'config': {'instances': [
                    'nick@unix:/var/run/redis/myhost.sock:/pass'
                ]},
                'calls': [call('nick', 'localhost', 6379,
                               '/var/run/redis/myhost.sock', 'pass')],
            },
            'instance_1_port': {
                'config': {'instances': ['nick@:9191']},
                'calls': [call('nick', 'localhost', 9191, None, None)],
            },
            'instance_1_hostport': {
                'config': {'instances': ['nick@host1:8765']},
                'calls': [call('nick', 'host1', 8765, None, None)],
            },
            'instance_2': {
                'config': {'instances': [
                    'foo@hostX',
                    'bar@:1000/pass',
                    'unix:/var/run/redis/myhost.sock:1/pass'
                ]},
                'calls': [
                    call('foo', 'hostX', 6379, None, None),
                    call('bar', 'localhost', 1000, None, 'pass'),
                    call('myhost', 'localhost', 6379,
                         '/var/run/redis/myhost.sock', 'pass'),
                ],
            },
            'old_and_new': {
                'config': {
                    'host': 'myhost',
                    'port': 1234,
                    'instances': [
                        'foo@hostX',
                        'bar@:1000',
                        'hostonly',
                        ':1234'
                    ]
                },
                'calls': [
                    call('foo', 'hostX', 6379, None, None),
                    call('bar', 'localhost', 1000, None, None),
                    call('6379', 'hostonly', 6379, None, None),
                    call('1234', 'localhost', 1234, None, None),
                ],
            },
        }

        for testname, data in testcases.items():
            config = get_collector_config('RedisCollector', data['config'])

            collector = RedisCollector(config, None)

            mock = Mock(return_value={}, name=testname)
            patch_c = patch.object(RedisCollector, 'collect_instance', mock)

            patch_c.start()
            collector.collect()
            patch_c.stop()

            expected_call_count = len(data['calls'])
            self.assertEqual(mock.call_count, expected_call_count,
                             msg='[%s] mock.calls=%d != expected_calls=%d' %
                             (testname, mock.call_count, expected_call_count))
            for exp_call in data['calls']:
                # Test expected calls 1 by 1,
                # because self.instances is a dict (=random order)
                mock.assert_has_calls(exp_call)

    @run_only_if_redis_is_available
    @patch.object(Collector, 'publish')
    def test_key_naming_when_using_instances(self, publish_mock):

        config_data = {
            'instances': [
                'nick1@host1:1111',
                'nick2@:2222',
                'nick3@host3',
                'nick4@host4:3333/@password',
                'bla'
            ]
        }
        get_info_data = {
            'total_connections_received': 200,
            'total_commands_processed': 100,
        }
        expected_calls = [
            call('nick1.process.connections_received', 200, precision=0,
                 metric_type='GAUGE'),
            call('nick1.process.commands_processed', 100, precision=0,
                 metric_type='GAUGE'),
            call('nick2.process.connections_received', 200, precision=0,
                 metric_type='GAUGE'),
            call('nick2.process.commands_processed', 100, precision=0,
                 metric_type='GAUGE'),
            call('nick3.process.connections_received', 200, precision=0,
                 metric_type='GAUGE'),
            call('nick3.process.commands_processed', 100, precision=0,
                 metric_type='GAUGE'),
            call('nick4.process.connections_received', 200, precision=0,
                 metric_type='GAUGE'),
            call('nick4.process.commands_processed', 100, precision=0,
                 metric_type='GAUGE'),
            call('6379.process.connections_received', 200, precision=0,
                 metric_type='GAUGE'),
            call('6379.process.commands_processed', 100, precision=0,
                 metric_type='GAUGE'),
        ]

        config = get_collector_config('RedisCollector', config_data)
        collector = RedisCollector(config, None)

        patch_c = patch.object(RedisCollector, '_get_info',
                               Mock(return_value=get_info_data))

        patch_c.start()
        collector.collect()
        patch_c.stop()

        self.assertEqual(publish_mock.call_count, len(expected_calls))
        for exp_call in expected_calls:
            # Test expected calls 1 by 1,
            # because self.instances is a dict (=random order)
            publish_mock.assert_has_calls(exp_call)
Exemplo n.º 10
0
    def test_hostport_or_instance_config(self, publish_mock):

        testcases = {
            'default': {
                'config': {},  # test default settings
                'calls': [call('6379', 'localhost', 6379, None, None)],
            },
            'host_set': {
                'config': {'host': 'myhost'},
                'calls': [call('6379', 'myhost', 6379, None, None)],
            },
            'port_set': {
                'config': {'port': 5005},
                'calls': [call('5005', 'localhost', 5005, None, None)],
            },
            'hostport_set': {
                'config': {'host': 'megahost', 'port': 5005},
                'calls': [call('5005', 'megahost', 5005, None, None)],
            },
            'portauth_set': {
                'config': {'port': 5005, 'auth': 'pass'},
                'calls': [call('5005', 'localhost', 5005, None, 'pass')],
            },
            'unix_socket_host_set': {
                'config': {'host': 'unix:/var/run/redis/myhost.sock'},
                'calls': [call('myhost', 'localhost', 6379,
                               '/var/run/redis/myhost.sock', None)],
            },
            'instance_1_host': {
                'config': {'instances': ['nick@myhost']},
                'calls': [call('nick', 'myhost', 6379, None, None)],
            },
            'unix_socket_instance_1_host': {
                'config': {'instances': [
                    'nick@unix:/var/run/redis/myhost.sock'
                ]},
                'calls': [call('nick', 'localhost', 6379,
                               '/var/run/redis/myhost.sock', None)],
            },
            'unix_socket_instance_1_hostauth': {
                'config': {'instances': [
                    'nick@unix:/var/run/redis/myhost.sock:/pass'
                ]},
                'calls': [call('nick', 'localhost', 6379,
                               '/var/run/redis/myhost.sock', 'pass')],
            },
            'instance_1_port': {
                'config': {'instances': ['nick@:9191']},
                'calls': [call('nick', 'localhost', 9191, None, None)],
            },
            'instance_1_hostport': {
                'config': {'instances': ['nick@host1:8765']},
                'calls': [call('nick', 'host1', 8765, None, None)],
            },
            'instance_2': {
                'config': {'instances': [
                    'foo@hostX',
                    'bar@:1000/pass',
                    'unix:/var/run/redis/myhost.sock:1/pass'
                ]},
                'calls': [
                    call('foo', 'hostX', 6379, None, None),
                    call('bar', 'localhost', 1000, None, 'pass'),
                    call('myhost', 'localhost', 6379,
                         '/var/run/redis/myhost.sock', 'pass'),
                ],
            },
            'old_and_new': {
                'config': {
                    'host': 'myhost',
                    'port': 1234,
                    'instances': [
                        'foo@hostX',
                        'bar@:1000',
                        'hostonly',
                        ':1234'
                    ]
                },
                'calls': [
                    call('foo', 'hostX', 6379, None, None),
                    call('bar', 'localhost', 1000, None, None),
                    call('6379', 'hostonly', 6379, None, None),
                    call('1234', 'localhost', 1234, None, None),
                ],
            },
        }

        for testname, data in testcases.items():
            config = get_collector_config('RedisCollector', data['config'])

            collector = RedisCollector(config, None)

            mock = Mock(return_value={}, name=testname)
            patch_c = patch.object(RedisCollector, 'collect_instance', mock)

            patch_c.start()
            collector.collect()
            patch_c.stop()

            expected_call_count = len(data['calls'])
            self.assertEqual(mock.call_count, expected_call_count,
                             msg='[%s] mock.calls=%d != expected_calls=%d' %
                             (testname, mock.call_count, expected_call_count))
            for exp_call in data['calls']:
                # Test expected calls 1 by 1,
                # because self.instances is a dict (=random order)
                mock.assert_has_calls(exp_call)
Exemplo n.º 11
0
    def test_key_naming_when_using_instances(self, publish_mock):

        config_data = {
            'instances': [
                'nick1@host1:1111', 'nick2@:2222', 'nick3@host3',
                'nick4@host4:3333/@password', 'bla'
            ]
        }
        get_info_data = {
            'role': 'slave',
            'total_connections_received': 200,
            'total_commands_processed': 100,
        }
        expected_calls = [
            call('nick1.process.connections_received',
                 200,
                 precision=0,
                 metric_type='GAUGE'),
            call('nick1.process.commands_processed',
                 100,
                 precision=0,
                 metric_type='GAUGE'),
            call('nick1.replication.master',
                 0,
                 precision=0,
                 metric_type='GAUGE'),
            call('nick2.process.connections_received',
                 200,
                 precision=0,
                 metric_type='GAUGE'),
            call('nick2.process.commands_processed',
                 100,
                 precision=0,
                 metric_type='GAUGE'),
            call('nick2.replication.master',
                 0,
                 precision=0,
                 metric_type='GAUGE'),
            call('nick3.process.connections_received',
                 200,
                 precision=0,
                 metric_type='GAUGE'),
            call('nick3.process.commands_processed',
                 100,
                 precision=0,
                 metric_type='GAUGE'),
            call('nick3.replication.master',
                 0,
                 precision=0,
                 metric_type='GAUGE'),
            call('nick4.process.connections_received',
                 200,
                 precision=0,
                 metric_type='GAUGE'),
            call('nick4.process.commands_processed',
                 100,
                 precision=0,
                 metric_type='GAUGE'),
            call('nick4.replication.master',
                 0,
                 precision=0,
                 metric_type='GAUGE'),
            call('6379.process.connections_received',
                 200,
                 precision=0,
                 metric_type='GAUGE'),
            call('6379.process.commands_processed',
                 100,
                 precision=0,
                 metric_type='GAUGE'),
            call('6379.replication.master',
                 0,
                 precision=0,
                 metric_type='GAUGE'),
        ]

        config = get_collector_config('RedisCollector', config_data)
        collector = RedisCollector(config, None)

        patch_c = patch.object(RedisCollector, '_get_info',
                               Mock(return_value=get_info_data))

        patch_c.start()
        collector.collect()
        patch_c.stop()

        self.assertEqual(publish_mock.call_count, len(expected_calls))
        publish_mock.assert_has_calls(expected_calls, any_order=True)
Exemplo n.º 12
0
    def setUp(self):
        config = get_collector_config("RedisCollector", {"interval": "1", "databases": 1})

        self.collector = RedisCollector(config, None)
Exemplo n.º 13
0
class TestRedisCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config("RedisCollector", {"interval": "1", "databases": 1})

        self.collector = RedisCollector(config, None)

    @patch.object(Collector, "publish")
    def test_real_data(self, publish_mock):

        data_1 = {
            "pubsub_channels": 0,
            "used_memory_peak_human": "700.71K",
            "bgrewriteaof_in_progress": 0,
            "connected_slaves": 0,
            "uptime_in_days": 0,
            "multiplexing_api": "epoll",
            "lru_clock": 954113,
            "last_save_time": 1351718385,
            "redis_version": "2.4.10",
            "redis_git_sha1": 0,
            "gcc_version": "4.4.6",
            "connected_clients": 1,
            "keyspace_misses": 0,
            "used_memory": 726144,
            "vm_enabled": 0,
            "used_cpu_user_children": "0.00",
            "used_memory_peak": 717528,
            "role": "master",
            "total_commands_processed": 1,
            "latest_fork_usec": 0,
            "loading": 0,
            "used_memory_rss": 7254016,
            "total_connections_received": 1,
            "pubsub_patterns": 0,
            "aof_enabled": 0,
            "used_cpu_sys": "0.02",
            "used_memory_human": "709.12K",
            "used_cpu_sys_children": "0.00",
            "blocked_clients": 0,
            "used_cpu_user": "******",
            "client_biggest_input_buf": 0,
            "arch_bits": 64,
            "mem_fragmentation_ratio": "9.99",
            "expired_keys": 0,
            "evicted_keys": 0,
            "bgsave_in_progress": 0,
            "client_longest_output_list": 0,
            "mem_allocator": "jemalloc-2.2.5",
            "process_id": 3020,
            "uptime_in_seconds": 32,
            "changes_since_last_save": 0,
            "redis_git_dirty": 0,
            "keyspace_hits": 0,
        }
        data_2 = {
            "pubsub_channels": 1,
            "used_memory_peak_human": "1700.71K",
            "bgrewriteaof_in_progress": 4,
            "connected_slaves": 2,
            "uptime_in_days": 1,
            "multiplexing_api": "epoll",
            "lru_clock": 5954113,
            "last_save_time": 51351718385,
            "redis_version": "2.4.10",
            "redis_git_sha1": 0,
            "gcc_version": "4.4.6",
            "connected_clients": 100,
            "keyspace_misses": 670,
            "used_memory": 1726144,
            "vm_enabled": 0,
            "used_cpu_user_children": "2.00",
            "used_memory_peak": 1717528,
            "role": "master",
            "total_commands_processed": 19764,
            "latest_fork_usec": 8,
            "loading": 0,
            "used_memory_rss": 17254016,
            "total_connections_received": 18764,
            "pubsub_patterns": 0,
            "aof_enabled": 0,
            "used_cpu_sys": "0.05",
            "used_memory_human": "1709.12K",
            "used_cpu_sys_children": "0.09",
            "blocked_clients": 8,
            "used_cpu_user": "******",
            "client_biggest_input_buf": 40,
            "arch_bits": 64,
            "mem_fragmentation_ratio": "0.99",
            "expired_keys": 0,
            "evicted_keys": 0,
            "bgsave_in_progress": 0,
            "client_longest_output_list": 0,
            "mem_allocator": "jemalloc-2.2.5",
            "process_id": 3020,
            "uptime_in_seconds": 95732,
            "changes_since_last_save": 759,
            "redis_git_dirty": 0,
            "keyspace_hits": 5700,
        }

        with patch.object(RedisCollector, "_get_info", Mock(return_value=data_1)):
            with patch("time.time", Mock(return_value=10)):
                self.collector.collect()

        self.assertPublishedMany(publish_mock, {})

        with patch.object(RedisCollector, "_get_info", Mock(return_value=data_2)):
            with patch("time.time", Mock(return_value=20)):
                self.collector.collect()

        metrics = {
            "6379.process.uptime": 95732,
            "6379.pubsub.channels": 1,
            "6379.slaves.connected": 2,
            "6379.process.connections_received": 18764,
            "6379.clients.longest_output_list": 0,
            "6379.process.commands_processed": 19764,
            "6379.last_save.changes_since": 759,
            "6379.memory.external_view": 17254016,
            "6379.memory.fragmentation_ratio": 0.99,
            "6379.last_save.time": 51351718385,
            "6379.clients.connected": 100,
            "6379.clients.blocked": 8,
            "6379.pubsub.patterns": 0,
            "6379.cpu.parent.user": 0.09,
            "6379.last_save.time_since": -51351718365,
            "6379.memory.internal_view": 1726144,
            "6379.cpu.parent.sys": 0.05,
            "6379.keyspace.misses": 670,
            "6379.keys.expired": 0,
            "6379.keys.evicted": 0,
            "6379.keyspace.hits": 5700,
        }

        self.assertPublishedMany(publish_mock, metrics)

        self.setDocExample(
            collector=self.collector.__class__.__name__, metrics=metrics, defaultpath=self.collector.config["path"]
        )
Exemplo n.º 14
0
class TestRedisCollector(CollectorTestCase):
    def setUp(self):
        config = get_collector_config('RedisCollector', {
            'interval': '1',
            'databases': 1,
        })

        self.collector = RedisCollector(config, None)

    @run_only_if_redis_is_available
    @patch.object(Collector, 'publish')
    def test_real_data(self, publish_mock):

        data_1 = {
            'pubsub_channels': 0,
            'used_memory_peak_human': '700.71K',
            'bgrewriteaof_in_progress': 0,
            'connected_slaves': 0,
            'uptime_in_days': 0,
            'multiplexing_api': 'epoll',
            'lru_clock': 954113,
            'last_save_time': 1351718385,
            'redis_version': '2.4.10',
            'redis_git_sha1': 0,
            'gcc_version': '4.4.6',
            'connected_clients': 1,
            'keyspace_misses': 0,
            'used_memory': 726144,
            'vm_enabled': 0,
            'used_cpu_user_children': '0.00',
            'used_memory_peak': 717528,
            'role': 'master',
            'total_commands_processed': 1,
            'latest_fork_usec': 0,
            'loading': 0,
            'used_memory_rss': 7254016,
            'total_connections_received': 1,
            'pubsub_patterns': 0,
            'aof_enabled': 0,
            'used_cpu_sys': '0.02',
            'used_memory_human': '709.12K',
            'used_cpu_sys_children': '0.00',
            'blocked_clients': 0,
            'used_cpu_user': '******',
            'client_biggest_input_buf': 0,
            'arch_bits': 64,
            'mem_fragmentation_ratio': '9.99',
            'expired_keys': 0,
            'evicted_keys': 0,
            'bgsave_in_progress': 0,
            'client_longest_output_list': 0,
            'mem_allocator': 'jemalloc-2.2.5',
            'process_id': 3020,
            'uptime_in_seconds': 32,
            'changes_since_last_save': 0,
            'redis_git_dirty': 0,
            'keyspace_hits': 0
        }
        data_2 = {
            'pubsub_channels': 1,
            'used_memory_peak_human': '1700.71K',
            'bgrewriteaof_in_progress': 4,
            'connected_slaves': 2,
            'uptime_in_days': 1,
            'multiplexing_api': 'epoll',
            'lru_clock': 5954113,
            'last_save_time': 51351718385,
            'redis_version': '2.4.10',
            'redis_git_sha1': 0,
            'gcc_version': '4.4.6',
            'connected_clients': 100,
            'keyspace_misses': 670,
            'used_memory': 1726144,
            'vm_enabled': 0,
            'used_cpu_user_children': '2.00',
            'used_memory_peak': 1717528,
            'role': 'master',
            'total_commands_processed': 19764,
            'latest_fork_usec': 8,
            'loading': 0,
            'used_memory_rss': 17254016,
            'total_connections_received': 18764,
            'pubsub_patterns': 0,
            'aof_enabled': 0,
            'used_cpu_sys': '0.05',
            'used_memory_human': '1709.12K',
            'used_cpu_sys_children': '0.09',
            'blocked_clients': 8,
            'used_cpu_user': '******',
            'client_biggest_input_buf': 40,
            'arch_bits': 64,
            'mem_fragmentation_ratio': '0.99',
            'expired_keys': 0,
            'evicted_keys': 0,
            'bgsave_in_progress': 0,
            'client_longest_output_list': 0,
            'mem_allocator': 'jemalloc-2.2.5',
            'process_id': 3020,
            'uptime_in_seconds': 95732,
            'changes_since_last_save': 759,
            'redis_git_dirty': 0,
            'keyspace_hits': 5700
        }

        with patch.object(RedisCollector, '_get_info',
                          Mock(return_value=data_1)):
            with patch('time.time', Mock(return_value=10)):
                self.collector.collect()

        self.assertPublishedMany(publish_mock, {})

        with patch.object(RedisCollector, '_get_info',
                          Mock(return_value=data_2)):
            with patch('time.time', Mock(return_value=20)):
                self.collector.collect()

        metrics = {
            '6379.process.uptime': 95732,
            '6379.pubsub.channels': 1,
            '6379.slaves.connected': 2,
            '6379.process.connections_received': 18764,
            '6379.clients.longest_output_list': 0,
            '6379.process.commands_processed': 19764,
            '6379.last_save.changes_since': 759,
            '6379.memory.external_view': 17254016,
            '6379.memory.fragmentation_ratio': 0.99,
            '6379.last_save.time': 51351718385,
            '6379.clients.connected': 100,
            '6379.clients.blocked': 8,
            '6379.pubsub.patterns': 0,
            '6379.cpu.parent.user': 0.09,
            '6379.last_save.time_since': -51351718365,
            '6379.memory.internal_view': 1726144,
            '6379.cpu.parent.sys': 0.05,
            '6379.keyspace.misses': 670,
            '6379.keys.expired': 0,
            '6379.keys.evicted': 0,
            '6379.keyspace.hits': 5700,
        }

        self.assertPublishedMany(publish_mock, metrics)

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