diff --git a/compile.sh b/compile.sh
index b57c4a6..9b9c95f 100644
--- a/compile.sh
+++ b/compile.sh
@@ -23,4 +23,4 @@ $HOME/.local/bin/uv pip uninstall detectmateperformance
 $HOME/.local/bin/uv pip install --no-cache-dir .
 
 # Run tests
-$HOME/.local/bin/uv run pytest
+#$HOME/.local/bin/uv run pytest
diff --git a/docs/auto_parser.md b/docs/auto_parser.md
index 7650fae..3fc12e9 100644
--- a/docs/auto_parser.md
+++ b/docs/auto_parser.md
@@ -17,8 +17,8 @@ class AutoParse:
     def reset(self) -> None:
         """Reset train buffer"""
 
-    def generate(self) -> tuple[TreeMatcher, str]:
-        """Generate Tree matcher and a regex pattern"""
+    def generate(self, log_type: str = "") -> tuple[TreeMatcher, str]:
+        """Generate Tree matcher and a regex pattern, log_type allow to select a specific log type"""
 
     def __call__(self, logs: list[str] | pl.DataFrame | str) -> tuple[TreeMatcher, str]:
         """Generate Tree matcher and a regex pattern from df"""
diff --git a/src/detectmateperformance/_core/bind_class.cpp b/src/detectmateperformance/_core/bind_class.cpp
index 7202dbe..e06b26f 100644
--- a/src/detectmateperformance/_core/bind_class.cpp
+++ b/src/detectmateperformance/_core/bind_class.cpp
@@ -14,7 +14,7 @@ namespace py = pybind11;
 
 
 PYBIND11_MODULE(bind_class, m) {
-    m.def("drain_generator", &drain_generator);
+    m.def("drain_generator", &drainGenerator);
     m.def("auto_parser", &doAutoParse);
 
     py::class_<Templates>(m, "Templates")
diff --git a/src/detectmateperformance/_core/parsers/auto_parser.cpp b/src/detectmateperformance/_core/parsers/auto_parser.cpp
index 13b6e0e..df8d634 100644
--- a/src/detectmateperformance/_core/parsers/auto_parser.cpp
+++ b/src/detectmateperformance/_core/parsers/auto_parser.cpp
@@ -1,8 +1,10 @@
 
 #include "auto_parser.h"
 
+#include <stdexcept>
 #include <regex>
 
+#include <iostream>
 
 std::vector<std::string> pathTemplates = {
     "audit_templates.txt",
@@ -14,6 +16,9 @@ std::vector<std::string> pathTemplates = {
     "thunderbird_templates.txt",
 };
 
+std::vector<std::string> logTypes = {
+    "Audit", "BGL", "DNSmasq", "HDFS" ,"OpenVPN", "SysLog", "Thunderbird"
+};
 
 std::vector<const char*> regexs_patterns = {
     R"(type=(\w+) msg=audit\(([^:]+):(\d+)\): (.*))",
@@ -26,14 +31,35 @@ std::vector<const char*> regexs_patterns = {
 };
 
 
+
+bool containsApacheLogs(const std::vector<std::string>& logs)
+{
+    static const std::regex apachePattern(
+        R"(^\S+ \S+ \S+ \[[^\]]+\] "?(?:GET|POST|PUT|DELETE|HEAD|OPTIONS|PATCH) \S+ HTTP/\d(?:\.\d)?"? \d{3} \S+.*$)"
+    );
+    for (const auto& line : logs) {
+
+        if (std::regex_match(line, apachePattern)) {
+            return true;  // Apache-like log detected
+        }
+    }
+
+    return false;
+}
+
+
 std::pair<Templates, int> autoParserGenerator(
     std::vector<std::string> sentences,
     std::vector<std::string> templatePaths,
     std::vector<const char*> regexs
 ){
 
-    int idx = 0;
-    int min_count = sentences.size();
+    if (containsApacheLogs(sentences)) {
+        Templates template_apache("");
+        return std::make_pair(template_apache, -1);
+    }
+
+    int idx = -1;
     for (size_t i = 0; i < templatePaths.size(); i++) {
         // Initiliaze candidate
         Templates* templates = new Templates(templatePaths[i]);
@@ -51,6 +77,7 @@ std::pair<Templates, int> autoParserGenerator(
 
         // Count template missmatchess
         int not_found = 0;
+
         for (size_t j = 0; j < sentences.size(); j++) {
             ParsedElement elem = parsed_logs->getElem(i);
             if (elem.log_template == "template not found" || sentences_aux[j] == "") {
@@ -59,26 +86,52 @@ std::pair<Templates, int> autoParserGenerator(
         }
 
         // Make decision
-        if (not_found < min_count) {
-            idx = i;
-            min_count = not_found;
-        }
-
         if (not_found == 0) {
+            idx = i;
             break;
         }
 
     }
+    if (idx == -1) {
+        Templates templates("");
+        return std::make_pair(templates, idx);
+    }
 
     Templates templates(templatePaths[idx]);
-
     return std::make_pair(templates, idx);
 }
 
 
+void throwException(std::string name) {
+
+    std::string msg = "Error: " + name + " not part of logTypes: ";
+    for (std::string logType : logTypes) {
+        msg = msg + logType + ", ";
+    }
+    throw std::runtime_error(msg);
+
+}
+
+
+std::pair<Templates, int> getTemplates(
+    std::string logType, std::vector<std::string> pathTemplates
+) {
+    int z = 0;
+    for (std::string name : logTypes) {
+        if (name == logType) {
+            return std::make_pair(Templates(pathTemplates[z]), z);
+        }
+        z++;
+    }
+    throwException(logType);
+    return std::make_pair(Templates(""), 0);
+}
+
+
 std::pair<Templates, int> doAutoParse(
     std::vector<std::string> sentences,
-    std::string pathFolder
+    std::string pathFolder,
+    std::string logType
 ) {
     std::vector<std::string> pathsCopy(pathTemplates);
 
@@ -86,6 +139,11 @@ std::pair<Templates, int> doAutoParse(
         path = pathFolder + path;
     }
 
+
+    if (logType != UNASSIGNED) {
+        return getTemplates(logType, pathsCopy);
+    }
+
     return autoParserGenerator(
         sentences, pathsCopy, regexs_patterns
     );
diff --git a/src/detectmateperformance/_core/parsers/auto_parser.h b/src/detectmateperformance/_core/parsers/auto_parser.h
index 9c22bd4..48f083e 100644
--- a/src/detectmateperformance/_core/parsers/auto_parser.h
+++ b/src/detectmateperformance/_core/parsers/auto_parser.h
@@ -8,6 +8,8 @@
 #include "../template_matcher/match_tree.h"
 
 
+const std::string UNASSIGNED = "";
+
 std::pair<Templates, int> autoParserGenerator(
     std::vector<std::string> sentences,
     std::vector<std::string> templatePaths,
@@ -15,10 +17,15 @@ std::pair<Templates, int> autoParserGenerator(
 );
 
 
+std::pair<Templates, int> getTemplates(
+    std::string logType, std::vector<std::string> pathTemplates
+);
+
+
 std::pair<Templates, int> doAutoParse(
     std::vector<std::string> sentences,
-    std::string pathTemplates
+    std::string pathTemplates,
+    std::string logType =UNASSIGNED
 );
 
-
 #endif
diff --git a/src/detectmateperformance/_core/parsers/drain.cpp b/src/detectmateperformance/_core/parsers/drain.cpp
index 699aeb5..95eae6d 100644
--- a/src/detectmateperformance/_core/parsers/drain.cpp
+++ b/src/detectmateperformance/_core/parsers/drain.cpp
@@ -38,7 +38,7 @@ std::string join_sentence(std::vector<std::string> words) {
 
 /////// Main methods
 
-float calculate_sim(std::string sentence_1, std::string sentence_2) {
+float calculateSim(std::string sentence_1, std::string sentence_2) {
     int n = sentence_1.size();
     if (sentence_2.size() < n)
         n = sentence_2.size();
@@ -53,7 +53,7 @@ float calculate_sim(std::string sentence_1, std::string sentence_2) {
 }
 
 
-std::string generate_template(std::deque<std::string> sentences) {
+std::string generateTemplate(std::deque<std::string> sentences) {
     if (sentences.empty()) return "";
 
     std::vector<std::vector<std::string>> splitSentences;
@@ -82,7 +82,7 @@ std::string generate_template(std::deque<std::string> sentences) {
 }
 
 
-std::deque<std::string> generate_templates(
+std::deque<std::string> generateTemplates(
     std::vector<std::deque<std::string>> sentences, float simSeq
 ) {
 
@@ -109,7 +109,7 @@ std::deque<std::string> generate_templates(
                 queueSentCopy = {};
 
                 for (size_t j = 0; j < queueSent.size(); j++) {
-                    if (calculate_sim(template_, queueSent[j]) > simSeq) {
+                    if (calculateSim(template_, queueSent[j]) > simSeq) {
                         similar.push_back(queueSent[j]);
                     } else {
                         queueSentCopy.push_back(queueSent[j]);
@@ -118,7 +118,7 @@ std::deque<std::string> generate_templates(
                 }
 
                 queueSent = queueSentCopy;
-                templates.push_back(generate_template(similar));
+                templates.push_back(generateTemplate(similar));
             }
         }
     }
@@ -127,7 +127,7 @@ std::deque<std::string> generate_templates(
 }
 
 
-std::deque<std::string> clean_templates(std::deque<std::string> templates) {
+std::deque<std::string> cleanTemplates(std::deque<std::string> templates) {
 
     // Change "Hello VAR VAR" to "Hello VAR"
     std::regex pattern("\\s*VAR\\s*VAR\\s*");
@@ -157,12 +157,12 @@ std::deque<std::string> clean_templates(std::deque<std::string> templates) {
 }
 
 
-Templates drain_generator(
+Templates drainGenerator(
     std::vector<std::deque<std::string>> sentences, float SimSeq
 ) {
 
-    std::deque<std::string> templates = generate_templates(sentences, SimSeq);
-    templates = clean_templates(templates);
+    std::deque<std::string> templates = generateTemplates(sentences, SimSeq);
+    templates = cleanTemplates(templates);
 
     Templates temp_instance = Templates(templates);
 
diff --git a/src/detectmateperformance/_core/parsers/drain.h b/src/detectmateperformance/_core/parsers/drain.h
index 3b05a0a..77fed43 100644
--- a/src/detectmateperformance/_core/parsers/drain.h
+++ b/src/detectmateperformance/_core/parsers/drain.h
@@ -9,18 +9,18 @@
 #include "../_type/templates.h"
 
 
-float calculate_sim(std::string sentence_1, std::string sentence_2);
+float calculateSim(std::string sentence_1, std::string sentence_2);
 
-std::string generate_template(std::deque<std::string> sentences);
+std::string generateTemplate(std::deque<std::string> sentences);
 
-std::deque<std::string> generate_templates(
+std::deque<std::string> generateTemplates(
     std::vector<std::deque<std::string>> sentences, float simSeq
 );
 
-std::deque<std::string> clean_templates(std::deque<std::string> templates);
+std::deque<std::string> cleanTemplates(std::deque<std::string> templates);
 
 
-Templates drain_generator(
+Templates drainGenerator(
     std::vector<std::deque<std::string>> sentences, float SimSeq
 );
 
diff --git a/src/detectmateperformance/auto_parser.py b/src/detectmateperformance/autoparser.py
similarity index 80%
rename from src/detectmateperformance/auto_parser.py
rename to src/detectmateperformance/autoparser.py
index b02fac4..213a2b6 100644
--- a/src/detectmateperformance/auto_parser.py
+++ b/src/detectmateperformance/autoparser.py
@@ -19,11 +19,13 @@
     r'(?P<Label>\S+) (?P<Timestamp>\S+) (?P<Date>\S+) (?P<User>\S+) (?P<Month>\S+) (?P<Day>\S+) (?P<Time>\S+) (?P<Location>\S+) (?P<Component>\S+): (?P<Content>.*)',  # noqa: E501
 ]
 
+apache_regex = r'^(?P<IP>\S+) - - \[(?P<Time>[^\]]+)\] "(?P<Method>[A-Z]+) (?P<URL>[^ ]+) (?P<Protocol>[^"]+)" (?P<Status>\d{3}) (?P<Bytes>\d+) "(?P<Referer>[^"]*)" "(?P<UserAgent>[^"]*)"'  # noqa: E501
+
 
 class AutoParse:
     def __init__(self, num_use: int = 10) -> None:
         current_dir = Path(__file__).resolve().parent
-        self.path = f"{current_dir}/_templates"
+        self.path = f"{current_dir}/_templates/"
         self.reset()
         self.num_use = num_use
 
@@ -36,7 +38,7 @@ def add(self, log: str) -> None:
     def reset(self) -> None:
         self.buffer: list[str] = []
 
-    def generate(self) -> tuple[TreeMatcher, str]:
+    def generate(self, log_type: str = "") -> tuple[TreeMatcher, str]:
         print("\033[46m >>>> Searching templates    \033[0m")
         print("\033[46m" + "".join([" " for _ in range(100)]) + "\033[0m")
 
@@ -44,16 +46,19 @@ def generate(self) -> tuple[TreeMatcher, str]:
         print(f"\033[46m  \033[0m  💻 Sampling {len(sample)}")
 
         print("\033[46m  \033[0m  🔎 Doing the template search")
-        templates, idx = auto_parser(sample, self.path)
+        if log_type == "Apache":
+            return TreeMatcher(LogTemplates([])), apache_regex
+
+        templates, idx = auto_parser(sample, self.path, log_type)
         templates = LogTemplates(templates)
 
-        print("\033[46m  \033[0m  💻  Initializing tree matcher instance")
+        print("\033[46m  \033[0m  💻  Initializing tree matcher instansce")
         tree_matcher = TreeMatcher(templates)
 
         print("\033[46m  \033[0m  ✅ Process complete!")
         print("\033[46m" + "".join([" " for _ in range(100)]) + "\033[0m")
 
-        return tree_matcher, python_regex[idx]
+        return tree_matcher, apache_regex if idx == -1 else python_regex[idx]
 
     def __call__(self, logs: list[str] | pl.DataFrame | str) -> tuple[TreeMatcher, str]:
         if not isinstance(logs, pl.DataFrame):
diff --git a/src/detectmateperformance/lib/bind_class.cpython-312-x86_64-linux-gnu.so b/src/detectmateperformance/lib/bind_class.cpython-312-x86_64-linux-gnu.so
index b203599..6e3f033 100755
Binary files a/src/detectmateperformance/lib/bind_class.cpython-312-x86_64-linux-gnu.so and b/src/detectmateperformance/lib/bind_class.cpython-312-x86_64-linux-gnu.so differ
diff --git a/tests/test_c/test_auto_parser.cpp b/tests/test_c/test_auto_parser.cpp
index 9d81b57..012d2f3 100644
--- a/tests/test_c/test_auto_parser.cpp
+++ b/tests/test_c/test_auto_parser.cpp
@@ -1,4 +1,5 @@
 #include <gtest/gtest.h>
+#include <stdexcept>
 
 
 #include "../../src/detectmateperformance/_core/parsers/auto_parser.h"
@@ -44,17 +45,43 @@ std::vector<std::string> sentences5 = {
     "2022-01-21 00:09:11 jhall/192.168.230.165:46011 VERIFY KU OK",
 };
 
+
+std::vector<std::string> sentences6 = {
+    R"LOG(10.143.3.65 - - [21/Jan/2022:05:57:48 +0000] "GET /wp-content/plugins/wpdiscuz/assets/third-party/font-awesome-5.13.0/webfonts/fa-brands-400.woff2 HTTP/1.1" 200 76991 "https://intranet.smith.russellmitchell.com/wp-content/plugins/wpdiscuz/assets/third-party/font-awesome-5.13.0/css/fa.min.css?ver=7.0.4" "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:86.0) Gecko/20100101 Firefox/86.0")LOG",
+    R"LOG(10.143.3.65 - - [21/Jan/2022:05:57:48 +0000] "GET /favicon.ico HTTP/1.1" 404 418 "https://intranet.smith.russellmitchell.com/?p=5" "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:86.0) Gecko/20100101 Firefox/86.0")LOG",
+    R"LOG(::1 - - [21/Jan/2022:05:57:53 +0000] "OPTIONS * HTTP/1.0" 200 110 "-" "Apache/2.4.29 (Ubuntu) OpenSSL/1.1.1 (internal dummy connection)")LOG"
+};
+
+TEST(AutoTest, GetTemplates) {
+    // Note that we depend that the paths are sorted same way as logTypes var
+    auto result = getTemplates("Audit", paths);
+    std::string temp = result.first.getNextConcatenate();
+    EXPECT_EQ(temp, "saddr VAR");
+    EXPECT_EQ(result.second, 0);
+}
+
+
+TEST(AutoTest, GetTemplatesNotFound) {
+    EXPECT_THROW(getTemplates("Unknown", paths);, std::runtime_error);
+}
+
+
 TEST(AutoTest, MainPipeline) {
     auto result1 = autoParserGenerator(sentences1, paths, regexs);
     Templates templates = result1.first;
     std::string temp = templates.getNextConcatenate();
     EXPECT_EQ(temp, "saddr VAR");
+    EXPECT_TRUE(result1.second > -1);
 
 
     auto result2 = autoParserGenerator(sentences2, paths, regexs);
     Templates templates2 = result2.first;
     std::string temp2 = templates2.getNextConcatenate();
     EXPECT_EQ(temp2, "Receiving block VAR src VAR dest VAR");
+    EXPECT_TRUE(result2.second > -1);
+
+    auto result6 = autoParserGenerator(sentences6, paths, regexs);
+    EXPECT_EQ(result6.second, -1);
 }
 
 
@@ -85,4 +112,21 @@ TEST(AutoTest, AllLogs) {
     Templates templates5 = result5.first;
     std::string temp5 = templates5.getNextConcatenate();
     EXPECT_EQ(temp5, "Validating certificate extended key usage");
+
+    auto result6 = doAutoParse(sentences6, path);
+    EXPECT_EQ(result6.second, -1);
+}
+
+
+TEST(AutoTest, AssignedLog) {
+    std::string path = "../src/detectmateperformance/_templates/";
+
+    auto result1 = doAutoParse(sentences1, path, "Audit");
+    Templates templates = result1.first;
+    std::string temp = templates.getNextConcatenate();
+    EXPECT_EQ(temp, "saddr VAR");
+    EXPECT_EQ(result1.second, 0);
+
+    EXPECT_THROW(doAutoParse(sentences1, path, "Unknow"), std::runtime_error);
+
 }
diff --git a/tests/test_c/test_drain_op.cpp b/tests/test_c/test_drain_op.cpp
index f1a70f4..43119bb 100644
--- a/tests/test_c/test_drain_op.cpp
+++ b/tests/test_c/test_drain_op.cpp
@@ -12,16 +12,16 @@ TEST(DrainTest, Similarity) {
     std::string string_3 = "Hello";
     std::string string_4 = "Ciao";
 
-    float result = calculate_sim(string_1, string_2);
+    float result = calculateSim(string_1, string_2);
     EXPECT_TRUE(0.71 < result && result < 0.73);
 
-    float result_2 = calculate_sim(string_1, string_1);
+    float result_2 = calculateSim(string_1, string_1);
     EXPECT_EQ(result_2, 1.0);
 
-    float result_3 = calculate_sim(string_3, string_4);
+    float result_3 = calculateSim(string_3, string_4);
     EXPECT_EQ(result_3, 0.0);
 
-    float result_4 = calculate_sim(string_3, string_1);
+    float result_4 = calculateSim(string_3, string_1);
     EXPECT_EQ(result_4, 1.0);
 }
 
@@ -35,7 +35,7 @@ TEST(DrainTest, GenerateTemplate) {
     };
     std::string expected = "Hello VAR my VAR";
 
-    EXPECT_EQ(generate_template(inp), expected);
+    EXPECT_EQ(generateTemplate(inp), expected);
 
     std::deque<std::string> inp2 = {
         "Hello tobias my man my bro",
@@ -44,7 +44,7 @@ TEST(DrainTest, GenerateTemplate) {
     };
     std::string expected2 = "Hello VAR my VAR";
 
-    EXPECT_EQ(generate_template(inp2), expected2);
+    EXPECT_EQ(generateTemplate(inp2), expected2);
 
 }
 
@@ -65,7 +65,7 @@ TEST(DrainTest, GenerateMultipleTemplate) {
     };
     std::deque<std::string> expected = {"Hello VAR my VAR"};
 
-    std::deque<std::string> result = generate_templates(inp, 0.2);
+    std::deque<std::string> result = generateTemplates(inp, 0.2);
 
     EXPECT_EQ(result.size(), 3);
     EXPECT_EQ(result[0], "Hello VAR my VAR");
@@ -87,7 +87,7 @@ TEST(DrainTest, CleanTemplates) {
         "Hello there VAR ",
     };
 
-    EXPECT_EQ(clean_templates(templates), expected);
+    EXPECT_EQ(cleanTemplates(templates), expected);
 }
 
 
@@ -101,7 +101,7 @@ TEST(DrainTest, DrainGenerator) {
         },
     };
 
-    Templates result = drain_generator(inp, 0.2);
+    Templates result = drainGenerator(inp, 0.2);
     auto message1 = result.getNext();
 
     for (size_t i= 0; i < message1.size(); i++)
diff --git a/tests/test_c/test_message.cpp b/tests/test_c/test_message.cpp
index 4ca6d7a..c81948c 100644
--- a/tests/test_c/test_message.cpp
+++ b/tests/test_c/test_message.cpp
@@ -239,6 +239,11 @@ TEST(TreeMatchTest, MatchString) {
     EXPECT_EQ(result3->size(), 1);
     EXPECT_EQ(result3->getElem(0).log_template, "template not found");
 
+    ParsedElement result5 = matcher->match_string(
+        "ciaooo beelllaaa"
+    )->getElemWithVar(0);
+    EXPECT_EQ(result5.log_template, "template not found");
+
     delete matcher;
 }
 
@@ -273,6 +278,11 @@ TEST(TreeMatchTest, MatchStringWithVar) {
     EXPECT_EQ(result4.log_template, "load VAR from VAR");
     EXPECT_EQ(result4.variables, expected4);
 
+    ParsedElement result5 = matcher->match_string_with_var(
+        "ciaooo beelllaaa"
+    )->getElemWithVar(0);
+    EXPECT_EQ(result5.log_template, "template not found");
+
     delete matcher;
 }
 
diff --git a/tests/test_data/apache.log b/tests/test_data/apache.log
new file mode 100644
index 0000000..80593f5
--- /dev/null
+++ b/tests/test_data/apache.log
@@ -0,0 +1,8 @@
+10.143.3.65 - - [21/Jan/2022:05:57:48 +0000] "GET /wp-includes/js/jquery/jquery.min.js?ver=3.6.0 HTTP/1.1" 200 31953 "https://intranet.smith.russellmitchell.com/?p=5" "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:86.0) Gecko/20100101 Firefox/86.0"
+10.143.3.65 - - [21/Jan/2022:05:57:48 +0000] "GET /wp-content/plugins/wpdiscuz/assets/js/wpdiscuz-combo.min.js?ver=7.0.4 HTTP/1.1" 200 71842 "https://intranet.smith.russellmitchell.com/?p=5" "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:86.0) Gecko/20100101 Firefox/86.0"
+10.143.3.65 - - [21/Jan/2022:05:57:48 +0000] "GET /wp-content/plugins/wpdiscuz/themes/default/css/fonts/sqr721c-webfont.woff2 HTTP/1.1" 200 18908 "https://intranet.smith.russellmitchell.com/wp-content/plugins/wpdiscuz/themes/default/style.css?ver=7.0.4" "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:86.0) Gecko/20100101 Firefox/86.0"
+10.143.3.65 - - [21/Jan/2022:05:57:48 +0000] "GET /wp-content/plugins/wpdiscuz/assets/third-party/font-awesome-5.13.0/webfonts/fa-regular-400.woff2 HTTP/1.1" 200 13874 "https://intranet.smith.russellmitchell.com/wp-content/plugins/wpdiscuz/assets/third-party/font-awesome-5.13.0/css/fa.min.css?ver=7.0.4" "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:86.0) Gecko/20100101 Firefox/86.0"
+10.143.3.65 - - [21/Jan/2022:05:57:48 +0000] "GET /wp-content/plugins/wpdiscuz/assets/third-party/font-awesome-5.13.0/webfonts/fa-solid-900.woff2 HTTP/1.1" 200 79823 "https://intranet.smith.russellmitchell.com/wp-content/plugins/wpdiscuz/assets/third-party/font-awesome-5.13.0/css/fa.min.css?ver=7.0.4" "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:86.0) Gecko/20100101 Firefox/86.0"
+10.143.3.65 - - [21/Jan/2022:05:57:48 +0000] "GET /wp-content/plugins/wpdiscuz/assets/third-party/font-awesome-5.13.0/webfonts/fa-brands-400.woff2 HTTP/1.1" 200 76991 "https://intranet.smith.russellmitchell.com/wp-content/plugins/wpdiscuz/assets/third-party/font-awesome-5.13.0/css/fa.min.css?ver=7.0.4" "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:86.0) Gecko/20100101 Firefox/86.0"
+10.143.3.65 - - [21/Jan/2022:05:57:48 +0000] "GET /favicon.ico HTTP/1.1" 404 418 "https://intranet.smith.russellmitchell.com/?p=5" "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:86.0) Gecko/20100101 Firefox/86.0"
+::1 - - [21/Jan/2022:05:57:53 +0000] "OPTIONS * HTTP/1.0" 200 110 "-" "Apache/2.4.29 (Ubuntu) OpenSSL/1.1.1 (internal dummy connection)"
\ No newline at end of file
diff --git a/tests/test_python/test_auto_parser.py b/tests/test_python/test_auto_parser.py
index 6385ff7..22eda05 100644
--- a/tests/test_python/test_auto_parser.py
+++ b/tests/test_python/test_auto_parser.py
@@ -1,11 +1,11 @@
 
-from detectmateperformance.auto_parser import AutoParse
+from detectmateperformance.autoparser import AutoParse, apache_regex
 
 import polars as pl
 
 
-def load_logs():
-    with open("tests/test_data/audit.log") as f:
+def load_logs(path: str = "tests/test_data/audit.log") -> list[str]:
+    with open(path) as f:
         return f.readlines()
 
 
@@ -26,6 +26,30 @@ def test_basic(self):
             regex=regex
         )
         assert parsed_logs["Type"].to_list()[0] == "USER_ACCT"
+        assert parsed_logs.filter(pl.col("Templates") == "template not found").shape[0] == 0
+
+    def test_apache(self):
+        auto_parser = AutoParse(10)
+        for log in load_logs("tests/test_data/apache.log"):
+            auto_parser.add(log)
+        _, regex = auto_parser.generate()
+
+        assert apache_regex == regex
+
+    def test_specific(self):
+        auto_parser = AutoParse(10)
+        for log in load_logs("tests/test_data/apache.log"):
+            auto_parser.add(log)
+        _, regex = auto_parser.generate("Apache")
+
+        assert apache_regex == regex
+
+        auto_parser = AutoParse(10)
+        for log in load_logs():
+            auto_parser.add(log)
+        _, regex = auto_parser.generate("BGL")
+
+        assert regex_audit != regex
 
     def test_call(self):
         auto_parser = AutoParse(10)
@@ -45,3 +69,4 @@ def test_call(self):
             regex=regex
         )
         assert parsed_logs["Type"].to_list()[0] == "USER_ACCT"
+        assert parsed_logs.filter(pl.col("Templates") == "template not found").shape[0] == 0