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 229 lines 7.09 KB
Raw
1 """
2 Logging utilities.
3 """
4
5 import logging
6 import os
7 import sys
8 import typing as t
9 from enum import Enum
10
11 from composio.utils.redaction import redact_sensitive_text, redact_sensitive_value
12
13 ENV_COMPOSIO_LOGGING_LEVEL = "COMPOSIO_LOGGING_LEVEL"
14
15 _DEFAULT_FORMAT = "[%(asctime)s][%(levelname)s] %(message)s"
16 _DEFAULT_LOGGER_NAME = "composio"
17
18 _LOG_VERBOSITY = int(os.environ.get("COMPOSIO_LOG_VERBOSITY", 0))
19 _LOG_LINE_SIZE_BY_VERBOSITY = {
20 0: 256,
21 1: 512,
22 2: 1024,
23 3: -1,
24 }
25
26 _logger: t.Optional[logging.Logger] = None
27 """Global logger object for composio."""
28
29 _logger_wrapper: t.Optional["_VerbosityWrapper"] = None
30 """Global logger object wrapped with verbosity setting for composio."""
31
32
33 class LogLevel(Enum):
34 """Logging level."""
35
36 CRITICAL = "critical"
37 FATAL = "fatal"
38 ERROR = "error"
39 WARNING = "warning"
40 WARN = "warn"
41 INFO = "info"
42 DEBUG = "debug"
43 NOTSET = "notset"
44
45
46 _LEVELS: t.Dict[LogLevel, int] = {
47 LogLevel.CRITICAL: logging.CRITICAL,
48 LogLevel.FATAL: logging.FATAL,
49 LogLevel.ERROR: logging.ERROR,
50 LogLevel.WARNING: logging.WARNING,
51 LogLevel.WARN: logging.WARN,
52 LogLevel.INFO: logging.INFO,
53 LogLevel.DEBUG: logging.DEBUG,
54 LogLevel.NOTSET: logging.NOTSET,
55 }
56
57
58 class _VerbosityWrapper:
59 def __init__(
60 self,
61 logger: logging.Logger,
62 verbosity_level: t.Optional[int] = None,
63 ) -> None:
64 self.logger = logger
65 self.level = logger.level
66 self.setup(verbosity_level=verbosity_level)
67 self.verbosity = min(verbosity_level or _LOG_VERBOSITY, 3)
68 self.size = _LOG_LINE_SIZE_BY_VERBOSITY[self.verbosity]
69
70 def setup(self, verbosity_level: t.Optional[int] = None) -> None:
71 if verbosity_level is None:
72 return
73 self.verbosity = verbosity_level
74 self.size = _LOG_LINE_SIZE_BY_VERBOSITY[self.verbosity]
75
76 def _trim(self, msg) -> str:
77 msg = redact_sensitive_text(str(msg))
78 if self.size == -1:
79 return msg
80
81 if len(msg) < self.size:
82 return msg
83
84 return msg[: self.size] + "..."
85
86 def _prepare(
87 self,
88 msg,
89 args: t.Tuple[t.Any, ...],
90 *,
91 trim: bool = True,
92 ) -> str:
93 if args:
94 try:
95 format_args = (
96 args[0] if len(args) == 1 and isinstance(args[0], dict) else args
97 )
98 msg = msg % format_args
99 except (KeyError, TypeError, ValueError):
100 msg = f"{msg} [logging arguments omitted: formatting failed]"
101 return self._trim(msg) if trim else redact_sensitive_text(str(msg))
102
103 def _prepare_exception(self, msg: str, kwargs):
104 sanitized_kwargs = dict(kwargs)
105 if "extra" in sanitized_kwargs:
106 sanitized_kwargs["extra"] = redact_sensitive_value(
107 sanitized_kwargs["extra"]
108 )
109
110 exc_info = sanitized_kwargs.get("exc_info")
111 if not exc_info:
112 return msg, sanitized_kwargs
113
114 if isinstance(exc_info, BaseException):
115 exc_info = (type(exc_info), exc_info, exc_info.__traceback__)
116 elif not isinstance(exc_info, tuple):
117 exc_info = sys.exc_info()
118
119 exception = exc_info[1]
120 if exception is None:
121 sanitized_kwargs["exc_info"] = None
122 return msg, sanitized_kwargs
123
124 exception_text = logging.Formatter().formatException(exc_info)
125 sanitized_kwargs["exc_info"] = None
126 return f"{msg}\n{redact_sensitive_text(exception_text)}", sanitized_kwargs
127
128 def info(self, msg, *args, **kwargs):
129 if self.logger.isEnabledFor(logging.INFO):
130 msg, kwargs = self._prepare_exception(self._prepare(msg, args), kwargs)
131 self.logger.info(msg, **kwargs)
132
133 def debug(self, msg, *args, **kwargs):
134 if self.logger.isEnabledFor(logging.DEBUG):
135 msg, kwargs = self._prepare_exception(self._prepare(msg, args), kwargs)
136 self.logger.debug(msg, **kwargs)
137
138 def warning(self, msg, *args, **kwargs):
139 if self.logger.isEnabledFor(logging.WARNING):
140 msg, kwargs = self._prepare_exception(self._prepare(msg, args), kwargs)
141 self.logger.warning(msg, **kwargs)
142
143 def error(self, msg, *args, **kwargs):
144 if self.logger.isEnabledFor(logging.ERROR):
145 msg, kwargs = self._prepare_exception(
146 self._prepare(msg, args, trim=False), kwargs
147 )
148 self.logger.error(msg, **kwargs)
149
150 def isEnabledFor(self, level: int):
151 return self.logger.isEnabledFor(level=level)
152
153
154 def _parse_log_level_from_env(default: int) -> int:
155 """Parse log level from environment."""
156 level = os.environ.get(ENV_COMPOSIO_LOGGING_LEVEL)
157 if level is None:
158 return default
159
160 try:
161 return _LEVELS[LogLevel(level.lower())]
162 except (ValueError, KeyError):
163 return default
164
165
166 def setup(level: LogLevel = LogLevel.INFO, log_format: str = _DEFAULT_FORMAT) -> None:
167 """Setup logging config."""
168 global _logger_wrapper
169 if _logger_wrapper is None:
170 _logger_wrapper = get(name=_DEFAULT_LOGGER_NAME)
171
172 logging.basicConfig(format=log_format)
173 _logger_wrapper.logger.setLevel(_LEVELS[level])
174
175
176 def get(
177 name: t.Optional[str] = None,
178 level: LogLevel = LogLevel.INFO,
179 log_format: str = _DEFAULT_FORMAT,
180 verbosity_level: t.Optional[int] = None,
181 ) -> _VerbosityWrapper:
182 """Set up the logger."""
183 global _logger, _logger_wrapper
184 if _logger_wrapper is not None:
185 return t.cast(_VerbosityWrapper, _logger_wrapper)
186
187 # Setup logging format.
188 logging.basicConfig(format=log_format)
189
190 # Create logger
191 _logger = logging.getLogger(name or _DEFAULT_LOGGER_NAME)
192 _logger.setLevel(_parse_log_level_from_env(default=_LEVELS[level]))
193 _logger_wrapper = _VerbosityWrapper(_logger, verbosity_level=verbosity_level)
194 return _logger_wrapper
195
196
197 class WithLogger:
198 """Interface to endow subclasses with a logger."""
199
200 def __init__(
201 self,
202 logger: t.Optional[logging.Logger] = None,
203 logger_name: str = _DEFAULT_LOGGER_NAME,
204 logging_level: t.Optional[LogLevel] = None,
205 verbosity_level: t.Optional[int] = None,
206 ) -> None:
207 """
208 Initialize the logger.
209
210 :param logger: the logger object.
211 :param logger_name: the default logger name, if a logger is not provided.
212 :param logging_level: when given, applied to the logger in use (the
213 provided ``logger`` or the shared default one).
214 """
215 self._logger = (
216 _VerbosityWrapper(logger, verbosity_level=verbosity_level)
217 if logger is not None
218 else get(name=logger_name, level=logging_level or LogLevel.INFO)
219 )
220 if logging_level is not None:
221 self._logger.logger.setLevel(_LEVELS[logging_level])
222 self._logger.level = self._logger.logger.level
223 self._logger.setup(verbosity_level=verbosity_level)
224 self._logging_level = logging._levelToName[self._logger.level]
225
226 @property
227 def logger(self) -> logging.Logger:
228 """Get the component logger."""
229 return t.cast(logging.Logger, self._logger)