test_logging.py 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411
  1. """Logging is tested against isolated engines, ASGI apps and temporary files only."""
  2. import tests
  3. import ast
  4. import asyncio
  5. from datetime import datetime, timedelta, timezone
  6. import io
  7. import json
  8. import logging
  9. import multiprocessing
  10. from pathlib import Path
  11. import sqlite3
  12. import tempfile
  13. import unittest
  14. from types import SimpleNamespace
  15. from unittest.mock import MagicMock, patch
  16. import httpx
  17. from fastapi import FastAPI, HTTPException, Request
  18. from fastapi.responses import HTMLResponse, StreamingResponse
  19. from fastapi.staticfiles import StaticFiles
  20. from fastapi.testclient import TestClient
  21. from sqlalchemy import Column, Integer, create_engine, text
  22. from sqlalchemy.orm import declarative_base
  23. from sqlalchemy.pool import StaticPool
  24. from app.auth import AuthenticationMiddleware
  25. from app.config import settings, Settings
  26. from app.db import LoggingSession, install_engine_logging
  27. from app.http_logging import install_request_logging
  28. from app.logging_setup import (ApplicationFileHandler, configure_logging, request_context,
  29. run_cli, sanitize_sql)
  30. from app.oauth_token import create_access_token
  31. from app.permissions import Entitlement
  32. import app.logging_setup as setup
  33. SECRET = 'DO_NOT_LOG_SECRET_93'
  34. def config(directory, **kwargs):
  35. values = dict(LOG_DIR=str(directory), LOG_LEVEL='INFO', LOG_TO_FILE=True, LOG_TO_CONSOLE=True,
  36. LOG_RETENTION_DAYS=30, LOG_SQL_STATEMENT=True)
  37. values.update(kwargs)
  38. return SimpleNamespace(**values)
  39. def process_writer(directory, worker):
  40. configure_logging(config(directory, LOG_TO_CONSOLE=False))
  41. for index in range(35):
  42. logging.getLogger('app.worker').info('Worker event', extra={'event':'worker', 'count':worker*1000+index})
  43. for handler in list(logging.getLogger().handlers):
  44. if getattr(handler, '_gc_handler', False): handler.close()
  45. class LoggingTests(unittest.TestCase):
  46. def setUp(self):
  47. self.temp = tempfile.TemporaryDirectory(prefix='gcepic-logging-')
  48. self.root = Path(self.temp.name)
  49. root = logging.getLogger()
  50. self.old_handlers, self.old_level = root.handlers[:], root.level
  51. root.handlers.clear()
  52. self.old_config = setup._configuration
  53. self.logger_states = {name:(logger.level, logger.disabled, logger.propagate, logger.handlers[:])
  54. for name,logger in root.manager.loggerDict.items() if isinstance(logger, logging.Logger)}
  55. self.console = io.StringIO()
  56. self.configuration = config(self.root)
  57. configure_logging(self.configuration, console_stream=self.console)
  58. self.patch = patch.object(settings, 'LOG_SQL_STATEMENT', True)
  59. self.patch.start()
  60. def tearDown(self):
  61. self.patch.stop()
  62. root = logging.getLogger()
  63. for handler in list(root.handlers):
  64. root.removeHandler(handler)
  65. if getattr(handler, '_gc_handler', False): handler.close()
  66. root.handlers[:] = self.old_handlers; root.setLevel(self.old_level)
  67. for name, state in self.logger_states.items():
  68. logger = logging.getLogger(name)
  69. logger.setLevel(state[0]); logger.disabled=state[1]; logger.propagate=state[2]; logger.handlers[:]=state[3]
  70. setup._configuration = self.old_config
  71. self.temp.cleanup()
  72. def records(self):
  73. file = self.root/'application.log'
  74. return [json.loads(line) for line in file.read_text(encoding='utf-8').splitlines()] if file.exists() else []
  75. def engine(self, **kwargs):
  76. engine = create_engine('sqlite://', poolclass=StaticPool, connect_args={'check_same_thread':False}, hide_parameters=True, **kwargs)
  77. install_engine_logging(engine)
  78. self.addCleanup(engine.dispose)
  79. return engine
  80. def test_literals_comments_and_identifiers_are_sanitized(self):
  81. sql = "SELECT [col1], :bind2, N'O''Brien', 123, -1.23e+4, 0xAFF, .5, \"private\" /* private /* nested */ end */ -- private\nFROM [table2]"
  82. safe = sanitize_sql(sql)
  83. self.assertNotIn('private', safe); self.assertNotIn('Brien', safe)
  84. for value in ['123','1.23','0xAFF','.5']: self.assertNotIn(value, safe)
  85. for name in ['[col1]', ':bind2', '[table2]']: self.assertIn(name, safe)
  86. def test_idempotent_initialization_and_configured_outputs(self):
  87. root = logging.getLogger()
  88. count = len(root.handlers)
  89. configure_logging(self.configuration, console_stream=self.console)
  90. self.assertEqual(len(root.handlers), count)
  91. logging.getLogger('app.test').info('Started', extra={'event':'started'})
  92. self.assertEqual(len(self.records()), 1)
  93. self.assertEqual(self.console.getvalue().count('Started'), 1)
  94. self.assertRegex(self.records()[0]['timestamp'], r'\.\d{3}[+-]\d{2}:\d{2}$')
  95. self.assertEqual(Settings(_env_file=None, LOG_LEVEL='debug').LOG_LEVEL, 'DEBUG')
  96. def test_sql_error_logged_once_even_when_caught_and_logged_again(self):
  97. engine = self.engine()
  98. with LoggingSession(engine) as db:
  99. for value in ['first-secret', 'second-secret']:
  100. try:
  101. db.execute(text("SELECT :value FROM missing_table WHERE 91827=1 AND 'private-value'='private-value'").execution_options(query_name='test.missing'), {'value':value})
  102. except Exception:
  103. logging.getLogger('app.service').exception('Operation failed')
  104. records = self.records()
  105. self.assertEqual(len(records), 2)
  106. self.assertTrue(all(row['event']=='database_error' for row in records))
  107. self.assertEqual(records[0]['query_fingerprint'], records[1]['query_fingerprint'])
  108. self.assertEqual(records[0]['query_name'], 'test.missing')
  109. self.assertIn('missing_table', records[0]['sql'])
  110. self.assertTrue(records[0]['exceptions'][0]['frames'])
  111. combined=json.dumps(records)+self.console.getvalue()
  112. for value in ['first-secret','second-secret','private-value','91827','[parameters:']:
  113. self.assertNotIn(value, combined)
  114. def test_connect_and_fetch_errors_are_logged_without_driver_messages(self):
  115. def unavailable(): raise sqlite3.OperationalError(SECRET)
  116. engine = self.engine(creator=unavailable)
  117. with LoggingSession(engine) as db, self.assertRaises(Exception):
  118. db.execute(text('SELECT 1').execution_options(query_name='connect.test'))
  119. self.assertEqual(len(self.records()), 1)
  120. self.assertEqual(self.records()[0]['query_name'], 'connect.test')
  121. class Cursor(sqlite3.Cursor):
  122. def execute(self, sql, params=()):
  123. self.bad_fetch = 'fetch_marker' in sql
  124. return super().execute(sql, params)
  125. def fetchall(self):
  126. if getattr(self,'bad_fetch',False): raise sqlite3.OperationalError(SECRET)
  127. return super().fetchall()
  128. class Connection(sqlite3.Connection):
  129. def cursor(self,*args,**kwargs): return super().cursor(factory=Cursor)
  130. engine = self.engine(creator=lambda: sqlite3.connect(':memory:',factory=Connection))
  131. with LoggingSession(engine) as db, self.assertRaises(Exception):
  132. db.execute(text('SELECT 1 AS fetch_marker')).fetchall()
  133. self.assertEqual(len(self.records()), 2)
  134. self.assertEqual(self.records()[-1]['operation'], 'fetch')
  135. self.assertNotIn(SECRET, json.dumps(self.records())+self.console.getvalue())
  136. def test_commit_rollback_and_flush_errors_are_captured(self):
  137. class Connection(sqlite3.Connection):
  138. fail_commit=False; fail_rollback=False
  139. def commit(self):
  140. if self.fail_commit:
  141. self.fail_commit=False; raise sqlite3.OperationalError(SECRET)
  142. return super().commit()
  143. def rollback(self):
  144. if self.fail_rollback:
  145. self.fail_rollback=False; raise sqlite3.OperationalError(SECRET)
  146. return super().rollback()
  147. engine=self.engine(creator=lambda:sqlite3.connect(':memory:',factory=Connection))
  148. with LoggingSession(engine) as db:
  149. db.execute(text('CREATE TABLE sample (id INTEGER PRIMARY KEY)')); db.commit()
  150. db.execute(text('INSERT INTO sample VALUES (1)'))
  151. db.connection().connection.driver_connection.fail_commit=True
  152. with self.assertRaises(Exception): db.commit()
  153. db.rollback()
  154. db.execute(text('SELECT 1'))
  155. db.connection().connection.driver_connection.fail_rollback=True
  156. with self.assertRaises(Exception): db.rollback()
  157. Base=declarative_base()
  158. class Model(Base):
  159. __tablename__='unique_sample'
  160. id=Column(Integer, primary_key=True)
  161. Base.metadata.create_all(engine)
  162. with LoggingSession(engine) as db:
  163. db.add_all([Model(id=1),Model(id=1)])
  164. with self.assertRaises(Exception): db.flush()
  165. db.rollback()
  166. operations=[row['operation'] for row in self.records() if row.get('event')=='database_error']
  167. self.assertIn('commit',operations); self.assertIn('rollback',operations); self.assertIn('flush',operations)
  168. self.assertEqual(len(operations),3)
  169. self.assertNotIn(SECRET, json.dumps(self.records())+self.console.getvalue())
  170. def app(self):
  171. app=FastAPI()
  172. @app.get('/status/{code}')
  173. async def response(code:int): return HTMLResponse(SECRET,status_code=code)
  174. @app.get('/http-error')
  175. async def http_error(): raise HTTPException(400, SECRET)
  176. @app.get('/number')
  177. async def number(value:int): return value
  178. @app.get('/ok')
  179. async def ok(request:Request):
  180. request.state.principal=SimpleNamespace(username=request.headers.get('x-test-user','tester'))
  181. logging.getLogger('app.service').info('Service event')
  182. from starlette.concurrency import run_in_threadpool
  183. await run_in_threadpool(lambda:logging.getLogger('app.service').info('Thread event'))
  184. await asyncio.sleep(.01)
  185. return {'ok':True}
  186. @app.get('/health')
  187. async def health(): return {'ok':True}
  188. failure=RuntimeError(SECRET)
  189. @app.get('/crash')
  190. async def crash(): raise failure
  191. @app.get('/stream')
  192. async def stream():
  193. async def chunks():
  194. yield b'first'
  195. raise RuntimeError(SECRET)
  196. return StreamingResponse(chunks())
  197. app.mount('/static',StaticFiles(directory=self.root),name='static')
  198. install_request_logging(app)
  199. return app, failure
  200. def test_http_codes_validation_static_and_exception_deduplication(self):
  201. app,failure=self.app()
  202. with TestClient(app,raise_server_exceptions=False) as client:
  203. for code in [400,401,403,404,405,422,500,503]:
  204. response=client.get('/status/'+str(code)+'?token='+SECRET,headers={'Authorization':SECRET,'Cookie':'token='+SECRET})
  205. self.assertEqual(response.status_code,code)
  206. row=self.records()[-1]
  207. self.assertEqual(row['level'],'ERROR' if code>=500 else 'WARNING')
  208. self.assertEqual(row['request_id'],response.headers['X-Request-ID'])
  209. self.assertNotIn('?',row['path'])
  210. self.assertEqual(client.get('/number?value='+SECRET).status_code,422)
  211. self.assertEqual(client.post('/ok',json={'password':SECRET}).status_code,405)
  212. self.assertEqual(client.get('/static/missing.txt').status_code,404)
  213. self.assertEqual(client.get('/http-error').status_code,400)
  214. crash=client.get('/crash')
  215. self.assertEqual(crash.status_code,500)
  216. self.assertTrue(crash.headers['X-Request-ID'])
  217. repeated=client.get('/crash')
  218. self.assertNotEqual(crash.headers['X-Request-ID'],repeated.headers['X-Request-ID'])
  219. logging.getLogger('uvicorn.error').error('Exception in ASGI application',exc_info=(RuntimeError,failure,failure.__traceback__))
  220. technical=[row for row in self.records() if row.get('event')=='unhandled_exception']
  221. self.assertEqual(len(technical),2)
  222. self.assertNotIn(SECRET,json.dumps(self.records())+self.console.getvalue())
  223. def test_caught_query_error_in_http_200_keeps_request_context(self):
  224. app=FastAPI()
  225. engine=self.engine()
  226. @app.get('/caught-query')
  227. def caught(request:Request):
  228. request.state.principal=SimpleNamespace(username='tester')
  229. with LoggingSession(engine) as db:
  230. try:
  231. db.execute(text('SELECT :secret FROM missing_http_table').execution_options(query_name='http.caught'), {'secret':SECRET})
  232. except Exception:
  233. logging.getLogger('app.service').exception('Query handled')
  234. return HTMLResponse('Formularfehler',status_code=200)
  235. install_request_logging(app)
  236. with TestClient(app) as client:
  237. response=client.get('/caught-query')
  238. rows=self.records()
  239. self.assertEqual([row['event'] for row in rows], ['database_error','http_completed'])
  240. self.assertTrue(all(row['request_id']==response.headers['x-request-id'] for row in rows))
  241. self.assertTrue(all(row['user']=='tester' for row in rows))
  242. self.assertEqual(rows[-1]['status'],200)
  243. self.assertNotIn(SECRET,json.dumps(rows)+self.console.getvalue())
  244. def test_stream_error_keeps_sent_status_and_health_success_is_debug(self):
  245. app,_=self.app()
  246. with TestClient(app,raise_server_exceptions=False) as client:
  247. client.get('/health'); self.assertEqual(self.records(),[])
  248. response=client.get('/stream')
  249. self.assertEqual(response.status_code,200)
  250. summary=next(row for row in self.records() if row.get('event')=='http_completed')
  251. self.assertEqual(summary['status'],200); self.assertEqual(summary['outcome'],'stream_failed')
  252. self.assertEqual(summary['level'],'ERROR')
  253. self.assertNotIn(SECRET,json.dumps(self.records()))
  254. def test_parallel_request_and_thread_contexts_are_isolated(self):
  255. app,_=self.app()
  256. async def requests():
  257. async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app),base_url='http://test') as client:
  258. return await asyncio.gather(*[client.get('/ok?secret='+SECRET,headers={'x-test-user':user,'X-Request-ID':SECRET}) for user in ['alpha','beta']])
  259. responses=asyncio.run(requests())
  260. ids={response.headers['x-request-id'] for response in responses}
  261. self.assertEqual(len(ids),2); self.assertNotIn(SECRET,ids)
  262. users={row['request_id']:row['user'] for row in self.records() if row.get('event')=='http_completed'}
  263. self.assertEqual(set(users.values()),{'alpha','beta'})
  264. for row in self.records(): self.assertEqual(row['user'],users[row['request_id']])
  265. self.assertIsNone(request_context.get())
  266. def test_early_auth_errors_and_htmx_login_are_observed(self):
  267. app=FastAPI()
  268. @app.post('/write')
  269. def write(): return {'ok':True}
  270. app.add_middleware(AuthenticationMiddleware)
  271. install_request_logging(app)
  272. entitlement=(Entitlement('1','10','SC','Mitarbeiter',100),)
  273. with patch.multiple(settings,TRUSTED_PROXY_IPS=['testclient'],DEBUG_AUTH=False,COOKIE_SECURE=False), \
  274. patch('app.auth.SessionLocal',return_value=MagicMock()), \
  275. patch('app.auth.load_entitlements',return_value=entitlement), \
  276. patch('app.auth.lookup_directory_user',return_value=None), TestClient(app) as client:
  277. denied=client.post('/write',headers={'X-Remote-User':'invalid'})
  278. self.assertEqual(denied.status_code,401)
  279. login=client.post('/write',headers={'HX-Request':'true'})
  280. self.assertEqual(login.status_code,200); self.assertIn('HX-Redirect',login.headers)
  281. token=create_access_token(username='tester',name='Tester',email='',role='Mitarbeiter',auth_source='ldap',csrf='csrf')
  282. client.cookies.set(settings.SESSION_COOKIE_NAME,token)
  283. self.assertEqual(client.post('/write').status_code,403)
  284. statuses=[row['status'] for row in self.records() if row.get('event')=='http_completed']
  285. self.assertEqual(statuses,[401,200,403])
  286. self.assertTrue(any(row.get('event')=='auth_login_required' for row in self.records()))
  287. def test_retention_rotation_parallel_processes_and_fallback(self):
  288. old=self.root/'application.log.2001-01-01'; old.write_text('expired',encoding='utf-8')
  289. preserved=self.root/'webservice.log'; preserved.write_text('keep',encoding='utf-8')
  290. handler=next(handler for handler in logging.getLogger().handlers if isinstance(handler,ApplicationFileHandler))
  291. handler.cleanup_archives(); self.assertFalse(old.exists()); self.assertTrue(preserved.exists())
  292. logging.getLogger('app.test').info('before rotation')
  293. handler.clh._do_lock()
  294. try: handler.doRollover()
  295. finally: handler.clh._do_unlock()
  296. logging.getLogger('app.test').info('after rotation')
  297. self.assertEqual(self.records()[-1]['message'],'after rotation')
  298. with patch.object(handler.clh,'do_write',side_effect=PermissionError(SECRET)), patch('sys.stderr',new=io.StringIO()) as fallback:
  299. logging.getLogger('app.test').error('safe failure')
  300. self.assertIn('Konsolenfallback',fallback.getvalue()); self.assertNotIn(SECRET,fallback.getvalue())
  301. directory=self.root/'workers'; directory.mkdir()
  302. seed=ApplicationFileHandler(str(directory/'application.log'))
  303. seed.setFormatter(setup.JsonFormatter()); seed.addFilter(setup.ContextFilter())
  304. seed.handle(logging.LogRecord('app.worker',logging.INFO,__file__,0,'Before shared rotation',(),None))
  305. seed.clh._do_lock()
  306. try:
  307. seed.rolloverAt=int(datetime.now(timezone.utc).timestamp())-10
  308. seed.write_rollover_time()
  309. finally:
  310. seed.clh._do_unlock()
  311. seed.close()
  312. processes=[multiprocessing.get_context('spawn').Process(target=process_writer,args=(str(directory),n)) for n in range(3)]
  313. for process in processes: process.start()
  314. for process in processes:
  315. process.join(20)
  316. if process.is_alive(): process.terminate(); self.fail('Logging worker timed out')
  317. self.assertEqual(process.exitcode,0)
  318. rows=[json.loads(line) for line in (directory/'application.log').read_text(encoding='utf-8').splitlines()]
  319. self.assertEqual(len(rows),105); self.assertEqual(len({row['count'] for row in rows}),105)
  320. archived=[json.loads(line) for archive in directory.glob('application.log.*') for line in archive.read_text(encoding='utf-8').splitlines()]
  321. self.assertEqual([row['message'] for row in archived],['Before shared rotation'])
  322. def test_cli_failure_and_disabled_sql_text(self):
  323. with patch('app.logging_setup.configure_logging'), self.assertRaises(SystemExit):
  324. run_cli(lambda: (_ for _ in ()).throw(RuntimeError(SECRET)))
  325. self.assertEqual(self.records()[-1]['event'],'cli_failed')
  326. with patch.object(settings,'LOG_SQL_STATEMENT',False), LoggingSession(self.engine()) as db:
  327. with self.assertRaises(Exception): db.execute(text('SELECT * FROM missing'))
  328. self.assertNotIn('sql',self.records()[-1]); self.assertNotIn(SECRET,self.console.getvalue())
  329. def test_project_python_has_no_print_calls(self):
  330. root=Path(__file__).resolve().parent.parent
  331. paths=list((root/'app').rglob('*.py'))+list(root.glob('*.py'))+list((root/'tests').glob('*.py'))
  332. for path in paths:
  333. tree=ast.parse(path.read_text(encoding='utf-8-sig'))
  334. for node in ast.walk(tree):
  335. self.assertFalse(isinstance(node,ast.Call) and isinstance(node.func,ast.Name) and node.func.id=='print',str(path))
  336. def test_file_configuration_failure_falls_back_without_exposing_exception(self):
  337. output=io.StringIO()
  338. with patch('app.logging_setup.ApplicationFileHandler',side_effect=PermissionError(SECRET)):
  339. configure_logging(config(self.root/'denied',LOG_TO_CONSOLE=False),console_stream=output)
  340. logging.getLogger('app.service').error('Still available')
  341. self.assertIn('Konsolenfallback',output.getvalue())
  342. self.assertIn('Still available',output.getvalue())
  343. self.assertNotIn(SECRET,output.getvalue())
  344. def test_cleanup_queries_are_parameterized_and_cli_imports_work(self):
  345. import app.cleanup_comments as cleanup
  346. import filter_export
  347. rows=[SimpleNamespace(Client_DB='1',Beleg_Nr='R1',Timestamp=datetime(2026,1,1),
  348. Benutzer_ID='tester',Kommentar='AZ: 123/45 Schaden '+SECRET+' bei '+SECRET+' eingereicht')]
  349. db=MagicMock()
  350. db.execute.return_value.fetchall.return_value=rows
  351. with patch('app.cleanup_comments.SessionLocal',return_value=db):
  352. db.__enter__.return_value=db
  353. cleanup.main()
  354. cleanup.get_details_from_comments()
  355. writes=[call for call in db.execute.call_args_list if 'INSERT' in str(call.args[0]) or 'UPDATE' in str(call.args[0])]
  356. self.assertEqual(len(writes),2)
  357. for call in writes:
  358. self.assertNotIn(SECRET,str(call.args[0]))
  359. self.assertIn(SECRET,str(call.args[1]))
  360. filter_export.import_filter_config2()
  361. self.assertNotIn(SECRET,self.console.getvalue())
  362. def test_mail_and_docuware_metadata_never_dump_payloads(self):
  363. import app.imap as imap
  364. import app.docuware_search as docuware_search
  365. payload=SECRET.encode()
  366. message=SimpleNamespace(subject='WRG123456 '+SECRET,
  367. attachments=[SimpleNamespace(filename=SECRET+'.pdf',payload=payload,size=len(payload))])
  368. db=MagicMock(); db.__enter__.return_value=db
  369. db.execute.return_value.fetchall.return_value=[('1','WRG123456')]
  370. mailbox=MagicMock(); mailbox.login.return_value.__enter__.return_value=mailbox
  371. mailbox.fetch.return_value=[message]
  372. with patch.dict('os.environ',{'LOCAL_STORAGE':str(self.root/'files')}), \
  373. patch('app.imap.SessionLocal',return_value=db),patch('app.imap.MailBox',return_value=mailbox):
  374. imap.main()
  375. connection=SimpleNamespace(organizations=[SimpleNamespace(file_cabinets=[SECRET],baskets=[SECRET])])
  376. with patch('app.docuware_search.docuware.connect',return_value=connection):
  377. docuware_search.main()
  378. self.assertTrue(any(row.get('event')=='mail_attachment_saved' and row['size_bytes']==len(payload) for row in self.records()))
  379. self.assertNotIn(SECRET,json.dumps(self.records())+self.console.getvalue())
  380. if __name__=='__main__': unittest.main()