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, Any, 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 _TracingSignal = Signal[ClientSession, SimpleNamespace, _ParamT_contra] 

16 

17 

18__all__ = ( 

19 "TraceConfig", 

20 "TraceRequestStartParams", 

21 "TraceRequestEndParams", 

22 "TraceRequestExceptionParams", 

23 "TraceConnectionQueuedStartParams", 

24 "TraceConnectionQueuedEndParams", 

25 "TraceConnectionCreateStartParams", 

26 "TraceConnectionCreateEndParams", 

27 "TraceConnectionReuseconnParams", 

28 "TraceDnsResolveHostStartParams", 

29 "TraceDnsResolveHostEndParams", 

30 "TraceDnsCacheHitParams", 

31 "TraceDnsCacheMissParams", 

32 "TraceRequestRedirectParams", 

33 "TraceRequestChunkSentParams", 

34 "TraceResponseChunkReceivedParams", 

35 "TraceRequestHeadersSentParams", 

36) 

37 

38 

39class TraceConfig: 

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

41 

42 def __init__( 

43 self, trace_config_ctx_factory: type[SimpleNamespace] = SimpleNamespace 

44 ) -> None: 

45 self._on_request_start: _TracingSignal[TraceRequestStartParams] = Signal(self) 

46 self._on_request_chunk_sent: _TracingSignal[TraceRequestChunkSentParams] = ( 

47 Signal(self) 

48 ) 

49 self._on_response_chunk_received: _TracingSignal[ 

50 TraceResponseChunkReceivedParams 

51 ] = Signal(self) 

52 self._on_request_end: _TracingSignal[TraceRequestEndParams] = Signal(self) 

53 self._on_request_exception: _TracingSignal[TraceRequestExceptionParams] = ( 

54 Signal(self) 

55 ) 

56 self._on_request_redirect: _TracingSignal[TraceRequestRedirectParams] = Signal( 

57 self 

58 ) 

59 self._on_connection_queued_start: _TracingSignal[ 

60 TraceConnectionQueuedStartParams 

61 ] = Signal(self) 

62 self._on_connection_queued_end: _TracingSignal[ 

63 TraceConnectionQueuedEndParams 

64 ] = Signal(self) 

65 self._on_connection_create_start: _TracingSignal[ 

66 TraceConnectionCreateStartParams 

67 ] = Signal(self) 

68 self._on_connection_create_end: _TracingSignal[ 

69 TraceConnectionCreateEndParams 

70 ] = Signal(self) 

71 self._on_connection_reuseconn: _TracingSignal[ 

72 TraceConnectionReuseconnParams 

73 ] = Signal(self) 

74 self._on_dns_resolvehost_start: _TracingSignal[ 

75 TraceDnsResolveHostStartParams 

76 ] = Signal(self) 

77 self._on_dns_resolvehost_end: _TracingSignal[TraceDnsResolveHostEndParams] = ( 

78 Signal(self) 

79 ) 

80 self._on_dns_cache_hit: _TracingSignal[TraceDnsCacheHitParams] = Signal(self) 

81 self._on_dns_cache_miss: _TracingSignal[TraceDnsCacheMissParams] = Signal(self) 

82 self._on_request_headers_sent: _TracingSignal[TraceRequestHeadersSentParams] = ( 

83 Signal(self) 

84 ) 

85 

86 self._trace_config_ctx_factory = trace_config_ctx_factory 

87 

88 def trace_config_ctx(self, trace_request_ctx: Any = None) -> SimpleNamespace: 

89 """Return a new trace_config_ctx instance""" 

90 return self._trace_config_ctx_factory(trace_request_ctx=trace_request_ctx) 

91 

92 def freeze(self) -> None: 

93 self._on_request_start.freeze() 

94 self._on_request_chunk_sent.freeze() 

95 self._on_response_chunk_received.freeze() 

96 self._on_request_end.freeze() 

97 self._on_request_exception.freeze() 

98 self._on_request_redirect.freeze() 

99 self._on_connection_queued_start.freeze() 

100 self._on_connection_queued_end.freeze() 

101 self._on_connection_create_start.freeze() 

102 self._on_connection_create_end.freeze() 

103 self._on_connection_reuseconn.freeze() 

104 self._on_dns_resolvehost_start.freeze() 

105 self._on_dns_resolvehost_end.freeze() 

106 self._on_dns_cache_hit.freeze() 

107 self._on_dns_cache_miss.freeze() 

108 self._on_request_headers_sent.freeze() 

109 

110 @property 

111 def on_request_start(self) -> "_TracingSignal[TraceRequestStartParams]": 

112 return self._on_request_start 

113 

114 @property 

115 def on_request_chunk_sent( 

116 self, 

117 ) -> "_TracingSignal[TraceRequestChunkSentParams]": 

118 return self._on_request_chunk_sent 

119 

120 @property 

121 def on_response_chunk_received( 

122 self, 

123 ) -> "_TracingSignal[TraceResponseChunkReceivedParams]": 

124 return self._on_response_chunk_received 

125 

126 @property 

127 def on_request_end(self) -> "_TracingSignal[TraceRequestEndParams]": 

128 return self._on_request_end 

129 

130 @property 

131 def on_request_exception( 

132 self, 

133 ) -> "_TracingSignal[TraceRequestExceptionParams]": 

134 return self._on_request_exception 

135 

136 @property 

137 def on_request_redirect( 

138 self, 

139 ) -> "_TracingSignal[TraceRequestRedirectParams]": 

140 return self._on_request_redirect 

141 

142 @property 

143 def on_connection_queued_start( 

144 self, 

145 ) -> "_TracingSignal[TraceConnectionQueuedStartParams]": 

146 return self._on_connection_queued_start 

147 

148 @property 

149 def on_connection_queued_end( 

150 self, 

151 ) -> "_TracingSignal[TraceConnectionQueuedEndParams]": 

152 return self._on_connection_queued_end 

153 

154 @property 

155 def on_connection_create_start( 

156 self, 

157 ) -> "_TracingSignal[TraceConnectionCreateStartParams]": 

158 return self._on_connection_create_start 

159 

160 @property 

161 def on_connection_create_end( 

162 self, 

163 ) -> "_TracingSignal[TraceConnectionCreateEndParams]": 

164 return self._on_connection_create_end 

165 

166 @property 

167 def on_connection_reuseconn( 

168 self, 

169 ) -> "_TracingSignal[TraceConnectionReuseconnParams]": 

170 return self._on_connection_reuseconn 

171 

172 @property 

173 def on_dns_resolvehost_start( 

174 self, 

175 ) -> "_TracingSignal[TraceDnsResolveHostStartParams]": 

176 return self._on_dns_resolvehost_start 

177 

178 @property 

179 def on_dns_resolvehost_end( 

180 self, 

181 ) -> "_TracingSignal[TraceDnsResolveHostEndParams]": 

182 return self._on_dns_resolvehost_end 

183 

184 @property 

185 def on_dns_cache_hit(self) -> "_TracingSignal[TraceDnsCacheHitParams]": 

186 return self._on_dns_cache_hit 

187 

188 @property 

189 def on_dns_cache_miss(self) -> "_TracingSignal[TraceDnsCacheMissParams]": 

190 return self._on_dns_cache_miss 

191 

192 @property 

193 def on_request_headers_sent( 

194 self, 

195 ) -> "_TracingSignal[TraceRequestHeadersSentParams]": 

196 return self._on_request_headers_sent 

197 

198 

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

200class TraceRequestStartParams: 

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

202 

203 method: str 

204 url: URL 

205 headers: "CIMultiDict[str]" 

206 

207 

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

209class TraceRequestChunkSentParams: 

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

211 

212 method: str 

213 url: URL 

214 chunk: bytes 

215 

216 

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

218class TraceResponseChunkReceivedParams: 

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

220 

221 method: str 

222 url: URL 

223 chunk: bytes 

224 

225 

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

227class TraceRequestEndParams: 

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

229 

230 method: str 

231 url: URL 

232 headers: "CIMultiDict[str]" 

233 response: ClientResponse 

234 

235 

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

237class TraceRequestExceptionParams: 

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

239 

240 method: str 

241 url: URL 

242 headers: "CIMultiDict[str]" 

243 exception: BaseException 

244 

245 

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

247class TraceRequestRedirectParams: 

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

249 

250 method: str 

251 url: URL 

252 headers: "CIMultiDict[str]" 

253 response: ClientResponse 

254 

255 

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

257class TraceConnectionQueuedStartParams: 

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

259 

260 

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

262class TraceConnectionQueuedEndParams: 

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

264 

265 

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

267class TraceConnectionCreateStartParams: 

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

269 

270 

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

272class TraceConnectionCreateEndParams: 

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

274 

275 

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

277class TraceConnectionReuseconnParams: 

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

279 

280 

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

282class TraceDnsResolveHostStartParams: 

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

284 

285 host: str 

286 

287 

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

289class TraceDnsResolveHostEndParams: 

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

291 

292 host: str 

293 

294 

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

296class TraceDnsCacheHitParams: 

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

298 

299 host: str 

300 

301 

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

303class TraceDnsCacheMissParams: 

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

305 

306 host: str 

307 

308 

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

310class TraceRequestHeadersSentParams: 

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

312 

313 method: str 

314 url: URL 

315 headers: "CIMultiDict[str]" 

316 

317 

318class Trace: 

319 """Internal dependency holder class. 

320 

321 Used to keep together the main dependencies used 

322 at the moment of send a signal. 

323 """ 

324 

325 def __init__( 

326 self, 

327 session: "ClientSession", 

328 trace_config: TraceConfig, 

329 trace_config_ctx: SimpleNamespace, 

330 ) -> None: 

331 self._trace_config = trace_config 

332 self._trace_config_ctx = trace_config_ctx 

333 self._session = session 

334 

335 async def send_request_start( 

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

337 ) -> None: 

338 return await self._trace_config.on_request_start.send( 

339 self._session, 

340 self._trace_config_ctx, 

341 TraceRequestStartParams(method, url, headers), 

342 ) 

343 

344 async def send_request_chunk_sent( 

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

346 ) -> None: 

347 return await self._trace_config.on_request_chunk_sent.send( 

348 self._session, 

349 self._trace_config_ctx, 

350 TraceRequestChunkSentParams(method, url, chunk), 

351 ) 

352 

353 async def send_response_chunk_received( 

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

355 ) -> None: 

356 return await self._trace_config.on_response_chunk_received.send( 

357 self._session, 

358 self._trace_config_ctx, 

359 TraceResponseChunkReceivedParams(method, url, chunk), 

360 ) 

361 

362 async def send_request_end( 

363 self, 

364 method: str, 

365 url: URL, 

366 headers: "CIMultiDict[str]", 

367 response: ClientResponse, 

368 ) -> None: 

369 return await self._trace_config.on_request_end.send( 

370 self._session, 

371 self._trace_config_ctx, 

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

373 ) 

374 

375 async def send_request_exception( 

376 self, 

377 method: str, 

378 url: URL, 

379 headers: "CIMultiDict[str]", 

380 exception: BaseException, 

381 ) -> None: 

382 return await self._trace_config.on_request_exception.send( 

383 self._session, 

384 self._trace_config_ctx, 

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

386 ) 

387 

388 async def send_request_redirect( 

389 self, 

390 method: str, 

391 url: URL, 

392 headers: "CIMultiDict[str]", 

393 response: ClientResponse, 

394 ) -> None: 

395 return await self._trace_config._on_request_redirect.send( 

396 self._session, 

397 self._trace_config_ctx, 

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

399 ) 

400 

401 async def send_connection_queued_start(self) -> None: 

402 return await self._trace_config.on_connection_queued_start.send( 

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

404 ) 

405 

406 async def send_connection_queued_end(self) -> None: 

407 return await self._trace_config.on_connection_queued_end.send( 

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

409 ) 

410 

411 async def send_connection_create_start(self) -> None: 

412 return await self._trace_config.on_connection_create_start.send( 

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

414 ) 

415 

416 async def send_connection_create_end(self) -> None: 

417 return await self._trace_config.on_connection_create_end.send( 

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

419 ) 

420 

421 async def send_connection_reuseconn(self) -> None: 

422 return await self._trace_config.on_connection_reuseconn.send( 

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

424 ) 

425 

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

427 return await self._trace_config.on_dns_resolvehost_start.send( 

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

429 ) 

430 

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

432 return await self._trace_config.on_dns_resolvehost_end.send( 

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

434 ) 

435 

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

437 return await self._trace_config.on_dns_cache_hit.send( 

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

439 ) 

440 

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

442 return await self._trace_config.on_dns_cache_miss.send( 

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

444 ) 

445 

446 async def send_request_headers( 

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

448 ) -> None: 

449 return await self._trace_config._on_request_headers_sent.send( 

450 self._session, 

451 self._trace_config_ctx, 

452 TraceRequestHeadersSentParams(method, url, headers), 

453 )