Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/aiohttp/tracing.py: 63%

1from types import SimpleNamespace 

2from typing import TYPE_CHECKING, Awaitable, Mapping, Optional, Protocol, Type, TypeVar 

3 

4import attr 

5from aiosignal import Signal 

6from multidict import CIMultiDict 

7from yarl import URL 

8 

9from .client_reqrep import ClientResponse 

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 

46class TraceConfig: 

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

48 

49 def __init__( 

50 self, trace_config_ctx_factory: Type[SimpleNamespace] = SimpleNamespace 

51 ) -> None: 

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

53 Signal(self) 

54 ) 

55 self._on_request_chunk_sent: Signal[ 

56 _SignalCallback[TraceRequestChunkSentParams] 

57 ] = Signal(self) 

58 self._on_response_chunk_received: Signal[ 

59 _SignalCallback[TraceResponseChunkReceivedParams] 

60 ] = Signal(self) 

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

62 self 

63 ) 

64 self._on_request_exception: Signal[ 

65 _SignalCallback[TraceRequestExceptionParams] 

66 ] = Signal(self) 

67 self._on_request_redirect: Signal[ 

68 _SignalCallback[TraceRequestRedirectParams] 

69 ] = Signal(self) 

70 self._on_connection_queued_start: Signal[ 

71 _SignalCallback[TraceConnectionQueuedStartParams] 

72 ] = Signal(self) 

73 self._on_connection_queued_end: Signal[ 

74 _SignalCallback[TraceConnectionQueuedEndParams] 

75 ] = Signal(self) 

76 self._on_connection_create_start: Signal[ 

77 _SignalCallback[TraceConnectionCreateStartParams] 

78 ] = Signal(self) 

79 self._on_connection_create_end: Signal[ 

80 _SignalCallback[TraceConnectionCreateEndParams] 

81 ] = Signal(self) 

82 self._on_connection_reuseconn: Signal[ 

83 _SignalCallback[TraceConnectionReuseconnParams] 

84 ] = Signal(self) 

85 self._on_dns_resolvehost_start: Signal[ 

86 _SignalCallback[TraceDnsResolveHostStartParams] 

87 ] = Signal(self) 

88 self._on_dns_resolvehost_end: Signal[ 

89 _SignalCallback[TraceDnsResolveHostEndParams] 

90 ] = Signal(self) 

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

92 Signal(self) 

93 ) 

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

95 Signal(self) 

96 ) 

97 self._on_request_headers_sent: Signal[ 

98 _SignalCallback[TraceRequestHeadersSentParams] 

99 ] = Signal(self) 

100 

101 self._trace_config_ctx_factory = trace_config_ctx_factory 

102 

103 def trace_config_ctx( 

104 self, trace_request_ctx: Optional[Mapping[str, str]] = None 

105 ) -> SimpleNamespace: 

106 """Return a new trace_config_ctx instance""" 

107 return self._trace_config_ctx_factory(trace_request_ctx=trace_request_ctx) 

108 

109 def freeze(self) -> None: 

110 self._on_request_start.freeze() 

111 self._on_request_chunk_sent.freeze() 

112 self._on_response_chunk_received.freeze() 

113 self._on_request_end.freeze() 

114 self._on_request_exception.freeze() 

115 self._on_request_redirect.freeze() 

116 self._on_connection_queued_start.freeze() 

117 self._on_connection_queued_end.freeze() 

118 self._on_connection_create_start.freeze() 

119 self._on_connection_create_end.freeze() 

120 self._on_connection_reuseconn.freeze() 

121 self._on_dns_resolvehost_start.freeze() 

122 self._on_dns_resolvehost_end.freeze() 

123 self._on_dns_cache_hit.freeze() 

124 self._on_dns_cache_miss.freeze() 

125 self._on_request_headers_sent.freeze() 

126 

127 @property 

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

129 return self._on_request_start 

130 

131 @property 

132 def on_request_chunk_sent( 

133 self, 

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

135 return self._on_request_chunk_sent 

136 

137 @property 

138 def on_response_chunk_received( 

139 self, 

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

141 return self._on_response_chunk_received 

142 

143 @property 

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

145 return self._on_request_end 

146 

147 @property 

148 def on_request_exception( 

149 self, 

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

151 return self._on_request_exception 

152 

153 @property 

154 def on_request_redirect( 

155 self, 

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

157 return self._on_request_redirect 

158 

159 @property 

160 def on_connection_queued_start( 

161 self, 

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

163 return self._on_connection_queued_start 

164 

165 @property 

166 def on_connection_queued_end( 

167 self, 

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

169 return self._on_connection_queued_end 

170 

171 @property 

172 def on_connection_create_start( 

173 self, 

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

175 return self._on_connection_create_start 

176 

177 @property 

178 def on_connection_create_end( 

179 self, 

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

181 return self._on_connection_create_end 

182 

183 @property 

184 def on_connection_reuseconn( 

185 self, 

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

187 return self._on_connection_reuseconn 

188 

189 @property 

190 def on_dns_resolvehost_start( 

191 self, 

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

193 return self._on_dns_resolvehost_start 

194 

195 @property 

196 def on_dns_resolvehost_end( 

197 self, 

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

199 return self._on_dns_resolvehost_end 

200 

201 @property 

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

203 return self._on_dns_cache_hit 

204 

205 @property 

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

207 return self._on_dns_cache_miss 

208 

209 @property 

210 def on_request_headers_sent( 

211 self, 

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

213 return self._on_request_headers_sent 

214 

215 

216@attr.s(auto_attribs=True, frozen=True, slots=True) 

217class TraceRequestStartParams: 

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

219 

220 method: str 

221 url: URL 

222 headers: "CIMultiDict[str]" 

223 

224 

225@attr.s(auto_attribs=True, frozen=True, slots=True) 

226class TraceRequestChunkSentParams: 

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

228 

229 method: str 

230 url: URL 

231 chunk: bytes 

232 

233 

234@attr.s(auto_attribs=True, frozen=True, slots=True) 

235class TraceResponseChunkReceivedParams: 

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

237 

238 method: str 

239 url: URL 

240 chunk: bytes 

241 

242 

243@attr.s(auto_attribs=True, frozen=True, slots=True) 

244class TraceRequestEndParams: 

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

246 

247 method: str 

248 url: URL 

249 headers: "CIMultiDict[str]" 

250 response: ClientResponse 

251 

252 

253@attr.s(auto_attribs=True, frozen=True, slots=True) 

254class TraceRequestExceptionParams: 

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

256 

257 method: str 

258 url: URL 

259 headers: "CIMultiDict[str]" 

260 exception: BaseException 

261 

262 

263@attr.s(auto_attribs=True, frozen=True, slots=True) 

264class TraceRequestRedirectParams: 

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

266 

267 method: str 

268 url: URL 

269 headers: "CIMultiDict[str]" 

270 response: ClientResponse 

271 

272 

273@attr.s(auto_attribs=True, frozen=True, slots=True) 

274class TraceConnectionQueuedStartParams: 

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

276 

277 

278@attr.s(auto_attribs=True, frozen=True, slots=True) 

279class TraceConnectionQueuedEndParams: 

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

281 

282 

283@attr.s(auto_attribs=True, frozen=True, slots=True) 

284class TraceConnectionCreateStartParams: 

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

286 

287 

288@attr.s(auto_attribs=True, frozen=True, slots=True) 

289class TraceConnectionCreateEndParams: 

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

291 

292 

293@attr.s(auto_attribs=True, frozen=True, slots=True) 

294class TraceConnectionReuseconnParams: 

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

296 

297 

298@attr.s(auto_attribs=True, frozen=True, slots=True) 

299class TraceDnsResolveHostStartParams: 

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

301 

302 host: str 

303 

304 

305@attr.s(auto_attribs=True, frozen=True, slots=True) 

306class TraceDnsResolveHostEndParams: 

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

308 

309 host: str 

310 

311 

312@attr.s(auto_attribs=True, frozen=True, slots=True) 

313class TraceDnsCacheHitParams: 

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

315 

316 host: str 

317 

318 

319@attr.s(auto_attribs=True, frozen=True, slots=True) 

320class TraceDnsCacheMissParams: 

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

322 

323 host: str 

324 

325 

326@attr.s(auto_attribs=True, frozen=True, slots=True) 

327class TraceRequestHeadersSentParams: 

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

329 

330 method: str 

331 url: URL 

332 headers: "CIMultiDict[str]" 

333 

334 

335class Trace: 

336 """Internal dependency holder class. 

337 

338 Used to keep together the main dependencies used 

339 at the moment of send a signal. 

340 """ 

341 

342 def __init__( 

343 self, 

344 session: "ClientSession", 

345 trace_config: TraceConfig, 

346 trace_config_ctx: SimpleNamespace, 

347 ) -> None: 

348 self._trace_config = trace_config 

349 self._trace_config_ctx = trace_config_ctx 

350 self._session = session 

351 

352 async def send_request_start( 

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

354 ) -> None: 

355 return await self._trace_config.on_request_start.send( 

356 self._session, 

357 self._trace_config_ctx, 

358 TraceRequestStartParams(method, url, headers), 

359 ) 

360 

361 async def send_request_chunk_sent( 

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

363 ) -> None: 

364 return await self._trace_config.on_request_chunk_sent.send( 

365 self._session, 

366 self._trace_config_ctx, 

367 TraceRequestChunkSentParams(method, url, chunk), 

368 ) 

369 

370 async def send_response_chunk_received( 

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

372 ) -> None: 

373 return await self._trace_config.on_response_chunk_received.send( 

374 self._session, 

375 self._trace_config_ctx, 

376 TraceResponseChunkReceivedParams(method, url, chunk), 

377 ) 

378 

379 async def send_request_end( 

380 self, 

381 method: str, 

382 url: URL, 

383 headers: "CIMultiDict[str]", 

384 response: ClientResponse, 

385 ) -> None: 

386 return await self._trace_config.on_request_end.send( 

387 self._session, 

388 self._trace_config_ctx, 

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

390 ) 

391 

392 async def send_request_exception( 

393 self, 

394 method: str, 

395 url: URL, 

396 headers: "CIMultiDict[str]", 

397 exception: BaseException, 

398 ) -> None: 

399 return await self._trace_config.on_request_exception.send( 

400 self._session, 

401 self._trace_config_ctx, 

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

403 ) 

404 

405 async def send_request_redirect( 

406 self, 

407 method: str, 

408 url: URL, 

409 headers: "CIMultiDict[str]", 

410 response: ClientResponse, 

411 ) -> None: 

412 return await self._trace_config._on_request_redirect.send( 

413 self._session, 

414 self._trace_config_ctx, 

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

416 ) 

417 

418 async def send_connection_queued_start(self) -> None: 

419 return await self._trace_config.on_connection_queued_start.send( 

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

421 ) 

422 

423 async def send_connection_queued_end(self) -> None: 

424 return await self._trace_config.on_connection_queued_end.send( 

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

426 ) 

427 

428 async def send_connection_create_start(self) -> None: 

429 return await self._trace_config.on_connection_create_start.send( 

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

431 ) 

432 

433 async def send_connection_create_end(self) -> None: 

434 return await self._trace_config.on_connection_create_end.send( 

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

436 ) 

437 

438 async def send_connection_reuseconn(self) -> None: 

439 return await self._trace_config.on_connection_reuseconn.send( 

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

441 ) 

442 

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

444 return await self._trace_config.on_dns_resolvehost_start.send( 

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

446 ) 

447 

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

449 return await self._trace_config.on_dns_resolvehost_end.send( 

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

451 ) 

452 

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

454 return await self._trace_config.on_dns_cache_hit.send( 

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

456 ) 

457 

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

459 return await self._trace_config.on_dns_cache_miss.send( 

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

461 ) 

462 

463 async def send_request_headers( 

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

465 ) -> None: 

466 return await self._trace_config._on_request_headers_sent.send( 

467 self._session, 

468 self._trace_config_ctx, 

469 TraceRequestHeadersSentParams(method, url, headers), 

470 )