def __init__(self,
host,
port,
compress=True,
path='/gelf',
timeout=5,
**kwargs):
"""
Logging handler that transforms each record into GELF (graylog extended log format) and sends it over HTTP.
:param host: GELF HTTP input host
:param port: GELF HTTP input port
:param compress: compress message before sending it to the server or not
:param path: path of the HTTP input (http://docs.graylog.org/en/latest/pages/sending_data.html#gelf-via-http)
:param timeout: amount of seconds that HTTP client should wait before it discards the request
if the server doesn't respond
"""
LoggingHandler.__init__(self)
BaseHandler.__init__(self, compress=compress, **kwargs)
self.host = host
self.port = port
self.path = path
self.timeout = timeout
self.headers = {}
if compress:
self.headers['Content-Encoding'] = 'gzip,deflate'
def __init__(self,
filename='file_.log',
mode='a',
encoding=None,
delay=False):
"""
Open the specified file and use it as the stream for logging.
"""
from iohandler import IOFile
self.fph = IOFile.IOFileHandler()
self.filename = filename
filename = os.fspath(filename)
self.baseFilename = os.path.abspath(filename)
fn = os.path.basename(self.filename)
self._file_object = self.fph.open(file_name=fn,
file_path=os.path.dirname(filename),
create_file_if_none=True,
mode='ab+')
self.mode = mode
self.encoding = encoding
self.delay = delay
if delay:
# We don't open the stream, but we still need to call the
# Handler constructor to set level, formatter, lock etc.
Handler.__init__(self)
self.stream = None
else:
StreamHandler.__init__(self, self._open())
def __init__(self, stdout=None, stderr=None, formatter=None):
"""
Initialize the handler.
If stream is not specified, sys.stderr is used.
Parameters
----------
stdout : file-like object, optional
Stream to which DEBUG and INFO messages should be written. \
If `None`, `sys.stdout` will be used.
stderr : file-like object, optional
Stream to which WARNING, ERROR, CRITICAL messages will be \
written. If `None`, `sys.stderr` will be used.
formatter : `logging.Formatter` object, optional
Assigned to `self.formatter`, used to format outgoing \
log messages.
Notes
-----
N.B. it is **not** recommended to pass `sys.stdout` or
`sys.stderr` as constructor arguments explicitly, as certain
things (like nosetests) can reassign these during code
execution! Instead, simply pass `None`.
"""
Handler.__init__(self)
self._stdout = stdout
self._stderr = stderr
self.formatter = formatter
def __init__(self, toaddrs, subject, sendmail = 'sendmail'):
Handler.__init__(self)
self.sendmail = '%s -t' % sendmail
self.msg = """To: %s
Subject: %s
""" % (', '.join(toaddrs), subject)
def __init__(self, toaddrs, subject, sendmail='sendmail'):
Handler.__init__(self)
self.sendmail = '%s -t' % sendmail
self.msg = """To: %s
Subject: %s
""" % (', '.join(toaddrs), subject)
def __init__(self,
host,
port,
user,
password,
exchange="mq_log",
virtual_host="/",
machine_id=None,
process_id=None):
Handler.__init__(self)
self.machine_id = machine_id
self.process_id = process_id
self.exchange = exchange
credentials = pika.PlainCredentials(user, password)
__conn_params = {
"host": host,
"port": port,
"virtual_host": virtual_host,
"credentials": credentials
}
self.__conn = None
self.__channel = None
self.__conn_params = pika.ConnectionParameters(**__conn_params)
def __init__(self, q, level=NOTSET):
if sys.version_info[:2] > (2, 6):
super(QueueHandler, self).__init__(level)
else:
Handler.__init__(self, level)
self.q = q
def __init__(self, api_key, channel, stack_trace=True, username='******', icon_url=None, icon_emoji=None,
fail_silent=False, ping_users=None, ping_level=None):
Handler.__init__(self)
self.formatter = NoStacktraceFormatter()
self.stack_trace = stack_trace
self.fail_silent = fail_silent
self.slacker = slacker.Slacker(api_key)
self.username = username
self.icon_url = icon_url
self.icon_emoji = icon_emoji if (icon_emoji or icon_url) else DEFAULT_EMOJI
self.channel = channel
if not self.channel.startswith('#') and not self.channel.startswith('@'):
self.channel = '#' + self.channel
self.ping_level = ping_level
self.ping_users = []
if ping_users:
user_list = self.slacker.users.list().body['members']
for ping_user in ping_users:
ping_user = ping_user.lstrip('@')
for user in user_list:
if user['name'] == ping_user:
self.ping_users.append(user['id'])
break
else:
raise RuntimeError('User not found in Slack users list: %s' % ping_user)
def __init__(self) -> None:
"""
Obligatory call to the Handler init.
Uses system output, not prints!
"""
Handler.__init__(self)
self.output = sys.stderr
def __init__(self, zlog_client, filepath):
self.client = zlog_client
self.filepath = os.path.abspath(filepath)
# A unique ID so that the server can identify us:
self.client_id = uuid.uuid4().hex.encode('utf8')
Handler.__init__(self)
self.client.check_access(self.filepath)
def __init__(self, level=NOTSET, view_id=None):
Handler.__init__(self, level)
self.state_deferral = None
self.view = None
self.buffer_id = None
self.follow_bottom = True
self.cache = []
def __init__(self,
api_key,
channel,
stack_trace=True,
username=None,
icon_url=None,
icon_emoji=None,
fail_silent=False,
link_names=True):
Handler.__init__(self)
self.formatter = NoStacktraceFormatter()
self.stack_trace = stack_trace
self.fail_silent = fail_silent
self.slacker = slacker.Slacker(api_key)
self.username = username
self.icon_url = icon_url
self.icon_emoji = icon_emoji
self.channel = channel
self.link_names = link_names
if not (self.channel.startswith('#') or self.channel.startswith('@')):
raise ValueError(
'Invalid channel "{}". '
'It must start with "#" for a channel or "@" for a private message.'
.format(self.channel))
def __init__(self, stdout=None, stderr=None, formatter=None):
"""
Initialize the handler.
If stream is not specified, sys.stderr is used.
Parameters
----------
stdout : file-like object, optional
Stream to which DEBUG and INFO messages should be written. \
If `None`, `sys.stdout` will be used.
stderr : file-like object, optional
Stream to which WARNING, ERROR, CRITICAL messages will be \
written. If `None`, `sys.stderr` will be used.
formatter : `logging.Formatter` object, optional
Assigned to `self.formatter`, used to format outgoing \
log messages.
Notes
-----
N.B. it is **not** recommended to pass `sys.stdout` or
`sys.stderr` as constructor arguments explicitly, as certain
things (like nosetests) can reassign these during code
execution! Instead, simply pass `None`.
"""
Handler.__init__(self)
self._stdout = stdout
self._stderr = stderr
self.formatter = formatter
def __init__(self,
webhook_url,
username='******',
channel=None,
icon_url=None,
timeout=None,
proxies={},
verify=True,
format=None,
asyncio_requests=False):
Handler.__init__(self)
self.webhook_url = webhook_url
self.channel = channel
self.username = username
self.icon_url = icon_url
self.session = requests.session()
self.session.proxies = proxies
self.session.verify = verify
self.session.timeout = DEFAULT_TIMEOUT if timeout is None else timeout
self.session.headers.update({'Content-Type': 'application/json'})
if format is not None:
self.formatter = logging.Formatter(format)
self.asyncio_requests = asyncio_requests
if self.asyncio_requests:
self.loop = asyncio.get_event_loop()
def __init__(self, tray_icon):
Handler.__init__(self)
self.tray_icon = tray_icon
formatter = Formatter('%(message)s')
self.setLevel('INFO')
self.setFormatter(formatter)
self.pattern = r'(<.+>)(.+)'
def __init__(self, reEmitMethod):
"""
Initialize the handler. `reEmitMethod` should be a function
taking one logging.LogRecord parameter.
"""
Handler.__init__(self)
self.reEmit = reEmitMethod
def __init__(self, argv=None):
'''
int, user choices needed
'''
Handler.__init__(self)
self.argv = argv
def __init__(self,
prefix='',
ext='log',
folder='logs',
year=True,
month=True,
encoding='utf-8'):
"""
Класс записи логов в файл с расширинным функционалом. Собственных публичных методов не имеет.
Переопределяет родительские методы close и emit.
:param prefix: string, префикс в названии файла, отделяется от даты символом "_", по умолчанию пустой
:param ext: string, расширение файлов логов, по умолчанию "log"
:param folder: string, каталог верхнего уровня для хранения файлов логов, по умолчанию "logs"
:param year: bool, добавить к пути файлов логов год, по умолчанию True
:param month: bool, добавлять к пути файлов логов, по умолчанию True
:param encoding: string, кодировка файла логов, по умолчанию "utf-8"
"""
self.filename = ''
self.prefix = prefix
self.ext = ext
self.folder = folder
self.year = year
self.month = month
self.encoding = encoding
self.stream = None
# Вызывается конструктор прапредка класса, чтобы заранее не открывать файл логов,
# только перед непосредственной записью строки лога в файл
Handler.__init__(self)
def __init__(self,
level=NOTSET,
client_auth='',
timeout=3,
verbose=False,
time_zone="local",
*args,
**kwargs):
# Make sure there is a trailing slash or reqests 2.8.1 will try a GET instead of POST
self.client_auth = client_auth if client_auth.endswith(
'/') else "%s/" % client_auth
self.timeout = timeout
# Used to determine which time setting is used in the simple record_type
self.time_zone = time_zone
# Intentionally hard coded in HttpLogHandler
self.record_type = 'reference'
# If True will print each log_record to console before writing to mongo
self.verbose = verbose
# Don't call super here. We don't want to call BaseMongoLogHandler.__init__ here.
# But we still need this to be a python Handler subclass with SimpleMongoLogger.create_log_record
Handler.__init__(self, level=level)
def __init__(
self,
sender,
logger_name,
max_batch,
min_batch,
max_history_len,
max_time_to_update,
*args,
**kwargs,
):
Handler.__init__(self, *args, **kwargs)
if self.level < 30:
logger.warning("Level was %s < 30. Level set to 30.", self.level)
self.level = 30
self.logger_name = logger_name
self.consumer = ConsumerThread(
sender,
max_batch=max_batch,
min_batch=min_batch,
max_history_len=max_history_len,
max_time_to_update=max_time_to_update,
)
self.consumer.add_producer()
self.lock = condition
global QUEUE
self.queue = QUEUE
def __init__(self, **kwargs):
Handler.__init__(self)
self.app = kwargs['app']
self.queue = QueueFactory.QueueFactory().create(kwargs['type'],
kwargs['queue_name'],
host=kwargs['host'],
port=kwargs['port'])
def __init__(self, textEdit, level=logging.NOTSET, buffer_len=500):
self.textEdit = textEdit
self.buffer_len = buffer_len
self.messages = []
Handler.__init__(self, level=level)
QtCore.QObject.__init__(self)
self.new_log_signal.connect(self.on_new_log)
def __init__(self, size=1000):
Handler.__init__(self)
# only buffer 1000 log records
self.size = size
self.ring = RingBuffer(self.size)
self.dirty = False
return
def __init__(self, text, yscroll, size):
Handler.__init__(self)
self.setLevel(DEBUG)
self.display_debug = False
self.display_filter = ''
self.records = []
self.text = text
self.yscroll = yscroll
self.size = size
self.deleted = 0
boldfont = tkinter.font.Font(font=text['font'])
boldfont['weight'] = 'bold'
text.tag_config('time', foreground='#888')
text.tag_config('DEBUG_levelname', foreground='#888')
text.tag_config('INFO_levelname', foreground='#080')
text.tag_config('WARNING_levelname',
background='red',
foreground='white')
text.tag_config('ERROR_levelname',
background='red',
foreground='white')
text.tag_config('WARNING_message', font=boldfont)
text.tag_config('ERROR_message', font=boldfont)
text['state'] = 'disabled'
def __init__(self,
level=INFO,
webhook='',
username='******',
icon_emoji=':loud_sound:',
sender=None,
channel='#slack-notification'):
"""
Constructor
:param level: log level
:param webhook: Slack webhook
:param username: display Username of bot
:param icon_emoji: icon for bot
:param sender: send from whom
:param channel: channel to send
"""
Handler.__init__(self, level)
self.webhook = webhook
self.username = username
self.icon_emoji = icon_emoji
if sender is None:
sender = socket.gethostname()
self.sender = sender
self.channel = channel
self.session = requests.Session()
def __init__(self, level=logging.NOTSET, error_level=logging.WARNING):
"""
Records with a level strictly less that error_level are
written to standard output. Standard error is used otherwise.
"""
Handler.__init__(self, level)
self.error_level = error_level
def __init__(self, email, queue):
Handler.__init__(self)
self.cache = SimpleCache()
self.mailobj = MailObj()
self.mailobj.template = 'critical_report'
self.mailobj.to = email
self.queue = queue
def __init__(self, recipients=None):
Handler.__init__(self)
self.bot = TwitterDownloaderBot()
self.bot.setState('available', 'Twitter Downloader')
self.bot.recipients = recipients if recipients is not None else administrator_jid[:]
threading.Thread(target=self.bot.start, args=[google_user_name, google_password]).start()
def __init__(
self,
sender: str,
recipients: list,
subject: str = None,
access_key: str = None,
secret_key: str = None,
region: str = None,
):
Handler.__init__(self)
self.sender = sender
self.recipients = recipients
self.subject = subject
self.access_key = access_key
self.secret_key = secret_key
self.region = region
if access_key and secret_key and region:
self.ses_client = boto3_client(
'ses',
region_name=self.region,
aws_access_key_id=self.access_key,
aws_secret_access_key=self.secret_key)
else:
self.ses_client = boto3_client('ses')
def __init__(self):
Handler.__init__(self)
# Hard code sys.stdout for stream
self.stream = sys.stdout
self.prev = None
def __init__(self, log, level=NOTSET): """ :param log: Your ready-to-use log object :param level: One of the ordered standard logging constants (INFO, ERROR etc.) """ Handler.__init__(self, level) self._log = log
def __init__(self, text, yscroll, size):
Handler.__init__(self)
self.setLevel(DEBUG)
self.display_debug = False
self.display_filter = ''
self.records = []
self.text = text
self.yscroll = yscroll
self.size = size
self.deleted = 0
boldfont = tkinter.font.Font(font=text['font'])
boldfont['weight'] = 'bold'
text.tag_config('time', foreground='#888')
text.tag_config('DEBUG_levelname', foreground='#888')
text.tag_config('INFO_levelname', foreground='#080')
text.tag_config('WARNING_levelname', background='red', foreground='white')
text.tag_config('ERROR_levelname', background='red', foreground='white')
text.tag_config('WARNING_message', font=boldfont)
text.tag_config('ERROR_message', font=boldfont)
text['state'] = 'disabled'
def __init__(self, host='127.0.0.1', port=5555, transport=TCPTransport):
Handler.__init__(self)
self.client = Client(host, port, transport)
try:
conn = transport(host, port)
conn.close()
except TransportError:
raise ConnectionError("Could not connect to Riemann server.")
def __init__(self, base_url=None):
if(base_url is None):
self.base_url = 'https://logs-01.loggly.com/inputs/b121e4df-f910-4d6a-b6c1-b19ca2776233/tag/python/'
else:
self.base_url = base_url
self.localip = socket.gethostbyname(socket.gethostname())
self.publicip = urllib2.urlopen('http://ip.42.pl/raw').read()
Handler.__init__(self)
def __init__(self, webhook_url, channel=None):
# Make sure the url string begins with https://
webhook_url = re.sub(r'http(?:s*):\/\/', '', webhook_url)
self.url = 'https://' + webhook_url
self.channel = channel
# Finish spinning up the base log handler class
Handler.__init__(self)
def __init__(self, text_edit):
"""
Initialize the handler.
"""
Handler.__init__(self)
self.text_edit = text_edit
def __init__(self, host='localhost', port=6379, db=0, key='logstash'):
Handler.__init__(self)
self._key = key
self.r_server = redis.Redis(host)
if version == 1:
self.formatter = formatter.LogstashFormatterVersion1(message_type, [], fqdn)
else:
self.formatter = formatter.LogstashFormatterVersion0(message_type, [], fqdn)
def __init__(self, host='127.0.0.1', port=5555, transport=TCPTransport):
Handler.__init__(self)
self.client = Client(host, port, transport)
try:
conn = transport(host, port)
conn.close()
except TransportError:
raise ConnectionError("Could not connect to Riemann server.")
def __init__(self, task):
'''
initialize and prepare the file
'''
Handler.__init__(self)
self.logsfile = open(
path.join(json_settings[ENV_VAR]["logs_folder"], task), 'w')
self.task = task
def __init__(self, streams=None):
"""
初始化处理程序
"""
Handler.__init__(self)
if streams is None:
streams = {}
self.streams = streams
def __init__(self, logs_type):
self.logs_type = logs_type
if logs_type == None:
self.logs_type = "terminal"
self.db = None
if "db" in self.logs_type or "all" in self.logs_type:
self.db = postgres_class()
Handler.__init__(self)
def __init__(self, argv=None, sa_object=None):
'''
int, user choices needed
'''
Handler.__init__(self)
self.argv = argv
self.sa_object = sa_object
def __init__ ( self, splash_screen ):
""" Creates a new handler for a splash screen.
"""
# Base class constructor:
Handler.__init__( self )
# The splash screen that we will display log messages on:
self._splash_screen = splash_screen
def __init__(self, flow_api_token, source="PyFlowdock Logging Helper", from_address='*****@*****.**', from_name='Logger'): # super(FlowdockTeamInboxLoggingHandler, self).__init__() Handler.__init__(self) self.level = DEBUG self.api = TeamInbox(flow_api_token) self.source = source self.from_address = from_address self.from_name = from_name
def __init__(self):
Handler.__init__(self)
self.__consoleFuncForLevel = {
'DEBUG': self.__debug,
'INFO': self.__info,
'WARNING': self.__warn,
'ERROR': self.__error,
'CRITICAL': self.__error
}
def init__(self, **kwargs):
level = kwargs.get('level')
if not level:
level = logging.ERROR
Handler.__init__(self, level=level)
self.__whoami = kwargs.get('from')
if not self.__whoami:
self.__whoami = 'Djanbber Flask Logger'
self.sender = JabberSender.create(**kwargs)
def __init__(self, tissue, options, noseconfig):
Handler.__init__(self)
self.tissue = tissue
self.message_buffer_size = options.pocket_batch_size
self.buffered_messsage_count = 0
self.session = None
self.session_objects = {}
self.last_error = None
getLogger().addHandler(self)
def __init__(self, ident=None, facility=syslog.LOG_USER, log_pid=False):
Handler.__init__(self)
self.facility = facility
if isinstance(facility, basestring):
self.facility = self.facility_names[facility]
options = 0
if log_pid:
options |= syslog.LOG_PID
syslog.openlog(ident, options, self.facility)
self.formatter = None
def __init__(self, stdout=None, stderr=None, formatter=None):
"""
Initialize the handler.
If stream is not specified, sys.stderr is used.
"""
Handler.__init__(self)
self._stdout = stdout
self._stderr = stderr
self.formatter = formatter
def __init__(self, stream):
if not isinstance(stream, six.string_types):
raise Exception("Cannot use file like objects. Use 'stdout' or 'stderr'"
" as a str and without 'ext://'.")
self._use_stderr = True
if 'stdout' in stream:
self._use_stderr = False
# StreamHandler tries to set self.stream
Handler.__init__(self)
def __init__(self, socket_name, formatter_class=formatter.MiniLogstashFormatter, cpickle=False, **kwargs):
"""
Initialize a handler.
"""
Handler.__init__(self)
self.formatter = formatter_class(**kwargs)
self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
self.sock.settimeout(2)
self.sock.connect(socket_name)
def __init__(self, username, password):
Handler.__init__(self)
self.username = username
self.screen_name = username
self.password = password
self._oauth_token = None
self._oauth_token_secret = None
self._consumer = oauth2.Consumer(CONSUMER_KEY,
CONSUMER_SECRET)
self._client = oauth2.Client(self._consumer)
Handler.setFormatter(self, TwitterFormatter())
def __init__(self, api_key, channel, stack_trace=False, username='******', icon_url=None, icon_emoji=None):
Handler.__init__(self)
self.slack_chat = Chat(api_key)
self.channel = channel
self.stack_trace = stack_trace
self.username = username
self.icon_url = icon_url
self.icon_emoji = icon_emoji if (icon_emoji or icon_url) else ':heavy_exclamation_mark:'
if not self.channel.startswith('#'):
self.channel = '#' + self.channel
def __init__(self, socket_name, max_send_buff_size=10000, formatter_class=formatter.MiniLogstashFormatter, **kwargs):
"""
Initialize a handler.
"""
import zmq
Handler.__init__(self)
self.formatter = formatter_class(**kwargs)
ctx = zmq.Context()
self.sock = ctx.socket(zmq.PUB)
self.sock.setsockopt(zmq.SNDHWM, max_send_buff_size)
self.sock.connect(socket_name)
def __init__(self, fileName, maxBytes=60*1024, level=DEBUG):
Handler.__init__(self, level)
path, fileName = os.path.split(fileName)
if path=="":
path = "."
self.path = path
self.maxBytes = maxBytes
# Default formatter for this handler. NOTE: can be overriden!
self.setFormatter(Formatter("%(asctime)s %(levelname)s - \t%(message)s"))
self.name, self.ext = os.path.splitext(fileName)
self.re = re.compile("^" + re.escape(self.name) + "(\d+)" + re.escape(self.ext) + "$")
self.fileName = self.getCurrentFileName()
self.__openFile()
def __init__(self, tissue, options, noseconfig):
Handler.__init__(self)
self.tissue = tissue
self.message_buffer_size = options.pocket_batch_size
if options.pocket_write_frequency > 0:
self.write_frequency = timedelta(options.pocket_write_frequency)
self.next_write = datetime.now() + self.write_frequency
else:
self.next_write = self.write_frequency = None
self.buffered_messsage_count = 0
self.session = None
self.session_objects = {}
self.last_error = None
getLogger().addHandler(self)
def __init__(self, level=NOTSET, client_auth='', timeout=3, verbose=False, time_zone="local", *args, **kwargs):
# Make sure there is a trailing slash or reqests 2.8.1 will try a GET instead of POST
self.client_auth = client_auth if client_auth.endswith('/') else "%s/" % client_auth
self.timeout = timeout
# Used to determine which time setting is used in the simple record_type
self.time_zone = time_zone
# Intentionally hard coded in HttpLogHandler
self.record_type = 'reference'
# If True will print each log_record to console before writing to mongo
self.verbose = verbose
# Don't call super here. We don't want to call BaseMongoLogHandler.__init__ here.
# But we still need this to be a python Handler subclass with SimpleMongoLogger.create_log_record
Handler.__init__(self, level=level)
def __init__(self, queue=None, logging_url="", channel="", username="",
icon_emoji = ""):
QueueListener.__init__(self,queue)
Handler.__init__(self)
"""
logging_url, channel, username, icon_emoji can all be overridden
by the extra dictionary parameter of a logging record
For example:
logging.info('Test messate',extra={'channel':'@someone',
'username':'******',
'icon_emoji':':penguin:'})
"""
self.logging_url = logging_url
self.payload = {
"channel": channel,
"username": username,
"icon_emoji": icon_emoji
}
def __init__(self, host, port, user, password, exchange="mq_log", virtual_host="/", machine_id=None, process_id=None):
Handler.__init__(self)
self.machine_id = machine_id
self.process_id = process_id
self.exchange = exchange
credentials = pika.PlainCredentials(user, password)
__conn_params = {
"host": host,
"port": port,
"virtual_host": virtual_host,
"credentials": credentials
}
self.__conn = None
self.__channel = None
self.__conn_params = pika.ConnectionParameters(**__conn_params)
def __init__(self, *args, **kwargs):
"""logging.Handler interface for Scribe.
Params:
buffer: If True, buffer messages when scribe is unavailable. If False, drop on floor.
category: Scribe category for logging events.
host: Scribe host.
port: Scribe port.
"""
if not _SCRIBE_PRESENT:
raise self.ScribeHandlerException(
"Could not initialize ScribeHandler: Scribe modules not present.")
self._buffer_enabled = kwargs.pop("buffer")
self._category = kwargs.pop("category")
self._client = None
self._host = kwargs.pop("host")
self._log_buffer = []
self._port = kwargs.pop("port")
self._transport = None
Handler.__init__(self, *args, **kwargs)
