Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

next
py 585 lines 21.4 KB
Raw
1 """SDK-owned logging and deprecation surface.
2
3 ``Composio(...)`` accepts ``logger`` / ``logging_level`` and routes the
4 generated ``composio_client`` logger through the SDK's redacting wrapper.
5 Runtime deprecations (the client's response-driven ones and the SDK's own)
6 all surface as :class:`ComposioDeprecationWarning`.
7 """
8
9 import io
10 import logging
11 import typing as t
12 import warnings
13
14 import httpx
15 import pytest
16
17 from composio import Composio, ComposioDeprecationWarning, exceptions
18 from composio.client import (
19 CLIENT_LOGGER_NAME,
20 _ClientLogForwarder,
21 _forwarding_wrappers,
22 )
23 from composio.core.models.base import allow_tracking
24 from composio.utils.logging import LogLevel
25
26 _LIST_BODY: dict[str, t.Any] = {
27 "items": [],
28 "next_cursor": None,
29 "total_pages": 1,
30 "current_page": 1,
31 "total_items": 0,
32 }
33
34
35 @pytest.fixture(autouse=True)
36 def disable_telemetry():
37 token = allow_tracking.set(False)
38 yield
39 allow_tracking.reset(token)
40
41
42 @pytest.fixture(autouse=True)
43 def reset_client_logger():
44 """Start each test without the forwarder state earlier tests left behind.
45
46 The forwarder and the set of live wrappers are process-wide, so a DEBUG
47 instance from an earlier test would otherwise keep the client logger
48 permissive and mask level assertions here.
49 """
50 client_logger = logging.getLogger(CLIENT_LOGGER_NAME)
51 for handler in list(client_logger.handlers):
52 if isinstance(handler, _ClientLogForwarder):
53 client_logger.removeHandler(handler)
54 _forwarding_wrappers.clear()
55 client_logger.setLevel(logging.NOTSET)
56 yield
57
58
59 @pytest.fixture
60 def custom_logger() -> t.Iterator[tuple[logging.Logger, io.StringIO]]:
61 output = io.StringIO()
62 logger = logging.getLogger("composio-test-sdk-owned-logger")
63 logger.handlers = [logging.StreamHandler(output)]
64 logger.propagate = False
65 logger.setLevel(logging.DEBUG)
66 yield logger, output
67 logger.handlers = []
68
69
70 def _mock_transport(
71 headers: t.Optional[dict[str, str]] = None,
72 seen: t.Optional[list[httpx.Request]] = None,
73 ) -> httpx.Client:
74 def handler(request: httpx.Request) -> httpx.Response:
75 if seen is not None:
76 seen.append(request)
77 return httpx.Response(200, json=_LIST_BODY, headers=headers or {})
78
79 return httpx.Client(transport=httpx.MockTransport(handler))
80
81
82 def _forwarders() -> list[_ClientLogForwarder]:
83 return [
84 handler
85 for handler in logging.getLogger(CLIENT_LOGGER_NAME).handlers
86 if isinstance(handler, _ClientLogForwarder)
87 ]
88
89
90 class TestCustomLogger:
91 def test_sdk_logs_use_custom_logger_with_redaction(self, custom_logger):
92 logger, output = custom_logger
93 composio = Composio(api_key="test-key", logger=logger)
94
95 assert composio.logger.logger is logger
96 composio.logger.info("sdk record api_key=sdk-secret")
97
98 text = output.getvalue()
99 assert "sdk record" in text
100 assert "sdk-secret" not in text
101 assert "[REDACTED]" in text
102
103 def test_client_records_are_forwarded_with_redaction(self, custom_logger):
104 logger, output = custom_logger
105 Composio(api_key="test-key", logger=logger)
106
107 logging.getLogger(CLIENT_LOGGER_NAME).info(
108 "Authorization: Bearer client-secret-token"
109 )
110
111 text = output.getvalue()
112 assert "Authorization" in text
113 assert "client-secret-token" not in text
114 assert "[REDACTED]" in text
115
116 def test_client_request_lifecycle_reaches_custom_logger(self, custom_logger):
117 logger, output = custom_logger
118 composio = Composio(
119 api_key="test-key", http_client=_mock_transport(), logger=logger
120 )
121
122 composio.client.toolkits.list()
123
124 text = output.getvalue()
125 assert "path=/api/v3.1/toolkits" in text
126 assert "status=200" in text
127
128 def test_client_request_lifecycle_stays_out_of_info(self, custom_logger):
129 logger, output = custom_logger
130 logger.setLevel(logging.INFO)
131 composio = Composio(
132 api_key="test-key", http_client=_mock_transport(), logger=logger
133 )
134
135 composio.client.toolkits.list()
136
137 assert logging.getLogger(CLIENT_LOGGER_NAME).level == logging.WARNING
138 assert "path=/api/v3.1/toolkits" not in output.getvalue()
139
140 def test_without_retries_clone_keeps_custom_logger(self, custom_logger):
141 logger, output = custom_logger
142 composio = Composio(
143 api_key="test-key", http_client=_mock_transport(), logger=logger
144 )
145
146 composio.client.without_retries.toolkits.list()
147
148 forwarders = _forwarders()
149 assert len(forwarders) == 1
150 assert forwarders[0].wrapper.logger is logger
151 assert "path=/api/v3.1/toolkits" in output.getvalue()
152
153 def test_client_logger_does_not_propagate_to_root(self, custom_logger):
154 logger, _ = custom_logger
155 Composio(api_key="test-key", logger=logger)
156
157 client_logger = logging.getLogger(CLIENT_LOGGER_NAME)
158 assert client_logger.propagate is False
159
160 def test_forwarder_is_installed_once_per_logger(self, custom_logger):
161 logger, _ = custom_logger
162 Composio(api_key="test-key", logger=logger)
163 Composio(api_key="test-key", logger=logger)
164
165 forwarders = _forwarders()
166 assert len(forwarders) == 1
167 assert forwarders[0].wrapper.logger is logger
168
169 def test_client_records_follow_the_requesting_instance(self, custom_logger):
170 logger, output = custom_logger
171 other = logging.getLogger("composio-test-sdk-owned-logger-other")
172 other_output = io.StringIO()
173 other.handlers = [logging.StreamHandler(other_output)]
174 other.propagate = False
175 other.setLevel(logging.DEBUG)
176 try:
177 first = Composio(
178 api_key="test-key", http_client=_mock_transport(), logger=other
179 )
180 second = Composio(
181 api_key="test-key", http_client=_mock_transport(), logger=logger
182 )
183 assert len(_forwarders()) == 1
184
185 # A request through the earlier instance still logs to its own
186 # logger, even though a newer instance was constructed since.
187 first.client.without_retries.toolkits.list()
188 assert "path=/api/v3.1/toolkits" in other_output.getvalue()
189 assert "path=/api/v3.1/toolkits" not in output.getvalue()
190
191 second.client.without_retries.toolkits.list()
192 assert "path=/api/v3.1/toolkits" in output.getvalue()
193
194 # Outside any request, records go to the most recent instance.
195 logging.getLogger(CLIENT_LOGGER_NAME).info("delivered once")
196 assert "delivered once" in output.getvalue()
197 assert "delivered once" not in other_output.getvalue()
198 finally:
199 other.handlers = []
200
201 def test_quieter_instance_does_not_silence_earlier_debug_instance(
202 self, custom_logger
203 ):
204 logger, output = custom_logger
205 quiet = logging.getLogger("composio-test-sdk-owned-logger-quiet")
206 quiet_output = io.StringIO()
207 quiet.handlers = [logging.StreamHandler(quiet_output)]
208 quiet.propagate = False
209 quiet.setLevel(logging.WARNING)
210 try:
211 debug_instance = Composio(
212 api_key="test-key", http_client=_mock_transport(), logger=logger
213 )
214 quiet_instance = Composio(
215 api_key="test-key", http_client=_mock_transport(), logger=quiet
216 )
217 # The shared source logger stays permissive enough for the DEBUG
218 # instance; the quiet instance's wrapper filters its own output.
219 assert logging.getLogger(CLIENT_LOGGER_NAME).level == logging.DEBUG
220
221 debug_instance.client.without_retries.toolkits.list()
222 assert "path=/api/v3.1/toolkits" in output.getvalue()
223
224 quiet_instance.client.without_retries.toolkits.list()
225 assert "path=/api/v3.1/toolkits" not in quiet_output.getvalue()
226 finally:
227 quiet.handlers = []
228
229 def test_debug_instance_lowers_level_set_by_earlier_quiet_instance(
230 self, custom_logger
231 ):
232 logger, output = custom_logger
233 quiet = logging.getLogger("composio-test-sdk-owned-logger-quiet")
234 quiet.handlers = [logging.StreamHandler(io.StringIO())]
235 quiet.propagate = False
236 quiet.setLevel(logging.WARNING)
237 try:
238 Composio(api_key="test-key", http_client=_mock_transport(), logger=quiet)
239 assert logging.getLogger(CLIENT_LOGGER_NAME).level == logging.WARNING
240
241 debug_instance = Composio(
242 api_key="test-key", http_client=_mock_transport(), logger=logger
243 )
244 assert logging.getLogger(CLIENT_LOGGER_NAME).level == logging.DEBUG
245
246 debug_instance.client.without_retries.toolkits.list()
247 assert "path=/api/v3.1/toolkits" in output.getvalue()
248 finally:
249 quiet.handlers = []
250
251
252 class TestLoggingLevel:
253 def test_logging_level_applies_to_sdk_and_client_loggers(self, custom_logger):
254 logger, output = custom_logger
255 composio = Composio(
256 api_key="test-key", logger=logger, logging_level=LogLevel.WARNING
257 )
258
259 assert logger.level == logging.WARNING
260 assert logging.getLogger(CLIENT_LOGGER_NAME).level == logging.WARNING
261 assert composio._logging_level == "WARNING"
262
263 composio.logger.info("sdk info dropped")
264 logging.getLogger(CLIENT_LOGGER_NAME).info("client info dropped")
265 composio.logger.warning("sdk warning kept")
266 logging.getLogger(CLIENT_LOGGER_NAME).warning("client warning kept")
267
268 text = output.getvalue()
269 assert "dropped" not in text
270 assert "sdk warning kept" in text
271 assert "client warning kept" in text
272
273 def test_logging_level_debug_enables_debug_records(self, custom_logger):
274 logger, output = custom_logger
275 logger.setLevel(logging.WARNING)
276 composio = Composio(
277 api_key="test-key", logger=logger, logging_level=LogLevel.DEBUG
278 )
279
280 composio.logger.debug("sdk debug kept")
281 logging.getLogger(CLIENT_LOGGER_NAME).debug("client debug kept")
282
283 text = output.getvalue()
284 assert "sdk debug kept" in text
285 assert "client debug kept" in text
286
287
288 class TestDeprecationWarnings:
289 def test_category_is_re_exported(self):
290 assert exceptions.ComposioDeprecationWarning is ComposioDeprecationWarning
291 assert issubclass(ComposioDeprecationWarning, UserWarning)
292 assert not issubclass(ComposioDeprecationWarning, DeprecationWarning)
293
294 def test_client_deprecation_header_reaches_caller(self, custom_logger):
295 logger, _ = custom_logger
296 composio = Composio(
297 api_key="test-key",
298 http_client=_mock_transport(headers={"Deprecation": "@1688169599"}),
299 logger=logger,
300 )
301
302 with pytest.warns(ComposioDeprecationWarning, match="toolkits.list"):
303 composio.client.toolkits.list()
304
305 def test_no_warning_without_deprecation_header(self, custom_logger):
306 logger, _ = custom_logger
307 composio = Composio(
308 api_key="test-key", http_client=_mock_transport(), logger=logger
309 )
310
311 with warnings.catch_warnings():
312 warnings.simplefilter("error", ComposioDeprecationWarning)
313 composio.client.toolkits.list()
314
315 def test_tool_router_alias_warns_with_sdk_category(self):
316 composio = Composio(api_key="test-key")
317
318 with pytest.warns(ComposioDeprecationWarning, match="tool_router"):
319 alias = composio.tool_router
320
321 assert alias is composio.sessions
322
323
324 class TestToolsListWireParams:
325 def test_search_is_sent_as_query(self, custom_logger):
326 logger, _ = custom_logger
327 seen: list[httpx.Request] = []
328 composio = Composio(
329 api_key="test-key", http_client=_mock_transport(seen=seen), logger=logger
330 )
331
332 with warnings.catch_warnings():
333 warnings.simplefilter("error", ComposioDeprecationWarning)
334 composio.tools.get_raw_composio_tools(search="github issues")
335
336 assert len(seen) == 1
337 params = seen[0].url.params
338 assert params["query"] == "github issues"
339 assert "search" not in params
340
341
342 _TOOL_BODY: dict[str, t.Any] = {
343 "slug": "GMAIL_SEND_EMAIL",
344 "name": "Send email",
345 "description": "Sends an email",
346 "input_parameters": {"type": "object", "properties": {}},
347 "output_parameters": {"type": "object", "properties": {}},
348 "toolkit": {"slug": "gmail", "name": "Gmail", "logo": ""},
349 "version": "20250114_00",
350 }
351 _EXECUTE_BODY: dict[str, t.Any] = {
352 "data": {"ok": True},
353 "successful": True,
354 "error": None,
355 }
356
357 _DEPRECATED_TOOLKITS_HEADER = "Composio-Deprecated-Toolkits"
358 _GMAIL_ITEM = (
359 '"GMAIL";version="20250114_00";deprecated=@1779840000;'
360 'sunset=@1787788800;reason="lifecycle"'
361 )
362
363
364 def _tool_transport(
365 retrieve_headers: t.Optional[dict[str, str]] = None,
366 execute_headers: t.Optional[dict[str, str]] = None,
367 seen: t.Optional[list[httpx.Request]] = None,
368 event_hooks: t.Optional[dict[str, list[t.Callable[..., t.Any]]]] = None,
369 ) -> httpx.Client:
370 """Serve the tool schema on GET and the execute body on POST."""
371
372 def handler(request: httpx.Request) -> httpx.Response:
373 if seen is not None:
374 seen.append(request)
375 if request.method == "POST":
376 return httpx.Response(
377 200, json=_EXECUTE_BODY, headers=execute_headers or {}
378 )
379 return httpx.Response(200, json=_TOOL_BODY, headers=retrieve_headers or {})
380
381 return httpx.Client(
382 transport=httpx.MockTransport(handler), event_hooks=event_hooks or {}
383 )
384
385
386 class TestToolkitDeprecationHeader:
387 """``Composio-Deprecated-Toolkits`` surfaces once per toolkit version as a
388 :class:`ComposioDeprecationWarning`, beside the client's own ``Deprecation``
389 handling and without ever failing the call."""
390
391 @pytest.fixture(autouse=True)
392 def _reset_warned(self):
393 from composio.utils import toolkit_deprecation
394
395 toolkit_deprecation._reset_for_tests()
396 yield
397 toolkit_deprecation._reset_for_tests()
398
399 @staticmethod
400 def _deprecations(caught: list[warnings.WarningMessage]) -> list[str]:
401 return [
402 str(w.message)
403 for w in caught
404 if issubclass(w.category, ComposioDeprecationWarning)
405 ]
406
407 def test_tool_retrieve_warns_once(self, custom_logger):
408 logger, _ = custom_logger
409 composio = Composio(
410 api_key="test-key",
411 http_client=_tool_transport(
412 retrieve_headers={_DEPRECATED_TOOLKITS_HEADER: _GMAIL_ITEM}
413 ),
414 logger=logger,
415 )
416
417 with warnings.catch_warnings(record=True) as caught:
418 warnings.simplefilter("always")
419 tool = composio.tools.get_raw_composio_tool_by_slug("GMAIL_SEND_EMAIL")
420 composio.tools.get_raw_composio_tool_by_slug("GMAIL_SEND_EMAIL")
421
422 assert tool.slug == "GMAIL_SEND_EMAIL"
423 messages = self._deprecations(caught)
424 assert len(messages) == 1
425 assert "[Deprecation] Toolkit GMAIL version 20250114_00" in messages[0]
426 assert "deprecated on 2026-05-27 (lifecycle)" in messages[0]
427 assert "stop working on 2026-08-27" in messages[0]
428 assert 'toolkit_versions={"gmail": "<version>"}' in messages[0]
429 assert "COMPOSIO_TOOLKIT_VERSION_GMAIL" in messages[0]
430 assert (
431 "https://docs.composio.dev/docs/tools-direct/toolkit-versioning"
432 "#deprecation-and-sunset"
433 ) in messages[0]
434
435 def test_execute_path_warns_once_across_retrieve_and_execute(self, custom_logger):
436 logger, _ = custom_logger
437 seen: list[httpx.Request] = []
438 composio = Composio(
439 api_key="test-key",
440 http_client=_tool_transport(
441 retrieve_headers={_DEPRECATED_TOOLKITS_HEADER: _GMAIL_ITEM},
442 execute_headers={_DEPRECATED_TOOLKITS_HEADER: _GMAIL_ITEM},
443 seen=seen,
444 ),
445 logger=logger,
446 )
447
448 with warnings.catch_warnings(record=True) as caught:
449 warnings.simplefilter("always")
450 result = composio.tools.execute(
451 "GMAIL_SEND_EMAIL", {}, user_id="user-1", version="20250114_00"
452 )
453
454 assert result["successful"] is True
455 assert [request.method for request in seen] == ["GET", "POST"]
456 assert len(self._deprecations(caught)) == 1
457
458 def test_without_retries_clone_shares_the_hook(self, custom_logger):
459 """Only the execute response, served through ``client.without_retries``,
460 carries the header: the warning proves the clone shares the hook."""
461 logger, _ = custom_logger
462 composio = Composio(
463 api_key="test-key",
464 http_client=_tool_transport(
465 execute_headers={_DEPRECATED_TOOLKITS_HEADER: _GMAIL_ITEM}
466 ),
467 logger=logger,
468 )
469 assert composio.client.without_retries._client is composio.client._client
470
471 with warnings.catch_warnings(record=True) as caught:
472 warnings.simplefilter("always")
473 composio.tools.execute(
474 "GMAIL_SEND_EMAIL", {}, user_id="user-1", version="20250114_00"
475 )
476
477 messages = self._deprecations(caught)
478 assert len(messages) == 1
479 assert "GMAIL version 20250114_00" in messages[0]
480
481 def test_no_header_no_warning(self, custom_logger):
482 logger, _ = custom_logger
483 composio = Composio(
484 api_key="test-key", http_client=_tool_transport(), logger=logger
485 )
486
487 with warnings.catch_warnings():
488 warnings.simplefilter("error", ComposioDeprecationWarning)
489 composio.tools.get_raw_composio_tool_by_slug("GMAIL_SEND_EMAIL")
490 composio.tools.execute(
491 "GMAIL_SEND_EMAIL", {}, user_id="user-1", version="20250114_00"
492 )
493
494 def test_client_deprecation_and_toolkit_header_are_two_warnings(
495 self, custom_logger
496 ):
497 logger, _ = custom_logger
498 composio = Composio(
499 api_key="test-key",
500 http_client=_tool_transport(
501 retrieve_headers={
502 "Deprecation": "@1688169599",
503 _DEPRECATED_TOOLKITS_HEADER: _GMAIL_ITEM,
504 }
505 ),
506 logger=logger,
507 )
508
509 with warnings.catch_warnings(record=True) as caught:
510 warnings.simplefilter("always")
511 composio.tools.get_raw_composio_tool_by_slug("GMAIL_SEND_EMAIL")
512
513 messages = self._deprecations(caught)
514 assert len(messages) == 2
515 ours = [m for m in messages if "[Deprecation] Toolkit GMAIL" in m]
516 theirs = [m for m in messages if "tools.retrieve" in m]
517 assert len(ours) == 1
518 assert len(theirs) == 1
519
520 def test_malformed_header_keeps_body_and_stays_silent(self, custom_logger):
521 logger, _ = custom_logger
522 composio = Composio(
523 api_key="test-key",
524 http_client=_tool_transport(
525 retrieve_headers={_DEPRECATED_TOOLKITS_HEADER: '"GMAIL;version=;;@@'}
526 ),
527 logger=logger,
528 )
529
530 with warnings.catch_warnings(record=True) as caught:
531 warnings.simplefilter("always")
532 tool = composio.tools.get_raw_composio_tool_by_slug("GMAIL_SEND_EMAIL")
533
534 assert tool.slug == "GMAIL_SEND_EMAIL"
535 assert self._deprecations(caught) == []
536
537 def test_user_http_client_keeps_its_own_hook_and_gets_ours(self, custom_logger):
538 logger, _ = custom_logger
539 user_seen: list[httpx.Response] = []
540
541 def user_hook(response: httpx.Response) -> None:
542 user_seen.append(response)
543
544 http_client = _tool_transport(
545 retrieve_headers={_DEPRECATED_TOOLKITS_HEADER: _GMAIL_ITEM},
546 event_hooks={"response": [user_hook]},
547 )
548 composio = Composio(api_key="test-key", http_client=http_client, logger=logger)
549
550 with warnings.catch_warnings(record=True) as caught:
551 warnings.simplefilter("always")
552 composio.tools.get_raw_composio_tool_by_slug("GMAIL_SEND_EMAIL")
553
554 assert http_client.event_hooks["response"][0] is user_hook
555 assert len(http_client.event_hooks["response"]) == 2
556 assert len(user_seen) == 1
557 assert len(self._deprecations(caught)) == 1
558
559 def test_second_instance_does_not_rewarn_until_reset(self, custom_logger):
560 from composio.utils import toolkit_deprecation
561
562 logger, _ = custom_logger
563 headers = {_DEPRECATED_TOOLKITS_HEADER: _GMAIL_ITEM}
564
565 with warnings.catch_warnings(record=True) as caught:
566 warnings.simplefilter("always")
567 Composio(
568 api_key="test-key",
569 http_client=_tool_transport(retrieve_headers=headers),
570 logger=logger,
571 ).tools.get_raw_composio_tool_by_slug("GMAIL_SEND_EMAIL")
572 Composio(
573 api_key="test-key",
574 http_client=_tool_transport(retrieve_headers=headers),
575 logger=logger,
576 ).tools.get_raw_composio_tool_by_slug("GMAIL_SEND_EMAIL")
577 assert len(self._deprecations(caught)) == 1
578 toolkit_deprecation._reset_for_tests()
579 Composio(
580 api_key="test-key",
581 http_client=_tool_transport(retrieve_headers=headers),
582 logger=logger,
583 ).tools.get_raw_composio_tool_by_slug("GMAIL_SEND_EMAIL")
584
585 assert len(self._deprecations(caught)) == 2