Coverage for /pythoncovmergedfiles/medio/medio/src/aiohttp/aiohttp/tracing.py: 64%

1from types import SimpleNamespace 

2from typing import TYPE_CHECKING, Any, Awaitable, Generic, Protocol, TypeVar, overload 

3 

4from aiosignal import Signal 

5from multidict import CIMultiDict 

6from yarl import URL 

7 

8from .client_reqrep import ClientResponse 

9from .helpers import frozen_dataclass_decorator 

10 

11if TYPE_CHECKING: 

12 from .client import ClientSession 

13 

14 _ParamT_contra = TypeVar("_ParamT_contra", contravariant=True) 

15 

16 class _SignalCallback(Protocol[_ParamT_contra]): 

17 def __call__( 

18 self, 

19 __client_session: ClientSession, 

20 __trace_config_ctx: SimpleNamespace, 

21 __params: _ParamT_contra, 

22 ) -> Awaitable[None]: ... 

23 

24 

25__all__ = ( 

26 "TraceConfig", 

27 "TraceRequestStartParams", 

28 "TraceRequestEndParams", 

29 "TraceRequestExceptionParams", 

30 "TraceConnectionQueuedStartParams", 

31 "TraceConnectionQueuedEndParams", 

32 "TraceConnectionCreateStartParams", 

33 "TraceConnectionCreateEndParams", 

34 "TraceConnectionReuseconnParams", 

35 "TraceDnsResolveHostStartParams", 

36 "TraceDnsResolveHostEndParams", 

37 "TraceDnsCacheHitParams", 

38 "TraceDnsCacheMissParams", 

39 "TraceRequestRedirectParams", 

40 "TraceRequestChunkSentParams", 

41 "TraceResponseChunkReceivedParams", 

42 "TraceRequestHeadersSentParams", 

43) 

44 

45_T = TypeVar("_T", covariant=True) 

46 

47 

48class _Factory(Protocol[_T]): 

49 def __call__(self, **kwargs: Any) -> _T: ... 

50 

51 

52class TraceConfig(Generic[_T]): 

53 """First-class used to trace requests launched via ClientSession objects.""" 

54 

55 @overload 

56 def __init__(self: "TraceConfig[SimpleNamespace]") -> None: ... 

57 @overload 

58 def __init__(self, trace_config_ctx_factory: _Factory[_T]) -> None: ... 

59 def __init__( 

60 self, trace_config_ctx_factory: _Factory[Any] = SimpleNamespace 

61 ) -> None: 

62 self._on_request_start: Signal[_SignalCallback[TraceRequestStartParams]] = ( 

63 Signal(self) 

64 ) 

65 self._on_request_chunk_sent: Signal[ 

66 _SignalCallback[TraceRequestChunkSentParams] 

67 ] = Signal(self) 

68 self._on_response_chunk_received: Signal[ 

69 _SignalCallback[TraceResponseChunkReceivedParams] 

70 ] = Signal(self) 

71 self._on_request_end: Signal[_SignalCallback[TraceRequestEndParams]] = Signal( 

72 self 

73 ) 

74 self._on_request_exception: Signal[ 

75 _SignalCallback[TraceRequestExceptionParams] 

76 ] = Signal(self) 

77 self._on_request_redirect: Signal[ 

78 _SignalCallback[TraceRequestRedirectParams] 

79 ] = Signal(self) 

80 self._on_connection_queued_start: Signal[ 

81 _SignalCallback[TraceConnectionQueuedStartParams] 

82 ] = Signal(self) 

83 self._on_connection_queued_end: Signal[ 

84 _SignalCallback[TraceConnectionQueuedEndParams] 

85 ] = Signal(self) 

86 self._on_connection_create_start: Signal[ 

87 _SignalCallback[TraceConnectionCreateStartParams] 

88 ] = Signal(self) 

89 self._on_connection_create_end: Signal[ 

90 _SignalCallback[TraceConnectionCreateEndParams] 

91 ] = Signal(self) 

92 self._on_connection_reuseconn: Signal[ 

93 _SignalCallback[TraceConnectionReuseconnParams] 

94 ] = Signal(self) 

95 self._on_dns_resolvehost_start: Signal[ 

96 _SignalCallback[TraceDnsResolveHostStartParams] 

97 ] = Signal(self) 

98 self._on_dns_resolvehost_end: Signal[ 

99 _SignalCallback[TraceDnsResolveHostEndParams] 

100 ] = Signal(self) 

101 self._on_dns_cache_hit: Signal[_SignalCallback[TraceDnsCacheHitParams]] = ( 

102 Signal(self) 

103 ) 

104 self._on_dns_cache_miss: Signal[_SignalCallback[TraceDnsCacheMissParams]] = ( 

105 Signal(self) 

106 ) 

107 self._on_request_headers_sent: Signal[ 

108 _SignalCallback[TraceRequestHeadersSentParams] 

109 ] = Signal(self) 

110 

111 self._trace_config_ctx_factory: _Factory[_T] = trace_config_ctx_factory 

112 

113 def trace_config_ctx(self, trace_request_ctx: Any = None) -> _T: 

114 """Return a new trace_config_ctx instance""" 

115 return self._trace_config_ctx_factory(trace_request_ctx=trace_request_ctx) 

116 

117 def freeze(self) -> None: 

118 self._on_request_start.freeze() 

119 self._on_request_chunk_sent.freeze() 

120 self._on_response_chunk_received.freeze() 

121 self._on_request_end.freeze() 

122 self._on_request_exception.freeze() 

123 self._on_request_redirect.freeze() 

124 self._on_connection_queued_start.freeze() 

125 self._on_connection_queued_end.freeze() 

126 self._on_connection_create_start.freeze() 

127 self._on_connection_create_end.freeze() 

128 self._on_connection_reuseconn.freeze() 

129 self._on_dns_resolvehost_start.freeze() 

130 self._on_dns_resolvehost_end.freeze() 

131 self._on_dns_cache_hit.freeze() 

132 self._on_dns_cache_miss.freeze() 

133 self._on_request_headers_sent.freeze() 

134 

135 @property 

136 def on_request_start(self) -> "Signal[_SignalCallback[TraceRequestStartParams]]": 

137 return self._on_request_start 

138 

139 @property 

140 def on_request_chunk_sent( 

141 self, 

142 ) -> "Signal[_SignalCallback[TraceRequestChunkSentParams]]": 

143 return self._on_request_chunk_sent 

144 

145 @property 

146 def on_response_chunk_received( 

147 self, 

148 ) -> "Signal[_SignalCallback[TraceResponseChunkReceivedParams]]": 

149 return self._on_response_chunk_received 

150 

151 @property 

152 def on_request_end(self) -> "Signal[_SignalCallback[TraceRequestEndParams]]": 

153 return self._on_request_end 

154 

155 @property 

156 def on_request_exception( 

157 self, 

158 ) -> "Signal[_SignalCallback[TraceRequestExceptionParams]]": 

159 return self._on_request_exception 

160 

161 @property 

162 def on_request_redirect( 

163 self, 

164 ) -> "Signal[_SignalCallback[TraceRequestRedirectParams]]": 

165 return self._on_request_redirect 

166 

167 @property 

168 def on_connection_queued_start( 

169 self, 

170 ) -> "Signal[_SignalCallback[TraceConnectionQueuedStartParams]]": 

171 return self._on_connection_queued_start 

172 

173 @property 

174 def on_connection_queued_end( 

175 self, 

176 ) -> "Signal[_SignalCallback[TraceConnectionQueuedEndParams]]": 

177 return self._on_connection_queued_end 

178 

179 @property 

180 def on_connection_create_start( 

181 self, 

182 ) -> "Signal[_SignalCallback[TraceConnectionCreateStartParams]]": 

183 return self._on_connection_create_start 

184 

185 @property 

186 def on_connection_create_end( 

187 self, 

188 ) -> "Signal[_SignalCallback[TraceConnectionCreateEndParams]]": 

189 return self._on_connection_create_end 

190 

191 @property 

192 def on_connection_reuseconn( 

193 self, 

194 ) -> "Signal[_SignalCallback[TraceConnectionReuseconnParams]]": 

195 return self._on_connection_reuseconn 

196 

197 @property 

198 def on_dns_resolvehost_start( 

199 self, 

200 ) -> "Signal[_SignalCallback[TraceDnsResolveHostStartParams]]": 

201 return self._on_dns_resolvehost_start 

202 

203 @property 

204 def on_dns_resolvehost_end( 

205 self, 

206 ) -> "Signal[_SignalCallback[TraceDnsResolveHostEndParams]]": 

207 return self._on_dns_resolvehost_end 

208 

209 @property 

210 def on_dns_cache_hit(self) -> "Signal[_SignalCallback[TraceDnsCacheHitParams]]": 

211 return self._on_dns_cache_hit 

212 

213 @property 

214 def on_dns_cache_miss(self) -> "Signal[_SignalCallback[TraceDnsCacheMissParams]]": 

215 return self._on_dns_cache_miss 

216 

217 @property 

218 def on_request_headers_sent( 

219 self, 

220 ) -> "Signal[_SignalCallback[TraceRequestHeadersSentParams]]": 

221 return self._on_request_headers_sent 

222 

223 

224@frozen_dataclass_decorator 

225class TraceRequestStartParams: 

226 """Parameters sent by the `on_request_start` signal""" 

227 

228 method: str 

229 url: URL 

230 headers: "CIMultiDict[str]" 

231 

232 

233@frozen_dataclass_decorator 

234class TraceRequestChunkSentParams: 

235 """Parameters sent by the `on_request_chunk_sent` signal""" 

236 

237 method: str 

238 url: URL 

239 chunk: bytes 

240 

241 

242@frozen_dataclass_decorator 

243class TraceResponseChunkReceivedParams: 

244 """Parameters sent by the `on_response_chunk_received` signal""" 

245 

246 method: str 

247 url: URL 

248 chunk: bytes 

249 

250 

251@frozen_dataclass_decorator 

252class TraceRequestEndParams: 

253 """Parameters sent by the `on_request_end` signal""" 

254 

255 method: str 

256 url: URL 

257 headers: "CIMultiDict[str]" 

258 response: ClientResponse 

259 

260 

261@frozen_dataclass_decorator 

262class TraceRequestExceptionParams: 

263 """Parameters sent by the `on_request_exception` signal""" 

264 

265 method: str 

266 url: URL 

267 headers: "CIMultiDict[str]" 

268 exception: BaseException 

269 

270 

271@frozen_dataclass_decorator 

272class TraceRequestRedirectParams: 

273 """Parameters sent by the `on_request_redirect` signal""" 

274 

275 method: str 

276 url: URL 

277 headers: "CIMultiDict[str]" 

278 response: ClientResponse 

279 

280 

281@frozen_dataclass_decorator 

282class TraceConnectionQueuedStartParams: 

283 """Parameters sent by the `on_connection_queued_start` signal""" 

284 

285 

286@frozen_dataclass_decorator 

287class TraceConnectionQueuedEndParams: 

288 """Parameters sent by the `on_connection_queued_end` signal""" 

289 

290 

291@frozen_dataclass_decorator 

292class TraceConnectionCreateStartParams: 

293 """Parameters sent by the `on_connection_create_start` signal""" 

294 

295 

296@frozen_dataclass_decorator 

297class TraceConnectionCreateEndParams: 

298 """Parameters sent by the `on_connection_create_end` signal""" 

299 

300 

301@frozen_dataclass_decorator 

302class TraceConnectionReuseconnParams: 

303 """Parameters sent by the `on_connection_reuseconn` signal""" 

304 

305 

306@frozen_dataclass_decorator 

307class TraceDnsResolveHostStartParams: 

308 """Parameters sent by the `on_dns_resolvehost_start` signal""" 

309 

310 host: str 

311 

312 

313@frozen_dataclass_decorator 

314class TraceDnsResolveHostEndParams: 

315 """Parameters sent by the `on_dns_resolvehost_end` signal""" 

316 

317 host: str 

318 

319 

320@frozen_dataclass_decorator 

321class TraceDnsCacheHitParams: 

322 """Parameters sent by the `on_dns_cache_hit` signal""" 

323 

324 host: str 

325 

326 

327@frozen_dataclass_decorator 

328class TraceDnsCacheMissParams: 

329 """Parameters sent by the `on_dns_cache_miss` signal""" 

330 

331 host: str 

332 

333 

334@frozen_dataclass_decorator 

335class TraceRequestHeadersSentParams: 

336 """Parameters sent by the `on_request_headers_sent` signal""" 

337 

338 method: str 

339 url: URL 

340 headers: "CIMultiDict[str]" 

341 

342 

343class Trace: 

344 """Internal dependency holder class. 

345 

346 Used to keep together the main dependencies used 

347 at the moment of send a signal. 

348 """ 

349 

350 def __init__( 

351 self, 

352 session: "ClientSession", 

353 trace_config: TraceConfig[object], 

354 trace_config_ctx: Any, 

355 ) -> None: 

356 self._trace_config = trace_config 

357 self._trace_config_ctx = trace_config_ctx 

358 self._session = session 

359 

360 async def send_request_start( 

361 self, method: str, url: URL, headers: "CIMultiDict[str]" 

362 ) -> None: 

363 return await self._trace_config.on_request_start.send( 

364 self._session, 

365 self._trace_config_ctx, 

366 TraceRequestStartParams(method, url, headers), 

367 ) 

368 

369 async def send_request_chunk_sent( 

370 self, method: str, url: URL, chunk: bytes 

371 ) -> None: 

372 return await self._trace_config.on_request_chunk_sent.send( 

373 self._session, 

374 self._trace_config_ctx, 

375 TraceRequestChunkSentParams(method, url, chunk), 

376 ) 

377 

378 async def send_response_chunk_received( 

379 self, method: str, url: URL, chunk: bytes 

380 ) -> None: 

381 return await self._trace_config.on_response_chunk_received.send( 

382 self._session, 

383 self._trace_config_ctx, 

384 TraceResponseChunkReceivedParams(method, url, chunk), 

385 ) 

386 

387 async def send_request_end( 

388 self, 

389 method: str, 

390 url: URL, 

391 headers: "CIMultiDict[str]", 

392 response: ClientResponse, 

393 ) -> None: 

394 return await self._trace_config.on_request_end.send( 

395 self._session, 

396 self._trace_config_ctx, 

397 TraceRequestEndParams(method, url, headers, response), 

398 ) 

399 

400 async def send_request_exception( 

401 self, 

402 method: str, 

403 url: URL, 

404 headers: "CIMultiDict[str]", 

405 exception: BaseException, 

406 ) -> None: 

407 return await self._trace_config.on_request_exception.send( 

408 self._session, 

409 self._trace_config_ctx, 

410 TraceRequestExceptionParams(method, url, headers, exception), 

411 ) 

412 

413 async def send_request_redirect( 

414 self, 

415 method: str, 

416 url: URL, 

417 headers: "CIMultiDict[str]", 

418 response: ClientResponse, 

419 ) -> None: 

420 return await self._trace_config._on_request_redirect.send( 

421 self._session, 

422 self._trace_config_ctx, 

423 TraceRequestRedirectParams(method, url, headers, response), 

424 ) 

425 

426 async def send_connection_queued_start(self) -> None: 

427 return await self._trace_config.on_connection_queued_start.send( 

428 self._session, self._trace_config_ctx, TraceConnectionQueuedStartParams() 

429 ) 

430 

431 async def send_connection_queued_end(self) -> None: 

432 return await self._trace_config.on_connection_queued_end.send( 

433 self._session, self._trace_config_ctx, TraceConnectionQueuedEndParams() 

434 ) 

435 

436 async def send_connection_create_start(self) -> None: 

437 return await self._trace_config.on_connection_create_start.send( 

438 self._session, self._trace_config_ctx, TraceConnectionCreateStartParams() 

439 ) 

440 

441 async def send_connection_create_end(self) -> None: 

442 return await self._trace_config.on_connection_create_end.send( 

443 self._session, self._trace_config_ctx, TraceConnectionCreateEndParams() 

444 ) 

445 

446 async def send_connection_reuseconn(self) -> None: 

447 return await self._trace_config.on_connection_reuseconn.send( 

448 self._session, self._trace_config_ctx, TraceConnectionReuseconnParams() 

449 ) 

450 

451 async def send_dns_resolvehost_start(self, host: str) -> None: 

452 return await self._trace_config.on_dns_resolvehost_start.send( 

453 self._session, self._trace_config_ctx, TraceDnsResolveHostStartParams(host) 

454 ) 

455 

456 async def send_dns_resolvehost_end(self, host: str) -> None: 

457 return await self._trace_config.on_dns_resolvehost_end.send( 

458 self._session, self._trace_config_ctx, TraceDnsResolveHostEndParams(host) 

459 ) 

460 

461 async def send_dns_cache_hit(self, host: str) -> None: 

462 return await self._trace_config.on_dns_cache_hit.send( 

463 self._session, self._trace_config_ctx, TraceDnsCacheHitParams(host) 

464 ) 

465 

466 async def send_dns_cache_miss(self, host: str) -> None: 

467 return await self._trace_config.on_dns_cache_miss.send( 

468 self._session, self._trace_config_ctx, TraceDnsCacheMissParams(host) 

469 ) 

470 

471 async def send_request_headers( 

472 self, method: str, url: URL, headers: "CIMultiDict[str]" 

473 ) -> None: 

474 return await self._trace_config._on_request_headers_sent.send( 

475 self._session, 

476 self._trace_config_ctx, 

477 TraceRequestHeadersSentParams(method, url, headers), 

478 )