gh-135852: Remove out of tree pywin32 dependency for NTEventLogHandler

Include/internal/pycore_global_strings.h

@@ -435,7 +435,6 @@ struct _Py_global_strings {
         STRUCT_FOR_ID(env)
         STRUCT_FOR_ID(errors)
         STRUCT_FOR_ID(event)
-        STRUCT_FOR_ID(event_id)
         STRUCT_FOR_ID(eventmask)
         STRUCT_FOR_ID(exc)
         STRUCT_FOR_ID(exc_type)
@@ -692,7 +691,6 @@ struct _Py_global_strings {
         STRUCT_FOR_ID(query)
         STRUCT_FOR_ID(quotetabs)
         STRUCT_FOR_ID(raw)
-        STRUCT_FOR_ID(raw_data)
         STRUCT_FOR_ID(read)
         STRUCT_FOR_ID(read1)
         STRUCT_FOR_ID(readable)
@@ -773,7 +771,6 @@ struct _Py_global_strings {
         STRUCT_FOR_ID(strict)
         STRUCT_FOR_ID(strict_mode)
         STRUCT_FOR_ID(string)
-        STRUCT_FOR_ID(strings)
         STRUCT_FOR_ID(sub_key)
         STRUCT_FOR_ID(subcalls)
         STRUCT_FOR_ID(symmetric_difference_update)

Lib/logging/handlers.py

@@ -1156,14 +1156,15 @@ def __init__(self, appname, dllname=None, logtype="Application"):
             pass
         self.deftype = _winapi.EVENTLOG_ERROR_TYPE
         self.typemap = {
-            logging.DEBUG   : _winapi.EVENTLOG_INFORMATION_TYPE,
-            logging.INFO    : _winapi.EVENTLOG_INFORMATION_TYPE,
-            logging.WARNING : _winapi.EVENTLOG_WARNING_TYPE,
-            logging.ERROR   : _winapi.EVENTLOG_ERROR_TYPE,
+            logging.DEBUG: _winapi.EVENTLOG_INFORMATION_TYPE,
+            logging.INFO: _winapi.EVENTLOG_INFORMATION_TYPE,
+            logging.WARNING: _winapi.EVENTLOG_WARNING_TYPE,
+            logging.ERROR: _winapi.EVENTLOG_ERROR_TYPE,
             logging.CRITICAL: _winapi.EVENTLOG_ERROR_TYPE,
         }
 
-    def _add_source_to_registry(self, appname, dllname, logtype):
+    @staticmethod
+    def _add_source_to_registry(appname, dllname, logtype):
         import winreg
 
         key_path = f"SYSTEM\\CurrentControlSet\\Services\\EventLog\\{logtype}\\{appname}"
@@ -1212,22 +1213,20 @@ def emit(self, record):
         Determine the message ID, event category and event type. Then
         log the message in the NT event log.
         """
-        if self._winapi:
+        try:
+            id = self.getMessageID(record)
+            cat = self.getEventCategory(record)
+            type = self.getEventType(record)
+            msg = self.format(record)
+
+            # Get a handle to the event log
+            handle = self._winapi.RegisterEventSource(None, self.appname)
             try:
-                id = self.getMessageID(record)
-                cat = self.getEventCategory(record)
-                type = self.getEventType(record)
-                msg = self.format(record)
-
-                # Get a handle to the event log
-                handle = self._winapi.RegisterEventSource(None, self.appname)
-                if handle != self._winapi.INVALID_HANDLE_VALUE:
-                    try:
-                        self._winapi.ReportEvent(handle, type, cat, id, [msg])
-                    finally:
-                        self._winapi.DeregisterEventSource(handle)
-            except Exception:
-                self.handleError(record)
+                self._winapi.ReportEvent(handle, type, cat, id, msg)
+            finally:
+                self._winapi.DeregisterEventSource(handle)
+        except Exception:
+            self.handleError(record)
 
     def close(self):
         """

Lib/test/test_logging.py

@@ -7221,14 +7221,14 @@ def test_basic(self):
         self.assertTrue(found, msg=msg)
 
     @unittest.skipUnless(sys.platform == "win32", "Windows required for this test")
-    def test_updated_implementation(self):
-        h = logging.handlers.NTEventLogHandler('test_updated')
+    def test_without_pywin32(self):
+        h = logging.handlers.NTEventLogHandler('python_test')
         self.addCleanup(h.close)
 
         # Verify that the handler uses _winapi module
         self.assertIsNotNone(h._winapi, "_winapi module should be available")
 
-        r = logging.makeLogRecord({'msg': 'Test Updated Implementation'})
+        r = logging.makeLogRecord({'msg': 'Hello!'})
         h.emit(r)
 
 

Lib/test/test_winapi.py

@@ -161,13 +161,16 @@ def test_event_source_registration(self):
         source_name = "PythonTestEventSource"
 
         handle = _winapi.RegisterEventSource(None, source_name)
+        self.addCleanup(_winapi.DeregisterEventSource, handle)
         self.assertNotEqual(handle, _winapi.INVALID_HANDLE_VALUE)
 
-        with self.assertRaisesRegex(OSError, '[WinError 87]'):
+        with self.assertRaises(OSError) as cm:
             _winapi.RegisterEventSource(None, "")
+        self.assertEqual(cm.exception.winerror, 87)
 
-        with self.assertRaisesRegex(OSError, '[WinError 6]'):
+        with self.assertRaises(OSError) as cm:
             _winapi.DeregisterEventSource(_winapi.INVALID_HANDLE_VALUE)
+        self.assertEqual(cm.exception.winerror, 6)
 
     def test_report_event(self):
         source_name = "PythonTestEventSource"
@@ -176,15 +179,15 @@ def test_report_event(self):
         self.assertNotEqual(handle, _winapi.INVALID_HANDLE_VALUE)
         self.addCleanup(_winapi.DeregisterEventSource, handle)
 
-        # Test with strings and raw data
-        test_strings = ["Test message 1", "Test message 2"]
-        test_data = b"test raw data"
         _winapi.ReportEvent(handle, _winapi.EVENTLOG_SUCCESS, 1, 1002,
-                            test_strings, test_data)
+                            "Test message 1")
+
+        with self.assertRaises(TypeError):
+            _winapi.ReportEvent(handle, _winapi.EVENTLOG_SUCCESS, 1, 1002, 42)
 
-        # Test with empty strings list
-        _winapi.ReportEvent(handle, _winapi.EVENTLOG_AUDIT_FAILURE, 2, 1003, [])
+        with self.assertRaises(TypeError):
+            _winapi.ReportEvent(handle, _winapi.EVENTLOG_SUCCESS, 1, 1002, None)
 
-        with self.assertRaisesRegex(TypeError, 'expected a list of strings, not int'):
-            _winapi.ReportEvent(handle, _winapi.EVENTLOG_ERROR_TYPE, 0, 1001,
-                                ["string", 123])
+        with self.assertRaises(ValueError):
+            _winapi.ReportEvent(handle, _winapi.EVENTLOG_SUCCESS, 1, 1002,
+                                "Test message \0 with embedded null character")

Modules/_winapi.c

@@ -3029,8 +3029,9 @@ _winapi_DeregisterEventSource_impl(PyObject *module, HANDLE handle)
     success = DeregisterEventSource(handle);
     Py_END_ALLOW_THREADS
 
-    if (!success)
+    if (!success) {
         return PyErr_SetFromWindowsErr(0);
+    }
 
     Py_RETURN_NONE;
 }
@@ -3046,99 +3047,44 @@ _winapi.ReportEvent
         The event category.
     event_id: unsigned_int(bitwise=False)
         The event identifier.
-    strings: object(subclass_of='&PyList_Type')
-        A list of strings to be inserted into the event message.
-    raw_data: Py_buffer(accept={str, buffer, NoneType}) = None
-        The raw data for the event.
+    string: object
+        A string to be inserted into the event message.
+    /
 
 Writes an entry at the end of the specified event log.
 [clinic start generated code]*/
 
 static PyObject *
 _winapi_ReportEvent_impl(PyObject *module, HANDLE handle,
                          unsigned short type, unsigned short category,
-                         unsigned int event_id, PyObject *strings,
-                         Py_buffer *raw_data)
-/*[clinic end generated code: output=fc3bbbde78cffd6c input=abcc01d4fc284975]*/
+                         unsigned int event_id, PyObject *string)
+/*[clinic end generated code: output=8eb5e919369c9c6d input=6db2c51252f95b93]*/
 {
     BOOL success;
-    LPCWSTR *string_array = NULL;
-    WORD num_strings = 0;
-    LPVOID data = NULL;
-    DWORD data_size = 0;
-
-    // Handle strings list
-    Py_ssize_t size = PyList_Size(strings);
-    if (size > USHRT_MAX) {
-        PyErr_SetString(PyExc_ValueError, "strings is too long");
-        return NULL;
-    }
-    num_strings = (WORD)size;
+    LPCWSTR wide_string = NULL;
 
-    // Handle raw data
-    if (raw_data->len > PY_DWORD_MAX) {
-        PyErr_SetString(PyExc_ValueError, "raw_data is too large");
+    if (!PyUnicode_Check(string)) {
+        PyErr_SetString(PyExc_TypeError, "string must be a str");
         return NULL;
     }
-    if (raw_data->obj != NULL) {
-        data = raw_data->buf;
-        data_size = (DWORD)raw_data->len;
-    }
 
-    if (num_strings > 0) {
-        string_array = (LPCWSTR *)PyMem_New(LPCWSTR, num_strings);
-        if (string_array == NULL) {
-            return PyErr_NoMemory();
-        }
-
-        for (WORD i = 0; i < num_strings; i++) {
-            PyObject *item = PyList_GetItemRef(strings, i);
-            if (item == NULL) {
-                // Clean up already allocated strings
-                for (WORD j = 0; j < i; j++) {
-                    PyMem_Free((void *)string_array[j]);
-                }
-                PyMem_Free(string_array);
-                return NULL;
-            }
-            if (!PyUnicode_Check(item)) {
-                for (WORD j = 0; j < i; j++) {
-                    PyMem_Free((void *)string_array[j]);
-                }
-                PyMem_Free(string_array);
-                PyErr_Format(PyExc_TypeError,
-                             "expected a list of strings, not %T", item);
-                return NULL;
-            }
-            string_array[i] = PyUnicode_AsWideCharString(item, NULL);
-            Py_DECREF(item);
-            if (!string_array[i]) {
-                for (WORD j = 0; j < i; j++) {
-                    PyMem_Free((void *)string_array[j]);
-                }
-                PyMem_Free(string_array);
-                return NULL;
-            }
-        }
+    wide_string = PyUnicode_AsWideCharString(string, NULL);
+    if (!wide_string) {
+        return NULL;
     }
 
     Py_BEGIN_ALLOW_THREADS
-    success = ReportEventW(handle, type, category, event_id,
-                          NULL, num_strings, data_size,
-                          string_array, data);
+    success = ReportEventW(handle, type, category, event_id, NULL, 1, 0,
+                           &wide_string, NULL);
     Py_END_ALLOW_THREADS
 
     int ret = GetLastError();
-    // Clean up allocated strings
-    if (string_array) {
-        for (WORD i = 0; i < num_strings; i++) {
-            PyMem_Free((void *)string_array[i]);
-        }
-        PyMem_Free(string_array);
-    }
 
-    if (!success)
+    PyMem_Free((void *)wide_string);
+
+    if (!success) {
         return PyErr_SetFromWindowsErr(ret);
+    }
 
     Py_RETURN_NONE;
 }