| | |
| | |
| |
|
| | from __future__ import absolute_import, print_function |
| |
|
| | import argparse |
| | import logging |
| | import pprint |
| | import sys |
| | import threading |
| | import traceback |
| |
|
| | from kafka.vendor.six.moves import range |
| |
|
| | from kafka import KafkaConsumer, KafkaProducer |
| | from test.fixtures import KafkaFixture, ZookeeperFixture |
| |
|
| | logging.basicConfig(level=logging.ERROR) |
| |
|
| |
|
| | def start_brokers(n): |
| | print('Starting {0} {1}-node cluster...'.format(KafkaFixture.kafka_version, n)) |
| | print('-> 1 Zookeeper') |
| | zk = ZookeeperFixture.instance() |
| | print('---> {0}:{1}'.format(zk.host, zk.port)) |
| | print() |
| |
|
| | partitions = min(n, 3) |
| | replicas = min(n, 3) |
| | print('-> {0} Brokers [{1} partitions / {2} replicas]'.format(n, partitions, replicas)) |
| | brokers = [ |
| | KafkaFixture.instance(i, zk, zk_chroot='', |
| | partitions=partitions, replicas=replicas) |
| | for i in range(n) |
| | ] |
| | for broker in brokers: |
| | print('---> {0}:{1}'.format(broker.host, broker.port)) |
| | print() |
| | return brokers |
| |
|
| |
|
| | class ConsumerPerformance(object): |
| |
|
| | @staticmethod |
| | def run(args): |
| | try: |
| | props = {} |
| | for prop in args.consumer_config: |
| | k, v = prop.split('=') |
| | try: |
| | v = int(v) |
| | except ValueError: |
| | pass |
| | if v == 'None': |
| | v = None |
| | props[k] = v |
| |
|
| | if args.brokers: |
| | brokers = start_brokers(args.brokers) |
| | props['bootstrap_servers'] = ['{0}:{1}'.format(broker.host, broker.port) |
| | for broker in brokers] |
| | print('---> bootstrap_servers={0}'.format(props['bootstrap_servers'])) |
| | print() |
| |
|
| | print('-> Producing records') |
| | record = bytes(bytearray(args.record_size)) |
| | producer = KafkaProducer(compression_type=args.fixture_compression, |
| | **props) |
| | for i in range(args.num_records): |
| | producer.send(topic=args.topic, value=record) |
| | producer.flush() |
| | producer.close() |
| | print('-> OK!') |
| | print() |
| |
|
| | print('Initializing Consumer...') |
| | props['auto_offset_reset'] = 'earliest' |
| | if 'consumer_timeout_ms' not in props: |
| | props['consumer_timeout_ms'] = 10000 |
| | props['metrics_sample_window_ms'] = args.stats_interval * 1000 |
| | for k, v in props.items(): |
| | print('---> {0}={1}'.format(k, v)) |
| | consumer = KafkaConsumer(args.topic, **props) |
| | print('---> group_id={0}'.format(consumer.config['group_id'])) |
| | print('---> report stats every {0} secs'.format(args.stats_interval)) |
| | print('---> raw metrics? {0}'.format(args.raw_metrics)) |
| | timer_stop = threading.Event() |
| | timer = StatsReporter(args.stats_interval, consumer, |
| | event=timer_stop, |
| | raw_metrics=args.raw_metrics) |
| | timer.start() |
| | print('-> OK!') |
| | print() |
| |
|
| | records = 0 |
| | for msg in consumer: |
| | records += 1 |
| | if records >= args.num_records: |
| | break |
| | print('Consumed {0} records'.format(records)) |
| |
|
| | timer_stop.set() |
| |
|
| | except Exception: |
| | exc_info = sys.exc_info() |
| | traceback.print_exception(*exc_info) |
| | sys.exit(1) |
| |
|
| |
|
| | class StatsReporter(threading.Thread): |
| | def __init__(self, interval, consumer, event=None, raw_metrics=False): |
| | super(StatsReporter, self).__init__() |
| | self.interval = interval |
| | self.consumer = consumer |
| | self.event = event |
| | self.raw_metrics = raw_metrics |
| |
|
| | def print_stats(self): |
| | metrics = self.consumer.metrics() |
| | if self.raw_metrics: |
| | pprint.pprint(metrics) |
| | else: |
| | print('{records-consumed-rate} records/sec ({bytes-consumed-rate} B/sec),' |
| | ' {fetch-latency-avg} latency,' |
| | ' {fetch-rate} fetch/s,' |
| | ' {fetch-size-avg} fetch size,' |
| | ' {records-lag-max} max record lag,' |
| | ' {records-per-request-avg} records/req' |
| | .format(**metrics['consumer-fetch-manager-metrics'])) |
| |
|
| |
|
| | def print_final(self): |
| | self.print_stats() |
| |
|
| | def run(self): |
| | while self.event and not self.event.wait(self.interval): |
| | self.print_stats() |
| | else: |
| | self.print_final() |
| |
|
| |
|
| | def get_args_parser(): |
| | parser = argparse.ArgumentParser( |
| | description='This tool is used to verify the consumer performance.') |
| |
|
| | parser.add_argument( |
| | '--topic', type=str, |
| | help='Topic for consumer test', |
| | default='kafka-python-benchmark-test') |
| | parser.add_argument( |
| | '--num-records', type=int, |
| | help='number of messages to consume', |
| | default=1000000) |
| | parser.add_argument( |
| | '--record-size', type=int, |
| | help='message size in bytes', |
| | default=100) |
| | parser.add_argument( |
| | '--consumer-config', type=str, nargs='+', default=(), |
| | help='kafka consumer related configuration properties like ' |
| | 'bootstrap_servers,client_id etc..') |
| | parser.add_argument( |
| | '--fixture-compression', type=str, |
| | help='specify a compression type for use with broker fixtures / producer') |
| | parser.add_argument( |
| | '--brokers', type=int, |
| | help='Number of kafka brokers to start', |
| | default=0) |
| | parser.add_argument( |
| | '--stats-interval', type=int, |
| | help='Interval in seconds for stats reporting to console', |
| | default=5) |
| | parser.add_argument( |
| | '--raw-metrics', action='store_true', |
| | help='Enable this flag to print full metrics dict on each interval') |
| | return parser |
| |
|
| |
|
| | if __name__ == '__main__': |
| | args = get_args_parser().parse_args() |
| | ConsumerPerformance.run(args) |
| |
|
