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, 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, 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, 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, *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)