Using internal logger instead of syslog

include/pyworker.h

@@ -78,6 +78,8 @@
 #include <sys/sem.h>
 #include <sys/wait.h>
 
+#include "logger.h"
+
 #define EXIT_PYERR 42
 #define WPIPER_SIG 30
 #define PYENTRY_FUNNAME "entrypoint"

include/responder.h

@@ -54,6 +54,7 @@
 #include <sys/ipc.h>
 #include <sys/sem.h>
 
+#include "logger.h"
 #include "pyworker.h"
 
 

src/main.c

@@ -40,6 +40,7 @@
 #include <sys/wait.h>
 
 #include "conf.h"
+#include "logger.h"
 #include "responder.h"
 
 #define IDENT_FMT "pyfcgi[%d]"
@@ -47,6 +48,8 @@
 
 #define EARLY_ERR(err_str) write(2, err_str, strlen(err_str))
 
+extern pyfcgi_conf_t PyFCGI_conf;
+
 int main(int argc, char **argv)
 {
 	char *ident, *py_entrypoint;
@@ -64,6 +67,12 @@ int main(int argc, char **argv)
 		return 1;
 	}
 
+PyFCGI_conf.context.pid = getpid();
+
+	pyfcgi_logger_init();
+	pyfcgi_logger_set_ident("pyfcgi(main)");
+	pyfcgi_logger_add("/tmp/pyfcgi.log", 0xFF, 0xFF, NULL);
+
 	ident_len = snprintf(NULL, 0, IDENT_FMT, getpid());
 	ident_len++;
 	ident = malloc(sizeof(char)*ident_len);
@@ -72,11 +81,11 @@ int main(int argc, char **argv)
 		EARLY_ERR("Unable to allocate memory for ident string...\n");
 		return -1;
 	}
-
 	snprintf(ident, ident_len, IDENT_FMT, getpid());
+	pyfcgi_logger_enable_syslog(ident);
+
 
-	openlog(ident, LOG_CONS | LOG_PERROR, LOG_DAEMON | LOG_USER);
-	syslog(LOG_INFO, "New server started");
+	pyfcgi_log(LOG_INFO, "New server started");
 
 	while(1)
 	{
@@ -84,7 +93,7 @@ int main(int argc, char **argv)
 		if(child == -1)
 		{
 			// TODO : Error
-			syslog(LOG_EMERG, "Failed to fork : '%s' sleeping %ds", strerror(errno), emerg_sleep);
+			pyfcgi_log(LOG_EMERG, "Failed to fork : '%s' sleeping %ds", strerror(errno), emerg_sleep);
 			sleep(emerg_sleep);
 			continue;
 		}
@@ -96,17 +105,17 @@ int main(int argc, char **argv)
 		waitpid(child, &child_ret, 0);
 		if(child_ret)
 		{
-			syslog(LOG_ERR, "Responder loop function exits with error code '%d'",
+			pyfcgi_log(LOG_ERR, "Responder loop function exits with error code '%d'",
 				WEXITSTATUS(child_ret));
 			if(WIFSIGNALED(child_ret))
 			{
-				syslog(LOG_ERR, "Responder loop function terminated by sig '%d'",
+				pyfcgi_log(LOG_ERR, "Responder loop function terminated by sig '%d'",
 					WTERMSIG(child_ret));
 			}
 		}
 		else
 		{
-			syslog(LOG_NOTICE, "Restarting main process after %d requests", MAX_REQS);
+			pyfcgi_log(LOG_NOTICE, "Restarting main process after %d requests", MAX_REQS);
 		}
 	}
 
@@ -143,7 +152,7 @@ int main(int argc, char **argv)
  *
  * @subsubsection main_how_use_syslog Logging, using syslog
  * 
- * Right now PyFCGI uses syslog() to log stuff using a pyfcgi ident.
+ * Right now PyFCGI uses pyfcgi_log() to log stuff using a pyfcgi ident.
  * PyFCGI logs can be filtered using /etc/rsyslog.d/pyfcgi.conf :
  * 
 <pre>

src/pyworker.c

@@ -47,7 +47,7 @@ int work(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
 	if(sigemptyset(&emptyset))
 	{
 		err = errno;
-		syslog(	LOG_ALERT, "sigemptyset fails in piper : %s",
+		pyfcgi_log(	LOG_ALERT, "sigemptyset fails in piper : %s",
 			strerror(err));
 		exit(err);
 	}
@@ -61,12 +61,12 @@ int work(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
 	if( !(piper_stack = malloc(PIPER_STACK_SZ)) )
 	{
 		err = errno;
-		syslog(LOG_ALERT, "Error while allocating piper stack : %s",
+		pyfcgi_log(LOG_ALERT, "Error while allocating piper stack : %s",
 		       strerror(err));
 		exit(err);
 	}
 
-	syslog(	LOG_INFO,
+	pyfcgi_log(	LOG_INFO,
 		"Worker %d started", wrk_id);
 
 	update_python_path(); // add cwd to python path
@@ -76,14 +76,14 @@ int work(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
 	piper_args.pystderr = pipe_err[0];
 
 	fetch_pyflush(&pystdout_flush, &pystderr_flush);
-	syslog(	LOG_INFO,
+	pyfcgi_log(	LOG_INFO,
 		"Worker[%d] Python started", wrk_id);
 	
 	//importing os
 	py_osmod = PyImport_ImportModule("os");
 	if(!py_osmod)
 	{
-		syslog(LOG_ALERT, "Unable to import os module");
+		pyfcgi_log(LOG_ALERT, "Unable to import os module");
 		log_expt(LOG_ALERT);
 		Py_Exit(EXIT_PYERR);
 	}
@@ -91,7 +91,7 @@ int work(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
 	// loading module
 	entry_fun = import_entrypoint(py_entrypoint);
 
-	syslog(	LOG_INFO,
+	pyfcgi_log(	LOG_INFO,
 		"Worker[%d] Waiting request with %s.%s()", wrk_id,
 		py_entrypoint, PYENTRY_FUNNAME);
 
@@ -100,7 +100,7 @@ int work(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
 	if(semop(semid, &sop, 1) < 0)
 	{
 		err = errno;
-		syslog(LOG_ERR,
+		pyfcgi_log(LOG_ERR,
 		       "Worker[%d] error incrementing the semaphore : %s",
 		       wrk_id, strerror(err));
 	}
@@ -108,7 +108,7 @@ int work(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
 	if(pipe(pipe_ctl) == -1)
 	{
 		err = errno;
-		syslog(LOG_ALERT,
+		pyfcgi_log(LOG_ALERT,
 		       "Worker[%d] Pipe fails for piper ctl : %s",
 		       wrk_id, strerror(err));
 		exit(err);
@@ -123,14 +123,14 @@ int work(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
 		if(semop(semid, &sop, 1) < 0)
 		{
 			err = errno;
-			syslog(LOG_ERR,
+			pyfcgi_log(LOG_ERR,
 			       "Worker[%d] error decrementing the semaphore : %s",
 			       wrk_id, strerror(err));
 		}
 
 		count++;
 		/*
-		syslog(	LOG_INFO,
+		pyfcgi_log(	LOG_INFO,
 			"Worker[%d] request %d", wrk_id, count);
 		*/
 		piper_args.out = out_stream;
@@ -150,7 +150,7 @@ int work(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
 		if(pid < 0)
 		{
 			err = errno;
-			syslog(LOG_ALERT,
+			pyfcgi_log(LOG_ALERT,
 			       "Worker[%d] req #%d Fork failed for piper : %s",
 			       wrk_id, count, strerror(err));
 			exit(err);
@@ -175,7 +175,7 @@ int work(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
 		else
 		{
 			/*
-			syslog(LOG_DEBUG, "Worker[%d] request %d funcall [OK]",
+			pyfcgi_log(LOG_DEBUG, "Worker[%d] request %d funcall [OK]",
 				wrk_id, count);
 			*/
 		}
@@ -189,23 +189,23 @@ int work(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
 		kill(pid, WPIPER_SIG); //indicate child python call ended
 /*
 gettimeofday(&stop, NULL);
-syslog(LOG_DEBUG, "W%dR%dtimer KIL %ld.%06ld us", wrk_id, count, stop.tv_sec - start.tv_sec, stop.tv_usec - start.tv_usec);
+pyfcgi_log(LOG_DEBUG, "W%dR%dtimer KIL %ld.%06ld us", wrk_id, count, stop.tv_sec - start.tv_sec, stop.tv_usec - start.tv_usec);
 */
 		waitpid(pid, &piper_status, 0);
 /*
 gettimeofday(&stop, NULL);
-syslog(LOG_DEBUG, "W%dR%dtimer W8  %ld.%06ld us", wrk_id, count, stop.tv_sec - start.tv_sec, stop.tv_usec - start.tv_usec);
+pyfcgi_log(LOG_DEBUG, "W%dR%dtimer W8  %ld.%06ld us", wrk_id, count, stop.tv_sec - start.tv_sec, stop.tv_usec - start.tv_usec);
 */
 		if(WIFSIGNALED(piper_status))
 		{
-			syslog(LOG_ERR,
+			pyfcgi_log(LOG_ERR,
 			       "Woker[%d] req #%d piper terminated by sig %d",
 			       wrk_id, count, WTERMSIG(piper_status));
 			exit(40);
 		}
 		else if(WEXITSTATUS(piper_status))
 		{
-			syslog(LOG_ERR,
+			pyfcgi_log(LOG_ERR,
 			       "Woker[%d] req #%d piper exited with error status %d",
 			       wrk_id, count, WEXITSTATUS(piper_status));
 			exit(41);
@@ -221,7 +221,7 @@ syslog(LOG_DEBUG, "W%dR%dtimer W8  %ld.%06ld us", wrk_id, count, stop.tv_sec - s
 		if(semop(semid, &sop, 1) < 0)
 		{
 			err = errno;
-			syslog(LOG_ERR,
+			pyfcgi_log(LOG_ERR,
 			       "Worker[%d] error incrementing the semaphore : %s",
 			       wrk_id, strerror(err));
 		}
@@ -233,7 +233,7 @@ syslog(LOG_DEBUG, "W%dR%dtimer W8  %ld.%06ld us", wrk_id, count, stop.tv_sec - s
 			stop.tv_usec += 1000000;
 			stop.tv_sec -= 1;
 		}
-		syslog(LOG_DEBUG, "Worker[%d] request %d END [OK] %lu bytes in %ld.%06lds",
+		pyfcgi_log(LOG_DEBUG, "Worker[%d] request %d END [OK] %lu bytes in %ld.%06lds",
 			wrk_id, count, rep_sz, stop.tv_sec, stop.tv_usec);
 	}
 	free(piper_stack);
@@ -269,14 +269,14 @@ int worker_piper(void *ptr)
 	if(sigaction(WPIPER_SIG, act, NULL))
 	{
 		err = errno;
-		syslog(	LOG_ALERT, "Unable to sigaction in piper : %s",
+		pyfcgi_log(	LOG_ALERT, "Unable to sigaction in piper : %s",
 			strerror(err));
 		exit(err);
 	}
 	write(ctl_pipe, " ", 1);
 
 
-	//syslog(LOG_DEBUG, "Worker[%d] req #%d piper", wrk_id, req_id);
+	//pyfcgi_log(LOG_DEBUG, "Worker[%d] req #%d piper", wrk_id, req_id);
 
 	fds[0].fd = pystderr;
 	fds[1].fd = pystdout;
@@ -290,7 +290,7 @@ int worker_piper(void *ptr)
 	while(cont)
 	{
 		poll_ret = poll(fds, nfds, 0);
-//syslog(LOG_DEBUG, "Worker[%d] req #%d poll_ret = %d", wrk_id, req_id, poll_ret);
+//pyfcgi_log(LOG_DEBUG, "Worker[%d] req #%d poll_ret = %d", wrk_id, req_id, poll_ret);
 		if(poll_ret < 0)
 		{
 			err = errno;
@@ -298,7 +298,7 @@ int worker_piper(void *ptr)
 			{
 				continue;
 			}
-			syslog( LOG_WARNING, "Poll error : %s",
+			pyfcgi_log( LOG_WARNING, "Poll error : %s",
 			        strerror(err));
 			fds[0].revents = fds[1].revents = 0;
 			continue;
@@ -311,19 +311,19 @@ int worker_piper(void *ptr)
 		if(poll_ret && (revents = fds[1].revents))
 		{
 			/*
-			syslog(LOG_DEBUG, "Worker[%d] req #%d STDOUT evt !",
+			pyfcgi_log(LOG_DEBUG, "Worker[%d] req #%d STDOUT evt !",
 			       wrk_id, req_id);
 			*/
 			poll_ret--;
 			if(revents & POLLIN)
 			{
 				/*
-				syslog(LOG_DEBUG, "Worker[%d] req #%d POLLIN STDOUT !",
+				pyfcgi_log(LOG_DEBUG, "Worker[%d] req #%d POLLIN STDOUT !",
 				       wrk_id, req_id);
 				*/
 				ret = read(pystdout, buf, PIPE_BUF);
 				/*
-				syslog(LOG_DEBUG, "Worker[%d] req #%d read(stdout) ret %d",
+				pyfcgi_log(LOG_DEBUG, "Worker[%d] req #%d read(stdout) ret %d",
 				       wrk_id, req_id, ret);
 				*/
 				if(ret < 0)
@@ -333,7 +333,7 @@ int worker_piper(void *ptr)
 					{
 						continue;
 					}
-					syslog( LOG_ERR,
+					pyfcgi_log( LOG_ERR,
 						"Error reading python stdout : %s",
 						strerror(err));
 					exit(err);
@@ -355,13 +355,13 @@ int worker_piper(void *ptr)
 		if(poll_ret && (revents = fds[0].revents))
 		{
 			/*
-			syslog(LOG_DEBUG, "Worker[%d] req #%d STDERR evt !",
+			pyfcgi_log(LOG_DEBUG, "Worker[%d] req #%d STDERR evt !",
 			       wrk_id, req_id);
 			*/
 			if(revents & POLLIN)
 			{
 				/*
-				syslog(LOG_DEBUG, "Worker[%d] req #%d POLLIN STDERR !",
+				pyfcgi_log(LOG_DEBUG, "Worker[%d] req #%d POLLIN STDERR !",
 				       wrk_id, req_id);
 				*/
 				while(1)
@@ -374,13 +374,13 @@ int worker_piper(void *ptr)
 						{
 							continue;
 						}
-						syslog( LOG_ERR,
+						pyfcgi_log( LOG_ERR,
 						        "Error reading python stdout : %s",
 							strerror(err));
 						exit(err);
 					}
 					buf[ret] = '\0';
-					syslog(LOG_ERR,
+					pyfcgi_log(LOG_ERR,
 					       "Worker[%d] Python error : %s",
 					       wrk_id, buf);
 					break;
@@ -391,7 +391,7 @@ int worker_piper(void *ptr)
 		fds[0].revents = fds[1].revents = 0;
 	}
 	/*
-	syslog(LOG_DEBUG, "Worker[%d] req #%d piper exiting...",
+	pyfcgi_log(LOG_DEBUG, "Worker[%d] req #%d piper exiting...",
 	       wrk_id, req_id);
 	*/
 	if(!closed)
@@ -406,7 +406,7 @@ int worker_piper(void *ptr)
 void worker_piper_sighandler(int signum)
 {
 	worker_piper_sigrcv = 1;
-	//syslog(LOG_DEBUG, "SIG");
+	//pyfcgi_log(LOG_DEBUG, "SIG");
 }
 
 int ctl_get_rep_sz(int ctl_pipe, size_t* rep_sz)
@@ -421,25 +421,25 @@ int ctl_get_rep_sz(int ctl_pipe, size_t* rep_sz)
 	if( (ret = poll(&fds, 1, 0)) < 0)
 	{
 		err = errno;
-		syslog(LOG_ERR, "Failed to poll ctl pipe : %s",
+		pyfcgi_log(LOG_ERR, "Failed to poll ctl pipe : %s",
 		       strerror(err));
 		return -1;
 	}
 	if(!ret)
 	{
-		syslog(LOG_ERR, "No data in ctl pipe for rep_sz...");
+		pyfcgi_log(LOG_ERR, "No data in ctl pipe for rep_sz...");
 		return -1;
 	}
 	ret = read(ctl_pipe, rep_sz, sizeof(size_t));
 	if(ret < 0)
 	{
-		syslog(LOG_ERR, "Error reading ctl pipe : %s",
+		pyfcgi_log(LOG_ERR, "Error reading ctl pipe : %s",
 		       strerror(errno));
 		return -1;
 	}
 	if(ret < sizeof(size_t))
 	{
-		syslog(LOG_ERR, "Incomplete read from ctl pipe, no rep_sz...");
+		pyfcgi_log(LOG_ERR, "Incomplete read from ctl pipe, no rep_sz...");
 		return -1;
 	}
 	return 0;
@@ -455,10 +455,10 @@ PyObject* import_entrypoint(char* py_entrypoint)
 	if(!entry_module)
 	{
 		//TODO syslog python error / traceback
-		syslog(	LOG_CRIT,
+		pyfcgi_log(	LOG_CRIT,
 			"Unable to import python file '%s'",
 			py_entrypoint);
-		syslog( LOG_INFO,
+		pyfcgi_log( LOG_INFO,
 			"%s", getcwd(NULL, 256));
 		log_expt(LOG_ERR);
 		sleep(1);
@@ -472,14 +472,14 @@ PyObject* import_entrypoint(char* py_entrypoint)
 	if(!entry_fun)
 	{
 		//TODO syslog python error / traceback
-		syslog(	LOG_CRIT,
+		pyfcgi_log(	LOG_CRIT,
 			"Unable to import object '%s' from '%s'",
 			PYENTRY_FUNNAME, py_entrypoint);
 		Py_Exit(2);
 	}
 	if(!PyCallable_Check(entry_fun))
 	{
-		syslog( LOG_CRIT,
+		pyfcgi_log( LOG_CRIT,
 			"When imported from '%s', '%s' was not a callable",
 			py_entrypoint, PYENTRY_FUNNAME);
 		Py_Exit(3);
@@ -493,7 +493,7 @@ static PyObject* _fetch_pyflush(const char *fdname)
 	pyfd = PySys_GetObject(fdname);
 	if(!pyfd)
 	{
-		syslog(LOG_ALERT, "Unable to fetch sys.%s", fdname);
+		pyfcgi_log(LOG_ALERT, "Unable to fetch sys.%s", fdname);
 		log_expt(LOG_ALERT);
 		Py_Exit(EXIT_PYERR);
 	}
@@ -501,13 +501,13 @@ static PyObject* _fetch_pyflush(const char *fdname)
 	Py_DECREF(pyfd);
 	if(!pyflush)
 	{
-		syslog(LOG_ALERT, "Unable to fetch sys.%s.flush", fdname);
+		pyfcgi_log(LOG_ALERT, "Unable to fetch sys.%s.flush", fdname);
 		log_expt(LOG_ALERT);
 		Py_Exit(EXIT_PYERR);
 	}
 	if(!PyCallable_Check(pyflush))
 	{
-		syslog(LOG_ALERT, "sys.%s.flush is not callable !",
+		pyfcgi_log(LOG_ALERT, "sys.%s.flush is not callable !",
 		       fdname);
 		Py_Exit(EXIT_PYERR);
 	}
@@ -581,7 +581,7 @@ void update_python_path()
 		}
 		else
 		{
-			syslog(LOG_ALERT, "Unable to fetch python path, got NULL.");
+			pyfcgi_log(LOG_ALERT, "Unable to fetch python path, got NULL.");
 		}
 		err_fmt = NULL;
 		err = 0;
@@ -622,7 +622,7 @@ update_python_path_err_cwd:
 update_python_path_err:
 	if(err_fmt)
 	{
-		syslog( LOG_ALERT, err_fmt, strerror(err));
+		pyfcgi_log( LOG_ALERT, err_fmt, strerror(err));
 	}
 	exit(err);
 }
@@ -657,7 +657,7 @@ void update_python_fd(int pipe_out[2], int pipe_err[2])
 		}
 		else
 		{
-			syslog(	LOG_ALERT,
+			pyfcgi_log(	LOG_ALERT,
 				"Unable to import python os module, got NULL.");
 		}
 		err_fmt = NULL;
@@ -673,7 +673,7 @@ void update_python_fd(int pipe_out[2], int pipe_err[2])
 		}
 		else
 		{
-			syslog(	LOG_ALERT,
+			pyfcgi_log(	LOG_ALERT,
 				"Unable to fetch os.fdopen() , got NULL.");
 		}
 		err_fmt = NULL;
@@ -683,7 +683,7 @@ void update_python_fd(int pipe_out[2], int pipe_err[2])
 	args = Py_BuildValue("is", pipe_out[1], "w");
 	if(!args)
 	{
-		syslog(	LOG_ERR, "Error building values with '%d', '%s' for stdout",
+		pyfcgi_log(	LOG_ERR, "Error building values with '%d', '%s' for stdout",
 			pipe_out[1], "w");
 		log_expt(LOG_ALERT);
 		err_fmt = NULL;
@@ -692,7 +692,7 @@ void update_python_fd(int pipe_out[2], int pipe_err[2])
 	new_fd = PyObject_CallObject(pyfdopen, args);
 	if(!new_fd || PyErr_Occurred())
 	{
-		syslog(	LOG_ERR, "Error calling fdopen(%d, '%s')",
+		pyfcgi_log(	LOG_ERR, "Error calling fdopen(%d, '%s')",
 			pipe_out[1], "w");
 		log_expt(LOG_ALERT);
 		err_fmt = NULL;
@@ -701,7 +701,7 @@ void update_python_fd(int pipe_out[2], int pipe_err[2])
 	Py_DECREF(args);
 	if(PySys_SetObject("stdout", new_fd))
 	{
-		syslog(LOG_ERR, "Unable to set sys.stdout");
+		pyfcgi_log(LOG_ERR, "Unable to set sys.stdout");
 		log_expt(LOG_ALERT);
 		goto update_python_fd_err_newfd;
 	}
@@ -710,7 +710,7 @@ void update_python_fd(int pipe_out[2], int pipe_err[2])
 	args = Py_BuildValue("is", pipe_err[1], "w");
 	if(!args)
 	{
-		syslog(	LOG_ERR, "Error building values with '%d', '%s' for stderr",
+		pyfcgi_log(	LOG_ERR, "Error building values with '%d', '%s' for stderr",
 			pipe_out[1], "w");
 		log_expt(LOG_ALERT);
 		err_fmt = NULL;
@@ -719,7 +719,7 @@ void update_python_fd(int pipe_out[2], int pipe_err[2])
 	new_fd = PyObject_CallObject(pyfdopen, args);
 	if(!new_fd || PyErr_Occurred())
 	{
-		syslog(	LOG_ERR, "Error calling fdopen(%d, '%s')",
+		pyfcgi_log(	LOG_ERR, "Error calling fdopen(%d, '%s')",
 			pipe_out[1], "w");
 		log_expt(LOG_ALERT);
 		err_fmt = NULL;
@@ -728,7 +728,7 @@ void update_python_fd(int pipe_out[2], int pipe_err[2])
 	Py_DECREF(args);
 	if(PySys_SetObject("stderr", new_fd))
 	{
-		syslog(LOG_ERR, "Unable to set sys.stderr");
+		pyfcgi_log(LOG_ERR, "Unable to set sys.stderr");
 		log_expt(LOG_ALERT);
 		goto update_python_fd_err_newfd;
 	}
@@ -751,7 +751,7 @@ update_python_fd_err_pipeout:
 update_python_fd_err:
 	if(err_fmt)
 	{
-		syslog(pri, err_fmt, strerror(err));
+		pyfcgi_log(pri, err_fmt, strerror(err));
 	}
 	exit(1);
 }
@@ -767,7 +767,7 @@ void update_pyenv(PyObject *py_osmod, char **environ)
 	pyenv = PyObject_GetAttrString(py_osmod, "environ");
 	if(!pyenv)
 	{
-		syslog(LOG_WARNING, "Unable to get os.environ");
+		pyfcgi_log(LOG_WARNING, "Unable to get os.environ");
 		log_expt(LOG_ALERT);
 	}
 	else
@@ -787,19 +787,19 @@ void update_pyenv(PyObject *py_osmod, char **environ)
 		}
 		if(!*value)
 		{
-			syslog(LOG_WARNING, "Droping environment value without value : '%s'",
+			pyfcgi_log(LOG_WARNING, "Droping environment value without value : '%s'",
 			       key);
 			cur++;
 			continue;
 		}
 		value++;
 		*(value-1) = '\0'; // dirty modification of **environ
-//syslog(LOG_DEBUG, "PySetEnv '%s'='%s'", key, value);
+//pyfcgi_log(LOG_DEBUG, "PySetEnv '%s'='%s'", key, value);
 		pykey = PyUnicode_DecodeLocale(key, "surrogateescape");
 		if(!pykey)
 		{
 			*(value-1) = '='; // **environ restore
-			syslog(LOG_ALERT, "Unable to parse environ key string '%s'",
+			pyfcgi_log(LOG_ALERT, "Unable to parse environ key string '%s'",
 			       key);
 			log_expt(LOG_ALERT);
 			Py_Exit(EXIT_PYERR);
@@ -808,14 +808,14 @@ void update_pyenv(PyObject *py_osmod, char **environ)
 		pyval = PyUnicode_DecodeFSDefault(value);
 		if(!pyval)
 		{
-			syslog(LOG_ALERT, "Unable to parse environ val string '%s'",
+			pyfcgi_log(LOG_ALERT, "Unable to parse environ val string '%s'",
 			       value);
 			log_expt(LOG_ALERT);
 			Py_Exit(EXIT_PYERR);
 		}
 		if(PyDict_SetItem(pyenv, pykey, pyval) == -1)
 		{
-			syslog(LOG_ERR, "Unable to set environ '%s'='%s'",
+			pyfcgi_log(LOG_ERR, "Unable to set environ '%s'='%s'",
 			       key, value);
 			log_expt(LOG_ERR);
 		}
@@ -831,7 +831,7 @@ void log_expt(int priority)
 {
 	if(!PyErr_Occurred())
 	{
-		syslog(priority, "No exception");
+		pyfcgi_log(priority, "No exception");
 		return;
 	}
 
@@ -847,7 +847,7 @@ void log_expt(int priority)
 	expt_str = PyObject_GetAttrString(expt, "__str__");
 	if(!expt_str)
 	{
-		syslog(LOG_ERR, "Unable to fetch __str__ from exception");
+		pyfcgi_log(LOG_ERR, "Unable to fetch __str__ from exception");
 	}
 	expt_val = PyObject_CallObject(expt_str, NULL);
 	expt_bytes = PyUnicode_AsUTF8String(expt_val);
@@ -866,5 +866,5 @@ void log_expt(int priority)
 	msg = malloc(sizeof(char) * msg_sz);
 	snprintf(msg, msg_sz, msg_fmt, type, val);
 
-	syslog(priority, msg);
+	pyfcgi_log(priority, msg);
 }

src/responder.c

@@ -44,7 +44,7 @@ int responder_loop(char *py_entrypoint, unsigned int max_reqs,
 	timeout.tv_nsec = 100000000;
 	idle = 0;
 
-	syslog(LOG_INFO, "Preparing workers");
+	pyfcgi_log(LOG_INFO, "Preparing workers");
 
 	init_context();
 
@@ -52,7 +52,7 @@ int responder_loop(char *py_entrypoint, unsigned int max_reqs,
 	if(!wrk_pids)
 	{
 		err = errno;
-		syslog(	LOG_ALERT,
+		pyfcgi_log(	LOG_ALERT,
 			"Unable to allocate memory for childs PID : %s",
 			strerror(err));
 		clean_exit(err);
@@ -94,7 +94,7 @@ int responder_loop(char *py_entrypoint, unsigned int max_reqs,
 			}
 			if(n == n_wrk)
 			{
-				syslog(LOG_WARNING,
+				pyfcgi_log(LOG_WARNING,
 				       "Child %d stopped but was notregistered",
 				       ret);
 				continue;
@@ -106,48 +106,48 @@ int responder_loop(char *py_entrypoint, unsigned int max_reqs,
 			if(ret < 0)
 			{
 				err = errno;
-				syslog(LOG_ALERT,
+				pyfcgi_log(LOG_ALERT,
 				       "Unable to dec sem after child exit : %s",
 				       strerror(err));
 				clean_exit(err);
 			}
 			if(status)
 			{
-				syslog(LOG_WARNING,
+				pyfcgi_log(LOG_WARNING,
 				       "Worker[%d] exited with status %d",
 				       n, status);
 			}
 			else
 			{
-				syslog(LOG_INFO,
+				pyfcgi_log(LOG_INFO,
 				       "Worker[%d] PID %d exited normally",
 				       n, wrk_pids[n]);
 			}
 			// child stopped, looking for it
 			if(wanted_n < n_wrk)
 			{	// need to shift the list and dec n_wrk
-				syslog(LOG_DEBUG, "GC Workers");
-syslog( LOG_DEBUG, "GC want %d have %d", wanted_n, n_wrk);
+				pyfcgi_log(LOG_DEBUG, "GC Workers");
+pyfcgi_log( LOG_DEBUG, "GC want %d have %d", wanted_n, n_wrk);
 				memmove(wrk_pids+n, wrk_pids+n+1,
 				        sizeof(pid_t) * (n_wrk - n));
 				n_wrk--;
 			}
 			else
 			{	// respawn on same slot
-				syslog(LOG_INFO, "respawn #%d", n);
+				pyfcgi_log(LOG_INFO, "respawn #%d", n);
 				wrk_pids[n] = spawn(py_entrypoint, n,
 				                    semid, max_reqs);
 				continue;
 			}
 		}
 		ret = semtimedop(semid, &sop, 1, &timeout);
-//syslog( LOG_DEBUG, "semtimeop ret=%d want %d have %d", ret, wanted_n, n_wrk);
+//pyfcgi_log( LOG_DEBUG, "semtimeop ret=%d want %d have %d", ret, wanted_n, n_wrk);
 		if(ret < 0)
 		{
 			err = errno;
 			if(err == EAGAIN)
 			{
-//syslog(LOG_DEBUG, "IDLE want %d have %d\t min=%d", wanted_n, n_wrk, min_wrk);
+//pyfcgi_log(LOG_DEBUG, "IDLE want %d have %d\t min=%d", wanted_n, n_wrk, min_wrk);
 				// workers idle
 				if(!idle)
 				{
@@ -159,13 +159,13 @@ syslog( LOG_DEBUG, "GC want %d have %d", wanted_n, n_wrk);
 				}
 				continue;
 			}
-			syslog(LOG_ERR, "Unable to read semaphore : %s",
+			pyfcgi_log(LOG_ERR, "Unable to read semaphore : %s",
 			       strerror(err));
 		}
 		if(!ret && n_wrk < max_wrk)
 		{
 			idle=0;
-			syslog( LOG_DEBUG,
+			pyfcgi_log( LOG_DEBUG,
 				"All workers busy, spawning a new one");
 			n = n_wrk;
 			n_wrk++;
@@ -179,11 +179,11 @@ syslog( LOG_DEBUG, "GC want %d have %d", wanted_n, n_wrk);
 	for(n_wrk=0; n_wrk != min_wrk; n_wrk++)
 	{
 		waitpid(wrk_pids[n_wrk], &status, 0);
-		syslog(LOG_DEBUG, "Child %d stopped with status %d",
+		pyfcgi_log(LOG_DEBUG, "Child %d stopped with status %d",
 		       wrk_pids[n_wrk], status);
 	}
 		//printf("Content-Type: text/html\r\n\r\nHello world !\n");
-	syslog(LOG_INFO,"Child workers stoped, stopping responder");
+	pyfcgi_log(LOG_INFO,"Child workers stoped, stopping responder");
 	exit(0);
 }
 
@@ -198,7 +198,7 @@ pid_t spawn(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
 	res = fork();
 	if(res == -1)
 	{
-		syslog(	LOG_ERR, "Fork fails for worker #%d : %s",
+		pyfcgi_log(	LOG_ERR, "Fork fails for worker #%d : %s",
 			wrk_id, strerror(errno));
 		return -1;
 	}
@@ -211,7 +211,7 @@ pid_t spawn(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
 	// busy. Let some time to this one to go up...
 	// TODO: find a better way to avoid spawning to max_wrk
 	nanosleep(&timeout, NULL);
-	syslog(	LOG_INFO,
+	pyfcgi_log(	LOG_INFO,
 		"Worker #%d spawned with PID %d", wrk_id, res);
 	return res;
 }
@@ -225,14 +225,14 @@ int new_semaphore(key_t semkey)
 	if(semid == -1)
 	{
 		err = errno;
-		syslog(	LOG_ALERT,
+		pyfcgi_log(	LOG_ALERT,
 			"Unable to create semaphore : %s",
 			strerror(err));
 		clean_exit(err);
 	}
 	if(pyfcgi_semid)
 	{
-		syslog(	LOG_WARNING,
+		pyfcgi_log(	LOG_WARNING,
 			"The semid context was not zero when calling new_semaphore, attempt to closeing it.");
 		semctl(pyfcgi_semid, 0, IPC_RMID);
 
@@ -245,7 +245,7 @@ void clean_exit(int status)
 {
 	if(pyfcgi_semid && semctl(pyfcgi_semid, 0, IPC_RMID) == -1)
 	{
-		syslog(	LOG_CRIT,
+		pyfcgi_log(	LOG_CRIT,
 			"Unable to delete semaphore before exiting.");
 	}
 	exit(status);