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
