From 2325f4feb08913ebc29637d69c719649a199e4a7 Mon Sep 17 00:00:00 2001
From: checktheroads <mtt.lov@gmail.com>
Date: Sun, 12 May 2019 11:04:23 -0700
Subject: [PATCH] reworked app-wide logging

---
 .flask_cache/0cc005a225d064a6216a21c390e8fd8f | Bin 0 -> 2021 bytes
 .flask_cache/1fc39e56a58c627ed59c0d0523e808e2 | Bin 0 -> 52 bytes
 .flask_cache/2029240f6d1128be89ddc32729463129 | Bin 8 -> 8 bytes
 .flask_cache/379a23d6e49ea74418d51711a36df194 | Bin 0 -> 63 bytes
 .flask_cache/5e8887a448534e50af390288650930ea | Bin 0 -> 351 bytes
 .flask_cache/632595e1de107e8f891d3cf18b102ff1 | Bin 0 -> 113 bytes
 .flask_cache/74bc75c0764cbc805c70645cef1f026b | Bin 241 -> 241 bytes
 .flask_cache/c10d865004bdf7e67dcf50a6039073dd | Bin 0 -> 56 bytes
 .flask_cache/c9a8ada7d4e04353536dc74ceb1b08e2 | Bin 0 -> 64 bytes
 .flask_cache/d277c4e120e0e4b7fa8f80455a32af2e | Bin 0 -> 52 bytes
 .flask_cache/e6dad9c79446e7c35963c49fd05507d6 | Bin 0 -> 110 bytes
 .flask_cache/e9ad28e2141cab0361d67aef3520c6f7 | Bin 0 -> 51 bytes
 hyperglass/command/construct.py               | 127 ++++++------------
 hyperglass/command/execute.py                 |  48 +++----
 hyperglass/configuration/__init__.py          |   2 +-
 hyperglass/hyperglass.py                      |  17 +--
 requirements.txt                              |   2 +-
 17 files changed, 74 insertions(+), 122 deletions(-)
 create mode 100644 .flask_cache/0cc005a225d064a6216a21c390e8fd8f
 create mode 100644 .flask_cache/1fc39e56a58c627ed59c0d0523e808e2
 create mode 100644 .flask_cache/379a23d6e49ea74418d51711a36df194
 create mode 100644 .flask_cache/5e8887a448534e50af390288650930ea
 create mode 100644 .flask_cache/632595e1de107e8f891d3cf18b102ff1
 create mode 100644 .flask_cache/c10d865004bdf7e67dcf50a6039073dd
 create mode 100644 .flask_cache/c9a8ada7d4e04353536dc74ceb1b08e2
 create mode 100644 .flask_cache/d277c4e120e0e4b7fa8f80455a32af2e
 create mode 100644 .flask_cache/e6dad9c79446e7c35963c49fd05507d6
 create mode 100644 .flask_cache/e9ad28e2141cab0361d67aef3520c6f7

diff --git a/.flask_cache/0cc005a225d064a6216a21c390e8fd8f b/.flask_cache/0cc005a225d064a6216a21c390e8fd8f
new file mode 100644
index 0000000000000000000000000000000000000000..788cb21772140e6c77cde33c0385d91004fa303a
GIT binary patch
literal 2021
zcmchX!H(K65QclGREa0(aimHWNFlWyJHfsIC9C#Qjy?3yKnz$42}%sR-1-phWA)ZU
zAE%R$lx4$iCAPbk2qW8Ld*++@KfeC@`-}VS<&R&lUR2}rPc-_i0mUl2hS_ohX0!8Q
zo0@r4SYU)urRY140YJ;C-x*y^A<wqfq)V{TEYYA-o9|(f<+U%mI<V7uVX_oF$p^&e
zmD@-cb`#l^f>>LfuT5$SYv%p6jyqGFFBEhGh<1@l%7Y!4p#!`TPJL0V7tuDcy-t`!
zO9kYH64C(}#(0@Eg^s~yu-(Lw)%_*DaZ@N<#zCuZ_3?tn#w8kX@O?i3Cb`F|z04<E
zjmelO#i*Jv=&rTR%^dJ9(t|~wt)ab#O6hvsmCPOV4p+jb+$>EBAFiej)JG5pl58F&
zn_Mr-^BlO=X1TIJ8OFGa5)(UMQcO)6CG|1mY`sP_cCUbP!Gt39KP8OTCL8c()+2=1
zvjT58nzR+J1KnKDwb|*opQXwE@bGqQPZ|Gn$9zCsR=5yEF@^b5!c!Ew;befwM~wMu
zK*CUklVGAIQoL`NpL3#uyUcfemr8yKckH#l-1W^Pxi{6o@uf%Zmz2P{P@ghC6rVhx
zt>&nU<AKBk9GjGu;g%L=Q<PQCqy#3YtQ)$F2A7EP2qLCK!BO5C;GsVfiiH*M;ZPya
z(QV*o{Fuvxz#n%7{a?%vN_TO`H@NR5@13OOp2mOXJl#>kf5S$sh!6(`<4aH83IpE4
y7UjRCVAQ*#;0@cO$k$tr0`5Nm^`u6bI5zL2Mcb=877;e)seZGjr7;Da@9rNcGx7)k

literal 0
HcmV?d00001

diff --git a/.flask_cache/1fc39e56a58c627ed59c0d0523e808e2 b/.flask_cache/1fc39e56a58c627ed59c0d0523e808e2
new file mode 100644
index 0000000000000000000000000000000000000000..d7f3b143f02b8b9ed7ce103918c4f2e031c393a9
GIT binary patch
literal 52
zcmeY|6MQ2^uYqN%G6Mwk$QP%irz>O@E9B*uC?qPBCFW$ND0l`aIHsf&r4|?KP0<4Y
Dn;H-W

literal 0
HcmV?d00001

diff --git a/.flask_cache/2029240f6d1128be89ddc32729463129 b/.flask_cache/2029240f6d1128be89ddc32729463129
index 19194ee9ff9503b8dd90e8248beba5a47b51f168..5815809c3b921298a9d0c1e079123aec7733e1f6 100644
GIT binary patch
literal 8
PcmeZf&}(4v7SaO%2R8wU

literal 8
PcmeZf&}(4v=FkHG2O|N0

diff --git a/.flask_cache/379a23d6e49ea74418d51711a36df194 b/.flask_cache/379a23d6e49ea74418d51711a36df194
new file mode 100644
index 0000000000000000000000000000000000000000..42123ed33f06f306cb8cc1d50415cd6dd72e2840
GIT binary patch
literal 63
zcmea;6m=s;uYqN%9s>mQXeAb>q@|@PWELwV<|$<6l_ln6rYJbM2Pin_=jN8?WtLPb
OxaAk+CYI<;(E|W%Srlmi

literal 0
HcmV?d00001

diff --git a/.flask_cache/5e8887a448534e50af390288650930ea b/.flask_cache/5e8887a448534e50af390288650930ea
new file mode 100644
index 0000000000000000000000000000000000000000..6d142c971734d198da3719a8bbada8214afea1be
GIT binary patch
literal 351
zcmZvXK~BRk5Jf>^l~c?zk?Lt}lSXC7rbsNhfC?cM7Op#?7O7nv2f>a*z(IN&j)R-1
zC5w(V`eTp$^#AQ{_WOii7eBM}v$h^@;xPZ*5>TyGl$zcevYH?`P)p|nCUdW}u`dwT
z1l~2F-8oCxYe+e^CrcjgreJL8t{{E)WgNk(4Gqm|0Q-9c93HX+fWvnE!Iqp=#=c^p
z$|$rHARP<jJV#zcthmfzaeWV5OeW9q%cdp`qgEn9fUaD#Dl6rQ8O<aYV_vY1i~0mK
fFCur;XNry~4@?QYaQmSD0XrvB%KT`hbM%dW5Se9*

literal 0
HcmV?d00001

diff --git a/.flask_cache/632595e1de107e8f891d3cf18b102ff1 b/.flask_cache/632595e1de107e8f891d3cf18b102ff1
new file mode 100644
index 0000000000000000000000000000000000000000..3b22b1d0ee6d48669b243a3e725f48bbe13b65fd
GIT binary patch
literal 113
zcmeY=Nw^WC*T6D0fdK+~q+N@O@{1Ib^YijjlS?x5(iKYb6;e{mGLuvFrufchtev9K
z!&a1ET9R5crH3^qvDm<HN)K~#ZpxG%&ZP8$c(Bxz9*)d{f}+&4%!(;J>_!F#hE`UF
KQ%c*X=m7wD8z<fX

literal 0
HcmV?d00001

diff --git a/.flask_cache/74bc75c0764cbc805c70645cef1f026b b/.flask_cache/74bc75c0764cbc805c70645cef1f026b
index e7d10b7e2d8e43be4e517575c21a806d820ef970..180e4b35c91a30f3e731d2aa5bd5dedf0d2342e7 100644
GIT binary patch
delta 12
Tcmey!_>qytYrp@Ei7amcBMAkY

delta 12
Tcmey!_>qyt%d7I*M3%PzAr%Eq

diff --git a/.flask_cache/c10d865004bdf7e67dcf50a6039073dd b/.flask_cache/c10d865004bdf7e67dcf50a6039073dd
new file mode 100644
index 0000000000000000000000000000000000000000..09cd911aa6d5df8b4b6d7189fe2b48e08858bbc1
GIT binary patch
literal 56
zcmea$489Sg*T6DWodE)Rl+*I_lM;(kQxr0b74q^+6cQE65_2+B6g&eI98*$?Qj3fA
Hrsx3x#g-8V

literal 0
HcmV?d00001

diff --git a/.flask_cache/c9a8ada7d4e04353536dc74ceb1b08e2 b/.flask_cache/c9a8ada7d4e04353536dc74ceb1b08e2
new file mode 100644
index 0000000000000000000000000000000000000000..702cf88ec3d4b31731073896996694bde29a7aa8
GIT binary patch
literal 64
zcmeZz5p^R*uYqN%J_7{wXeSn@qyd3KX0bwIo<e3`Sz=CRih`4SfP!;=Zf<E_W=W-j
NTYgb)Vu{`qJphoh6$bzS

literal 0
HcmV?d00001

diff --git a/.flask_cache/d277c4e120e0e4b7fa8f80455a32af2e b/.flask_cache/d277c4e120e0e4b7fa8f80455a32af2e
new file mode 100644
index 0000000000000000000000000000000000000000..35f7f758a154ce0cc2d58f16d216012ca3ccd507
GIT binary patch
literal 52
zcmea;5OgC(uYqN%G6Mwk$R`%3q$y+;E9B*uC?qPBCFW$ND0l`aIHsf&r4|?KP0<4Y
DlxGj&

literal 0
HcmV?d00001

diff --git a/.flask_cache/e6dad9c79446e7c35963c49fd05507d6 b/.flask_cache/e6dad9c79446e7c35963c49fd05507d6
new file mode 100644
index 0000000000000000000000000000000000000000..44dfb5801e3eba5b6907d513a3853a8c20106e5c
GIT binary patch
literal 110
zcmea$iM|n|*T6D0mH`5KA{9sjaa^hjo_S@7IhiR6nRx}JB?>92C8^0JsVNGHB?{_s
Q>I%7uMcJuEdR$ZV0IQD}@&Et;

literal 0
HcmV?d00001

diff --git a/.flask_cache/e9ad28e2141cab0361d67aef3520c6f7 b/.flask_cache/e9ad28e2141cab0361d67aef3520c6f7
new file mode 100644
index 0000000000000000000000000000000000000000..f68511c622e39168f422b0cfcb17606ee0a8a8ba
GIT binary patch
literal 51
zcmeae8+0Q^uYqN%5(5PE$ff1yD`XZc<mHzrBr238=47TQcm^mqrlb_578mPH(E|XC
Ck`J-~

literal 0
HcmV?d00001

diff --git a/hyperglass/command/construct.py b/hyperglass/command/construct.py
index 4836b2d..9c472b8 100644
--- a/hyperglass/command/construct.py
+++ b/hyperglass/command/construct.py
@@ -3,12 +3,11 @@ import sys
 import toml
 import logging
 from netaddr import *
-from loguru import logger
+from logzero import logger
 
 # Local imports
 from hyperglass import configuration
 
-log = logging.getLogger(__name__)
 # Load TOML config file
 devices = configuration.devices()
 
@@ -18,13 +17,10 @@ commands = configuration.commands()
 # Filter config to router list
 routers_list = devices["router"]
 
-logger.add(sys.stderr)
-
 # Receives JSON from Flask, constucts the command that will be passed to the router
 # Also handles input validation & error handling
 def construct(router, cmd, ipprefix):
-    input_params = (router, cmd, ipprefix)
-    logger.info(*input_params)
+    logger.info(f"Constructing {cmd} command for {router} to {ipprefix}...")
     try:
         # Loop through routers config file, match input router with configured routers, set variables
         for r in routers_list:
@@ -47,8 +43,10 @@ def construct(router, cmd, ipprefix):
                             if cmd == "Query Type":
                                 msg = "You must select a query type."
                                 code = 415
-                                logger.error(msg, code, *input_params)
-                                return (msg, code)
+                                logger.error(
+                                    f"{msg}, {code}, {router}, {cmd}, {ipprefix}"
+                                )
+                                return (msg, code, router, cmd, ipprefix)
                             # BGP Community Query
                             elif cmd in ["bgp_community"]:
                                 # Extended Communities, new-format
@@ -56,26 +54,18 @@ def construct(router, cmd, ipprefix):
                                     for a, c in dual_commands.items():
                                         if a == cmd:
                                             command = c.format(target=ipprefix)
-                                            msg = "{i} matched new-format community.".format(
-                                                i=ipprefix
-                                            )
+                                            msg = f"{ipprefix} matched new-format community."
                                             code = 200
-                                            logger.warning(
-                                                msg, code, router, type, command
-                                            )
                                             return (msg, code, router, type, command)
                                 # Extended Communities, 32 bit format
                                 elif re.match("^[0-9]{1,10}$", ipprefix):
                                     for a, c in dual_commands.items():
                                         if a == cmd:
                                             command = c.format(target=ipprefix)
-                                            msg = "{i} matched 32 bit community.".format(
-                                                i=ipprefix
+                                            msg = (
+                                                f"{ipprefix} matched 32 bit community."
                                             )
                                             code = 200
-                                            logger.warning(
-                                                msg, code, router, type, command
-                                            )
                                             return (msg, code, router, type, command)
                                 # RFC 8092 Large Community Support
                                 elif re.match(
@@ -85,42 +75,32 @@ def construct(router, cmd, ipprefix):
                                     for a, c in dual_commands.items():
                                         if a == cmd:
                                             command = c.format(target=ipprefix)
-                                            msg = "{i} matched large community.".format(
-                                                i=ipprefix
-                                            )
+                                            msg = f"{ipprefix} matched large community."
                                             code = 200
-                                            logger.warning(
-                                                msg, code, router, type, command
-                                            )
                                             return (msg, code, router, type, command)
-                                        else:
-                                            msg = "{i} is an invalid BGP Community Format.".format(
-                                                i=ipprefix
-                                            )
-                                            code = 415
-                                            logger.error(msg, code, *input_params)
-                                            return (msg, code)
+                                else:
+                                    msg = f"{ipprefix} is an invalid BGP Community Format."
+                                    code = 415
+                                    logger.error(
+                                        f"{msg}, {code}, {router}, {cmd}, {ipprefix}"
+                                    )
+                                    return (msg, code, router, cmd, ipprefix)
                             # BGP AS_PATH Query
                             elif cmd in ["bgp_aspath"]:
                                 if re.match(".*", ipprefix):
                                     for a, c in dual_commands.items():
                                         if a == cmd:
                                             command = c.format(target=ipprefix)
-                                            msg = "{i} matched AS_PATH regex.".format(
-                                                i=ipprefix
-                                            )
+                                            msg = f"{ipprefix} matched AS_PATH regex."
                                             code = 200
-                                            logger.warning(
-                                                msg, code, router, type, command
-                                            )
                                             return (msg, code, router, type, command)
                                 else:
-                                    msg = "{i} is an invalid AS_PATH regex.".format(
-                                        i=ipprefix
-                                    )
+                                    msg = f"{ipprefix} is an invalid AS_PATH regex."
                                     code = 415
-                                    logger.error(msg, code, *input_params)
-                                    return (msg, code)
+                                    logger.error(
+                                        f"{msg}, {code}, {router}, {cmd}, {ipprefix}"
+                                    )
+                                    return (msg, code, router, cmd, ipprefix)
                             # BGP Route Query
                             elif cmd in ["bgp_route"]:
                                 try:
@@ -129,13 +109,8 @@ def construct(router, cmd, ipprefix):
                                         for a, c in ipv4_commands.items():
                                             if a == cmd:
                                                 command = c.format(target=ipprefix)
-                                                msg = "{i} is a valid IPv4 Adddress.".format(
-                                                    i=ipprefix
-                                                )
+                                                msg = f"{ipprefix} is a valid IPv4 Adddress."
                                                 code = 200
-                                                logger.warning(
-                                                    msg, code, router, type, command
-                                                )
                                                 return (
                                                     msg,
                                                     code,
@@ -148,13 +123,8 @@ def construct(router, cmd, ipprefix):
                                         for a, c in ipv6_commands.items():
                                             if a == cmd:
                                                 command = c.format(target=ipprefix)
-                                                msg = "{i} is a valid IPv6 Adddress.".format(
-                                                    i=ipprefix
-                                                )
+                                                msg = f"{ipprefix} is a valid IPv6 Adddress."
                                                 code = 200
-                                                logger.warning(
-                                                    msg, code, router, type, command
-                                                )
                                                 return (
                                                     msg,
                                                     code,
@@ -164,12 +134,12 @@ def construct(router, cmd, ipprefix):
                                                 )
                                 # Exception from netaddr library will return a user-facing error
                                 except:
-                                    msg = "{i} is an invalid IP Address.".format(
-                                        i=ipprefix
-                                    )
+                                    msg = f"{ipprefix} is an invalid IP Address."
                                     code = 415
-                                    logger.error(msg, code, *input_params)
-                                    return (msg, code)
+                                    logger.error(
+                                        f"{msg}, {code}, {router}, {cmd}, {ipprefix}"
+                                    )
+                                    return (msg, code, router, cmd, ipprefix)
                             # Ping/Traceroute
                             elif cmd in ["ping", "traceroute"]:
                                 try:
@@ -180,13 +150,8 @@ def construct(router, cmd, ipprefix):
                                                     target=ipprefix,
                                                     src_addr_ipv4=src_addr_ipv4,
                                                 )
-                                                msg = "{i} is a valid IPv4 Adddress.".format(
-                                                    i=ipprefix
-                                                )
+                                                msg = f"{ipprefix} is a valid IPv4 Adddress."
                                                 code = 200
-                                                logger.warning(
-                                                    msg, code, router, type, command
-                                                )
                                                 return (
                                                     msg,
                                                     code,
@@ -201,13 +166,8 @@ def construct(router, cmd, ipprefix):
                                                     target=ipprefix,
                                                     src_addr_ipv6=src_addr_ipv6,
                                                 )
-                                                msg = "{i} is a valid IPv6 Adddress.".format(
-                                                    i=ipprefix
-                                                )
+                                                msg = f"{ipprefix} is a valid IPv6 Adddress."
                                                 code = 200
-                                                logger.warning(
-                                                    msg, code, router, type, command
-                                                )
                                                 return (
                                                     msg,
                                                     code,
@@ -216,22 +176,23 @@ def construct(router, cmd, ipprefix):
                                                     command,
                                                 )
                                 except:
-                                    msg = "{i} is an invalid IP Address.".format(
-                                        i=ipprefix
-                                    )
+                                    msg = f"{ipprefix} is an invalid IP Address."
                                     code = 415
-                                    logger.error(msg, code, *input_params)
-                                    return (msg, code)
+                                    logger.error(
+                                        f"{msg}, {code}, {router}, {cmd}, {ipprefix}"
+                                    )
+                                    return (msg, code, router, cmd, ipprefix)
                             else:
-                                msg = "Command {i} not found.".format(i=cmd)
+                                msg = f"Command {cmd} not found."
                                 code = 415
-                                logger.error(msg, code, *input_params)
-                                return (msg, code)
+                                logger.error(
+                                    f"{msg}, {code}, {router}, {cmd}, {ipprefix}"
+                                )
+                                return (msg, code, router, cmd, ipprefix)
             except:
+                router_ip = r["address"]
                 error_msg = logger.error(
-                    "Input router IP {router} does not match the configured router IP of {ip}".format(
-                        router=router, ip=r["address"]
-                    )
+                    f"Input router IP {router} does not match the configured router IP of {router_ip}"
                 )
                 raise ValueError(error_msg)
     except:
diff --git a/hyperglass/command/execute.py b/hyperglass/command/execute.py
index 6028152..523f756 100644
--- a/hyperglass/command/execute.py
+++ b/hyperglass/command/execute.py
@@ -1,7 +1,7 @@
 import sys
 import time
 from netaddr import *
-from loguru import logger
+from logzero import logger
 from netmiko import redispatch
 from netmiko import ConnectHandler
 from hyperglass import configuration
@@ -22,35 +22,36 @@ blacklist = IPSet(blacklist_config["blacklist"])
 
 general_error = "Error connecting to device."
 
-logger.add(sys.stderr)
-
 
 def execute(lg_data):
-    logger.info(lg_data)
+    logger.info(f"Received lookup request for: {lg_data}")
     # Check POST data from JS, if location matches a configured router's
     # location, use the router's configured IP address to connect
+    router = lg_data["router"]
+    cmd = lg_data["cmd"]
+    ipprefix = lg_data["ipprefix"]
+
     for r in routers_list:
-        if r["location"] == lg_data["router"]:
+        if r["location"] == router:
             lg_router_address = r["address"]
 
     # Check blacklist.toml array for prefixes/IPs and return an error upon a match
-    if lg_data["cmd"] in ["bgp_route", "ping", "traceroute"]:
+    if cmd in ["bgp_route", "ping", "traceroute"]:
         try:
-            if IPNetwork(lg_data["ipprefix"]).ip in blacklist:
-                msg = "{i} is not allowed.".format(i=lg_data["ipprefix"])
+            if IPNetwork(ipprefix).ip in blacklist:
+                msg = f"{ipprefix} is not allowed."
                 code = 405
-                logger.error(msg, code, lg_data)
+                logger.error(f"{msg}, {code}, {lg_data}")
                 return (msg, code, lg_data)
         # If netaddr library throws an exception, return a user-facing error.
         except:
-            msg = "{i} is not a valid IP Address.".format(i=lg_data["ipprefix"])
+            msg = f"{ipprefix} is not a valid IP Address."
             code = 415
-            logger.error(msg, code, lg_data)
+            logger.error(f"{msg}, {code}, {lg_data}")
             return (msg, code, lg_data)
     # Send "clean" request to constructor to build the command that will be sent to the router
-    print(lg_router_address)
     msg, status, router, type, command = construct.construct(
-        lg_router_address, lg_data["cmd"], lg_data["ipprefix"]
+        lg_router_address, cmd, ipprefix
     )
     # Loop through proxy config, match configured proxy name for each router with a configured proxy
     # Return configured proxy parameters for netmiko
@@ -71,7 +72,7 @@ def execute(lg_data):
         else:
             msg = "Router does not have a proxy configured."
             code = 415
-            logger.error(msg, code, lg_data)
+            logger.error(f"{msg}, {code}, {lg_data}")
             return (msg, code, lg_data)
 
     # Matches router with configured credential
@@ -88,9 +89,9 @@ def execute(lg_data):
             matched_password = credentials_list[configured_credential]["password"]
             return matched_username, matched_password
         else:
-            msg = "Credential {i} does not exist".format(i=configured_credential)
+            msg = f"Credential {configured_credential} does not exist"
             code = 415
-            logger.error(msg, code, lg_data)
+            logger.error(f"{msg}, {code}, {lg_data}")
             return (general_error, code, lg_data)
 
     # Connect to the router via netmiko library, return the command output
@@ -100,9 +101,9 @@ def execute(lg_data):
             nm_output_direct = nm_connect_direct.send_command(command)
             return nm_output_direct
         except:
-            msg = "Unable to reach target {l}".format(l=lg_data["router"])
+            msg = f"Unable to reach target {router}"
             code = 415
-            logger.error(msg, code, lg_data)
+            logger.error(f"{msg}, {code}, {lg_data}")
             return (general_error, code, lg_data)
 
     # Connect to the proxy server via netmiko library, then log into the router
@@ -137,11 +138,9 @@ def execute(lg_data):
             if host_output:
                 return host_output
         except:
-            msg = "Proxy server {p} unable to reach target {d}".format(
-                p=nm_proxy["host"], d=nm_host["host"]
-            )
+            msg = f'Proxy server {nm_proxy["host"]} unable to reach target {nm_host["host"]}'
             code = 415
-            logger.error(msg, code, lg_data)
+            logger.error(f"{msg}, {code}, {lg_data}")
             return (general_error, code, lg_data)
 
     nm_host = {
@@ -160,14 +159,15 @@ def execute(lg_data):
             else:
                 connection_proxied = True
     if status == 200:
+        logger.info(f"Executing {command} on {router}...")
         try:
             if connection_proxied is True:
                 output_proxied = getOutputProxy(configured_proxy)
-                parsed_output = parse.parse(output_proxied, type, lg_data["cmd"])
+                parsed_output = parse.parse(output_proxied, type, cmd)
                 return parsed_output, status, router, type, command
             elif connection_proxied is False:
                 output_direct = getOutputDirect()
-                parsed_output = parse.parse(output_direct, type, lg_data["cmd"])
+                parsed_output = parse.parse(output_direct, type, cmd)
                 return parsed_output, status, router, type, command
         except:
             raise
diff --git a/hyperglass/configuration/__init__.py b/hyperglass/configuration/__init__.py
index 0bab6fd..e94130e 100644
--- a/hyperglass/configuration/__init__.py
+++ b/hyperglass/configuration/__init__.py
@@ -32,7 +32,7 @@ def devices():
 def requires_ipv6_cidr():
     f = os.path.join(dir, "requires_ipv6_cidr.toml")
     t = toml.load(f)
-    return t
+    return t["requires_ipv6_cidr"]
 
 
 # Filter config to branding variables
diff --git a/hyperglass/hyperglass.py b/hyperglass/hyperglass.py
index 1881bb2..fbdac82 100644
--- a/hyperglass/hyperglass.py
+++ b/hyperglass/hyperglass.py
@@ -2,7 +2,7 @@
 import sys
 import json
 import toml
-from loguru import logger
+from logzero import logger
 from flask import Flask, request, Response, jsonify, flash
 from flask_caching import Cache
 from flask_limiter import Limiter
@@ -13,8 +13,6 @@ from hyperglass import render
 from hyperglass import configuration
 from hyperglass.command import execute
 
-logger.add(sys.stderr)
-
 # Load TOML config file
 devices = configuration.devices()
 # Filter config file to list of routers & subsequent configurations
@@ -130,17 +128,14 @@ def lg():
     # Check if cached entry exists
     if cache.get(cache_key) is None:
         cache_value = execute.execute(lg_data)
-        logger.info(cache_value[1:])
         value_output = cache_value[0]
         value_code = cache_value[1]
         value_params = cache_value[2:]
-        logger.info("No cache match for: {cache_key}".format(cache_key=cache_key))
+        logger.info(f"No cache match for: {cache_key}")
         # If it doesn't, create a cache entry
         try:
             cache.set(cache_key, value_output)
-            logger.info(
-                "Added cache entry: {value_params}".format(value_params=value_params)
-            )
+            logger.info(f"Added cache entry: {value_params}")
         except:
             raise RuntimeError("Unable to add output to cache.", 415, *value_params)
         # If 200, return output
@@ -151,11 +146,7 @@ def lg():
             return Response(cache.get(cache_key), value_code)
     # If it does, return the cached entry
     else:
-        logger.info(
-            "Cache match for: {cache_key}, returning cached entry...".format(
-                cache_key=cache_key
-            )
-        )
+        logger.info(f"Cache match for: {cache_key}, returning cached entry...")
         try:
             return cache.get(cache_key)
         except:
diff --git a/requirements.txt b/requirements.txt
index 1ffd03f..698cc5d 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -7,4 +7,4 @@ netmiko
 netaddr
 markdown2
 libsass
-loguru
+logzero