Phenquestions
Hoewel u diensten zoals Google Analytics, Monster Insights, enz. kunt gebruiken., het is leuker om een monitoringsysteem te bouwen met Python, SQL-database en Pusher voor realtime gegevensupdates.
In de tutorial van vandaag bespreken we hoe je zo'n tool kunt maken met Python, Flask en Pusher. De tutorial is een sterk aangepaste spin-off van een tutorial die is gepubliceerd op de officiële pagina van Pusher.
Vereisten
Voor deze build moet je weten hoe je moet werken met de programmeertaal Python, eenvoudige webontwikkeling en API's.
Installatievereisten
Begin met het installeren van Python op uw systeem. U moet ook Pusher en Flask installeren, httpagentparser.
De database maken
De eerste stap is het maken van een database waarin de gegevens worden opgeslagen. Voor Python wordt sqlite3 standaard geleverd en het gebruik ervan is eenvoudig. Maak een bestand met de naam database.py en voer de onderstaande code in:
import sqlite3van sqlite3 importfout
def create_connection(database):
proberen:
conn = sqlite3.aansluiten(
database, isolation_level=Geen, check_same_thread=False)
conn.row_factory = lambda c, r: dict(
zip([col[0] voor col in c.beschrijving], r))
retour verbinding
behalve Fout als e:
print(e)
def create_table(c, sql):
c.uitvoeren (sql)
def update_or_create_page(c, data):
sql = "SELECTEER * VAN pagina's waar naam=? en sessie=?"
c.uitvoeren(sql, data[:-1])
resultaat = c.halen()
als resultaat == Geen:
create_pages(c, gegevens)
anders:
afdrukken (resultaat)
update_pages(c, resultaat['id'])
def create_pages(c, data):
afdrukken(gegevens)
sql = "INSERT INTO pagina's(naam,sessie,eerste_bezocht)
WAARDEN (?,?,?)"
c.uitvoeren (sql, gegevens)
def update_pages(c, pageId):
print(pagina-ID)
sql = "UPDATE pagina's
SET bezoeken = bezoeken+1
WAAR id = ?"
c.execute(sql, [pageId])
def create_session(c, data):
sql = "INSERT INTO session(ip, continent, country, city, os, browser, session, created_at)
WAARDEN (?,?,?,?,?,?,?,?)"
c.uitvoeren (sql, gegevens)
def select_all_sessions(c):
sql = "SELECTEER * UIT sessies"
c.uitvoeren (sql)
rijen = c.ophalen()
rijen retourneren
def select_all_pages(c):
sql = "SELECTEER * UIT pagina's"
c.uitvoeren (sql)
rijen = c.ophalen()
rijen retourneren
def select_all_user_visits(c, session_id):
sql = "SELECTEER * VAN pagina's waar sessie =?"
c.execute(sql, [session_id])
rijen = c.ophalen()
rijen retourneren
def hoofd():
databank = "./pythonsqlite.db"
sql_create_pages = """
MAAK TABEL INDIEN NIET BESTAAT pagina's (
id geheel getal PRIMAIRE SLEUTEL,
naam varchar(225) NIET NULL,
sessie varchar(255) NIET NULL,
first_visited datetime NIET NULL,
bezoeken geheel getal NOT NULL Standaard 1
);
"""
sql_create_session = """
MAAK TABEL ALS NIET BESTAAT sessies (
id geheel getal PRIMAIRE SLEUTEL,
ip varchar(225) NIET NULL,
continent varchar(225) NIET NULL,
land varchar(225) NIET NULL,
stad varchar(225) NIET NULL,
os varchar(225) NIET NULL,
browser varchar(225) NIET NULL,
sessie varchar(225) NIET NULL,
created_at datetime NIET NULL
);
"""
# maak een databaseverbinding aan
conn = create_connection(database)
als conn niet Geen is:
# tabellen maken
create_table(conn, sql_create_pages)
create_table(conn, sql_create_session)
print("Verbinding tot stand gebracht!")
anders:
print("Kan geen verbinding maken")
if __name__ == '__main__':
hoofd()
Sla het bestand op en voer het script uit om de database met de relevante gegevens te maken.
python-database.py"Verbinding gemaakt!”
Ga vervolgens naar pusher en maak een account aan. Maak vervolgens een applicatie en volg de wizard om de app in te stellen. Eenmaal voltooid, kopieert u de app-sleutels en slaat u ze op in een python-woordenboek zoals hieronder weergegeven:.
duwer = duwer(app_id = "1079412",
sleutel = "e5d266a24f3502d2b814",
secret = "bab634d2398eb5fcb0f8",
cluster = "us2")
Maak ten slotte een kolftoepassing en bouw de backend zoals weergegeven in de onderstaande code:
from flask import Flask, render_template, request, session, jsonifyurllib importeren.verzoek
van pusher import Pusher
van datetime import datetime
httpagentparser importeren
import json
importeer os
hashlib importeren
uit database importeren create_connection, create_session, update_or_create_page, select_all_sessions, select_all_user_visits, select_all_pages
app = Kolf(__naam__)
app.secret_key = os.urandom(24)
# configureer pusher-object
duwer = duwer(
app_id = "1079412",
sleutel = "e5d266a24f3502d2b814",
secret = "bab634d2398eb5fcb0f8",
cluster = "us2")
databank = "./pythonsqlite.db"
conn = create_connection(database)
c = verbinding.cursor()
gebruikersOS = Geen
gebruikersIP = Geen
userCity = Geen
userBrowser = Geen
userCountry = Geen
userContinent = Geen
sessionID = Geen
def hoofd():
global conn, c
def parseVisitor(data):
update_or_create_page(c, data)
opdringer.trigger(u'paginaweergave', u'nieuw',
u'pagina': gegevens[0],
u'session': sessionID,
u'ip': gebruikersIP
)
opdringer.trigger(u'nummers', u'update',
u'page': gegevens[0],
u'session': sessionID,
u'ip': gebruikersIP
)
@app.before_request
def getAnalyticsData():
global userOS, userBrowser, userIP, userContinent, userCity, userCountry, sessionID
userInfo = httpagentparser.detecteren (verzoek).kopteksten.get('User-Agent'))
userOS = userInfo['platform']['naam']
userBrowser = userInfo['browser']['naam']
gebruikersIP = "196.207.130.148 "op verzoek.remote_addr == '127.0.0.1' anders verzoek.remote_addr
api = "https://www.ilocate.io/api/lookup/" + gebruikersIP
proberen:
resp = urllib.verzoek.urlopen(api)
resultaat = resp.lezen()
resultaat = json.ladingen (resultaat.decoderen("utf-8"))
userCountry = resultaat["land"]
userContinent = resultaat["continent"]
userCity = resultaat["stad"]
behalve:
print("Kon niet vinden: ", userIP)
getSession()
def getSession():
globale sessie-ID
tijd = datumtijd.nu().vervangen (microseconde = 0)
indien 'gebruiker' niet in sessie is:
lijnen = (str(tijd)+gebruikersIP).coderen('utf-8')
sessie['gebruiker'] = hashlib.md5(lijnen).hexdigest()
sessionID = sessie['gebruiker']
opdringer.trigger(u'sessie', u'nieuw',
u'ip': gebruikersIP,
u'continent': userContinent,
u'country': userCountry,
u'city': userCity,
u'os': userOS,
u'browser': userBrowser,
u'session': sessionID,
u'time': str(tijd),
)
data = [userIP, userContinent, userCountry,
userCity, userOS, userBrowser, sessionID, tijd]
create_session(c, gegevens)
anders:
sessionID = sessie['gebruiker']
@app.route('/')
def-index():
data = ['home', sessionID, str(datetimedate.nu().vervangen(microseconde=0))]
ontledenBezoeker(gegevens)
retourneer f'Gebruikersgegevens: data'
@app.route('/get-all-sessions')
def get_all_sessions():
gegevens = []
dbRows = select_all_sessions(c)
voor rij in dbRows:
gegevens.toevoegen(
'ip': rij['ip'],
'continent': rij['continent'],
'land': rij['land'],
'stad': rij['stad'],
'os': rij['os'],
'browser': rij['browser'],
'sessie': rij['sessie'],
'time': rij['created_at']
)
retourneer jsonify(gegevens)
if __name__ == '__main__':
hoofd()
app.uitvoeren (debug = True)
Als u klaar bent, voert u de app uit met de opdracht flask run en navigeert u naar 127.0.0.1: 5000/ Dit zou de gebruiker moeten loggen, de sessie-informatie van het specifieke IP-adres inclusief Agent (browser), Land, en dergelijke.
Om alle gelogde sessies te bekijken, ga naar 127.0.0.1:5000/alle-sessies ophalen.
["browser":"Chrome",
"city":"New York",
"continent":"Noord-Amerika",
"country":"Verenigde Staten",
"ip":"192.148.18.103",
"os":"Linux",
"session":"9a5d6a84d93ad62a599293acb2e751a1",
"time":"2021-01-13 02:52:32"
,
"browser":"Mozilla",
"city":"Oregon",
"continent":"Noord-Amerika",
"country":"Verenigde Staten",
"ip":"66.115.149.229",
"os":"Vensters",
"session":"64d205c98c839e1d346c733ffd41b27f",
"tijd":"2021-01-13 02:54:12"
,
"browser":"Chrome",
"city":"Ogden",
"continent":"Noord-Amerika",
"country":"Verenigde Staten",
"ip":"172.231.59.124",
"os":"Vensters",
"session":"3fd564c16a32b5139a8dd0578e36aded",
"time":"2021-01-13 02:54:37"
,
"browser":"Chrome",
"city":"New York",
"continent":"Noord-Amerika",
"country":"Verenigde Staten",
"ip":"72.229.28.185",
"os":"Vensters",
"session":"27ad92271023888427da216de10a7cae",
"time":"2021-01-13 02:55:07"
,
"browser":"Chrome",
"city":"Nairobi",
"continent":"Afrika",
"country":"Kenia",
"ip":"196.207.130.148",
"os":"Linux",
"session":"c92cdab9eefa2fe121d49264986e7345",
"time":"2021-01-13 02:56:43"
,
"browser":"Chrome",
"city":"Nairobi",
"continent":"Afrika",
"country":"Kenia",
"ip":"196.207.130.148",
"os":"Vensters",
"session":"31ee28ec6a655e0fa13be4dba8c13861",
"time":"2021-01-13 03:11:49"
]
Als de app actief is, kunt u uw IP-adres en browser willekeurig wijzigen om voldoende informatie voor uw database te verzamelen. Met behulp van de verzamelde gegevens kunt u gegevenstools zoals ELK-stack gebruiken om deze te visualiseren en te zien welke locaties en browsers de applicatie meer bezoeken.
Het volgende is een voorbeeldvisualisatie van verzamelde gegevens van de bovenstaande app.
Conclusie
In deze zelfstudie hebben we Python, SQLite en Pusher gebruikt om informatie te verzamelen over gebruikers die de website bezoeken en vervolgens de gegevens gebruikt om visualisaties te maken.
Om het simpel te houden, heb ik de app-uitvoer beperkt tot console en JSON om tegemoet te komen aan degenen die niet met Flask jinja-templating hebben gewerkt.
Deze eenvoudige app staat open voor uitbreiding tot een volwaardige tool voor webanalyse. Overweeg de onderstaande bronnen voor aanvullende kennis:
- https://pusher.com/tutorials/web-traffic-monitor-python
- https://fles.palletsprojecten.com/nl/1.1.X/
- https://docs.Python.org/3/bibliotheek/sqlite3.html
- https://pusher.com/docs
