def getLogger(): """Get current logger.""" if not CloudLogger.LOGGER: CloudLogger.LOGGER = logging.getLogger('python-logstash-logger') CloudLogger.LOGGER.setLevel(logging.INFO) CloudLogger.LOGGER.addHandler(logstash.LogstashHandler(CONFIG_LOGGING["logstash_host"], CONFIG_LOGGING["logstash_port"], version=1)) return CloudLogger.LOGGER
def _init_plugin(self): if not self.disabled: self.logger = logging.getLogger('python-logstash-logger') self.logger.setLevel(logging.DEBUG) self.handler = logstash.LogstashHandler(self.ls_server, self.ls_port, version=1, message_type=self.ls_type) self.logger.addHandler(self.handler) self.hostname = socket.gethostname() self.session = str(uuid.uuid4()) self.errors = 0 self.base_data = {'session': self.session, 'host': self.hostname} if self.ls_pre_command is not None: self.base_data['ansible_pre_command_output'] = os.popen( self.ls_pre_command).read() if self._options is not None: self.base_data['ansible_checkmode'] = self._options.check self.base_data['ansible_tags'] = self._options.tags self.base_data['ansible_skip_tags'] = self._options.skip_tags self.base_data['inventory'] = self._options.inventory
def main(): #setup ELK logging ELK_logger = logging.getLogger('python-logstash-logger') ELK_logger.setLevel(logging.INFO) formatter = logging.Formatter('%(asctime)s:%(levelname)s:%(message)s') ELK_logger.addHandler(logstash.LogstashHandler(host, port, version=1)) #run infinite loop while True: operation = getOperation(ELK_logger) if operation == '0': extra = { 'test_string': 'Exit', 'test_boolean': True, 'test_dict': {}, 'test_float': 0, 'test_integer': 0, 'test_list': [] } ELK_logger.info('User request to exit.', extra=extra) break num1 = getNumber("Please enter the 1st number:", ELK_logger) num2 = getNumber("Please enter the 2nd number:", ELK_logger) if (operation == '1'): add(num1, num2, ELK_logger) elif (operation == '2'): subtract(num1, num2, ELK_logger) elif (operation == '3'): multiply(num1, num2, ELK_logger) elif (operation == '4'): divide(num1, num2, ELK_logger)
def test_log(self): host = 'localhost' test_logger = logging.getLogger('python-logstash-logger') test_logger.setLevel(logging.INFO) test_logger.addHandler(logstash.LogstashHandler(host, 5044, version=1)) # test_logger.addHandler(logstash.TCPLogstashHandler(host, 5959, version=1)) test_logger.error('python-logstash: test logstash error message.') test_logger.info('python-logstash: test logstash info message.') test_logger.warning('python-logstash: test logstash warning message.') # add extra field to logstash message extra = { 'test_string': 'python version: ' + repr(sys.version_info), 'test_boolean': True, 'test_dict': { 'a': 1, 'b': 'c' }, 'test_float': 1.23, 'test_integer': 123, 'test_list': [1, 2, '3'], } test_logger.info('python-logstash: test extra fields', extra=extra)
def main(): """.""" log = logging.getLogger('logging_spammer') log.setLevel(logging.DEBUG) host_name = socket.gethostname() address = socket.gethostbyname(host_name) print('hostname = {}, address = {}'.format(host_name, address)) # For the host to be resolved the container must be in the same overlay # network as the logstash container. host = 'logstash' if hostname_resolves(host): handler = logstash.LogstashHandler(host, port=5000, version=1) log.addHandler(handler) else: handler = logging.StreamHandler(stream=sys.stdout) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) log.addHandler(handler) start_time = time.time() try: while True: elapsed = time.time() - start_time log.info('hello from %s (%.1f s)', host_name, elapsed) # log.info('hello ...') # log.debug('hello again ...') log.debug('this is a debug message from %s', host_name) time.sleep(random.uniform(0.01, 0.5)) except KeyboardInterrupt: print('Exiting...')
def __init__(self): # Note: use "backtrace" and "diagnose" in production, # Note: backtrace and diagnose will LEAK sensitive data logger.add("backend.log", enqueue=True, rotation="5 MB" # backtrace=True, # diagnose=True ) # handler = logging.handlers.SysLogHandler(address=('localhost', 5000)) # logger.add(handler) logger.add(logstash.LogstashHandler("localhost", 5000, version=1)) # for udp - logstash.LogstashHandler("localhost", 5000, version=1) # for tcp - logstash.TCPLogstashHandler(host, 5959, version=1) # add extra field to logstash message extra = { 'test_string': 'python version: ' + repr(sys.version_info), 'test_boolean': True, 'test_dict': {'a': 1, 'b': 'c'}, 'test_float': 1.23, 'test_integer': 123, 'test_list': [1, 2, '3'], } logger.info('python-logstash: test extra fields{extra}', extra=extra)
def detectQR(image_name): host = '127.0.0.1' test_logger = logging.getLogger() handler = logging.StreamHandler() formatter = LogstashFormatterV1() handler.setFormatter(formatter) test_logger.setLevel(logging.INFO) test_logger.addHandler(logstash.LogstashHandler(host, 5000, version=1)) script_path = os.getcwd() detect_result = os.popen("java -jar QRDetect.jar %s" % image_name) csv = detect_result.read().split(',') timestamp = image_name.split('_')[1].split('.')[0] if (len(csv) == 2): print("NO QR DETECETED") else: for i in range(0, int(len(csv) / 3)): data = { 'cartID': int(csv[i + 1]), 'camID': int(csv[0]), 'x': int(csv[i + 2]), 'y': int(csv[i + 3]), 'time': int(timestamp), } #data_json = json.dumps(data, indent = 2) test_logger.info('python-logstash: test extra fields', extra=data)
def __init__(self, args=None): self.__dict__ = self.__shared_state if args is None: return self.args = args name = {'dragon': 'DragonHab', 'bug': 'BugHab', 'test': 'DevHab'} self.name = name[self.args.purpose] self._log = logging.getLogger(self.name) self._log.setLevel(logging.DEBUG) sh = logstash.TCPLogstashHandler('192.168.1.2', 5003) sh.setFormatter(VerboseLogstashFormatter()) self._log.addHandler(sh) formatter = logging.Formatter( '{asctime} {levelname} {filename}:{lineno} {message}', style='{') ch = logging.StreamHandler() ch.setFormatter(formatter) self._log.addHandler(ch) self._metric_log = logging.getLogger(self.name + "_metric") # ch2 = logging.StreamHandler(stream=None) # self._metric_log.addHandler(ch2) self._metric_log.addHandler( logstash.LogstashHandler('192.168.1.2', 5002, version=1)) self._metric_log.setLevel(logging.DEBUG) self._metric_log.propagate = True
def get_logger(lvl=logging.DEBUG, log_file_name=None, logger_name='default', elk_host=None, elk_port=None): logger = logging.getLogger(logger_name) logger.setLevel(lvl) stdout_formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') if elk_host and elk_port: import logstash logstash_handler = logstash.LogstashHandler(elk_host, int(elk_port)) logstash_handler.setLevel(lvl) logger.addHandler(logstash_handler) if log_file_name: hdlr = logging.FileHandler(log_file_name) hdlr.setFormatter(stdout_formatter) hdlr.setLevel(lvl) logger.addHandler(hdlr) stdout_handler = logging.StreamHandler(sys.stdout) stdout_handler.setLevel(lvl) stdout_handler.setFormatter(stdout_formatter) logger.addHandler(stdout_handler) if not DEBUG: logger.disabled = True return logger
def configure_logging(): structlog.configure( processors=[ structlog.stdlib.filter_by_level, structlog.stdlib.add_log_level, structlog.stdlib.PositionalArgumentsFormatter(), structlog.processors.StackInfoRenderer(), structlog.processors.format_exc_info, structlog.processors.UnicodeDecoder(), # required as LogstashHandler uses `extra` for logging JSON values structlog.stdlib.render_to_log_kwargs, ], # required to mimic Flask's threadlocal context allowing # logging during the whole request process context_class=structlog.threadlocal.wrap_dict(dict), logger_factory=structlog.stdlib.LoggerFactory(), wrapper_class=structlog.stdlib.BoundLogger, cache_logger_on_first_use=True, ) stream_handler = logging.StreamHandler() stream_handler.setFormatter( structlog.stdlib.ProcessorFormatter( processor=structlog.dev.ConsoleRenderer()) ) app_logger = logging.getLogger('app') app_logger.addHandler(stream_handler) app_logger.setLevel(logging.INFO) # for TCP use TCPLogstashHandler and port 5000 logstash_handler = logstash.LogstashHandler( 'logstash', 5959, version=1) app_logger.addHandler(logstash_handler)
def __init__(self): self.connection, self.cursor = self.connect() self.tablename = "events" self.col1 = "event_id" self.col2 = "event_timestamp" self.logger = logging.getLogger('python-logstash-logger') self.logger.setLevel(logging.INFO) self.logger.addHandler(logstash.LogstashHandler(self.host, 5959, version=1))
def __init__(self, app, print_to_stdout=False): import logging import logstash logger = logging.getLogger() logger.setLevel(logging.DEBUG if app.debug else ( logging.INFO if app.testing else logging.WARNING)) logger.addHandler( logstash.LogstashHandler('elk.profi', 5959, version=1, message_type=app.apptype)) self._l = logger def pp(t, message, *args, stack_info=False, **kwargs): import pprint, sys, traceback ppr = pprint.PrettyPrinter(indent=2, compact=True, width=120) def ppr(obj): ppr.pprint(obj) if stack_info: type_, value_, traceback_ = sys.exc_info() tblist = traceback.format_tb(traceback_) if len(tblist): print('\n'.join()) print(type_, value_) extra = kwargs.get('extra', None) if extra: extra = extra.get('zzz_pr_more_info', None) print('{}: {}'.format(t, message).encode('utf-8')) if extra: ppr(extra) return True if print_to_stdout: self.exception = lambda m, *args, **kwargs: pp('!!! Exception', m, stack_info=True, *args, **kwargs) and \ self._l.exception(m, *args, stack_info=True, **kwargs) self.critical = lambda m, *args, **kwargs: pp('!!! Critical', m, *args, stack_info=True, **kwargs) and \ self._l.critical(m, *args, stack_info=True, **kwargs) self.error = lambda m, *args, **kwargs: pp('!! Error', m, *args, stack_info=True, **kwargs) and \ self._l.error(m, *args, stack_info=True, **kwargs) self.warning = lambda m, *args, **kwargs: pp('! Warning', m, *args, stack_info=True if app.testing or app.debug else False, **kwargs) and \ self._l.warning(m, *args, stack_info=True if app.testing or app.debug else False, **kwargs) self.info = lambda m, *args, **kwargs: pp('Info', m, *args, stack_info=True if app.debug else False, **kwargs) and \ self._l.info(m, *args, stack_info=True if app.debug else False, **kwargs) self.debug = lambda m, *args, **kwargs: pp('Debug', m, *args, stack_info=True, **kwargs) and \ self._l.debug(m, *args, stack_info=True, **kwargs) else: self.exception = partial(self._l.exception, stack_info=True) self.critical = partial(self._l.critical, stack_info=True) self.error = partial(self._l.error, stack_info=True) self.warning = partial( self._l.warning, stack_info=True if app.testing or app.debug else False) self.info = partial(self._l.info, stack_info=True if app.debug else False) self.debug = partial(self._l.debug, stack_info=True)
def __init__(self): # Create logger and levels self._app_logger = logging.getLogger('python-logstash-logger') self.app_logger.setLevel(logging.INFO) # Create a stream and logstash handler to show logs to output and send to ELK stack. self._stream_handler = logging.StreamHandler() self.app_logger.addHandler( logstash.LogstashHandler('34.227.222.14', 5959, version=1)) self.app_logger.addHandler(self.stream_handler)
def __init__(self, logger_type=''): logging.basicConfig() self.logger = logging.getLogger('piddyurl-logstash-logger') self.logger.setLevel(logging.INFO) if logger_type=='logstash': host=os.environ.get('LOGSTASH_HOST','logstash') port=int(os.environ.get('LOGSTASH_PORT','9500')) self.logger.addHandler(logstash.LogstashHandler(host, port, version=1))
def main(): try: hpc = hpfeeds.new(HOST, PORT, IDENT, SECRET) glastopf_logger = logging.getLogger('python-logstash-logger') glastopf_logger.setLevel(logging.INFO) glastopf_logger.addHandler(logstash.LogstashHandler('127.0.0.1', 8070, version=1)) except hpfeeds.FeedException, e: print >>sys.stderr, 'feed exception:', e return 1
def calculate(things_to_buy_count, request_data, customer_id, coupons_list, final_payment_amount, nocoupon_payment_amount): host = '127.0.0.1' test_logger = logging.getLogger() handler = logging.StreamHandler() formatter = LogstashFormatterV1() handler.setFormatter(formatter) test_logger.setLevel(logging.INFO) test_logger.addHandler(logstash.LogstashHandler(host, 5000, version=1)) i = 0 while i < things_to_buy_count: item_serial = str(request_data['serial' + str(i + 1)]) try: print(item_serial) item_ob_info = Item_Info.objects.get(serial_num=item_serial) item_ob = Item_Info.objects.get(serial_num=item_serial).item except Item_Info.DoesNotExist: print('Invalid Item Serial\n') return HttpResponse('Invalid Item Serial\n') print(customer_id) logdata = { 'serial': item_serial, } data = Pur_History(customer=customer_id, item=item_ob_info) print(data) data.save() test_logger.info('python-logstash: test extra fields', extra=logdata) coupon_use_checker = False for coupon in coupons_list: if coupon.coupon_item.item == item_ob and coupon.coupon_use == None: Coupon_Item_Info.objects.filter( serial_num=coupon.serial_num).update(coupon_use=True) final_payment_amount = final_payment_amount + int( (float(item_ob.price) * (float(1) - float(coupon.coupon_item.discount_rate) / float(100)))) print( int((float(item_ob.price) * (float(1) - float(coupon.coupon_item.discount_rate) / 100)))) print('coupon adjust') coupon_use_checker = True break if coupon_use_checker == False: print(item_ob.price) print('coupon not adjust') final_payment_amount = final_payment_amount + item_ob.price nocoupon_payment_amount = nocoupon_payment_amount + item_ob.price i = i + 1 return final_payment_amount
def __init__(self, argument_list): """Parse CLI arguments. argument_list is a list such as ['--foo', 'FOO', '--bar', 'BAR']""" ap = argparse.ArgumentParser( description=self.description, epilog='If no logstash server is specified, ' 'prints log entries to stdout instead.') ap.add_argument('--logstash-server', help='logstash server', type=parse_logstash_server_string, default=None) ap.add_argument('--varnishd-instance-name', help='varnishd instance name', default=None) ap.add_argument('--varnishlog-path', help='varnishlog full path', default='/usr/bin/varnishlog') self.args = ap.parse_args(argument_list) self.cmd = [ self.args.varnishlog_path, '-g', 'raw', # Query for "Back healthy" and "Went sick" events '-q', 'Backend_health ~ "Back healthy|Went sick"', ] self.layer = 'backend' if self.args.varnishd_instance_name: self.cmd.extend(['-n', self.args.varnishd_instance_name]) self.layer = self.args.varnishd_instance_name if self.args.logstash_server: handler = logstash.LogstashHandler( self.args.logstash_server[0], port=self.args.logstash_server[1], version=1, message_type='logback', tags=['varnishospital']) else: handler = logging.StreamHandler(sys.stdout) handler.setLevel(logging.DEBUG) self.logger = logging.getLogger('varnishospital') self.logger.setLevel(logging.DEBUG) self.logger.addHandler(handler)
def __init__(self, argument_list): """Parse CLI arguments. argument_list is a list such as ['--foo', 'FOO', '--bar', 'BAR']""" ap = self.get_argument_parser() ap.add_argument('--logstash-server', help='logstash server', type=parse_logstash_server_string, default=None) ap.add_argument('--transaction-timeout', help='varnish transaction timeout', type=int, default=600) ap.add_argument('--varnishd-instance-name', help='varnishd instance name', default=None) ap.add_argument('--varnishlog-path', help='varnishlog full path', default='/usr/bin/varnishlog') self.args = ap.parse_args(argument_list) self.cmd = [self.args.varnishlog_path] + self.varnishlog_args() self.layer = 'backend' if self.args.varnishd_instance_name: self.cmd.extend(['-n', self.args.varnishd_instance_name]) self.layer = self.args.varnishd_instance_name class_name = self.__class__.__name__.lower() if self.args.logstash_server: handler = logstash.LogstashHandler( self.args.logstash_server[0], port=self.args.logstash_server[1], version=1, message_type='logback', tags=[class_name]) else: handler = logging.StreamHandler(sys.stdout) handler.setFormatter(CEEFormatter()) handler.setLevel(logging.DEBUG) self.logger = logging.getLogger(class_name) self.logger.setLevel(logging.DEBUG) self.logger.addHandler(handler) self.tx = {}
def detectQR(image_name): host = '127.0.0.1' test_logger = logging.getLogger() handler = logging.StreamHandler() formatter = LogstashFormatterV1() handler.setFormatter(formatter) test_logger.setLevel(logging.INFO) test_logger.addHandler(logstash.LogstashHandler(host, 5000, version=1)) #image_name = '1527589403.6_1.jpg'; script_path = os.getcwd() detect_result = os.popen("java -jar QRDetect.jar %s" % image_name) csv = detect_result.read().split(',') #timestamp = image_name.split('_')[1].split('.')[0] timestamp = image_name.split('_')[0] if (len(csv) == 2): print("NO QR DETECETED") print(csv) else: print("QR DETECTED############################") print(csv) for i in range(0, int(len(csv) / 3)): logdata = { 'cartID': int(csv[i + 1]), 'camID': int(csv[0]), 'x': int(csv[i + 2]), 'y': int(csv[i + 3]), 'time': int(timestamp), } #data_json = json.dumps(data, indent = 2) time_num = int(timestamp) #serial = 'cart128644' serial = str(int(csv[i + 1])) camera_num = int(csv[0]) coor_x = int(csv[i + 2]) coor_y = int(csv[i + 3]) cart_customer = Cart_Info.objects.get(serial_num=serial).owner camera = Camera_Info.objects.get(num=camera_num) data = Mv_History(time=time_num, customer=cart_customer, camera_num=camera, x=coor_x, y=coor_y) data.save() #receive_cartqrcode(serial,camera_num,coor_x,coor_y) print("DB SAVED") test_logger.info('python-logstash: test extra fields', extra=logdata) print("LOG SAVED")
def __init__ (self,logfile=None,loggername=None,level=logging.INFO): # Logstash config try: logstash_host,logstash_port = Config().observer_logstash_hostport.split(':') logstash_handler = logstash.LogstashHandler(logstash_host, int(logstash_port), version=1) except: logstash_handler = None # default is to locate loggername from the logfile if avail. if not logfile: try: logfile = Config().observer_log_file except: logfile = "/var/log/xos.log" if (logfile == "console"): loggername = "console" handler = logging.StreamHandler() else: if not loggername: loggername=os.path.basename(logfile) try: handler=logging.handlers.RotatingFileHandler(logfile,maxBytes=1000000, backupCount=5) except IOError: # This is usually a permissions error becaue the file is # owned by root, but httpd is trying to access it. tmplogfile=os.getenv("TMPDIR", "/tmp") + os.path.sep + os.path.basename(logfile) # In strange uses, 2 users on same machine might use same code, # meaning they would clobber each others files # We could (a) rename the tmplogfile, or (b) # just log to the console in that case. # Here we default to the console. if os.path.exists(tmplogfile) and not os.access(tmplogfile,os.W_OK): loggername = loggername + "-console" handler = logging.StreamHandler() else: handler=logging.handlers.RotatingFileHandler(tmplogfile,maxBytes=1000000, backupCount=5) handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")) self.logger=logging.getLogger(loggername) self.logger.setLevel(level) # check if logger already has the handler we're about to add handler_exists = False logstash_handler_exists = False if not len(self.logger.handlers): self.logger.addHandler(handler) if (logstash_handler): self.logger.addHandler(logstash_handler) self.loggername=loggername
def send_to_logstash(self, json_data): global test_logger if test_logger is None: try: import logstash test_logger = logging.getLogger('python-logstash-logger') test_logger.setLevel(logging.INFO) etl_host, etl_port = ETL.get_logstash_server() test_logger.addHandler(logstash.LogstashHandler(etl_host, etl_port, version=1)) except: raise test_logger.info('python-logstash', extra=json_data)
def _setup_handler(self): logstash_handler = None if self.handler == 'AMQP': logstash_handler = logstash.AMQPLogstashHandler( version=1, host=self.host, durable=self.durable, username=self.username, password=self.password, exchange=self.exchange) elif self.handler == 'TCP': logstash_handler = logstash.LogstashHandler(self.host, self.port, version=1) elif self.handler == "UDP": logstash_handler = logstash.LogstashHandler(self.host, self.port, version=1) self.attack_logger = logging.getLogger('python-logstash-handler') self.attack_logger.setLevel(logging.INFO) self.attack_logger.addHandler(logstash_handler)
def __init__(self, bot): """Init.""" self.bot = bot self.settings = dataIO.load_json(JSON) self.extra = {} self.task = bot.loop.create_task(self.loop_task()) self.handler = logstash.LogstashHandler(HOST, PORT, version=1) self.logger = logging.getLogger('discord.logger') self.logger.setLevel(logging.INFO) self.logger.addHandler(self.handler) self.logger.info('discord.logger: Logstash cog init') logging.getLogger("red").addHandler(self.handler)
def add_logstash_handler(logger, log_config): """ Adds a logstash handler to the given logger based on the config :param logger: The logger to utilize :type logger: Logger :param log_config: Path to the logging configuration :type log_config: LoggingConfig :return: The logger to use :rtype: Logger """ host = log_config.host port = log_config.port version = log_config.version logger.addHandler(logstash.LogstashHandler(host, port, version)) return logger
def get_logger(file_name, bot_name): """ Provides a logger to keep a trace of what is happening in a file. It is recommended to use the logger provided by this function instead of prints. :param file_name: Just pass __name__ here. :param bot_name: The name of the bot running :return: A logger object """ logger = logging.getLogger(file_name + ' ' + bot_name) logger.setLevel(logging.DEBUG) handler = logstash.LogstashHandler(credentials['logstash']['host'], credentials['logstash']['port'], version=1) logger.addHandler(handler) logger.addHandler(logging.StreamHandler(sys.stdout)) return logger
def get_dependency(self, *args, **kwargs): worker_ctx = args[0] service_name = worker_ctx.service_name if not self.logger_by_service_name.get(service_name): logger = logging.getLogger(service_name) self.logger_by_service_name[service_name] = logger logger.setLevel(self.log_level) formatter = logging.Formatter(self.log_formatter) handler = logstash.LogstashHandler(self.host, self.port, version=1) handler.setFormatter(formatter) logger.addHandler(handler) if self.local_file: file_handler = FileHandler(self.local_file) file_handler.setFormatter(formatter) logger.addHandler(file_handler) return self.logger_by_service_name[service_name]
def register_logging(app): app.logger.name = 'app' # logstash_handler stashHandler = logstash.LogstashHandler(app.config.get('ELK_HOST'), app.config.get('ELK_PORT')) app.logger.addHandler(stashHandler) # socket_handler socketHandler = logging.handlers.SocketHandler( 'localhost', logging.handlers.DEFAULT_TCP_LOGGING_PORT) app.logger.addHandler(socketHandler) print(app.logger.name) # set own root logger rootLogger = logging.getLogger(__name__) rootLogger.setLevel(logging.DEBUG) socketHandler = logging.handlers.SocketHandler( 'localhost', logging.handlers.DEFAULT_TCP_LOGGING_PORT) rootLogger.addHandler(socketHandler) rootLogger.setLevel(logging.DEBUG)
def start(host, port=5959, tag='salt/engine/logstash'): ''' Listen to salt events and forward them to logstash ''' logstash_logger = logging.getLogger('python-logstash-logger') logstash_logger.setLevel(logging.INFO) logstash_logger.addHandler(logstash.LogstashHandler(host, port, version=1)) if __opts__.get('id').endswith('_master'): event_bus = salt.utils.event.get_master_event(__opts__, __opts__['sock_dir']) else: event_bus = salt.utils.event.get_event('minion', transport=__opts__['transport'], opts=__opts__, sock_dir=__opts__['sock_dir']) log.debug('Logstash engine started') while True: event = event_bus.get_event() if event: logstash_logger.info(tag, extra=json.dumps(event))
def new_logger(name): '''Return new logger which will log both to logstash and to file in JSON format. Log files are stored in <logdir>/name.json ''' log = get_task_logger(name) handler = logstash.LogstashHandler(_logstash['host'], _logstash['port']) log.addHandler(handler) init_logdir(_logdir) handler = TimedRotatingFileHandler( '%s.json' % join(_logdir, name), when='midnight', utc=True, ) handler.setFormatter(JSONFormatter()) log.addHandler(handler) return CeleryAdapter(log, {})
def app_maker(config_file="../config/config.yaml"): app = Flask(__name__) print("Opening config: {}".format(config_file)) open_config(app, config_file=config_file) setup_stats_client(app) if 'log_file' in app.config: file_handler = FileHandler(app.config['log_file']) file_handler.setFormatter(logstash.LogstashFormatterVersion1) app.logger.addHandler(file_handler) logstash_config = app.config.get('logstash', {}) if logstash_config.get('enabled', False): host = logstash_config.get('host', '127.0.0.1') port = logstash_config.get('port', 5959) version = logstash_config.get('version', 1) app.logger.addHandler( logstash.LogstashHandler(host, port, version=version)) setup_routes(app) return app