[babeltrace.git] / src / bindings / python / bt2 / bt2 / native_bt_log_and_append_error.h

/*
 * SPDX-License-Identifier: MIT
 *
 * Copyright (c) 2017 Philippe Proulx <pproulx@efficios.com>
 */

#ifndef BABELTRACE_BINDINGS_PYTHON_BT2_BT2_NATIVE_BT_LOG_AND_APPEND_ERROR_H
#define BABELTRACE_BINDINGS_PYTHON_BT2_BT2_NATIVE_BT_LOG_AND_APPEND_ERROR_H

#include <stdbool.h>

#include "logging/comp-logging.h"

static
void restore_current_thread_error_and_append_exception_chain_recursive(
		int active_log_level, PyObject *py_exc_value,
		bt_self_component_class *self_component_class,
		bt_self_component *self_component,
		bt_self_message_iterator *self_message_iterator,
		const char *module_name)
{
	PyObject *py_exc_cause_value;
	PyObject *py_exc_type = NULL;
	PyObject *py_exc_tb = NULL;
	PyObject *py_bt_error_msg = NULL;
	GString *gstr = NULL;

	/* If this exception has a (Python) cause, handle that one first. */
	py_exc_cause_value = PyException_GetCause(py_exc_value);
	if (py_exc_cause_value) {
		restore_current_thread_error_and_append_exception_chain_recursive(
			active_log_level, py_exc_cause_value,
			self_component_class, self_component,
			self_message_iterator, module_name);
	}

	py_exc_tb = PyException_GetTraceback(py_exc_value);

	if (PyErr_GivenExceptionMatches(py_exc_value, py_mod_bt2_exc_error_type)) {
		/*
		 * If the raised exception is a bt2._Error, restore the wrapped
		 * error.
		 */
		PyObject *py_error_swig_ptr;
		const bt_error *error;
		int ret;

		/*
		 * We never raise a bt2._Error with a (Python) cause: it should
		 * be the end of the chain.
		 */
		BT_ASSERT(!py_exc_cause_value);

		/*
		 * We steal the error object from the exception, to move
		 * it back as the current thread's error.
		 */
		py_error_swig_ptr = PyObject_GetAttrString(py_exc_value, "_ptr");
		BT_ASSERT(py_error_swig_ptr);

		ret = PyObject_SetAttrString(py_exc_value, "_ptr", Py_None);
		BT_ASSERT(ret == 0);

		ret = SWIG_ConvertPtr(py_error_swig_ptr, (void **) &error,
			SWIGTYPE_p_bt_error, 0);
		BT_ASSERT(ret == 0);

		Py_DECREF(py_error_swig_ptr);

		BT_CURRENT_THREAD_MOVE_ERROR_AND_RESET(error);

		/*
		 * Append a cause with just the traceback and message, not the
		 * full str() of the bt2._Error.  We don't want the causes of
		 * this bt2._Error to be included in the cause we create.
		 */
		gstr = bt_py_common_format_tb(py_exc_tb, active_log_level);
		if (!gstr) {
			/* bt_py_common_format_tb has already warned. */
			goto end;
		}

		g_string_prepend(gstr, "Traceback (most recent call last):\n");

		py_bt_error_msg = PyObject_GetAttrString(py_exc_value, "_msg");
		BT_ASSERT(py_bt_error_msg);

		g_string_append_printf(gstr, "\nbt2._Error: %s",
			PyUnicode_AsUTF8(py_bt_error_msg));
	} else {
		py_exc_type = PyObject_Type(py_exc_value);

		gstr = bt_py_common_format_exception(py_exc_type, py_exc_value,
				py_exc_tb, active_log_level, false);
		if (!gstr) {
			/* bt_py_common_format_exception has already warned. */
			goto end;
		}
	}

	if (self_component_class) {
		BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_COMPONENT_CLASS(
			self_component_class, "%s", gstr->str);
	} else if (self_component) {
		BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_COMPONENT(
			self_component, "%s", gstr->str);
	} else if (self_message_iterator) {
		BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_MESSAGE_ITERATOR(
			self_message_iterator, "%s", gstr->str);
	} else {
		BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(
			module_name, "%s", gstr->str);
	}

end:
	if (gstr) {
		g_string_free(gstr, TRUE);
	}

	Py_XDECREF(py_exc_cause_value);
	Py_XDECREF(py_exc_type);
	Py_XDECREF(py_exc_tb);
	Py_XDECREF(py_bt_error_msg);
}

/*
 * If you have the following code:
 *
 * try:
 *     try:
 *         something_that_raises_bt2_error()
 *     except bt2._Error as e1:
 *         raise ValueError from e1
 * except ValueError as e2:
 *     raise TypeError from e2
 *
 * We will have the following exception chain:
 *
 *     TypeError -> ValueError -> bt2._Error
 *
 * Where the TypeError is the current exception (obtained from PyErr_Fetch).
 *
 * The bt2._Error contains a `struct bt_error *` that used to be the current
 * thread's error, at the moment the exception was raised.
 *
 * This function gets to the bt2._Error and restores the wrapped
 * `struct bt_error *` as the current thread's error.
 *
 * Then, for each exception in the chain, starting with the oldest one, it adds
 * an error cause to the current thread's error.
 */
static
void restore_bt_error_and_append_current_exception_chain(
		int active_log_level,
		bt_self_component_class *self_component_class,
		bt_self_component *self_component,
		bt_self_message_iterator *self_message_iterator,
		const char *module_name)
{
	BT_ASSERT(PyErr_Occurred());

	/* Used to access and restore the current exception. */
	PyObject *py_exc_type;
	PyObject *py_exc_value;
	PyObject *py_exc_tb;

	/* Fetch and normalize the Python exception. */
	PyErr_Fetch(&py_exc_type, &py_exc_value, &py_exc_tb);
	PyErr_NormalizeException(&py_exc_type, &py_exc_value, &py_exc_tb);
	BT_ASSERT(py_exc_type);
	BT_ASSERT(py_exc_value);
	BT_ASSERT(py_exc_tb);

	/*
	 * Set the exception's traceback so it's possible to get it using
	 * PyException_GetTraceback in
	 * restore_current_thread_error_and_append_exception_chain_recursive.
	 */
	PyException_SetTraceback(py_exc_value, py_exc_tb);

	restore_current_thread_error_and_append_exception_chain_recursive(
		active_log_level, py_exc_value, self_component_class,
		self_component, self_message_iterator, module_name);

	PyErr_Restore(py_exc_type, py_exc_value, py_exc_tb);
}

static inline
void log_exception_and_maybe_append_cause(
		int func_log_level,
		int active_log_level,
		bool append_error,
		bt_self_component_class *self_component_class,
		bt_self_component *self_component,
		bt_self_message_iterator *self_message_iterator,
		const char *module_name)
{
	GString *gstr;

	BT_ASSERT(PyErr_Occurred());
	gstr = bt_py_common_format_current_exception(active_log_level);
	if (!gstr) {
		/* bt_py_common_format_current_exception() logs errors */
		goto end;
	}

	BT_COMP_LOG_CUR_LVL(func_log_level, active_log_level, self_component,
		"%s", gstr->str);

	if (append_error) {
		restore_bt_error_and_append_current_exception_chain(
			active_log_level, self_component_class, self_component,
			self_message_iterator, module_name);

	}

end:
	if (gstr) {
		g_string_free(gstr, TRUE);
	}
}

static
bt_logging_level get_self_component_log_level(bt_self_component *self_comp)
{
	return bt_component_get_logging_level(
		bt_self_component_as_component(self_comp));
}

static
bt_logging_level get_self_message_iterator_log_level(
		bt_self_message_iterator *self_msg_iter)
{
	bt_self_component *self_comp =
		bt_self_message_iterator_borrow_component(self_msg_iter);

	return get_self_component_log_level(self_comp);
}

static inline
void loge_exception_append_cause_clear(const char *module_name, int active_log_level)
{
	log_exception_and_maybe_append_cause(BT_LOG_ERROR, active_log_level,
		true, NULL, NULL, NULL, module_name);
	PyErr_Clear();
}

static inline
void logw_exception_clear(int active_log_level)
{
	log_exception_and_maybe_append_cause(BT_LOG_WARNING, active_log_level,
		false, NULL, NULL, NULL, NULL);
	PyErr_Clear();
}

#endif /* BABELTRACE_BINDINGS_PYTHON_BT2_BT2_NATIVE_BT_LOG_AND_APPEND_ERROR_H */
Commit	Line	Data
612a9870	1	/*
0235b0db	2	* SPDX-License-Identifier: MIT
612a9870 PP	3	*
612a9870 PP	4	* Copyright (c) 2017 Philippe Proulx <pproulx@efficios.com>
612a9870 PP	5	*/
612a9870 PP	6
ae2be88d SM	7	#ifndef BABELTRACE_BINDINGS_PYTHON_BT2_BT2_NATIVE_BT_LOG_AND_APPEND_ERROR_H
	8	#define BABELTRACE_BINDINGS_PYTHON_BT2_BT2_NATIVE_BT_LOG_AND_APPEND_ERROR_H
	9
c4f23e30 FD	10	#include <stdbool.h>
c4f23e30 FD	11
612a9870 PP	12	#include "logging/comp-logging.h"
	13
	14	static
	15	void restore_current_thread_error_and_append_exception_chain_recursive(
	16	int active_log_level, PyObject *py_exc_value,
	17	bt_self_component_class *self_component_class,
	18	bt_self_component *self_component,
	19	bt_self_message_iterator *self_message_iterator,
	20	const char *module_name)
	21	{
	22	PyObject *py_exc_cause_value;
	23	PyObject *py_exc_type = NULL;
	24	PyObject *py_exc_tb = NULL;
332c7e11	25	PyObject *py_bt_error_msg = NULL;
612a9870 PP	26	GString *gstr = NULL;
612a9870 PP	27
332c7e11	28	/* If this exception has a (Python) cause, handle that one first. */
612a9870 PP	29	py_exc_cause_value = PyException_GetCause(py_exc_value);
	30	if (py_exc_cause_value) {
	31	restore_current_thread_error_and_append_exception_chain_recursive(
	32	active_log_level, py_exc_cause_value,
	33	self_component_class, self_component,
	34	self_message_iterator, module_name);
	35	}
	36
332c7e11 SM	37	py_exc_tb = PyException_GetTraceback(py_exc_value);
332c7e11 SM	38
612a9870	39	if (PyErr_GivenExceptionMatches(py_exc_value, py_mod_bt2_exc_error_type)) {
332c7e11 SM	40	/*
	41	* If the raised exception is a bt2._Error, restore the wrapped
	42	* error.
	43	*/
612a9870 PP	44	PyObject *py_error_swig_ptr;
	45	const bt_error *error;
	46	int ret;
	47
	48	/*
332c7e11 SM	49	* We never raise a bt2._Error with a (Python) cause: it should
332c7e11 SM	50	* be the end of the chain.
612a9870 PP	51	*/
	52	BT_ASSERT(!py_exc_cause_value);
	53
	54	/*
	55	* We steal the error object from the exception, to move
	56	* it back as the current thread's error.
	57	*/
	58	py_error_swig_ptr = PyObject_GetAttrString(py_exc_value, "_ptr");
	59	BT_ASSERT(py_error_swig_ptr);
	60
	61	ret = PyObject_SetAttrString(py_exc_value, "_ptr", Py_None);
	62	BT_ASSERT(ret == 0);
	63
	64	ret = SWIG_ConvertPtr(py_error_swig_ptr, (void **) &error,
	65	SWIGTYPE_p_bt_error, 0);
	66	BT_ASSERT(ret == 0);
	67
332c7e11 SM	68	Py_DECREF(py_error_swig_ptr);
332c7e11 SM	69
612a9870 PP	70	BT_CURRENT_THREAD_MOVE_ERROR_AND_RESET(error);
612a9870 PP	71
332c7e11 SM	72	/*
	73	* Append a cause with just the traceback and message, not the
	74	* full str() of the bt2._Error. We don't want the causes of
	75	* this bt2._Error to be included in the cause we create.
	76	*/
	77	gstr = bt_py_common_format_tb(py_exc_tb, active_log_level);
	78	if (!gstr) {
	79	/* bt_py_common_format_tb has already warned. */
	80	goto end;
	81	}
612a9870	82
332c7e11 SM	83	g_string_prepend(gstr, "Traceback (most recent call last):\n");
	84
	85	py_bt_error_msg = PyObject_GetAttrString(py_exc_value, "_msg");
	86	BT_ASSERT(py_bt_error_msg);
612a9870	87
332c7e11 SM	88	g_string_append_printf(gstr, "\nbt2._Error: %s",
	89	PyUnicode_AsUTF8(py_bt_error_msg));
	90	} else {
	91	py_exc_type = PyObject_Type(py_exc_value);
	92
	93	gstr = bt_py_common_format_exception(py_exc_type, py_exc_value,
	94	py_exc_tb, active_log_level, false);
	95	if (!gstr) {
	96	/* bt_py_common_format_exception has already warned. */
	97	goto end;
	98	}
612a9870 PP	99	}
	100
	101	if (self_component_class) {
	102	BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_COMPONENT_CLASS(
	103	self_component_class, "%s", gstr->str);
	104	} else if (self_component) {
	105	BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_COMPONENT(
	106	self_component, "%s", gstr->str);
	107	} else if (self_message_iterator) {
	108	BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_MESSAGE_ITERATOR(
	109	self_message_iterator, "%s", gstr->str);
	110	} else {
	111	BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(
	112	module_name, "%s", gstr->str);
	113	}
	114
	115	end:
	116	if (gstr) {
	117	g_string_free(gstr, TRUE);
	118	}
	119
	120	Py_XDECREF(py_exc_cause_value);
	121	Py_XDECREF(py_exc_type);
	122	Py_XDECREF(py_exc_tb);
332c7e11	123	Py_XDECREF(py_bt_error_msg);
612a9870 PP	124	}
	125
	126	/*
	127	* If you have the following code:
	128	*
	129	* try:
	130	* try:
	131	* something_that_raises_bt2_error()
	132	* except bt2._Error as e1:
	133	* raise ValueError from e1
	134	* except ValueError as e2:
	135	* raise TypeError from e2
	136	*
	137	* We will have the following exception chain:
	138	*
	139	* TypeError -> ValueError -> bt2._Error
	140	*
	141	* Where the TypeError is the current exception (obtained from PyErr_Fetch).
	142	*
	143	* The bt2._Error contains a `struct bt_error *` that used to be the current
	144	* thread's error, at the moment the exception was raised.
	145	*
	146	* This function gets to the bt2._Error and restores the wrapped
	147	* `struct bt_error *` as the current thread's error.
	148	*
	149	* Then, for each exception in the chain, starting with the oldest one, it adds
	150	* an error cause to the current thread's error.
	151	*/
	152	static
	153	void restore_bt_error_and_append_current_exception_chain(
	154	int active_log_level,
	155	bt_self_component_class *self_component_class,
	156	bt_self_component *self_component,
	157	bt_self_message_iterator *self_message_iterator,
	158	const char *module_name)
	159	{
	160	BT_ASSERT(PyErr_Occurred());
	161
	162	/* Used to access and restore the current exception. */
	163	PyObject *py_exc_type;
	164	PyObject *py_exc_value;
	165	PyObject *py_exc_tb;
	166
	167	/* Fetch and normalize the Python exception. */
	168	PyErr_Fetch(&py_exc_type, &py_exc_value, &py_exc_tb);
	169	PyErr_NormalizeException(&py_exc_type, &py_exc_value, &py_exc_tb);
	170	BT_ASSERT(py_exc_type);
	171	BT_ASSERT(py_exc_value);
	172	BT_ASSERT(py_exc_tb);
	173
	174	/*
	175	* Set the exception's traceback so it's possible to get it using
	176	* PyException_GetTraceback in
	177	* restore_current_thread_error_and_append_exception_chain_recursive.
	178	*/
	179	PyException_SetTraceback(py_exc_value, py_exc_tb);
	180
	181	restore_current_thread_error_and_append_exception_chain_recursive(
	182	active_log_level, py_exc_value, self_component_class,
	183	self_component, self_message_iterator, module_name);
	184
	185	PyErr_Restore(py_exc_type, py_exc_value, py_exc_tb);
	186	}
	187
188	static inline
84e438af SM	189	void log_exception_and_maybe_append_cause(
	190	int func_log_level,
	191	int active_log_level,
	192	bool append_error,
612a9870 PP	193	bt_self_component_class *self_component_class,
	194	bt_self_component *self_component,
	195	bt_self_message_iterator *self_message_iterator,
	196	const char *module_name)
	197	{
	198	GString *gstr;
	199
	200	BT_ASSERT(PyErr_Occurred());
	201	gstr = bt_py_common_format_current_exception(active_log_level);
	202	if (!gstr) {
	203	/* bt_py_common_format_current_exception() logs errors */
	204	goto end;
	205	}
	206
	207	BT_COMP_LOG_CUR_LVL(func_log_level, active_log_level, self_component,
	208	"%s", gstr->str);
	209
	210	if (append_error) {
	211	restore_bt_error_and_append_current_exception_chain(
	212	active_log_level, self_component_class, self_component,
	213	self_message_iterator, module_name);
	214
	215	}
	216
	217	end:
	218	if (gstr) {
	219	g_string_free(gstr, TRUE);
	220	}
	221	}
	222
	223	static
	224	bt_logging_level get_self_component_log_level(bt_self_component *self_comp)
	225	{
	226	return bt_component_get_logging_level(
	227	bt_self_component_as_component(self_comp));
	228	}
	229
	230	static
	231	bt_logging_level get_self_message_iterator_log_level(
	232	bt_self_message_iterator *self_msg_iter)
	233	{
	234	bt_self_component *self_comp =
	235	bt_self_message_iterator_borrow_component(self_msg_iter);
	236
	237	return get_self_component_log_level(self_comp);
	238	}
	239
	240	static inline
981f33dd	241	void loge_exception_append_cause_clear(const char *module_name, int active_log_level)
612a9870	242	{
84e438af	243	log_exception_and_maybe_append_cause(BT_LOG_ERROR, active_log_level,
612a9870	244	true, NULL, NULL, NULL, module_name);
981f33dd	245	PyErr_Clear();
612a9870 PP	246	}
612a9870 PP	247
612a9870	248	static inline
981f33dd	249	void logw_exception_clear(int active_log_level)
612a9870	250	{
84e438af	251	log_exception_and_maybe_append_cause(BT_LOG_WARNING, active_log_level,
612a9870	252	false, NULL, NULL, NULL, NULL);
981f33dd	253	PyErr_Clear();
612a9870	254	}
ae2be88d SM	255
ae2be88d SM	256	#endif /* BABELTRACE_BINDINGS_PYTHON_BT2_BT2_NATIVE_BT_LOG_AND_APPEND_ERROR_H */