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

1from types import SimpleNamespace 

2from typing import TYPE_CHECKING, Awaitable, 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: # pragma: no cover 

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 

26__all__ = ( 

27 "TraceConfig", 

28 "TraceRequestStartParams", 

29 "TraceRequestEndParams", 

30 "TraceRequestExceptionParams", 

31 "TraceConnectionQueuedStartParams", 

32 "TraceConnectionQueuedEndParams", 

33 "TraceConnectionCreateStartParams", 

34 "TraceConnectionCreateEndParams", 

35 "TraceConnectionReuseconnParams", 

36 "TraceDnsResolveHostStartParams", 

37 "TraceDnsResolveHostEndParams", 

38 "TraceDnsCacheHitParams", 

39 "TraceDnsCacheMissParams", 

40 "TraceRequestRedirectParams", 

41 "TraceRequestChunkSentParams", 

42 "TraceResponseChunkReceivedParams", 

43 "TraceRequestHeadersSentParams", 

44) 

45 

46 

47class TraceConfig: 

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

49 

50 def __init__( 

51 self, trace_config_ctx_factory: Type[SimpleNamespace] = SimpleNamespace 

52 ) -> None: 

53 self._on_request_start: Signal[ 

54 _SignalCallback[TraceRequestStartParams] 

55 ] = Signal(self) 

56 self._on_request_chunk_sent: Signal[ 

57 _SignalCallback[TraceRequestChunkSentParams] 

58 ] = Signal(self) 

59 self._on_response_chunk_received: Signal[ 

60 _SignalCallback[TraceResponseChunkReceivedParams] 

61 ] = Signal(self) 

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

63 self 

64 ) 

65 self._on_request_exception: Signal[ 

66 _SignalCallback[TraceRequestExceptionParams] 

67 ] = Signal(self) 

68 self._on_request_redirect: Signal[ 

69 _SignalCallback[TraceRequestRedirectParams] 

70 ] = Signal(self) 

71 self._on_connection_queued_start: Signal[ 

72 _SignalCallback[TraceConnectionQueuedStartParams] 

73 ] = Signal(self) 

74 self._on_connection_queued_end: Signal[ 

75 _SignalCallback[TraceConnectionQueuedEndParams] 

76 ] = Signal(self) 

77 self._on_connection_create_start: Signal[ 

78 _SignalCallback[TraceConnectionCreateStartParams] 

79 ] = Signal(self) 

80 self._on_connection_create_end: Signal[ 

81 _SignalCallback[TraceConnectionCreateEndParams] 

82 ] = Signal(self) 

83 self._on_connection_reuseconn: Signal[ 

84 _SignalCallback[TraceConnectionReuseconnParams] 

85 ] = Signal(self) 

86 self._on_dns_resolvehost_start: Signal[ 

87 _SignalCallback[TraceDnsResolveHostStartParams] 

88 ] = Signal(self) 

89 self._on_dns_resolvehost_end: Signal[ 

90 _SignalCallback[TraceDnsResolveHostEndParams] 

91 ] = Signal(self) 

92 self._on_dns_cache_hit: Signal[ 

93 _SignalCallback[TraceDnsCacheHitParams] 

94 ] = Signal(self) 

95 self._on_dns_cache_miss: Signal[ 

96 _SignalCallback[TraceDnsCacheMissParams] 

97 ] = Signal(self) 

98 self._on_request_headers_sent: Signal[ 

99 _SignalCallback[TraceRequestHeadersSentParams] 

100 ] = Signal(self) 

101 

102 self._trace_config_ctx_factory = trace_config_ctx_factory 

103 

104 def trace_config_ctx( 

105 self, trace_request_ctx: Optional[SimpleNamespace] = None 

106 ) -> SimpleNamespace: 

107 """Return a new trace_config_ctx instance""" 

108 return self._trace_config_ctx_factory(trace_request_ctx=trace_request_ctx) 

109 

110 def freeze(self) -> None: 

111 self._on_request_start.freeze() 

112 self._on_request_chunk_sent.freeze() 

113 self._on_response_chunk_received.freeze() 

114 self._on_request_end.freeze() 

115 self._on_request_exception.freeze() 

116 self._on_request_redirect.freeze() 

117 self._on_connection_queued_start.freeze() 

118 self._on_connection_queued_end.freeze() 

119 self._on_connection_create_start.freeze() 

120 self._on_connection_create_end.freeze() 

121 self._on_connection_reuseconn.freeze() 

122 self._on_dns_resolvehost_start.freeze() 

123 self._on_dns_resolvehost_end.freeze() 

124 self._on_dns_cache_hit.freeze() 

125 self._on_dns_cache_miss.freeze() 

126 self._on_request_headers_sent.freeze() 

127 

128 @property 

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

130 return self._on_request_start 

131 

132 @property 

133 def on_request_chunk_sent( 

134 self, 

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

136 return self._on_request_chunk_sent 

137 

138 @property 

139 def on_response_chunk_received( 

140 self, 

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

142 return self._on_response_chunk_received 

143 

144 @property 

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

146 return self._on_request_end 

147 

148 @property 

149 def on_request_exception( 

150 self, 

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

152 return self._on_request_exception 

153 

154 @property 

155 def on_request_redirect( 

156 self, 

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

158 return self._on_request_redirect 

159 

160 @property 

161 def on_connection_queued_start( 

162 self, 

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

164 return self._on_connection_queued_start 

165 

166 @property 

167 def on_connection_queued_end( 

168 self, 

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

170 return self._on_connection_queued_end 

171 

172 @property 

173 def on_connection_create_start( 

174 self, 

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

176 return self._on_connection_create_start 

177 

178 @property 

179 def on_connection_create_end( 

180 self, 

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

182 return self._on_connection_create_end 

183 

184 @property 

185 def on_connection_reuseconn( 

186 self, 

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

188 return self._on_connection_reuseconn 

189 

190 @property 

191 def on_dns_resolvehost_start( 

192 self, 

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

194 return self._on_dns_resolvehost_start 

195 

196 @property 

197 def on_dns_resolvehost_end( 

198 self, 

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

200 return self._on_dns_resolvehost_end 

201 

202 @property 

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

204 return self._on_dns_cache_hit 

205 

206 @property 

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

208 return self._on_dns_cache_miss 

209 

210 @property 

211 def on_request_headers_sent( 

212 self, 

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

214 return self._on_request_headers_sent 

215 

216 

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

218class TraceRequestStartParams: 

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

220 

221 method: str 

222 url: URL 

223 headers: "CIMultiDict[str]" 

224 

225 

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

227class TraceRequestChunkSentParams: 

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

229 

230 method: str 

231 url: URL 

232 chunk: bytes 

233 

234 

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

236class TraceResponseChunkReceivedParams: 

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

238 

239 method: str 

240 url: URL 

241 chunk: bytes 

242 

243 

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

245class TraceRequestEndParams: 

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

247 

248 method: str 

249 url: URL 

250 headers: "CIMultiDict[str]" 

251 response: ClientResponse 

252 

253 

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

255class TraceRequestExceptionParams: 

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

257 

258 method: str 

259 url: URL 

260 headers: "CIMultiDict[str]" 

261 exception: BaseException 

262 

263 

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

265class TraceRequestRedirectParams: 

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

267 

268 method: str 

269 url: URL 

270 headers: "CIMultiDict[str]" 

271 response: ClientResponse 

272 

273 

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

275class TraceConnectionQueuedStartParams: 

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

277 

278 

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

280class TraceConnectionQueuedEndParams: 

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

282 

283 

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

285class TraceConnectionCreateStartParams: 

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

287 

288 

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

290class TraceConnectionCreateEndParams: 

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

292 

293 

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

295class TraceConnectionReuseconnParams: 

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

297 

298 

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

300class TraceDnsResolveHostStartParams: 

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

302 

303 host: str 

304 

305 

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

307class TraceDnsResolveHostEndParams: 

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

309 

310 host: str 

311 

312 

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

314class TraceDnsCacheHitParams: 

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

316 

317 host: str 

318 

319 

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

321class TraceDnsCacheMissParams: 

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

323 

324 host: str 

325 

326 

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

328class TraceRequestHeadersSentParams: 

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

330 

331 method: str 

332 url: URL 

333 headers: "CIMultiDict[str]" 

334 

335 

336class Trace: 

337 """Internal dependency holder class. 

338 

339 Used to keep together the main dependencies used 

340 at the moment of send a signal. 

341 """ 

342 

343 def __init__( 

344 self, 

345 session: "ClientSession", 

346 trace_config: TraceConfig, 

347 trace_config_ctx: SimpleNamespace, 

348 ) -> None: 

349 self._trace_config = trace_config 

350 self._trace_config_ctx = trace_config_ctx 

351 self._session = session 

352 

353 async def send_request_start( 

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

355 ) -> None: 

356 return await self._trace_config.on_request_start.send( 

357 self._session, 

358 self._trace_config_ctx, 

359 TraceRequestStartParams(method, url, headers), 

360 ) 

361 

362 async def send_request_chunk_sent( 

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

364 ) -> None: 

365 return await self._trace_config.on_request_chunk_sent.send( 

366 self._session, 

367 self._trace_config_ctx, 

368 TraceRequestChunkSentParams(method, url, chunk), 

369 ) 

370 

371 async def send_response_chunk_received( 

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

373 ) -> None: 

374 return await self._trace_config.on_response_chunk_received.send( 

375 self._session, 

376 self._trace_config_ctx, 

377 TraceResponseChunkReceivedParams(method, url, chunk), 

378 ) 

379 

380 async def send_request_end( 

381 self, 

382 method: str, 

383 url: URL, 

384 headers: "CIMultiDict[str]", 

385 response: ClientResponse, 

386 ) -> None: 

387 return await self._trace_config.on_request_end.send( 

388 self._session, 

389 self._trace_config_ctx, 

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

391 ) 

392 

393 async def send_request_exception( 

394 self, 

395 method: str, 

396 url: URL, 

397 headers: "CIMultiDict[str]", 

398 exception: BaseException, 

399 ) -> None: 

400 return await self._trace_config.on_request_exception.send( 

401 self._session, 

402 self._trace_config_ctx, 

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

404 ) 

405 

406 async def send_request_redirect( 

407 self, 

408 method: str, 

409 url: URL, 

410 headers: "CIMultiDict[str]", 

411 response: ClientResponse, 

412 ) -> None: 

413 return await self._trace_config._on_request_redirect.send( 

414 self._session, 

415 self._trace_config_ctx, 

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

417 ) 

418 

419 async def send_connection_queued_start(self) -> None: 

420 return await self._trace_config.on_connection_queued_start.send( 

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

422 ) 

423 

424 async def send_connection_queued_end(self) -> None: 

425 return await self._trace_config.on_connection_queued_end.send( 

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

427 ) 

428 

429 async def send_connection_create_start(self) -> None: 

430 return await self._trace_config.on_connection_create_start.send( 

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

432 ) 

433 

434 async def send_connection_create_end(self) -> None: 

435 return await self._trace_config.on_connection_create_end.send( 

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

437 ) 

438 

439 async def send_connection_reuseconn(self) -> None: 

440 return await self._trace_config.on_connection_reuseconn.send( 

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

442 ) 

443 

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

445 return await self._trace_config.on_dns_resolvehost_start.send( 

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

447 ) 

448 

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

450 return await self._trace_config.on_dns_resolvehost_end.send( 

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

452 ) 

453 

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

455 return await self._trace_config.on_dns_cache_hit.send( 

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

457 ) 

458 

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

460 return await self._trace_config.on_dns_cache_miss.send( 

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

462 ) 

463 

464 async def send_request_headers( 

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

466 ) -> None: 

467 return await self._trace_config._on_request_headers_sent.send( 

468 self._session, 

469 self._trace_config_ctx, 

470 TraceRequestHeadersSentParams(method, url, headers), 

471 )