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, 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 from .typedefs import Protocol 

14 

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

16 

17 class _SignalCallback(Protocol[_ParamT_contra]): 

18 def __call__( 

19 self, 

20 __client_session: ClientSession, 

21 __trace_config_ctx: SimpleNamespace, 

22 __params: _ParamT_contra, 

23 ) -> Awaitable[None]: 

24 ... 

25 

26 

27__all__ = ( 

28 "TraceConfig", 

29 "TraceRequestStartParams", 

30 "TraceRequestEndParams", 

31 "TraceRequestExceptionParams", 

32 "TraceConnectionQueuedStartParams", 

33 "TraceConnectionQueuedEndParams", 

34 "TraceConnectionCreateStartParams", 

35 "TraceConnectionCreateEndParams", 

36 "TraceConnectionReuseconnParams", 

37 "TraceDnsResolveHostStartParams", 

38 "TraceDnsResolveHostEndParams", 

39 "TraceDnsCacheHitParams", 

40 "TraceDnsCacheMissParams", 

41 "TraceRequestRedirectParams", 

42 "TraceRequestChunkSentParams", 

43 "TraceResponseChunkReceivedParams", 

44 "TraceRequestHeadersSentParams", 

45) 

46 

47 

48class TraceConfig: 

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

50 

51 def __init__( 

52 self, trace_config_ctx_factory: Type[SimpleNamespace] = SimpleNamespace 

53 ) -> None: 

54 self._on_request_start: Signal[ 

55 _SignalCallback[TraceRequestStartParams] 

56 ] = Signal(self) 

57 self._on_request_chunk_sent: Signal[ 

58 _SignalCallback[TraceRequestChunkSentParams] 

59 ] = Signal(self) 

60 self._on_response_chunk_received: Signal[ 

61 _SignalCallback[TraceResponseChunkReceivedParams] 

62 ] = Signal(self) 

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

64 self 

65 ) 

66 self._on_request_exception: Signal[ 

67 _SignalCallback[TraceRequestExceptionParams] 

68 ] = Signal(self) 

69 self._on_request_redirect: Signal[ 

70 _SignalCallback[TraceRequestRedirectParams] 

71 ] = Signal(self) 

72 self._on_connection_queued_start: Signal[ 

73 _SignalCallback[TraceConnectionQueuedStartParams] 

74 ] = Signal(self) 

75 self._on_connection_queued_end: Signal[ 

76 _SignalCallback[TraceConnectionQueuedEndParams] 

77 ] = Signal(self) 

78 self._on_connection_create_start: Signal[ 

79 _SignalCallback[TraceConnectionCreateStartParams] 

80 ] = Signal(self) 

81 self._on_connection_create_end: Signal[ 

82 _SignalCallback[TraceConnectionCreateEndParams] 

83 ] = Signal(self) 

84 self._on_connection_reuseconn: Signal[ 

85 _SignalCallback[TraceConnectionReuseconnParams] 

86 ] = Signal(self) 

87 self._on_dns_resolvehost_start: Signal[ 

88 _SignalCallback[TraceDnsResolveHostStartParams] 

89 ] = Signal(self) 

90 self._on_dns_resolvehost_end: Signal[ 

91 _SignalCallback[TraceDnsResolveHostEndParams] 

92 ] = Signal(self) 

93 self._on_dns_cache_hit: Signal[ 

94 _SignalCallback[TraceDnsCacheHitParams] 

95 ] = Signal(self) 

96 self._on_dns_cache_miss: Signal[ 

97 _SignalCallback[TraceDnsCacheMissParams] 

98 ] = Signal(self) 

99 self._on_request_headers_sent: Signal[ 

100 _SignalCallback[TraceRequestHeadersSentParams] 

101 ] = Signal(self) 

102 

103 self._trace_config_ctx_factory = trace_config_ctx_factory 

104 

105 def trace_config_ctx( 

106 self, trace_request_ctx: Optional[SimpleNamespace] = None 

107 ) -> SimpleNamespace: 

108 """Return a new trace_config_ctx instance""" 

109 return self._trace_config_ctx_factory(trace_request_ctx=trace_request_ctx) 

110 

111 def freeze(self) -> None: 

112 self._on_request_start.freeze() 

113 self._on_request_chunk_sent.freeze() 

114 self._on_response_chunk_received.freeze() 

115 self._on_request_end.freeze() 

116 self._on_request_exception.freeze() 

117 self._on_request_redirect.freeze() 

118 self._on_connection_queued_start.freeze() 

119 self._on_connection_queued_end.freeze() 

120 self._on_connection_create_start.freeze() 

121 self._on_connection_create_end.freeze() 

122 self._on_connection_reuseconn.freeze() 

123 self._on_dns_resolvehost_start.freeze() 

124 self._on_dns_resolvehost_end.freeze() 

125 self._on_dns_cache_hit.freeze() 

126 self._on_dns_cache_miss.freeze() 

127 self._on_request_headers_sent.freeze() 

128 

129 @property 

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

131 return self._on_request_start 

132 

133 @property 

134 def on_request_chunk_sent( 

135 self, 

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

137 return self._on_request_chunk_sent 

138 

139 @property 

140 def on_response_chunk_received( 

141 self, 

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

143 return self._on_response_chunk_received 

144 

145 @property 

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

147 return self._on_request_end 

148 

149 @property 

150 def on_request_exception( 

151 self, 

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

153 return self._on_request_exception 

154 

155 @property 

156 def on_request_redirect( 

157 self, 

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

159 return self._on_request_redirect 

160 

161 @property 

162 def on_connection_queued_start( 

163 self, 

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

165 return self._on_connection_queued_start 

166 

167 @property 

168 def on_connection_queued_end( 

169 self, 

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

171 return self._on_connection_queued_end 

172 

173 @property 

174 def on_connection_create_start( 

175 self, 

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

177 return self._on_connection_create_start 

178 

179 @property 

180 def on_connection_create_end( 

181 self, 

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

183 return self._on_connection_create_end 

184 

185 @property 

186 def on_connection_reuseconn( 

187 self, 

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

189 return self._on_connection_reuseconn 

190 

191 @property 

192 def on_dns_resolvehost_start( 

193 self, 

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

195 return self._on_dns_resolvehost_start 

196 

197 @property 

198 def on_dns_resolvehost_end( 

199 self, 

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

201 return self._on_dns_resolvehost_end 

202 

203 @property 

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

205 return self._on_dns_cache_hit 

206 

207 @property 

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

209 return self._on_dns_cache_miss 

210 

211 @property 

212 def on_request_headers_sent( 

213 self, 

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

215 return self._on_request_headers_sent 

216 

217 

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

219class TraceRequestStartParams: 

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

221 

222 method: str 

223 url: URL 

224 headers: "CIMultiDict[str]" 

225 

226 

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

228class TraceRequestChunkSentParams: 

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

230 

231 method: str 

232 url: URL 

233 chunk: bytes 

234 

235 

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

237class TraceResponseChunkReceivedParams: 

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

239 

240 method: str 

241 url: URL 

242 chunk: bytes 

243 

244 

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

246class TraceRequestEndParams: 

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

248 

249 method: str 

250 url: URL 

251 headers: "CIMultiDict[str]" 

252 response: ClientResponse 

253 

254 

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

256class TraceRequestExceptionParams: 

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

258 

259 method: str 

260 url: URL 

261 headers: "CIMultiDict[str]" 

262 exception: BaseException 

263 

264 

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

266class TraceRequestRedirectParams: 

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

268 

269 method: str 

270 url: URL 

271 headers: "CIMultiDict[str]" 

272 response: ClientResponse 

273 

274 

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

276class TraceConnectionQueuedStartParams: 

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

278 

279 

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

281class TraceConnectionQueuedEndParams: 

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

283 

284 

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

286class TraceConnectionCreateStartParams: 

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

288 

289 

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

291class TraceConnectionCreateEndParams: 

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

293 

294 

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

296class TraceConnectionReuseconnParams: 

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

298 

299 

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

301class TraceDnsResolveHostStartParams: 

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

303 

304 host: str 

305 

306 

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

308class TraceDnsResolveHostEndParams: 

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

310 

311 host: str 

312 

313 

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

315class TraceDnsCacheHitParams: 

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

317 

318 host: str 

319 

320 

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

322class TraceDnsCacheMissParams: 

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

324 

325 host: str 

326 

327 

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

329class TraceRequestHeadersSentParams: 

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

331 

332 method: str 

333 url: URL 

334 headers: "CIMultiDict[str]" 

335 

336 

337class Trace: 

338 """Internal dependency holder class. 

339 

340 Used to keep together the main dependencies used 

341 at the moment of send a signal. 

342 """ 

343 

344 def __init__( 

345 self, 

346 session: "ClientSession", 

347 trace_config: TraceConfig, 

348 trace_config_ctx: SimpleNamespace, 

349 ) -> None: 

350 self._trace_config = trace_config 

351 self._trace_config_ctx = trace_config_ctx 

352 self._session = session 

353 

354 async def send_request_start( 

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

356 ) -> None: 

357 return await self._trace_config.on_request_start.send( 

358 self._session, 

359 self._trace_config_ctx, 

360 TraceRequestStartParams(method, url, headers), 

361 ) 

362 

363 async def send_request_chunk_sent( 

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

365 ) -> None: 

366 return await self._trace_config.on_request_chunk_sent.send( 

367 self._session, 

368 self._trace_config_ctx, 

369 TraceRequestChunkSentParams(method, url, chunk), 

370 ) 

371 

372 async def send_response_chunk_received( 

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

374 ) -> None: 

375 return await self._trace_config.on_response_chunk_received.send( 

376 self._session, 

377 self._trace_config_ctx, 

378 TraceResponseChunkReceivedParams(method, url, chunk), 

379 ) 

380 

381 async def send_request_end( 

382 self, 

383 method: str, 

384 url: URL, 

385 headers: "CIMultiDict[str]", 

386 response: ClientResponse, 

387 ) -> None: 

388 return await self._trace_config.on_request_end.send( 

389 self._session, 

390 self._trace_config_ctx, 

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

392 ) 

393 

394 async def send_request_exception( 

395 self, 

396 method: str, 

397 url: URL, 

398 headers: "CIMultiDict[str]", 

399 exception: BaseException, 

400 ) -> None: 

401 return await self._trace_config.on_request_exception.send( 

402 self._session, 

403 self._trace_config_ctx, 

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

405 ) 

406 

407 async def send_request_redirect( 

408 self, 

409 method: str, 

410 url: URL, 

411 headers: "CIMultiDict[str]", 

412 response: ClientResponse, 

413 ) -> None: 

414 return await self._trace_config._on_request_redirect.send( 

415 self._session, 

416 self._trace_config_ctx, 

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

418 ) 

419 

420 async def send_connection_queued_start(self) -> None: 

421 return await self._trace_config.on_connection_queued_start.send( 

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

423 ) 

424 

425 async def send_connection_queued_end(self) -> None: 

426 return await self._trace_config.on_connection_queued_end.send( 

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

428 ) 

429 

430 async def send_connection_create_start(self) -> None: 

431 return await self._trace_config.on_connection_create_start.send( 

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

433 ) 

434 

435 async def send_connection_create_end(self) -> None: 

436 return await self._trace_config.on_connection_create_end.send( 

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

438 ) 

439 

440 async def send_connection_reuseconn(self) -> None: 

441 return await self._trace_config.on_connection_reuseconn.send( 

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

443 ) 

444 

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

446 return await self._trace_config.on_dns_resolvehost_start.send( 

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

448 ) 

449 

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

451 return await self._trace_config.on_dns_resolvehost_end.send( 

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

453 ) 

454 

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

456 return await self._trace_config.on_dns_cache_hit.send( 

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

458 ) 

459 

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

461 return await self._trace_config.on_dns_cache_miss.send( 

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

463 ) 

464 

465 async def send_request_headers( 

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

467 ) -> None: 

468 return await self._trace_config._on_request_headers_sent.send( 

469 self._session, 

470 self._trace_config_ctx, 

471 TraceRequestHeadersSentParams(method, url, headers), 

472 )