Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
| 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) |