diff --git a/Include/internal/pycore_global_strings.h b/Include/internal/pycore_global_strings.h
index 2966b60..f646979 100644
--- a/Include/internal/pycore_global_strings.h
+++ b/Include/internal/pycore_global_strings.h
@@ -350,6 +350,7 @@ struct _Py_global_strings {
         STRUCT_FOR_ID(exception)
         STRUCT_FOR_ID(exp)
         STRUCT_FOR_ID(extend)
+        STRUCT_FOR_ID(facility)
         STRUCT_FOR_ID(factory)
         STRUCT_FOR_ID(family)
         STRUCT_FOR_ID(fanout)
@@ -392,6 +393,7 @@ struct _Py_global_strings {
         STRUCT_FOR_ID(hi)
         STRUCT_FOR_ID(hook)
         STRUCT_FOR_ID(id)
+        STRUCT_FOR_ID(ident)
         STRUCT_FOR_ID(ignore)
         STRUCT_FOR_ID(imag)
         STRUCT_FOR_ID(importlib)
@@ -447,6 +449,7 @@ struct _Py_global_strings {
         STRUCT_FOR_ID(lo)
         STRUCT_FOR_ID(locale)
         STRUCT_FOR_ID(locals)
+        STRUCT_FOR_ID(logoption)
         STRUCT_FOR_ID(loop)
         STRUCT_FOR_ID(mapping)
         STRUCT_FOR_ID(match)
diff --git a/Include/internal/pycore_runtime_init_generated.h b/Include/internal/pycore_runtime_init_generated.h
index 617582f..bd1fede 100644
--- a/Include/internal/pycore_runtime_init_generated.h
+++ b/Include/internal/pycore_runtime_init_generated.h
@@ -859,6 +859,7 @@
                 INIT_ID(exception), \
                 INIT_ID(exp), \
                 INIT_ID(extend), \
+                INIT_ID(facility), \
                 INIT_ID(factory), \
                 INIT_ID(family), \
                 INIT_ID(fanout), \
@@ -901,6 +902,7 @@
                 INIT_ID(hi), \
                 INIT_ID(hook), \
                 INIT_ID(id), \
+                INIT_ID(ident), \
                 INIT_ID(ignore), \
                 INIT_ID(imag), \
                 INIT_ID(importlib), \
@@ -956,6 +958,7 @@
                 INIT_ID(lo), \
                 INIT_ID(locale), \
                 INIT_ID(locals), \
+                INIT_ID(logoption), \
                 INIT_ID(loop), \
                 INIT_ID(mapping), \
                 INIT_ID(match), \
@@ -2026,6 +2029,8 @@
     PyUnicode_InternInPlace(&string);
     string = &_Py_ID(extend);
     PyUnicode_InternInPlace(&string);
+    string = &_Py_ID(facility);
+    PyUnicode_InternInPlace(&string);
     string = &_Py_ID(factory);
     PyUnicode_InternInPlace(&string);
     string = &_Py_ID(family);
@@ -2110,6 +2115,8 @@
     PyUnicode_InternInPlace(&string);
     string = &_Py_ID(id);
     PyUnicode_InternInPlace(&string);
+    string = &_Py_ID(ident);
+    PyUnicode_InternInPlace(&string);
     string = &_Py_ID(ignore);
     PyUnicode_InternInPlace(&string);
     string = &_Py_ID(imag);
@@ -2220,6 +2227,8 @@
     PyUnicode_InternInPlace(&string);
     string = &_Py_ID(locals);
     PyUnicode_InternInPlace(&string);
+    string = &_Py_ID(logoption);
+    PyUnicode_InternInPlace(&string);
     string = &_Py_ID(loop);
     PyUnicode_InternInPlace(&string);
     string = &_Py_ID(mapping);
@@ -5981,6 +5990,10 @@
         _PyObject_Dump((PyObject *)&_Py_ID(extend));
         Py_FatalError("immortal object has less refcnt than expected _PyObject_IMMORTAL_REFCNT");
     };
+    if (Py_REFCNT((PyObject *)&_Py_ID(facility)) < _PyObject_IMMORTAL_REFCNT) {
+        _PyObject_Dump((PyObject *)&_Py_ID(facility));
+        Py_FatalError("immortal object has less refcnt than expected _PyObject_IMMORTAL_REFCNT");
+    };
     if (Py_REFCNT((PyObject *)&_Py_ID(factory)) < _PyObject_IMMORTAL_REFCNT) {
         _PyObject_Dump((PyObject *)&_Py_ID(factory));
         Py_FatalError("immortal object has less refcnt than expected _PyObject_IMMORTAL_REFCNT");
@@ -6149,6 +6162,10 @@
         _PyObject_Dump((PyObject *)&_Py_ID(id));
         Py_FatalError("immortal object has less refcnt than expected _PyObject_IMMORTAL_REFCNT");
     };
+    if (Py_REFCNT((PyObject *)&_Py_ID(ident)) < _PyObject_IMMORTAL_REFCNT) {
+        _PyObject_Dump((PyObject *)&_Py_ID(ident));
+        Py_FatalError("immortal object has less refcnt than expected _PyObject_IMMORTAL_REFCNT");
+    };
     if (Py_REFCNT((PyObject *)&_Py_ID(ignore)) < _PyObject_IMMORTAL_REFCNT) {
         _PyObject_Dump((PyObject *)&_Py_ID(ignore));
         Py_FatalError("immortal object has less refcnt than expected _PyObject_IMMORTAL_REFCNT");
@@ -6369,6 +6386,10 @@
         _PyObject_Dump((PyObject *)&_Py_ID(locals));
         Py_FatalError("immortal object has less refcnt than expected _PyObject_IMMORTAL_REFCNT");
     };
+    if (Py_REFCNT((PyObject *)&_Py_ID(logoption)) < _PyObject_IMMORTAL_REFCNT) {
+        _PyObject_Dump((PyObject *)&_Py_ID(logoption));
+        Py_FatalError("immortal object has less refcnt than expected _PyObject_IMMORTAL_REFCNT");
+    };
     if (Py_REFCNT((PyObject *)&_Py_ID(loop)) < _PyObject_IMMORTAL_REFCNT) {
         _PyObject_Dump((PyObject *)&_Py_ID(loop));
         Py_FatalError("immortal object has less refcnt than expected _PyObject_IMMORTAL_REFCNT");
diff --git a/Modules/clinic/syslogmodule.c.h b/Modules/clinic/syslogmodule.c.h
new file mode 100644
index 0000000..0ce66ad
--- /dev/null
+++ b/Modules/clinic/syslogmodule.c.h
@@ -0,0 +1,257 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+#  include "pycore_gc.h"            // PyGC_Head
+#  include "pycore_runtime.h"       // _Py_ID()
+#endif
+
+
+PyDoc_STRVAR(syslog_openlog__doc__,
+"openlog($module, /, ident=<unrepresentable>, logoption=0,\n"
+"        facility=LOG_USER)\n"
+"--\n"
+"\n"
+"Set logging options of subsequent syslog() calls.");
+
+#define SYSLOG_OPENLOG_METHODDEF    \
+    {"openlog", _PyCFunction_CAST(syslog_openlog), METH_FASTCALL|METH_KEYWORDS, syslog_openlog__doc__},
+
+static PyObject *
+syslog_openlog_impl(PyObject *module, PyObject *ident, long logopt,
+                    long facility);
+
+static PyObject *
+syslog_openlog(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+    #define NUM_KEYWORDS 3
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(ident), &_Py_ID(logoption), &_Py_ID(facility), },
+    };
+    #undef NUM_KEYWORDS
+    #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+    #else  // !Py_BUILD_CORE
+    #  define KWTUPLE NULL
+    #endif  // !Py_BUILD_CORE
+
+    static const char * const _keywords[] = {"ident", "logoption", "facility", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "openlog",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[3];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
+    PyObject *ident = NULL;
+    long logopt = 0;
+    long facility = LOG_USER;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 3, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    if (args[0]) {
+        if (!PyUnicode_Check(args[0])) {
+            _PyArg_BadArgument("openlog", "argument 'ident'", "str", args[0]);
+            goto exit;
+        }
+        if (PyUnicode_READY(args[0]) == -1) {
+            goto exit;
+        }
+        ident = args[0];
+        if (!--noptargs) {
+            goto skip_optional_pos;
+        }
+    }
+    if (args[1]) {
+        logopt = PyLong_AsLong(args[1]);
+        if (logopt == -1 && PyErr_Occurred()) {
+            goto exit;
+        }
+        if (!--noptargs) {
+            goto skip_optional_pos;
+        }
+    }
+    facility = PyLong_AsLong(args[2]);
+    if (facility == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+skip_optional_pos:
+    return_value = syslog_openlog_impl(module, ident, logopt, facility);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(syslog_syslog__doc__,
+"syslog([priority=LOG_INFO,] message)\n"
+"Send the string message to the system logger.");
+
+#define SYSLOG_SYSLOG_METHODDEF    \
+    {"syslog", (PyCFunction)syslog_syslog, METH_VARARGS, syslog_syslog__doc__},
+
+static PyObject *
+syslog_syslog_impl(PyObject *module, int group_left_1, int priority,
+                   const char *message);
+
+static PyObject *
+syslog_syslog(PyObject *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int group_left_1 = 0;
+    int priority = LOG_INFO;
+    const char *message;
+
+    switch (PyTuple_GET_SIZE(args)) {
+        case 1:
+            if (!PyArg_ParseTuple(args, "s:syslog", &message)) {
+                goto exit;
+            }
+            break;
+        case 2:
+            if (!PyArg_ParseTuple(args, "is:syslog", &priority, &message)) {
+                goto exit;
+            }
+            group_left_1 = 1;
+            break;
+        default:
+            PyErr_SetString(PyExc_TypeError, "syslog.syslog requires 1 to 2 arguments");
+            goto exit;
+    }
+    return_value = syslog_syslog_impl(module, group_left_1, priority, message);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(syslog_closelog__doc__,
+"closelog($module, /)\n"
+"--\n"
+"\n"
+"Reset the syslog module values and call the system library closelog().");
+
+#define SYSLOG_CLOSELOG_METHODDEF    \
+    {"closelog", (PyCFunction)syslog_closelog, METH_NOARGS, syslog_closelog__doc__},
+
+static PyObject *
+syslog_closelog_impl(PyObject *module);
+
+static PyObject *
+syslog_closelog(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return syslog_closelog_impl(module);
+}
+
+PyDoc_STRVAR(syslog_setlogmask__doc__,
+"setlogmask($module, maskpri, /)\n"
+"--\n"
+"\n"
+"Set the priority mask to maskpri and return the previous mask value.");
+
+#define SYSLOG_SETLOGMASK_METHODDEF    \
+    {"setlogmask", (PyCFunction)syslog_setlogmask, METH_O, syslog_setlogmask__doc__},
+
+static long
+syslog_setlogmask_impl(PyObject *module, long maskpri);
+
+static PyObject *
+syslog_setlogmask(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    long maskpri;
+    long _return_value;
+
+    maskpri = PyLong_AsLong(arg);
+    if (maskpri == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    _return_value = syslog_setlogmask_impl(module, maskpri);
+    if ((_return_value == -1) && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = PyLong_FromLong(_return_value);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(syslog_LOG_MASK__doc__,
+"LOG_MASK($module, pri, /)\n"
+"--\n"
+"\n"
+"Calculates the mask for the individual priority pri.");
+
+#define SYSLOG_LOG_MASK_METHODDEF    \
+    {"LOG_MASK", (PyCFunction)syslog_LOG_MASK, METH_O, syslog_LOG_MASK__doc__},
+
+static long
+syslog_LOG_MASK_impl(PyObject *module, long pri);
+
+static PyObject *
+syslog_LOG_MASK(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    long pri;
+    long _return_value;
+
+    pri = PyLong_AsLong(arg);
+    if (pri == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    _return_value = syslog_LOG_MASK_impl(module, pri);
+    if ((_return_value == -1) && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = PyLong_FromLong(_return_value);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(syslog_LOG_UPTO__doc__,
+"LOG_UPTO($module, pri, /)\n"
+"--\n"
+"\n"
+"Calculates the mask for all priorities up to and including pri.");
+
+#define SYSLOG_LOG_UPTO_METHODDEF    \
+    {"LOG_UPTO", (PyCFunction)syslog_LOG_UPTO, METH_O, syslog_LOG_UPTO__doc__},
+
+static long
+syslog_LOG_UPTO_impl(PyObject *module, long pri);
+
+static PyObject *
+syslog_LOG_UPTO(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    long pri;
+    long _return_value;
+
+    pri = PyLong_AsLong(arg);
+    if (pri == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    _return_value = syslog_LOG_UPTO_impl(module, pri);
+    if ((_return_value == -1) && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = PyLong_FromLong(_return_value);
+
+exit:
+    return return_value;
+}
+/*[clinic end generated code: output=3b1bdb16565b8fda input=a9049054013a1b77]*/
diff --git a/Modules/syslogmodule.c b/Modules/syslogmodule.c
index 1593eea..b6296ed 100644
--- a/Modules/syslogmodule.c
+++ b/Modules/syslogmodule.c
@@ -54,6 +54,13 @@ Revision history:
 
 #include <syslog.h>
 
+/*[clinic input]
+module syslog
+[clinic start generated code]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=478f4ac94a1d4cae]*/
+
+#include "clinic/syslogmodule.c.h"
+
 /*  only one instance, only one syslog, so globals should be ok  */
 static PyObject *S_ident_o = NULL;                      /*  identifier, held by openlog()  */
 static char S_log_open = 0;
@@ -113,18 +120,22 @@ syslog_get_argv(void)
 }
 
 
-static PyObject *
-syslog_openlog(PyObject * self, PyObject * args, PyObject *kwds)
-{
-    long logopt = 0;
-    long facility = LOG_USER;
-    PyObject *ident = NULL;
-    static char *keywords[] = {"ident", "logoption", "facility", 0};
-    const char *ident_str = NULL;
+/*[clinic input]
+syslog.openlog
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwds,
-                          "|Ull:openlog", keywords, &ident, &logopt, &facility))
-        return NULL;
+    ident: unicode = NULL
+    logoption as logopt: long = 0
+    facility: long(c_default="LOG_USER") = LOG_USER
+
+Set logging options of subsequent syslog() calls.
+[clinic start generated code]*/
+
+static PyObject *
+syslog_openlog_impl(PyObject *module, PyObject *ident, long logopt,
+                    long facility)
+/*[clinic end generated code: output=5476c12829b6eb75 input=8a987a96a586eee7]*/
+{
+    const char *ident_str = NULL;
 
     if (ident) {
         Py_INCREF(ident);
@@ -158,48 +169,37 @@ syslog_openlog(PyObject * self, PyObject * args, PyObject *kwds)
 }
 
 
+
+/*[clinic input]
+syslog.syslog
+
+    [
+    priority: int(c_default="LOG_INFO") = LOG_INFO
+    ]
+
+    message: str
+
+    /
+
+Send the string message to the system logger.
+[clinic start generated code]*/
+
 static PyObject *
-syslog_syslog(PyObject * self, PyObject * args)
+syslog_syslog_impl(PyObject *module, int group_left_1, int priority,
+                   const char *message)
+/*[clinic end generated code: output=c3dbc73445a0e078 input=ac83d92b12ea3d4e]*/
 {
-    PyObject *message_object;
-    const char *message;
-    int   priority = LOG_INFO;
-
-    if (!PyArg_ParseTuple(args, "iU;[priority,] message string",
-                          &priority, &message_object)) {
-        PyErr_Clear();
-        if (!PyArg_ParseTuple(args, "U;[priority,] message string",
-                              &message_object))
-            return NULL;
-    }
-
-    message = PyUnicode_AsUTF8(message_object);
-    if (message == NULL)
-        return NULL;
-
     if (PySys_Audit("syslog.syslog", "is", priority, message) < 0) {
         return NULL;
     }
 
     /*  if log is not opened, open it now  */
     if (!S_log_open) {
-        PyObject *openargs;
-
-        /* Continue even if PyTuple_New fails, because openlog(3) is optional.
-         * So, we can still do logging in the unlikely event things are so hosed
-         * that we can't do this tuple.
-         */
-        if ((openargs = PyTuple_New(0))) {
-            PyObject *openlog_ret = syslog_openlog(self, openargs, NULL);
-            Py_DECREF(openargs);
-            if (openlog_ret == NULL) {
-                return NULL;
-            }
-            Py_DECREF(openlog_ret);
-        }
-        else {
+        PyObject *openlog_ret = syslog_openlog_impl(module, NULL, 0, LOG_USER);
+        if (openlog_ret == NULL) {
             return NULL;
         }
+        Py_DECREF(openlog_ret);
     }
 
     /* Incref ident, because it can be decrefed if syslog.openlog() is
@@ -214,8 +214,16 @@ syslog_syslog(PyObject * self, PyObject * args)
     Py_RETURN_NONE;
 }
 
+
+/*[clinic input]
+syslog.closelog
+
+Reset the syslog module values and call the system library closelog().
+[clinic start generated code]*/
+
 static PyObject *
-syslog_closelog(PyObject *self, PyObject *unused)
+syslog_closelog_impl(PyObject *module)
+/*[clinic end generated code: output=97890a80a24b1b84 input=fb77a54d447acf07]*/
 {
     if (PySys_Audit("syslog.closelog", NULL) < 0) {
         return NULL;
@@ -228,51 +236,67 @@ syslog_closelog(PyObject *self, PyObject *unused)
     Py_RETURN_NONE;
 }
 
-static PyObject *
-syslog_setlogmask(PyObject *self, PyObject *args)
-{
-    long maskpri, omaskpri;
+/*[clinic input]
+syslog.setlogmask -> long
 
-    if (!PyArg_ParseTuple(args, "l;mask for priority", &maskpri))
-        return NULL;
+    maskpri: long
+    /
+
+Set the priority mask to maskpri and return the previous mask value.
+[clinic start generated code]*/
+
+static long
+syslog_setlogmask_impl(PyObject *module, long maskpri)
+/*[clinic end generated code: output=d6ed163917b434bf input=adff2c2b76c7629c]*/
+{
     if (PySys_Audit("syslog.setlogmask", "l", maskpri) < 0) {
-        return NULL;
+        return -1;
     }
-    omaskpri = setlogmask(maskpri);
-    return PyLong_FromLong(omaskpri);
+
+    return setlogmask(maskpri);
 }
 
-static PyObject *
-syslog_log_mask(PyObject *self, PyObject *args)
+/*[clinic input]
+syslog.LOG_MASK -> long
+
+    pri: long
+    /
+
+Calculates the mask for the individual priority pri.
+[clinic start generated code]*/
+
+static long
+syslog_LOG_MASK_impl(PyObject *module, long pri)
+/*[clinic end generated code: output=c4a5bbfcc74c7c94 input=534829cb7fb5f7d2]*/
 {
-    long mask;
-    long pri;
-    if (!PyArg_ParseTuple(args, "l:LOG_MASK", &pri))
-        return NULL;
-    mask = LOG_MASK(pri);
-    return PyLong_FromLong(mask);
+    return LOG_MASK(pri);
 }
 
-static PyObject *
-syslog_log_upto(PyObject *self, PyObject *args)
+/*[clinic input]
+syslog.LOG_UPTO -> long
+
+    pri: long
+    /
+
+Calculates the mask for all priorities up to and including pri.
+[clinic start generated code]*/
+
+static long
+syslog_LOG_UPTO_impl(PyObject *module, long pri)
+/*[clinic end generated code: output=9eab083c90601d7e input=5e906d6c406b7458]*/
 {
-    long mask;
-    long pri;
-    if (!PyArg_ParseTuple(args, "l:LOG_UPTO", &pri))
-        return NULL;
-    mask = LOG_UPTO(pri);
-    return PyLong_FromLong(mask);
+    return LOG_UPTO(pri);
 }
 
 /* List of functions defined in the module */
 
 static PyMethodDef syslog_methods[] = {
-    {"openlog",         _PyCFunction_CAST(syslog_openlog),           METH_VARARGS | METH_KEYWORDS},
-    {"closelog",        syslog_closelog,        METH_NOARGS},
-    {"syslog",          syslog_syslog,          METH_VARARGS},
-    {"setlogmask",      syslog_setlogmask,      METH_VARARGS},
-    {"LOG_MASK",        syslog_log_mask,        METH_VARARGS},
-    {"LOG_UPTO",        syslog_log_upto,        METH_VARARGS},
+    SYSLOG_OPENLOG_METHODDEF
+    SYSLOG_CLOSELOG_METHODDEF
+    SYSLOG_SYSLOG_METHODDEF
+    SYSLOG_SETLOGMASK_METHODDEF
+    SYSLOG_LOG_MASK_METHODDEF
+    SYSLOG_LOG_UPTO_METHODDEF
     {NULL,              NULL,                   0}
 };