[core] Support sequence of strings for Formatter fmt (#55)

Fixes: #16

### Test Plan
- Unit tests

### To Do
- [ ] ? Add tests for this format when using dict config?

Author: nhairs

docs/changelog.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Allows using values like `ext://sys.stderr` in `fileConfig`/`dictConfig` value fields.
 - Support comma seperated lists for Formatter `fmt` (`style=","`) e.g. `"asctime,message,levelname"` [#15](https://github.com/nhairs/python-json-logger/issues/15)
   - Note that this style is specific to `python-json-logger` and thus care should be taken not to pass this format to other logging Formatter implementations.
+- Supports sequences of strings (e.g. lists and tuples) of field names for Formatter `fmt`. [#16](https://github.com/nhairs/python-json-logger/issues/16)
 
 ### Changed
 - Rename `pythonjsonlogger.core.LogRecord` and `log_record` arguments to avoid confusion / overlapping with `logging.LogRecord`. [#38](https://github.com/nhairs/python-json-logger/issues/38)

docs/quickstart.md

@@ -45,10 +45,23 @@ logger.addHandler(logHandler)
 ### Output fields
 
 #### Required Fields
-You can control the logged fields by setting the `fmt` argument when creating the formatter. By default formatters will follow the same `style` of `fmt` as the `logging` module: `%`, `$`, and `{`. All [`LogRecord` attributes](https://docs.python.org/3/library/logging.html#logrecord-attributes) can be output using their name.
+You can control the logged fields by setting the `fmt` argument when creating the formatter. A variety of different formats are supported including:
+
+- Standard library formats: where `style` is one of `%`, `$`, or `{`. This allows using Python JSON Logger Formatters with your existing config.
+- Comma format: where `style` is `,` which simplifies the writing of formats where you can't use more complex formats.
+- A sequence of string: e.g. lists or tuples.
+
+All [`LogRecord` attributes](https://docs.python.org/3/library/logging.html#logrecord-attributes) can be output using their name.
 
 ```python
+# Standard library format
 formatter = JsonFormatter("{message}{asctime}{exc_info}", style="{")
+
+# Comma format
+formatter = JsonFormatter("message,asctime,exc_info", style=",")
+
+# Sequence of strings format
+formatter = JsonFormatter(["message", "asctime", "exc_info"])
 ```
 
 #### Message Fields

src/pythonjsonlogger/core.py

@@ -128,7 +128,7 @@ class BaseJsonFormatter(logging.Formatter):
     # pylint: disable=too-many-arguments,super-init-not-called
     def __init__(
         self,
-        fmt: Optional[str] = None,
+        fmt: Optional[Union[str, Sequence[str]]] = None,
         datefmt: Optional[str] = None,
         style: str = "%",
         validate: bool = True,
@@ -145,11 +145,11 @@ def __init__(
     ) -> None:
         """
         Args:
-            fmt: string representing fields to log
+            fmt: String format or `Sequence` of field names of fields to log.
             datefmt: format to use when formatting `asctime` field
-            style: how to extract log fields from `fmt`
+            style: how to extract log fields from `fmt`. Ignored if `fmt` is a `Sequence[str]`.
             validate: validate `fmt` against style, if implementing a custom `style` you
-                must set this to `False`.
+                must set this to `False`. Ignored if `fmt` is a `Sequence[str]`.
             defaults: a dictionary containing default fields that are added before all other fields and
                 may be overridden. The supplied fields are still subject to `rename_fields`.
             prefix: an optional string prefix added at the beginning of
@@ -181,25 +181,34 @@ def __init__(
         - `fmt` now supports comma seperated lists (`style=","`). Note that this style is specific
           to `python-json-logger` and thus care should be taken to not to pass this format to other
           logging Formatter implementations.
+        - `fmt` now supports sequences of strings (e.g. lists and tuples) of field names.
         """
         ## logging.Formatter compatibility
         ## ---------------------------------------------------------------------
         # Note: validate added in python 3.8, defaults added in 3.10
-        if style in logging._STYLES:
-            _style = logging._STYLES[style][0](fmt)  # type: ignore[operator]
-            if validate:
-                _style.validate()
-            self._style = _style
-            self._fmt = _style._fmt
-
-        elif style == "," or not validate:
-            self._style = style
-            self._fmt = fmt
-
-            # TODO: Validate comma format
-
-        else:
-            raise ValueError("Style must be one of: '%{$,'")
+        if fmt is None or isinstance(fmt, str):
+            if style in logging._STYLES:
+                _style = logging._STYLES[style][0](fmt)  # type: ignore[operator]
+                if validate:
+                    _style.validate()
+                self._style = _style
+                self._fmt = _style._fmt
+
+            elif style == "," or not validate:
+                self._style = style
+                self._fmt = fmt
+                # TODO: Validate comma format
+
+            else:
+                raise ValueError("Style must be one of: '%{$,'")
+
+            self._required_fields = self.parse()
+
+        # Note: we do this check second as string is still a Sequence[str]
+        elif isinstance(fmt, Sequence):
+            self._style = "__sequence__"
+            self._fmt = str(fmt)
+            self._required_fields = list(fmt)
 
         self.datefmt = datefmt
 
@@ -221,7 +230,6 @@ def __init__(
         self.reserved_attrs = set(reserved_attrs if reserved_attrs is not None else RESERVED_ATTRS)
         self.timestamp = timestamp
 
-        self._required_fields = self.parse()
         self._skip_fields = set(self._required_fields)
         self._skip_fields.update(self.reserved_attrs)
         self.defaults = defaults if defaults is not None else {}
@@ -282,8 +290,14 @@ def parse(self) -> List[str]:
         if self._fmt is None:
             return []
 
-        if isinstance(self._style, str) and self._style == ",":
-            return [field.strip() for field in self._fmt.split(",") if field.strip()]
+        if isinstance(self._style, str):
+            if self._style == "__sequence__":
+                raise RuntimeError("Must not call parse when fmt is a sequence of strings")
+
+            if self._style == ",":
+                return [field.strip() for field in self._fmt.split(",") if field.strip()]
+
+            raise ValueError(f"Style {self._style!r} is not supported")
 
         if isinstance(self._style, logging.StringTemplateStyle):
             formatter_style_pattern = STYLE_STRING_TEMPLATE_REGEX

tests/test_formatters.py

@@ -184,6 +184,32 @@ def test_comma_format(env: LoggingEnvironment, class_: type[BaseJsonFormatter]):
     return
 
 
+@pytest.mark.parametrize("class_", ALL_FORMATTERS)
+def test_sequence_list_format(env: LoggingEnvironment, class_: type[BaseJsonFormatter]):
+    env.set_formatter(class_(["levelname", "message", "filename", "lineno", "asctime"]))
+
+    msg = "testing logging format"
+    env.logger.info(msg)
+    log_json = env.load_json()
+
+    assert log_json["message"] == msg
+    assert log_json.keys() == {"levelname", "message", "filename", "lineno", "asctime"}
+    return
+
+
+@pytest.mark.parametrize("class_", ALL_FORMATTERS)
+def test_sequence_tuple_format(env: LoggingEnvironment, class_: type[BaseJsonFormatter]):
+    env.set_formatter(class_(("levelname", "message", "filename", "lineno", "asctime")))
+
+    msg = "testing logging format"
+    env.logger.info(msg)
+    log_json = env.load_json()
+
+    assert log_json["message"] == msg
+    assert log_json.keys() == {"levelname", "message", "filename", "lineno", "asctime"}
+    return
+
+
 @pytest.mark.parametrize("class_", ALL_FORMATTERS)
 def test_defaults_field(env: LoggingEnvironment, class_: type[BaseJsonFormatter]):
     env.set_formatter(class_(defaults={"first": 1, "second": 2}))