Pytonorm

Hur man bygger en webbtrafikövervakare med Python, Flask, SQLite och Pusher

Hur man bygger en webbtrafikövervakare med Python, Flask, SQLite och Pusher
Om du har en webbapplikation som är ute på Internet måste du veta var dina besökare kommer ifrån, de system de använder och andra sådana saker.

Även om du kan använda tjänster som Google Analytics, Monster Insights, etc., det är roligare att bygga ett övervakningssystem med Python, SQL-databas och Pusher för att uppdatera data i realtid.

I dagens handledning kommer vi att gå igenom hur man skapar ett sådant verktyg med Python, Flask och Pusher. Självstudien är en mycket anpassad spin-off från en handledning som publiceras på Pusher's officiella sida.

Krav

För den här versionen måste du veta hur du arbetar med python-programmeringsspråket, enkel webbutveckling och API: er.

Installationskrav

Börja med att installera Python på ditt system. Du måste också installera Pusher and Flask, httpagentparser.

Skapa databasen

Det första steget är att skapa en databas där data lagras. För Python kommer sqlite3 som standard, och det är enkelt att använda det. Skapa en fil som heter databas.py och ange koden nedan:

importera sqlite3
från importfel sqlite3
def create_connection (databas):
Prova:
conn = sqlite3.ansluta(
databas, isolation_level = Ingen, check_same_thread = Falsk)
anslutning.row_factory = lambda c, r: dict (
zip ([col [0] för col in c.beskrivning], r))
returanslutning
utom fel som e:
skriva ut (e)
def create_table (c, sql):
c.exekvera (sql)
def update_or_create_page (c, data):
sql = "VÄLJ * FRÅN sidor där namn =? och session =?"
c.exekvera (sql, data [: - 1])
resultat = c.fetchone ()
om resultat == Ingen:
create_pages (c, data)
annan:
skriva ut (resultat)
update_pages (c, result ['id'])
def create_pages (c, data):
skriva ut (data)
sql = "INSERT INTO-sidor (namn, session, först_besökt)
VÄRDEN (?,?,?) "
c.exekvera (sql, data)
def update_pages (c, pageId):
skriv ut (pageId)
sql = "UPPDATERA sidor
SET-besök = besök + 1
VAR id = ?"
c.exekvera (sql, [pageId])
def create_session (c, data):
sql = "INSERT INTO sessions (ip, kontinent, land, stad, operativsystem, webbläsare, session, skapad_at)
VÄRDEN (?,?,?,?,?,?,?,?) "
c.exekvera (sql, data)
def select_all_sessions (c):
sql = "VÄLJ * FRÅN sessioner"
c.exekvera (sql)
rader = c.fetchall ()
returnera rader
def select_all_pages (c):
sql = "VÄLJ * FRÅN sidor"
c.exekvera (sql)
rader = c.fetchall ()
returnera rader
def select_all_user_visits (c, session_id):
sql = "VÄLJ * FRÅN sidor där session =?"
c.kör (sql, [session_id])
rader = c.fetchall ()
returnera rader
def huvud ():
databas = "./ pythonsqlite.db "
sql_create_pages = "" "
SKAPA TABELL OM INTE FUNGERAR sidor (
id heltal PRIMÄRT NYCKEL,
namn varchar (225) INTE NULL,
session varchar (255) INTE NULL,
first_visited datetime NOT NULL,
besök heltal INTE NULL Standard 1
);
"" "
sql_create_session = "" "
SKAPA TABELL OM INTE FÖR sessioner (
ID-heltal PRIMÄRT NYCKEL,
ip varchar (225) INTE NULL,
continent varchar (225) INTE NULL,
landvarchar (225) INTE NULL,
city ​​varchar (225) INTE NULL,
os varchar (225) INTE NULL,
webbläsarvarchar (225) INTE NULL,
session varchar (225) INTE NULL,
created_at datetime NOT NULL
);
"" "
# skapa en databasanslutning
conn = create_connection (databas)
om anslutning inte är Ingen:
# skapa tabeller
create_table (anslut, sql_create_pages)
create_table (anslut, sql_create_session)
skriv ut ("Uppkoppling upprättad!")
annan:
skriva ut ("Kunde inte upprätta anslutning")
om __name__ == '__main__':
huvud ()

Spara filen och kör skriptet för att skapa databasen med relevanta data.

python-databas.py
"Kontakt etablerad!”

Gå sedan vidare till pusher och skapa ett konto. Skapa sedan en applikation och följ guiden för att konfigurera appen. När du är klar kopierar du appnycklarna och lagrar dem i en pythonordbok som visas nedan.

pusher = Pusher (
app_id = "1079412",
key = "e5d266a24f3502d2b814",
hemligt = "bab634d2398eb5fcb0f8",
cluster = "us2")

Slutligen skapar du en kolvapplikation och bygger backend som visas i koden nedan:

från kolvimport Kolv, render_template, begäran, session, jsonify
importera urllib.begäran
från pusher import Pusher
från datetime importera datetime
importera httpagentparser
importera json
importera os
importera hashlib
från databasimport skapa_anslutning, skapa_session, uppdatera_eller_skapa_sida, välj_all_sessioner, välj_all_användarbesök, välj_all_sidor
app = kolv (__ namn__)
app.secret_key = os.urandom (24)
# configure pusher object
pusher = Pusher (
app_id = "1079412",
key = "e5d266a24f3502d2b814",
hemligt = "bab634d2398eb5fcb0f8",
cluster = "us2")
databas = "./ pythonsqlite.db "
conn = create_connection (databas)
c = anslutning.markör ()
userOS = Ingen
userIP = Ingen
userCity = Ingen
userBrowser = Ingen
userCountry = Ingen
userContinent = Ingen
sessionID = Ingen
def huvud ():
global anslutning, c
def parseVisitor (data):
update_or_create_page (c, data)
pusher.trigger (u'pageview ', u'new',
u'page ': data [0],
u'session ': sessionID,
u'ip ': userIP
)
pusher.trigger (u'numbers ', u'update',
u'page ': data [0],
u'session ': sessionID,
u'ip ': userIP
)
@app.före_förfrågan
def getAnalyticsData ():
global userOS, userBrowser, userIP, userContinent, userCity, userCountry, sessionID
userInfo = httpagentparser.upptäcka (begäran.rubriker.get ('User-Agent'))
userOS = userInfo ['platform'] ['name']
userBrowser = userInfo ['webbläsare'] ['namn']
userIP = "196.207.130.148 "på begäran.remote_addr == '127.0.0.1 'annan begäran.remote_addr
api = "https: // www.placera.io / api / lookup / "+ userIP
Prova:
resp = urllib.begäran.urlopen (api)
resultat = resp.läsa()
resultat = json.belastningar (resultat.avkoda ("utf-8"))
userCountry = resultat ["land"]
userContinent = resultat ["kontinent"]
userCity = resultat ["stad"]
bortsett från:
skriva ut ("Kunde inte hitta:", userIP)
getSession ()
def getSession ():
global sessionID
tid = datetime.nu().ersätt (mikrosekund = 0)
om 'användare' inte är i session:
rader = (str (tid) + userIP).koda ('utf-8')
session ['användare'] = hashlib.md5 (rader).hexdigest ()
sessionID = session ['användare']
pusher.trigger (u'session ', u'new',
u'ip ': userIP,
u'continent ': userContinent,
u'country ': userCountry,
u'city ': userCity,
u'os ': userOS,
u'browser ': userBrowser,
u'session ': sessionID,
u'time ': str (tid),
)
data = [userIP, userContinent, userCountry,
userCity, userOS, userBrowser, sessionID, time]
skapa_session (c, data)
annan:
sessionID = session ['användare']
@app.rutt('/')
def index ():
data = ['home', sessionID, str (datetime.nu().ersätt (mikrosekund = 0))]
parseVisitor (data)
returnera f'Användardata: data '
@app.rutt ('/ get-all-sessions')
def get_all_sessions ():
data = []
dbRows = select_all_sessions (c)
för rad i dbRows:
data.bifoga(
'ip': rad ['ip'],
'kontinent': rad ['kontinent'],
'land': rad ['land'],
'stad': rad ['stad'],
'os': rad ['os'],
'webbläsare': rad ['webbläsare'],
'session': rad ['session'],
'tid': rad ['created_at']
)
returnera jsonify (data)
om __name__ == '__main__':
huvud ()
app.kör (debug = True)

När du är klar kör du appen med kommandokolvkörningen och navigerar till 127.0.0.1: 5000 / Detta ska logga användaren, sessionsinformationen för den specifika IP-adressen inklusive agent (webbläsare), land och liknande.

Om du vill visa hela den loggade sessionen går du till 127.0.0.1: 5000 / get-all-sessions.

[

"browser": "Chrome",
"city": "New York",
"continent": "Nordamerika",
"country": "United States",
"ip": "192.148.18.103 ",
"os": "Linux",
"session": "9a5d6a84d93ad62a599293acb2e751a1",
"tid": "2021-01-13 02:52:32"
,

"browser": "Mozilla",
"city": "Oregon",
"continent": "Nordamerika",
"country": "United States",
"ip": "66.115.149.229 ",
"os": "Windows",
"session": "64d205c98c839e1d346c733ffd41b27f",
"tid": "2021-01-13 02:54:12"
,

"browser": "Chrome",
"city": "Ogden",
"continent": "Nordamerika",
"country": "United States",
"ip": "172.231.59.124 ",
"os": "Windows",
"session": "3fd564c16a32b5139a8dd0578e36aded",
"tid": "2021-01-13 02:54:37"
,

"browser": "Chrome",
"city": "New York",
"continent": "Nordamerika",
"country": "United States",
"ip": "72.229.28.185 ",
"os": "Windows",
"session": "27ad92271023888427da216de10a7cae",
"tid": "2021-01-13 02:55:07"
,

"browser": "Chrome",
"city": "Nairobi",
"continent": "Africa",
"country": "Kenya",
"ip": "196.207.130.148 ",
"os": "Linux",
"session": "c92cdab9eefa2fe121d49264986e7345",
"tid": "2021-01-13 02:56:43"
,

"browser": "Chrome",
"city": "Nairobi",
"continent": "Africa",
"country": "Kenya",
"ip": "196.207.130.148 ",
"os": "Windows",
"session": "31ee28ec6a655e0fa13be4dba8c13861",
"tid": "2021-01-13 03:11:49"

]

Med appen igång kan du slumpmässigt ändra din IP-adress och webbläsare för att samla in tillräckligt med information för din databas. Med hjälp av insamlad data kan du använda dataverktyg som ELK stack för att visualisera den och se vilka platser och webbläsare som besöker applikationen mer.

Följande är ett exempel på visualisering av insamlad data från appen ovan.

Slutsats

I denna handledning använde vi Python, SQLite och Pusher för att samla in information om användare som besökte webbplatsen och använde sedan data för att skapa visualiseringar.

För att hålla sakerna enkla begränsade jag apputgången till konsol och JSON för att rymma dem som inte har arbetat med Flask jinja-mall.

Denna enkla app är öppen för expansion till ett fullfjädrat webbanalysverktyg. Tänk på resurserna nedan för ytterligare kunskap:

Spel Bästa spelkonsolemulatorer för Linux
Bästa spelkonsolemulatorer för Linux
Den här artikeln listar populära spelkonsolemuleringsprogram som finns tillgängliga för Linux. Emulation är ett mjukvarukompatibilitetsskikt som emule...
Spel Bästa Linux Distros för spel 2021
Bästa Linux Distros för spel 2021
Linux-operativsystemet har kommit långt från sitt ursprungliga, enkla, serverbaserade utseende. Detta operativsystem har förbättrats enormt de senaste...
Spel Hur du fångar och strömmar din spelsession på Linux
Hur du fångar och strömmar din spelsession på Linux
Tidigare betraktades spel bara som en hobby, men med tiden såg spelindustrin en enorm tillväxt när det gäller teknik och antalet spelare. Spelpubliken...