diff --git a/doc/src/sgml/libpq.sgml b/doc/src/sgml/libpq.sgml
index 910e9a8..eb0c588 100644
--- a/doc/src/sgml/libpq.sgml
+++ b/doc/src/sgml/libpq.sgml
@@ -5941,12 +5941,28 @@ PGContextVisibility PQsetErrorContextVisibility(PGconn *conn, PGContextVisibilit
 
     <listitem>
      <para>
-      Enables  tracing of the client/server communication to a debugging file stream.
+      Enables tracing of the client/server communication to a debugging file
+      stream.
+      Only available when protocol version 3 or higher is used.
 <synopsis>
 void PQtrace(PGconn *conn, FILE *stream);
 </synopsis>
      </para>
 
+     <para>
+      Each line consists of: an optional timestamp, a direction indicator
+      (<literal>&gt;</literal> for messages from client to server,
+      and <literal>&lt;</literal> for messages from server to client),
+      message type, message length, and message contents.
+      Protocol strings are enclosed in double quotes, while strings used as data
+      values are enclosed in single quotes.  Non-printable chars are printed as
+      hexadecimal escapes.
+      For numerical quantities, 16-bit values are preceded with <literal>#</literal>
+      and 32-bit values are printed without a prefix.
+      Further message-type-specific detail can be found in
+      <xref linkend="protocol-message-formats"/>.
+     </para>
+
      <note>
       <para>
        On Windows, if the <application>libpq</application> library and an application are
@@ -5961,6 +5977,28 @@ void PQtrace(PGconn *conn, FILE *stream);
     </listitem>
    </varlistentry>
 
+   <varlistentry id="libpq-PQtraceSetFlags">
+    <term><function>PQtraceSetFlags</function><indexterm><primary>PQtraceSetFlags</primary></indexterm></term>
+
+    <listitem>
+     <para>
+      Controls the tracing behavior of client/server communication.
+<synopsis>
+void PQtraceSetFlags(PGconn *conn, int flags);
+</synopsis>
+     </para>
+
+     <para>
+      <literal>flags</literal> contains flag bits describing the operating mode
+      of tracing.
+      If <literal>flags</literal> contains <literal>PQTRACE_SUPPRESS_TIMESTAMPS</literal>,
+      then the timestamp is not included when printing each message.
+      This function must be called after calling <function>PQtrace</function>.
+     </para>
+
+    </listitem>
+   </varlistentry>
+
    <varlistentry id="libpq-PQuntrace">
     <term><function>PQuntrace</function><indexterm><primary>PQuntrace</primary></indexterm></term>
 
diff --git a/src/interfaces/libpq/Makefile b/src/interfaces/libpq/Makefile
index 2aca882..2311399 100644
--- a/src/interfaces/libpq/Makefile
+++ b/src/interfaces/libpq/Makefile
@@ -41,6 +41,7 @@ OBJS = \
 	fe-secure.o \
 	legacy-pqsignal.o \
 	libpq-events.o \
+	libpq-trace.o \
 	pqexpbuffer.o \
 	fe-auth.o
 
@@ -113,6 +114,7 @@ install: all installdirs install-lib
 	$(INSTALL_DATA) $(srcdir)/libpq-fe.h '$(DESTDIR)$(includedir)'
 	$(INSTALL_DATA) $(srcdir)/libpq-events.h '$(DESTDIR)$(includedir)'
 	$(INSTALL_DATA) $(srcdir)/libpq-int.h '$(DESTDIR)$(includedir_internal)'
+	$(INSTALL_DATA) $(srcdir)/libpq-trace.h '$(DESTDIR)$(includedir_internal)'
 	$(INSTALL_DATA) $(srcdir)/pqexpbuffer.h '$(DESTDIR)$(includedir_internal)'
 	$(INSTALL_DATA) $(srcdir)/pg_service.conf.sample '$(DESTDIR)$(datadir)/pg_service.conf.sample'
 
@@ -126,6 +128,7 @@ uninstall: uninstall-lib
 	rm -f '$(DESTDIR)$(includedir)/libpq-fe.h'
 	rm -f '$(DESTDIR)$(includedir)/libpq-events.h'
 	rm -f '$(DESTDIR)$(includedir_internal)/libpq-int.h'
+	rm -f '$(DESTDIR)$(includedir_internal)/libpq-trace.h'
 	rm -f '$(DESTDIR)$(includedir_internal)/pqexpbuffer.h'
 	rm -f '$(DESTDIR)$(datadir)/pg_service.conf.sample'
 
diff --git a/src/interfaces/libpq/exports.txt b/src/interfaces/libpq/exports.txt
index bbc1f90..09f1111 100644
--- a/src/interfaces/libpq/exports.txt
+++ b/src/interfaces/libpq/exports.txt
@@ -179,3 +179,4 @@ PQgetgssctx               176
 PQsetSSLKeyPassHook_OpenSSL         177
 PQgetSSLKeyPassHook_OpenSSL         178
 PQdefaultSSLKeyPassHook_OpenSSL     179
+PQtraceSetFlags           180
diff --git a/src/interfaces/libpq/fe-connect.c b/src/interfaces/libpq/fe-connect.c
index 4e21057..d6c5943 100644
--- a/src/interfaces/libpq/fe-connect.c
+++ b/src/interfaces/libpq/fe-connect.c
@@ -6826,27 +6826,6 @@ PQsetErrorContextVisibility(PGconn *conn, PGContextVisibility show_context)
 	return old;
 }
 
-void
-PQtrace(PGconn *conn, FILE *debug_port)
-{
-	if (conn == NULL)
-		return;
-	PQuntrace(conn);
-	conn->Pfdebug = debug_port;
-}
-
-void
-PQuntrace(PGconn *conn)
-{
-	if (conn == NULL)
-		return;
-	if (conn->Pfdebug)
-	{
-		fflush(conn->Pfdebug);
-		conn->Pfdebug = NULL;
-	}
-}
-
 PQnoticeReceiver
 PQsetNoticeReceiver(PGconn *conn, PQnoticeReceiver proc, void *arg)
 {
diff --git a/src/interfaces/libpq/fe-exec.c b/src/interfaces/libpq/fe-exec.c
index 9a03804..5009e98 100644
--- a/src/interfaces/libpq/fe-exec.c
+++ b/src/interfaces/libpq/fe-exec.c
@@ -966,10 +966,6 @@ pqSaveParameterStatus(PGconn *conn, const char *name, const char *value)
 	pgParameterStatus *pstatus;
 	pgParameterStatus *prev;
 
-	if (conn->Pfdebug)
-		fprintf(conn->Pfdebug, "pqSaveParameterStatus: '%s' = '%s'\n",
-				name, value);
-
 	/*
 	 * Forget any old information about the parameter
 	 */
diff --git a/src/interfaces/libpq/fe-misc.c b/src/interfaces/libpq/fe-misc.c
index ce2d24b..ba682b3 100644
--- a/src/interfaces/libpq/fe-misc.c
+++ b/src/interfaces/libpq/fe-misc.c
@@ -49,6 +49,7 @@
 
 #include "libpq-fe.h"
 #include "libpq-int.h"
+#include "libpq-trace.h"
 #include "mb/pg_wchar.h"
 #include "pg_config_paths.h"
 #include "port/pg_bswap.h"
@@ -84,9 +85,6 @@ pqGetc(char *result, PGconn *conn)
 
 	*result = conn->inBuffer[conn->inCursor++];
 
-	if (conn->Pfdebug)
-		fprintf(conn->Pfdebug, "From backend> %c\n", *result);
-
 	return 0;
 }
 
@@ -100,9 +98,6 @@ pqPutc(char c, PGconn *conn)
 	if (pqPutMsgBytes(&c, 1, conn))
 		return EOF;
 
-	if (conn->Pfdebug)
-		fprintf(conn->Pfdebug, "To backend> %c\n", c);
-
 	return 0;
 }
 
@@ -138,10 +133,6 @@ pqGets_internal(PQExpBuffer buf, PGconn *conn, bool resetbuffer)
 
 	conn->inCursor = ++inCursor;
 
-	if (conn->Pfdebug)
-		fprintf(conn->Pfdebug, "From backend> \"%s\"\n",
-				buf->data);
-
 	return 0;
 }
 
@@ -167,9 +158,6 @@ pqPuts(const char *s, PGconn *conn)
 	if (pqPutMsgBytes(s, strlen(s) + 1, conn))
 		return EOF;
 
-	if (conn->Pfdebug)
-		fprintf(conn->Pfdebug, "To backend> \"%s\"\n", s);
-
 	return 0;
 }
 
@@ -188,13 +176,6 @@ pqGetnchar(char *s, size_t len, PGconn *conn)
 
 	conn->inCursor += len;
 
-	if (conn->Pfdebug)
-	{
-		fprintf(conn->Pfdebug, "From backend (%lu)> ", (unsigned long) len);
-		fwrite(s, 1, len, conn->Pfdebug);
-		fprintf(conn->Pfdebug, "\n");
-	}
-
 	return 0;
 }
 
@@ -212,13 +193,6 @@ pqSkipnchar(size_t len, PGconn *conn)
 	if (len > (size_t) (conn->inEnd - conn->inCursor))
 		return EOF;
 
-	if (conn->Pfdebug)
-	{
-		fprintf(conn->Pfdebug, "From backend (%lu)> ", (unsigned long) len);
-		fwrite(conn->inBuffer + conn->inCursor, 1, len, conn->Pfdebug);
-		fprintf(conn->Pfdebug, "\n");
-	}
-
 	conn->inCursor += len;
 
 	return 0;
@@ -234,13 +208,6 @@ pqPutnchar(const char *s, size_t len, PGconn *conn)
 	if (pqPutMsgBytes(s, len, conn))
 		return EOF;
 
-	if (conn->Pfdebug)
-	{
-		fprintf(conn->Pfdebug, "To backend> ");
-		fwrite(s, 1, len, conn->Pfdebug);
-		fprintf(conn->Pfdebug, "\n");
-	}
-
 	return 0;
 }
 
@@ -278,9 +245,6 @@ pqGetInt(int *result, size_t bytes, PGconn *conn)
 			return EOF;
 	}
 
-	if (conn->Pfdebug)
-		fprintf(conn->Pfdebug, "From backend (#%lu)> %d\n", (unsigned long) bytes, *result);
-
 	return 0;
 }
 
@@ -314,9 +278,6 @@ pqPutInt(int value, size_t bytes, PGconn *conn)
 			return EOF;
 	}
 
-	if (conn->Pfdebug)
-		fprintf(conn->Pfdebug, "To backend (%lu#)> %d\n", (unsigned long) bytes, value);
-
 	return 0;
 }
 
@@ -525,10 +486,6 @@ pqPutMsgStart(char msg_type, PGconn *conn)
 	conn->outMsgEnd = endPos;
 	/* length word, if needed, will be filled in by pqPutMsgEnd */
 
-	if (conn->Pfdebug)
-		fprintf(conn->Pfdebug, "To backend> Msg %c\n",
-				msg_type ? msg_type : ' ');
-
 	return 0;
 }
 
@@ -563,10 +520,6 @@ pqPutMsgBytes(const void *buf, size_t len, PGconn *conn)
 int
 pqPutMsgEnd(PGconn *conn)
 {
-	if (conn->Pfdebug)
-		fprintf(conn->Pfdebug, "To backend> Msg complete, length %u\n",
-				conn->outMsgEnd - conn->outCount);
-
 	/* Fill in length word if needed */
 	if (conn->outMsgStart >= 0)
 	{
@@ -576,6 +529,10 @@ pqPutMsgEnd(PGconn *conn)
 		memcpy(conn->outBuffer + conn->outMsgStart, &msgLen, 4);
 	}
 
+	/* Trace message only when there is first 1 byte */
+	if (conn->Pfdebug && (conn->outCount < conn->outMsgStart))
+		pqTraceOutputMessage(conn, conn->outBuffer + conn->outCount, true);
+
 	/* Make message eligible to send */
 	conn->outCount = conn->outMsgEnd;
 
@@ -1002,11 +959,13 @@ pqSendSome(PGconn *conn, int len)
 int
 pqFlush(PGconn *conn)
 {
-	if (conn->Pfdebug)
-		fflush(conn->Pfdebug);
-
 	if (conn->outCount > 0)
+	{
+		if (conn->Pfdebug)
+			fflush(conn->Pfdebug);
+
 		return pqSendSome(conn, conn->outCount);
+	}
 
 	return 0;
 }
diff --git a/src/interfaces/libpq/fe-protocol3.c b/src/interfaces/libpq/fe-protocol3.c
index eb55d52..da15337 100644
--- a/src/interfaces/libpq/fe-protocol3.c
+++ b/src/interfaces/libpq/fe-protocol3.c
@@ -28,6 +28,7 @@
 
 #include "libpq-fe.h"
 #include "libpq-int.h"
+#include "libpq-trace.h"
 #include "mb/pg_wchar.h"
 #include "port/pg_bswap.h"
 
@@ -414,6 +415,9 @@ pqParseInput3(PGconn *conn)
 		/* Successfully consumed this message */
 		if (conn->inCursor == conn->inStart + 5 + msgLength)
 		{
+			if(conn->Pfdebug)
+				pqTraceOutputMessage(conn, conn->inBuffer + conn->inStart, false);
+
 			/* Normal case: parsing agrees with specified length */
 			conn->inStart = conn->inCursor;
 		}
@@ -1609,6 +1613,9 @@ getCopyDataMessage(PGconn *conn)
 				return -1;
 		}
 
+		if(conn->Pfdebug)
+			pqTraceOutputMessage(conn, conn->inBuffer + conn->inStart, false);
+
 		/* Drop the processed message and loop around for another */
 		conn->inStart = conn->inCursor;
 	}
@@ -2066,6 +2073,8 @@ pqFunctionCall3(PGconn *conn, Oid fnid,
 		}
 		/* Completed this message, keep going */
 		/* trust the specified message length as what to skip */
+		if(conn->Pfdebug)
+			pqTraceOutputMessage(conn, conn->inBuffer + conn->inStart, false);
 		conn->inStart += 5 + msgLength;
 		needInput = false;
 	}
diff --git a/src/interfaces/libpq/libpq-fe.h b/src/interfaces/libpq/libpq-fe.h
index fa9b62a..59ea464 100644
--- a/src/interfaces/libpq/libpq-fe.h
+++ b/src/interfaces/libpq/libpq-fe.h
@@ -362,7 +362,9 @@ extern PGContextVisibility PQsetErrorContextVisibility(PGconn *conn,
 													   PGContextVisibility show_context);
 
 /* Enable/disable tracing */
+#define PQTRACE_SUPPRESS_TIMESTAMPS		1
 extern void PQtrace(PGconn *conn, FILE *debug_port);
+extern void PQtraceSetFlags(PGconn *conn, int flags);
 extern void PQuntrace(PGconn *conn);
 
 /* Override default notice handling routines */
diff --git a/src/interfaces/libpq/libpq-int.h b/src/interfaces/libpq/libpq-int.h
index 2f052f6..9f79a7c 100644
--- a/src/interfaces/libpq/libpq-int.h
+++ b/src/interfaces/libpq/libpq-int.h
@@ -376,6 +376,7 @@ struct pg_conn
 
 	/* Optional file to write trace info to */
 	FILE	   *Pfdebug;
+	int			traceFlags;
 
 	/* Callback procedures for notice message processing */
 	PGNoticeHooks noticeHooks;
diff --git a/src/interfaces/libpq/libpq-trace.c b/src/interfaces/libpq/libpq-trace.c
new file mode 100644
index 0000000..3da0c91
--- /dev/null
+++ b/src/interfaces/libpq/libpq-trace.c
@@ -0,0 +1,810 @@
+/*-------------------------------------------------------------------------
+ *
+ *	libpq-trace.c
+ *	  functions for libpq protocol tracing
+ *
+ * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/interfaces/libpq/libpq-trace.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres_fe.h"
+
+#include <limits.h>
+#include <time.h>
+
+#ifdef WIN32
+#include "win32.h"
+#else
+#include <unistd.h>
+#include <sys/time.h>
+#endif
+
+#include "libpq-fe.h"
+#include "libpq-int.h"
+#include "libpq-trace.h"
+#include "pgtime.h"
+#include "port/pg_bswap.h"
+
+/*
+ * protocol message types:
+ *
+ * protocol_message_type_b[]: message types sent by a backend
+ * protocol_message_type_f[]: message types sent by a frontend
+ */
+static const char *const protocol_message_type_b[] = {
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* \x00 ... \x0f */
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* \x10 ... \x1f */
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* \x20 ... \x2f */
+	0,							/* 0 */
+	"ParseComplete",			/* 1 */
+	"BindComplete",				/* 2 */
+	"CloseComplete",			/* 3 */
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* \x34 ... \x3f */
+	0,							/* @ */
+	"NotificationResponse",		/* A */
+	0,							/* B */
+	"CommandComplete",			/* C */
+	"DataRow",					/* D */
+	"ErrorResponse",			/* E */
+	0,							/* F */
+	"CopyInResponse",			/* G */
+	"CopyOutResponse",			/* H */
+	"EmptyQueryResponse",		/* I */
+	0,							/* J */
+	"BackendKeyData",			/* K */
+	0,							/* L */
+	0,							/* M */
+	"NoticeResponse",			/* N */
+	0,							/* O */
+	0,							/* P */
+	0,							/* Q */
+	"Authentication",			/* R */
+	"ParameterStatus",			/* S */
+	"RowDescription",			/* T */
+	0,							/* U */
+	"FunctionCallResponse",		/* V */
+	"CopyBothResponse",			/* W */
+	0,							/* X */
+	0,							/* Y */
+	"ReadyForQuery",			/* Z */
+	0, 0, 0, 0, 0,				/* \x5b ... \x5f */
+	0,							/* ` */
+	0,							/* a */
+	0,							/* b */
+	"CopyDone",					/* c */
+	"CopyData",					/* d */
+	0, 0, 0, 0, 0, 0, 0, 0, 0,	/* \x65 ... \0x6d */
+	"NoData",					/* n */
+	0,							/* o */
+	0,							/* p */
+	0,							/* q */
+	0,							/* r */
+	"PortalSuspended",			/* s */
+	"ParameterDescription",		/* t */
+	0,							/* u */
+	"NegotiateProtocolVersion", /* v */
+};
+
+static const char *const protocol_message_type_f[] = {
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* \x00 ... \x0f */
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* \x10 ... \x1f */
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* \x20 ... \x2f */
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* \x30 ... \x3f */
+	0,							/* @ */
+	0,							/* A */
+	"Bind",						/* B */
+	"Close",					/* C */
+	"Describe",					/* D */
+	"Execute",					/* E */
+	"FunctionCall",				/* F */
+	0,							/* G */
+	"Flush",					/* H */
+	0, 0, 0, 0, 0, 0, 0,		/* I ... O */
+	"Parse",					/* P */
+	"Query",					/* Q */
+	0,							/* R */
+	"Sync",						/* S */
+	0, 0, 0, 0,					/* T ... W */
+	"Terminate",				/* X */
+	0, 0, 0, 0, 0, 0, 0,		/* \x59 ... \x5f */
+	0,							/* ` */
+	0,							/* a */
+	0,							/* b */
+	"CopyDone",					/* c */
+	"CopyData",					/* d */
+	0,							/* e */
+	"CopyFail",					/* f */
+	0, 0, 0, 0, 0, 0, 0, 0, 0,	/* g ... o */
+	"AuthenticationResponse",	/* p */
+};
+
+static const char *pqGetProtocolMsgType(unsigned char c,
+										bool toServer);
+
+/* -------------------------
+ * FE/BE trace support
+ *
+ * We accumulate frontend message pieces in an array as the libpq code writes
+ * them, and log the complete message when pqTraceOutputFeMsg is called.
+ * For backend, we print the pieces as soon as we receive them from the server.
+ * -------------------------
+ */
+
+void
+PQtrace(PGconn *conn, FILE *debug_port)
+{
+	if (conn == NULL)
+		return;
+	PQuntrace(conn);
+	if (debug_port == NULL)
+		return;
+
+	setvbuf(debug_port, NULL, _IOLBF, 0);
+	conn->Pfdebug = debug_port;
+	conn->traceFlags = 0;
+}
+
+void
+PQuntrace(PGconn *conn)
+{
+	if (conn == NULL)
+		return;
+	if (conn->Pfdebug)
+	{
+		fflush(conn->Pfdebug);
+		conn->Pfdebug = NULL;
+	}
+
+	conn->traceFlags = 0;
+}
+
+void
+PQtraceSetFlags(PGconn *conn, int flags)
+{
+	if (conn == NULL)
+		return;
+	/* If PQtrace() failed, do nothing. */
+	if (conn->Pfdebug == NULL)
+		return;
+	conn->traceFlags = flags;
+}
+
+/*
+ * pqGetProtocolMsgType:
+ *		Get a protocol type from first byte identifier
+ */
+static const char *
+pqGetProtocolMsgType(unsigned char c, bool toServer)
+{
+	if (toServer == true &&
+		c < lengthof(protocol_message_type_f) &&
+		protocol_message_type_f[c] != NULL)
+		return protocol_message_type_f[c];
+
+	if (toServer == false &&
+		c < lengthof(protocol_message_type_b) &&
+		protocol_message_type_b[c] != NULL)
+		return protocol_message_type_b[c];
+
+	return "UnknownMessage:";
+}
+
+/*
+ *   pqTraceOutputByte1: output 1 char message to the log
+ */
+static void
+pqTraceOutputByte1(const char *data, FILE *pfdebug)
+{
+	fputc(' ', pfdebug);
+	/*
+	 * Show non-printable data in hex format, including the
+	 * terminating \0 that completes ErrorResponse and NoticeResponse
+	 * messages.
+	 */
+	if (!isprint(*data))
+		fprintf(pfdebug, "\\x%02x", *data);
+	else
+		fprintf(pfdebug, "%c", *data);
+}
+
+/*
+ *   pqTraceOutputInt16: output a 2-byte integer message to the log
+ */
+static int
+pqTraceOutputInt16(const char *data, FILE *pfdebug)
+{
+	uint16		tmp2;
+	int			result;
+
+	memcpy(&tmp2, data , 2);
+	result = (int) pg_ntoh16(tmp2);
+	fputc(' ', pfdebug);
+	fprintf(pfdebug, "#%d", result);
+
+	return result;
+}
+
+/*
+ *   pqTraceOutputInt32: output a 4-byte integer message to the log
+ */
+static int
+pqTraceOutputInt32(const char *data, FILE *pfdebug)
+{
+	int			result;
+
+	memcpy(&result, data, 4);
+	result = (int) pg_ntoh32(result);
+	fputc(' ', pfdebug);
+	fprintf(pfdebug, "%d", result);
+
+	return result;
+}
+
+/*
+ *   pqTraceOutputString: output a string message to the log
+ */
+static void
+pqTraceOutputString(const char *data, FILE *pfdebug)
+{
+	fputc(' ', pfdebug);
+	fprintf(pfdebug, "\"%s\"", data);
+}
+
+/*
+ * pqTraceOutputBinary: output a string possibly consisting of
+ * non-printable characters. Hex representation is used for such
+ * chars; others are printed normally.
+ *
+ * XXX this probably doesn't do a great job with multibyte chars, but then we
+ * don't know what is text and what encoding it'd be in.
+ */
+static void
+pqTraceOutputBinary(const char *v, int length, FILE *pfdebug)
+{
+	int			i,
+				next;			/* first char not yet printed */
+
+	for (next = i = 0; i < length; ++i)
+	{
+		if (isprint(v[i]))
+			continue;
+		else
+		{
+			fwrite(v + next, 1, i - next, pfdebug);
+			fprintf(pfdebug, "\\x%02x", v[i]);
+			next = i + 1;
+		}
+	}
+	if (next < length)
+		fwrite(v + next, 1, length - next, pfdebug);
+}
+
+/*
+ * pqTraceOutputNchar: output a string of exactly len bytes message to the log
+ */
+static void
+pqTraceOutputNchar(const char *data, FILE *pfdebug, int len)
+{
+	fputc(' ', pfdebug);
+	fprintf(pfdebug, "\'");
+	pqTraceOutputBinary(data, len, pfdebug);
+	fprintf(pfdebug, "\'");
+}
+
+static int
+moveStrCursor(const char *buf, int cursor, int end)
+{
+	while (cursor < end && buf[cursor])
+		cursor++;
+	cursor++;
+
+	return cursor;
+}
+
+/*
+ * Output functions by protocol message type
+ */
+
+/* Authentication */
+static void
+pqTraceOutputR(const char *message, FILE *f)
+{
+	pqTraceOutputInt32(message, f);
+}
+
+/* BackendKeyData */
+static void
+pqTraceOutputK(const char *message, FILE *f)
+{
+	int	cursor = 0;
+
+	pqTraceOutputInt32(message + cursor, f);
+	cursor += 4;
+	pqTraceOutputInt32(message + cursor, f);
+}
+
+/* Bind */
+static void
+pqTraceOutputB(const char *message, int end, FILE *f)
+{
+	int cursor = 0;
+	int nparams;
+	int nbytes;
+	int i;
+
+	pqTraceOutputString(message + cursor, f);
+	cursor = moveStrCursor(message, cursor, end);
+	pqTraceOutputString(message + cursor, f);
+	cursor = moveStrCursor(message, cursor, end);
+	nparams = pqTraceOutputInt16(message + cursor, f);
+	cursor += 2;
+
+	for (i = 0; i < nparams; i++)
+	{
+		pqTraceOutputInt16(message + cursor, f);
+		cursor += 2;
+	}
+
+	nparams = pqTraceOutputInt16(message + cursor, f);
+	cursor += 2;
+
+	for (i = 0; i < nparams; i++)
+	{
+		nbytes = pqTraceOutputInt32(message + cursor, f);
+		cursor += 4;
+		if (nbytes == -1)
+			break;
+		pqTraceOutputNchar(message + cursor, f, nbytes);
+		cursor += nbytes;
+	}
+
+	pqTraceOutputInt16(message + cursor, f);
+	cursor += 4;
+	pqTraceOutputInt16(message + cursor, f);
+}
+
+/* Close(F) or CommandComplete(B) */
+static void
+pqTraceOutputC(const char *message, FILE *f, bool toServer)
+{
+	int	cursor = 0;
+
+	if (toServer)
+	{
+		pqTraceOutputByte1(message + cursor, f);
+		cursor++;
+		pqTraceOutputString(message + cursor, f);
+	}
+	else
+		pqTraceOutputString(message + cursor, f);
+}
+
+/* CopyFail */
+static void
+pqTraceOutputf(const char *message, int end, FILE *f)
+{
+	pqTraceOutputString(message, f);
+}
+
+/* CopyInResponse */
+static void
+pqTraceOutputG(const char *message, int end, FILE *f)
+{
+	int	cursor = 0;
+
+	pqTraceOutputByte1(message + cursor, f);
+	cursor++;
+
+	while (end > cursor)
+	{
+		pqTraceOutputInt16(message + cursor, f);
+		cursor += 2;
+	}
+}
+
+/* CopyOutResponse */
+static void
+pqTraceOutputH(const char *message, int end, FILE *f, bool toServer)
+{
+	int	cursor = 0;
+
+	if (!toServer)
+	{
+		pqTraceOutputByte1(message + cursor, f);
+		cursor++;
+
+		while (end > cursor)
+		{
+			pqTraceOutputInt16(message + cursor, f);
+			cursor += 2;
+		}
+	}
+}
+
+/* CopyBothResponse */
+static void
+pqTraceOutputW(const char *message, int end, FILE *f)
+{
+	int	cursor = 0;
+
+	pqTraceOutputByte1(message + cursor, f);
+	cursor++;
+
+	while (end > cursor)
+	{
+		pqTraceOutputInt16(message + cursor, f);
+		cursor += 2;
+	}
+}
+
+/* Describe(F) or DataRow(B) */
+static void
+pqTraceOutputD(const char *message, FILE *f, bool toServer)
+{
+	int	cursor = 0;
+
+	if (toServer)
+	{
+		pqTraceOutputByte1(message + cursor, f);
+		cursor++;
+		pqTraceOutputString(message + cursor, f);
+	}
+	else
+	{
+		int		nfields;
+		int		len;
+		int		i;
+
+		nfields = pqTraceOutputInt16(message + cursor, f);
+		cursor += 2;
+		for (i = 0; i < nfields; i++)
+		{
+			len = pqTraceOutputInt32(message + cursor, f);
+			cursor += 4;
+			if (len == -1)
+				break;
+			pqTraceOutputNchar(message + cursor, f, len);
+			cursor += len;
+		}
+	}
+}
+
+/* Execute(F) or ErrorResponse(B) */
+static void
+pqTraceOutputE(const char *message, int end, FILE *f, bool toServer)
+{
+	int	cursor = 0;
+
+	if (toServer)
+	{
+		pqTraceOutputString(message + cursor, f);
+		cursor = moveStrCursor(message, cursor, end);
+		pqTraceOutputInt32(message + cursor, f);
+	}
+	else
+	{
+		while (end > cursor)
+		{
+			pqTraceOutputByte1(message + cursor, f);
+			if (message[cursor] == '\0')
+				break;
+			cursor++;
+			pqTraceOutputString(message + cursor, f);
+			cursor = moveStrCursor(message, cursor, end);
+		}
+	}
+}
+
+/* FunctionCall */
+static void
+pqTraceOutputF(const char *message, FILE *f)
+{
+	int	cursor = 0;
+	int nargs;
+	int nbytes;
+	int	i;
+
+	pqTraceOutputInt32(message + cursor, f);
+	cursor += 4;
+	pqTraceOutputInt16(message + cursor, f);
+	cursor += 2;
+
+	pqTraceOutputInt16(message + cursor, f);
+	cursor += 2;
+
+	nargs = pqTraceOutputInt16(message + cursor, f);
+	cursor += 2;
+
+	for (i = 0; i < nargs; i++)
+	{
+		nbytes = pqTraceOutputInt32(message + cursor, f);
+		cursor += 4;
+		if (nbytes == -1)
+			break;
+		pqTraceOutputNchar(message + cursor, f, nbytes);
+		cursor += nbytes;
+	}
+
+	pqTraceOutputInt16(message + cursor, f);
+}
+
+/* FunctionCallResponse */
+static void
+pqTraceOutputV(const char *message, FILE *f)
+{
+	int	cursor = 0;
+	int		len;
+
+	len = pqTraceOutputInt32(message + cursor, f);
+	cursor += 4;
+	if ( len != -1)
+		pqTraceOutputNchar(message + cursor, f, len);
+}
+
+/* NegotiateProtocolVersion */
+static void
+pqTraceOutputv(const char *message, FILE *f)
+{
+	int	cursor = 0;
+
+	pqTraceOutputInt32(message + cursor, f);
+	cursor += 4;
+	pqTraceOutputInt32(message + cursor, f);
+}
+
+/* NoticeResponse */
+static void
+pqTraceOutputN(const char *message, int end, FILE *f)
+{
+	int	cursor = 0;
+
+	while (end > cursor)
+	{
+		pqTraceOutputByte1(message, f);
+		cursor++;
+		if (message[cursor] == '\0')
+			break;
+		pqTraceOutputString(message + cursor, f);
+		cursor = moveStrCursor(message, cursor, end);
+	}
+}
+
+/* NotificationResponse */
+static void
+pqTraceOutputA(const char *message, int end, FILE *f)
+{
+	int	cursor = 0;
+
+	pqTraceOutputInt16(message + cursor, f);
+	cursor += 2;
+	pqTraceOutputString(message + cursor, f);
+	cursor = moveStrCursor(message, cursor, end);
+	pqTraceOutputString(message + cursor, f);
+}
+
+/* ParameterDescription */
+static void
+pqTraceOutputt(const char *message, FILE *f)
+{
+	int	cursor = 0;
+	int	nfields;
+	int	i;
+
+	nfields = pqTraceOutputInt16(message + cursor, f);
+	cursor += 2;
+
+	for (i = 0; i < nfields; i++)
+	{
+		pqTraceOutputInt32(message + cursor, f);
+		cursor += 4;
+	}
+}
+
+/* ParameterStatus */
+static void
+pqTraceOutputS(const char *message, int end, FILE *f, bool toServer)
+{
+	int	cursor = 0;
+
+	if (!toServer)
+	{
+		pqTraceOutputString(message + cursor, f);
+		cursor = moveStrCursor(message, cursor, end);
+		pqTraceOutputString(message + cursor, f);
+	}
+}
+
+/* Parse */
+static void
+pqTraceOutputP(const char *message, int end, FILE *f)
+{
+	int	cursor = 0;
+	int nparams;
+	int i;
+
+	pqTraceOutputString(message + cursor, f);
+	cursor = moveStrCursor(message, cursor, end);
+	pqTraceOutputString(message + cursor, f);
+	cursor = moveStrCursor(message, cursor, end);
+	nparams = pqTraceOutputInt16(message + cursor, f);
+	cursor += 2;
+
+	for (i = 0; i < nparams; i++)
+	{
+		pqTraceOutputInt32(message + cursor, f);
+		cursor += 4;
+	}
+}
+
+/* Query */
+static void
+pqTraceOutputQ(const char *message, FILE *f)
+{
+	pqTraceOutputString(message, f);
+}
+
+/* ReadyForQuery */
+static void
+pqTraceOutputZ(const char *message, FILE *f)
+{
+	pqTraceOutputByte1(message, f);
+}
+
+/* RowDescription */
+static void
+pqTraceOutputT(const char *message, int end, FILE *f)
+{
+	int	cursor = 0;
+	int nfields;
+	int	i;
+
+	nfields = pqTraceOutputInt16(message + cursor, f);
+	cursor += 2;
+
+	for (i = 0; i < nfields; i++)
+	{
+		pqTraceOutputString(message + cursor, f);
+		cursor = moveStrCursor(message, cursor, end);
+		pqTraceOutputInt32(message + cursor, f);
+		cursor +=4;
+		pqTraceOutputInt16(message + cursor, f);
+		cursor +=2;
+		pqTraceOutputInt32(message + cursor, f);
+		cursor +=4;
+		pqTraceOutputInt16(message + cursor, f);
+		cursor +=2;
+		pqTraceOutputInt32(message + cursor, f);
+		cursor +=4;
+		pqTraceOutputInt16(message + cursor, f);
+		cursor +=2;
+	}
+}
+
+void
+pqTraceOutputMessage(PGconn *conn, const char *message, bool toServer)
+{
+	struct timeval tval;
+	pg_time_t	stamp_time;
+	char		timestr[128];
+	char 		id = '\0';
+	int			length;
+	char	   *prefix = toServer ? ">" : "<";
+	int			LogCursor = 0;
+	int			LogEnd;
+	const char	*message_type = "UnkownMessage";
+
+	if ((conn->traceFlags & PQTRACE_SUPPRESS_TIMESTAMPS) == 0)
+	{
+		gettimeofday(&tval, NULL);
+		stamp_time = (pg_time_t) tval.tv_sec;
+
+		strftime(timestr,  sizeof(timestr),
+				 "%Y-%m-%d %H:%M:%S",
+				 localtime(&stamp_time));
+		/* append microseconds */
+		sprintf(timestr + strlen(timestr), ".%06d", (int) (tval.tv_usec));
+	}
+	else
+		timestr[0] = '\0';
+
+	id = message[LogCursor++];
+
+	memcpy(&length, message + LogCursor , 4);
+	length = (int) pg_ntoh32(length);
+	LogCursor += 4;
+	LogEnd = length - 4;
+
+	message_type = pqGetProtocolMsgType(id, toServer);
+
+	fprintf(conn->Pfdebug, "%s\t%s\t%s\t%d", timestr, prefix, message_type, length);
+
+	switch(id)
+	{
+		case 'R':	/* Authentication */
+			pqTraceOutputR(message + LogCursor, conn->Pfdebug);
+			break;
+		case 'K':	/* secret key data from the backend */
+			pqTraceOutputK(message + LogCursor, conn->Pfdebug);
+			break;
+		case 'B':	/* Bind */
+			pqTraceOutputB(message + LogCursor, LogEnd, conn->Pfdebug);
+			break;
+		case 'C':	/* Close(F) or Command Complete(B) */
+			pqTraceOutputC(message + LogCursor, conn->Pfdebug, toServer);
+			break;
+		case 'd':	/* Copy Data */
+			/* Drop COPY data to reduce the overhead of logging. */
+			break;
+		case 'f':	/* Copy Fail */
+			pqTraceOutputf(message + LogCursor, LogEnd, conn->Pfdebug);
+			break;
+		case 'G':	/* Start Copy In */
+			pqTraceOutputG(message + LogCursor, LogEnd, conn->Pfdebug);
+			break;
+		case 'H':	/* Flush(F) or Start Copy Out(B) */
+			pqTraceOutputH(message + LogCursor, LogEnd, conn->Pfdebug, toServer);
+			break;
+		case 'W':	/* Start Copy Both */
+			pqTraceOutputW(message + LogCursor, LogEnd, conn->Pfdebug);
+			break;
+		case 'D':	/* Describe(F) or Data Row(B) */
+			pqTraceOutputD(message + LogCursor, conn->Pfdebug, toServer);
+			break;
+		case 'E':	/* Execute(F) or Error Return(B) */
+			pqTraceOutputE(message + LogCursor, LogEnd, conn->Pfdebug, toServer);
+			break;
+		case 'F':	/* Function Call */
+			pqTraceOutputF(message + LogCursor, conn->Pfdebug);
+			break;
+		case 'V':	/* Function Call response */
+			pqTraceOutputV(message + LogCursor, conn->Pfdebug);
+			break;
+		case 'v':	/* Negotiate Protocol Version */
+			pqTraceOutputv(message + LogCursor, conn->Pfdebug);
+			break;
+		case 'N':	/* Notice Response */
+			pqTraceOutputN(message + LogCursor, LogEnd, conn->Pfdebug);
+			break;
+		case 'A':	/* Notification Response */
+			pqTraceOutputA(message + LogCursor, LogEnd, conn->Pfdebug);
+			break;
+		case 't':	/* Parameter Description */
+			pqTraceOutputt(message + LogCursor, conn->Pfdebug);
+			break;
+		case 'S':	/* Parameter Status(B) or Sync(F) */
+			pqTraceOutputS(message + LogCursor, LogEnd, conn->Pfdebug, toServer);
+			break;
+		case 'P':	/* Parse */
+			pqTraceOutputP(message + LogCursor, LogEnd, conn->Pfdebug);
+			break;
+		case 'Q':	/* Query */
+			pqTraceOutputQ(message + LogCursor, conn->Pfdebug);
+			break;
+		case 'Z':	/* Ready For Query */
+			pqTraceOutputZ(message + LogCursor, conn->Pfdebug);
+			break;
+		case 'T':	/* Row Description */
+			pqTraceOutputT(message + LogCursor, LogEnd, conn->Pfdebug);
+			break;
+		case '2':	/* Bind Complete */
+		case '3':	/* Close Complete */
+		case 'c':	/* Copy Done */
+		case 'I':	/* empty query */
+		case 'n':	/* No Data */
+		case '1':	/* Parse Complete */
+		case 's':	/* Portal Suspended */
+		case 'X':	/* Terminate */
+			/* No message content */
+			break;
+		default:
+			fprintf(conn->Pfdebug, "Invalid Protocol:%c\n", id);
+			break;
+	}
+
+	fputc('\n', conn->Pfdebug);
+}
diff --git a/src/interfaces/libpq/libpq-trace.h b/src/interfaces/libpq/libpq-trace.h
new file mode 100644
index 0000000..6a643db
--- /dev/null
+++ b/src/interfaces/libpq/libpq-trace.h
@@ -0,0 +1,32 @@
+/*-------------------------------------------------------------------------
+ *
+ * libpq-trace.h
+ *	  This file contains definitions for structures and
+ *	  externs for functions used by libpq protocol tracing.
+ *
+ * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/interfaces/libpq/libpq-trace.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef LIBPQ_TRACE_H
+#define LIBPQ_TRACE_H
+
+#include "libpq-fe.h"
+#include "libpq-int.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern void pqTraceOutputMessage(PGconn *conn, const char *message, bool toServer);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif							/* LIBPQ_TRACE_H */