Python Default.registerLogModule Beispiele

Beispiel #1

Datei: minimal.py Projekt: bugcy013/experiments

        Actor.__init__(self, name)
        self.createQueue("inbox")
        self.registerConsumer(self.consume, self.queuepool.inbox)

    def consume(self, event):
        self.logging.info("Received event.")
        sleep(0.5)


# gevent_profiler.set_stats_output('my-stats.txt')
# gevent_profiler.set_summary_output('my-summary.txt')
# gevent_profiler.set_trace_output('my-trace.txt')

# gevent_profiler.attach()

#Initialize router
router = Default(interval=1, rescue=False, uuid=False)
router.registerLogModule(STDOUT, "logs_out")
router.registerMetricModule(STDOUT, "metrics_out")

router.register(Input, "input")
router.register(Output, "output")

router.connect("input.outbox", "output.inbox")

#start
router.start()
router.block()

# gevent_profiler.detach()

Beispiel #2

Datei: broker_test.py Projekt: smetj/experiments

                        'broker_exchange': "",
                        'broker_key': "test",
                        'broker_tag': "test"
                    },
                    "data": str(x)
                })
                x += 1
                looper += 1
            except:
                break


#Initialize router
router = Default(interval=1, rescue=False, uuid=False)
router.registerLogModule((LogFormatFilter, "logformatfilter", 0),
                         "inbox",
                         debug=False)
router.registerMetricModule((Graphite, "graphite", 0), "inbox")
router.register((STDOUT, "stdout", 0))
router.register((Null, "null", 0))
router.connect("logformatfilter.outbox", "stdout.inbox")
router.connect("graphite.outbox", "null.inbox")

#Feedback loop
router.register((Header, "header", 0),
                header={
                    'broker_exchange': "",
                    'broker_key': "test",
                    'broker_tag': "test"
                })
router.register((AMQP, "broker", 0), host="sandbox", consume_queue="test")

Beispiel #3

Datei: test_wb_minimal_thread.py Projekt: smetj/experiments

        thread.setDaemon(True)
        thread.start()

    def run(self):
        while self.loop():
            try:
                self.queuepool.outbox.put({"header": {}, "data": "X"})
            except:
                self.queuepool.outbox.waitUntilPutAllowed()


#Initialize router
router = Default(interval=1, rescue=False, uuid=False)

#Organize log flow
router.registerLogModule((Filter, "logformatfilter", 0))
router.register((STDOUT, "stdout", 0))
router.connect("logformatfilter.outbox", "stdout.inbox")

#Organize metric flow
router.registerMetricModule((Graphite, "graphite", 0))
router.register((TCP, 'graphite_out', 0),
                host="graphite-001",
                port=2013,
                stream=True)
router.connect("graphite.outbox", "graphite_out.inbox")

#Organize data flow
router.register((XGenerator, "xgenerator", 0))
router.register((Null, "null", 0))
router.register((STDOUT, "events_stdout", 0))

Beispiel #4

Datei: funnel_test.py Projekt: bugcy013/experiments

        x=0
        looper=0
        while self.loop():
            try:
                if looper == 100:
                    looper=0
                    sleep()
                self.queuepool.outbox.put({"header":{},"data":str(x)})
                x+=1
                looper+=1
            except:
                break


router = Default(interval=1, rescue=False, uuid=False)
router.registerLogModule((LogFormatFilter, "logformatfilter", 0), "inbox", debug=False)
router.registerMetricModule((Graphite, "graphite", 0), "inbox")

router.register((STDOUT, "stdout_logs", 0))
router.register((STDOUT, "stdout", 0))
router.register((NumberGenerator, "numbergenerator1", 0))
router.register((NumberGenerator, "numbergenerator2", 0))
router.register((Funnel, "funnel", 0))

#logs & metrics
router.connect("logformatfilter.outbox", "stdout_logs.inbox")

#events
router.connect("numbergenerator1.outbox", "funnel.one")
router.connect("numbergenerator2.outbox", "funnel.two")
router.connect("funnel.outbox", "stdout.inbox")

Beispiel #5

Datei: test_wb_output_mqtt.py Projekt: smetj/experiments

from wishbone.module import Null
from wishbone.module import LogLevelFilter
from wishbone.module import STDOUT
from wishbone.module import Header
from wishbone.module import TestEvent
from wishbone.module import Fanout

from wb_output_mqtt import MQTT
from gevent import sleep, spawn

#Initialize router
router = Default(interval=1, rescue=False, uuid=False)

#organize eventstream
router.registerMetricModule(Null, "null")

#organize logstream
router.registerLogModule(LogLevelFilter, "loglevelfilter")
router.register(STDOUT, "stdout_logs")
router.connect("loglevelfilter.outbox", "stdout_logs.inbox")

router.register(TestEvent, "testevent", interval=0)
router.register(Header, "header", header={"mqtt": {"topic": "my/topic"}})
router.register(MQTT, "mqtt", client_id="blah", host="127.0.0.1")

router.connect("testevent.outbox", "header.inbox")
router.connect("header.outbox", "mqtt.inbox")

#start
router.start()
router.block()

Beispiel #6

Datei: test_wb_minimal.py Projekt: bugcy013/experiments

class Output(Actor):
    def __init__(self, name, size=1):
        Actor.__init__(self, name, setupbasic=False)
        self.createQueue("inbox", size)
        self.registerConsumer(self.consume, self.queuepool.inbox)

    def consume(self, event):
        self.logging.info("Received event.")
        sleep(5)

#Initialize router
router = Default(interval=1, rescue=False, uuid=False)

#Organize log flow
router.registerLogModule(LogLevelFilter, "loglevelfilter")
router.register(STDOUT, "stdout")
router.connect("loglevelfilter.outbox", "stdout.inbox")

#Organize metric flow
router.registerMetricModule(Null, "null")

#Organize data flow
router.register(Input, "input")
router.register(Forwarder, "forwarder")
router.register(Output, "output")

router.connect("input.outbox", "forwarder.inbox")
router.connect("forwarder.outbox", "output.inbox")

#start

Beispiel #7

Datei: test_wb_input_amqp.py Projekt: bugcy013/experiments

class Output(Actor):
    def __init__(self, name, size=1000):
        Actor.__init__(self, name, setupbasic=False)
        self.createQueue("inbox", size)
        self.registerConsumer(self.consume, self.queuepool.inbox)

    def consume(self, event):
        pass
        #self.logging.info("Received event.")
        #sleep(0.005)

#Initialize router
router = Default(interval=1, rescue=False, uuid=False)

#Organize log flow
router.registerLogModule(LogLevelFilter, "loglevelfilter", max_level=7)
router.register(STDOUT, "stdout")
router.connect("loglevelfilter.outbox", "stdout.inbox")

#Organize metric flow
router.registerMetricModule(Null, "null")
# router.registerMetricModule(Graphite, "graphite")
# router.register(TCP, "graphite_transport", host="graphite-001", port=2013)
# router.connect("graphite.outbox", "graphite_transport.inbox")

#Organize data flow
router.register(AMQP, "amqp", host="localhost", queue="test", prefetch_count=100, no_ack=True)
router.register(Forwarder, "forwarder")
router.register(Output, "output")

router.connect("amqp.outbox", "forwarder.inbox")

Beispiel #8

        Actor.__init__(self, name)
        self.createQueue("inbox")
        self.registerConsumer(self.consume, self.queuepool.inbox)

    def consume(self, event):
        self.logging.info("Received event.")
        sleep(0.5)


# gevent_profiler.set_stats_output('my-stats.txt')
# gevent_profiler.set_summary_output('my-summary.txt')
# gevent_profiler.set_trace_output('my-trace.txt')

# gevent_profiler.attach()

#Initialize router
router = Default(interval=1, rescue=False, uuid=False)
router.registerLogModule(STDOUT, "logs_out")
router.registerMetricModule(STDOUT, "metrics_out")

router.register(Input, "input")
router.register(Output, "output")

router.connect("input.outbox", "output.inbox")

#start
router.start()
router.block()

# gevent_profiler.detach()

Beispiel #9

Datei: test_wb_minimal.py Projekt: bugcy013/experiments

        Actor.__init__(self, name, setupbasic=False)
        self.createQueue("outbox")
        spawn(self.generate)

    def generate(self):
        context_switch_loop = self.getContextSwitcher(100, self.loop)
        while context_switch_loop.do():
            try:
                self.queuepool.outbox.put({"header":{},"data":"X"})
            except:
                break

#Initialize router
router = Default(interval=1, rescue=False, uuid=False)

#Organize log flow
router.registerLogModule(STDOUT, "stdout")

#Organize metric flow
router.registerMetricModule(Graphite, "graphite")
router.register(TCP, 'graphite_out', host="graphite-001", port=2013)
router.connect("graphite.outbox", "graphite_out.inbox")

#Organize data flow
router.register(XGenerator, "xgenerator")
router.register(Null, "null")
router.connect("xgenerator.outbox", "null.inbox")

#start
router.start()
router.block()

Beispiel #10

Datei: test_wb_output_amqp.py Projekt: smetj/experiments

from wishbone.module import Graphite

from wb_output_amqp import AMQP
from wb_output_tcp import TCP

#Initialize router
router = Default(interval=1, rescue=False, uuid=False, throttle=True)

#organize metricstream
router.registerMetricModule(Null, "null")
#router.registerMetricModule(Graphite, "graphite")
#router.register(TCP, "graphite_transport", host="graphite-001", port=2013)
#router.connect("graphite.outbox", "graphite_transport.inbox")

#organize logstream
router.registerLogModule(LogLevelFilter, "loglevelfilter", max_level=7)
router.register(STDOUT, "stdout_logs")
router.connect("loglevelfilter.outbox", "stdout_logs.inbox")

#router.register(TestEvent, "testevent", interval=1)
router.register(TestEvent, "testevent", interval=0.5)
router.register(Header,
                "header",
                key="amqp",
                header={
                    'broker_exchange': "",
                    'broker_key': "test",
                    'broker_tag': "test"
                })
router.register(STDOUT, "stdout", complete=True)
router.register(

Beispiel #11

Datei: test_wb_minimal.py Projekt: smetj/experiments

        self.createQueue("outbox")
        spawn(self.generate)

    def generate(self):
        context_switch_loop = self.getContextSwitcher(100, self.loop)
        while context_switch_loop.do():
            try:
                self.queuepool.outbox.put({"header": {}, "data": "X"})
            except:
                break


#Initialize router
router = Default(interval=1, rescue=False, uuid=False)

#Organize log flow
router.registerLogModule(STDOUT, "stdout")

#Organize metric flow
router.registerMetricModule(Graphite, "graphite")
router.register(TCP, 'graphite_out', host="graphite-001", port=2013)
router.connect("graphite.outbox", "graphite_out.inbox")

#Organize data flow
router.register(XGenerator, "xgenerator")
router.register(Null, "null")
router.connect("xgenerator.outbox", "null.inbox")

#start
router.start()
router.block()