98 lines
7.2 KiB
Python
98 lines
7.2 KiB
Python
#!/usr/bin/env python3
|
|
"""Real HTTP/PG/Valkey experiment. Run only on dedicated research network.
|
|
No source instrumentation, secret output, inferred SELECT counts or retries.
|
|
"""
|
|
import argparse, csv, datetime, hashlib, http.client, json, math, os
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
from pathlib import Path
|
|
from threading import Barrier
|
|
import time
|
|
import sys
|
|
sys.path.insert(0, str(Path(__file__).resolve().parents[2]/'tests'))
|
|
from client import Client
|
|
import psycopg
|
|
from psycopg import sql
|
|
import redis
|
|
|
|
def main():
|
|
p=argparse.ArgumentParser(); p.add_argument('--label',required=True); p.add_argument('--out',required=True); p.add_argument('--pilot',action='store_true'); a=p.parse_args()
|
|
out=Path(a.out); out.mkdir(parents=True,exist_ok=False)
|
|
plan=json.loads(Path('/workspace/evidence/grade5/plan.json').read_text(encoding='utf-8-sig'))
|
|
url=Path(os.environ['DATABASE_URL_FILE']).read_text().strip()
|
|
cache_url=Path(os.environ['CACHE_URL_FILE']).read_text().strip()
|
|
with psycopg.connect(url,autocommit=True) as setup:
|
|
setup.execute('CREATE EXTENSION IF NOT EXISTS pg_stat_statements')
|
|
if not setup.execute("SELECT 1 FROM pg_roles WHERE rolname='g5observer'").fetchone():
|
|
password=psycopg.conninfo.conninfo_to_dict(url)['password']
|
|
setup.execute(sql.SQL('CREATE ROLE g5observer LOGIN SUPERUSER PASSWORD {}').format(sql.Literal(password)))
|
|
app_oid=setup.execute("SELECT oid FROM pg_roles WHERE rolname='messenger'").fetchone()[0]
|
|
observer=psycopg.connect(url,user='g5observer',autocommit=True)
|
|
blocker=psycopg.connect(url,user='g5observer',autocommit=True)
|
|
cache=redis.Redis.from_url(cache_url,decode_responses=True,socket_timeout=2)
|
|
c=Client('http://api:8080'); actor=c.user('g5bench'); key='profile:'+actor['id']
|
|
c.call('GET','/api/v1/users/me',actor=actor,schema='User')
|
|
clients=plan['clients']; conns=[http.client.HTTPConnection('api',8080,timeout=plan['http_timeout_seconds']) for _ in range(clients)]
|
|
for conn in conns:
|
|
conn.request('GET','/health/live'); response=conn.getresponse(); response.read(); assert response.status==200
|
|
def stats():
|
|
return {str(qid):{'query':query,'calls':calls,'exec_ms':ms,'rows':rows} for qid,query,calls,ms,rows in observer.execute('SELECT queryid,query,calls,total_exec_time,rows FROM pg_stat_statements WHERE userid=%s AND dbid=(SELECT oid FROM pg_database WHERE datname=current_database())',(app_oid,))}
|
|
def category(query):
|
|
if query.startswith('SELECT user_id FROM sessions WHERE token_hash='): return 'session_select'
|
|
if query.startswith('SELECT id,username,display_name,created_at FROM users WHERE id='): return 'profile_select'
|
|
if query.strip() in ('BEGIN','COMMIT','ROLLBACK'): return 'transaction'
|
|
if query.startswith('SELECT $1'): return 'health_or_constant'
|
|
return 'other'
|
|
request_file=(out/'requests.csv').open('w',newline=''); w=csv.DictWriter(request_file,fieldnames=['mode','repeat','burst','client','status','latency_ms','error']); w.writeheader()
|
|
bursts=[]; start_all=time.monotonic()
|
|
count=2 if a.pilot else plan['bursts_per_mode_repeat']; repeats=1 if a.pilot else plan['repeats']
|
|
def request(i,barrier):
|
|
conn=conns[i]; barrier.wait(timeout=10); started=time.perf_counter(); status=0; error=''
|
|
try:
|
|
conn.request('GET','/api/v1/users/me',headers={'Authorization':'Bearer '+actor['token']})
|
|
response=conn.getresponse(); data=response.read(); status=response.status
|
|
value=json.loads(data)
|
|
if status==200 and value!=actor['user']: error='UserMismatch'
|
|
if not response.getheader('X-Request-Id'): error='MissingRequestId'
|
|
if status!=200: error='HTTP'+str(status)
|
|
except Exception as exc:
|
|
error=type(exc).__name__; conn.close()
|
|
return {'client':i,'status':status,'latency_ms':(time.perf_counter()-started)*1000,'error':error}
|
|
with ThreadPoolExecutor(max_workers=clients) as executor:
|
|
for repeat in range(1,repeats+1):
|
|
modes=plan['modes']; modes=modes[repeat-1:]+modes[:repeat-1]
|
|
for mode in modes:
|
|
for burst in range(1,count+1):
|
|
if mode=='warm':
|
|
c.call('GET','/api/v1/users/me',actor=actor,schema='User'); assert cache.exists(key)
|
|
else:
|
|
cache.delete(key); assert not cache.exists(key)
|
|
if mode=='contended':
|
|
blocker.execute('BEGIN'); blocker.execute('LOCK TABLE users IN ACCESS EXCLUSIVE MODE')
|
|
before=stats(); barrier=Barrier(clients+1)
|
|
futures=[executor.submit(request,i,barrier) for i in range(clients)]
|
|
started=time.monotonic(); barrier.wait(timeout=10)
|
|
lock_waiters=None; lock_elapsed=0
|
|
if mode=='contended':
|
|
time.sleep(plan['contended_users_lock_seconds'])
|
|
lock_waiters=observer.execute("SELECT count(*) FROM pg_stat_activity WHERE usename='messenger' AND wait_event_type='Lock'").fetchone()[0]
|
|
blocker.execute('COMMIT'); lock_elapsed=time.monotonic()-started
|
|
results=[f.result() for f in futures]; elapsed=time.monotonic()-started
|
|
after=stats(); deltas=[]; totals={cat:0 for cat in ['session_select','profile_select','transaction','health_or_constant','other']}
|
|
for qid,entry in after.items():
|
|
old=before.get(qid,{'calls':0,'exec_ms':0,'rows':0}); calls=entry['calls']-old['calls']
|
|
if calls:
|
|
kind=category(entry['query']); totals[kind]+=calls
|
|
deltas.append({'queryid':qid,'query':entry['query'],'category':kind,'calls':calls,'exec_ms':entry['exec_ms']-old['exec_ms'],'rows':entry['rows']-old['rows']})
|
|
for result in results: w.writerow({'mode':mode,'repeat':repeat,'burst':burst,**result})
|
|
request_file.flush()
|
|
bursts.append({'mode':mode,'repeat':repeat,'burst':burst,'elapsed_s':elapsed,'lock_elapsed_s':lock_elapsed,'profile_lock_waiters':lock_waiters,'counts':totals,'all_sql':sum(totals.values()),'queries':deltas})
|
|
(out/'bursts.json').write_text(json.dumps(bursts,indent=2))
|
|
print(json.dumps({'repeat':repeat,'mode':mode,'profile_select':sum(b['counts']['profile_select'] for b in bursts if b['mode']==mode and b['repeat']==repeat),'requests':count*clients}),flush=True)
|
|
request_file.close()
|
|
meta={'label':a.label,'pilot':a.pilot,'started_utc':datetime.datetime.now(datetime.timezone.utc).isoformat(),'wall_s':time.monotonic()-start_all,'plan':plan,'python':sys.version,'app_src_sha256':{p.name:hashlib.sha256(p.read_bytes()).hexdigest() for p in sorted(Path('/app/src').glob('*.py'))},'pg_version':observer.execute('SHOW server_version').fetchone()[0],'cache_version':cache.info('server')['redis_version']}
|
|
(out/'meta.json').write_text(json.dumps(meta,indent=2))
|
|
for conn in conns: conn.close()
|
|
cache.delete(key); observer.close(); blocker.close()
|
|
print('COMPLETE',a.label,'wall_s',round(meta['wall_s'],3),flush=True)
|
|
if __name__=='__main__': main()
|