def make_app(global_config, **settings): """Paste entry point: return a configured WSGI application.""" config = Configurator(settings=settings) keystore = {} for setting, value in settings.iteritems(): key_prefix = "key." if setting.startswith(key_prefix): key_name = setting[len(key_prefix):] key_secret = base64.b64decode(value) keystore[key_name] = key_secret allowed_origins = [ x.strip() for x in settings["allowed_origins"].split(",") if x.strip() ] metrics_client = baseplate.make_metrics_client(settings) event_queue = MessageQueue("/events", max_messages=MAXIMUM_QUEUE_LENGTH, max_message_size=MAXIMUM_EVENT_SIZE) error_queue = MessageQueue("/errors", max_messages=MAXIMUM_QUEUE_LENGTH, max_message_size=MAXIMUM_EVENT_SIZE) collector = EventCollector(keystore, metrics_client, event_queue, error_queue, allowed_origins) config.add_route("v1", "/v1", request_method="POST") config.add_route("v1_options", "/v1", request_method="OPTIONS") config.add_view(collector.process_request, route_name="v1") config.add_view(collector.check_cors, route_name="v1_options") config.add_route("health", "/health") config.add_view(health_check, route_name="health", renderer="json") return config.make_wsgi_app()
def setUp(self): # we create the queues before the actual code can so that we can # override the max sizes to use these numbers which are safe to use # without extra privileges on linux self.events_queue = MessageQueue(name="/events", max_messages=10, max_message_size=8192) self.errors_queue = MessageQueue(name="/errors", max_messages=10, max_message_size=8192) class MockDatetime(datetime.datetime): @classmethod def utcnow(cls): return datetime.datetime(2015, 11, 17, 12, 34, 56) datetime.datetime = MockDatetime app = collector.make_app(global_config={}, **{ "key.TestKey1": "dGVzdA==", "msgq.events": "0xcafe", "msgq.errors": "0xdecaf", "allowed_origins": "example.com", "metrics.namespace": "eventcollector", "metrics.endpoint": "", }) self.test_app = webtest.TestApp(app)
def __init__(self, name, event_serializer=serialize_v1_event): self.queue = MessageQueue( "/events-" + name, max_messages=MAX_QUEUE_SIZE, max_message_size=MAX_EVENT_SIZE, ) self.serialize_event = event_serializer
def test_put_zero_timeout(self): message_queue = MessageQueue(self.qname, max_messages=1, max_message_size=1) with contextlib.closing(message_queue) as mq: mq.put(b"x", timeout=0) message = mq.get() self.assertEqual(message, b"x")
def test_put_full_zero_timeout(self): message_queue = MessageQueue(self.qname, max_messages=1, max_message_size=1) with contextlib.closing(message_queue) as mq: mq.put(b"1", timeout=0) with self.assertRaises(TimedOutError): mq.put(b"2", timeout=0)
def test_create_queue(self): message_queue = MessageQueue(self.qname, max_messages=1, max_message_size=1) with contextlib.closing(message_queue) as mq: self.assertEqual(mq.queue.max_messages, 1) self.assertEqual(mq.queue.max_message_size, 1)
def publish_traces(): arg_parser = argparse.ArgumentParser() arg_parser.add_argument("config_file", type=argparse.FileType("r"), help="path to a configuration file") arg_parser.add_argument("--queue-name", default="main", help="name of trace queue / publisher config (default: main)") arg_parser.add_argument("--debug", default=False, action="store_true", help="enable debug logging") arg_parser.add_argument("--app-name", default="main", metavar="NAME", help="name of app to load from config_file (default: main)") args = arg_parser.parse_args() if args.debug: level = logging.DEBUG else: level = logging.WARNING logging.basicConfig(level=level) config_parser = configparser.RawConfigParser() config_parser.readfp(args.config_file) publisher_raw_cfg = dict(config_parser.items("trace-publisher:" + args.queue_name)) publisher_cfg = config.parse_config(publisher_raw_cfg, { "zipkin_api_url": config.Endpoint, "post_timeout": config.Optional(config.Integer, POST_TIMEOUT_DEFAULT), "max_batch_size": config.Optional(config.Integer, MAX_BATCH_SIZE_DEFAULT), "retry_limit": config.Optional(config.Integer, RETRY_LIMIT_DEFAULT), }) trace_queue = MessageQueue( "/traces-" + args.queue_name, max_messages=MAX_QUEUE_SIZE, max_message_size=MAX_SPAN_SIZE, ) # pylint: disable=maybe-no-member inner_batch = TraceBatch(max_size=publisher_cfg.max_batch_size) batcher = TimeLimitedBatch(inner_batch, MAX_BATCH_AGE) metrics_client = metrics_client_from_config(publisher_raw_cfg) publisher = ZipkinPublisher( publisher_cfg.zipkin_api_url.address, metrics_client, post_timeout=publisher_cfg.post_timeout, ) while True: try: message = trace_queue.get(timeout=.2) except TimedOutError: message = None try: batcher.add(message) except BatchFull: serialized = batcher.serialize() publisher.publish(serialized) batcher.reset() batcher.add(message)
def test_get_timeout(self): message_queue = MessageQueue(self.qname, max_messages=1, max_message_size=1) with contextlib.closing(message_queue) as mq: start = time.time() with self.assertRaises(TimedOutError): mq.get(timeout=0.1) elapsed = time.time() - start self.assertAlmostEqual(elapsed, 0.1, places=2)
def main(): """Run a consumer. Two environment variables are expected: * CONFIG_URI: A PasteDeploy URI pointing at the configuration for the application. * QUEUE: The name of the queue to consume (currently one of "events" or "errors"). """ config_uri = os.environ["CONFIG_URI"] config = paste.deploy.loadwsgi.appconfig(config_uri) logging.config.fileConfig(config["__file__"]) queue_name = os.environ["QUEUE"] queue = MessageQueue("/" + queue_name, max_messages=MAXIMUM_QUEUE_LENGTH, max_message_size=MAXIMUM_EVENT_SIZE) metrics_client = baseplate.make_metrics_client(config) topic_name = config["topic." + queue_name] producer_options = { "codec": CODEC_GZIP, "batch_send_every_n": 20, "batch_send_every_t": 0.01, # 10 milliseconds } while True: try: kafka_client = KafkaClient(config["kafka_brokers"]) kafka_producer = SimpleProducer(kafka_client, **producer_options) except KafkaError as exc: _LOG.warning("could not connect: %s", exc) metrics_client.counter("injector.connection_error").increment() time.sleep(_RETRY_DELAY) continue while True: message = queue.get() for retry in itertools.count(): try: kafka_producer.send_messages(topic_name, message) except KafkaError as exc: _LOG.warning("failed to send message: %s", exc) metrics_client.counter("injector.error").increment() time.sleep(_RETRY_DELAY) else: metrics_client.counter("collected.injector").increment() break kafka_producer.stop()
def __init__(self, queue_name): self.queue = MessageQueue( "/traces-" + queue_name, max_messages=MAX_SIDECAR_QUEUE_SIZE, max_message_size=MAX_SIDECAR_MESSAGE_SIZE, )
def __init__(self, name): self.queue = MessageQueue( "/events-" + name, max_messages=MAX_QUEUE_SIZE, max_message_size=MAX_EVENT_SIZE, )
# consumer.py from baseplate.message_queue import MessageQueue mq = MessageQueue("/baseplate-testing", max_messages=1, max_message_size=1) # Unless a `timeout` kwarg is passed, this will block until # we can pop a message from the queue. message = mq.get() print("Get Message: %s" % message)
import time # producer.py from baseplate.message_queue import MessageQueue # If the queue doesn't already exist, we'll create it. mq = MessageQueue("/test4", max_messages=5, max_message_size=3) i = 1 while True: message = str(i) mq.put(message) print("Put Message: %s" % message) i += 1 #time.sleep(1)
def main(): """Run a consumer. Two environment variables are expected: * CONFIG_URI: A PasteDeploy URI pointing at the configuration for the application. * QUEUE: The name of the queue to consume (currently one of "events" or "errors"). """ config_uri = os.environ["CONFIG_URI"] config = paste.deploy.loadwsgi.appconfig(config_uri) logging.config.fileConfig(config["__file__"]) queue_name = os.environ["QUEUE"] queue = MessageQueue( "/" + queue_name, max_messages=MAXIMUM_QUEUE_LENGTH[queue_name], max_message_size=MAXIMUM_MESSAGE_SIZE[queue_name], ) metrics_client = baseplate.make_metrics_client(config) topic_name = config["topic." + queue_name] # Details at http://kafka-python.readthedocs.org/en/1.0.2/apidoc/KafkaProducer.html producer_options = { "compression_type": 'gzip', "batch_size": 20, "linger_ms": 10, "retries": int(config["kafka_retries"]), "retry_backoff_ms": _RETRY_DELAY_SECS * 1000 } def producer_error_cb(msg, queue): def requeue_msg(exc): _LOG.warning("failed to send message=%s due to error=%s", msg, exc) metrics_client.counter("injector.error").increment() queue.put(msg) return requeue_msg def producer_success_cb(success_val): metrics_client.counter("collected.injector").increment() while True: try: kafka_brokers = [ broker.strip() for broker in config['kafka_brokers'].split(',') ] kafka_producer = KafkaProducer(bootstrap_servers=kafka_brokers, **producer_options) except KafkaError as exc: _LOG.warning("could not connect: %s", exc) metrics_client.counter("injector.connection_error").increment() time.sleep(_RETRY_DELAY_SECS) continue process_queue(queue, topic_name, kafka_producer, producer_success_cb, producer_error_cb, metrics_client=metrics_client) kafka_producer.stop()
def publish_events(): arg_parser = argparse.ArgumentParser() arg_parser.add_argument("config_file", type=argparse.FileType("r"), help="path to a configuration file") arg_parser.add_argument( "--queue-name", default="main", help="name of event queue / publisher config (default: main)", ) arg_parser.add_argument("--debug", default=False, action="store_true", help="enable debug logging") args = arg_parser.parse_args() if args.debug: level = logging.DEBUG else: level = logging.WARNING logging.basicConfig(level=level) config_parser = configparser.RawConfigParser() config_parser.readfp(args.config_file) # pylint: disable=deprecated-method raw_config = dict(config_parser.items("event-publisher:" + args.queue_name)) cfg = config.parse_config( raw_config, { "collector": { "hostname": config.String, "version": config.Optional(config.Integer, default=1), }, "key": { "name": config.String, "secret": config.Base64 }, }, ) metrics_client = metrics_client_from_config(raw_config) event_queue = MessageQueue("/events-" + args.queue_name, max_messages=MAX_QUEUE_SIZE, max_message_size=MAX_EVENT_SIZE) # pylint: disable=maybe-no-member serializer = SERIALIZER_BY_VERSION[cfg.collector.version]() batcher = TimeLimitedBatch(serializer, MAX_BATCH_AGE) publisher = BatchPublisher(metrics_client, cfg) while True: try: message = event_queue.get(timeout=0.2) except TimedOutError: message = None try: batcher.add(message) except BatchFull: serialized = batcher.serialize() publisher.publish(serialized) batcher.reset() batcher.add(message)