javacore-analyser 2.0rc1__py3-none-any.whl → 2.1__py3-none-any.whl

javacore_analyser/javacore_analyser_web.py

@@ -2,6 +2,7 @@
 # Copyright IBM Corp. 2024 - 2024
 # SPDX-License-Identifier: Apache-2.0
 #
+import argparse
 import locale
 import logging
 import os
@@ -9,6 +10,7 @@ import re
 import shutil
 import sys
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -16,29 +18,30 @@ from flask import Flask, render_template, request, send_from_directory, redirect
 from waitress import serve
 
 import javacore_analyser.javacore_analyser_batch
-from javacore_analyser.constants import DEFAULT_REPORTS_DIR, DEFAULT_PORT
+from javacore_analyser.constants import DEFAULT_REPORTS_DIR, DEFAULT_PORT, TEMP_DIR
 from javacore_analyser.logging_utils import create_console_logging, create_file_logging
 
 """
 To run the application from cmd type:
-export REPORTS_DIR=/tmp/reports
+
 flask --app javacore_analyser_web run
 """
 app = Flask(__name__)
-with app.app_context():
-    create_console_logging()
-    logging.info("Javacore analyser")
-    logging.info("Python version: " + sys.version)
-    logging.info("Preferred encoding: " + locale.getpreferredencoding())
-    reports_dir = os.getenv("REPORTS_DIR", DEFAULT_REPORTS_DIR)
-    logging.info("Reports directory: " + reports_dir)
-    create_file_logging(reports_dir)
+reports_dir = DEFAULT_REPORTS_DIR
+
+
+# Assisted by watsonx Code Assistant
+def create_temp_data_in_reports_dir(directory):
+    tmp_reports_dir = os.path.join(directory, TEMP_DIR)
+    if os.path.isdir(tmp_reports_dir):
+        shutil.rmtree(tmp_reports_dir, ignore_errors=True)
+    os.mkdir(tmp_reports_dir)
 
 
 @app.route('/')
 def index():
     reports = [{"name": Path(f).name, "date": time.ctime(os.path.getctime(f)), "timestamp": os.path.getctime(f)}
-               for f in os.scandir(reports_dir) if f.is_dir()]
+               for f in os.scandir(reports_dir) if f.is_dir() and Path(f).name is not TEMP_DIR]
     reports.sort(key=lambda item: item["timestamp"], reverse=True)
     return render_template('index.html', reports=reports)
 
@@ -50,8 +53,8 @@ def dir_listing(path):
 
 @app.route('/zip/<path:path>')
 def compress(path):
+    temp_zip_dir = tempfile.TemporaryDirectory()
     try:
-        temp_zip_dir = tempfile.TemporaryDirectory()
         temp_zip_dir_name = temp_zip_dir.name
         zip_filename = path + ".zip"
         report_location = os.path.join(reports_dir, path)
@@ -68,7 +71,7 @@ def compress(path):
 def delete(path):
     # Checking if the report exists. This is to prevent attempt to delete any data by deleting any file outside
     # report dir if you prepare path variable.
-    reports_list = os.listdir(reports_dir)
+    # reports_list = os.listdir(reports_dir)
     report_location = os.path.normpath(os.path.join(reports_dir, path))
     if not report_location.startswith(reports_dir):
         logging.error("Deleted report in report list. Not deleting")
@@ -82,10 +85,19 @@ def delete(path):
 # Latest GenAI contribution: ibm/granite-20b-code-instruct-v2
 @app.route('/upload', methods=['POST'])
 def upload_file():
+
+    report_name = request.values.get("report_name")
+    report_name = re.sub(r'[^a-zA-Z0-9]', '_', report_name)
+
+    # Create a temporary directory to store uploaded files
+    # Note We have to use permanent files and then delete them.
+    # tempfile.Temporary_directory function does not work when you want to access files from another threads.
+    javacores_temp_dir_name = os.path.normpath(os.path.join(reports_dir, TEMP_DIR, report_name))
+    if not javacores_temp_dir_name.startswith(reports_dir):
+        raise Exception("Security exception: Uncontrolled data used in path expression")
+
     try:
-        # Create a temporary directory to store uploaded files
-        javacores_temp_dir = tempfile.TemporaryDirectory()
-        javacores_temp_dir_name = javacores_temp_dir.name
+        os.mkdir(javacores_temp_dir_name)
 
         # Get the list of files from webpage
         files = request.files.getlist("files")
@@ -97,26 +109,50 @@ def upload_file():
             file.save(file_name)
             input_files.append(file_name)
 
-        report_name = request.values.get("report_name")
-        report_name = re.sub(r'[^a-zA-Z0-9]', '_', report_name)
-
         # Process the uploaded file
-        report_output_dir = reports_dir + '/' + report_name
-        javacore_analyser.javacore_analyser_batch.process_javacores_and_generate_report_data(input_files,
-                                                                                             report_output_dir)
-
+        report_output_dir = os.path.join(reports_dir, report_name)
+        processing_thread = threading.Thread(
+            target=javacore_analyser.javacore_analyser_batch.process_javacores_and_generate_report_data,
+            name="Processing javacore data", args=(input_files, report_output_dir)
+        )
+        processing_thread.start()
+
+        time.sleep(1)  # Give 1 second to generate index.html in processing_thread before redirecting
         return redirect("/reports/" + report_name + "/index.html")
     finally:
-        javacores_temp_dir.cleanup()
+        shutil.rmtree(javacores_temp_dir_name, ignore_errors=True)
+
 
 def main():
-    debug = os.getenv("DEBUG", False)
-    port = os.getenv("PORT", DEFAULT_PORT)
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--debug", help="Debug mode. Use only for development", default=False)
+    parser.add_argument("--port", help="Port to run application", default=DEFAULT_PORT)
+    parser.add_argument("--reports-dir", help="Directory where app reports are stored",
+                        default=DEFAULT_REPORTS_DIR)
+    args = parser.parse_args()
+    debug = args.debug
+    port = args.port
+    reports_directory = args.reports_dir
+
+    run_web(debug, port, reports_directory)
+
+
+def run_web(debug=False, port=5000, reports_directory=DEFAULT_REPORTS_DIR):
+    global reports_dir
+    reports_dir = reports_directory
+    create_console_logging()
+    logging.info("Javacore analyser")
+    logging.info("Python version: " + sys.version)
+    logging.info("Preferred encoding: " + locale.getpreferredencoding())
+    logging.info("Reports directory: " + reports_dir)
+    create_file_logging(reports_dir)
+    create_temp_data_in_reports_dir(reports_dir)
     if debug:
         app.run(debug=True, port=port)  # Run Flask for development
     else:
         serve(app, port=port)  # Run Waitress in production
 
+
 if __name__ == '__main__':
     """
     The application passes the following environmental variables:

javacore_analyser/javacore_set.py

@@ -17,6 +17,7 @@ from xml.dom.minidom import parseString
 import importlib_resources
 from lxml import etree
 from lxml.etree import XMLSyntaxError
+from tqdm import tqdm
 
 from javacore_analyser import tips
 from javacore_analyser.code_snapshot_collection import CodeSnapshotCollection
@@ -32,7 +33,7 @@ def _create_xml_xsl_for_collection(tmp_dir, templates_dir, xml_xsl_filename, col
     logging.info("Creating xmls and xsls in " + tmp_dir)
     os.mkdir(tmp_dir)
     extensions = [".xsl", ".xml"]
-    for extension in extensions:
+    for extension in tqdm(extensions, desc="Creating xml/xsl files", unit=" file"):
         file_full_path = os.path.normpath(os.path.join(templates_dir, xml_xsl_filename + extension))
         if not file_full_path.startswith(templates_dir):
             raise Exception("Security exception: Uncontrolled data used in path expression")
@@ -89,6 +90,7 @@ class JavacoreSet:
 
     # Assisted by WCA@IBM
     # Latest GenAI contribution: ibm/granite-8b-code-instruct
+    @staticmethod
     def process_javacores(input_path):
         """
         Processes Java core data and generates tips based on the analysis.
@@ -124,49 +126,53 @@ class JavacoreSet:
         temp_dir = tempfile.TemporaryDirectory()
         temp_dir_name = temp_dir.name
         logging.info("Created temp dir: " + temp_dir_name)
-        self.__create_output_files_structure(output_dir)
         self.__create_report_xml(temp_dir_name + "/report.xml")
+        placeholder_filename = os.path.join(output_dir, "data", "html", "processing_data.html")
+        self.__generate_placeholder_htmls(placeholder_filename,
+                                          os.path.join(output_dir, "threads"),
+                                          self.threads, "thread")
+        self.__generate_placeholder_htmls(placeholder_filename,
+                                          os.path.join(output_dir, "javacores"),
+                                          self.javacores, "")
+        self.__create_index_html(temp_dir_name, output_dir)
         self.__generate_htmls_for_threads(output_dir, temp_dir_name)
         self.__generate_htmls_for_javacores(output_dir, temp_dir_name)
-        self.__create_index_html(temp_dir_name, output_dir)
 
-    def __create_output_files_structure(self, output_dir):
-        if not os.path.isdir(output_dir):
-            os.mkdir(output_dir)
-        data_output_dir = os.path.normpath(os.path.join(output_dir, 'data'))
-        if not data_output_dir.startswith(output_dir):
-            raise Exception("Security exception: Uncontrolled data used in path expression")
-        if os.path.isdir(data_output_dir):
-            shutil.rmtree(data_output_dir, ignore_errors=True)
-        logging.info("Data dir: " + data_output_dir)
+    @staticmethod
+    def __generate_placeholder_htmls(placeholder_file, directory, collection, file_prefix):
+        if os.path.exists(directory):
+            shutil.rmtree(directory)
+        os.mkdir(directory)
 
-        style_css_resource = importlib_resources.files("javacore_analyser") / "data" / "style.css"
-        data_dir = os.path.dirname(style_css_resource)
-        os.mkdir(data_output_dir)
-        shutil.copytree(data_dir, data_output_dir, dirs_exist_ok=True)
+        for element in tqdm(collection, desc="Generating placeholder htmls", unit=" file"):
+            filename = file_prefix + "_" + element.get_id() + ".html"
+            if filename.startswith("_"):
+                filename = filename[1:]
+            file_path = os.path.join(directory, filename)
+            shutil.copy2(placeholder_file, file_path)
 
     def __generate_htmls_for_threads(self, output_dir, temp_dir_name):
-        _create_xml_xsl_for_collection(temp_dir_name + "/threads",
-                                       output_dir + "/data/xml/threads", "thread",
+        _create_xml_xsl_for_collection(os.path.join(temp_dir_name, "threads"),
+                                       os.path.join(output_dir, "data", "xml", "threads"), "thread",
                                        self.threads,
                                        "thread")
         self.generate_htmls_from_xmls_xsls(self.report_xml_file,
-                                           temp_dir_name + "/threads",
-                                           output_dir + "/threads", )
+                                           os.path.join(temp_dir_name, "threads"),
+                                           os.path.join(output_dir, "threads"))
 
     def __generate_htmls_for_javacores(self, output_dir, temp_dir_name):
-        _create_xml_xsl_for_collection(temp_dir_name + "/javacores",
-                                       output_dir + "/data/xml/javacores/", "javacore",
+        _create_xml_xsl_for_collection(os.path.join(temp_dir_name, "javacores"),
+                                       os.path.join(output_dir, "data", "xml", "javacores"), "javacore",
                                        self.javacores,
                                        "")
         self.generate_htmls_from_xmls_xsls(self.report_xml_file,
-                                           temp_dir_name + "/javacores",
-                                           output_dir + "/javacores", )
+                                           os.path.join(temp_dir_name, "javacores"),
+                                           os.path.join(output_dir, "javacores"))
 
     def populate_snapshot_collections(self):
         for javacore in self.javacores:
             javacore.print_javacore()
-            for s in javacore.snapshots:
+            for s in tqdm(javacore.snapshots, desc="Populating snapshot collection", unit=" javacore"):
                 self.threads.add_snapshot(s)
                 self.stacks.add_snapshot(s)
 
@@ -234,6 +240,7 @@ class JavacoreSet:
         filename = os.path.join(self.path, filename)
         curr_line = ""
         i = 0
+        file = None
         try:
             file = open(filename, 'r')
             for line in file:
@@ -253,17 +260,18 @@ class JavacoreSet:
                 elif line.startswith(JAVA_VERSION):
                     self.java_version = line[len(JAVA_VERSION) + 1:].strip()
                     continue
-        except Exception as e:
-            print(f'Error during processing file: {file.name} \n'
-                  f'line number: {i} \n'
-                  f'line: {curr_line}\n'
-                  f'Check the exception below what happened')
+        except Exception as ex:
+            logging.exception(ex)
+            logging.error(f'Error during processing file: {file.name} \n'
+                          f'line number: {i} \n'
+                          f'line: {curr_line}\n'
+                          f'Check the exception below what happened')
         finally:
             file.close()
 
     def parse_javacores(self):
         """ creates a Javacore object for each javacore...txt file in the given path """
-        for filename in self.files:
+        for filename in tqdm(self.files, "Parsing javacore files", unit=" file"):
             filename = os.path.join(self.path, filename)
             javacore = Javacore()
             javacore.create(filename, self)
@@ -283,7 +291,7 @@ class JavacoreSet:
     #     return None
 
     def sort_snapshots(self):
-        for thread in self.threads:
+        for thread in tqdm(self.threads, "Sorting snapshot data", unit=" snapshot"):
             thread.sort_snapshots()
             # thread.compare_call_stacks()
 
@@ -314,7 +322,7 @@ class JavacoreSet:
     def print_thread_states(self):
         for thread in self.threads:
             logging.debug("max running states:" + str(thread.get_continuous_running_states()))
-            logging.debug(thread.name + "(id: " + str(thread.id) + "; hash: " + thread.get_hash() + ") " + \
+            logging.debug(thread.name + "(id: " + str(thread.id) + "; hash: " + thread.get_hash() + ") " +
                           "states: " + thread.get_snapshot_states())
 
     # Assisted by WCA@IBM
@@ -377,6 +385,8 @@ class JavacoreSet:
 
         verbose_gc_list_node = self.doc.createElement("verbose_gc_list")
         report_info_node.appendChild(verbose_gc_list_node)
+
+        total_collects_in_time_limits = 0
         for vgc in self.gc_parser.get_files():
             verbose_gc_node = self.doc.createElement("verbose_gc")
             verbose_gc_list_node.appendChild(verbose_gc_node)
@@ -386,9 +396,11 @@ class JavacoreSet:
             verbose_gc_collects_node = self.doc.createElement("verbose_gc_collects")
             verbose_gc_node.appendChild(verbose_gc_collects_node)
             verbose_gc_collects_node.appendChild(self.doc.createTextNode(str(vgc.get_number_of_collects())))
+            total_collects_in_time_limits += vgc.get_number_of_collects()
             verbose_gc_total_collects_node = self.doc.createElement("verbose_gc_total_collects")
             verbose_gc_node.appendChild(verbose_gc_total_collects_node)
             verbose_gc_total_collects_node.appendChild(self.doc.createTextNode(str(vgc.get_total_number_of_collects())))
+        verbose_gc_list_node.setAttribute("total_collects_in_time_limits", str(total_collects_in_time_limits))
 
         system_info_node = self.doc.createElement("system_info")
         doc_node.appendChild(system_info_node)
@@ -474,6 +486,7 @@ class JavacoreSet:
         Returns:
         str: The JavaCore set in the XML format.
         """
+        file = None
         try:
             file = open(self.report_xml_file, "r")
             content = file.read()
@@ -492,11 +505,12 @@ class JavacoreSet:
     def __create_index_html(input_dir, output_dir):
 
         # Copy index.xml and report.xsl to temp - for index.html we don't need to generate anything. Copying is enough.
-        #index_xml = validate_uncontrolled_data_used_in_path([output_dir, "data", "xml", "index.xml"])
-        index_xml = os.path.normpath(importlib_resources.files("javacore_analyser") / "data" / "xml" / "index.xml")
+        # index_xml = validate_uncontrolled_data_used_in_path([output_dir, "data", "xml", "index.xml"])
+        index_xml = os.path.normpath(str(importlib_resources.files("javacore_analyser") / "data" / "xml" / "index.xml"))
         shutil.copy2(index_xml, input_dir)
 
-        report_xsl = os.path.normpath(importlib_resources.files("javacore_analyser") / "data" / "xml" / "report.xsl")
+        report_xsl = os.path.normpath(
+            str(importlib_resources.files("javacore_analyser") / "data" / "xml" / "report.xsl"))
         shutil.copy2(report_xsl, input_dir)
 
         xslt_doc = etree.parse(input_dir + "/report.xsl")
@@ -519,17 +533,22 @@ class JavacoreSet:
             os.mkdir(output_dir)
         shutil.copy2(report_xml_file, data_input_dir)
 
-        # Generating list of tuples. This is required attribute for p.map function executed few lines below.
-        generate_html_from_xml_xsl_files_params = []
-        for file in os.listdir(data_input_dir):
-            generate_html_from_xml_xsl_files_params.append((file, data_input_dir, output_dir))
-
         # https://docs.python.org/3.8/library/multiprocessing.html
         threads_no = JavacoreSet.get_number_of_parallel_threads()
         logging.info(f"Using {threads_no} threads to generate html files")
+
+        list_files = os.listdir(data_input_dir)
+        progress_bar = tqdm(desc="Generating html files", unit=' files')
+
+        # Generating list of tuples. This is required attribute for p.map function executed few lines below.
+        generate_html_from_xml_xsl_files_params = []
+        for file in list_files:
+            generate_html_from_xml_xsl_files_params.append((file, data_input_dir, output_dir, progress_bar))
+
         with Pool(threads_no) as p:
             p.map(JavacoreSet.generate_html_from_xml_xsl_files, generate_html_from_xml_xsl_files_params)
 
+        progress_bar.close()
         logging.info(f"Generated html files in {output_dir}")
 
     # Run with the same number of threads as you have processes but leave one thread for something else.
@@ -540,7 +559,7 @@ class JavacoreSet:
     @staticmethod
     def generate_html_from_xml_xsl_files(args):
 
-        collection_file, collection_input_dir, output_dir = args
+        collection_file, collection_input_dir, output_dir, progress_bar = args
 
         if not collection_file.endswith(".xsl"): return
 
@@ -567,10 +586,30 @@ class JavacoreSet:
         logging.debug("Generating file " + html_file)
         output_doc.write(html_file, pretty_print=True)
 
+        progress_bar.update(1)
+
+    @staticmethod
+    def create_xml_xsl_for_collection(tmp_dir, xml_xsls_prefix_path, collection, output_file_prefix):
+        logging.info("Creating xmls and xsls in " + tmp_dir)
+        os.mkdir(tmp_dir)
+        extensions = [".xsl", ".xml"]
+        for extension in extensions:
+            file_content = Path(xml_xsls_prefix_path + extension).read_text()
+            for element in tqdm(collection, desc="Creating xml/xsl files", unit=" files"):
+                element_id = element.get_id()
+                filename = output_file_prefix + "_" + str(element_id) + extension
+                if filename.startswith("_"):
+                    filename = filename[1:]
+                file = os.path.join(tmp_dir, filename)
+                logging.debug("Writing file " + file)
+                f = open(file, "w")
+                f.write(file_content.format(id=element_id))
+                f.close()
+
     @staticmethod
     def parse_mem_arg(line):
         line = line.split()[-1]  # avoid matching the '2' in tag name 2CIUSERARG
-        tokens = re.findall("[\d]+[KkMmGg]?$", line)
+        tokens = re.findall("\d+[KkMmGg]?$", line)
         if len(tokens) != 1: return UNKNOWN
         return tokens[0]
 

javacore_analyser/snapshot_collection_collection.py

@@ -2,6 +2,8 @@
 # Copyright IBM Corp. 2024 - 2024
 # SPDX-License-Identifier: Apache-2.0
 #
+from tqdm import tqdm
+
 
 class SnapshotCollectionCollection:
 
@@ -23,15 +25,15 @@ class SnapshotCollectionCollection:
     def __iter__(self):
         return self.snapshot_collections.__iter__()
 
-    def __next__(self):
-        return self.snapshot_collections.__next__()
+    # def __next__(self):
+    #    return self.snapshot_collections.__next__()
 
     def get_xml(self, doc):
         info_node = doc.createElement(self.snapshot_collection_type.__name__)
 
         all_threads_node = doc.createElement('all_snapshot_collection')
         info_node.appendChild(all_threads_node)
-        for collection in self.snapshot_collections:
+        for collection in tqdm(self.snapshot_collections, desc=" Generating threads data", unit=" thread"):
             all_threads_node.appendChild(collection.get_xml(doc))
 
         return info_node

javacore_analyser/stack_trace.py

@@ -26,8 +26,8 @@ class StackTrace:
     def __iter__(self):
         return self.stack_trace_elements.__iter__()
 
-    def __next__(self):
-        return self.stack_trace_elements.__next__()
+    # def __next__(self):
+    #    return self.stack_trace_elements.__next__()
 
     def equals(self, stack_trace):
         self_stack_trace_size = len(self.stack_trace_elements)

javacore_analyser/stack_trace_element.py

@@ -9,7 +9,7 @@ from javacore_analyser.stack_trace_kind import StackTraceKind
 
 class StackTraceElement:
 
-    def __init__(self, line = None):
+    def __init__(self, line=None):
         if line is None:
             self.line = None
             self.kind = StackTraceKind.JAVA

javacore_analyser/templates/index.html

@@ -17,12 +17,17 @@
 
     <h2>Generate report:</h2>
     <form action="/upload" method="post" enctype="multipart/form-data">
-      <br>Report Name: <input type="text" id="report_name" name="report_name" required></br>
-      <br>Archive file or multiple javacore files: <input type="file" name="files" multiple required> </br>
+      <ol>
+      <li>Choose archive (zip, 7z, tgz, bz2) file or multiple javacore files:
+        <input type="file" name="files" multiple required>
+      </li>
+      <li>Give the name for your report: <input type="text" id="report_name" name="report_name" required></li>
+      <li>Click button to process: <input type="submit" value="Run"></li>
+      </ol>
       <strong>
-        NOTE: The report generation is expensive operation and might take even few minutes. Please be patient
+        NOTE: Report generation is an expensive operation. It may take a few minutes. Please be patient.
       </strong>
-      <br><input type="submit" value="Upload"></br>
+
     </form>
     <br></br>
 

javacore_analyser/thread_snapshot.py

@@ -2,7 +2,7 @@
 # Copyright IBM Corp. 2024 - 2024
 # SPDX-License-Identifier: Apache-2.0
 #
-
+import logging
 import os
 import re
 from datetime import datetime
@@ -123,7 +123,8 @@ class ThreadSnapshot:
         try:
             token = m.group(1)
             self.cpu_usage = float(token)
-        except:
+        except Exception as ex:
+            logging.warning(ex)
             self.cpu_usage = 0
         # tokens = re.findall("[0-9]+\.[0-9]+", line)
         # if len(tokens) == 0:

javacore_analyser/tips.py

@@ -2,6 +2,7 @@
 # Copyright IBM Corp. 2024 - 2024
 # SPDX-License-Identifier: Apache-2.0
 #
+import logging
 
 # This is a module containing list of the tips.
 # Each tip has to implement dynamic method generate(javacore_set)
@@ -16,6 +17,7 @@ class TestTip:
 
     @staticmethod
     def generate(javacore_set):
+        logging.info(javacore_set)
         return ["this is a test tip. Ignore it."]
 
 
@@ -157,7 +159,7 @@ class BlockingThreadsTip:
                 result.append(BlockingThreadsTip.BLOCKING_THREADS_TEXT.format(blocker_name,
                                                                               blocked_size / javacores_no))
                 if len(result) >= BlockingThreadsTip.MAX_BLOCKING_THREADS_NO:
-                    break;
+                    break
         return result
 
 
@@ -165,9 +167,9 @@ class HighCpuUsageTip:
     # Generates the tip if the thread is using above x percent of CPU. Also informs, if this is verbose gc thread.
 
     # Report as high cpu usage for the application using the cpu usage above this value
-    CRITICAL_CPU_USAGE = 50;
+    CRITICAL_CPU_USAGE = 50
 
-    CRITICAL_USAGE_FOR_GC = 5;
+    CRITICAL_USAGE_FOR_GC = 5
 
     MAX_NUMBER_OF_HIGH_CPU_USAGE_THREADS = 5
 

javacore_analyser/verbose_gc.py

@@ -8,6 +8,8 @@ import ntpath
 from datetime import datetime
 from xml.dom.minidom import Element, parseString
 
+from tqdm import tqdm
+
 ROOT_CLOSING_TAG = "</verbosegc>"
 GC_START = "gc-start"
 GC_END = "gc-end"
@@ -43,7 +45,7 @@ class VerboseGcParser:
 
     def parse_files(self, start_time, stop_time):
         logging.info("Started parsing GC files")
-        for file_path in self.__file_paths:
+        for file_path in tqdm(self.__file_paths, desc="Parsing verbose gc", unit=" file"):
             try:
                 collects_from_time_range = 0
                 file = VerboseGcFile(file_path)
@@ -109,6 +111,7 @@ class VerboseGcFile:
 
     def __parse(self):
         # read in the file as collection of lines
+        file = None
         try:
             xml_text = ""
             root_closing_tag_available = False
@@ -152,7 +155,6 @@ class VerboseGcFile:
     gets the total number of gc collections in this VerboseGcFile
     regardless of the time when tey occurred with regards to the javacores
     '''
-
     def get_total_number_of_collects(self):
         if self.__total_number_of_collects < 0:
             self.get_collects()