Example #1
0
def _main(filepath, options):
    try:
        if options.lines > 0:
            with open(filepath, 'rb') as f:
                if options.head:
                    if options.follow:
                        sys.stderr.write('Cannot follow from top of file.\n')
                        sys.exit(1)
                    lines = head(f, options.lines)
                else:
                    lines = tail(f, options.lines)

                encoding = locale.getpreferredencoding()
                for line in lines:
                    print(line.decode(encoding))

        if options.follow:
            for line in follow_path(filepath):
                if line is not None:
                    print(line)
                else:
                    time.sleep(options.sleep)
    except KeyboardInterrupt:
        # Escape silently
        pass
Example #2
0
async def my_background_task():
    await client.wait_until_ready()
    while not client.is_closed():
        print("The bot is ready!")

        while 1:
            for line in tailhead.follow_path(log_loc):
                if line is not None:
                    if ("ENCOUNTER_START" in line):
                        if debug: print('\rfound encounter start: ' + line)
                    elif ("ENCOUNTER_END" in line):
                        if debug: print('\rfound encounter end: ' + line)

                        if int(line[-1]) == 0:
                            await client.get_channel(channel_id).send(
                                "You wiped :(")
                        else:
                            await client.get_channel(channel_id).send(
                                "You did the thing! :D")

                        await client.get_channel(channel_id).send(str(command))

                        if debug:
                            await client.get_channel(channel_id).send(line)

                else:
                    if debug:
                        sys.stdout.write('\r' + "waiting for log event " +
                                         next(spinner))
                    time.sleep(1)
Example #3
0
 def run(self):
     for line in tailhead.follow_path(self.path):
         if line is None:
             time.sleep(0.1)
             if self.should_exit:
                 return
             continue
         self.update_metrics(line)
 def run(self):
     for line in tailhead.follow_path(self.path):
         if line is None:
             time.sleep(0.1)
             if self.should_exit:
                 return
             continue
         try:
             payload = json.loads(line)['Payload']
         except json.decoder.JSONDecodeError:
             print("Line not parsable as JSON: {}".format(line))
             continue
         self.update_metrics(payload)
    def run(self):
        while True:
            line1 = tailhead.tail(open('/var/log/mycroft/audio.log', "rb"), 3)
            line1sant = str(line1[0].decode("utf-8"))
            emit('my_response', {'data': line1sant})
            for line2 in tailhead.follow_path('/var/log/mycroft/audio.log'):
                if line2 is not None:
                    emit('my_response', {'data': line2})
                else:
                    if self._should_kill:
                        break
                    time.sleep(1)

            if self._should_kill:
                break
        
        self.reset_kill()
Example #6
0
    def follow_tail(self):
        """
        Read (tail and follow) the log file, parse entries and send messages
        to Sentry using Raven.
        """

        try:
            follower = tailhead.follow_path(self.filepath)
        except (FileNotFoundError, PermissionError) as err:
            raise SystemExit("Error: Can't read logfile %s (%s)" %
                             (self.filepath, err))

        for line in follower:
            self.message = None
            self.params = None
            self.site = None

            if line is not None:
                self.parse(line)
                send_message(self.message, self.params, self.site, self.logger)
Example #7
0
def logging_thread(file):
    container_id = file.split('/')[-2]
    container_obj = (next((item for item in running_containers_data
                           if item['id'] == container_id)))
    container_name = container_obj['name']
    for newlines in tailhead.follow_path(file):
        if newlines is not None:
            new_logs_batch = ''
            initial_logs_raw = []
            log_line_list = newlines.split("{\"log")
            for i in log_line_list:
                results = line_formater("{\"log" + i, container_name)
                if results[0] == '':
                    continue
                initial_logs_raw.append({"log": results[0], "ms": results[1]})
                for i in initial_logs_raw:
                    new_logs_batch += i['log']
                print(new_logs_batch)
                container_obj['current_logs'] = content
                send_log_to_listener(new_logs_batch)
Example #8
0
    def follow_tail(self):
        """
        Read (tail and follow) the log file, parse entries and send messages
        to Sentry using Raven.
        """

        try:
            follower = tailhead.follow_path(self.filepath)
        except (FileNotFoundError, PermissionError) as err:
            raise SystemExit("Error: Can't read logfile %s (%s)" %
                             (self.filepath, err))

        for line in follower:
            self.clear_attributes()

            if line is not None:
                self.parse(line)
                send_message(
                    self.message,
                    self.level,
                    self.data,
                )
            else:
                time.sleep(1)
Example #9
0
    def run(self):
        """
        This function is used for tailing the recording log and finding
        out when a new recording have taken place.
        """
        logging.debug('ENTERING FUNCTION: run()')
        list_cameras()

        for line in tailhead.follow_path(self.unifi_record_log):
            if line is not None:
                if 'STOPPING' in line and 'motionRecording' in line:
                    split_row = line.split()
                    # Debug to output line captured from recording.log
                    #logging.debug('Capture: %s', split_row)
                    rec_time = split_row[2].split('.')[0]
                    rec_camera_id, rec_camera_name = split_row[4][6:].strip(
                        '[]').split('|')
                    rec_duration = split_row[9]
                    logging.info('---------- New recording ----------')
                    logging.info('---------- Camera: %s ----------',
                                 rec_camera_name)
                    rec_id = split_row[7].split(':')[1]

                    logging.info(
                        '---------- Camera ID: %s Time: %s Rec ID: %s %s----------',
                        rec_camera_name, rec_time, rec_id, rec_duration)
                    d1 = datetime.datetime.now().strftime("%H:%M:%S")
                    d1 = str(d1)
                    d2 = rec_time
                    FMT = "%H:%M:%S"
                    offby = datetime.datetime.strptime(
                        d1, FMT) - datetime.datetime.strptime(d2, FMT)
                    offby = offby.total_seconds()
                    logging.info('---------- Recording time: %s ----------',
                                 rec_time)
                    logging.info('---------- Process   time: %s ----------',
                                 d1)
                    logging.info(
                        '---------- Detection behind by %s ----------', offby)
                    rec_timestamp = rec_time.replace(":", "_")
                    if (offby > 9000):
                        continue
                    # Download the recording.
                    rec_file = self.download_recording(rec_id)
                    if not rec_file:
                        continue

                    # Run detection on the recording.
                    self.run_detection(rec_file)

                    if self.get_detection_result():
                        self.copy_result_movie(rec_camera_name, rec_timestamp)
                        self.copy_results_output(rec_camera_name,
                                                 rec_timestamp)
                        notification_image = self.get_notification_image(
                            rec_camera_id, rec_id)
                        self.send_discord_notification(notification_image,
                                                       rec_camera_name,
                                                       rec_timestamp)
                    else:
                        logging.info('Person NOT FOUND in recording.')

                    # Destroy recording
                    os.remove(rec_file)

                else:
                    time.sleep(1)
Example #10
0
def follow_file(file, logger):
    for line in tailhead.follow_path(file):
        if line:
            extract = re.search(regex, line)
            level = extract.group("level") if extract and extract.groupdict().get("level") else "info"
            getattr(logger, level.lower(), "info")(line)
    except ImportError:
        log("Checkrune failed - keeping Rune")
        return True
		
		
		

	

def makehash(xy):
    string2hash = xy
    hash_object = hashlib.md5(string2hash.encode())
    hex_dig = hash_object.hexdigest()
    return hex_dig
	
def write_file(msg):
    localtime = time.localtime(time.time())
    timestring = time.strftime ('%d.%m.%Y - %H:%M:%S')
    hash = makehash(msg)
    keep_rune = rune_eval(msg)
    with open("runesell.txt", 'w') as f:
        f.write("%s %s\n"%(hash,keep_rune))
        f.close()
        print msg
	
for line in tailhead.follow_path(runfilepath):
	if line is not None:
		print(line)
		write_file(line)
	else:
		time.sleep(5)
Example #12
0
import os
import tailhead
import time
import re
from subprocess import run

keywords = ["emerg", "alert", "crit", "err", "info"]
regexes = []

#
# assert logfile or even use argparse to get it in
#

for key in keywords:
    expr = '\]\s{1,}' + key +'\:(.*)$'
    regexes.append(re.compile(expr))

for line in tailhead.follow_path('/var/log/syslog'):
    if line is not None:
        for expr in regexes:
            exists = re.match(expr, line)
            if exists is not None:
                print(exists)
                #run(['notify-send', text]
    else:
        time.sleep(1)
parser.add_argument("--api-url",
                    type=str,
                    required=True,
                    help="URL of API to forward logs to")
parser.add_argument("--proxy", type=str, required=False, help="HTTP proxies")

parsed = parser.parse_args()

file_path = parsed.export_file
api_url = parsed.api_url
proxy = parsed.proxy

# -------------------------------------------------------------------------
# MAIN

for line in tailhead.follow_path(file_path):
    if line is None:
        time.sleep(0.1)
        continue

    try:
        proxies_dict = {}
        if proxy:
            proxies_dict = {
                "http": proxy,
                "https": proxy,
            }

        resp = requests.post(api_url,
                             data=line,
                             headers={'Content-Type': 'application/json'},
#!/usr/bin/python3

# imports
import tailhead
import telegram_send

# blocklist
blocklist = open("blocklist.txt", "r").read().split()

# Follow the file as it grows
for line in tailhead.follow_path('logfile.txt'):
    # check against blocklist
    for unwantedUrl in blocklist:
        # if there exist a line with a entry on the blocklist, do 'telegram-send'
        if unwantedUrl in line:
            # disabling potential links to be clickable by putting the dot between brackets
            safeUrl = line.replace(".", "[.]")
            telegram_send.send(messages=[safeUrl],
                               conf=None,
                               disable_web_page_preview="true")
Example #15
-1
def _main(filepath, options):
    try:
        if options.lines > 0:
            with open(filepath, 'rb') as f:
                if options.head:
                    if options.follow:
                        sys.stderr.write('Cannot follow from top of file.\n')
                        sys.exit(1)
                    lines = head(f, options.lines)
                else:
                    lines = tail(f, options.lines)

                encoding = locale.getpreferredencoding()
                for line in lines:
                    print(line.decode(encoding))

        if options.follow:
            for line in follow_path(filepath):
                if line is not None:
                    print(line)
                else:
                    time.sleep(options.sleep)
    except KeyboardInterrupt:
        # Escape silently
        pass