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

1from types import SimpleNamespace 

2from typing import TYPE_CHECKING, Any, 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 

15__all__ = ( 

16 "TraceConfig", 

17 "TraceRequestStartParams", 

18 "TraceRequestEndParams", 

19 "TraceRequestExceptionParams", 

20 "TraceConnectionQueuedStartParams", 

21 "TraceConnectionQueuedEndParams", 

22 "TraceConnectionCreateStartParams", 

23 "TraceConnectionCreateEndParams", 

24 "TraceConnectionReuseconnParams", 

25 "TraceDnsResolveHostStartParams", 

26 "TraceDnsResolveHostEndParams", 

27 "TraceDnsCacheHitParams", 

28 "TraceDnsCacheMissParams", 

29 "TraceRequestRedirectParams", 

30 "TraceRequestChunkSentParams", 

31 "TraceResponseChunkReceivedParams", 

32 "TraceRequestHeadersSentParams", 

33) 

34 

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

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

37_TracingSignal = Signal["ClientSession", _T, _ParamT_contra] 

38 

39 

40class _Factory(Protocol[_T]): 

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

42 

43 

44class TraceConfig(Generic[_T]): 

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

46 

47 @overload 

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

49 @overload 

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

51 def __init__( 

52 self, trace_config_ctx_factory: _Factory[Any] = SimpleNamespace 

53 ) -> None: 

54 self._on_request_start: _TracingSignal[_T, TraceRequestStartParams] = Signal( 

55 self 

56 ) 

57 self._on_request_chunk_sent: _TracingSignal[_T, TraceRequestChunkSentParams] = ( 

58 Signal(self) 

59 ) 

60 self._on_response_chunk_received: _TracingSignal[ 

61 _T, TraceResponseChunkReceivedParams 

62 ] = Signal(self) 

63 self._on_request_end: _TracingSignal[_T, TraceRequestEndParams] = Signal(self) 

64 self._on_request_exception: _TracingSignal[_T, TraceRequestExceptionParams] = ( 

65 Signal(self) 

66 ) 

67 self._on_request_redirect: _TracingSignal[_T, TraceRequestRedirectParams] = ( 

68 Signal(self) 

69 ) 

70 self._on_connection_queued_start: _TracingSignal[ 

71 _T, TraceConnectionQueuedStartParams 

72 ] = Signal(self) 

73 self._on_connection_queued_end: _TracingSignal[ 

74 _T, TraceConnectionQueuedEndParams 

75 ] = Signal(self) 

76 self._on_connection_create_start: _TracingSignal[ 

77 _T, TraceConnectionCreateStartParams 

78 ] = Signal(self) 

79 self._on_connection_create_end: _TracingSignal[ 

80 _T, TraceConnectionCreateEndParams 

81 ] = Signal(self) 

82 self._on_connection_reuseconn: _TracingSignal[ 

83 _T, TraceConnectionReuseconnParams 

84 ] = Signal(self) 

85 self._on_dns_resolvehost_start: _TracingSignal[ 

86 _T, TraceDnsResolveHostStartParams 

87 ] = Signal(self) 

88 self._on_dns_resolvehost_end: _TracingSignal[ 

89 _T, TraceDnsResolveHostEndParams 

90 ] = Signal(self) 

91 self._on_dns_cache_hit: _TracingSignal[_T, TraceDnsCacheHitParams] = Signal( 

92 self 

93 ) 

94 self._on_dns_cache_miss: _TracingSignal[_T, TraceDnsCacheMissParams] = Signal( 

95 self 

96 ) 

97 self._on_request_headers_sent: _TracingSignal[ 

98 _T, TraceRequestHeadersSentParams 

99 ] = Signal(self) 

100 

101 self._trace_config_ctx_factory: _Factory[_T] = trace_config_ctx_factory 

102 

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

104 """Return a new trace_config_ctx instance""" 

105 return self._trace_config_ctx_factory(trace_request_ctx=trace_request_ctx) 

106 

107 def freeze(self) -> None: 

108 self._on_request_start.freeze() 

109 self._on_request_chunk_sent.freeze() 

110 self._on_response_chunk_received.freeze() 

111 self._on_request_end.freeze() 

112 self._on_request_exception.freeze() 

113 self._on_request_redirect.freeze() 

114 self._on_connection_queued_start.freeze() 

115 self._on_connection_queued_end.freeze() 

116 self._on_connection_create_start.freeze() 

117 self._on_connection_create_end.freeze() 

118 self._on_connection_reuseconn.freeze() 

119 self._on_dns_resolvehost_start.freeze() 

120 self._on_dns_resolvehost_end.freeze() 

121 self._on_dns_cache_hit.freeze() 

122 self._on_dns_cache_miss.freeze() 

123 self._on_request_headers_sent.freeze() 

124 

125 @property 

126 def on_request_start(self) -> "_TracingSignal[_T, TraceRequestStartParams]": 

127 return self._on_request_start 

128 

129 @property 

130 def on_request_chunk_sent( 

131 self, 

132 ) -> "_TracingSignal[_T, TraceRequestChunkSentParams]": 

133 return self._on_request_chunk_sent 

134 

135 @property 

136 def on_response_chunk_received( 

137 self, 

138 ) -> "_TracingSignal[_T, TraceResponseChunkReceivedParams]": 

139 return self._on_response_chunk_received 

140 

141 @property 

142 def on_request_end(self) -> "_TracingSignal[_T, TraceRequestEndParams]": 

143 return self._on_request_end 

144 

145 @property 

146 def on_request_exception( 

147 self, 

148 ) -> "_TracingSignal[_T, TraceRequestExceptionParams]": 

149 return self._on_request_exception 

150 

151 @property 

152 def on_request_redirect( 

153 self, 

154 ) -> "_TracingSignal[_T, TraceRequestRedirectParams]": 

155 return self._on_request_redirect 

156 

157 @property 

158 def on_connection_queued_start( 

159 self, 

160 ) -> "_TracingSignal[_T, TraceConnectionQueuedStartParams]": 

161 return self._on_connection_queued_start 

162 

163 @property 

164 def on_connection_queued_end( 

165 self, 

166 ) -> "_TracingSignal[_T, TraceConnectionQueuedEndParams]": 

167 return self._on_connection_queued_end 

168 

169 @property 

170 def on_connection_create_start( 

171 self, 

172 ) -> "_TracingSignal[_T, TraceConnectionCreateStartParams]": 

173 return self._on_connection_create_start 

174 

175 @property 

176 def on_connection_create_end( 

177 self, 

178 ) -> "_TracingSignal[_T, TraceConnectionCreateEndParams]": 

179 return self._on_connection_create_end 

180 

181 @property 

182 def on_connection_reuseconn( 

183 self, 

184 ) -> "_TracingSignal[_T, TraceConnectionReuseconnParams]": 

185 return self._on_connection_reuseconn 

186 

187 @property 

188 def on_dns_resolvehost_start( 

189 self, 

190 ) -> "_TracingSignal[_T, TraceDnsResolveHostStartParams]": 

191 return self._on_dns_resolvehost_start 

192 

193 @property 

194 def on_dns_resolvehost_end( 

195 self, 

196 ) -> "_TracingSignal[_T, TraceDnsResolveHostEndParams]": 

197 return self._on_dns_resolvehost_end 

198 

199 @property 

200 def on_dns_cache_hit(self) -> "_TracingSignal[_T, TraceDnsCacheHitParams]": 

201 return self._on_dns_cache_hit 

202 

203 @property 

204 def on_dns_cache_miss(self) -> "_TracingSignal[_T, TraceDnsCacheMissParams]": 

205 return self._on_dns_cache_miss 

206 

207 @property 

208 def on_request_headers_sent( 

209 self, 

210 ) -> "_TracingSignal[_T, TraceRequestHeadersSentParams]": 

211 return self._on_request_headers_sent 

212 

213 

214@frozen_dataclass_decorator 

215class TraceRequestStartParams: 

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

217 

218 method: str 

219 url: URL 

220 headers: "CIMultiDict[str]" 

221 

222 

223@frozen_dataclass_decorator 

224class TraceRequestChunkSentParams: 

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

226 

227 method: str 

228 url: URL 

229 chunk: bytes 

230 

231 

232@frozen_dataclass_decorator 

233class TraceResponseChunkReceivedParams: 

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

235 

236 method: str 

237 url: URL 

238 chunk: bytes 

239 

240 

241@frozen_dataclass_decorator 

242class TraceRequestEndParams: 

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

244 

245 method: str 

246 url: URL 

247 headers: "CIMultiDict[str]" 

248 response: ClientResponse 

249 

250 

251@frozen_dataclass_decorator 

252class TraceRequestExceptionParams: 

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

254 

255 method: str 

256 url: URL 

257 headers: "CIMultiDict[str]" 

258 exception: BaseException 

259 

260 

261@frozen_dataclass_decorator 

262class TraceRequestRedirectParams: 

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

264 

265 method: str 

266 url: URL 

267 headers: "CIMultiDict[str]" 

268 response: ClientResponse 

269 

270 

271@frozen_dataclass_decorator 

272class TraceConnectionQueuedStartParams: 

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

274 

275 

276@frozen_dataclass_decorator 

277class TraceConnectionQueuedEndParams: 

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

279 

280 

281@frozen_dataclass_decorator 

282class TraceConnectionCreateStartParams: 

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

284 

285 

286@frozen_dataclass_decorator 

287class TraceConnectionCreateEndParams: 

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

289 

290 

291@frozen_dataclass_decorator 

292class TraceConnectionReuseconnParams: 

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

294 

295 

296@frozen_dataclass_decorator 

297class TraceDnsResolveHostStartParams: 

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

299 

300 host: str 

301 

302 

303@frozen_dataclass_decorator 

304class TraceDnsResolveHostEndParams: 

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

306 

307 host: str 

308 

309 

310@frozen_dataclass_decorator 

311class TraceDnsCacheHitParams: 

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

313 

314 host: str 

315 

316 

317@frozen_dataclass_decorator 

318class TraceDnsCacheMissParams: 

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

320 

321 host: str 

322 

323 

324@frozen_dataclass_decorator 

325class TraceRequestHeadersSentParams: 

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

327 

328 method: str 

329 url: URL 

330 headers: "CIMultiDict[str]" 

331 

332 

333class Trace: 

334 """Internal dependency holder class. 

335 

336 Used to keep together the main dependencies used 

337 at the moment of send a signal. 

338 """ 

339 

340 def __init__( 

341 self, 

342 session: "ClientSession", 

343 trace_config: TraceConfig[object], 

344 trace_config_ctx: Any, 

345 ) -> None: 

346 self._trace_config = trace_config 

347 self._trace_config_ctx = trace_config_ctx 

348 self._session = session 

349 

350 async def send_request_start( 

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

352 ) -> None: 

353 return await self._trace_config.on_request_start.send( 

354 self._session, 

355 self._trace_config_ctx, 

356 TraceRequestStartParams(method, url, headers), 

357 ) 

358 

359 async def send_request_chunk_sent( 

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

361 ) -> None: 

362 return await self._trace_config.on_request_chunk_sent.send( 

363 self._session, 

364 self._trace_config_ctx, 

365 TraceRequestChunkSentParams(method, url, chunk), 

366 ) 

367 

368 async def send_response_chunk_received( 

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

370 ) -> None: 

371 return await self._trace_config.on_response_chunk_received.send( 

372 self._session, 

373 self._trace_config_ctx, 

374 TraceResponseChunkReceivedParams(method, url, chunk), 

375 ) 

376 

377 async def send_request_end( 

378 self, 

379 method: str, 

380 url: URL, 

381 headers: "CIMultiDict[str]", 

382 response: ClientResponse, 

383 ) -> None: 

384 return await self._trace_config.on_request_end.send( 

385 self._session, 

386 self._trace_config_ctx, 

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

388 ) 

389 

390 async def send_request_exception( 

391 self, 

392 method: str, 

393 url: URL, 

394 headers: "CIMultiDict[str]", 

395 exception: BaseException, 

396 ) -> None: 

397 return await self._trace_config.on_request_exception.send( 

398 self._session, 

399 self._trace_config_ctx, 

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

401 ) 

402 

403 async def send_request_redirect( 

404 self, 

405 method: str, 

406 url: URL, 

407 headers: "CIMultiDict[str]", 

408 response: ClientResponse, 

409 ) -> None: 

410 return await self._trace_config._on_request_redirect.send( 

411 self._session, 

412 self._trace_config_ctx, 

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

414 ) 

415 

416 async def send_connection_queued_start(self) -> None: 

417 return await self._trace_config.on_connection_queued_start.send( 

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

419 ) 

420 

421 async def send_connection_queued_end(self) -> None: 

422 return await self._trace_config.on_connection_queued_end.send( 

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

424 ) 

425 

426 async def send_connection_create_start(self) -> None: 

427 return await self._trace_config.on_connection_create_start.send( 

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

429 ) 

430 

431 async def send_connection_create_end(self) -> None: 

432 return await self._trace_config.on_connection_create_end.send( 

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

434 ) 

435 

436 async def send_connection_reuseconn(self) -> None: 

437 return await self._trace_config.on_connection_reuseconn.send( 

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

439 ) 

440 

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

442 return await self._trace_config.on_dns_resolvehost_start.send( 

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

444 ) 

445 

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

447 return await self._trace_config.on_dns_resolvehost_end.send( 

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

449 ) 

450 

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

452 return await self._trace_config.on_dns_cache_hit.send( 

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

454 ) 

455 

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

457 return await self._trace_config.on_dns_cache_miss.send( 

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

459 ) 

460 

461 async def send_request_headers( 

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

463 ) -> None: 

464 return await self._trace_config._on_request_headers_sent.send( 

465 self._session, 

466 self._trace_config_ctx, 

467 TraceRequestHeadersSentParams(method, url, headers), 

468 )