Phenquestions
Embora você possa usar serviços como Google Analytics, Monster Insights, etc., é mais divertido construir um sistema de monitoramento usando Python, banco de dados SQL e Pusher para atualizações de dados em tempo real.
No tutorial de hoje, veremos como criar tal ferramenta usando Python, Flask e Pusher. O tutorial é um spin-off altamente personalizado de um tutorial publicado na página oficial do Pusher.
Requisitos
Para esta construção, você precisará saber como trabalhar com a linguagem de programação python, desenvolvimento web simples e APIs.
Requisitos de instalação
Comece instalando Python em seu sistema. Você também precisará instalar o Pusher e o Flask, httpagentparser.
Criação do banco de dados
O primeiro passo é criar um banco de dados onde os dados são armazenados. Para Python, sqlite3 vem como padrão e usá-lo é simples. Crie um arquivo chamado banco de dados.py e digite o código abaixo:
import sqlite3from sqlite3 import Error
def create_connection (banco de dados):
tentar:
conn = sqlite3.conectar(
banco de dados, nível_de_isolamento = Nenhum, nome_de_check_thread = Falso)
con.row_factory = lambda c, r: dict (
zip ([col [0] para col em c.descrição], r))
retorno conn
exceto Erro como e:
imprimir (e)
def create_table (c, sql):
c.executar (sql)
def update_or_create_page (c, data):
sql = "SELECIONE * DAS páginas onde nome =? e sessão =?"
c.execute (sql, data [: - 1])
resultado = c.fetchone ()
if result == None:
create_pages (c, data)
senão:
imprimir (resultado)
update_pages (c, resultado ['id'])
def create_pages (c, data):
imprimir (dados)
sql = "INSERT INTO páginas (nome, sessão, primeiro_visitado)
VALORES (?,?,?) "
c.executar (sql, dados)
def update_pages (c, pageId):
imprimir (pageId)
sql = "ATUALIZAR páginas
SET visitas = visitas + 1
ONDE id = ?"
c.execute (sql, [pageId])
def create_session (c, data):
sql = "INSERT INTO sessões (ip, continente, país, cidade, sistema operacional, navegador, sessão, created_at)
VALORES (?,?,?,?,?,?,?,?) "
c.executar (sql, dados)
def select_all_sessions (c):
sql = "SELECIONE * DAS sessões"
c.executar (sql)
linhas = c.fetchall ()
retornar linhas
def select_all_pages (c):
sql = "SELECIONE * DAS páginas"
c.executar (sql)
linhas = c.fetchall ()
retornar linhas
def select_all_user_visits (c, session_id):
sql = "SELECIONE * DAS páginas onde sessão =?"
c.execute (sql, [session_id])
linhas = c.fetchall ()
retornar linhas
def main ():
banco de dados = "./ pythonsqlite.db "
sql_create_pages = "" "
CRIAR TABELA SE NÃO EXISTIR páginas (
id inteiro PRIMARY KEY,
nome varchar (225) NÃO NULO,
sessão varchar (255) NÃO NULO,
datetime first_visited NOT NULL,
visitas número inteiro NOT NULL Padrão 1
);
"" "
sql_create_session = "" "
CRIAR TABELA SE NÃO EXISTIR sessões (
id inteiro PRIMARY KEY,
ip varchar (225) NÃO NULO,
continente varchar (225) NÃO NULO,
país varchar (225) NÃO NULO,
cidade varchar (225) NÃO NULO,
os varchar (225) NÃO NULO,
navegador varchar (225) NÃO NULO,
sessão varchar (225) NÃO NULO,
created_at datetime NOT NULL
);
"" "
# criar uma conexão de banco de dados
conn = create_connection (banco de dados)
se conn não for Nenhum:
# criar tabelas
criar_tabela (conexão, sql_create_pages)
criar_tabela (conexão, sql_create_session)
print ("Conexão estabelecida!")
senão:
print ("Não foi possível estabelecer conexão")
if __name__ == '__main__':
a Principal()
Salve o arquivo e execute o script para criar o banco de dados com os dados relevantes.
banco de dados python.py"Conexão estabelecida!”
Em seguida, vá para o empurrador e crie uma conta. Em seguida, crie um aplicativo e siga o assistente para configurá-lo. Depois de concluído, copie as chaves do aplicativo e armazene-as em um dicionário Python, conforme mostrado abaixo.
empurrador = empurrador (app_id = "1079412",
key = "e5d266a24f3502d2b814",
secret = "bab634d2398eb5fcb0f8",
cluster = "us2")
Por fim, crie um aplicativo flask e construa o back-end conforme mostrado no código abaixo:
from flask importar Flask, render_template, request, session, jsonifyimportar urllib.solicitação
de pusher import Pusher
de datetime import datetime
import httpagentparser
import json
importar os
importar hashlib
de importação de banco de dados create_connection, create_session, update_or_create_page, select_all_sessions, select_all_user_visits, select_all_pages
app = Flask (__ name__)
aplicativo.secret_key = os.urandom (24)
# configurar objeto empurrador
empurrador = empurrador (
app_id = "1079412",
key = "e5d266a24f3502d2b814",
secret = "bab634d2398eb5fcb0f8",
cluster = "us2")
banco de dados = "./ pythonsqlite.db "
conn = create_connection (banco de dados)
c = conn.cursor()
userOS = Nenhum
userIP = Nenhum
userCity = None
userBrowser = Nenhum
userCountry = Nenhum
userContinent = None
sessionID = Nenhum
def main ():
conexão global, c
def parseVisitor (dados):
update_or_create_page (c, dados)
empurrador.gatilho (u'pageview ', u'new',
u'page ': dados [0],
u'session ': sessionID,
u'ip ': userIP
)
empurrador.trigger (u'numbers ', u'update',
u'page ': dados [0],
u'session ': sessionID,
u'ip ': userIP
)
@aplicativo.before_request
def getAnalyticsData ():
userOS global, userBrowser, userIP, userContinent, userCity, userCountry, sessionID
userInfo = httpagentparser.detectar (pedido.cabeçalhos.get ('User-Agent'))
userOS = userInfo ['plataforma'] ['nome']
userBrowser = userInfo ['navegador'] ['nome']
userIP = "196.207.130.148 "se pedido.remote_addr == '127.0.0.1 'outro pedido.remote_addr
api = "https: // www.iplocar.io / api / lookup / "+ IP do usuário
tentar:
resp = urllib.solicitação.urlopen (api)
resultado = resp.leitura()
resultado = json.carrega (resultado.decodificar ("utf-8"))
userCountry = resultado ["país"]
userContinent = result ["continente"]
userCity = resultado ["cidade"]
exceto:
print ("Não foi possível encontrar:", IP do usuário)
getSession ()
def getSession ():
ID de sessão global
time = datetime.agora().substituir (microssegundo = 0)
se o 'usuário' não estiver na sessão:
linhas = (str (tempo) + IP do usuário).codificar ('utf-8')
sessão ['usuário'] = hashlib.md5 (linhas).hexdigest ()
sessionID = sessão ['usuário']
empurrador.gatilho (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 (tempo),
)
data = [userIP, userContinent, userCountry,
userCity, userOS, userBrowser, sessionID, time]
create_session (c, dados)
senão:
sessionID = sessão ['usuário']
@aplicativo.rota('/')
índice def ():
data = ['home', sessionID, str (datetime.agora().substituir (microssegundo = 0))]
parseVisitor (dados)
retornar f'Dados de usuário: data '
@aplicativo.rota ('/ get-all-sessions')
def get_all_sessions ():
dados = []
dbRows = select_all_sessions (c)
para linha em dbRows:
dados.acrescentar(
'ip': linha ['ip'],
'continente': linha ['continente'],
'country': linha ['country'],
'cidade': linha ['cidade'],
'os': linha ['os'],
'navegador': linha ['navegador'],
'sessão': linha ['sessão'],
'time': linha ['created_at']
)
retornar jsonify (dados)
if __name__ == '__main__':
a Principal()
aplicativo.executar (debug = True)
Depois de concluído, execute o aplicativo usando o comando flask run e navegue até 127.0.0.1: 5000 / Isso deve registrar o usuário, as informações da sessão do endereço IP específico, incluindo Agente (navegador), País e outros.
Para ver toda a sessão registrada, vá para 127.0.0.1: 5000 / get-all-sessions.
["navegador": "Chrome",
"cidade": "Nova York",
"continente": "América do Norte",
"país": "Estados Unidos",
"ip": "192.148.18.103 ",
"os": "Linux",
"sessão": "9a5d6a84d93ad62a599293acb2e751a1",
"hora": "2021-01-13 02:52:32"
,
"navegador": "Mozilla",
"cidade": "Oregon",
"continente": "América do Norte",
"país": "Estados Unidos",
"ip": "66.115.149.229 ",
"os": "Windows",
"sessão": "64d205c98c839e1d346c733ffd41b27f",
"hora": "2021-01-13 02:54:12"
,
"navegador": "Chrome",
"cidade": "Ogden",
"continente": "América do Norte",
"país": "Estados Unidos",
"ip": "172.231.59.124 ",
"os": "Windows",
"sessão": "3fd564c16a32b5139a8dd0578e36aded",
"hora": "2021-01-13 02:54:37"
,
"navegador": "Chrome",
"cidade": "Nova York",
"continente": "América do Norte",
"país": "Estados Unidos",
"ip": "72.229.28.185 ",
"os": "Windows",
"sessão": "27ad92271023888427da216de10a7cae",
"hora": "2021-01-13 02:55:07"
,
"navegador": "Chrome",
"cidade": "Nairobi",
"continente": "África",
"país": "Quênia",
"ip": "196.207.130.148 ",
"os": "Linux",
"sessão": "c92cdab9eefa2fe121d49264986e7345",
"hora": "2021-01-13 02:56:43"
,
"navegador": "Chrome",
"cidade": "Nairobi",
"continente": "África",
"país": "Quênia",
"ip": "196.207.130.148 ",
"os": "Windows",
"sessão": "31ee28ec6a655e0fa13be4dba8c13861",
"hora": "2021-01-13 03:11:49"
]
Com o aplicativo em execução, você pode alterar aleatoriamente seu endereço IP e navegadores para coletar informações suficientes para seu banco de dados. Usando os dados coletados, você pode usar ferramentas de dados como pilha ELK para visualizá-lo e ver quais locais e navegadores visitam o aplicativo mais.
A seguir está um exemplo de visualização dos dados coletados do aplicativo acima.
Conclusão
Neste tutorial, usamos Python, SQLite e Pusher para coletar informações sobre os usuários que visitam o site e, em seguida, usamos os dados para criar visualizações.
Para manter as coisas simples, limitei a saída do aplicativo para console e JSON para acomodar aqueles que não trabalharam com modelos Flask jinja.
Este aplicativo simples está aberto para expansão em uma ferramenta de análise da web completa. Considere os recursos abaixo para conhecimento adicional:
- https: // empurrador.com / tutorials / web-traffic-monitor-python
- https: // flask.projetos de paletes.com / en / 1.1.x /
- https: // docs.Pitão.org / 3 / library / sqlite3.html
- https: // empurrador.com / docs
