From 8b85464094b4e36fddcad9744d0b59b8621605eb Mon Sep 17 00:00:00 2001
From: Anthonin Bonnefoy <anthonin.bonnefoy@datadoghq.com>
Date: Mon, 15 May 2023 10:00:08 +0200
Subject: [PATCH v11] Add pg_tracing extension to contrib

This extension add the possibility to create server-side
spans for distributed tracing.

When a query is sampled, the extension will create spans
tracking the process of this query: Parse, Planner, Executor...
During ExecutorEnd, the planstate is also converted in spans,
effectively generating an explain analyze in a trace format.

The spans are exposed through the pg_tracing_peek_spans and
pg_tracing_consume_spans views.

Sending spans to a trace collector is outside this extension's
scope.
---
 contrib/Makefile                              |    1 +
 contrib/meson.build                           |    1 +
 contrib/pg_tracing/Makefile                   |   30 +
 contrib/pg_tracing/expected/cleanup.out       |    8 +
 contrib/pg_tracing/expected/extended.out      |  156 +
 contrib/pg_tracing/expected/insert.out        |   56 +
 contrib/pg_tracing/expected/nested.out        |  297 ++
 contrib/pg_tracing/expected/parallel.out      |   48 +
 contrib/pg_tracing/expected/reset.out         |   13 +
 contrib/pg_tracing/expected/sample.out        |  149 +
 contrib/pg_tracing/expected/select.out        |  304 ++
 contrib/pg_tracing/expected/subxact.out       |   58 +
 contrib/pg_tracing/expected/trigger.out       |  264 ++
 contrib/pg_tracing/expected/utility.out       |  285 ++
 contrib/pg_tracing/expected/wal.out           |   75 +
 contrib/pg_tracing/meson.build                |   61 +
 contrib/pg_tracing/pg_tracing--1.0.sql        |  101 +
 contrib/pg_tracing/pg_tracing.c               | 2592 +++++++++++++++++
 contrib/pg_tracing/pg_tracing.conf            |    1 +
 contrib/pg_tracing/pg_tracing.control         |    5 +
 contrib/pg_tracing/pg_tracing.h               |   43 +
 contrib/pg_tracing/pg_tracing_explain.c       |  552 ++++
 contrib/pg_tracing/pg_tracing_explain.h       |   21 +
 contrib/pg_tracing/pg_tracing_parallel.c      |  103 +
 contrib/pg_tracing/pg_tracing_parallel.h      |   44 +
 contrib/pg_tracing/pg_tracing_query_process.c |  478 +++
 contrib/pg_tracing/pg_tracing_query_process.h |   30 +
 contrib/pg_tracing/pg_tracing_span.c          |  261 ++
 contrib/pg_tracing/pg_tracing_span.h          |  150 +
 contrib/pg_tracing/sql/cleanup.sql            |    5 +
 contrib/pg_tracing/sql/extended.sql           |   41 +
 contrib/pg_tracing/sql/insert.sql             |   22 +
 contrib/pg_tracing/sql/nested.sql             |  205 ++
 contrib/pg_tracing/sql/parallel.sql           |   23 +
 contrib/pg_tracing/sql/reset.sql              |    3 +
 contrib/pg_tracing/sql/sample.sql             |   45 +
 contrib/pg_tracing/sql/select.sql             |   99 +
 contrib/pg_tracing/sql/subxact.sql            |   18 +
 contrib/pg_tracing/sql/trigger.sql            |  185 ++
 contrib/pg_tracing/sql/utility.sql            |  183 ++
 contrib/pg_tracing/sql/wal.sql                |   31 +
 contrib/pg_tracing/t/001_basic.pl             |   34 +
 doc/src/sgml/contrib.sgml                     |    1 +
 doc/src/sgml/filelist.sgml                    |    1 +
 doc/src/sgml/pgtracing.sgml                   | 1010 +++++++
 src/backend/executor/instrument.c             |    9 +-
 src/include/executor/instrument.h             |    2 +
 47 files changed, 8101 insertions(+), 3 deletions(-)
 create mode 100644 contrib/pg_tracing/Makefile
 create mode 100644 contrib/pg_tracing/expected/cleanup.out
 create mode 100644 contrib/pg_tracing/expected/extended.out
 create mode 100644 contrib/pg_tracing/expected/insert.out
 create mode 100644 contrib/pg_tracing/expected/nested.out
 create mode 100644 contrib/pg_tracing/expected/parallel.out
 create mode 100644 contrib/pg_tracing/expected/reset.out
 create mode 100644 contrib/pg_tracing/expected/sample.out
 create mode 100644 contrib/pg_tracing/expected/select.out
 create mode 100644 contrib/pg_tracing/expected/subxact.out
 create mode 100644 contrib/pg_tracing/expected/trigger.out
 create mode 100644 contrib/pg_tracing/expected/utility.out
 create mode 100644 contrib/pg_tracing/expected/wal.out
 create mode 100644 contrib/pg_tracing/meson.build
 create mode 100644 contrib/pg_tracing/pg_tracing--1.0.sql
 create mode 100644 contrib/pg_tracing/pg_tracing.c
 create mode 100644 contrib/pg_tracing/pg_tracing.conf
 create mode 100644 contrib/pg_tracing/pg_tracing.control
 create mode 100644 contrib/pg_tracing/pg_tracing.h
 create mode 100644 contrib/pg_tracing/pg_tracing_explain.c
 create mode 100644 contrib/pg_tracing/pg_tracing_explain.h
 create mode 100644 contrib/pg_tracing/pg_tracing_parallel.c
 create mode 100644 contrib/pg_tracing/pg_tracing_parallel.h
 create mode 100644 contrib/pg_tracing/pg_tracing_query_process.c
 create mode 100644 contrib/pg_tracing/pg_tracing_query_process.h
 create mode 100644 contrib/pg_tracing/pg_tracing_span.c
 create mode 100644 contrib/pg_tracing/pg_tracing_span.h
 create mode 100644 contrib/pg_tracing/sql/cleanup.sql
 create mode 100644 contrib/pg_tracing/sql/extended.sql
 create mode 100644 contrib/pg_tracing/sql/insert.sql
 create mode 100644 contrib/pg_tracing/sql/nested.sql
 create mode 100644 contrib/pg_tracing/sql/parallel.sql
 create mode 100644 contrib/pg_tracing/sql/reset.sql
 create mode 100644 contrib/pg_tracing/sql/sample.sql
 create mode 100644 contrib/pg_tracing/sql/select.sql
 create mode 100644 contrib/pg_tracing/sql/subxact.sql
 create mode 100644 contrib/pg_tracing/sql/trigger.sql
 create mode 100644 contrib/pg_tracing/sql/utility.sql
 create mode 100644 contrib/pg_tracing/sql/wal.sql
 create mode 100644 contrib/pg_tracing/t/001_basic.pl
 create mode 100644 doc/src/sgml/pgtracing.sgml

diff --git a/contrib/Makefile b/contrib/Makefile
index da4e2316a3..721a58fcde 100644
--- a/contrib/Makefile
+++ b/contrib/Makefile
@@ -36,6 +36,7 @@ SUBDIRS = \
 		pg_prewarm	\
 		pg_stat_statements \
 		pg_surgery	\
+		pg_tracing		\
 		pg_trgm		\
 		pgrowlocks	\
 		pgstattuple	\
diff --git a/contrib/meson.build b/contrib/meson.build
index c0b267c632..05d1a3c34e 100644
--- a/contrib/meson.build
+++ b/contrib/meson.build
@@ -52,6 +52,7 @@ subdir('pgrowlocks')
 subdir('pg_stat_statements')
 subdir('pgstattuple')
 subdir('pg_surgery')
+subdir('pg_tracing')
 subdir('pg_trgm')
 subdir('pg_visibility')
 subdir('pg_walinspect')
diff --git a/contrib/pg_tracing/Makefile b/contrib/pg_tracing/Makefile
new file mode 100644
index 0000000000..153f45f365
--- /dev/null
+++ b/contrib/pg_tracing/Makefile
@@ -0,0 +1,30 @@
+# contrib/pg_tracing/Makefile
+
+MODULE_big = pg_tracing
+OBJS = \
+	$(WIN32RES) \
+	pg_tracing.o \
+	pg_tracing_query_process.o \
+	pg_tracing_explain.o \
+	pg_tracing_parallel.o \
+	pg_tracing_span.o
+
+TAP_TESTS = 1
+
+EXTENSION = pg_tracing
+DATA = pg_tracing--1.0.sql
+PGFILEDESC = "pg_tracing - Distributed tracing for postgres"
+
+REGRESS_OPTS = --temp-config $(top_srcdir)/contrib/pg_tracing/pg_tracing.conf
+REGRESS = utility select extended insert trigger sample subxact reset nested wal parallel cleanup
+
+ifdef USE_PGXS
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)
+else
+subdir = contrib/pg_tracing
+top_builddir = ../..
+include $(top_builddir)/src/Makefile.global
+include $(top_srcdir)/contrib/contrib-global.mk
+endif
diff --git a/contrib/pg_tracing/expected/cleanup.out b/contrib/pg_tracing/expected/cleanup.out
new file mode 100644
index 0000000000..7ab66964ef
--- /dev/null
+++ b/contrib/pg_tracing/expected/cleanup.out
@@ -0,0 +1,8 @@
+-- Drop test table and test functions
+DROP TABLE pg_tracing_test;
+DROP function test_function_project_set;
+DROP function test_function_result;
+DROP EXTENSION pg_tracing CASCADE;
+NOTICE:  drop cascades to 2 other objects
+DETAIL:  drop cascades to view peek_spans_with_level
+drop cascades to view peek_ordered_spans
diff --git a/contrib/pg_tracing/expected/extended.out b/contrib/pg_tracing/expected/extended.out
new file mode 100644
index 0000000000..7cb8d31966
--- /dev/null
+++ b/contrib/pg_tracing/expected/extended.out
@@ -0,0 +1,156 @@
+-- Trace everything
+SET pg_tracing.sample_rate = 1.0;
+-- Simple query with extended protocol
+SELECT $1, $2 \bind 1 2 \g
+ ?column? | ?column? 
+----------+----------
+ 1        | 2
+(1 row)
+
+SELECT span_type, span_operation, parameters, lvl FROM peek_ordered_spans;
+   span_type    |          span_operation           |     parameters     | lvl 
+----------------+-----------------------------------+--------------------+-----
+ Parse          | Parse                             |                    |   1
+ Utility        | SET pg_tracing.sample_rate = 0.0; |                    |   1
+ ProcessUtility | ProcessUtility                    |                    |   2
+ Parse          | Parse                             |                    |   1
+ Select         | SELECT $1, $2                     | $1 = '1', $2 = '2' |   1
+ Planner        | Planner                           |                    |   2
+ Executor       | ExecutorRun                       |                    |   2
+ Result         | Result                            |                    |   3
+(8 rows)
+
+CALL clean_spans();
+-- Trigger an error due to mismatching number of parameters
+BEGIN; select $1 \bind \g
+ERROR:  bind message supplies 0 parameters, but prepared statement "" requires 1
+ROLLBACK;
+SELECT span_type, span_operation, parameters, lvl FROM peek_ordered_spans;
+   span_type    | span_operation | parameters | lvl 
+----------------+----------------+------------+-----
+ Parse          | Parse          |            |   1
+ Utility        | BEGIN;         |            |   1
+ ProcessUtility | ProcessUtility |            |   2
+ Parse          | Parse          |            |   1
+ Utility        | ROLLBACK;      |            |   1
+ ProcessUtility | ProcessUtility |            |   2
+(6 rows)
+
+CALL clean_spans();
+-- Execute queries with extended protocol within an explicit transaction
+BEGIN;
+SELECT $1 \bind 1 \g
+ ?column? 
+----------
+ 1
+(1 row)
+
+SELECT $1, $2 \bind 2 3 \g
+ ?column? | ?column? 
+----------+----------
+ 2        | 3
+(1 row)
+
+COMMIT;
+-- Spans within the same transaction should have been generated with the same trace_id
+SELECT count(distinct(trace_id)) = 1 FROM pg_tracing_peek_spans;
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT span_type, span_operation, parameters, lvl FROM peek_ordered_spans;
+   span_type    | span_operation |     parameters     | lvl 
+----------------+----------------+--------------------+-----
+ Parse          | Parse          |                    |   1
+ Utility        | BEGIN;         |                    |   1
+ ProcessUtility | ProcessUtility |                    |   2
+ Parse          | Parse          |                    |   1
+ Select         | SELECT $1      | $1 = '1'           |   1
+ Planner        | Planner        |                    |   2
+ Executor       | ExecutorRun    |                    |   2
+ Result         | Result         |                    |   3
+ Parse          | Parse          |                    |   1
+ Select         | SELECT $1, $2  | $1 = '2', $2 = '3' |   1
+ Planner        | Planner        |                    |   2
+ Executor       | ExecutorRun    |                    |   2
+ Result         | Result         |                    |   3
+ Parse          | Parse          |                    |   1
+ Utility        | COMMIT;        |                    |   1
+ ProcessUtility | ProcessUtility |                    |   2
+(16 rows)
+
+CALL clean_spans();
+-- Mix extended protocol and simple protocol
+BEGIN;
+SELECT $1 \bind 1 \g
+ ?column? 
+----------
+ 1
+(1 row)
+
+SELECT 5, 6, 7;
+ ?column? | ?column? | ?column? 
+----------+----------+----------
+        5 |        6 |        7
+(1 row)
+
+SELECT $1, $2 \bind 2 3 \g
+ ?column? | ?column? 
+----------+----------
+ 2        | 3
+(1 row)
+
+COMMIT;
+-- Spans within the same transaction should have been generated with the same trace_id
+SELECT count(distinct(trace_id)) = 1 FROM pg_tracing_peek_spans;
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT span_type, span_operation, parameters, lvl FROM peek_ordered_spans;
+   span_type    |   span_operation   |       parameters       | lvl 
+----------------+--------------------+------------------------+-----
+ Parse          | Parse              |                        |   1
+ Utility        | BEGIN;             |                        |   1
+ ProcessUtility | ProcessUtility     |                        |   2
+ Parse          | Parse              |                        |   1
+ Select         | SELECT $1          | $1 = '1'               |   1
+ Planner        | Planner            |                        |   2
+ Executor       | ExecutorRun        |                        |   2
+ Result         | Result             |                        |   3
+ Parse          | Parse              |                        |   1
+ Select         | SELECT $1, $2, $3; | $1 = 5, $2 = 6, $3 = 7 |   1
+ Planner        | Planner            |                        |   2
+ Executor       | ExecutorRun        |                        |   2
+ Result         | Result             |                        |   3
+ Parse          | Parse              |                        |   1
+ Select         | SELECT $1, $2      | $1 = '2', $2 = '3'     |   1
+ Planner        | Planner            |                        |   2
+ Executor       | ExecutorRun        |                        |   2
+ Result         | Result             |                        |   3
+ Parse          | Parse              |                        |   1
+ Utility        | COMMIT;            |                        |   1
+ ProcessUtility | ProcessUtility     |                        |   2
+(21 rows)
+
+CALL clean_spans();
+-- gdesc calls a single parse command then execute a query. Make sure we handle this case
+SELECT 1 \gdesc
+  Column  |  Type   
+----------+---------
+ ?column? | integer
+(1 row)
+
+SELECT span_type, span_operation, parameters, lvl FROM peek_ordered_spans;
+ span_type |                                                        span_operation                                                        |             parameters              | lvl 
+-----------+------------------------------------------------------------------------------------------------------------------------------+-------------------------------------+-----
+ Parse     | Parse                                                                                                                        |                                     |   1
+ Select    | SELECT name AS "Column", pg_catalog.format_type(tp, tpm) AS "Type"FROM (VALUES ($1, $2::pg_catalog.oid,$3)) s(name, tp, tpm) | $1 = '?column?', $2 = '23', $3 = -1 |   1
+ Planner   | Planner                                                                                                                      |                                     |   2
+ Executor  | ExecutorRun                                                                                                                  |                                     |   2
+ Result    | Result                                                                                                                       |                                     |   3
+(5 rows)
+
+CALL clean_spans();
diff --git a/contrib/pg_tracing/expected/insert.out b/contrib/pg_tracing/expected/insert.out
new file mode 100644
index 0000000000..ec62564ac0
--- /dev/null
+++ b/contrib/pg_tracing/expected/insert.out
@@ -0,0 +1,56 @@
+-- Only trace queries with sample flag
+SET pg_tracing.sample_rate = 0.0;
+SET pg_tracing.caller_sample_rate = 1.0;
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ CREATE TABLE IF NOT EXISTS pg_tracing_test_table_with_constraint (a int, b char(20), CONSTRAINT PK_tracing_test PRIMARY KEY (a));
+SELECT span_type, span_operation, lvl from peek_ordered_spans where trace_id=1;
+   span_type    |                                                          span_operation                                                           | lvl 
+----------------+-----------------------------------------------------------------------------------------------------------------------------------+-----
+ Parse          | Parse                                                                                                                             |   1
+ Utility        | CREATE TABLE IF NOT EXISTS pg_tracing_test_table_with_constraint (a int, b char(20), CONSTRAINT PK_tracing_test PRIMARY KEY (a)); |   1
+ ProcessUtility | ProcessUtility                                                                                                                    |   2
+ Utility        | CREATE TABLE IF NOT EXISTS pg_tracing_test_table_with_constraint (a int, b char(20), CONSTRAINT PK_tracing_test PRIMARY KEY (a)); |   3
+ ProcessUtility | ProcessUtility                                                                                                                    |   4
+ Utility        | CREATE TABLE IF NOT EXISTS pg_tracing_test_table_with_constraint (a int, b char(20), CONSTRAINT PK_tracing_test PRIMARY KEY (a)); |   3
+ ProcessUtility | ProcessUtility                                                                                                                    |   4
+(7 rows)
+
+-- Simple insertion
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000002-0000000000000002-01'*/ INSERT INTO pg_tracing_test_table_with_constraint VALUES(1, 'aaa');
+SELECT span_type, span_operation from peek_ordered_spans where trace_id=2;
+ span_type |                          span_operation                           
+-----------+-------------------------------------------------------------------
+ Parse     | Parse
+ Insert    | INSERT INTO pg_tracing_test_table_with_constraint VALUES($1, $2);
+ Planner   | Planner
+ Executor  | ExecutorRun
+ Insert    | Insert on pg_tracing_test_table_with_constraint
+ Result    | Result
+(6 rows)
+
+-- Trigger constraint violation
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000003-0000000000000003-01'*/ INSERT INTO pg_tracing_test_table_with_constraint VALUES(1, 'aaa');
+ERROR:  duplicate key value violates unique constraint "pk_tracing_test"
+DETAIL:  Key (a)=(1) already exists.
+SELECT span_type, span_operation, sql_error_code, lvl from peek_ordered_spans where trace_id=3;
+ span_type |                          span_operation                           | sql_error_code | lvl 
+-----------+-------------------------------------------------------------------+----------------+-----
+ Parse     | Parse                                                             | 00000          |   1
+ Insert    | INSERT INTO pg_tracing_test_table_with_constraint VALUES($1, $2); | 23505          |   1
+ Planner   | Planner                                                           | 00000          |   2
+ Executor  | ExecutorRun                                                       | 23505          |   2
+ Insert    | Insert on pg_tracing_test_table_with_constraint                   | 23505          |   3
+ Result    | Result                                                            | 23505          |   4
+(6 rows)
+
+-- Trigger an error while calling pg_tracing_peek_spans which resets tracing, nothing should be generated
+CALL clean_spans();
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000004-0000000000000004-01'*/ INSERT INTO pg_tracing_test_table_with_constraint VALUES(length((select sql_error_code from public.pg_tracing_peek_spans)), 'aaa');
+ERROR:  null value in column "a" of relation "pg_tracing_test_table_with_constraint" violates not-null constraint
+DETAIL:  Failing row contains (null, aaa                 ).
+SELECT span_type, span_operation, sql_error_code from peek_ordered_spans where trace_id=4;
+ span_type | span_operation | sql_error_code 
+-----------+----------------+----------------
+(0 rows)
+
+-- Cleanup
+CALL clean_spans();
diff --git a/contrib/pg_tracing/expected/nested.out b/contrib/pg_tracing/expected/nested.out
new file mode 100644
index 0000000000..8444f42669
--- /dev/null
+++ b/contrib/pg_tracing/expected/nested.out
@@ -0,0 +1,297 @@
+-- Create test function to sample
+CREATE OR REPLACE FUNCTION test_function_project_set(a int) RETURNS SETOF oid AS
+$BODY$
+BEGIN
+	RETURN QUERY SELECT oid from pg_class where oid = a;
+END;
+$BODY$
+LANGUAGE plpgsql;
+CREATE OR REPLACE FUNCTION test_function_result(a int, b text) RETURNS void AS
+$BODY$
+BEGIN
+    INSERT INTO pg_tracing_test(a, b) VALUES (a, b);
+END;
+$BODY$
+LANGUAGE plpgsql;
+-- Trace a statement with a function call
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000051-0000000000000051-01'*/ select test_function_project_set(1);
+ test_function_project_set 
+---------------------------
+(0 rows)
+
+-- The test function call will generate the following spans (non exhaustive list):
+-- +---------------------------------------------------------------------------------------------------+
+-- | A: Select test_function_project_set(1);                                                                       |
+-- +-+--------++----------++----------------++--------------------------------------------------------++
+--   |B: Parse||C: Planner||D: ExecutorStart||E: ExecutorRun                                          |
+--   +--------++----------++----------------+++-----------------------------------------------------+-+
+--                                            |F: ProjectSet                                        |
+--                                            ++---------+---------+------------------------------+-+
+--                                             |G: Result|H: Parse | I: Select a from b where...  |
+--                                             +---------+---------+----+--------------+----------+
+--                                                                      |J: ExecutorRun|
+--                                                                      +--------------+
+-- Gather span_id, span start and span end of function call statement
+SELECT span_id AS span_a_id,
+        get_span_start(span_start) as span_a_start,
+        get_span_end(span_start) as span_a_end
+		from pg_tracing_peek_spans where parent_id=81 and span_type!='Parse' \gset
+SELECT span_id AS span_e_id,
+        get_span_start(span_start) as span_e_start,
+        get_span_end(span_start) as span_e_end
+		from pg_tracing_peek_spans where parent_id=:span_a_id and span_type='Executor' and span_operation='ExecutorRun' \gset
+SELECT span_id AS span_f_id,
+        get_span_start(span_start) as span_f_start,
+        get_span_end(span_start) as span_f_end
+		from pg_tracing_peek_spans where parent_id=:span_e_id and span_type='ProjectSet' \gset
+SELECT span_id AS span_g_id,
+        get_span_start(span_start) as span_g_start,
+        get_span_end(span_start) as span_g_end
+		from pg_tracing_peek_spans where parent_id=:span_f_id and span_type='Result' \gset
+SELECT span_id AS span_h_id,
+        get_span_start(span_start) as span_h_start,
+        get_span_end(span_start) as span_h_end
+		from pg_tracing_peek_spans where parent_id=:span_f_id and span_type='Parse' \gset
+SELECT span_id AS span_i_id,
+        get_span_start(span_start) as span_i_start,
+        get_span_end(span_start) as span_i_end
+		from pg_tracing_peek_spans where parent_id=:span_f_id and span_type='Select' \gset
+SELECT span_id AS span_j_id,
+        get_span_start(span_start) as span_j_start,
+        get_span_end(span_start) as span_j_end
+		from pg_tracing_peek_spans where parent_id=:span_i_id and span_operation='ExecutorRun' \gset
+-- Check that spans' start and end are within expection
+SELECT :span_a_start <= :span_e_start AS top_query_before_run,
+		:span_a_end >= :span_e_end AS top_ends_after_run_end,
+		:span_e_start <= :span_f_start AS top_run_starts_before_project,
+		:span_e_end >= :span_f_end AS top_run_ends_after_project_end,
+		:span_e_end >= :span_h_end AS top_run_ends_before_select_end,
+		:span_e_end >= :span_i_end AS top_run_ends_after_nested_run_end;
+ top_query_before_run | top_ends_after_run_end | top_run_starts_before_project | top_run_ends_after_project_end | top_run_ends_before_select_end | top_run_ends_after_nested_run_end 
+----------------------+------------------------+-------------------------------+--------------------------------+--------------------------------+-----------------------------------
+ t                    | t                      | t                             | t                              | t                              | t
+(1 row)
+
+SELECT
+		:span_g_end >= :span_h_start AS nested_result_ends_before_parse,
+		:span_h_end <= :span_i_start AS nested_parse_ends_before_select,
+		:span_j_start >= :span_i_start AS run_starts_after_parent_select,
+		:span_j_end <= :span_i_end AS run_ends_after_select_end;
+ nested_result_ends_before_parse | nested_parse_ends_before_select | run_starts_after_parent_select | run_ends_after_select_end 
+---------------------------------+---------------------------------+--------------------------------+---------------------------
+ t                               | t                               | t                              | t
+(1 row)
+
+-- Check that the root span is the longest one
+WITH max_end AS (select max(span_end) from pg_tracing_peek_spans)
+SELECT span_end = max_end.max from pg_tracing_peek_spans, max_end
+    where span_id = :span_a_id;
+ ?column? 
+----------
+ t
+(1 row)
+
+-- Check that ExecutorRun is attached to the nested top span
+SELECT span_operation, deparse_info from pg_tracing_peek_spans where parent_id=:span_j_id order by span_operation;
+                   span_operation                   |         deparse_info         
+----------------------------------------------------+------------------------------
+ IndexOnlyScan using pg_class_oid_index on pg_class | Index Cond: (oid = '1'::oid)
+(1 row)
+
+-- Check tracking with top tracking
+SET pg_tracing.track = 'top';
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000052-0000000000000052-01'*/ select test_function_project_set(1);
+ test_function_project_set 
+---------------------------
+(0 rows)
+
+SELECT count(*) from pg_tracing_consume_spans where trace_id=82;
+ count 
+-------
+     6
+(1 row)
+
+-- Check tracking with no tracking
+SET pg_tracing.track = 'none';
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000053-0000000000000053-01'*/ select test_function_project_set(1);
+ test_function_project_set 
+---------------------------
+(0 rows)
+
+SELECT count(*) from pg_tracing_consume_spans where trace_id=83;
+ count 
+-------
+     0
+(1 row)
+
+-- Reset tracking setting
+SET pg_tracing.track TO DEFAULT;
+-- Create test procedure
+CREATE OR REPLACE PROCEDURE sum_one(i int) AS $$
+DECLARE
+  r int;
+BEGIN
+  SELECT (i + i)::int INTO r;
+END; $$ LANGUAGE plpgsql;
+-- Test tracking of procedure with utility tracking enabled
+SET pg_tracing.track_utility=on;
+/*traceparent='00-00000000000000000000000000000054-0000000000000054-01'*/ CALL sum_one(3);
+select span_operation, lvl FROM peek_ordered_spans where trace_id=84;
+   span_operation    | lvl 
+---------------------+-----
+ Parse               |   1
+ CALL sum_one($1);   |   1
+ ProcessUtility      |   2
+ Parse               |   3
+ SELECT (i + i)::int |   3
+ Planner             |   4
+ Planner             |   4
+ ExecutorRun         |   4
+ Result              |   5
+(9 rows)
+
+-- Test again with utility tracking disabled
+SET pg_tracing.track_utility=off;
+/*traceparent='00-00000000000000000000000000000055-0000000000000055-01'*/ CALL sum_one(10);
+select span_operation, lvl FROM peek_ordered_spans where trace_id=85;
+ span_operation | lvl 
+----------------+-----
+(0 rows)
+
+-- Create immutable function
+CREATE OR REPLACE FUNCTION test_immutable_function(a int) RETURNS oid
+AS 'SELECT oid from pg_class where oid = a;'
+LANGUAGE sql IMMUTABLE;
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000056-0000000000000056-01'*/ select test_immutable_function(1);
+ test_immutable_function 
+-------------------------
+                        
+(1 row)
+
+select span_operation, lvl FROM peek_ordered_spans where trace_id=86;
+           span_operation            | lvl 
+-------------------------------------+-----
+ Parse                               |   1
+ select test_immutable_function($1); |   1
+ Planner                             |   2
+ Planner                             |   2
+ ExecutorRun                         |   2
+ Result                              |   3
+(6 rows)
+
+-- Create function with generate series
+CREATE OR REPLACE FUNCTION test_generate_series(IN anyarray, OUT x anyelement)
+    RETURNS SETOF anyelement
+    LANGUAGE sql
+    AS 'select * from pg_catalog.generate_series(array_lower($1, 1), array_upper($1, 1), 1)';
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000057-0000000000000057-01'*/ select test_generate_series('{1,2,3,4}'::int[]) FROM (VALUES (1,2));
+ test_generate_series 
+----------------------
+                    1
+                    2
+                    3
+                    4
+(4 rows)
+
+SELECT span_id AS span_project_set_id,
+        get_span_start(span_start) as span_project_set_start,
+        get_span_end(span_start) as span_project_set_end
+		from pg_tracing_peek_spans where span_type='ProjectSet' \gset
+SELECT span_id AS span_result_id,
+        get_span_start(span_start) as span_result_start,
+        get_span_end(span_start) as span_result_end
+		from pg_tracing_peek_spans where parent_id=:span_project_set_id and span_type='Result' \gset
+SELECT span_id AS span_parse,
+        get_span_start(span_start) as span_parse_start,
+        get_span_end(span_start) as span_parse_end
+		from pg_tracing_peek_spans where parent_id=:span_project_set_id and span_type='Parse' \gset
+-- Check that spans' start and end are within expection
+SELECT :span_project_set_start <= :span_parse_start AS project_set_starts_before_parse,
+        :span_result_start <= :span_parse_start AS result_starts_before_parse,
+        :span_result_end <= :span_parse_start AS result_ends_before_parse,
+        :span_project_set_end >= :span_parse_end AS project_set_ends_after_parse;
+ project_set_starts_before_parse | result_starts_before_parse | result_ends_before_parse | project_set_ends_after_parse 
+---------------------------------+----------------------------+--------------------------+------------------------------
+ t                               | t                          | t                        | t
+(1 row)
+
+select span_operation, lvl FROM peek_ordered_spans where trace_id=87;
+                                     span_operation                                     | lvl 
+----------------------------------------------------------------------------------------+-----
+ Parse                                                                                  |   1
+ select test_generate_series($1::int[]) FROM (VALUES ($2,$3));                          |   1
+ Planner                                                                                |   2
+ ExecutorRun                                                                            |   2
+ ProjectSet                                                                             |   3
+ Result                                                                                 |   4
+ Parse                                                                                  |   4
+ select * from pg_catalog.generate_series(array_lower($1, $2), array_upper($1, $3), $4) |   4
+ Planner                                                                                |   5
+(9 rows)
+
+-- +---------------------------------------------------------------------------------------------------+
+-- | A: Select test_function(1);                                                                       |
+-- +-+--------++----------++----------------++--------------------------------------------------------++
+--   |B: Parse||C: Planner||D: ExecutorStart||E: ExecutorRun                                          |
+--   +--------++----------++----------------+++-----------------------------------------------------+-+
+--                                            |F: Result                                            |
+--                                            ++---------------+----------------------------------+-+
+--                                             |G: Parse       |     H: Insert INTO...            |
+--                                             +---------------+--------+--------------+----------+
+--                                                                      |I: ExecutorRun|
+--                                                                      +--------------+
+-- Check function with result node
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000058-0000000000000058-01'*/ select test_function_result(1, 'test');
+ test_function_result 
+----------------------
+ 
+(1 row)
+
+-- Gather span_id, span start and span end of function call statement
+SELECT span_id AS span_a_id,
+        get_span_start(span_start) as span_a_start,
+        get_span_end(span_start) as span_a_end
+		from pg_tracing_peek_spans where parent_id=88 and span_type!='Parse' \gset
+SELECT span_id AS span_e_id,
+        get_span_start(span_start) as span_e_start,
+        get_span_end(span_start) as span_e_end
+		from pg_tracing_peek_spans where parent_id=:span_a_id and span_type='Executor' and span_operation='ExecutorRun' \gset
+SELECT span_id AS span_f_id,
+        get_span_start(span_start) as span_f_start,
+        get_span_end(span_start) as span_f_end
+		from pg_tracing_peek_spans where parent_id=:span_e_id and span_type='Result' \gset
+SELECT span_id AS span_g_id,
+        get_span_start(span_start) as span_g_start,
+        get_span_end(span_start) as span_g_end
+		from pg_tracing_peek_spans where parent_id=:span_f_id and span_type='Parse' \gset
+SELECT span_id AS span_h_id,
+        get_span_start(span_start) as span_h_start,
+        get_span_end(span_start) as span_h_end
+		from pg_tracing_peek_spans where parent_id=:span_f_id and span_type='Insert' \gset
+-- Check that parse span is correctly positioned
+SELECT :span_g_start >= :span_f_start AS parse_start_after_result,
+		:span_g_end <= :span_f_end AS parse_ends_before_result,
+		:span_g_end <= :span_h_start AS parse_ends_before_insert_node;
+ parse_start_after_result | parse_ends_before_result | parse_ends_before_insert_node 
+--------------------------+--------------------------+-------------------------------
+ t                        | t                        | t
+(1 row)
+
+select span_operation, lvl FROM peek_ordered_spans where trace_id=88;
+                 span_operation                  | lvl 
+-------------------------------------------------+-----
+ Parse                                           |   1
+ select test_function_result($1, $2);            |   1
+ Planner                                         |   2
+ ExecutorRun                                     |   2
+ Result                                          |   3
+ Parse                                           |   4
+ INSERT INTO pg_tracing_test(a, b) VALUES (a, b) |   4
+ Planner                                         |   5
+ ExecutorRun                                     |   5
+ Insert on pg_tracing_test                       |   6
+ Result                                          |   7
+(11 rows)
+
+-- Cleanup
+CALL clean_spans();
diff --git a/contrib/pg_tracing/expected/parallel.out b/contrib/pg_tracing/expected/parallel.out
new file mode 100644
index 0000000000..66bc24a409
--- /dev/null
+++ b/contrib/pg_tracing/expected/parallel.out
@@ -0,0 +1,48 @@
+begin;
+-- encourage use of parallel plans
+set local parallel_setup_cost=0;
+set local parallel_tuple_cost=0;
+set local min_parallel_table_scan_size=0;
+set local max_parallel_workers_per_gather=2;
+-- Trace parallel queries
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ select 1 from pg_class limit 1;
+ ?column? 
+----------
+        1
+(1 row)
+
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000002-0000000000000002-01'*/ select 2 from pg_class limit 2;
+ ?column? 
+----------
+        2
+        2
+(2 rows)
+
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000003-0000000000000003-00'*/ select 3 from pg_class limit 3;
+ ?column? 
+----------
+        3
+        3
+        3
+(3 rows)
+
+commit;
+-- Get root top span id
+SELECT span_id as root_span_id from pg_tracing_peek_spans where span_type='Select' and trace_id=1 and parent_id=1 \gset
+-- Get executor top span id
+SELECT span_id as executor_span_id from pg_tracing_peek_spans where span_operation='ExecutorRun' and trace_id=1 and parent_id=:root_span_id \gset
+-- Check the select spans that are attached to the root top span
+SELECT trace_id, span_type, span_operation from pg_tracing_peek_spans where span_type='Select' and parent_id=:executor_span_id order by span_operation;
+ trace_id | span_type | span_operation 
+----------+-----------+----------------
+        1 | Select    | Worker 0
+        1 | Select    | Worker 1
+(2 rows)
+
+-- Check number of executor spans
+SELECT count(*) from pg_tracing_consume_spans where span_type='Executor';
+ count 
+-------
+     6
+(1 row)
+
diff --git a/contrib/pg_tracing/expected/reset.out b/contrib/pg_tracing/expected/reset.out
new file mode 100644
index 0000000000..2e0c903121
--- /dev/null
+++ b/contrib/pg_tracing/expected/reset.out
@@ -0,0 +1,13 @@
+-- Check reset is working
+SELECT pg_tracing_reset();
+ pg_tracing_reset 
+------------------
+ 
+(1 row)
+
+SELECT traces from pg_tracing_info;
+ traces 
+--------
+      0
+(1 row)
+
diff --git a/contrib/pg_tracing/expected/sample.out b/contrib/pg_tracing/expected/sample.out
new file mode 100644
index 0000000000..835a6f4c01
--- /dev/null
+++ b/contrib/pg_tracing/expected/sample.out
@@ -0,0 +1,149 @@
+-- Trace nothing
+SET pg_tracing.sample_rate = 0.0;
+SET pg_tracing.caller_sample_rate = 0.0;
+-- Query with sampling flag
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ SELECT 1;
+ ?column? 
+----------
+        1
+(1 row)
+
+select count(distinct(trace_id))=0 from pg_tracing_consume_spans;
+ ?column? 
+----------
+ t
+(1 row)
+
+-- Query without trace context
+SELECT 1;
+ ?column? 
+----------
+        1
+(1 row)
+
+select count(distinct(trace_id))=0 from pg_tracing_consume_spans;
+ ?column? 
+----------
+ t
+(1 row)
+
+-- Enable full sampling
+SET pg_tracing.sample_rate = 1.0;
+-- Generate queries with sampling flag on, off and no trace context
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000002-0000000000000002-01'*/ SELECT 1;
+ ?column? 
+----------
+        1
+(1 row)
+
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000003-0000000000000003-00'*/ SELECT 2;
+ ?column? 
+----------
+        2
+(1 row)
+
+SELECT 3;
+ ?column? 
+----------
+        3
+(1 row)
+
+SELECT 4;
+ ?column? 
+----------
+        4
+(1 row)
+
+-- Check number of generated spans
+select count(distinct(trace_id)) from pg_tracing_peek_spans;
+ count 
+-------
+     4
+(1 row)
+
+-- Check span order
+select span_operation, parameters, lvl from peek_ordered_spans;
+ span_operation | parameters | lvl 
+----------------+------------+-----
+ Parse          |            |   1
+ SELECT $1;     | $1 = 1     |   1
+ Planner        |            |   2
+ ExecutorRun    |            |   2
+ Result         |            |   3
+ Parse          |            |   1
+ SELECT $1;     | $1 = 2     |   1
+ Planner        |            |   2
+ ExecutorRun    |            |   2
+ Result         |            |   3
+ Parse          |            |   1
+ SELECT $1;     | $1 = 3     |   1
+ Planner        |            |   2
+ ExecutorRun    |            |   2
+ Result         |            |   3
+ Parse          |            |   1
+ SELECT $1;     | $1 = 4     |   1
+ Planner        |            |   2
+ ExecutorRun    |            |   2
+ Result         |            |   3
+(20 rows)
+
+-- Top spans should reuse generated ids and have trace_id = parent_id
+select span_operation, parameters from peek_ordered_spans where trace_id = parent_id;
+ span_operation | parameters 
+----------------+------------
+ Parse          | 
+ SELECT $1;     | $1 = 1
+ Parse          | 
+ SELECT $1;     | $1 = 2
+ Parse          | 
+ SELECT $1;     | $1 = 3
+ Parse          | 
+ SELECT $1;     | $1 = 4
+(8 rows)
+
+CALL clean_spans();
+-- Only trace query with sampled flag
+SET pg_tracing.sample_rate = 0.0;
+SET pg_tracing.caller_sample_rate = 1.0;
+-- Generate queries with sampling flag on, off and no trace context
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000004-0000000000000004-01'*/ SELECT 1;
+ ?column? 
+----------
+        1
+(1 row)
+
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000005-0000000000000005-00'*/ SELECT 2;
+ ?column? 
+----------
+        2
+(1 row)
+
+SELECT 1;
+ ?column? 
+----------
+        1
+(1 row)
+
+-- Check number of generated spans
+select count(distinct(trace_id)) from pg_tracing_peek_spans;
+ count 
+-------
+     2
+(1 row)
+
+-- Check span ordering
+select span_operation, parameters, lvl from peek_ordered_spans;
+          span_operation           | parameters | lvl 
+-----------------------------------+------------+-----
+ Parse                             |            |   1
+ SET pg_tracing.sample_rate = 0.0; |            |   1
+ ProcessUtility                    |            |   2
+ Parse                             |            |   1
+ SELECT $1;                        | $1 = 1     |   1
+ Planner                           |            |   2
+ ExecutorRun                       |            |   2
+ Result                            |            |   3
+(8 rows)
+
+-- Cleaning
+CALL clean_spans();
diff --git a/contrib/pg_tracing/expected/select.out b/contrib/pg_tracing/expected/select.out
new file mode 100644
index 0000000000..a630eceea4
--- /dev/null
+++ b/contrib/pg_tracing/expected/select.out
@@ -0,0 +1,304 @@
+-- Only trace queries with sample flag
+SET pg_tracing.sample_rate = 0.0;
+SET pg_tracing.caller_sample_rate = 1.0;
+-- Run a simple query
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ SELECT 1;
+ ?column? 
+----------
+        1
+(1 row)
+
+-- Get top span id
+SELECT span_id AS top_span_id from pg_tracing_peek_spans where parent_id=1 and span_type!='Parse' \gset
+-- Check parameters
+SELECT parameters from pg_tracing_peek_spans where span_id=:top_span_id;
+ parameters 
+------------
+ $1 = 1
+(1 row)
+
+-- Check the number of children
+SELECT count(*) from pg_tracing_peek_spans where parent_id=:'top_span_id';
+ count 
+-------
+     2
+(1 row)
+
+-- Check span_operation
+SELECT span_type, span_operation from pg_tracing_peek_spans where trace_id=1 order by span_start, span_end desc;
+ span_type | span_operation 
+-----------+----------------
+ Parse     | Parse
+ Select    | SELECT $1;
+ Planner   | Planner
+ Executor  | ExecutorRun
+ Result    | Result
+(5 rows)
+
+-- Check count of query_id
+SELECT count(distinct query_id) from pg_tracing_consume_spans where trace_id=1;
+ count 
+-------
+     1
+(1 row)
+
+-- Check reported number of trace
+SELECT traces from pg_tracing_info;
+ traces 
+--------
+     26
+(1 row)
+
+-- Trace a statement with function call
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000003-0000000000000003-01'*/ SELECT count(*) from current_database();
+ count 
+-------
+     1
+(1 row)
+
+-- Check the generated span span_type, span_operation and order of function call
+SELECT span_type, span_operation, lvl FROM peek_ordered_spans where trace_id=3;
+  span_type   |              span_operation              | lvl 
+--------------+------------------------------------------+-----
+ Parse        | Parse                                    |   1
+ Select       | SELECT count(*) from current_database(); |   1
+ Planner      | Planner                                  |   2
+ Executor     | ExecutorRun                              |   2
+ Aggregate    | Aggregate                                |   3
+ FunctionScan | FunctionScan on current_database         |   4
+(6 rows)
+
+-- Trace a more complex query with multiple function calls
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000004-0000000000000004-01'*/ SELECT s.relation_size + s.index_size
+FROM (SELECT
+      pg_relation_size(C.oid) as relation_size,
+      pg_indexes_size(C.oid) as index_size
+    FROM pg_class C) as s limit 1;
+ ?column? 
+----------
+        0
+(1 row)
+
+-- Check the nested level of spans for a query with multiple function calls
+SELECT span_type, span_operation, lvl FROM peek_ordered_spans where trace_id=4;
+  span_type   |                                                                          span_operation                                                                          | lvl 
+--------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----
+ Parse        | Parse                                                                                                                                                            |   1
+ Select       | SELECT s.relation_size + s.index_sizeFROM (SELECT pg_relation_size(C.oid) as relation_size, pg_indexes_size(C.oid) as index_size FROM pg_class C) as s limit $1; |   1
+ Planner      | Planner                                                                                                                                                          |   2
+ Executor     | ExecutorRun                                                                                                                                                      |   2
+ Limit        | Limit                                                                                                                                                            |   3
+ SubqueryScan | SubqueryScan on s                                                                                                                                                |   4
+ SeqScan      | SeqScan on pg_class c                                                                                                                                            |   5
+(7 rows)
+
+-- Check that we're in a correct state after a timeout
+set statement_timeout=200;
+-- Trace query triggering a statement timeout
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000007-0000000000000007-01'*/ select * from pg_sleep(10);
+ERROR:  canceling statement due to statement timeout
+SELECT span_type, span_operation, sql_error_code, lvl FROM peek_ordered_spans where trace_id=7;
+  span_type   |       span_operation        | sql_error_code | lvl 
+--------------+-----------------------------+----------------+-----
+ Parse        | Parse                       | 00000          |   1
+ Select       | select * from pg_sleep($1); | 57014          |   1
+ Planner      | Planner                     | 00000          |   2
+ Executor     | ExecutorRun                 | 57014          |   2
+ FunctionScan | FunctionScan on pg_sleep    | 57014          |   3
+(5 rows)
+
+-- Cleanup statement setting
+set statement_timeout=0;
+-- Trace a working query after the timeout to check we're in a consistent state
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000008-0000000000000008-01'*/ select 1;
+ ?column? 
+----------
+        1
+(1 row)
+
+-- Check the spans order and error code
+SELECT span_type, span_operation, sql_error_code, lvl FROM peek_ordered_spans where trace_id=8;
+ span_type | span_operation | sql_error_code | lvl 
+-----------+----------------+----------------+-----
+ Parse     | Parse          | 00000          |   1
+ Select    | select $1;     | 00000          |   1
+ Planner   | Planner        | 00000          |   2
+ Executor  | ExecutorRun    | 00000          |   2
+ Result    | Result         | 00000          |   3
+(5 rows)
+
+-- Create a prepare statement with trace context passed as the first parameter
+PREPARE test_prepared (text, integer) AS /*$1*/ SELECT $2;
+EXECUTE test_prepared('dddbs=''postgres.db'',traceparent=''00-00000000000000000000000000000009-0000000000000009-01''', 1);
+ ?column? 
+----------
+        1
+(1 row)
+
+SELECT trace_id, span_type, span_operation, parameters, lvl FROM peek_ordered_spans where trace_id=9;
+ trace_id | span_type |                   span_operation                    |                                                   parameters                                                   | lvl 
+----------+-----------+-----------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----
+        9 | Select    | PREPARE test_prepared (text, integer) AS SELECT $2; | $1 = 'dddbs=''postgres.db'',traceparent=''00-00000000000000000000000000000009-0000000000000009-01''', $2 = '1' |   1
+        9 | Planner   | Planner                                             |                                                                                                                |   2
+        9 | Executor  | ExecutorRun                                         |                                                                                                                |   2
+        9 | Result    | Result                                              |                                                                                                                |   3
+(4 rows)
+
+-- Call the prepared statement with generic plan
+SET plan_cache_mode='force_generic_plan';
+EXECUTE test_prepared('dddbs=''postgres.db'',traceparent=''00-0000000000000000000000000000000a-000000000000000a-01''', 2);
+ ?column? 
+----------
+        2
+(1 row)
+
+SELECT trace_id, span_type, span_operation, parameters, lvl FROM peek_ordered_spans where trace_id=10;
+ trace_id | span_type |                   span_operation                    | parameters | lvl 
+----------+-----------+-----------------------------------------------------+------------+-----
+       10 | Select    | PREPARE test_prepared (text, integer) AS SELECT $2; |            |   1
+       10 | Executor  | ExecutorRun                                         |            |   2
+       10 | Result    | Result                                              |            |   3
+(3 rows)
+
+-- Cleanup
+SET plan_cache_mode='auto';
+DEALLOCATE test_prepared;
+-- Run a statement with node not executed
+/*dddbs='postgres.db',traceparent='00-0000000000000000000000000000000b-000000000000000b-01'*/ select 1 limit 0;
+ ?column? 
+----------
+(0 rows)
+
+SELECT span_operation, parameters, lvl from peek_ordered_spans where trace_id=11;
+   span_operation    |   parameters   | lvl 
+---------------------+----------------+-----
+ Parse               |                |   1
+ select $1 limit $2; | $1 = 1, $2 = 0 |   1
+ Planner             |                |   2
+ ExecutorRun         |                |   2
+ Limit               |                |   3
+(5 rows)
+
+-- Test multiple statements in a single query
+/*dddbs='postgres.db',traceparent='00-0000000000000000000000000000000c-000000000000000c-01'*/ select 1; select 2;
+ ?column? 
+----------
+        1
+(1 row)
+
+ ?column? 
+----------
+        2
+(1 row)
+
+SELECT span_operation, parameters, lvl from peek_ordered_spans where trace_id=12;
+ span_operation | parameters | lvl 
+----------------+------------+-----
+ Parse          |            |   1
+ select $1;     | $1 = 1     |   1
+ Planner        |            |   2
+ ExecutorRun    |            |   2
+ Result         |            |   3
+(5 rows)
+
+-- Check that parameters are not exported when disabled
+SET pg_tracing.export_parameters=false;
+/*dddbs='postgres.db',traceparent='00-0000000000000000000000000000000d-000000000000000d-01'*/ select 1, 2, 3;
+ ?column? | ?column? | ?column? 
+----------+----------+----------
+        1 |        2 |        3
+(1 row)
+
+SELECT span_operation, parameters, lvl from peek_ordered_spans where trace_id=13;
+   span_operation   | parameters | lvl 
+--------------------+------------+-----
+ Parse              |            |   1
+ select $1, $2, $3; |            |   1
+ Planner            |            |   2
+ ExecutorRun        |            |   2
+ Result             |            |   3
+(5 rows)
+
+SET pg_tracing.export_parameters=true;
+-- Check generated spans when deparse is disabled
+SET pg_tracing.deparse_plan=false;
+/*dddbs='postgres.db',traceparent='00-0000000000000000000000000000000e-000000000000000e-01'*/ SELECT * from pg_tracing_test where a=1;
+ a | b 
+---+---
+(0 rows)
+
+SELECT span_operation, deparse_info, parameters, lvl from peek_ordered_spans where trace_id=14;
+              span_operation               | deparse_info | parameters | lvl 
+-------------------------------------------+--------------+------------+-----
+ Parse                                     |              |            |   1
+ SELECT * from pg_tracing_test where a=$1; |              | $1 = 1     |   1
+ Planner                                   |              |            |   2
+ ExecutorRun                               |              |            |   2
+ BitmapHeapScan on pg_tracing_test         |              |            |   3
+ BitmapIndexScan on pg_tracing_index       |              |            |   4
+(6 rows)
+
+-- Check generated spans when deparse is enabled
+SET pg_tracing.deparse_plan=true;
+/*dddbs='postgres.db',traceparent='00-0000000000000000000000000000000f-000000000000000f-01'*/ SELECT * from pg_tracing_test where a=1;
+ a | b 
+---+---
+(0 rows)
+
+SELECT trace_id, span_operation, deparse_info, parameters, lvl from peek_ordered_spans where trace_id=15;
+ trace_id |              span_operation               |     deparse_info      | parameters | lvl 
+----------+-------------------------------------------+-----------------------+------------+-----
+       15 | Parse                                     |                       |            |   1
+       15 | SELECT * from pg_tracing_test where a=$1; |                       | $1 = 1     |   1
+       15 | Planner                                   |                       |            |   2
+       15 | ExecutorRun                               |                       |            |   2
+       15 | BitmapHeapScan on pg_tracing_test         | Recheck Cond: (a = 1) |            |   3
+       15 | BitmapIndexScan on pg_tracing_index       | Index Cond: (a = 1)   |            |   4
+(6 rows)
+
+-- Check multi statement query
+CALL clean_spans();
+SET pg_tracing.sample_rate = 1.0;
+-- Force a multi-query statement with \;
+SELECT 1\; SELECT 1, 2;
+ ?column? 
+----------
+        1
+(1 row)
+
+ ?column? | ?column? 
+----------+----------
+        1 |        2
+(1 row)
+
+SELECT span_type, span_operation, parameters, lvl from peek_ordered_spans;
+ span_type | span_operation | parameters | lvl 
+-----------+----------------+------------+-----
+ Parse     | Parse          |            |   1
+ Select    | SELECT $1;     | $1 = 1     |   1
+ Planner   | Planner        |            |   2
+ Executor  | ExecutorRun    |            |   2
+ Result    | Result         |            |   3
+(5 rows)
+
+CALL clean_spans();
+-- Check standalone trace
+SELECT 1;
+ ?column? 
+----------
+        1
+(1 row)
+
+-- Make sure we have unique span ids
+select count(span_id) from pg_tracing_consume_spans group by span_id;
+ count 
+-------
+     1
+     1
+     1
+     1
+     1
+(5 rows)
+
+-- Cleanup
+SET pg_tracing.sample_rate = 0.0;
diff --git a/contrib/pg_tracing/expected/subxact.out b/contrib/pg_tracing/expected/subxact.out
new file mode 100644
index 0000000000..c0114977d3
--- /dev/null
+++ b/contrib/pg_tracing/expected/subxact.out
@@ -0,0 +1,58 @@
+-- Enable full sampling
+SET pg_tracing.sample_rate = 1.0;
+-- Start a transaction with subxaction
+BEGIN;
+SAVEPOINT s1;
+INSERT INTO pg_tracing_test VALUES(generate_series(1, 2), 'aaa');
+SAVEPOINT s2;
+INSERT INTO pg_tracing_test VALUES(generate_series(1, 2), 'aaa');
+SAVEPOINT s3;
+SELECT 1;
+ ?column? 
+----------
+        1
+(1 row)
+
+COMMIT;
+-- Check that subxact_count is correctly reported
+select span_operation, parameters, subxact_count, lvl FROM peek_ordered_spans;
+                          span_operation                          |         parameters         | subxact_count | lvl 
+------------------------------------------------------------------+----------------------------+---------------+-----
+ Parse                                                            |                            |             0 |   1
+ BEGIN;                                                           |                            |             0 |   1
+ ProcessUtility                                                   |                            |             0 |   2
+ Parse                                                            |                            |             0 |   1
+ SAVEPOINT $1;                                                    | $1 = s1                    |             0 |   1
+ ProcessUtility                                                   |                            |             0 |   2
+ Parse                                                            |                            |             0 |   1
+ INSERT INTO pg_tracing_test VALUES(generate_series($1, $2), $3); | $1 = 1, $2 = 2, $3 = 'aaa' |             0 |   1
+ Planner                                                          |                            |             0 |   2
+ ExecutorRun                                                      |                            |             0 |   2
+ Insert on pg_tracing_test                                        |                            |             1 |   3
+ ProjectSet                                                       |                            |             1 |   4
+ Result                                                           |                            |             1 |   5
+ Parse                                                            |                            |             1 |   1
+ SAVEPOINT $1;                                                    | $1 = s2                    |             1 |   1
+ ProcessUtility                                                   |                            |             1 |   2
+ Parse                                                            |                            |             1 |   1
+ INSERT INTO pg_tracing_test VALUES(generate_series($1, $2), $3); | $1 = 1, $2 = 2, $3 = 'aaa' |             1 |   1
+ Planner                                                          |                            |             1 |   2
+ ExecutorRun                                                      |                            |             1 |   2
+ Insert on pg_tracing_test                                        |                            |             2 |   3
+ ProjectSet                                                       |                            |             2 |   4
+ Result                                                           |                            |             2 |   5
+ Parse                                                            |                            |             2 |   1
+ SAVEPOINT $1;                                                    | $1 = s3                    |             2 |   1
+ ProcessUtility                                                   |                            |             2 |   2
+ Parse                                                            |                            |             2 |   1
+ SELECT $1;                                                       | $1 = 1                     |             2 |   1
+ Planner                                                          |                            |             2 |   2
+ ExecutorRun                                                      |                            |             2 |   2
+ Result                                                           |                            |             2 |   3
+ Parse                                                            |                            |             2 |   1
+ COMMIT;                                                          |                            |             2 |   1
+ ProcessUtility                                                   |                            |             2 |   2
+(34 rows)
+
+-- Cleaning
+CALL clean_spans();
diff --git a/contrib/pg_tracing/expected/trigger.out b/contrib/pg_tracing/expected/trigger.out
new file mode 100644
index 0000000000..a7bbbf9094
--- /dev/null
+++ b/contrib/pg_tracing/expected/trigger.out
@@ -0,0 +1,264 @@
+-- Only trace queries with sample flag
+SET pg_tracing.sample_rate = 0.0;
+SET pg_tracing.caller_sample_rate = 1.0;
+-- Create test tables
+CREATE TABLE Employee (
+    EmployeeId INT NOT NULL,
+    LastName VARCHAR(20) NOT NULL,
+    CONSTRAINT PK_Employee PRIMARY KEY (EmployeeId));
+CREATE TABLE Employee_Audit (
+    EmployeeId INT NOT NULL,
+    LastName VARCHAR(20) NOT NULL,
+    EmpAdditionTime VARCHAR(20) NOT NULL);
+-- Create test trigger
+CREATE OR REPLACE FUNCTION employee_insert_trigger_fnc()
+  RETURNS trigger AS
+$$
+BEGIN
+    INSERT INTO Employee_Audit (EmployeeId, LastName, EmpAdditionTime)
+         VALUES(NEW.EmployeeId,NEW.LastName,current_date);
+RETURN NEW;
+END;
+$$
+LANGUAGE plpgsql;
+-- Hook the trigger twice
+CREATE TRIGGER employee_insert_trigger
+  AFTER INSERT
+  ON Employee
+  FOR EACH ROW
+  EXECUTE PROCEDURE employee_insert_trigger_fnc();
+CREATE TRIGGER employee_insert_trigger_2
+  AFTER INSERT
+  ON Employee
+  FOR EACH ROW
+  EXECUTE PROCEDURE employee_insert_trigger_fnc();
+-- Call update
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ INSERT INTO Employee VALUES(10,'Adams');
+--
+-- +--------+---------------------------------------------------------------------------------------------------------------------------------------+
+-- |A: Parse| B: INSERT INTO Employee                                                                                                               |
+-- +--------++----------+-+-------------------------+---------------------------------------------------------------------------------------------+-+
+--           |C: Planner| |D: ExecutorRun           | G: ExecutorFinish                                                                           |
+--           +----------+ ++-----------------------++--+--------+-------------------------------------------+-+---------------------------------+-+
+--                         |E: Insert into employee|   |H: Parse|  I: INSERT INTO Employee_Audit...         | |N: INSERT INTO Employee_Audit...|
+--                         ++---------+------------+   +--------+-+----------++----------------------------++ +--------------------------------+
+--                          |F: Result|                           |J: Planner||K: ExecutorRun              |  |O: ExecutorRun |
+--                          +---------+                           +----------+++---------------------------+  ++--------------+
+--                                                                             |L: Insert on employee audit|   | ...          |
+--                                                                             +-+---------+---------------+   +--------------+
+--                                                                               |M: Result|
+--                                                                               +---------+
+-- Gather span_id, span start and span end of call with triggers
+SELECT span_id AS span_a_id,
+        get_span_start(span_start) as span_a_start,
+        get_span_end(span_start) as span_a_end
+		from pg_tracing_peek_spans where parent_id=1 and span_type='Parse' \gset
+SELECT span_id AS span_b_id,
+        get_span_start(span_start) as span_b_start,
+        get_span_end(span_start) as span_b_end
+		from pg_tracing_peek_spans where parent_id=1 and span_type!='Parse' \gset
+SELECT span_id AS span_c_id,
+        get_span_start(span_start) as span_c_start,
+        get_span_end(span_start) as span_c_end
+		from pg_tracing_peek_spans where parent_id=:span_b_id and span_type='Planner' \gset
+SELECT span_id AS span_d_id,
+        get_span_start(span_start) as span_d_start,
+        get_span_end(span_start) as span_d_end
+		from pg_tracing_peek_spans where parent_id=:span_b_id and span_type='Executor' and span_operation='ExecutorRun' \gset
+SELECT span_id AS span_e_id,
+        get_span_start(span_start) as span_e_start,
+        get_span_end(span_start) as span_e_end
+		from pg_tracing_peek_spans where parent_id=:span_d_id and span_type='Insert' \gset
+SELECT span_id AS span_f_id,
+        get_span_start(span_start) as span_f_start,
+        get_span_end(span_start) as span_f_end
+		from pg_tracing_peek_spans where parent_id=:span_e_id and span_type='Result' \gset
+-- Executor Finish, first trigger
+SELECT span_id AS span_g_id,
+        get_span_start(span_start) as span_g_start,
+        get_span_end(span_start) as span_g_end
+		from pg_tracing_peek_spans where parent_id=:span_b_id and span_type='Executor' and span_operation='ExecutorFinish' \gset
+SELECT span_id AS span_h_id,
+        get_span_start(span_start) as span_h_start,
+        get_span_end(span_start) as span_h_end
+		from pg_tracing_peek_spans where parent_id=:span_g_id and span_type='Parse' \gset
+SELECT span_id AS span_i_id,
+        get_span_start(span_start) as span_i_start,
+        get_span_end(span_start) as span_i_end
+		from pg_tracing_peek_spans where parent_id=:span_g_id and span_type='Insert' limit 1 \gset
+SELECT span_id AS span_j_id,
+        get_span_start(span_start) as span_j_start,
+        get_span_end(span_start) as span_j_end
+		from pg_tracing_peek_spans where parent_id=:span_i_id and span_type='Planner' \gset
+SELECT span_id AS span_k_id,
+        get_span_start(span_start) as span_k_start,
+        get_span_end(span_start) as span_k_end
+		from pg_tracing_peek_spans where parent_id=:span_i_id and span_type='Executor' and span_operation='ExecutorRun' \gset
+SELECT span_id AS span_l_id,
+        get_span_start(span_start) as span_l_start,
+        get_span_end(span_start) as span_l_end
+		from pg_tracing_peek_spans where parent_id=:span_k_id and span_type='Insert' \gset
+SELECT span_id AS span_m_id,
+        get_span_start(span_start) as span_m_start,
+        get_span_end(span_start) as span_m_end
+		from pg_tracing_peek_spans where parent_id=:span_l_id and span_type='Result' \gset
+-- Executor Finish, second trigger
+SELECT span_id AS span_n_id,
+        get_span_start(span_start) as span_n_start,
+        get_span_end(span_start) as span_n_end
+        from pg_tracing_peek_spans where parent_id=:span_g_id and span_type='Insert' limit 1 offset 1 \gset
+SELECT span_id AS span_o_id,
+        get_span_start(span_start) as span_o_start,
+        get_span_end(span_start) as span_o_end
+        from pg_tracing_peek_spans where parent_id=:span_n_id and span_type='Executor' and span_operation='ExecutorRun' \gset
+-- Check that spans' start and end are within expection
+-- Root span
+SELECT :span_a_end <= :span_b_start as parse_before_root_span;
+ parse_before_root_span 
+------------------------
+ t
+(1 row)
+
+-- Planner
+SELECT :span_c_start >= :span_b_start as planner_starts_after_root_span;
+ planner_starts_after_root_span 
+--------------------------------
+ t
+(1 row)
+
+-- ExecutorRun
+SELECT :span_d_start >= :span_c_end as executor_run_starts_after_planner,
+       :span_d_end <= :span_g_start as executor_run_ends_before_finish;
+ executor_run_starts_after_planner | executor_run_ends_before_finish 
+-----------------------------------+---------------------------------
+ t                                 | t
+(1 row)
+
+-- First Insert
+SELECT :span_e_start >= :span_d_start as insert_starts_after_executor_run,
+       :span_e_start <= :span_f_start as insert_ends_before_executor_run,
+       :span_e_end >= :span_f_end as insert_starts_before_child,
+       :span_e_end <= :span_d_end as insert_ends_after_child;
+ insert_starts_after_executor_run | insert_ends_before_executor_run | insert_starts_before_child | insert_ends_after_child 
+----------------------------------+---------------------------------+----------------------------+-------------------------
+ t                                | t                               | t                          | t
+(1 row)
+
+-- ExecutorFinish
+SELECT :span_g_start <= :span_i_start as executor_finish_starts_before_child,
+       :span_g_end >= :span_o_end as executor_finish_ends_after_child;
+ executor_finish_starts_before_child | executor_finish_ends_after_child 
+-------------------------------------+----------------------------------
+ t                                   | t
+(1 row)
+
+-- First trigger
+SELECT :span_h_end <= :span_i_start as parse_ends_before_first_trigger,
+       :span_i_end >= :span_n_end as first_trigger_ends_after_child;
+ parse_ends_before_first_trigger | first_trigger_ends_after_child 
+---------------------------------+--------------------------------
+ t                               | t
+(1 row)
+
+-- Second trigger
+SELECT :span_o_start >= :span_i_end  as second_trigger_starts_after_first,
+       :span_o_end >= :span_o_end as second_trigger_ends_after_child,
+       :span_o_end <= :span_g_end as second_trigger_ends_before_executorfinish_end,
+       :span_n_end <= :span_g_end as second_trigger_ends_before_root_executorfinish_end;
+ second_trigger_starts_after_first | second_trigger_ends_after_child | second_trigger_ends_before_executorfinish_end | second_trigger_ends_before_root_executorfinish_end 
+-----------------------------------+---------------------------------+-----------------------------------------------+----------------------------------------------------
+ t                                 | t                               | t                                             | t
+(1 row)
+
+-- Check span_operation
+SELECT span_type, span_operation, lvl from peek_ordered_spans where trace_id=1;
+ span_type |                                                   span_operation                                                    | lvl 
+-----------+---------------------------------------------------------------------------------------------------------------------+-----
+ Parse     | Parse                                                                                                               |   1
+ Insert    | INSERT INTO Employee VALUES($1,$2);                                                                                 |   1
+ Planner   | Planner                                                                                                             |   2
+ Executor  | ExecutorRun                                                                                                         |   2
+ Insert    | Insert on employee                                                                                                  |   3
+ Result    | Result                                                                                                              |   4
+ Executor  | ExecutorFinish                                                                                                      |   2
+ Parse     | Parse                                                                                                               |   3
+ Insert    | INSERT INTO Employee_Audit (EmployeeId, LastName, EmpAdditionTime) VALUES(NEW.EmployeeId,NEW.LastName,current_date) |   3
+ Planner   | Planner                                                                                                             |   4
+ Executor  | ExecutorRun                                                                                                         |   4
+ Insert    | Insert on employee_audit                                                                                            |   5
+ Result    | Result                                                                                                              |   6
+ Insert    | INSERT INTO Employee_Audit (EmployeeId, LastName, EmpAdditionTime) VALUES(NEW.EmployeeId,NEW.LastName,current_date) |   3
+ Planner   | Planner                                                                                                             |   4
+ Executor  | ExecutorRun                                                                                                         |   4
+ Insert    | Insert on employee_audit                                                                                            |   5
+ Result    | Result                                                                                                              |   6
+(18 rows)
+
+-- Check count of query_id
+SELECT count(distinct query_id) from pg_tracing_consume_spans where trace_id=1;
+ count 
+-------
+     2
+(1 row)
+
+-- Second call, parse should not be present anymore
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ INSERT INTO Employee VALUES(11,'Adams');
+SELECT span_id AS span_b_id,
+        get_span_start(span_start) as span_b_start,
+        get_span_end(span_start) as span_b_end
+		from pg_tracing_peek_spans where parent_id=1 and span_type!='Parse' \gset
+SELECT span_id AS span_d_id,
+        get_span_start(span_start) as span_d_start,
+        get_span_end(span_start) as span_d_end
+		from pg_tracing_peek_spans where parent_id=:span_b_id and span_type='Executor' and span_operation='ExecutorRun' \gset
+SELECT span_id AS span_g_id,
+        get_span_start(span_start) as span_g_start,
+        get_span_end(span_start) as span_g_end
+		from pg_tracing_peek_spans where parent_id=:span_b_id and span_type='Executor' and span_operation='ExecutorFinish' \gset
+-- Check we don't have Parse span anymore
+SELECT count(*) = 0 from pg_tracing_peek_spans where parent_id=:span_g_id and span_type='Parse';
+ ?column? 
+----------
+ t
+(1 row)
+
+-- Insert should be attached to the correct parent
+SELECT count(*) = 1 from pg_tracing_peek_spans where parent_id=:span_g_id and span_type='Insert' limit 1 \gset
+invalid variable name: "?column?"
+-- Check that ExecutorRun ends before ExecutorFinish start
+SELECT :span_d_end <= :span_g_start as finish_start_after_run;
+ finish_start_after_run 
+------------------------
+ t
+(1 row)
+
+-- Check generated spans for the second call with trigger
+SELECT span_type, span_operation, lvl from peek_ordered_spans where trace_id=1;
+ span_type |                                                   span_operation                                                    | lvl 
+-----------+---------------------------------------------------------------------------------------------------------------------+-----
+ Parse     | Parse                                                                                                               |   1
+ Insert    | INSERT INTO Employee VALUES($1,$2);                                                                                 |   1
+ Planner   | Planner                                                                                                             |   2
+ Executor  | ExecutorRun                                                                                                         |   2
+ Insert    | Insert on employee                                                                                                  |   3
+ Result    | Result                                                                                                              |   4
+ Executor  | ExecutorFinish                                                                                                      |   2
+ Insert    | INSERT INTO Employee_Audit (EmployeeId, LastName, EmpAdditionTime) VALUES(NEW.EmployeeId,NEW.LastName,current_date) |   3
+ Planner   | Planner                                                                                                             |   4
+ Executor  | ExecutorRun                                                                                                         |   4
+ Insert    | Insert on employee_audit                                                                                            |   5
+ Result    | Result                                                                                                              |   6
+ Insert    | INSERT INTO Employee_Audit (EmployeeId, LastName, EmpAdditionTime) VALUES(NEW.EmployeeId,NEW.LastName,current_date) |   3
+ Planner   | Planner                                                                                                             |   4
+ Executor  | ExecutorRun                                                                                                         |   4
+ Insert    | Insert on employee_audit                                                                                            |   5
+ Result    | Result                                                                                                              |   6
+(17 rows)
+
+-- Check count of query_id
+SELECT count(distinct query_id) from pg_tracing_consume_spans where trace_id=1;
+ count 
+-------
+     2
+(1 row)
+
diff --git a/contrib/pg_tracing/expected/utility.out b/contrib/pg_tracing/expected/utility.out
new file mode 100644
index 0000000000..157ab647a4
--- /dev/null
+++ b/contrib/pg_tracing/expected/utility.out
@@ -0,0 +1,285 @@
+-- Some helper functions
+CREATE OR REPLACE FUNCTION get_span_start(time_start timestamptz) RETURNS bigint AS
+$BODY$
+BEGIN
+    RETURN extract(epoch from time_start);
+END;
+$BODY$
+LANGUAGE plpgsql;
+CREATE OR REPLACE FUNCTION get_span_end(time_end timestamptz) RETURNS bigint AS
+$BODY$
+BEGIN
+    RETURN extract(epoch from time_end);
+END;
+$BODY$
+LANGUAGE plpgsql;
+CREATE OR REPLACE PROCEDURE clean_spans() AS $$
+BEGIN
+    PERFORM count(*) from pg_tracing_consume_spans;
+END;
+$$ LANGUAGE plpgsql;
+-- Create pg_tracing extension with sampling on
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ CREATE EXTENSION pg_tracing;
+-- This will create the following spans (non exhaustive list):
+--
+-- +-------------------------------------------------------------------------------------+
+-- | A: Utility: Create Extension                                                        |
+-- +-+-----------------------------------------------------------------------------------+
+--   +----------------------------------------------------------------------------------+
+--   |B: ProcessUtility: Create Extension                                               |
+--   +---+-----------------------------------+---+--------------------------------------+
+--       +-----------------------------------+   +-------------------------------------+
+--       |C: Utility: Create Function1       |   |E: Utility: Create Function2         |
+--       ++----------------------------------+   ++-----------------------------------++
+--        +----------------------------------+    +-----------------------------------+
+--        |D: ProcessUtility: Create Function|    |F: ProcessUtility: Create Function2|
+--        +----------------------------------+    +-----------------------------------+
+-- Extract span_ids, start and end of those spans
+SELECT span_id AS span_a_id,
+        get_span_start(span_start) as span_a_start,
+        get_span_end(span_start) as span_a_end
+		from pg_tracing_peek_spans where parent_id=1 and span_type='Utility' \gset
+SELECT span_id AS span_b_id,
+        get_span_start(span_start) as span_b_start,
+        get_span_end(span_start) as span_b_end
+		from pg_tracing_peek_spans where parent_id=:span_a_id and span_type='ProcessUtility' \gset
+SELECT span_id AS span_c_id,
+        get_span_start(span_start) as span_c_start,
+        get_span_end(span_start) as span_c_end
+		from pg_tracing_peek_spans where parent_id=:span_b_id and span_type='Utility' limit 1 \gset
+SELECT span_id AS span_d_id,
+        get_span_start(span_start) as span_d_start,
+        get_span_end(span_start) as span_d_end
+		from pg_tracing_peek_spans where parent_id=:span_c_id and span_type='ProcessUtility' \gset
+SELECT span_id AS span_e_id,
+        get_span_start(span_start) as span_e_start,
+        get_span_end(span_start) as span_e_end
+		from pg_tracing_peek_spans where parent_id=:span_b_id and span_type='Utility' limit 1 offset 1 \gset
+-- Check that the start and end of those spans are within expectation
+SELECT :span_a_start <= :span_b_start AS span_a_starts_first,
+		:span_a_end >= :span_b_end AS span_a_ends_last,
+		:span_d_end <= :span_c_end AS nested_span_ends_before_parent,
+		:span_c_end <= :span_e_start AS next_utility_starts_after;
+ span_a_starts_first | span_a_ends_last | nested_span_ends_before_parent | next_utility_starts_after 
+---------------------+------------------+--------------------------------+---------------------------
+ t                   | t                | t                              | t
+(1 row)
+
+-- Clean current spans
+CALL clean_spans();
+--
+-- Test that no utility is captured with track_utility off
+--
+-- Set utility off
+SET pg_tracing.track_utility = off;
+-- Test utility tracking disabled + full sampling
+SET pg_tracing.sample_rate = 1.0;
+DROP EXTENSION pg_tracing;
+CREATE EXTENSION pg_tracing;
+SET pg_tracing.sample_rate = 0.0;
+-- View displaying spans with their nested level
+CREATE VIEW peek_spans_with_level AS
+    WITH RECURSIVE list_trace_spans(trace_id, parent_id, span_id, query_id, span_type, span_operation, span_start, span_end, sql_error_code, userid, dbid, pid, subxact_count, plan_startup_cost, plan_total_cost, plan_rows, plan_width, rows, nloops, shared_blks_hit, shared_blks_read, shared_blks_dirtied, shared_blks_written, local_blks_hit, local_blks_read, local_blks_dirtied, local_blks_written, blk_read_time, blk_write_time, temp_blks_read, temp_blks_written, temp_blk_read_time, temp_blk_write_time, wal_records, wal_fpi, wal_bytes, jit_functions, jit_generation_time, jit_inlining_time, jit_optimization_time, jit_emission_time, startup, parameters, deparse_info, lvl) AS (
+        SELECT p.*, 1
+        FROM pg_tracing_peek_spans p where trace_id=parent_id
+      UNION ALL
+        SELECT s.*, lvl + 1
+        FROM pg_tracing_peek_spans s, list_trace_spans st
+        WHERE s.parent_id = st.span_id
+    ) SELECT * FROM list_trace_spans;
+-- Create utility view to keep order stable
+CREATE VIEW peek_ordered_spans AS
+  SELECT * FROM peek_spans_with_level order by span_start, lvl;
+-- Nothing should have been generated
+select count(*) = 0 from pg_tracing_consume_spans;
+ ?column? 
+----------
+ t
+(1 row)
+
+-- Prepare and execute a prepared statement
+PREPARE test_prepared_one_param (integer) AS SELECT $1;
+EXECUTE test_prepared_one_param(100);
+ ?column? 
+----------
+      100
+(1 row)
+
+-- Nothing should be generated
+select count(*) = 0 from pg_tracing_consume_spans;
+ ?column? 
+----------
+ t
+(1 row)
+
+-- Force a query to start from ExecutorRun
+SET plan_cache_mode='force_generic_plan';
+EXECUTE test_prepared_one_param(200);
+ ?column? 
+----------
+      200
+(1 row)
+
+SET plan_cache_mode TO DEFAULT;
+-- Again, nothing should be generated
+select count(*) = 0 from pg_tracing_consume_spans;
+ ?column? 
+----------
+ t
+(1 row)
+
+--
+-- Test that no utility is captured with track_utility off
+--
+-- Enable utility tracking and track everything
+SET pg_tracing.track_utility = on;
+SET pg_tracing.sample_rate = 1.0;
+-- Prepare and execute a prepared statement
+PREPARE test_prepared_one_param_2 (integer) AS SELECT $1;
+EXECUTE test_prepared_one_param_2(100);
+ ?column? 
+----------
+      100
+(1 row)
+
+-- Check the number of generated spans
+select count(distinct(trace_id)) from pg_tracing_peek_spans;
+ count 
+-------
+     2
+(1 row)
+
+-- Check spans of test_prepared_one_param_2 execution
+select span_operation, parameters, lvl from peek_ordered_spans;
+                      span_operation                       | parameters | lvl 
+-----------------------------------------------------------+------------+-----
+ Parse                                                     |            |   1
+ PREPARE test_prepared_one_param_2 (integer) AS SELECT $1; |            |   1
+ ProcessUtility                                            |            |   2
+ Parse                                                     |            |   3
+ PREPARE test_prepared_one_param_2 (integer) AS SELECT $1; |            |   3
+ Parse                                                     |            |   1
+ EXECUTE test_prepared_one_param_2(100);                   |            |   1
+ ProcessUtility                                            |            |   2
+ PREPARE test_prepared_one_param_2 (integer) AS SELECT $1; | $1 = '100' |   3
+ Planner                                                   |            |   4
+ ExecutorRun                                               |            |   4
+ Result                                                    |            |   5
+(12 rows)
+
+-- Check the top span (standalone top span has trace_id=parent_id)
+select span_operation, parameters, lvl from peek_ordered_spans where trace_id = parent_id;
+                      span_operation                       | parameters | lvl 
+-----------------------------------------------------------+------------+-----
+ Parse                                                     |            |   1
+ PREPARE test_prepared_one_param_2 (integer) AS SELECT $1; |            |   1
+ Parse                                                     |            |   1
+ EXECUTE test_prepared_one_param_2(100);                   |            |   1
+(4 rows)
+
+CALL clean_spans();
+-- Test prepared statement with generic plan
+SET plan_cache_mode='force_generic_plan';
+EXECUTE test_prepared_one_param(200);
+ ?column? 
+----------
+      200
+(1 row)
+
+SET plan_cache_mode TO DEFAULT;
+-- Check the number of generated spans
+select count(distinct(trace_id)) from pg_tracing_peek_spans;
+ count 
+-------
+     3
+(1 row)
+
+-- Check spans of test_prepared_one_param execution
+select span_operation, parameters, lvl from peek_ordered_spans;
+                     span_operation                      | parameters | lvl 
+---------------------------------------------------------+------------+-----
+ Parse                                                   |            |   1
+ SET plan_cache_mode='force_generic_plan';               |            |   1
+ ProcessUtility                                          |            |   2
+ Parse                                                   |            |   1
+ EXECUTE test_prepared_one_param(200);                   |            |   1
+ ProcessUtility                                          |            |   2
+ PREPARE test_prepared_one_param (integer) AS SELECT $1; |            |   3
+ ExecutorRun                                             |            |   4
+ Result                                                  |            |   5
+ Parse                                                   |            |   1
+ SET plan_cache_mode TO DEFAULT;                         |            |   1
+ ProcessUtility                                          |            |   2
+(12 rows)
+
+-- Check the top span (standalone top span has trace_id=parent_id)
+select span_operation, parameters, lvl from peek_ordered_spans where trace_id = parent_id;
+              span_operation               | parameters | lvl 
+-------------------------------------------+------------+-----
+ Parse                                     |            |   1
+ SET plan_cache_mode='force_generic_plan'; |            |   1
+ Parse                                     |            |   1
+ EXECUTE test_prepared_one_param(200);     |            |   1
+ Parse                                     |            |   1
+ SET plan_cache_mode TO DEFAULT;           |            |   1
+(6 rows)
+
+CALL clean_spans();
+-- Second create extension should generate an error that is captured by span
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ CREATE EXTENSION pg_tracing;
+ERROR:  extension "pg_tracing" already exists
+select span_operation, parameters, sql_error_code, lvl from peek_ordered_spans where trace_id=1;
+        span_operation        | parameters | sql_error_code | lvl 
+------------------------------+------------+----------------+-----
+ Parse                        |            | 00000          |   1
+ CREATE EXTENSION pg_tracing; |            | 42710          |   1
+ ProcessUtility               |            | 42710          |   2
+(3 rows)
+
+-- Create test table
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000002-0000000000000002-01'*/ CREATE TABLE pg_tracing_test (a int, b char(20));
+-- Check create table spans
+select trace_id, span_type, span_operation, lvl from peek_ordered_spans where trace_id=2;
+ trace_id |   span_type    |                  span_operation                   | lvl 
+----------+----------------+---------------------------------------------------+-----
+        2 | Parse          | Parse                                             |   1
+        2 | Utility        | CREATE TABLE pg_tracing_test (a int, b char(20)); |   1
+        2 | ProcessUtility | ProcessUtility                                    |   2
+(3 rows)
+
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000003-0000000000000003-01'*/ CREATE INDEX pg_tracing_index ON pg_tracing_test (a);
+-- Check create index spans
+select trace_id, span_type, span_operation, lvl from peek_ordered_spans where trace_id=3;
+ trace_id |   span_type    |                    span_operation                     | lvl 
+----------+----------------+-------------------------------------------------------+-----
+        3 | Parse          | Parse                                                 |   1
+        3 | Utility        | CREATE INDEX pg_tracing_index ON pg_tracing_test (a); |   1
+        3 | ProcessUtility | ProcessUtility                                        |   2
+(3 rows)
+
+CREATE OR REPLACE FUNCTION lazy_function(IN anyarray, OUT x anyelement, OUT n int)
+    RETURNS SETOF RECORD
+    LANGUAGE sql STRICT IMMUTABLE PARALLEL SAFE
+    AS 'select s from pg_catalog.generate_series(1, 1, 1) as g(s)';
+-- Check that tracing a function call with the wrong number of arguments is managed correctly
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000004-0000000000000004-01'*/ select lazy_function('{1,2,3}'::int[]);
+ERROR:  return type mismatch in function declared to return record
+DETAIL:  Final statement returns too few columns.
+CONTEXT:  SQL function "lazy_function" during startup
+-- Check lazy function call with error
+select trace_id, span_type, span_operation, sql_error_code, lvl from peek_ordered_spans where trace_id=4;
+ trace_id | span_type  |                        span_operation                        | sql_error_code | lvl 
+----------+------------+--------------------------------------------------------------+----------------+-----
+        4 | Parse      | Parse                                                        | 00000          |   1
+        4 | Select     | select lazy_function($1::int[]);                             | 42P13          |   1
+        4 | Planner    | Planner                                                      | 00000          |   2
+        4 | Executor   | ExecutorRun                                                  | 42P13          |   2
+        4 | Parse      | Parse                                                        | 00000          |   2
+        4 | ProjectSet | ProjectSet                                                   | 42P13          |   3
+        4 | Result     | Result                                                       | 42P13          |   4
+        4 | Select     | select s from pg_catalog.generate_series($1, $2, $3) as g(s) | 00000          |   2
+(8 rows)
+
+-- Cleanup
+CALL clean_spans();
+SET pg_tracing.track_utility TO DEFAULT;
diff --git a/contrib/pg_tracing/expected/wal.out b/contrib/pg_tracing/expected/wal.out
new file mode 100644
index 0000000000..dbbd547e2f
--- /dev/null
+++ b/contrib/pg_tracing/expected/wal.out
@@ -0,0 +1,75 @@
+-- Enable wal instrumentation
+set pg_tracing.instrument_wal = true;
+-- Generate queries with wal write
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ INSERT INTO pg_tracing_test VALUES(generate_series(1, 10), 'aaa');
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000002-0000000000000002-01'*/ UPDATE pg_tracing_test SET b = 'bbb' WHERE a > 7;
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000003-0000000000000003-01'*/ DELETE FROM pg_tracing_test WHERE a > 9;
+-- Check WAL is generated for the above statements
+SELECT trace_id, span_type, span_operation, deparse_info,
+       wal_records > 0 as wal_records,
+       wal_bytes > 0 as wal_bytes
+FROM peek_ordered_spans;
+ trace_id |    span_type    |                          span_operation                          |     deparse_info      | wal_records | wal_bytes 
+----------+-----------------+------------------------------------------------------------------+-----------------------+-------------+-----------
+        1 | Parse           | Parse                                                            |                       |             | 
+        1 | Insert          | INSERT INTO pg_tracing_test VALUES(generate_series($1, $2), $3); |                       | t           | t
+        1 | Planner         | Planner                                                          |                       | f           | f
+        1 | Executor        | ExecutorRun                                                      |                       |             | 
+        1 | Insert          | Insert on pg_tracing_test                                        |                       | t           | t
+        1 | ProjectSet      | ProjectSet                                                       |                       | f           | f
+        1 | Result          | Result                                                           |                       | f           | f
+        2 | Parse           | Parse                                                            |                       |             | 
+        2 | Update          | UPDATE pg_tracing_test SET b = $1 WHERE a > $2;                  |                       | t           | t
+        2 | Planner         | Planner                                                          |                       | f           | f
+        2 | Executor        | ExecutorRun                                                      |                       |             | 
+        2 | Update          | Update on pg_tracing_test                                        |                       | t           | t
+        2 | BitmapHeapScan  | BitmapHeapScan on pg_tracing_test                                | Recheck Cond: (a > 7) | f           | f
+        2 | BitmapIndexScan | BitmapIndexScan on pg_tracing_index                              | Index Cond: (a > 7)   | f           | f
+        3 | Parse           | Parse                                                            |                       |             | 
+        3 | Delete          | DELETE FROM pg_tracing_test WHERE a > $1;                        |                       | t           | t
+        3 | Planner         | Planner                                                          |                       | f           | f
+        3 | Executor        | ExecutorRun                                                      |                       |             | 
+        3 | Delete          | Delete on pg_tracing_test                                        |                       | t           | t
+        3 | BitmapHeapScan  | BitmapHeapScan on pg_tracing_test                                | Recheck Cond: (a > 9) | f           | f
+        3 | BitmapIndexScan | BitmapIndexScan on pg_tracing_index                              | Index Cond: (a > 9)   | f           | f
+(21 rows)
+
+CALL clean_spans();
+-- Redo the same but without wal instrumentation
+set pg_tracing.instrument_wal = false;
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ INSERT INTO pg_tracing_test VALUES(generate_series(1, 10), 'aaa');
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000002-0000000000000002-01'*/ UPDATE pg_tracing_test SET b = 'bbb' WHERE a > 7;
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000003-0000000000000003-01'*/ DELETE FROM pg_tracing_test WHERE a > 9;
+-- With wal instrumentation disabled, wal counters should be set to 0
+SELECT trace_id, span_type, span_operation, deparse_info,
+       wal_records = 0 as wal_records,
+       wal_bytes = 0 as wal_bytes
+FROM peek_ordered_spans;
+ trace_id |    span_type    |                          span_operation                          |     deparse_info      | wal_records | wal_bytes 
+----------+-----------------+------------------------------------------------------------------+-----------------------+-------------+-----------
+        1 | Parse           | Parse                                                            |                       |             | 
+        1 | Insert          | INSERT INTO pg_tracing_test VALUES(generate_series($1, $2), $3); |                       | t           | t
+        1 | Planner         | Planner                                                          |                       | t           | t
+        1 | Executor        | ExecutorRun                                                      |                       |             | 
+        1 | Insert          | Insert on pg_tracing_test                                        |                       | t           | t
+        1 | ProjectSet      | ProjectSet                                                       |                       | t           | t
+        1 | Result          | Result                                                           |                       | t           | t
+        2 | Parse           | Parse                                                            |                       |             | 
+        2 | Update          | UPDATE pg_tracing_test SET b = $1 WHERE a > $2;                  |                       | t           | t
+        2 | Planner         | Planner                                                          |                       | t           | t
+        2 | Executor        | ExecutorRun                                                      |                       |             | 
+        2 | Update          | Update on pg_tracing_test                                        |                       | t           | t
+        2 | BitmapHeapScan  | BitmapHeapScan on pg_tracing_test                                | Recheck Cond: (a > 7) | t           | t
+        2 | BitmapIndexScan | BitmapIndexScan on pg_tracing_index                              | Index Cond: (a > 7)   | t           | t
+        3 | Parse           | Parse                                                            |                       |             | 
+        3 | Delete          | DELETE FROM pg_tracing_test WHERE a > $1;                        |                       | t           | t
+        3 | Planner         | Planner                                                          |                       | t           | t
+        3 | Executor        | ExecutorRun                                                      |                       |             | 
+        3 | Delete          | Delete on pg_tracing_test                                        |                       | t           | t
+        3 | BitmapHeapScan  | BitmapHeapScan on pg_tracing_test                                | Recheck Cond: (a > 9) | t           | t
+        3 | BitmapIndexScan | BitmapIndexScan on pg_tracing_index                              | Index Cond: (a > 9)   | t           | t
+(21 rows)
+
+-- Cleanup
+set pg_tracing.instrument_wal = true;
+CALL clean_spans();
diff --git a/contrib/pg_tracing/meson.build b/contrib/pg_tracing/meson.build
new file mode 100644
index 0000000000..223e705409
--- /dev/null
+++ b/contrib/pg_tracing/meson.build
@@ -0,0 +1,61 @@
+# Copyright (c) 2022-2023, PostgreSQL Global Development Group
+
+pg_tracing_sources = files(
+  'pg_tracing.c',
+  'pg_tracing_query_process.c',
+  'pg_tracing_explain.c',
+  'pg_tracing_parallel.c',
+  'pg_tracing_span.c',
+)
+
+if host_system == 'windows'
+  pg_tracing_sources += rc_lib_gen.process(win32ver_rc, extra_args: [
+    '--NAME', 'pg_tracing',
+    '--FILEDESC', 'pg_tracing - Add support for distributed tracing',])
+endif
+
+pg_tracing = shared_module('pg_tracing',
+  pg_tracing_sources,
+  kwargs: contrib_mod_args + {
+    'dependencies': contrib_mod_args['dependencies'],
+  },
+)
+contrib_targets += pg_tracing
+
+install_data(
+  'pg_tracing.control',
+  'pg_tracing--1.0.sql',
+  kwargs: contrib_data_args,
+)
+
+tests += {
+  'name': 'pg_tracing',
+  'sd': meson.current_source_dir(),
+  'bd': meson.current_build_dir(),
+  'regress': {
+	'sql': [
+	  'utility',
+	  'select',
+	  'extended',
+	  'insert',
+	  'trigger',
+	  'sample',
+	  'subxact',
+      'reset',
+      'nested',
+      'wal',
+      'parallel',
+      'cleanup'
+    ],
+	'regress_args': ['--temp-config', files('pg_tracing.conf')],
+    # Disabled because these tests require
+    # "shared_preload_libraries=pg_tracing", which typical
+    # runningcheck users do not have (e.g. buildfarm clients).
+    'runningcheck': false,
+  },
+  'tap': {
+    'tests': [
+      't/001_basic.pl',
+    ],
+  },
+}
diff --git a/contrib/pg_tracing/pg_tracing--1.0.sql b/contrib/pg_tracing/pg_tracing--1.0.sql
new file mode 100644
index 0000000000..3764243f8a
--- /dev/null
+++ b/contrib/pg_tracing/pg_tracing--1.0.sql
@@ -0,0 +1,101 @@
+/* contrib/pg_tracing/pg_tracing--1.0.sql */
+
+-- complain if script is sourced in psql, rather than via ALTER EXTENSION
+\echo Use "CREATE EXTENSION pg_tracing" to load this file. \quit
+
+--- Define pg_tracing_info
+CREATE FUNCTION pg_tracing_info(
+    OUT traces bigint,
+    OUT spans bigint,
+    OUT dropped_spans bigint,
+    OUT failed_truncates bigint,
+    OUT last_consume timestamp with time zone,
+    OUT stats_reset timestamp with time zone
+)
+RETURNS record
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT VOLATILE PARALLEL SAFE;
+
+CREATE FUNCTION pg_tracing_reset()
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C PARALLEL SAFE;
+
+CREATE FUNCTION pg_tracing_spans(
+    IN consume bool,
+    OUT trace_id bigint,
+    OUT parent_id bigint,
+    OUT span_id bigint,
+    OUT query_id bigint,
+    OUT span_type text,
+    OUT span_operation text,
+    OUT span_start timestamp with time zone,
+    OUT span_end timestamp with time zone,
+    OUT sql_error_code character(5),
+    OUT userid oid,
+    OUT dbid oid,
+    OUT pid int4,
+    OUT subxact_count smallint,
+
+--  Plan counters
+    OUT plan_startup_cost float8,
+    OUT plan_total_cost float8,
+    OUT plan_rows float8,
+    OUT plan_width int,
+
+-- Node Counters
+    OUT rows int8,
+    OUT nloops int8,
+
+    OUT shared_blks_hit int8,
+    OUT shared_blks_read int8,
+    OUT shared_blks_dirtied int8,
+    OUT shared_blks_written int8,
+
+    OUT local_blks_hit int8,
+    OUT local_blks_read int8,
+    OUT local_blks_dirtied int8,
+    OUT local_blks_written int8,
+
+    OUT blk_read_time float8,
+    OUT blk_write_time float8,
+
+    OUT temp_blks_read int8,
+    OUT temp_blks_written int8,
+    OUT temp_blk_read_time float8,
+    OUT temp_blk_write_time float8,
+
+    OUT wal_records int8,
+    OUT wal_fpi int8,
+    OUT wal_bytes numeric,
+
+    OUT jit_functions int8,
+    OUT jit_generation_time float8,
+    OUT jit_inlining_time float8,
+    OUT jit_optimization_time float8,
+    OUT jit_emission_time float8,
+
+--  Span node specific data
+    OUT startup bigint, -- First tuple
+    OUT parameters text,
+    OUT deparse_info text
+)
+RETURNS SETOF record
+AS 'MODULE_PATHNAME'
+LANGUAGE C PARALLEL SAFE;
+
+CREATE VIEW pg_tracing_info AS
+  SELECT * FROM pg_tracing_info();
+
+CREATE VIEW pg_tracing_peek_spans AS
+  SELECT * FROM pg_tracing_spans(false);
+
+CREATE VIEW pg_tracing_consume_spans AS
+  SELECT * FROM pg_tracing_spans(true);
+
+GRANT SELECT ON pg_tracing_info TO PUBLIC;
+GRANT SELECT ON pg_tracing_peek_spans TO pg_read_all_stats;
+GRANT SELECT ON pg_tracing_consume_spans TO pg_read_all_stats;
+
+-- Don't want this to be available to non-superusers.
+REVOKE EXECUTE ON FUNCTION pg_tracing_reset() FROM PUBLIC;
diff --git a/contrib/pg_tracing/pg_tracing.c b/contrib/pg_tracing/pg_tracing.c
new file mode 100644
index 0000000000..b403b5ea1c
--- /dev/null
+++ b/contrib/pg_tracing/pg_tracing.c
@@ -0,0 +1,2592 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_tracing.c
+ *		Generate spans for distributed tracing from SQL query
+ *
+ * Spans will only be generated for sampled queries. A query is sampled if:
+ * - It has a tracecontext propagated throught SQLCommenter and it passes the caller_sample_rate.
+ * - It has no SQLCommenter but the query randomly passes the global sample_rate
+ *
+ * A query with SQLcommenter will look like: /\*dddbs='postgres.db',traceparent='00-00000000000000000000000000000009-0000000000000005-01'*\/ select 1;
+ * The traceparent fields are detailed in https://www.w3.org/TR/trace-context/#traceparent-header-field-values
+ * 00000000000000000000000000000009: trace id
+ * 0000000000000005: parent id
+ * 01: trace flags (01 == sampled)
+ *
+ * If sampled, pg_tracing will generate spans for the current statement.
+ * A span represents an operation with a start time, an end time and metadatas (block stats, wal stats...).
+ * We will track the following operations:
+ * - Parse: We estimate a Parse span begining at the start of the statement and the end of post parse.
+ * - Top Span: The top span for a statement. They are created after extracting the traceid from traceparent or to represent a nested query.
+ * - Planner: We track the time spent in the planner and report the planner counters.
+ * - Node Span: Created from planstate. The name is extracted from the node type (IndexScan, SeqScan) and we rely on query instrumentation
+ *   to get their durations.
+ * - Executor: We only track steps of the Executor that could contain nested queries: Run and Finish
+ *
+ * A typical traced query will generate the following spans:
+ * +-----------------++-----------------------------------------------------------------------------------------+
+ * | Type: Parse     || Type: Select (top span)                                                                 |
+ * | Operation: Parse|| Operation: Select * pgbench_accounts WHERE aid=$1;                                      |
+ * +-----------------++------------------------+---+---+------------------------------------------------------+-+
+ *                    | Type: Planner          |   |Type: Executor                                        |
+ *                    | Operation: Planner     |   |Operation: Run                                        |
+ *                    +------------------------+   +--+--------------------------------------------------++
+ *                                                    | Type: IndexScan                                  |
+ *                                                    | Operation: IndexScan using pgbench_accounts_pkey |
+ *                                                    |            on pgbench_accounts                   |
+ *                                                    +--------------------------------------------------+
+ *
+ * IDENTIFICATION
+ *	  contrib/pg_tracing/pg_tracing.c
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "pg_tracing.h"
+#include "pg_tracing_explain.h"
+#include "pg_tracing_parallel.h"
+#include "pg_tracing_query_process.h"
+#include "pg_tracing_span.h"
+
+#include "access/xact.h"
+#include "common/pg_prng.h"
+#include "commands/async.h"
+#include "funcapi.h"
+#include "nodes/extensible.h"
+#include "optimizer/planner.h"
+#include "parser/analyze.h"
+#include "storage/ipc.h"
+#include "tcop/utility.h"
+#include "utils/builtins.h"
+#include "utils/lsyscache.h"
+#include "utils/ruleutils.h"
+#include "utils/xid8.h"
+
+PG_MODULE_MAGIC;
+
+typedef enum
+{
+	PG_TRACING_TRACK_NONE,		/* track no statements */
+	PG_TRACING_TRACK_TOP,		/* only top level statements */
+	PG_TRACING_TRACK_ALL		/* all statements, including nested ones */
+}			pgTracingTrackLevel;
+
+typedef enum
+{
+	PG_TRACING_KEEP_ON_FULL,	/* Keep existing buffers when full */
+	PG_TRACING_DROP_ON_FULL		/* Drop current buffers when full */
+}			pgTracingBufferMode;
+
+/*
+ * Structure to store flexible array of spans
+ */
+typedef struct pgTracingSpans
+{
+	int			end;			/* Index of last element */
+	int			max;			/* Maximum number of element */
+	Span		spans[FLEXIBLE_ARRAY_MEMBER];
+}			pgTracingSpans;
+
+/* GUC variables */
+static int	pg_tracing_max_span;	/* Maximum number of spans to store */
+static int	pg_tracing_max_parameter_str;	/* Maximum number of spans to
+											 * store */
+static bool pg_tracing_trace_parallel_workers = true;	/* True to generate
+														 * spans from parallel
+														 * workers */
+static int	pg_tracing_initial_allocated_spans = 25;	/* Number of spans
+														 * allocated at the
+														 * start of a trace at
+														 * the same time. */
+static bool pg_tracing_instrument_buffers;	/* Enable buffers instrumentation */
+static bool pg_tracing_instrument_wal;	/* Enable WAL instrumentation */
+static double pg_tracing_sample_rate = 0;	/* Sample rate applied to queries
+											 * without SQLCommenter */
+static double pg_tracing_caller_sample_rate = 1;	/* Sample rate applied to
+													 * queries with
+													 * SQLCommenter */
+static bool pg_tracing_export_parameters = true;	/* Export query's
+													 * parameters as span
+													 * metadata */
+static bool pg_tracing_deparse_plan = true; /* Deparse plan to generate more
+											 * detailed spans */
+static int	pg_tracing_track = PG_TRACING_TRACK_ALL;	/* tracking level */
+static bool pg_tracing_track_utility = true;	/* whether to track utility
+												 * commands */
+static int	pg_tracing_buffer_mode = PG_TRACING_KEEP_ON_FULL;	/* behaviour on full
+																 * buffer */
+static char *pg_tracing_notify_channel = NULL;	/* Name of the channel to
+												 * notify when span buffer
+												 * exceeds a provided
+												 * threshold */
+static double pg_tracing_notify_threshold = 0.8;	/* threshold for span
+													 * buffer usage
+													 * notification */
+
+static const struct config_enum_entry track_options[] =
+{
+	{"none", PG_TRACING_TRACK_NONE, false},
+	{"top", PG_TRACING_TRACK_TOP, false},
+	{"all", PG_TRACING_TRACK_ALL, false},
+	{NULL, 0, false}
+};
+
+static const struct config_enum_entry buffer_mode_options[] =
+{
+	{"keep_on_full", PG_TRACING_KEEP_ON_FULL, false},
+	{"drop_on_full", PG_TRACING_DROP_ON_FULL, false},
+	{NULL, 0, false}
+};
+
+#define pg_tracking_level(level) \
+	((pg_tracing_track == PG_TRACING_TRACK_ALL || \
+	(pg_tracing_track == PG_TRACING_TRACK_TOP && (level) == 0)))
+
+#define pg_tracing_enabled(trace_context, level) \
+	(trace_context->sampled && pg_tracking_level(level))
+
+#define US_IN_S INT64CONST(1000000)
+
+PG_FUNCTION_INFO_V1(pg_tracing_info);
+PG_FUNCTION_INFO_V1(pg_tracing_spans);
+PG_FUNCTION_INFO_V1(pg_tracing_reset);
+
+/*
+ * Global variables
+ */
+
+/* Memory context for pg_tracing. */
+static MemoryContext pg_tracing_mem_ctx;
+
+/* trace context at the root level of parse/planning hook */
+static struct pgTracingTraceContext root_trace_context;
+
+/* trace context used in nested levels or within executor hooks */
+static struct pgTracingTraceContext current_trace_context;
+
+/* Latest trace id observed */
+uint64		latest_trace_id;
+
+/* Latest local transaction id traced */
+LocalTransactionId latest_lxid = InvalidLocalTransactionId;
+
+/* Shared state with stats and file external state */
+static pgTracingSharedState * pg_tracing = NULL;
+
+/*
+ * Shared buffer storing spans. Query with sampled flag will add new spans to
+ * the shared state at the end of the traced query. Those spans will be consumed during calls to
+ * pg_tracing_consume_spans.
+ */
+static pgTracingSpans * shared_spans = NULL;
+
+/*
+ * Store all ongoing spans for the current trace.
+ * They will be added to shared_spans at the end of the query tracing.
+ */
+static pgTracingSpans * current_trace_spans;
+
+/*
+* Text for spans are buffered in this stringinfo and written at
+* the end of the tracing in a single write.
+*/
+static StringInfo current_trace_text;
+
+/*
+ * Maximum nested level for a query to know how many top spans we need to
+ * copy in shared_spans.
+ */
+static int	max_nested_level = -1;
+
+/* Current nesting depth of planner calls */
+static int	plan_nested_level = 0;
+
+/* Current nesting depth of ExecutorRun+ProcessUtility calls */
+static int	exec_nested_level = 0;
+
+/* Previous nested level observed during post parse */
+static int	previous_parse_nested_level = 0;
+
+/* Number of allocated levels. */
+static int	allocated_nested_level = 0;
+
+/* Possible start for a nested span */
+static TimestampTz nested_query_start_time = 0;
+
+/* Per nested level buffers */
+typedef struct pgTracingPerLevelBuffer
+{
+	Span		top_span;		/* top span in the current_trace_spans buffer */
+	Span		parse_span;		/* parse span for this level */
+	Span		executor_run;	/* executor run span by nested level. Executor
+								 * run is used as parent for spans generated
+								 * from planstate */
+	uint64		query_id;		/* Query id by nested level when available */
+}			pgTracingPerLevelBuffer;
+
+static pgTracingPerLevelBuffer * per_level_buffers;
+
+/* Timestamp of the latest statement checked for sampling. */
+static TimestampTz last_statement_check_for_sampling = 0;
+
+static void pg_tracing_shmem_request(void);
+static void pg_tracing_shmem_startup(void);
+
+/* Saved hook values in case of unload */
+static shmem_request_hook_type prev_shmem_request_hook = NULL;
+static shmem_startup_hook_type prev_shmem_startup_hook = NULL;
+static post_parse_analyze_hook_type prev_post_parse_analyze_hook = NULL;
+static planner_hook_type prev_planner_hook = NULL;
+static ExecutorStart_hook_type prev_ExecutorStart = NULL;
+static ExecutorRun_hook_type prev_ExecutorRun = NULL;
+static ExecutorFinish_hook_type prev_ExecutorFinish = NULL;
+static ExecutorEnd_hook_type prev_ExecutorEnd = NULL;
+static ProcessUtility_hook_type prev_ProcessUtility = NULL;
+
+static void pg_tracing_post_parse_analyze(ParseState *pstate, Query *query, JumbleState *jstate);
+static PlannedStmt *pg_tracing_planner_hook(Query *parse,
+											const char *query_string,
+											int cursorOptions,
+											ParamListInfo params);
+static void pg_tracing_ExecutorStart(QueryDesc *queryDesc, int eflags);
+static void pg_tracing_ExecutorRun(QueryDesc *queryDesc,
+								   ScanDirection direction,
+								   uint64 count, bool execute_once);
+static void pg_tracing_ExecutorFinish(QueryDesc *queryDesc);
+static void pg_tracing_ExecutorEnd(QueryDesc *queryDesc);
+static void pg_tracing_ProcessUtility(PlannedStmt *pstmt, const char *queryString,
+									  bool readOnlyTree,
+									  ProcessUtilityContext context, ParamListInfo params,
+									  QueryEnvironment *queryEnv,
+									  DestReceiver *dest, QueryCompletion *qc);
+
+static TimestampTz generate_member_nodes(PlanState **planstates, int nplans, planstateTraceContext * planstateTraceContext,
+										 uint64 parent_id, TimestampTz parent_start, TimestampTz *latest_end);
+static TimestampTz generate_span_from_planstate(PlanState *planstate, planstateTraceContext * planstateTraceContext,
+												uint64 parent_id, TimestampTz parent_start, TimestampTz *latest_end);
+static pgTracingStats get_empty_pg_tracing_stats(void);
+
+/*
+ * Module load callback
+ */
+void
+_PG_init(void)
+{
+	if (!process_shared_preload_libraries_in_progress)
+		return;
+
+	DefineCustomIntVariable("pg_tracing.max_span",
+							"Maximum number of spans stored in shared memory.",
+							NULL,
+							&pg_tracing_max_span,
+							5000,
+							0,
+							500000,
+							PGC_POSTMASTER,
+							0,
+							NULL,
+							NULL,
+							NULL);
+
+	DefineCustomIntVariable("pg_tracing.max_parameter_size",
+							"Maximum size of parameters. -1 to disable parameter in top span.",
+							NULL,
+							&pg_tracing_max_parameter_str,
+							1024,
+							0,
+							10000,
+							PGC_USERSET,
+							0,
+							NULL,
+							NULL,
+							NULL);
+
+	DefineCustomBoolVariable("pg_tracing.instrument_buffers",
+							 "Instrument and add buffers usage in spans.",
+							 NULL,
+							 &pg_tracing_instrument_buffers,
+							 true,
+							 PGC_USERSET,
+							 0,
+							 NULL,
+							 NULL,
+							 NULL);
+
+	DefineCustomBoolVariable("pg_tracing.instrument_wal",
+							 "Instrument and add WAL usage in spans.",
+							 NULL,
+							 &pg_tracing_instrument_wal,
+							 true,
+							 PGC_USERSET,
+							 0,
+							 NULL,
+							 NULL,
+							 NULL);
+
+	DefineCustomBoolVariable("pg_tracing.trace_parallel_workers",
+							 "Whether to generate samples from parallel workers.",
+							 NULL,
+							 &pg_tracing_trace_parallel_workers,
+							 true,
+							 PGC_USERSET,
+							 0,
+							 NULL,
+							 NULL,
+							 NULL);
+
+	DefineCustomIntVariable("pg_tracing.initial_allocated_spans",
+							"The number of allocated spans at the start of a trace. A higher number can help avoid reallocation when extending the buffer.",
+							NULL,
+							&pg_tracing_initial_allocated_spans,
+							25,
+							1,
+							500,
+							PGC_USERSET,
+							0,
+							NULL,
+							NULL,
+							NULL);
+
+	DefineCustomEnumVariable("pg_tracing.track",
+							 "Selects which statements are tracked by pg_tracing.",
+							 NULL,
+							 &pg_tracing_track,
+							 PG_TRACING_TRACK_ALL,
+							 track_options,
+							 PGC_USERSET,
+							 0,
+							 NULL,
+							 NULL,
+							 NULL);
+
+	DefineCustomBoolVariable("pg_tracing.track_utility",
+							 "Selects whether utility commands are tracked by pg_tracing.",
+							 NULL,
+							 &pg_tracing_track_utility,
+							 true,
+							 PGC_USERSET,
+							 0,
+							 NULL,
+							 NULL,
+							 NULL);
+
+	DefineCustomEnumVariable("pg_tracing.buffer_mode",
+							 "Controls behaviour on full buffer.",
+							 NULL,
+							 &pg_tracing_buffer_mode,
+							 PG_TRACING_KEEP_ON_FULL,
+							 buffer_mode_options,
+							 PGC_USERSET,
+							 0,
+							 NULL,
+							 NULL,
+							 NULL);
+
+	DefineCustomRealVariable("pg_tracing.sample_rate",
+							 "Fraction of queries without sampled flag or tracecontext to process.",
+							 NULL,
+							 &pg_tracing_sample_rate,
+							 0.0,
+							 0.0,
+							 1.0,
+							 PGC_USERSET,
+							 0,
+							 NULL,
+							 NULL,
+							 NULL);
+
+	DefineCustomRealVariable("pg_tracing.caller_sample_rate",
+							 "Fraction of queries having a tracecontext with sampled flag to process.",
+							 NULL,
+							 &pg_tracing_caller_sample_rate,
+							 1.0,
+							 0.0,
+							 1.0,
+							 PGC_USERSET,
+							 0,
+							 NULL,
+							 NULL,
+							 NULL);
+
+	DefineCustomBoolVariable("pg_tracing.export_parameters",
+							 "Export query's parameters as span metadata.",
+							 NULL,
+							 &pg_tracing_export_parameters,
+							 true,
+							 PGC_USERSET,
+							 0,
+							 NULL,
+							 NULL,
+							 NULL);
+
+	DefineCustomBoolVariable("pg_tracing.deparse_plan",
+							 "Deparse query plan to generate details more details on a plan node.",
+							 NULL,
+							 &pg_tracing_deparse_plan,
+							 true,
+							 PGC_USERSET,
+							 0,
+							 NULL,
+							 NULL,
+							 NULL);
+
+	DefineCustomStringVariable("pg_tracing.notify_channel",
+							   "Name of the channel to notify when span buffer reaches a provided threshold.",
+							   NULL,
+							   &pg_tracing_notify_channel,
+							   NULL,
+							   PGC_USERSET,
+							   0,
+							   NULL,
+							   NULL,
+							   NULL);
+
+	DefineCustomRealVariable("pg_tracing.notify_threshold",
+							 "When span buffer exceeds this threshold, a notification will be sent.",
+							 NULL,
+							 &pg_tracing_notify_threshold,
+							 0.8,
+							 0.0,
+							 1.0,
+							 PGC_USERSET,
+							 0,
+							 NULL,
+							 NULL,
+							 NULL);
+
+	MarkGUCPrefixReserved("pg_tracing");
+
+	/* For jumble state */
+	EnableQueryId();
+
+	/* Install hooks. */
+	prev_shmem_request_hook = shmem_request_hook;
+	shmem_request_hook = pg_tracing_shmem_request;
+
+	prev_shmem_startup_hook = shmem_startup_hook;
+	shmem_startup_hook = pg_tracing_shmem_startup;
+
+	prev_post_parse_analyze_hook = post_parse_analyze_hook;
+	post_parse_analyze_hook = pg_tracing_post_parse_analyze;
+
+	prev_planner_hook = planner_hook;
+	planner_hook = pg_tracing_planner_hook;
+
+	prev_ExecutorStart = ExecutorStart_hook;
+	ExecutorStart_hook = pg_tracing_ExecutorStart;
+	prev_ExecutorRun = ExecutorRun_hook;
+	ExecutorRun_hook = pg_tracing_ExecutorRun;
+	prev_ExecutorFinish = ExecutorFinish_hook;
+	ExecutorFinish_hook = pg_tracing_ExecutorFinish;
+	prev_ExecutorEnd = ExecutorEnd_hook;
+	ExecutorEnd_hook = pg_tracing_ExecutorEnd;
+
+	prev_ProcessUtility = ProcessUtility_hook;
+	ProcessUtility_hook = pg_tracing_ProcessUtility;
+}
+
+/*
+ * Estimate shared memory space needed.
+ */
+static Size
+pg_tracing_memsize(void)
+{
+	Size		size;
+
+	/* pg_tracing shared state */
+	size = sizeof(pgTracingSharedState);
+	/* span struct */
+	size = add_size(size, sizeof(pgTracingSpans));
+	/* the span variable array */
+	size = add_size(size, mul_size(pg_tracing_max_span, sizeof(Span)));
+	/* and the parallel workers context  */
+	size = add_size(size, mul_size(max_parallel_workers, sizeof(pgTracingParallelContext)));
+
+	return size;
+}
+
+/*
+ * shmem_request hook: request additional shared resources.  We'll allocate
+ * or attach to the shared resources in pgss_shmem_startup().
+ */
+static void
+pg_tracing_shmem_request(void)
+{
+	if (prev_shmem_request_hook)
+		prev_shmem_request_hook();
+	RequestAddinShmemSpace(pg_tracing_memsize());
+}
+
+
+/*
+ * Store span in the current_trace_spans buffer
+ */
+static void
+store_span(Span * span)
+{
+	int			index;
+
+	Assert(span->ended);
+	Assert(span->span_id > 0);
+
+	if (current_trace_spans->end >= current_trace_spans->max)
+	{
+		MemoryContext oldcxt;
+
+		/* Need to extend. */
+		/* TODO: Have a configurable limit? */
+		current_trace_spans->max *= 2;
+		oldcxt = MemoryContextSwitchTo(pg_tracing_mem_ctx);
+		current_trace_spans = repalloc(current_trace_spans, sizeof(pgTracingSpans) + current_trace_spans->max * sizeof(Span));
+		MemoryContextSwitchTo(oldcxt);
+	}
+	index = current_trace_spans->end++;
+	current_trace_spans->spans[index] = *span;
+}
+
+/*
+ * End and store a span in the current_trace_spans buffer
+ */
+static void
+end_and_store_span(Span * span, const TimestampTz *end_span_time)
+{
+	end_span(span, end_span_time);
+	store_span(span);
+}
+
+/*
+ * Get the span index of the top span for a specific nested level
+ */
+static Span *
+get_top_span_for_nested_level(int nested_level)
+{
+	Assert(nested_level <= max_nested_level);
+	Assert(nested_level >= 0);
+	return &per_level_buffers[nested_level].top_span;
+}
+
+/*
+ * End top span for the provided nested level
+ */
+static void
+end_top_span(const TimestampTz *end_time, const Span * previous_top_span)
+{
+	Span	   *top_span;
+
+	if (exec_nested_level > max_nested_level)
+		return;
+	top_span = get_top_span_for_nested_level(exec_nested_level);
+	if (!top_span->ended)
+		end_span(top_span, end_time);
+	if (previous_top_span != NULL)
+	{
+		store_span(top_span);
+		*top_span = *previous_top_span;
+	}
+}
+
+/*
+ * Decrease nested level while checking for possible nested span
+ * to end.
+ */
+static TimestampTz
+end_nested_span_and_decrease_nested_level(void)
+{
+	TimestampTz end_span_time = GetCurrentTimestamp();
+
+	end_top_span(&end_span_time, NULL);
+	exec_nested_level--;
+	return end_span_time;
+}
+
+/*
+ * Add span to the shared memory. Mutex must be acquired beforehand.
+ */
+static void
+add_span_to_shared_buffer_locked(const Span * span)
+{
+	/* Spans must be ended before adding them to the shared buffer */
+	Assert(span->ended);
+	if (shared_spans->end + 1 >= shared_spans->max)
+		pg_tracing->stats.dropped_spans++;
+	else
+	{
+		pg_tracing->stats.spans++;
+		shared_spans->spans[shared_spans->end++] = *span;
+	}
+}
+
+/*
+ * Check if we still have available space in the shared spans.
+ *
+ * Between the moment we check and the moment we insert spans, the buffer
+ * may be full but we will redo a check before. This check is done
+ * early when starting a top span to bail out early if the buffer is
+ * already full.
+ */
+static bool
+check_full_shared_spans()
+{
+	if (shared_spans->end + 1 >= shared_spans->max)
+	{
+		volatile	pgTracingSharedState *s = (volatile pgTracingSharedState *) pg_tracing;
+		bool		full_buffer = false;
+
+		SpinLockAcquire(&s->mutex);
+		if (pg_tracing_buffer_mode == PG_TRACING_DROP_ON_FULL)
+		{
+			s->stats.dropped_spans += shared_spans->end;
+			shared_spans->end = 0;
+			s->extent = 0;
+		}
+		else
+		{
+			full_buffer = true;
+			s->stats.dropped_spans++;
+		}
+		SpinLockRelease(&s->mutex);
+		return full_buffer;
+	}
+	return false;
+}
+
+/*
+ * Reset trace_context fields
+ */
+static void
+reset_trace_context(pgTracingTraceContext * trace_context)
+{
+	trace_context->sampled = 0;
+	trace_context->trace_id = 0;
+	trace_context->parent_id = 0;
+	trace_context->root_span.span_id = 0;
+	trace_context->in_aborted_transaction = false;
+}
+
+/*
+ * shmem_startup hook: allocate or attach to shared memory, Also create and
+ * load the query-texts file, which is expected to exist (even if empty)
+ * while the module is enabled.
+ */
+static void
+pg_tracing_shmem_startup(void)
+{
+	bool		found_pg_tracing;
+	bool		found_shared_spans;
+
+	if (prev_shmem_startup_hook)
+		prev_shmem_startup_hook();
+
+	/* reset in case this is a restart within the postmaster */
+	pg_tracing = NULL;
+
+	/* Create or attach to the shared memory state */
+	LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE);
+
+	reset_trace_context(&root_trace_context);
+	reset_trace_context(&current_trace_context);
+	pg_tracing = ShmemInitStruct("PgTracing Shared", sizeof(pgTracingSharedState), &found_pg_tracing);
+	shared_spans = ShmemInitStruct("PgTracing Spans",
+								   sizeof(pgTracingSpans) + pg_tracing_max_span * sizeof(Span),
+								   &found_shared_spans);
+
+	/* Initialize pg_tracing memory context */
+	pg_tracing_mem_ctx = AllocSetContextCreate(TopMemoryContext,
+											   "pg_tracing memory context",
+											   ALLOCSET_DEFAULT_SIZES);
+
+	/* Initialize shmem for trace propagation to parallel workers */
+	pg_tracing_shmem_parallel_startup();
+
+	/* First time, let's init shared state */
+	if (!found_pg_tracing)
+	{
+		pg_tracing->stats = get_empty_pg_tracing_stats();
+		SpinLockInit(&pg_tracing->mutex);
+	}
+	if (!found_shared_spans)
+	{
+		shared_spans->end = 0;
+		shared_spans->max = pg_tracing_max_span;
+	}
+	LWLockRelease(AddinShmemInitLock);
+}
+
+/*
+ * Process a query descriptor: Gather all query instrumentation in the query
+ * span counters and generate span nodes from queryDesc planstate
+ */
+static void
+process_query_desc(pgTracingTraceContext * trace_context, QueryDesc *queryDesc, int sql_error_code)
+{
+	NodeCounters *node_counters = &get_top_span_for_nested_level(exec_nested_level)->node_counters;
+
+	/* Process total counters */
+	if (queryDesc->totaltime)
+	{
+		InstrEndLoop(queryDesc->totaltime);
+		node_counters->buffer_usage = queryDesc->totaltime->bufusage;
+		node_counters->wal_usage = queryDesc->totaltime->walusage;
+	}
+	/* Process JIT counter */
+	if (queryDesc->estate->es_jit)
+		node_counters->jit_usage = queryDesc->estate->es_jit->instr;
+	node_counters->rows = queryDesc->estate->es_total_processed;
+
+	/* Process planstate */
+	if (queryDesc->planstate)
+	{
+		Bitmapset  *rels_used = NULL;
+		planstateTraceContext planstateTraceContext;
+		TimestampTz latest_end = 0;
+		Span	   *parent_span = &per_level_buffers[exec_nested_level].executor_run;
+
+		planstateTraceContext.rtable_names = select_rtable_names_for_explain(queryDesc->plannedstmt->rtable, rels_used);
+		planstateTraceContext.trace_id = trace_context->trace_id;
+		planstateTraceContext.ancestors = NULL;
+		planstateTraceContext.sql_error_code = sql_error_code;
+		/* Prepare the planstate context for deparsing */
+		planstateTraceContext.deparse_ctx = NULL;
+		if (pg_tracing_deparse_plan)
+			planstateTraceContext.deparse_ctx = deparse_context_for_plan_tree(queryDesc->plannedstmt, planstateTraceContext.rtable_names);
+
+		generate_span_from_planstate(queryDesc->planstate, &planstateTraceContext, parent_span->span_id, parent_span->start, &latest_end);
+		if (parent_span->end == 0)
+			parent_span->end = latest_end;
+		else
+			Assert(parent_span->end >= latest_end);
+	}
+}
+
+/*
+ * Create a trace id for the trace context if there's none.
+ * If trace was started from the global sample rate without
+ * a parent trace, we need to generate a random trace id.
+ */
+static void
+set_trace_id(struct pgTracingTraceContext *trace_context)
+{
+	if (trace_context->trace_id != 0)
+	{
+		/* Update last lxid seen */
+		latest_lxid = MyProc->lxid;
+		return;
+	}
+
+	/*
+	 * We want to keep the same trace id for all statements within the same
+	 * transaction. For that, we check if we're in the same local xid.
+	 */
+	if (MyProc->lxid == latest_lxid)
+	{
+		trace_context->trace_id = latest_trace_id;
+		return;
+	}
+
+	/*
+	 * We leave parent_id to 0 as a way to indicate that this is a standalone
+	 * trace.
+	 */
+	Assert(trace_context->parent_id == 0);
+	trace_context->trace_id = pg_prng_uint64(&pg_global_prng_state);
+	latest_trace_id = trace_context->trace_id;
+	latest_lxid = MyProc->lxid;
+}
+
+/*
+ * Decide whether a query should be sampled depending on the traceparent sampled
+ * and the provided sample rate configurations
+ */
+static bool
+apply_sample_rate(const struct pgTracingTraceContext *trace_context)
+{
+	double		rand;
+	bool		sampled;
+
+	/* Everything is sampled */
+	if (pg_tracing_sample_rate >= 1.0)
+		return true;
+
+	/* No SQLCommenter sampled and no global sample rate */
+	if (!trace_context->sampled && pg_tracing_sample_rate == 0.0)
+		return false;
+
+	/* SQLCommenter sampled caller sample */
+	if (trace_context->sampled && pg_tracing_caller_sample_rate >= 1.0)
+		return true;
+
+	/*
+	 * We have a non zero global sample rate or a sampled flag. Either way, we
+	 * need a rand value
+	 */
+	rand = pg_prng_double(&pg_global_prng_state);
+	if (trace_context->sampled)
+		/* Sampled flag case */
+		sampled = (rand < pg_tracing_caller_sample_rate);
+	else
+		/* Global rate case */
+		sampled = (rand < pg_tracing_sample_rate);
+	return sampled;
+}
+
+/*
+ * If the query was started as a prepared statement, we won't be able to
+ * extract traceparent during query parsing since parsing was skipped.
+ *
+ * We assume that SQLCommenter content can be passed as a text in the
+ * first parameter and try to extract the trace context from this first parameter.
+ */
+static void
+extract_trace_context_from_parameter(struct pgTracingTraceContext *trace_context, ParamListInfo params)
+{
+	Oid			typoutput;
+	bool		typisvarlena;
+	char	   *pstring;
+	ParamExternData param;
+
+	if (params == NULL || params->numParams == 0)
+		return;
+
+	param = params->params[0];
+	/* We only check the first parameter and if it's a text parameter */
+	if (param.ptype != TEXTOID)
+		return;
+
+	/* Get the text of the first string parameter */
+	getTypeOutputInfo(param.ptype, &typoutput, &typisvarlena);
+	pstring = OidOutputFunctionCall(typoutput, param.value);
+	extract_trace_context_from_query(trace_context, pstring, true);
+}
+
+/*
+ * Extract trace_context from either the query text or parameters.
+ * Sampling rate will be applied to the trace_context.
+ */
+static void
+extract_trace_context(struct pgTracingTraceContext *trace_context, ParseState *pstate, const ParamListInfo params)
+{
+	TimestampTz statement_start_ts;
+
+	/* Safety check... */
+	if (!pg_tracing || !pg_tracking_level(exec_nested_level))
+		return;
+
+	/* sampling already started */
+	if (trace_context->sampled)
+		return;
+
+	/* Don't start tracing if we're not at the top */
+	if (exec_nested_level > 0)
+		return;
+
+	/*
+	 * In a parallel worker, check the parallel context shared buffer to see
+	 * if the leader left a trace context
+	 */
+	if (IsParallelWorker())
+	{
+		if (pg_tracing_trace_parallel_workers)
+			fetch_parallel_context(trace_context);
+		return;
+	}
+
+	Assert(trace_context->root_span.span_id == 0);
+	Assert(trace_context->trace_id == 0);
+
+	if (params != NULL)
+		extract_trace_context_from_parameter(trace_context, params);
+	else if (pstate != NULL)
+		extract_trace_context_from_query(trace_context, pstate->p_sourcetext, false);
+
+	/*
+	 * A statement can go through this function 3 times: post parsing, planner
+	 * and executor run. If no sampling flag was extracted from SQLCommenter
+	 * and we've already seen this statement (using statement_start ts), don't
+	 * try to apply sample rate and exit.
+	 */
+	statement_start_ts = GetCurrentStatementStartTimestamp();
+	if (trace_context->sampled == 0 && last_statement_check_for_sampling == statement_start_ts)
+		return;
+	/* First time we see this statement, save the time */
+	last_statement_check_for_sampling = statement_start_ts;
+
+	trace_context->sampled = apply_sample_rate(trace_context);
+
+	if (trace_context->sampled && check_full_shared_spans())
+		/* Buffer is full, abort sampling */
+		trace_context->sampled = 0;
+
+	if (trace_context->sampled)
+		set_trace_id(trace_context);
+	else
+		/* No sampling, reset the context */
+		reset_trace_context(trace_context);
+}
+
+/*
+ * Adjust span's offsets with the provided file offset
+ */
+static void
+adjust_file_offset(Span * span, Size file_position)
+{
+	if (span->node_type_offset != -1)
+		span->node_type_offset += file_position;
+	if (span->operation_name_offset != -1)
+		span->operation_name_offset += file_position;
+	if (span->deparse_info_offset != -1)
+		span->deparse_info_offset += file_position;
+	if (span->parameter_offset != -1)
+		span->parameter_offset += file_position;
+}
+
+/*
+ * Reset pg_tracing memory context and global state.
+ */
+static void
+cleanup_tracing(void)
+{
+	if (!root_trace_context.sampled && !current_trace_context.sampled)
+		/* No need for cleaning */
+		return;
+	if (pg_tracing_trace_parallel_workers)
+		remove_parallel_context();
+	MemoryContextReset(pg_tracing_mem_ctx);
+	reset_trace_context(&root_trace_context);
+	reset_trace_context(&current_trace_context);
+	max_nested_level = -1;
+	previous_parse_nested_level = 0;
+	nested_query_start_time = 0;
+	current_trace_spans = NULL;
+	per_level_buffers = NULL;
+}
+
+/*
+ * End the query tracing and dump all spans in the shared buffer.
+ * This may happen either when query is finished or on a caught error.
+ */
+static void
+end_tracing(pgTracingTraceContext * trace_context)
+{
+	Size		file_position = 0;
+	int			end_spans_number;
+
+	/* We're still a nested query, tracing is not finished */
+	if (exec_nested_level + plan_nested_level > 0)
+		return;
+
+	/* Dump all buffered texts in file */
+	text_store_file(pg_tracing, current_trace_text->data, current_trace_text->len, &file_position);
+
+	for (int i = 0; i <= max_nested_level; i++)
+	{
+		Span	   *top_span = &per_level_buffers[i].top_span;
+
+		if (top_span->trace_id > 0)
+			store_span(top_span);
+	}
+	for (int i = 0; i <= max_nested_level; i++)
+	{
+		Span	   *parse_span = &per_level_buffers[i].parse_span;
+
+		if (parse_span->trace_id > 0)
+			store_span(parse_span);
+	}
+
+	for (int i = 0; i < current_trace_spans->end; i++)
+		adjust_file_offset(current_trace_spans->spans + i, file_position);
+
+	{
+		volatile	pgTracingSharedState *s = (volatile pgTracingSharedState *) pg_tracing;
+
+		SpinLockAcquire(&s->mutex);
+		/* We're at the end, add all spans to the shared memory */
+		for (int i = 0; i < current_trace_spans->end; i++)
+			add_span_to_shared_buffer_locked(&current_trace_spans->spans[i]);
+		end_spans_number = shared_spans->end;
+		SpinLockRelease(&s->mutex);
+	}
+
+	if (pg_tracing_notify_channel != NULL && !IsParallelWorker())
+	{
+		int			span_threshold = pg_tracing_max_span * pg_tracing_notify_threshold;
+
+		/*
+		 * We can't send notification within an aborted transaction as async
+		 * already went through the AtAbort_Notify. Queueing a notification
+		 * after could lead to a possible segfault.
+		 */
+		if (end_spans_number >= span_threshold && !trace_context->in_aborted_transaction)
+			/* We've crossed the threshold, send a notification */
+			Async_Notify(pg_tracing_notify_channel, NULL);
+	}
+
+	/* We can reset the memory context here */
+	cleanup_tracing();
+}
+
+/*
+ * When we catch an error (timeout, cancel query), we need to flag the ongoing
+ * span with an error, send current spans in the shared buffer and clean
+ * our memory context.
+ *
+ * We provide the ongoing span index where the error was caught to attach the
+ * sql error code to it.
+ */
+static void
+handle_pg_error(pgTracingTraceContext * trace_context,
+				Span * ongoing_span, QueryDesc *queryDesc,
+				TimestampTz *input_end_span_time)
+{
+	Span	   *top_span;
+	int			sql_error_code;
+	TimestampTz end_span_time;
+
+	/* If we're not sampling the query, bail out */
+	if (!pg_tracing_enabled(trace_context, exec_nested_level))
+		return;
+	sql_error_code = geterrcode();
+
+	/*
+	 * Order matters there. We want to process query desc before getting the
+	 * end time. Otherwise, the span nodes will have a higher duration than
+	 * their parents.
+	 */
+	if (queryDesc != NULL)
+		process_query_desc(trace_context, queryDesc, sql_error_code);
+
+	if (input_end_span_time != NULL)
+		end_span_time = *input_end_span_time;
+	else
+		end_span_time = GetCurrentTimestamp();
+
+	/* Assign the error code to the latest span */
+	if (ongoing_span != NULL)
+	{
+		ongoing_span->sql_error_code = sql_error_code;
+		end_and_store_span(ongoing_span, &end_span_time);
+	}
+
+	/* Assign the error code to the latest top span */
+	top_span = get_top_span_for_nested_level(exec_nested_level);
+	top_span->sql_error_code = sql_error_code;
+
+	/* End all ongoing top spans */
+	for (int i = 0; i <= max_nested_level; i++)
+	{
+		Span	   *span = &per_level_buffers[i].top_span;
+
+		if (!span->ended)
+			end_span(span, &end_span_time);
+	}
+
+	end_tracing(trace_context);
+}
+
+/*
+ * Get the parent id for the given nested level
+ *
+ * nested_level can be negative when creating the root top span.
+ * In this case, we use the parent id from the propagated trace context.
+ */
+static uint64
+get_parent_id(pgTracingTraceContext * trace_context, int nested_level)
+{
+	Span	   *top_span;
+
+	if (nested_level < 0)
+		return trace_context->parent_id;
+	Assert(nested_level <= allocated_nested_level);
+	top_span = get_top_span_for_nested_level(nested_level);
+	Assert(top_span->span_id > 0);
+	return top_span->span_id;
+}
+
+/*
+ * If we enter a new nested level, initialize all necessary buffers
+ * and start_trace timer.
+ *
+ * The start of a top span can vary: prepared statement will skip parsing, the use of cached
+ * plans will skip the planner hook.
+ * Thus, a top span can start in either post parse, planner hook or executor run.
+ */
+static bool
+initialize_trace_level(void)
+{
+	Assert(exec_nested_level >= 0);
+
+	/* Check if we've already created a top span for this nested level */
+	if (exec_nested_level <= max_nested_level)
+		return false;
+
+	/* First time */
+	if (max_nested_level == -1)
+	{
+		MemoryContext oldcxt;
+
+		Assert(pg_tracing_mem_ctx->isReset);
+
+		/*
+		 * We need to be able to pass information that depends on the nested
+		 * level.
+		 *
+		 * executor span ids: Since an executor run becomes the parent span,
+		 * we need subsequent created node spans to have the correct parent.
+		 *
+		 * query ids: used to propagate queryId to all spans in the same level
+		 *
+		 * top spans: We create one top span per nested level and those are
+		 * only inserted in the shared buffer at the end
+		 */
+		oldcxt = MemoryContextSwitchTo(pg_tracing_mem_ctx);
+		/* initial allocation */
+		allocated_nested_level = 1;
+		per_level_buffers = palloc0(allocated_nested_level * sizeof(pgTracingPerLevelBuffer));
+		current_trace_spans = palloc0(sizeof(pgTracingSpans) + pg_tracing_initial_allocated_spans * sizeof(Span));
+		current_trace_spans->max = pg_tracing_initial_allocated_spans;
+		current_trace_text = makeStringInfo();
+
+		MemoryContextSwitchTo(oldcxt);
+		{
+			/* Start of a new trace */
+			volatile	pgTracingSharedState *s = (volatile pgTracingSharedState *) pg_tracing;
+
+			SpinLockAcquire(&s->mutex);
+			s->stats.traces++;
+			SpinLockRelease(&s->mutex);
+		}
+
+	}
+	else if (exec_nested_level >= allocated_nested_level)
+	{
+		/* New nested level, allocate more memory */
+		MemoryContext oldcxt;
+		int			old_allocated_nested_level = allocated_nested_level;
+
+		oldcxt = MemoryContextSwitchTo(pg_tracing_mem_ctx);
+		allocated_nested_level++;
+		per_level_buffers = repalloc0(per_level_buffers, old_allocated_nested_level * sizeof(pgTracingPerLevelBuffer),
+									  allocated_nested_level * sizeof(pgTracingPerLevelBuffer));
+		MemoryContextSwitchTo(oldcxt);
+	}
+
+	max_nested_level = exec_nested_level;
+	return true;
+}
+
+/*
+ * Add a new string to the current_trace_text stringinfo
+ */
+static int
+add_str_to_trace_buffer(const char *str, int str_len)
+{
+	int			position = current_trace_text->cursor;
+
+	Assert(str_len > 0);
+
+	appendBinaryStringInfo(current_trace_text, str, str_len);
+	appendStringInfoChar(current_trace_text, '\0');
+	current_trace_text->cursor = current_trace_text->len;
+	return position;
+}
+
+/*
+ * Add the worker name to the current_trace_text stringinfo
+ */
+static int
+add_worker_name_to_trace_buffer(void)
+{
+	int			position = current_trace_text->cursor;
+
+	appendStringInfo(current_trace_text, "Worker %d", ParallelWorkerNumber);
+	appendStringInfoChar(current_trace_text, '\0');
+	current_trace_text->cursor = current_trace_text->len;
+	return position;
+}
+
+/*
+ * Start a new top span if we've entered a new nested level
+ * or if the previous span at the same level ended
+ */
+static void
+begin_top_span(pgTracingTraceContext * trace_context,
+			   Span * top_span, CmdType commandType,
+			   const Query *query, const JumbleState *jstate,
+			   const PlannedStmt *pstmt,
+			   const char *query_text, TimestampTz start_time)
+{
+	int			query_len;
+	const char *normalised_query;
+
+	/* in case of a cached plan, query might be unavailable */
+	if (query != NULL)
+		per_level_buffers[exec_nested_level].query_id = query->queryId;
+	else if (trace_context->query_id > 0)
+		per_level_buffers[exec_nested_level].query_id = trace_context->query_id;
+
+	/*
+	 * With multi-statement queries, we can have multiple top spans in a
+	 * level. Check if we have an previous top span that was ended and store
+	 * it.
+	 */
+	if (top_span->ended == true)
+		store_span(top_span);
+
+	begin_span(trace_context->trace_id, top_span, command_type_to_span_type(commandType),
+			   NULL, get_parent_id(trace_context, exec_nested_level - 1),
+			   per_level_buffers[exec_nested_level].query_id, &start_time);
+
+	if (IsParallelWorker())
+	{
+		/*
+		 * In a parallel worker, we use the worker name as the span's
+		 * operation
+		 */
+		top_span->operation_name_offset = add_worker_name_to_trace_buffer();
+		return;
+	}
+
+	if (jstate && jstate->clocations_count > 0 && query != NULL)
+	{
+		/* jstate is available, normalise query and extract parameters' values */
+		char	   *param_str;
+		int			param_len;
+
+		query_len = query->stmt_len;
+		normalised_query = normalise_query_parameters(jstate, query_text,
+													  query->stmt_location,
+													  &query_len, &param_str, &param_len);
+		Assert(param_len > 0);
+		if (pg_tracing_export_parameters)
+			top_span->parameter_offset = add_str_to_trace_buffer(param_str, param_len);
+	}
+	else
+	{
+		/*
+		 * No jstate available, normalise query but we won't be able to
+		 * extract parameters
+		 */
+		int			stmt_location;
+
+		if (query != NULL && query->stmt_len > 0)
+		{
+			query_len = query->stmt_len;
+			stmt_location = query->stmt_location;
+		}
+		else if (pstmt != NULL && pstmt->stmt_location != -1 && pstmt->stmt_len > 0)
+		{
+			query_len = pstmt->stmt_len;
+			stmt_location = pstmt->stmt_location;
+		}
+		else
+		{
+			query_len = strlen(query_text);
+			stmt_location = 0;
+		}
+		normalised_query = normalise_query(query_text, stmt_location, &query_len);
+	}
+	top_span->operation_name_offset = add_str_to_trace_buffer(normalised_query, query_len);
+}
+
+/*
+ * Initialise buffers if we are in a new nested level and start associated top span.
+ * If the top span already exists for the current nested level, this has no effect.
+ *
+ * This needs to be called every time a top span could be started: post parse, planner, executor start
+ * and process utility
+ */
+static Span *
+initialize_trace_level_and_top_span(pgTracingTraceContext * trace_context, CmdType commandType,
+									Query *query, JumbleState *jstate, const PlannedStmt *pstmt,
+									const char *query_text, TimestampTz start_time, bool in_post_parse)
+{
+	bool		new_allocated_level;
+	Span	   *top_span;
+
+	new_allocated_level = initialize_trace_level();
+	if (in_post_parse && exec_nested_level == 0)
+
+		/*
+		 * A the root post parse, we want to use trace_context's root_span as
+		 * the top span in per_level_buffers might still be ongoing.
+		 */
+		top_span = &trace_context->root_span;
+	else
+	{
+		top_span = get_top_span_for_nested_level(exec_nested_level);
+		if (exec_nested_level == 0 && top_span->span_id != trace_context->root_span.span_id)
+
+			/*
+			 * At root level, we need to copy the root span content
+			 */
+			*top_span = trace_context->root_span;
+	}
+
+	/*
+	 * It's possible to have multiple top spans within a nested query. If the
+	 * previous top span was closed, we need to start a new one. If it's still
+	 * ongoing, use it.
+	 */
+	if (!new_allocated_level && top_span->span_id > 0 && top_span->ended == false)
+		return top_span;
+
+	/* current_trace_spans buffer should have been allocated */
+	Assert(current_trace_spans != NULL);
+
+	/*
+	 * Either this is the first top span for this level or the previous one
+	 * was finished, start the new top span
+	 */
+	begin_top_span(trace_context, top_span, commandType, query, jstate, pstmt, query_text, start_time);
+	return top_span;
+}
+
+/*
+ * Post-parse-analyze hook
+ *
+ * Tracing can be started here if:
+ * - The query has a SQLCommenter with traceparent parameter with sampled flag on and passes the caller_sample_rate
+ * - The query passes the sample_rate
+ *
+ * If query is sampled, create a post parse span and start the top span.
+ */
+static void
+pg_tracing_post_parse_analyze(ParseState *pstate, Query *query, JumbleState *jstate)
+{
+	TimestampTz start_top_span;
+	Span	   *top_span;
+	pgTracingTraceContext *trace_context = &root_trace_context;
+	bool		new_lxid = MyProc->lxid != latest_lxid;
+
+	if (!pg_tracing_mem_ctx->isReset && new_lxid && exec_nested_level + plan_nested_level == 0)
+
+		/*
+		 * Some errors can happen outside of our PG_TRY (incorrect number of
+		 * bind parameters for example) which will leave a dirty trace
+		 * context. We can also have sampled individual Parse command through
+		 * extended protocol. In this case, we just drop the spans and reset
+		 * memory context
+		 */
+		cleanup_tracing();
+
+	if (exec_nested_level + plan_nested_level == 0)
+
+		/*
+		 * At the root level, clean any leftover state of previous trace
+		 * context
+		 */
+		reset_trace_context(&root_trace_context);
+	else
+		/* We're in a nested query, grab the ongoing trace_context */
+		trace_context = &current_trace_context;
+
+	if (prev_post_parse_analyze_hook)
+		prev_post_parse_analyze_hook(pstate, query, jstate);
+
+	/* If disabled, don't trace utility statement */
+	if (query->utilityStmt && !pg_tracing_track_utility)
+		return;
+
+	/* Evaluate if query is sampled or not */
+	extract_trace_context(trace_context, pstate, NULL);
+
+	if (!trace_context->sampled)
+		/* Query is not sampled, nothing to do */
+		return;
+
+	/*
+	 * We want to avoid calling get_ns at the start of post parse as it will
+	 * impact all queries and we will only use it when the query is sampled.
+	 */
+	start_top_span = GetCurrentTimestamp();
+
+	/*
+	 * Either we're inside a nested sampled query or we've parsed a query with
+	 * the sampled flag, start a new level with a top span
+	 */
+	top_span = initialize_trace_level_and_top_span(trace_context, query->commandType,
+												   query, jstate, NULL,
+												   pstate->p_sourcetext, start_top_span,
+												   true);
+
+	/*
+	 * We only create parse span when we have a good idea of when parsing
+	 * started. Since multiple queries can be parsed at once when entering a
+	 * new nested level, we only create a parse span when we detect a change
+	 * in parse nested level.
+	 */
+	if ((exec_nested_level + plan_nested_level == 0) ||
+		(nested_query_start_time > 0 && previous_parse_nested_level != exec_nested_level))
+	{
+		TimestampTz start_parse_span;
+		Span	   *parse_span = &per_level_buffers[exec_nested_level].parse_span;
+
+		/*
+		 * We don't have a precise time for parse end, estimate it
+		 *
+		 * TODO: Can we get a more precise start of parse?
+		 */
+		TimestampTz end_parse = start_top_span;
+
+		if (per_level_buffers[exec_nested_level].parse_span.trace_id > 0)
+		{
+			/* We have a previous parse span existing, store it */
+			store_span(&per_level_buffers[exec_nested_level].parse_span);
+		}
+
+		if (nested_query_start_time > 0 && (exec_nested_level + plan_nested_level) > 0)
+			start_parse_span = nested_query_start_time;
+		else
+			start_parse_span = GetCurrentStatementStartTimestamp();
+
+		/*
+		 * Parse should be at the same level as the top_span so we need to use
+		 * top_span's parent
+		 */
+		begin_span(trace_context->trace_id, parse_span, SPAN_PARSE, NULL, top_span->parent_id,
+				   per_level_buffers[exec_nested_level].query_id,
+				   &start_parse_span);
+		end_span(parse_span, &end_parse);
+	}
+
+	/* keep track of the previous parse level */
+	previous_parse_nested_level = exec_nested_level;
+}
+
+/*
+ * Planner hook
+ * Tracing can start here if the query skipped parsing (prepared statement) and passes the random sample_rate.
+ * If query is sampled, create a plan span and start the top span if not already started.
+ */
+static PlannedStmt *
+pg_tracing_planner_hook(Query *query,
+						const char *query_string,
+						int cursorOptions,
+						ParamListInfo params)
+{
+	PlannedStmt *result;
+	Span	   *top_span;
+	Span		span_planner;
+	pgTracingTraceContext *trace_context = &root_trace_context;
+	int64		start_span;
+
+	if (exec_nested_level > 0)
+		/* We're in a nested query, grab the ongoing trace_context */
+		trace_context = &current_trace_context;
+
+	/* Evaluate if query is sampled or not */
+	extract_trace_context(trace_context, NULL, params);
+
+	if (!pg_tracing_enabled(trace_context, plan_nested_level + exec_nested_level))
+	{
+		/* No sampling */
+		if (prev_planner_hook)
+			result = prev_planner_hook(query, query_string, cursorOptions,
+									   params);
+		else
+			result = standard_planner(query, query_string, cursorOptions,
+									  params);
+		return result;
+	}
+
+	start_span = GetCurrentTimestamp();
+
+	/*
+	 * We may have skipped parsing if statement was prepared, create a new top
+	 * span in this case.
+	 */
+	top_span = initialize_trace_level_and_top_span(trace_context, query->commandType, query,
+												   NULL, NULL, query_string, start_span, true);
+
+	/* Start planner span */
+	begin_span(trace_context->trace_id, &span_planner, SPAN_PLANNER,
+			   NULL, top_span->span_id,
+			   per_level_buffers[exec_nested_level].query_id, &start_span);
+
+	plan_nested_level++;
+	PG_TRY();
+	{
+		if (prev_planner_hook)
+			result = prev_planner_hook(query, query_string, cursorOptions,
+									   params);
+		else
+			result = standard_planner(query, query_string, cursorOptions,
+									  params);
+	}
+	PG_CATCH();
+	{
+		plan_nested_level--;
+		handle_pg_error(trace_context, &span_planner, NULL, NULL);
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+	plan_nested_level--;
+
+	/* End planner span */
+	end_and_store_span(&span_planner, NULL);
+
+	/* If we have a prepared statement, add bound parameters to the top span */
+	if (params != NULL && pg_tracing_export_parameters)
+	{
+		char	   *paramStr = BuildParamLogString(params,
+												   NULL, pg_tracing_max_parameter_str);
+
+		if (paramStr != NULL)
+			top_span->parameter_offset = add_str_to_trace_buffer(paramStr, strlen(paramStr));
+	}
+	return result;
+}
+
+/*
+ * ExecutorStart hook: Activate query instrumentation if query is sampled
+ * Tracing can be started here if the query used a cached plan and passes the random sample_rate.
+ * If query is sampled, start the top span if it doesn't already exist.
+ */
+static void
+pg_tracing_ExecutorStart(QueryDesc *queryDesc, int eflags)
+{
+	int			instrument_options;
+	pgTracingTraceContext *trace_context = &current_trace_context;
+	TimestampTz start_span = -1;
+	bool		is_lazy_function;
+
+	if (exec_nested_level + plan_nested_level == 0)
+	{
+		/* We're at the root level, copy trace context from parsing/planning */
+		*trace_context = root_trace_context;
+	}
+
+	/* Evaluate if query is sampled or not */
+	extract_trace_context(trace_context, NULL, queryDesc->params);
+
+	/*
+	 * We can detect the presence of lazy function through the node tag and
+	 * the executor flags. Lazy function will go through an ExecutorRun with
+	 * every call, possibly generating thousands of spans (ex: lazy call of
+	 * generate_series) which is not manageable and not very useful. If lazy
+	 * functions are detected, we don't instrument this node and no spans will
+	 * be generated.
+	 */
+	is_lazy_function = nodeTag(queryDesc->plannedstmt->planTree) == T_FunctionScan && eflags == EXEC_FLAG_SKIP_TRIGGERS;
+	if (pg_tracing_enabled(trace_context, exec_nested_level) && !is_lazy_function)
+	{
+		start_span = GetCurrentTimestamp();
+
+		if (trace_context->query_id != 0)
+
+			/*
+			 * TODO: Can this fail? Should we drop tracing if we detect
+			 * mismatch?
+			 */
+			Assert(trace_context->query_id == queryDesc->plannedstmt->queryId);
+
+		/*
+		 * In case of a cached plan, we haven't gone through neither parsing
+		 * nor planner hook. Parallel workers will also start tracing from
+		 * there. Create the top case in this case.
+		 */
+		initialize_trace_level_and_top_span(trace_context, queryDesc->operation,
+											NULL, NULL, NULL,
+											queryDesc->sourceText, start_span, false);
+
+		/*
+		 * Activate query instrumentation. Timer and rows instrumentation are
+		 * mandatory.
+		 */
+		instrument_options = INSTRUMENT_TIMER | INSTRUMENT_ROWS;
+		if (pg_tracing_instrument_buffers)
+			instrument_options |= INSTRUMENT_BUFFERS;
+		if (pg_tracing_instrument_wal)
+			instrument_options |= INSTRUMENT_WAL;
+		queryDesc->instrument_options = instrument_options;
+	}
+
+	if (prev_ExecutorStart)
+		prev_ExecutorStart(queryDesc, eflags);
+	else
+		standard_ExecutorStart(queryDesc, eflags);
+
+	if (start_span != -1)
+	{
+		/* Allocate totaltime instrumentation in the per-query context */
+		if (queryDesc->totaltime == NULL)
+		{
+			MemoryContext oldcxt;
+
+			oldcxt = MemoryContextSwitchTo(queryDesc->estate->es_query_cxt);
+			queryDesc->totaltime = InstrAlloc(1, instrument_options, false);
+			MemoryContextSwitchTo(oldcxt);
+		}
+	}
+}
+
+/*
+ * ExecutorRun hook: track nesting depth and create executor run span.
+ * If the plan needs to create parallel workers, push the trace context in the parallel shared buffer.
+ */
+static void
+pg_tracing_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction,
+					   uint64 count, bool execute_once)
+{
+	pgTracingTraceContext *trace_context = &current_trace_context;
+	bool		query_sampled = pg_tracing_enabled(trace_context, exec_nested_level);
+	bool		executor_sampled = query_sampled && queryDesc->instrument_options > 0;
+	TimestampTz start_span_time;
+	TimestampTz end_span_time;
+
+	if (query_sampled)
+	{
+		start_span_time = GetCurrentTimestamp();
+		nested_query_start_time = start_span_time;
+	}
+
+	if (executor_sampled)
+	{
+		/*
+		 * Executor run is used as the parent's span for nodes, store its' id
+		 * in the per level buffer.
+		 */
+		Span	   *executor_run_span = &per_level_buffers[exec_nested_level].executor_run;
+
+		/* Start executor run span */
+		begin_span(trace_context->trace_id, executor_run_span, SPAN_EXECUTOR_RUN,
+				   NULL, get_parent_id(trace_context, exec_nested_level),
+				   per_level_buffers[exec_nested_level].query_id,
+				   &start_span_time);
+
+		/*
+		 * If this query starts parallel worker, push the trace context for
+		 * the child processes
+		 */
+		if (queryDesc->plannedstmt->parallelModeNeeded && pg_tracing_trace_parallel_workers)
+			add_parallel_context(trace_context, executor_run_span->span_id,
+								 per_level_buffers[exec_nested_level].query_id);
+	}
+
+	exec_nested_level++;
+	PG_TRY();
+	{
+		if (prev_ExecutorRun)
+			prev_ExecutorRun(queryDesc, direction, count, execute_once);
+		else
+			standard_ExecutorRun(queryDesc, direction, count, execute_once);
+	}
+	PG_CATCH();
+	{
+		end_span_time = end_nested_span_and_decrease_nested_level();
+
+		/*
+		 * When a query is executing the pg_tracing_{peek,consume}_spans
+		 * function, sampling will be disabled while we have an ongoing trace
+		 * and current_trace_spans will be NULL.
+		 */
+		if (current_trace_spans != NULL && executor_sampled)
+			handle_pg_error(trace_context, &per_level_buffers[exec_nested_level].executor_run, queryDesc, &end_span_time);
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+	end_span_time = end_nested_span_and_decrease_nested_level();
+
+	/*
+	 * Same as above, tracing could have been aborted, check for
+	 * current_trace_spans
+	 */
+	if (current_trace_spans != NULL && executor_sampled)
+	{
+		Span	   *executor_run_span = &per_level_buffers[exec_nested_level].executor_run;
+
+		end_and_store_span(executor_run_span, &end_span_time);
+	}
+}
+
+/*
+ * ExecutorFinish hook: create executor finish span and track nesting depth.
+ * ExecutorFinish can start nested queries through triggers so we need
+ * to set the ExecutorFinish span as the top span.
+ */
+static void
+pg_tracing_ExecutorFinish(QueryDesc *queryDesc)
+{
+	pgTracingTraceContext *trace_context = &current_trace_context;
+	Span		previous_top_span;
+	Span	   *top_span;
+	bool		executor_sampled = pg_tracing_enabled(trace_context, exec_nested_level) && queryDesc->instrument_options > 0;
+
+	if (executor_sampled)
+	{
+		Span	   *executor_finish_span = &per_level_buffers[exec_nested_level].top_span;
+		TimestampTz start_span_time = GetCurrentTimestamp();
+
+		/* Save previous state of the top span */
+		previous_top_span = *executor_finish_span;
+		begin_span(trace_context->trace_id, executor_finish_span, SPAN_EXECUTOR_FINISH,
+				   NULL, previous_top_span.span_id,
+				   per_level_buffers[exec_nested_level].query_id, &start_span_time);
+		/* Set a possible start for nested query */
+		nested_query_start_time = start_span_time;
+	}
+
+	exec_nested_level++;
+	PG_TRY();
+	{
+		if (prev_ExecutorFinish)
+			prev_ExecutorFinish(queryDesc);
+		else
+			standard_ExecutorFinish(queryDesc);
+	}
+	PG_CATCH();
+	{
+		exec_nested_level--;
+		if (executor_sampled)
+			handle_pg_error(trace_context, &previous_top_span, queryDesc, NULL);
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+	exec_nested_level--;
+
+	if (!executor_sampled)
+		return;
+
+	top_span = get_top_span_for_nested_level(exec_nested_level);
+
+	/*
+	 * We only trace executorFinish when it has a nested query, check if we
+	 * have a possible child
+	 */
+	if (max_nested_level > exec_nested_level)
+	{
+		Span	   *nested_span = get_top_span_for_nested_level(exec_nested_level + 1);
+
+		/* Check if the child matches ExecutorFinish's id */
+		if (nested_span->parent_id == top_span->span_id)
+		{
+			/* ExecutorFinish has a child span, trace it */
+			end_top_span(NULL, &previous_top_span);
+			return;
+		}
+	}
+	/* Restore previous top span */
+	*top_span = previous_top_span;
+}
+
+/*
+ * ExecutorEnd hook will:
+ * - process queryDesc to generate span from planstate
+ * - end top span for the current nested level
+ * - end tracing if we're at the root nested level
+ */
+static void
+pg_tracing_ExecutorEnd(QueryDesc *queryDesc)
+{
+	pgTracingTraceContext *trace_context = &current_trace_context;
+	bool		tracing_enabled = pg_tracing_enabled(trace_context, exec_nested_level) && queryDesc->instrument_options > 0;
+
+	if (tracing_enabled)
+		process_query_desc(trace_context, queryDesc, 0);
+
+	exec_nested_level++;
+	if (prev_ExecutorEnd)
+		prev_ExecutorEnd(queryDesc);
+	else
+		standard_ExecutorEnd(queryDesc);
+	exec_nested_level--;
+
+	if (tracing_enabled)
+	{
+		TimestampTz end_span_time = GetCurrentTimestamp();
+		bool		overlapping_trace_context;
+		Span	   *top_span = get_top_span_for_nested_level(exec_nested_level);
+
+		/*
+		 * We may go through multiple statement nested in a single
+		 * ExecutorFinish (multiple triggers) so we need to update the
+		 * nested_start.
+		 */
+		nested_query_start_time = end_span_time;
+
+		/* End top span */
+		end_span(top_span, &end_span_time);
+
+		/*
+		 * if root trace context has a different root span index, it means
+		 * that we may have started to trace the next statement while still
+		 * processing the current one. This may happen with explicit
+		 * transaction using extended protocol, the parsing of the next
+		 * statement happens before the ExecutorEnd of the current statement.
+		 * In this case, we can't end tracing as we still have unfinished
+		 * spans.
+		 */
+		overlapping_trace_context = exec_nested_level == 0 &&
+			current_trace_context.root_span.span_id != root_trace_context.root_span.span_id && root_trace_context.sampled;
+		if (overlapping_trace_context)
+			store_span(top_span);
+		else
+			end_tracing(trace_context);
+	}
+}
+
+/*
+ * ProcessUtility hook
+ *
+ * Trace utility query if utility tracking is enabled and sampling was enabled
+ * during parse step.
+ * Process utility may create nested queries (for example function CALL) so we need
+ * to set the ProcessUtility span as the top span before going through the standard
+ * codepath.
+ */
+static void
+pg_tracing_ProcessUtility(PlannedStmt *pstmt, const char *queryString,
+						  bool readOnlyTree,
+						  ProcessUtilityContext context,
+						  ParamListInfo params, QueryEnvironment *queryEnv,
+						  DestReceiver *dest, QueryCompletion *qc)
+{
+	Span	   *process_utility_span;
+	Span		previous_top_span;
+	int64		end_span_time;
+	int64		start_span_time;
+	bool		track_utility = pg_tracing_track_utility;	/* Save track utility
+															 * value since this
+															 * value could be
+															 * modified by a SET */
+	pgTracingTraceContext *trace_context = &current_trace_context;
+
+	if (exec_nested_level + plan_nested_level == 0)
+		/* We're at root level, copy the root trace_context */
+		*trace_context = root_trace_context;
+	trace_context->in_aborted_transaction = IsAbortedTransactionBlockState();
+
+	if (!track_utility || !pg_tracing_enabled(trace_context, exec_nested_level))
+	{
+		/*
+		 * When utility tracking is disabled, we want to avoid tracing nested
+		 * queries created by the utility statement. Incrementing the nested
+		 * level will avoid starting a new nested trace while the root utility
+		 * wasn't traced
+		 */
+		if (!track_utility)
+			exec_nested_level++;
+		/* No sampling, just go through the standard process utility */
+		if (prev_ProcessUtility)
+			prev_ProcessUtility(pstmt, queryString, readOnlyTree,
+								context, params, queryEnv,
+								dest, qc);
+		else
+			standard_ProcessUtility(pstmt, queryString, readOnlyTree,
+									context, params, queryEnv,
+									dest, qc);
+		if (!track_utility)
+			exec_nested_level--;
+
+		/*
+		 * Tracing may have been started within the utility call without going
+		 * through ExecutorEnd (ex: prepare statement). Check and end tracing
+		 * here in this case.
+		 */
+		if (!pg_tracing_mem_ctx->isReset && exec_nested_level == 0)
+		{
+			Assert(current_trace_context.sampled || root_trace_context.sampled);
+			Assert(exec_nested_level == 0);
+			end_tracing(trace_context);
+		}
+		return;
+	}
+
+	/* Statement is sampled */
+	start_span_time = GetCurrentTimestamp();
+
+	/*
+	 * Set a possible start for nested query. ProcessUtility may start a
+	 * nested query and we can't use the statement start like we usually do.
+	 * We artificially start nested 1us later to avoid overlapping spans.
+	 */
+	nested_query_start_time = start_span_time;
+
+	/*
+	 * We need to set the process utility as the top span, save the previous
+	 * top span
+	 */
+	previous_top_span = *initialize_trace_level_and_top_span(trace_context, pstmt->commandType,
+															 NULL, NULL, pstmt, queryString, start_span_time, false);
+
+	Assert(previous_top_span.trace_id > 0);
+	process_utility_span = get_top_span_for_nested_level(exec_nested_level);
+
+	/* Build the process utility span. */
+	begin_span(trace_context->trace_id, process_utility_span, SPAN_PROCESS_UTILITY,
+			   NULL, get_parent_id(trace_context, exec_nested_level),
+			   per_level_buffers[exec_nested_level].query_id,
+			   &start_span_time);
+	Assert(previous_top_span.start <= process_utility_span->start);
+
+	exec_nested_level++;
+	PG_TRY();
+	{
+		if (prev_ProcessUtility)
+			prev_ProcessUtility(pstmt, queryString, readOnlyTree,
+								context, params, queryEnv,
+								dest, qc);
+		else
+			standard_ProcessUtility(pstmt, queryString, readOnlyTree,
+									context, params, queryEnv,
+									dest, qc);
+	}
+	PG_CATCH();
+	{
+		/*
+		 * Tracing may have been reset within processUtility, check for
+		 * current_trace_spans
+		 */
+		if (current_trace_spans != NULL)
+		{
+			end_span_time = end_nested_span_and_decrease_nested_level();
+			handle_pg_error(trace_context, &previous_top_span, NULL, &end_span_time);
+		}
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+
+	/* Same as above, abort if tracing was disabled within process utility */
+	if (current_trace_spans == NULL)
+	{
+		exec_nested_level--;
+		return;
+	}
+
+	end_span_time = end_nested_span_and_decrease_nested_level();
+
+	/* buffer may have been repalloced, grab a fresh pointer */
+	process_utility_span = get_top_span_for_nested_level(exec_nested_level);
+	if (qc != NULL)
+		process_utility_span->node_counters.rows = qc->nprocessed;
+
+	/* End process utility span */
+	end_top_span(&end_span_time, &previous_top_span);
+	/* End top span that was restored */
+	end_top_span(&end_span_time, NULL);
+
+	end_tracing(trace_context);
+
+	/*
+	 * We may iterate through a list of nested ProcessUtility calls, update
+	 * the nested query start.
+	 */
+	nested_query_start_time = end_span_time;
+}
+
+/*
+ * Iterate over a list of planstate to generate span node
+ */
+static TimestampTz
+generate_member_nodes(PlanState **planstates, int nplans, planstateTraceContext * planstateTraceContext, uint64 parent_id, TimestampTz parent_start, TimestampTz *latest_end)
+{
+	int			j;
+	TimestampTz child_end;
+
+	for (j = 0; j < nplans; j++)
+		child_end = generate_span_from_planstate(planstates[j], planstateTraceContext, parent_id, parent_start, latest_end);
+	return child_end;
+}
+
+/*
+ * Iterate over custom scan planstates to generate span node
+ */
+static TimestampTz
+generate_span_from_custom_scan(CustomScanState *css, planstateTraceContext * planstateTraceContext, uint64 parent_id, TimestampTz parent_start, TimestampTz *latest_end)
+{
+	ListCell   *cell;
+	TimestampTz last_end;
+
+	foreach(cell, css->custom_ps)
+		last_end = generate_span_from_planstate((PlanState *) lfirst(cell), planstateTraceContext, parent_id, parent_start, latest_end);
+	return last_end;
+}
+
+/*
+ * With nested queries, the post parse hook will be called before we know
+ * the top span parent. We will only know and the parent when we generate span nodes from planstate.
+ *
+ * When those nodes are created, we attach the top span.
+ */
+static void
+attach_top_span_to_new_parent(uint64 parent_id, TimestampTz parent_start, TimestampTz parent_end)
+{
+	Span	   *child_top_span;
+
+	if (exec_nested_level + 1 > max_nested_level)
+		/* No child to attach */
+		return;
+
+	child_top_span = &per_level_buffers[exec_nested_level + 1].top_span;
+	/* If child start after parent's end, don't link it */
+	if (parent_end < child_top_span->start)
+		return;
+	/* If child ends before parent's start, don't link it */
+	if (child_top_span->end < parent_start)
+		return;
+
+	/* Link this child to the new parent */
+	child_top_span->parent_id = parent_id;
+	/* Readjust top's end */
+	child_top_span->end = parent_end;
+}
+
+/*
+ * Attach an already existing parse span to a new parent.
+ *
+ * Parse span are created in the post_parse hook but we don't know
+ * its parent nor its exact start, we only have a good idea of its end.
+ *
+ * When processing the queryDesc, we can find possible parent candidate and
+ * attach the parse span. We need to adjust the parse span start to match
+ * the new parent.
+ *
+ * The parent node may have another child node (ProjectSet will have a Result
+ * outerplan node. The parse span will need to start after this child node.
+ */
+static void
+attach_parse_span_to_new_parent(uint64 parent_id, TimestampTz parent_start,
+								TimestampTz parent_end, TimestampTz new_start_time)
+{
+	Span	   *child_parse_span;
+
+	Assert(new_start_time <= parent_end);
+	if (exec_nested_level + 1 > max_nested_level)
+		/* No child to attach */
+		return;
+
+	/* Get child parse span */
+	child_parse_span = &per_level_buffers[exec_nested_level + 1].parse_span;
+	if (child_parse_span->trace_id == 0)
+		return;
+
+	/* If child start after parent's end, don't link it */
+	if (child_parse_span->start > parent_end)
+		return;
+
+	/* If child ends before parent's start, don't link it */
+	if (child_parse_span->end < parent_start)
+		return;
+
+	/* Check if child ends after parent's end */
+	if (child_parse_span->end > parent_end)
+		return;
+
+	/* Check if child ends before new start */
+	if (child_parse_span->end < new_start_time)
+		return;
+
+	/* Adjust span start */
+	child_parse_span->start = new_start_time;
+
+	/* Child span should already have ended */
+	Assert(child_parse_span->ended);
+	/* Link this child to the new parent */
+	child_parse_span->parent_id = parent_id;
+}
+
+
+/*
+ * Create span node for the provided planstate
+ */
+static Span
+create_span_node(PlanState *planstate, const planstateTraceContext * planstateTraceContext,
+				 uint64 *span_id, uint64 parent_id, SpanType span_type,
+				 char *subplan_name, TimestampTz *span_end)
+{
+	Span		span;
+	Plan const *plan = planstate->plan;
+	TimestampTz end_span_time;
+
+	/*
+	 * Make sure stats accumulation is done. Function is a no-op if if was
+	 * already done.
+	 */
+	InstrEndLoop(planstate->instrument);
+
+	/* We only create span node on node that were executed */
+	Assert(planstate->instrument->firsttime != 0);
+
+	if (span_end != NULL)
+		end_span_time = *span_end;
+	else if (planstate->instrument->total == 0)
+		end_span_time = GetCurrentTimestamp();
+	else
+		end_span_time = planstate->instrument->firsttime + planstate->instrument->total * US_IN_S;
+
+	begin_span(planstateTraceContext->trace_id, &span, span_type, span_id, parent_id,
+			   per_level_buffers[exec_nested_level].query_id,
+			   &planstate->instrument->firsttime);
+
+	/* first tuple time */
+	span.startup = planstate->instrument->startup * NS_PER_S;
+
+	if (span_type == SPAN_NODE)
+	{
+		/* Generate node specific variable strings and store them */
+		const char *node_type;
+		const char *deparse_info;
+		char const *operation_name;
+		int			deparse_info_len;
+
+		node_type = plan_to_node_type(plan);
+		span.node_type_offset = add_str_to_trace_buffer(node_type, strlen(node_type));
+
+		operation_name = plan_to_operation(planstateTraceContext, planstate, node_type);
+		span.operation_name_offset = add_str_to_trace_buffer(operation_name, strlen(operation_name));
+
+		/* deparse_ctx us NULL if deparsing was disabled */
+		if (planstateTraceContext->deparse_ctx != NULL)
+		{
+			deparse_info = plan_to_deparse_info(planstateTraceContext, planstate);
+			deparse_info_len = strlen(deparse_info);
+			if (deparse_info_len > 0)
+				span.deparse_info_offset = add_str_to_trace_buffer(deparse_info, deparse_info_len);
+		}
+	}
+	else if (subplan_name != NULL)
+		span.operation_name_offset = add_str_to_trace_buffer(subplan_name, strlen(subplan_name));
+
+	span.node_counters.rows = (int64) planstate->instrument->ntuples / planstate->instrument->nloops;
+	span.node_counters.nloops = (int64) planstate->instrument->nloops;
+	span.node_counters.buffer_usage = planstate->instrument->bufusage;
+	span.node_counters.wal_usage = planstate->instrument->walusage;
+
+	span.plan_counters.startup_cost = plan->startup_cost;
+	span.plan_counters.total_cost = plan->total_cost;
+	span.plan_counters.plan_rows = plan->plan_rows;
+	span.plan_counters.plan_width = plan->plan_width;
+
+	if (!planstate->state->es_finished)
+	{
+		/*
+		 * If the query is in an unfinished state, it means that we're in an
+		 * error handler. Stop the node instrumentation to get the latest
+		 * known state.
+		 */
+		if (!INSTR_TIME_IS_ZERO(planstate->instrument->starttime))
+			/* Don't stop the node if it wasn't started */
+			InstrStopNode(planstate->instrument, planstate->state->es_processed);
+		InstrEndLoop(planstate->instrument);
+		span.sql_error_code = planstateTraceContext->sql_error_code;
+	}
+	Assert(planstate->instrument->total > 0);
+	end_and_store_span(&span, &end_span_time);
+
+	return span;
+}
+
+/*
+ * Walk through the planstate tree generating a node span for each node.
+ * We pass possible error code to tag unfinished node with it.
+ */
+static TimestampTz
+generate_span_from_planstate(PlanState *planstate, planstateTraceContext * planstateTraceContext, uint64 parent_id, TimestampTz parent_start, TimestampTz *latest_end)
+{
+	ListCell   *l;
+	Plan const *plan = planstate->plan;
+	uint64		span_id;
+	TimestampTz span_start;
+	TimestampTz span_end;
+	TimestampTz outer_span_end = 0;
+
+	/* The node was never executed, skip it */
+	if (planstate->instrument == NULL || planstate->instrument->firsttime == 0)
+		return 0;
+
+	/*
+	 * Make sure stats accumulation is done. Function is a no-op if if was
+	 * already done.
+	 */
+	InstrEndLoop(planstate->instrument);
+
+	span_id = pg_prng_uint64(&pg_global_prng_state);
+	span_start = planstate->instrument->firsttime;
+	span_end = span_start + planstate->instrument->total * US_IN_S;
+	/* Keep track of the last child end */
+	if (*latest_end < span_end)
+		*latest_end = span_end;
+
+	Assert(parent_start <= span_start);
+	planstateTraceContext->ancestors = lcons(planstate->plan, planstateTraceContext->ancestors);
+
+	/* Walk the outerplan */
+	if (outerPlanState(planstate))
+		outer_span_end = generate_span_from_planstate(outerPlanState(planstate), planstateTraceContext, span_id, span_start, latest_end);
+	/* Walk the innerplan */
+	if (innerPlanState(planstate))
+		generate_span_from_planstate(innerPlanState(planstate), planstateTraceContext, span_id, span_start, latest_end);
+
+	/* Handle init plans */
+	foreach(l, planstate->initPlan)
+	{
+		SubPlanState *sstate = (SubPlanState *) lfirst(l);
+		PlanState  *splan = sstate->planstate;
+		Span		init_span;
+
+		if (splan->instrument->firsttime == 0)
+			continue;
+		init_span = create_span_node(splan, planstateTraceContext, NULL, parent_id, SPAN_NODE_INIT_PLAN, sstate->subplan->plan_name, NULL);
+		generate_span_from_planstate(splan, planstateTraceContext, init_span.span_id, init_span.start, latest_end);
+	}
+
+	/* Handle sub plans */
+	foreach(l, planstate->subPlan)
+	{
+		SubPlanState *sstate = (SubPlanState *) lfirst(l);
+		PlanState  *splan = sstate->planstate;
+		Span		subplan_span;
+
+		if (splan->instrument->firsttime == 0)
+			continue;
+		subplan_span = create_span_node(splan, planstateTraceContext, NULL, parent_id, SPAN_NODE_SUBPLAN, sstate->subplan->plan_name, NULL);
+		generate_span_from_planstate(splan, planstateTraceContext, subplan_span.span_id, subplan_span.start, latest_end);
+	}
+
+	/* Handle special nodes with children nodes */
+	switch (nodeTag(plan))
+	{
+		case T_Append:
+			generate_member_nodes(((AppendState *) planstate)->appendplans,
+								  ((AppendState *) planstate)->as_nplans, planstateTraceContext, span_id, span_start, latest_end);
+			break;
+		case T_MergeAppend:
+			generate_member_nodes(((MergeAppendState *) planstate)->mergeplans,
+								  ((MergeAppendState *) planstate)->ms_nplans, planstateTraceContext, span_id, span_start, latest_end);
+			break;
+		case T_BitmapAnd:
+			generate_member_nodes(((BitmapAndState *) planstate)->bitmapplans,
+								  ((BitmapAndState *) planstate)->nplans, planstateTraceContext, span_id, span_start, latest_end);
+			break;
+		case T_BitmapOr:
+			generate_member_nodes(((BitmapOrState *) planstate)->bitmapplans,
+								  ((BitmapOrState *) planstate)->nplans, planstateTraceContext, span_id, span_start, latest_end);
+			break;
+		case T_SubqueryScan:
+			generate_span_from_planstate(((SubqueryScanState *) planstate)->subplan, planstateTraceContext, span_id, span_start, latest_end);
+			break;
+		case T_CustomScan:
+			generate_span_from_custom_scan((CustomScanState *) planstate, planstateTraceContext, span_id, span_start, latest_end);
+			break;
+		default:
+			break;
+	}
+	planstateTraceContext->ancestors = list_delete_first(planstateTraceContext->ancestors);
+
+	/* If node had no duration, use the latest end of its child */
+	if (planstate->instrument->total == 0)
+		span_end = *latest_end;
+
+	/*
+	 * If we have a Result or ProjectSet node, make it the span parent of the
+	 * next query span if we have any
+	 *
+	 * TODO: Do we have other node that could be the base for nested queries?
+	 */
+	if (nodeTag(plan) == T_Result || nodeTag(plan) == T_ProjectSet)
+	{
+		attach_top_span_to_new_parent(span_id, span_start, span_end);
+		if (nodeTag(plan) == T_ProjectSet)
+		{
+			/* We should have an outer span with a ProjectSet */
+			Assert(outer_span_end > 0);
+
+			/*
+			 * A parse may happen within a projectset during function exec.
+			 * Try to attach existing child parse to the project set node.
+			 */
+			attach_parse_span_to_new_parent(span_id, span_start, span_end, outer_span_end);
+		}
+		else
+			attach_parse_span_to_new_parent(span_id, span_start, span_end, span_start);
+	}
+
+	create_span_node(planstate, planstateTraceContext, &span_id, parent_id, SPAN_NODE, NULL, &span_end);
+	return span_end;
+}
+
+/*
+ * Add plan counters to the Datum output
+ */
+static int
+add_plan_counters(const PlanCounters * plan_counters, int i, Datum *values)
+{
+	values[i++] = Float8GetDatumFast(plan_counters->startup_cost);
+	values[i++] = Float8GetDatumFast(plan_counters->total_cost);
+	values[i++] = Float8GetDatumFast(plan_counters->plan_rows);
+	values[i++] = Int32GetDatum(plan_counters->plan_width);
+	return i;
+}
+
+/*
+ * Add node counters to the Datum output
+ */
+static int
+add_node_counters(const NodeCounters * node_counters, int i, Datum *values)
+{
+	Datum		wal_bytes;
+	char		buf[256];
+	double		blk_read_time,
+				blk_write_time,
+				temp_blk_read_time,
+				temp_blk_write_time;
+	double		generation_counter,
+				inlining_counter,
+				optimization_counter,
+				emission_counter;
+	int64		jit_created_functions;
+
+	values[i++] = Int64GetDatumFast(node_counters->rows);
+	values[i++] = Int64GetDatumFast(node_counters->nloops);
+
+	/* Buffer usage */
+	values[i++] = Int64GetDatumFast(node_counters->buffer_usage.shared_blks_hit);
+	values[i++] = Int64GetDatumFast(node_counters->buffer_usage.shared_blks_read);
+	values[i++] = Int64GetDatumFast(node_counters->buffer_usage.shared_blks_dirtied);
+	values[i++] = Int64GetDatumFast(node_counters->buffer_usage.shared_blks_written);
+
+	values[i++] = Int64GetDatumFast(node_counters->buffer_usage.local_blks_hit);
+	values[i++] = Int64GetDatumFast(node_counters->buffer_usage.local_blks_read);
+	values[i++] = Int64GetDatumFast(node_counters->buffer_usage.local_blks_dirtied);
+	values[i++] = Int64GetDatumFast(node_counters->buffer_usage.local_blks_written);
+
+	blk_read_time = INSTR_TIME_GET_MILLISEC(node_counters->buffer_usage.shared_blk_read_time);
+	blk_write_time = INSTR_TIME_GET_MILLISEC(node_counters->buffer_usage.shared_blk_write_time);
+	temp_blk_read_time = INSTR_TIME_GET_MILLISEC(node_counters->buffer_usage.temp_blk_read_time);
+	temp_blk_write_time = INSTR_TIME_GET_MILLISEC(node_counters->buffer_usage.temp_blk_write_time);
+
+	values[i++] = Float8GetDatumFast(blk_read_time);
+	values[i++] = Float8GetDatumFast(blk_write_time);
+	values[i++] = Float8GetDatumFast(temp_blk_read_time);
+	values[i++] = Float8GetDatumFast(temp_blk_write_time);
+
+	values[i++] = Int64GetDatumFast(node_counters->buffer_usage.temp_blks_read);
+	values[i++] = Int64GetDatumFast(node_counters->buffer_usage.temp_blks_written);
+
+	/* WAL usage */
+	values[i++] = Int64GetDatumFast(node_counters->wal_usage.wal_records);
+	values[i++] = Int64GetDatumFast(node_counters->wal_usage.wal_fpi);
+	snprintf(buf, sizeof buf, UINT64_FORMAT, node_counters->wal_usage.wal_bytes);
+
+	/* Convert to numeric. */
+	wal_bytes = DirectFunctionCall3(numeric_in,
+									CStringGetDatum(buf),
+									ObjectIdGetDatum(0),
+									Int32GetDatum(-1));
+	values[i++] = wal_bytes;
+
+	/* JIT usage */
+	generation_counter = INSTR_TIME_GET_MILLISEC(node_counters->jit_usage.generation_counter);
+	inlining_counter = INSTR_TIME_GET_MILLISEC(node_counters->jit_usage.inlining_counter);
+	optimization_counter = INSTR_TIME_GET_MILLISEC(node_counters->jit_usage.optimization_counter);
+	emission_counter = INSTR_TIME_GET_MILLISEC(node_counters->jit_usage.emission_counter);
+	jit_created_functions = node_counters->jit_usage.created_functions;
+
+	values[i++] = Int64GetDatumFast(jit_created_functions);
+	values[i++] = Float8GetDatumFast(generation_counter);
+	values[i++] = Float8GetDatumFast(inlining_counter);
+	values[i++] = Float8GetDatumFast(optimization_counter);
+	values[i++] = Float8GetDatumFast(emission_counter);
+
+	return i;
+}
+
+/*
+ * Build the tuple for a Span and add it to the output
+ */
+static void
+add_result_span(ReturnSetInfo *rsinfo, Span * span,
+				const char *qbuffer, Size qbuffer_size)
+{
+#define PG_TRACING_TRACES_COLS	44
+	Datum		values[PG_TRACING_TRACES_COLS] = {0};
+	bool		nulls[PG_TRACING_TRACES_COLS] = {0};
+	const char *span_type;
+	const char *operation_name;
+	const char *sql_error_code;
+	int			i = 0;
+
+	span_type = get_span_type(span, qbuffer, qbuffer_size);
+	operation_name = get_operation_name(span, qbuffer, qbuffer_size);
+	sql_error_code = unpack_sql_state(span->sql_error_code);
+
+
+	Assert(span_type != NULL);
+	Assert(operation_name != NULL);
+	Assert(sql_error_code != NULL);
+
+	values[i++] = UInt64GetDatum(span->trace_id);
+	values[i++] = UInt64GetDatum(span->parent_id);
+	values[i++] = UInt64GetDatum(span->span_id);
+	values[i++] = UInt64GetDatum(span->query_id);
+	values[i++] = CStringGetTextDatum(span_type);
+	values[i++] = CStringGetTextDatum(operation_name);
+	values[i++] = Int64GetDatumFast(span->start);
+	values[i++] = Int64GetDatumFast(span->end);
+
+	values[i++] = CStringGetTextDatum(sql_error_code);
+	values[i++] = UInt32GetDatum(span->be_pid);
+	values[i++] = ObjectIdGetDatum(span->user_id);
+	values[i++] = ObjectIdGetDatum(span->database_id);
+	values[i++] = UInt8GetDatum(span->subxact_count);
+
+	if ((span->type >= SPAN_NODE && span->type <= SPAN_NODE_UNKNOWN)
+		|| span->type == SPAN_PLANNER)
+	{
+		i = add_plan_counters(&span->plan_counters, i, values);
+		i = add_node_counters(&span->node_counters, i, values);
+
+		values[i++] = Int64GetDatumFast(span->startup);
+		if (span->parameter_offset != -1 && qbuffer_size > 0 && qbuffer_size > span->parameter_offset)
+			values[i++] = CStringGetTextDatum(qbuffer + span->parameter_offset);
+		else
+			nulls[i++] = 1;
+		if (span->deparse_info_offset != -1 && qbuffer_size > 0 && qbuffer_size > span->deparse_info_offset)
+			values[i++] = CStringGetTextDatum(qbuffer + span->deparse_info_offset);
+	}
+
+	for (int j = i; j < PG_TRACING_TRACES_COLS; j++)
+		nulls[j] = 1;
+
+	tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls);
+}
+
+/*
+ * Return spans as a result set.
+ *
+ * Accept a consume parameter. When consume is set,
+ * we empty the shared buffer and truncate query text.
+ */
+Datum
+pg_tracing_spans(PG_FUNCTION_ARGS)
+{
+	bool		consume;
+	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
+	Span	   *span;
+	const char *qbuffer;
+	Size		qbuffer_size = 0;
+
+	consume = PG_GETARG_BOOL(0);
+	if (!pg_tracing)
+		ereport(ERROR,
+				(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+				 errmsg("pg_tracing must be loaded via shared_preload_libraries")));
+	InitMaterializedSRF(fcinfo, 0);
+
+	/*
+	 * If this query was sampled and we're consuming tracing_spans buffer, the
+	 * spans will target a query string that doesn't exist anymore in the
+	 * query file. Better abort the sampling, clean ongoing traces and remove
+	 * any possible parallel context pushed. Since this will be called within
+	 * an ExecutorRun, we will need to check for current_trace_spans at the
+	 * end of the ExecutorRun hook.
+	 */
+	cleanup_tracing();
+
+	qbuffer = qtext_load_file(&qbuffer_size);
+	{
+		volatile	pgTracingSharedState *s = (volatile pgTracingSharedState *) pg_tracing;
+
+		SpinLockAcquire(&s->mutex);
+		for (int i = 0; i < shared_spans->end; i++)
+		{
+			span = shared_spans->spans + i;
+			add_result_span(rsinfo, span, qbuffer, qbuffer_size);
+		}
+
+		/* Consume is set, remove spans from the shared buffer */
+		if (consume)
+		{
+			shared_spans->end = 0;
+			/* We only truncate query file if there's no active writers */
+			if (s->n_writers == 0)
+			{
+				s->extent = 0;
+				pg_truncate(PG_TRACING_TEXT_FILE, 0);
+			}
+			else
+				s->stats.failed_truncates++;
+		}
+		s->stats.last_consume = GetCurrentTimestamp();
+		SpinLockRelease(&s->mutex);
+	}
+	return (Datum) 0;
+}
+
+/*
+ * Return statistics of pg_tracing.
+ */
+Datum
+pg_tracing_info(PG_FUNCTION_ARGS)
+{
+#define PG_TRACING_INFO_COLS	6
+	pgTracingStats stats;
+	TupleDesc	tupdesc;
+	Datum		values[PG_TRACING_INFO_COLS] = {0};
+	bool		nulls[PG_TRACING_INFO_COLS] = {0};
+	int			i = 0;
+
+	if (!pg_tracing)
+		ereport(ERROR,
+				(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+				 errmsg("pg_tracing must be loaded via shared_preload_libraries")));
+
+	/* Build a tuple descriptor for our result type */
+	if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
+		elog(ERROR, "return type must be a row type");
+
+	/* Get a copy of the pg_tracing stats */
+	{
+		volatile	pgTracingSharedState *s = (volatile pgTracingSharedState *) pg_tracing;
+
+		SpinLockAcquire(&s->mutex);
+		stats = s->stats;
+		SpinLockRelease(&s->mutex);
+	}
+
+	values[i++] = Int64GetDatum(stats.traces);
+	values[i++] = Int64GetDatum(stats.spans);
+	values[i++] = Int64GetDatum(stats.dropped_spans);
+	values[i++] = Int64GetDatum(stats.failed_truncates);
+	values[i++] = TimestampTzGetDatum(stats.last_consume);
+	values[i++] = TimestampTzGetDatum(stats.stats_reset);
+
+	PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
+}
+
+/*
+ * Get an empty pgTracingStats
+ */
+static pgTracingStats
+get_empty_pg_tracing_stats(void)
+{
+	pgTracingStats stats;
+
+	stats.traces = 0;
+	stats.spans = 0;
+	stats.dropped_spans = 0;
+	stats.failed_truncates = 0;
+	stats.last_consume = 0;
+	stats.stats_reset = GetCurrentTimestamp();
+	return stats;
+}
+
+/*
+ * Reset pg_tracing statistics.
+ */
+Datum
+pg_tracing_reset(PG_FUNCTION_ARGS)
+{
+	/*
+	 * Reset statistics for pg_tracing since all entries are removed.
+	 */
+	pgTracingStats empty_stats = get_empty_pg_tracing_stats();
+
+	{
+		volatile	pgTracingSharedState *s = (volatile pgTracingSharedState *) pg_tracing;
+
+		SpinLockAcquire(&s->mutex);
+		s->stats = empty_stats;
+		SpinLockRelease(&s->mutex);
+	}
+	PG_RETURN_VOID();
+}
diff --git a/contrib/pg_tracing/pg_tracing.conf b/contrib/pg_tracing/pg_tracing.conf
new file mode 100644
index 0000000000..ad6b5e7c1d
--- /dev/null
+++ b/contrib/pg_tracing/pg_tracing.conf
@@ -0,0 +1 @@
+shared_preload_libraries = 'pg_tracing'
diff --git a/contrib/pg_tracing/pg_tracing.control b/contrib/pg_tracing/pg_tracing.control
new file mode 100644
index 0000000000..efa78a6610
--- /dev/null
+++ b/contrib/pg_tracing/pg_tracing.control
@@ -0,0 +1,5 @@
+# pg_tracing extension
+comment = 'Distributed tracing for postgres'
+default_version = '1.0'
+module_pathname = '$libdir/pg_tracing'
+relocatable = true
diff --git a/contrib/pg_tracing/pg_tracing.h b/contrib/pg_tracing/pg_tracing.h
new file mode 100644
index 0000000000..90c2ff6106
--- /dev/null
+++ b/contrib/pg_tracing/pg_tracing.h
@@ -0,0 +1,43 @@
+/*-------------------------------------------------------------------------
+ * pg_tracing.h
+ *
+ * IDENTIFICATION
+ *	  contrib/pg_tracing/pg_tracing.h
+ *-------------------------------------------------------------------------
+ */
+#ifndef _PG_TRACING_H_
+#define _PG_TRACING_H_
+
+#include "postgres.h"
+#include "pg_tracing_span.h"
+
+#include "storage/s_lock.h"
+
+/*
+ * Global statistics for pg_tracing
+ */
+typedef struct pgTracingStats
+{
+	int64		traces;			/* number of traces processed */
+	int64		spans;			/* number of spans processed */
+	int64		dropped_spans;	/* number of dropped spans due to full buffer */
+	int64		failed_truncates;	/* number of failed query file truncates
+									 * due to active writer */
+	TimestampTz last_consume;	/* Last time the shared spans buffer was
+								 * consumed */
+	TimestampTz stats_reset;	/* Last time stats were reset */
+}			pgTracingStats;
+
+/*
+ * Global shared state
+ */
+typedef struct pgTracingSharedState
+{
+	slock_t		mutex;			/* protects shared stats fields and
+								 * shared_spans buffer */
+	Size		extent;			/* current extent of query file */
+	int			n_writers;		/* number of active writers to query file */
+	pgTracingStats stats;		/* global statistics for pg_tracing */
+}			pgTracingSharedState;
+
+#endif
diff --git a/contrib/pg_tracing/pg_tracing_explain.c b/contrib/pg_tracing/pg_tracing_explain.c
new file mode 100644
index 0000000000..3c7d3a428f
--- /dev/null
+++ b/contrib/pg_tracing/pg_tracing_explain.c
@@ -0,0 +1,552 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_tracing_explain.c
+ *
+ *
+ * Copyright (c) 2023, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  contrib/pg_tracing/pg_tracing_explain.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "pg_tracing_explain.h"
+
+#include "nodes/makefuncs.h"
+#include "utils/builtins.h"
+#include "parser/parsetree.h"
+#include "nodes/extensible.h"
+#include "utils/lsyscache.h"
+#include "utils/ruleutils.h"
+
+
+/*
+ * Add the target relation of a scan or modity node to the stringinfo
+ */
+static void
+ExplainTargetRel(const planstateTraceContext * planstateTraceContext, const PlanState *planstate, Index rti, StringInfo str)
+{
+	char	   *objectname = NULL;
+	char	   *namespace = NULL;
+	RangeTblEntry *rte;
+	char	   *refname;
+
+	List	   *rtable;
+
+	rtable = planstate->state->es_range_table;
+	rte = rt_fetch(rti, rtable);
+
+	refname = (char *) list_nth(planstateTraceContext->rtable_names, rti - 1);
+	if (refname == NULL)
+		refname = rte->eref->aliasname;
+
+	switch (nodeTag(planstate->plan))
+	{
+		case T_SeqScan:
+		case T_SampleScan:
+		case T_IndexScan:
+		case T_IndexOnlyScan:
+		case T_BitmapHeapScan:
+		case T_TidScan:
+		case T_TidRangeScan:
+		case T_ForeignScan:
+		case T_CustomScan:
+		case T_ModifyTable:
+			/* Assert it's on a real relation */
+			Assert(rte->rtekind == RTE_RELATION);
+			objectname = get_rel_name(rte->relid);
+			break;
+		case T_FunctionScan:
+			{
+				FunctionScan *fscan = (FunctionScan *) planstate->plan;
+
+				/* Assert it's on a RangeFunction */
+				Assert(rte->rtekind == RTE_FUNCTION);
+
+				/*
+				 * If the expression is still a function call of a single
+				 * function, we can get the real name of the function.
+				 * Otherwise, punt.  (Even if it was a single function call
+				 * originally, the optimizer could have simplified it away.)
+				 */
+				if (list_length(fscan->functions) == 1)
+				{
+					RangeTblFunction *rtfunc = (RangeTblFunction *) linitial(fscan->functions);
+
+					if (IsA(rtfunc->funcexpr, FuncExpr))
+					{
+						FuncExpr   *funcexpr = (FuncExpr *) rtfunc->funcexpr;
+						Oid			funcid = funcexpr->funcid;
+
+						objectname = get_func_name(funcid);
+					}
+				}
+			}
+			break;
+		case T_TableFuncScan:
+			Assert(rte->rtekind == RTE_TABLEFUNC);
+			objectname = "xmltable";
+			break;
+		case T_ValuesScan:
+			Assert(rte->rtekind == RTE_VALUES);
+			break;
+		case T_CteScan:
+			/* Assert it's on a non-self-reference CTE */
+			Assert(rte->rtekind == RTE_CTE);
+			Assert(!rte->self_reference);
+			objectname = rte->ctename;
+			break;
+		case T_NamedTuplestoreScan:
+			Assert(rte->rtekind == RTE_NAMEDTUPLESTORE);
+			objectname = rte->enrname;
+			break;
+		case T_WorkTableScan:
+			/* Assert it's on a self-reference CTE */
+			Assert(rte->rtekind == RTE_CTE);
+			Assert(rte->self_reference);
+			objectname = rte->ctename;
+			break;
+		default:
+			break;
+	}
+
+	appendStringInfoString(str, " on");
+	if (namespace != NULL)
+		appendStringInfo(str, " %s.%s", quote_identifier(namespace),
+						 quote_identifier(objectname));
+	else if (objectname != NULL)
+		appendStringInfo(str, " %s", quote_identifier(objectname));
+	if (objectname == NULL || strcmp(refname, objectname) != 0)
+		appendStringInfo(str, " %s", quote_identifier(refname));
+}
+
+/*
+ * Add the target of a Scan node to the stringinfo
+ */
+static void
+ExplainScanTarget(const planstateTraceContext * planstateTraceContext, const PlanState *planstate, const Scan *plan, StringInfo str)
+{
+	ExplainTargetRel(planstateTraceContext, planstate, plan->scanrelid, str);
+}
+
+/*
+ * Add the target of a ModifyTable node to the stringinfo
+ */
+static void
+ExplainModifyTarget(const planstateTraceContext * planstateTraceContext, const PlanState *planstate, const ModifyTable *plan, StringInfo str)
+{
+	ExplainTargetRel(planstateTraceContext, planstate, plan->nominalRelation, str);
+}
+
+/*
+ * Add some additioanl details about an IndexScan or IndexOnlyScan to the stringinfo
+ */
+static void
+ExplainIndexScanDetails(Oid indexId, ScanDirection indexorderdir,
+						StringInfo str)
+{
+	const char *indexname = get_rel_name(indexId);
+
+	if (ScanDirectionIsBackward(indexorderdir))
+		appendStringInfoString(str, " Backward");
+	appendStringInfo(str, " using %s", quote_identifier(indexname));
+}
+
+static void
+plan_to_rel_name(const PlanState *planstate, const planstateTraceContext * planstateTraceContext, StringInfo str)
+{
+	const Plan *plan = planstate->plan;
+
+	switch (nodeTag(plan))
+	{
+		case T_SeqScan:
+		case T_SampleScan:
+		case T_BitmapHeapScan:
+		case T_TidScan:
+		case T_TidRangeScan:
+		case T_SubqueryScan:
+		case T_FunctionScan:
+		case T_TableFuncScan:
+		case T_ValuesScan:
+		case T_CteScan:
+		case T_WorkTableScan:
+			ExplainScanTarget(planstateTraceContext, planstate, (Scan *) plan, str);
+			break;
+		case T_ForeignScan:
+		case T_CustomScan:
+			if (((Scan *) plan)->scanrelid > 0)
+				ExplainScanTarget(planstateTraceContext, planstate, (Scan *) plan, str);
+			break;
+		case T_IndexScan:
+			{
+				IndexScan  *indexscan = (IndexScan *) plan;
+
+				ExplainIndexScanDetails(indexscan->indexid,
+										indexscan->indexorderdir,
+										str);
+				ExplainScanTarget(planstateTraceContext, planstate, (Scan *) indexscan, str);
+			}
+			break;
+		case T_IndexOnlyScan:
+			{
+				IndexOnlyScan *indexonlyscan = (IndexOnlyScan *) plan;
+
+				ExplainIndexScanDetails(indexonlyscan->indexid,
+										indexonlyscan->indexorderdir,
+										str);
+				ExplainScanTarget(planstateTraceContext, planstate, (Scan *) indexonlyscan, str);
+			}
+			break;
+		case T_BitmapIndexScan:
+			{
+				BitmapIndexScan *bitmapindexscan = (BitmapIndexScan *) plan;
+				const char *indexname = get_rel_name(bitmapindexscan->indexid);
+
+				appendStringInfo(str, " on %s",
+								 quote_identifier(indexname));
+			}
+			break;
+		case T_ModifyTable:
+			ExplainModifyTarget(planstateTraceContext, planstate, (ModifyTable *) plan, str);
+			break;
+		case T_NestLoop:
+		case T_MergeJoin:
+		case T_HashJoin:
+			{
+				const char *jointype;
+
+				switch (((Join *) plan)->jointype)
+				{
+					case JOIN_INNER:
+						jointype = "Inner";
+						break;
+					case JOIN_LEFT:
+						jointype = "Left";
+						break;
+					case JOIN_FULL:
+						jointype = "Full";
+						break;
+					case JOIN_RIGHT:
+						jointype = "Right";
+						break;
+					case JOIN_SEMI:
+						jointype = "Semi";
+						break;
+					case JOIN_ANTI:
+						jointype = "Anti";
+						break;
+					case JOIN_RIGHT_ANTI:
+						jointype = "Right Anti";
+						break;
+					default:
+						jointype = "???";
+						break;
+				}
+				if (((Join *) plan)->jointype != JOIN_INNER)
+					appendStringInfo(str, " %s Join", jointype);
+				else if (!IsA(plan, NestLoop))
+					appendStringInfoString(str, " Join");
+			}
+			break;
+		case T_SetOp:
+			{
+				const char *setopcmd;
+
+				switch (((SetOp *) plan)->cmd)
+				{
+					case SETOPCMD_INTERSECT:
+						setopcmd = "Intersect";
+						break;
+					case SETOPCMD_INTERSECT_ALL:
+						setopcmd = "Intersect All";
+						break;
+					case SETOPCMD_EXCEPT:
+						setopcmd = "Except";
+						break;
+					case SETOPCMD_EXCEPT_ALL:
+						setopcmd = "Except All";
+						break;
+					default:
+						setopcmd = "???";
+						break;
+				}
+				appendStringInfo(str, " %s", setopcmd);
+			}
+			break;
+		default:
+			break;
+	}
+}
+
+static void
+add_scan_qual(StringInfo str, const PlanState *planstate, List *qual,
+			  const char *qlabel, List *ancestors, List *deparse_ctx,
+			  bool useprefix)
+{
+	List	   *context;
+	char	   *exprstr;
+	Node	   *node;
+
+	if (qual == NIL)
+		return;
+
+	node = (Node *) make_ands_explicit(qual);
+
+	if (deparse_ctx != NULL)
+	{
+		/* Set up deparsing context */
+		context = set_deparse_context_plan(deparse_ctx,
+										   planstate->plan, ancestors);
+
+		/* Deparse the expression */
+		exprstr = deparse_expression(node, context, useprefix, false);
+		if (str->len > 0)
+			appendStringInfoChar(str, '|');
+		appendStringInfoString(str, qlabel);
+		appendStringInfoString(str, exprstr);
+	}
+}
+
+const char *
+plan_to_deparse_info(const planstateTraceContext * planstateTraceContext, const PlanState *planstate)
+{
+	StringInfo	deparse_info = makeStringInfo();
+	Plan const *plan = planstate->plan;
+	List	   *ancestors = planstateTraceContext->ancestors;
+	List	   *deparse_ctx = planstateTraceContext->deparse_ctx;
+
+	switch (nodeTag(plan))
+	{
+		case T_IndexScan:
+			add_scan_qual(deparse_info, planstate, ((IndexScan *) plan)->indexqualorig, "Index Cond: ",
+						  ancestors, deparse_ctx, false);
+			break;
+		case T_IndexOnlyScan:
+			add_scan_qual(deparse_info, planstate, ((IndexOnlyScan *) plan)->indexqual, "Index Cond: ",
+						  ancestors, deparse_ctx, false);
+			break;
+		case T_BitmapIndexScan:
+			add_scan_qual(deparse_info, planstate, ((BitmapIndexScan *) plan)->indexqualorig, "Index Cond: ",
+						  ancestors, deparse_ctx, false);
+			break;
+		case T_BitmapHeapScan:
+			add_scan_qual(deparse_info, planstate, ((BitmapHeapScan *) plan)->bitmapqualorig, "Recheck Cond: ",
+						  ancestors, deparse_ctx, false);
+			break;
+		case T_SeqScan:
+		case T_ValuesScan:
+		case T_CteScan:
+		case T_NamedTuplestoreScan:
+		case T_WorkTableScan:
+		case T_SubqueryScan:
+		case T_Gather:
+		case T_GatherMerge:
+		case T_FunctionScan:
+		case T_TableFuncScan:
+		case T_TidRangeScan:
+		case T_ForeignScan:
+		case T_CustomScan:
+		case T_Agg:
+		case T_WindowAgg:
+		case T_Group:
+		case T_Result:
+			add_scan_qual(deparse_info, planstate, plan->qual, "Filter : ",
+						  ancestors, deparse_ctx, false);
+			break;
+		case T_NestLoop:
+			add_scan_qual(deparse_info, planstate, ((NestLoop *) plan)->join.joinqual, "Join Filter : ",
+						  ancestors, deparse_ctx, false);
+			add_scan_qual(deparse_info, planstate, plan->qual, "Filter : ",
+						  ancestors, deparse_ctx, false);
+			break;
+		case T_MergeJoin:
+			add_scan_qual(deparse_info, planstate, ((MergeJoin *) plan)->mergeclauses, "Merge Cond: ",
+						  ancestors, deparse_ctx, false);
+			add_scan_qual(deparse_info, planstate, ((MergeJoin *) plan)->join.joinqual, "Join Filter: ",
+						  ancestors, deparse_ctx, false);
+			add_scan_qual(deparse_info, planstate, plan->qual, "Filter : ",
+						  ancestors, deparse_ctx, false);
+			break;
+		case T_HashJoin:
+			add_scan_qual(deparse_info, planstate, ((HashJoin *) plan)->hashclauses, "Hash Cond: ",
+						  ancestors, deparse_ctx, false);
+			add_scan_qual(deparse_info, planstate, ((MergeJoin *) plan)->join.joinqual, "Join Filter: ",
+						  ancestors, deparse_ctx, false);
+			add_scan_qual(deparse_info, planstate, plan->qual, "Filter : ",
+						  ancestors, deparse_ctx, false);
+			break;
+		default:
+			break;
+	}
+	return deparse_info->data;
+}
+
+char const *
+plan_to_operation(const planstateTraceContext * planstateTraceContext, const PlanState *planstate, const char *span_type)
+{
+	StringInfo	operation_name = makeStringInfo();
+	Plan const *plan = planstate->plan;
+
+	if (plan->parallel_aware)
+		appendStringInfoString(operation_name, "Parallel ");
+	if (plan->async_capable)
+		appendStringInfoString(operation_name, "Async ");
+	appendStringInfoString(operation_name, span_type);
+
+	plan_to_rel_name(planstate, planstateTraceContext, operation_name);
+
+	return operation_name->data;
+}
+
+/*
+ * Get the node type name from a plan node
+ */
+const char *
+plan_to_node_type(const Plan *plan)
+{
+	const char *custom_name;
+
+	switch (nodeTag(plan))
+	{
+		case T_Result:
+			return "Result";
+		case T_ProjectSet:
+			return "ProjectSet";
+		case T_ModifyTable:
+			switch (((ModifyTable *) plan)->operation)
+			{
+				case CMD_INSERT:
+					return "Insert";
+				case CMD_UPDATE:
+					return "Update";
+				case CMD_DELETE:
+					return "Delete";
+				case CMD_MERGE:
+					return "Merge";
+				default:
+					return "???";
+			}
+		case T_Append:
+			return "Append";
+		case T_MergeAppend:
+			return "MergeAppend";
+		case T_RecursiveUnion:
+			return "RecursiveUnion";
+		case T_BitmapAnd:
+			return "BitmapAnd";
+		case T_BitmapOr:
+			return "BitmapOr";
+		case T_NestLoop:
+			return "NestedLoop";
+		case T_MergeJoin:
+			return "Merge";		/* "Join" gets added by jointype switch */
+		case T_HashJoin:
+			return "Hash";		/* "Join" gets added by jointype switch */
+		case T_SeqScan:
+			return "SeqScan";
+		case T_SampleScan:
+			return "SampleScan";
+		case T_Gather:
+			return "Gather";
+		case T_GatherMerge:
+			return "GatherMerge";
+		case T_IndexScan:
+			return "IndexScan";
+		case T_IndexOnlyScan:
+			return "IndexOnlyScan";
+		case T_BitmapIndexScan:
+			return "BitmapIndexScan";
+		case T_BitmapHeapScan:
+			return "BitmapHeapScan";
+		case T_TidScan:
+			return "TidScan";
+		case T_TidRangeScan:
+			return "TidRangeScan";
+		case T_SubqueryScan:
+			return "SubqueryScan";
+		case T_FunctionScan:
+			return "FunctionScan";
+		case T_TableFuncScan:
+			return "TableFunctionScan";
+		case T_ValuesScan:
+			return "ValuesScan";
+		case T_CteScan:
+			return "CTEScan";
+		case T_NamedTuplestoreScan:
+			return "NamedTuplestoreScan";
+		case T_WorkTableScan:
+			return "WorkTableScan";
+		case T_ForeignScan:
+			switch (((ForeignScan *) plan)->operation)
+			{
+				case CMD_SELECT:
+					return "ForeignScan";
+				case CMD_INSERT:
+					return "ForeignInsert";
+				case CMD_UPDATE:
+					return "ForeignUpdate";
+				case CMD_DELETE:
+					return "ForeignDelete";
+				default:
+					return "???";
+			}
+		case T_CustomScan:
+			custom_name = ((CustomScan *) plan)->methods->CustomName;
+			if (custom_name)
+				return psprintf("CustomScan (%s)", custom_name);
+			else
+				return "CustomScan";
+		case T_Material:
+			return "Materialize";
+		case T_Memoize:
+			return "Memoize";
+		case T_Sort:
+			return "Sort";
+		case T_IncrementalSort:
+			return "IncrementalSort";
+		case T_Group:
+			return "Group";
+		case T_Agg:
+			{
+				Agg		   *agg = (Agg *) plan;
+
+				switch (agg->aggstrategy)
+				{
+					case AGG_PLAIN:
+						return "Aggregate";
+					case AGG_SORTED:
+						return "GroupAggregate";
+					case AGG_HASHED:
+						return "HashAggregate";
+					case AGG_MIXED:
+						return "MixedAggregate";
+					default:
+						return "Aggregate ???";
+				}
+			}
+		case T_WindowAgg:
+			return "WindowAgg";
+		case T_Unique:
+			return "Unique";
+		case T_SetOp:
+			switch (((SetOp *) plan)->strategy)
+			{
+				case SETOP_SORTED:
+					return "SetOp";
+				case SETOP_HASHED:
+					return "HashSetOp";
+				default:
+					return "SetOp ???";
+			}
+		case T_LockRows:
+			return "LockRows";
+		case T_Limit:
+			return "Limit";
+		case T_Hash:
+			return "Hash";
+		default:
+			return "???";
+	}
+}
diff --git a/contrib/pg_tracing/pg_tracing_explain.h b/contrib/pg_tracing/pg_tracing_explain.h
new file mode 100644
index 0000000000..c7b5ba94e4
--- /dev/null
+++ b/contrib/pg_tracing/pg_tracing_explain.h
@@ -0,0 +1,21 @@
+#ifndef _PG_TRACING_EXPLAIN_H_
+#define _PG_TRACING_EXPLAIN_H_
+
+#include "pg_tracing_span.h"
+#include "executor/execdesc.h"
+
+/* Context needed when generating spans from planstate */
+typedef struct planstateTraceContext
+{
+	uint64		trace_id;
+	int			sql_error_code;
+	List	   *ancestors;
+	List	   *deparse_ctx;
+	List	   *rtable_names;
+}			planstateTraceContext;
+
+extern const char *plan_to_node_type(const Plan *plan);
+extern const char *plan_to_operation(const planstateTraceContext * planstateTraceContext, const PlanState *planstate, const char *spanName);
+extern const char *plan_to_deparse_info(const planstateTraceContext * planstateTraceContext, const PlanState *planstate);
+
+#endif
diff --git a/contrib/pg_tracing/pg_tracing_parallel.c b/contrib/pg_tracing/pg_tracing_parallel.c
new file mode 100644
index 0000000000..75cf4d6e91
--- /dev/null
+++ b/contrib/pg_tracing/pg_tracing_parallel.c
@@ -0,0 +1,103 @@
+/*-------------------------------------------------------------------------
+ * pg_tracing_parallel.c
+ *
+ * IDENTIFICATION
+ *	  contrib/pg_tracing/pg_tracing_parallel.c
+ *-------------------------------------------------------------------------
+ */
+#include "pg_tracing_parallel.h"
+
+#include "storage/shmem.h"
+#include "storage/spin.h"
+
+/* Shared buffer storing trace context for parallel workers. */
+static pgTracingParallelWorkers * pg_tracing_parallel = NULL;
+
+/* Index of the parallel worker context shared buffer if any */
+static int	parallel_context_index = -1;
+
+void
+pg_tracing_shmem_parallel_startup(void)
+{
+	bool		found_parallel;
+
+	/* We won't have more than max_parallel_workers workers */
+	pg_tracing_parallel = ShmemInitStruct("PgTracing Parallel Workers Context",
+										  sizeof(pgTracingParallelWorkers) + max_parallel_workers * sizeof(pgTracingParallelContext),
+										  &found_parallel);
+	if (!found_parallel)
+	{
+		SpinLockInit(&pg_tracing_parallel->mutex);
+		for (int i = 0; i < max_parallel_workers; i++)
+			pg_tracing_parallel->trace_contexts[i].leader_backend_id = InvalidBackendId;
+	}
+}
+
+/*
+ * Push trace context to the shared parallel worker buffer
+ */
+void
+add_parallel_context(const struct pgTracingTraceContext *trace_context,
+					 uint64 parent_id, uint64 query_id)
+{
+	volatile	pgTracingParallelWorkers *p = (volatile pgTracingParallelWorkers *) pg_tracing_parallel;
+
+	Assert(parallel_context_index == -1);
+	SpinLockAcquire(&p->mutex);
+	for (int i = 0; i < max_parallel_workers; i++)
+	{
+		volatile	pgTracingParallelContext *ctx = p->trace_contexts + i;
+
+		Assert(ctx->leader_backend_id != MyBackendId);
+		if (ctx->leader_backend_id != InvalidBackendId)
+			continue;
+		/* Slot is available */
+		parallel_context_index = i;
+		ctx->leader_backend_id = MyBackendId;
+		ctx->trace_context = *trace_context;
+		/* We don't need to propagate root span index to parallel workers */
+		ctx->trace_context.root_span.span_id = 0;
+		ctx->trace_context.parent_id = parent_id;
+		break;
+	}
+	SpinLockRelease(&p->mutex);
+}
+
+/*
+ * Remove parallel context for the current leader from the shared memory.
+ */
+void
+remove_parallel_context(void)
+{
+	if (parallel_context_index < 0)
+		/* No tracing of parallel workers */
+		return;
+	{
+		volatile	pgTracingParallelWorkers *p = (volatile pgTracingParallelWorkers *) pg_tracing_parallel;
+
+		SpinLockAcquire(&p->mutex);
+		p->trace_contexts[parallel_context_index].leader_backend_id = InvalidBackendId;
+		SpinLockRelease(&p->mutex);
+	}
+	parallel_context_index = -1;
+}
+
+/*
+ * If we're inside a parallel worker, check if the trace context is stored in shared memory.
+ * If a trace context exists, it means that the query is sampled and worker tracing is enabled.
+ */
+void
+fetch_parallel_context(pgTracingTraceContext * trace_context)
+{
+	volatile	pgTracingParallelWorkers *p = (volatile pgTracingParallelWorkers *) pg_tracing_parallel;
+
+	SpinLockAcquire(&p->mutex);
+	for (int i = 0; i < max_parallel_workers; i++)
+	{
+		if (p->trace_contexts[i].leader_backend_id != ParallelLeaderBackendId)
+			continue;
+		/* Found a matching a trace context, fetch it */
+		*trace_context = p->trace_contexts[i].trace_context;
+	}
+	SpinLockRelease(&p->mutex);
+}
diff --git a/contrib/pg_tracing/pg_tracing_parallel.h b/contrib/pg_tracing/pg_tracing_parallel.h
new file mode 100644
index 0000000000..5e9436a10d
--- /dev/null
+++ b/contrib/pg_tracing/pg_tracing_parallel.h
@@ -0,0 +1,44 @@
+/*-------------------------------------------------------------------------
+ * pg_tracing_parallel.h
+ *		Store, retrieve and remove trace context for parallel workers.
+ *
+ * IDENTIFICATION
+ *	  contrib/pg_tracing/pg_tracing_parallel.h
+ *-------------------------------------------------------------------------
+ */
+#ifndef _PG_TRACING_PARALLEL_H_
+#define _PG_TRACING_PARALLEL_H_
+
+#include "postgres.h"
+#include "pg_tracing_span.h"
+
+#include "storage/s_lock.h"
+#include "storage/backendid.h"
+
+/*
+ * A trace context for a specific parallel context
+ */
+typedef struct pgTracingParallelContext
+{
+	BackendId	leader_backend_id;	/* Backend id of the leader, set to
+									 * InvalidBackendId if unused */
+	pgTracingTraceContext trace_context;
+}			pgTracingParallelContext;
+
+/*
+ * Store context for parallel workers
+ */
+typedef struct pgTracingParallelWorkers
+{
+	slock_t		mutex;
+	pgTracingParallelContext trace_contexts[FLEXIBLE_ARRAY_MEMBER];
+}			pgTracingParallelWorkers;
+
+
+extern void pg_tracing_shmem_parallel_startup(void);
+extern void add_parallel_context(const struct pgTracingTraceContext *trace_context,
+								 uint64 parent_id, uint64 query_id);
+extern void remove_parallel_context(void);
+extern void fetch_parallel_context(pgTracingTraceContext * trace_context);
+
+#endif
diff --git a/contrib/pg_tracing/pg_tracing_query_process.c b/contrib/pg_tracing/pg_tracing_query_process.c
new file mode 100644
index 0000000000..7d76129b84
--- /dev/null
+++ b/contrib/pg_tracing/pg_tracing_query_process.c
@@ -0,0 +1,478 @@
+#include "pg_tracing_query_process.h"
+#include "pg_tracing.h"
+
+#include <sys/stat.h>
+#include <unistd.h>
+#include "parser/scanner.h"
+#include "nodes/extensible.h"
+
+/*
+ * Extract traceparent parameters from SQLCommenter
+ *
+ * We're expecting the query to start with a SQLComment containing the
+ * traceparent parameter
+ * "/\*traceparent='00-00000000000000000000000000000009-0000000000000005-01'*\/
+ * SELECT 1;"
+ * Traceparent has the following format: version-traceid-parentid-sampled
+ * We also accept SQLCommenter as a parameter. In this case, we don't have
+ * the start and end of comments.
+ *
+ * if is_parameter is true, the SQLComment is passed as a query parameter and
+ * won't have the comment start and end.
+ */
+void
+extract_trace_context_from_query(pgTracingTraceContext * trace_context, const char *sqlcomment_str, bool is_parameter)
+{
+	const char *expected_start = "/*";
+	const char *traceparent;
+	const char *end_sqlcomment;
+	char	   *endptr;
+
+	if (!is_parameter)
+	{
+		/*
+		 * Look for the start of a comment We're expecting the comment to be
+		 * at the very start of the query
+		 */
+		for (size_t i = 0; i < strlen(expected_start); i++)
+		{
+			if (sqlcomment_str[i] != expected_start[i])
+				return;
+		}
+
+		/*
+		 * Check that we have an end
+		 */
+		end_sqlcomment = strstr(sqlcomment_str, "*/");
+		if (end_sqlcomment == NULL)
+			return;
+	}
+	else
+		end_sqlcomment = sqlcomment_str + strlen(sqlcomment_str);
+
+	/*
+	 * Locate traceparent parameter and make sure it has the expected size
+	 * "traceparent" + "=" + '' -> 13 characters
+	 * 00-00000000000000000000000000000009-0000000000000005-01 -> 55
+	 * characters
+	 */
+	traceparent = strstr(sqlcomment_str, "traceparent='");
+	if (traceparent == NULL || traceparent > end_sqlcomment || end_sqlcomment - traceparent < 55 + 13)
+		return;
+
+	/*
+	 * Move to the start of the traceparent values
+	 */
+	traceparent = traceparent + 13;
+
+	/*
+	 * Check that '-' are at the expected places
+	 */
+	if (traceparent[2] != '-' || traceparent[35] != '-' || traceparent[52] != '-')
+		return;
+
+	/*
+	 * Parse traceparent parameters
+	 */
+	errno = 0;
+	trace_context->trace_id = strtol(&traceparent[3], &endptr, 16);
+	if (endptr != traceparent + 35 || errno)
+		return;
+	trace_context->parent_id = strtol(&traceparent[36], &endptr, 16);
+	if (endptr != traceparent + 52 || errno)
+		return;
+	trace_context->sampled = strtol(&traceparent[53], &endptr, 16);
+	if (endptr != traceparent + 55 || errno)
+
+		/*
+		 * Just to be sure, reset sampled on error
+		 */
+		trace_context->sampled = 0;
+}
+
+
+/*
+ * comp_location: comparator for qsorting LocationLen structs by location
+ */
+static int
+comp_location(const void *a, const void *b)
+{
+	int			l = ((const LocationLen *) a)->location;
+	int			r = ((const LocationLen *) b)->location;
+
+	if (l < r)
+		return -1;
+	else if (l > r)
+		return +1;
+	else
+		return 0;
+}
+
+
+/*
+ * Normalise query and fill param_str.
+ * Normalised query will separate tokens with a single space and
+ * parameters are replaced by $1, $2...
+ * Parameters are put in the param_str wich will contain all parameters values
+ * using the format: "$1 = 0, $2 = 'v'"
+ */
+const char *
+normalise_query_parameters(const JumbleState *jstate, const char *query,
+						   int query_loc, int *query_len_p, char **param_str, int *param_len)
+{
+	char	   *norm_query;
+	int			query_len = *query_len_p;
+	int			norm_query_buflen,	/* Space allowed for norm_query */
+				n_quer_loc = 0;
+	LocationLen *locs;
+	core_yyscan_t yyscanner;
+	core_yy_extra_type yyextra;
+	core_YYSTYPE yylval;
+	YYLTYPE		yylloc;
+	int			current_loc = 0;
+	StringInfoData buf;
+
+	initStringInfo(&buf);
+
+	if (query_loc == -1)
+	{
+		/* If query location is unknown, distrust query_len as well */
+		query_loc = 0;
+		query_len = strlen(query);
+	}
+	else
+	{
+		/* Length of 0 (or -1) means "rest of string" */
+		if (query_len <= 0)
+			query_len = strlen(query);
+		else
+			Assert(query_len <= strlen(query));
+	}
+
+	norm_query_buflen = query_len + jstate->clocations_count * 10;
+	Assert(norm_query_buflen > 0);
+	locs = jstate->clocations;
+
+	/* Allocate result buffer */
+	norm_query = palloc(norm_query_buflen + 1);
+
+	if (jstate->clocations_count > 1)
+		qsort(jstate->clocations, jstate->clocations_count,
+			  sizeof(LocationLen), comp_location);
+
+	/* initialize the flex scanner --- should match raw_parser() */
+	yyscanner = scanner_init(query + query_loc,
+							 &yyextra,
+							 &ScanKeywords,
+							 ScanKeywordTokens);
+
+	for (;;)
+	{
+		int			loc = locs[current_loc].location;
+		int			tok;
+
+		loc -= query_loc;
+
+		tok = core_yylex(&yylval, &yylloc, yyscanner);
+
+		/*
+		 * We should not hit end-of-string, but if we do, behave sanely
+		 */
+		if (tok == 0)
+			break;				/* out of inner for-loop */
+		if (yylloc > query_len)
+			break;
+
+		/*
+		 * We should find the token position exactly, but if we somehow run
+		 * past it, work with that.
+		 */
+		if (current_loc < jstate->clocations_count && yylloc >= loc)
+		{
+			appendStringInfo(&buf,
+							 "%s$%d = ",
+							 current_loc > 0 ? ", " : "",
+							 current_loc + 1);
+			if (query[loc] == '-')
+			{
+				/*
+				 * It's a negative value - this is the one and only case where
+				 * we replace more than a single token.
+				 *
+				 * Do not compensate for the core system's special-case
+				 * adjustment of location to that of the leading '-' operator
+				 * in the event of a negative constant.  It is also useful for
+				 * our purposes to start from the minus symbol.  In this way,
+				 * queries like "select * from foo where bar = 1" and "select *
+				 * from foo where bar = -2" will have identical normalized
+				 * query strings.
+				 */
+				appendStringInfoChar(&buf, '-');
+				tok = core_yylex(&yylval, &yylloc, yyscanner);
+				if (tok == 0)
+					break;		/* out of inner for-loop */
+			}
+			if (yylloc > 0 && yyextra.scanbuf[yylloc - 1] == ' ' && n_quer_loc > 0)
+			{
+				norm_query[n_quer_loc++] = ' ';
+			}
+
+			/*
+			 * Append the current parameter $x in the normalised query
+			 */
+			n_quer_loc += sprintf(norm_query + n_quer_loc, "$%d",
+								  current_loc + 1 + jstate->highest_extern_param_id);
+
+			appendStringInfoString(&buf, yyextra.scanbuf + yylloc);
+
+			current_loc++;
+		}
+		else
+		{
+			int			to_copy;
+
+			if (yylloc > 0 && yyextra.scanbuf[yylloc - 1] == ' ' && n_quer_loc > 0)
+			{
+				norm_query[n_quer_loc++] = ' ';
+			}
+			to_copy = strlen(yyextra.scanbuf + yylloc);
+			Assert(n_quer_loc + to_copy < norm_query_buflen + 1);
+			memcpy(norm_query + n_quer_loc, yyextra.scanbuf + yylloc, to_copy);
+			n_quer_loc += to_copy;
+		}
+	}
+	scanner_finish(yyscanner);
+
+	*query_len_p = n_quer_loc;
+	norm_query[n_quer_loc] = '\0';
+	*param_str = buf.data;
+	*param_len = buf.len;
+	return norm_query;
+}
+
+/*
+ * Normalise query: tokens will be separated by a single space
+ */
+const char *
+normalise_query(const char *query, int query_loc, int *query_len_p)
+{
+	char	   *norm_query;
+	int			query_len = *query_len_p;
+	int			norm_query_buflen = query_len;
+	int			n_quer_loc = 0;
+	core_yyscan_t yyscanner;
+	core_yy_extra_type yyextra;
+	core_YYSTYPE yylval;
+	YYLTYPE		yylloc;
+
+	/* Allocate result buffer */
+	norm_query = palloc(norm_query_buflen + 2);
+
+	/* initialize the flex scanner --- should match raw_parser() */
+	yyscanner = scanner_init(query + query_loc, &yyextra, &ScanKeywords, ScanKeywordTokens);
+	for (;;)
+	{
+		int			tok;
+		int			to_copy;
+
+		tok = core_yylex(&yylval, &yylloc, yyscanner);
+
+		if (tok == 0)
+			break;				/* out of inner for-loop */
+		if (yylloc > query_len)
+			break;
+
+		if (yylloc > 0 && yyextra.scanbuf[yylloc - 1] == ' ' && n_quer_loc > 0)
+		{
+			norm_query[n_quer_loc++] = ' ';
+		}
+		to_copy = strlen(yyextra.scanbuf + yylloc);
+		Assert(n_quer_loc + to_copy < norm_query_buflen + 2);
+		memcpy(norm_query + n_quer_loc, yyextra.scanbuf + yylloc, to_copy);
+		n_quer_loc += to_copy;
+	}
+	scanner_finish(yyscanner);
+
+	*query_len_p = n_quer_loc;
+	norm_query[n_quer_loc] = '\0';
+	return norm_query;
+}
+
+/*
+ * Store text in the pg_tracing stat file
+ */
+bool
+text_store_file(pgTracingSharedState * pg_tracing, const char *text, int text_len,
+				Size *query_offset)
+{
+	Size		off;
+	int			fd;
+
+	{
+		volatile	pgTracingSharedState *s = (volatile pgTracingSharedState *) pg_tracing;
+
+		SpinLockAcquire(&s->mutex);
+		off = s->extent;
+		s->extent += text_len + 1;
+		s->n_writers++;
+		SpinLockRelease(&s->mutex);
+	}
+
+	/*
+	 * Don't allow the file to grow larger than what qtext_load_file can
+	 * (theoretically) handle.  This has been seen to be reachable on 32-bit
+	 * platforms.
+	 */
+	if (unlikely(text_len >= MaxAllocHugeSize - off))
+	{
+		errno = EFBIG;			/* not quite right, but it'll do */
+		fd = -1;
+		goto error;
+	}
+
+	/* Now write the data into the successfully-reserved part of the file */
+	fd = OpenTransientFile(PG_TRACING_TEXT_FILE, O_RDWR | O_CREAT | PG_BINARY);
+	if (fd < 0)
+		goto error;
+
+	if (pg_pwrite(fd, text, text_len, off) != text_len)
+		goto error;
+	if (pg_pwrite(fd, "\0", 1, off + text_len) != 1)
+		goto error;
+
+	CloseTransientFile(fd);
+
+	/* Mark our write complete */
+	{
+		volatile	pgTracingSharedState *s = (volatile pgTracingSharedState *) pg_tracing;
+
+		SpinLockAcquire(&s->mutex);
+		s->n_writers--;
+		SpinLockRelease(&s->mutex);
+	}
+
+	/*
+	 * Set offset once write was succesful
+	 */
+	*query_offset = off;
+
+	return true;
+
+error:
+	ereport(LOG,
+			(errcode_for_file_access(),
+			 errmsg("could not write file \"%s\": %m",
+					PG_TRACING_TEXT_FILE)));
+
+	if (fd >= 0)
+		CloseTransientFile(fd);
+
+	/* Mark our write complete */
+	{
+		volatile	pgTracingSharedState *s = (volatile pgTracingSharedState *) pg_tracing;
+
+		SpinLockAcquire(&s->mutex);
+		s->n_writers--;
+		SpinLockRelease(&s->mutex);
+	}
+
+	return false;
+}
+
+/*
+ * Read the external query text file into a malloc'd buffer.
+ *
+ * Returns NULL (without throwing an error) if unable to read, eg file not
+ * there or insufficient memory.
+ *
+ * On success, the buffer size is also returned into *buffer_size.
+ *
+ * This can be called without any lock on pgss->lock, but in that case the
+ * caller is responsible for verifying that the result is sane.
+ */
+const char *
+qtext_load_file(Size *buffer_size)
+{
+	char	   *buf;
+	int			fd;
+	struct stat stat;
+	Size		nread;
+
+	fd = OpenTransientFile(PG_TRACING_TEXT_FILE, O_RDONLY | PG_BINARY);
+	if (fd < 0)
+	{
+		if (errno != ENOENT)
+			ereport(LOG,
+					(errcode_for_file_access(),
+					 errmsg("could not read file \"%s\": %m",
+							PG_TRACING_TEXT_FILE)));
+		return NULL;
+	}
+
+	/* Get file length */
+	if (fstat(fd, &stat))
+	{
+		ereport(LOG,
+				(errcode_for_file_access(),
+				 errmsg("could not stat file \"%s\": %m",
+						PG_TRACING_TEXT_FILE)));
+		CloseTransientFile(fd);
+		return NULL;
+	}
+
+	/* Allocate buffer; beware that off_t might be wider than size_t */
+	if (stat.st_size <= MaxAllocHugeSize)
+		buf = (char *) malloc(stat.st_size);
+	else
+		buf = NULL;
+	if (buf == NULL)
+	{
+		ereport(LOG,
+				(errcode(ERRCODE_OUT_OF_MEMORY),
+				 errmsg("out of memory"),
+				 errdetail("Could not allocate enough memory to read file \"%s\".",
+						   PG_TRACING_TEXT_FILE)));
+		CloseTransientFile(fd);
+		return NULL;
+	}
+
+	/*
+	 * OK, slurp in the file.  Windows fails if we try to read more than
+	 * INT_MAX bytes at once, and other platforms might not like that either,
+	 * so read a very large file in 1GB segments.
+	 */
+	nread = 0;
+	while (nread < stat.st_size)
+	{
+		int			toread = Min(1024 * 1024 * 1024, stat.st_size - nread);
+
+		/*
+		 * If we get a short read and errno doesn't get set, the reason is
+		 * probably that garbage collection truncated the file since we did
+		 * the fstat(), so we don't log a complaint --- but we don't return
+		 * the data, either, since it's most likely corrupt due to concurrent
+		 * writes from garbage collection.
+		 */
+		errno = 0;
+		if (read(fd, buf + nread, toread) != toread)
+		{
+			if (errno)
+				ereport(LOG,
+						(errcode_for_file_access(),
+						 errmsg("could not read file \"%s\": %m",
+								PG_TRACING_TEXT_FILE)));
+			free(buf);
+			CloseTransientFile(fd);
+			return NULL;
+		}
+		nread += toread;
+	}
+
+	if (CloseTransientFile(fd) != 0)
+		ereport(LOG,
+				(errcode_for_file_access(),
+				 errmsg("could not close file \"%s\": %m", PG_TRACING_TEXT_FILE)));
+
+	*buffer_size = nread;
+	return buf;
+}
diff --git a/contrib/pg_tracing/pg_tracing_query_process.h b/contrib/pg_tracing/pg_tracing_query_process.h
new file mode 100644
index 0000000000..bf568f97e9
--- /dev/null
+++ b/contrib/pg_tracing/pg_tracing_query_process.h
@@ -0,0 +1,30 @@
+#ifndef _QUERY_PROCESS_H_
+#define _QUERY_PROCESS_H_
+
+#include "pg_tracing.h"
+#include "nodes/queryjumble.h"
+#include "parser/parse_node.h"
+
+/*
+ * Normalise query: - Comments are removed - Constants are replaced by $x -
+ * All tokens are separated by a single space
+ */
+extern const char *normalise_query_parameters(const JumbleState *jstate, const char *query,
+											  int query_loc, int *query_len_p, char **param_str,
+											  int *param_len);
+
+extern void extract_trace_context_from_query(pgTracingTraceContext * trace_context, const char *query_str, bool is_parameter);
+
+/*
+ * Normalise simple query
+ */
+extern const char *normalise_query(const char *query, int query_loc, int *query_len_p);
+bool		text_store_file(pgTracingSharedState * pg_tracing, const char *query,
+							int query_len, Size *query_offset);
+extern const char *qtext_load_file(Size *buffer_size);
+extern const char *qtext_load_file(Size *buffer_size);
+
+/* Location of external text file */
+#define PG_TRACING_TEXT_FILE	PG_STAT_TMP_DIR "/pg_tracing.stat"
+
+#endif
diff --git a/contrib/pg_tracing/pg_tracing_span.c b/contrib/pg_tracing/pg_tracing_span.c
new file mode 100644
index 0000000000..0127ec79d3
--- /dev/null
+++ b/contrib/pg_tracing/pg_tracing_span.c
@@ -0,0 +1,261 @@
+#include "pg_tracing_span.h"
+
+#include "nodes/extensible.h"
+#include "common/pg_prng.h"
+
+
+/*
+ * Convert a node CmdType to the matching SpanType
+ */
+SpanType
+command_type_to_span_type(CmdType cmd_type)
+{
+	switch (cmd_type)
+	{
+		case CMD_SELECT:
+			return SPAN_NODE_SELECT;
+		case CMD_INSERT:
+			return SPAN_NODE_INSERT;
+		case CMD_UPDATE:
+			return SPAN_NODE_UPDATE;
+		case CMD_DELETE:
+			return SPAN_NODE_DELETE;
+		case CMD_MERGE:
+			return SPAN_NODE_MERGE;
+		case CMD_UTILITY:
+			return SPAN_NODE_UTILITY;
+		case CMD_NOTHING:
+			return SPAN_NODE_NOTHING;
+		case CMD_UNKNOWN:
+			return SPAN_NODE_UNKNOWN;
+	}
+	return SPAN_NODE_UNKNOWN;
+}
+
+/*
+ * Initialize span fields
+ */
+static void
+initialize_span_fields(Span * span, SpanType type, uint64 trace_id, uint64 *span_id, uint64 parent_id, uint64 query_id)
+{
+	span->trace_id = trace_id;
+	span->type = type;
+
+	/*
+	 * If parent id is unset, it means that there's no propagated trace
+	 * informations from the caller. In this case, this is the top span,
+	 * span_id == parent_id and we reuse the generated trace id for the span
+	 * id.
+	 */
+	if (parent_id == 0)
+		span->parent_id = trace_id;
+	else
+		span->parent_id = parent_id;
+	if (span_id != NULL)
+		span->span_id = *span_id;
+	else
+		span->span_id = pg_prng_uint64(&pg_global_prng_state);
+
+	span->node_type_offset = -1;
+	span->operation_name_offset = -1;
+	span->deparse_info_offset = -1;
+	span->parameter_offset = -1;
+	span->sql_error_code = 0;
+	span->startup = 0;
+	span->be_pid = MyProcPid;
+	span->database_id = MyDatabaseId;
+	span->user_id = GetUserId();
+	span->subxact_count = MyProc->subxidStatus.count;
+	span->ended = false;
+	span->query_id = query_id;
+	memset(&span->node_counters, 0, sizeof(NodeCounters));
+	memset(&span->plan_counters, 0, sizeof(PlanCounters));
+
+	/*
+	 * Store the starting buffer for planner and process utility spans
+	 *
+	 * TODO: Do we need wal buffer for planner?
+	 */
+	if (type == SPAN_PLANNER || span->type == SPAN_PROCESS_UTILITY)
+	{
+		/* TODO Do we need to track wal for planner? */
+		span->node_counters.buffer_usage = pgBufferUsage;
+		span->node_counters.wal_usage = pgWalUsage;
+	}
+}
+
+/*
+ * Initialize span and set span starting time.
+ *
+ * A span needs a start timestamp and a duration.
+ * Given that some spans can have a very short duration (less than 1us), we
+ * need to rely on monotonic clock as much as possible to have the best precision.
+ *
+ * For that, after we've established that a query was sampled, we get both the wall clock
+ * and the monotonic clock at the start of a trace. They are both stored in pgTracingTraceContext.
+ * All subsequent times will use the monotonic clock.
+ * When we need to get the start of a span, we use the starting wall clock as a starting point
+ * and add the time between the two monotonic clocks.
+ *
+ * start_span is an optional nanosecond time to set for. If nothing is provided, we use the current monotonic clock.
+ * This parameter is mostly used when generating spans from planstate as we need to rely on the query instrumentation to find the node start.
+ */
+void
+begin_span(uint64 trace_id, Span * span, SpanType type,
+		   uint64 *span_id, uint64 parent_id, uint64 query_id,
+		   const TimestampTz *input_start_span_time)
+{
+	TimestampTz start_span_time;
+
+	initialize_span_fields(span, type, trace_id, span_id, parent_id, query_id);
+
+	/* If no start span is provided, get the current one */
+	if (input_start_span_time == NULL)
+		start_span_time = GetCurrentTimestamp();
+	else
+		start_span_time = *input_start_span_time;
+
+	span->start = start_span_time;
+}
+
+/*
+ * Set span duration and accumulated buffers
+ * end_span_input is optional, if NULL is passed, we use
+ * the current time
+ */
+void
+end_span(Span * span, const TimestampTz *end_time_input)
+{
+	BufferUsage buffer_usage;
+	WalUsage	wal_usage;
+
+	Assert(span->trace_id > 0);
+
+	/* Span should be ended only once */
+	Assert(!span->ended);
+	span->ended = true;
+
+	/* Set span duration with the end time before substrating the start */
+	if (end_time_input == NULL)
+		span->end = GetCurrentTimestamp();
+	else
+		span->end = *end_time_input;
+
+
+	if (span->type == SPAN_PLANNER || span->type == SPAN_PROCESS_UTILITY)
+	{
+		/* calc differences of buffer counters. */
+		memset(&buffer_usage, 0, sizeof(BufferUsage));
+		BufferUsageAccumDiff(&buffer_usage, &pgBufferUsage,
+							 &span->node_counters.buffer_usage);
+		span->node_counters.buffer_usage = buffer_usage;
+
+		/* calc differences of WAL counters. */
+		memset(&wal_usage, 0, sizeof(wal_usage));
+		WalUsageAccumDiff(&wal_usage, &pgWalUsage,
+						  &span->node_counters.wal_usage);
+		span->node_counters.wal_usage = wal_usage;
+	}
+}
+
+/*
+ * Get the type of a span.
+ * If it is a node span, the name may be pulled from the stat file.
+ */
+const char *
+get_span_type(const Span * span, const char *qbuffer, Size qbuffer_size)
+{
+	if (span->node_type_offset != -1 && qbuffer_size > 0 && span->node_type_offset <= qbuffer_size)
+	{
+		StringInfo	node_name = makeStringInfo();
+
+		appendStringInfoString(node_name, qbuffer + span->node_type_offset);
+		return node_name->data;
+	}
+
+	switch (span->type)
+	{
+		case SPAN_POST_PARSE:
+			return "Post Parse";
+		case SPAN_PARSE:
+			return "Parse";
+		case SPAN_PLANNER:
+			return "Planner";
+		case SPAN_FUNCTION:
+			return "Function";
+		case SPAN_PROCESS_UTILITY:
+			return "ProcessUtility";
+		case SPAN_EXECUTOR_RUN:
+			return "Executor";
+		case SPAN_EXECUTOR_FINISH:
+			return "Executor";
+
+		case SPAN_NODE_INIT_PLAN:
+			return "InitPlan";
+		case SPAN_NODE_SUBPLAN:
+			return "SubPlan";
+
+		case SPAN_NODE_SELECT:
+			return "Select";
+		case SPAN_NODE_INSERT:
+			return "Insert";
+		case SPAN_NODE_UPDATE:
+			return "Update";
+		case SPAN_NODE_DELETE:
+			return "Delete";
+		case SPAN_NODE_MERGE:
+			return "Merge";
+		case SPAN_NODE_UTILITY:
+			return "Utility";
+		case SPAN_NODE_NOTHING:
+			return "Nothing";
+		case SPAN_NODE_UNKNOWN:
+			return "Unknown";
+		case SPAN_NODE:
+			return "Node";
+	}
+	return "???";
+}
+
+/*
+ * Get the operation of a span.
+ * For node span, the name may be pulled from the stat file.
+ */
+const char *
+get_operation_name(const Span * span, const char *qbuffer, Size qbuffer_size)
+{
+	if (span->operation_name_offset != -1 && qbuffer_size > 0
+		&& span->operation_name_offset <= qbuffer_size)
+		return qbuffer + span->operation_name_offset;
+
+	switch (span->type)
+	{
+		case SPAN_POST_PARSE:
+			return "Post Parse";
+		case SPAN_PARSE:
+			return "Parse";
+		case SPAN_PLANNER:
+			return "Planner";
+		case SPAN_FUNCTION:
+			return "Function";
+		case SPAN_PROCESS_UTILITY:
+			return "ProcessUtility";
+		case SPAN_EXECUTOR_RUN:
+			return "ExecutorRun";
+		case SPAN_EXECUTOR_FINISH:
+			return "ExecutorFinish";
+		case SPAN_NODE_SELECT:
+		case SPAN_NODE_INSERT:
+		case SPAN_NODE_UPDATE:
+		case SPAN_NODE_DELETE:
+		case SPAN_NODE_MERGE:
+		case SPAN_NODE_UTILITY:
+		case SPAN_NODE_NOTHING:
+		case SPAN_NODE_INIT_PLAN:
+		case SPAN_NODE_SUBPLAN:
+		case SPAN_NODE_UNKNOWN:
+		case SPAN_NODE:
+			return "Node";
+	}
+	return "Unknown type";
+}
diff --git a/contrib/pg_tracing/pg_tracing_span.h b/contrib/pg_tracing/pg_tracing_span.h
new file mode 100644
index 0000000000..3293b5be62
--- /dev/null
+++ b/contrib/pg_tracing/pg_tracing_span.h
@@ -0,0 +1,150 @@
+/*-------------------------------------------------------------------------
+ * contrib/pg_tracing/pg_tracing_span.h
+ * 		Header for span.
+ *
+ * IDENTIFICATION
+ *	  contrib/pg_tracing/pg_tracing_span.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef _SPAN_H_
+#define _SPAN_H_
+
+#include "postgres.h"
+
+#include "jit/jit.h"
+#include "pgstat.h"
+#include "access/transam.h"
+
+/*
+ * SpanType: Type of the span
+ */
+typedef enum SpanType
+{
+	SPAN_PARSE,					/* Wraps query parsing */
+	SPAN_POST_PARSE,			/* Wraps post parsing */
+	SPAN_PLANNER,				/* Wraps planner execution in planner hook */
+	SPAN_FUNCTION,				/* Wraps function in fmgr hook */
+	SPAN_PROCESS_UTILITY,		/* Wraps ProcessUtility execution */
+
+	SPAN_EXECUTOR_RUN,
+	SPAN_EXECUTOR_FINISH,
+
+	SPAN_NODE_INIT_PLAN,
+	SPAN_NODE_SUBPLAN,
+
+	SPAN_NODE,					/* Represents a node execution, generated from
+								 * planstate */
+
+	SPAN_NODE_SELECT,			/* Query Span types. They are created from the
+								 * query cmdType */
+	SPAN_NODE_INSERT,
+	SPAN_NODE_UPDATE,
+	SPAN_NODE_DELETE,
+	SPAN_NODE_MERGE,
+	SPAN_NODE_UTILITY,
+	SPAN_NODE_NOTHING,
+	SPAN_NODE_UNKNOWN,
+}			SpanType;
+
+
+/*
+ * Counters extracted from query instrumentation
+ */
+typedef struct NodeCounters
+{
+	int64		rows;			/* # of tuples processed */
+	int64		nloops;			/* # of cycles for this node */
+
+	BufferUsage buffer_usage;	/* total buffer usage for this node */
+	WalUsage	wal_usage;		/* total WAL usage for this node */
+	JitInstrumentation jit_usage;	/* total JIT usage for this node */
+}			NodeCounters;
+
+/*
+ * Counters extracted from query's plan
+ */
+typedef struct PlanCounters
+{
+	/*
+	 * estimated execution costs for plan (see costsize.c for more info)
+	 */
+	Cost		startup_cost;	/* cost expended before fetching any tuples */
+	Cost		total_cost;		/* total cost (assuming all tuples fetched) */
+
+	/*
+	 * planner's estimate of result size of this plan step
+	 */
+	Cardinality plan_rows;		/* number of rows plan is expected to emit */
+	int			plan_width;		/* average row width in bytes */
+}			PlanCounters;
+
+/*
+ * The Span data structure represents an operation with a start, a duration
+ * and metadatas.
+ */
+typedef struct Span
+{
+	uint64		trace_id;		/* Trace id extracted from the SQLCommenter's
+								 * traceparent */
+	uint64		span_id;		/* Span Identifier generated from a random
+								 * uint64 */
+	uint64		parent_id;		/* Span's parent id. For the top span, it's
+								 * extracted from SQLCommenter's traceparent.
+								 * For other spans, we pass the parent's span */
+	uint64		query_id;		/* QueryId of the trace query if available */
+
+	TimestampTz start;			/* Start of the span */
+	TimestampTz end;			/* End of the span */
+
+	SpanType	type;			/* Type of the span. Used to generate the
+								 * span's name for all spans except SPAN_NODE */
+	bool		ended;			/* Track if the span was already ended.
+								 * Internal usage only */
+	int			be_pid;			/* Pid of the backend process */
+	Oid			user_id;		/* User ID when the span was created */
+	Oid			database_id;	/* Database ID where the span was created */
+
+	uint8		subxact_count;	/* Active count of backend's subtransaction */
+
+	/*
+	 * We store variable size metadata in an external file. Those represent
+	 * the position of NULL terminated strings in the file. Set to -1 if
+	 * unused.
+	 */
+	Size		node_type_offset;	/* name of the node type */
+	Size		operation_name_offset;	/* operation represented by the span */
+	Size		deparse_info_offset;	/* deparsing info extracted from a
+										 * plan node */
+	Size		parameter_offset;	/* query parameters values */
+
+	PlanCounters plan_counters; /* Counters with plan costs */
+	NodeCounters node_counters; /* Counters with node costs (jit, wal,
+								 * buffers) */
+	int64		startup;		/* Time to the first tuple in nanoseconds */
+	int			sql_error_code; /* query error code extracted from ErrorData,
+								 * 0 if query was successful */
+}			Span;
+
+/*
+ * Trace context for an ongoing trace
+ */
+typedef struct pgTracingTraceContext
+{
+	uint64		trace_id;		/* Id of the trace */
+	uint64		parent_id;		/* Span id of the parent */
+	int			sampled;		/* Is current statement sampled? */
+	uint64		query_id;		/* Query id of the current statement */
+	Span		root_span;
+	bool		in_aborted_transaction;
+}			pgTracingTraceContext;
+
+extern void begin_span(uint64 trace_id, Span * span,
+					   SpanType type, uint64 *span_id, uint64 parent_id, uint64 query_id, const TimestampTz *start_span);
+extern void end_span(Span * span, const TimestampTz *end_time);
+
+extern SpanType command_type_to_span_type(CmdType cmd_type);
+extern const char *get_span_type(const Span * span, const char *qbuffer, Size qbuffer_size);
+extern const char *get_operation_name(const Span * span, const char *qbuffer, Size qbuffer_size);
+
+#endif
diff --git a/contrib/pg_tracing/sql/cleanup.sql b/contrib/pg_tracing/sql/cleanup.sql
new file mode 100644
index 0000000000..43b54835de
--- /dev/null
+++ b/contrib/pg_tracing/sql/cleanup.sql
@@ -0,0 +1,5 @@
+-- Drop test table and test functions
+DROP TABLE pg_tracing_test;
+DROP function test_function_project_set;
+DROP function test_function_result;
+DROP EXTENSION pg_tracing CASCADE;
diff --git a/contrib/pg_tracing/sql/extended.sql b/contrib/pg_tracing/sql/extended.sql
new file mode 100644
index 0000000000..7f42f41c90
--- /dev/null
+++ b/contrib/pg_tracing/sql/extended.sql
@@ -0,0 +1,41 @@
+-- Trace everything
+SET pg_tracing.sample_rate = 1.0;
+
+-- Simple query with extended protocol
+SELECT $1, $2 \bind 1 2 \g
+SELECT span_type, span_operation, parameters, lvl FROM peek_ordered_spans;
+CALL clean_spans();
+
+-- Trigger an error due to mismatching number of parameters
+BEGIN; select $1 \bind \g
+ROLLBACK;
+SELECT span_type, span_operation, parameters, lvl FROM peek_ordered_spans;
+CALL clean_spans();
+
+-- Execute queries with extended protocol within an explicit transaction
+BEGIN;
+SELECT $1 \bind 1 \g
+SELECT $1, $2 \bind 2 3 \g
+COMMIT;
+
+-- Spans within the same transaction should have been generated with the same trace_id
+SELECT count(distinct(trace_id)) = 1 FROM pg_tracing_peek_spans;
+SELECT span_type, span_operation, parameters, lvl FROM peek_ordered_spans;
+CALL clean_spans();
+
+-- Mix extended protocol and simple protocol
+BEGIN;
+SELECT $1 \bind 1 \g
+SELECT 5, 6, 7;
+SELECT $1, $2 \bind 2 3 \g
+COMMIT;
+
+-- Spans within the same transaction should have been generated with the same trace_id
+SELECT count(distinct(trace_id)) = 1 FROM pg_tracing_peek_spans;
+SELECT span_type, span_operation, parameters, lvl FROM peek_ordered_spans;
+CALL clean_spans();
+
+-- gdesc calls a single parse command then execute a query. Make sure we handle this case
+SELECT 1 \gdesc
+SELECT span_type, span_operation, parameters, lvl FROM peek_ordered_spans;
+CALL clean_spans();
diff --git a/contrib/pg_tracing/sql/insert.sql b/contrib/pg_tracing/sql/insert.sql
new file mode 100644
index 0000000000..28c25d9d40
--- /dev/null
+++ b/contrib/pg_tracing/sql/insert.sql
@@ -0,0 +1,22 @@
+-- Only trace queries with sample flag
+SET pg_tracing.sample_rate = 0.0;
+SET pg_tracing.caller_sample_rate = 1.0;
+
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ CREATE TABLE IF NOT EXISTS pg_tracing_test_table_with_constraint (a int, b char(20), CONSTRAINT PK_tracing_test PRIMARY KEY (a));
+SELECT span_type, span_operation, lvl from peek_ordered_spans where trace_id=1;
+
+-- Simple insertion
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000002-0000000000000002-01'*/ INSERT INTO pg_tracing_test_table_with_constraint VALUES(1, 'aaa');
+SELECT span_type, span_operation from peek_ordered_spans where trace_id=2;
+
+-- Trigger constraint violation
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000003-0000000000000003-01'*/ INSERT INTO pg_tracing_test_table_with_constraint VALUES(1, 'aaa');
+SELECT span_type, span_operation, sql_error_code, lvl from peek_ordered_spans where trace_id=3;
+
+-- Trigger an error while calling pg_tracing_peek_spans which resets tracing, nothing should be generated
+CALL clean_spans();
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000004-0000000000000004-01'*/ INSERT INTO pg_tracing_test_table_with_constraint VALUES(length((select sql_error_code from public.pg_tracing_peek_spans)), 'aaa');
+SELECT span_type, span_operation, sql_error_code from peek_ordered_spans where trace_id=4;
+
+-- Cleanup
+CALL clean_spans();
diff --git a/contrib/pg_tracing/sql/nested.sql b/contrib/pg_tracing/sql/nested.sql
new file mode 100644
index 0000000000..8a29da5d22
--- /dev/null
+++ b/contrib/pg_tracing/sql/nested.sql
@@ -0,0 +1,205 @@
+-- Create test function to sample
+CREATE OR REPLACE FUNCTION test_function_project_set(a int) RETURNS SETOF oid AS
+$BODY$
+BEGIN
+	RETURN QUERY SELECT oid from pg_class where oid = a;
+END;
+$BODY$
+LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION test_function_result(a int, b text) RETURNS void AS
+$BODY$
+BEGIN
+    INSERT INTO pg_tracing_test(a, b) VALUES (a, b);
+END;
+$BODY$
+LANGUAGE plpgsql;
+
+
+-- Trace a statement with a function call
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000051-0000000000000051-01'*/ select test_function_project_set(1);
+
+-- The test function call will generate the following spans (non exhaustive list):
+-- +---------------------------------------------------------------------------------------------------+
+-- | A: Select test_function_project_set(1);                                                                       |
+-- +-+--------++----------++----------------++--------------------------------------------------------++
+--   |B: Parse||C: Planner||D: ExecutorStart||E: ExecutorRun                                          |
+--   +--------++----------++----------------+++-----------------------------------------------------+-+
+--                                            |F: ProjectSet                                        |
+--                                            ++---------+---------+------------------------------+-+
+--                                             |G: Result|H: Parse | I: Select a from b where...  |
+--                                             +---------+---------+----+--------------+----------+
+--                                                                      |J: ExecutorRun|
+--                                                                      +--------------+
+
+-- Gather span_id, span start and span end of function call statement
+SELECT span_id AS span_a_id,
+        get_span_start(span_start) as span_a_start,
+        get_span_end(span_start) as span_a_end
+		from pg_tracing_peek_spans where parent_id=81 and span_type!='Parse' \gset
+SELECT span_id AS span_e_id,
+        get_span_start(span_start) as span_e_start,
+        get_span_end(span_start) as span_e_end
+		from pg_tracing_peek_spans where parent_id=:span_a_id and span_type='Executor' and span_operation='ExecutorRun' \gset
+SELECT span_id AS span_f_id,
+        get_span_start(span_start) as span_f_start,
+        get_span_end(span_start) as span_f_end
+		from pg_tracing_peek_spans where parent_id=:span_e_id and span_type='ProjectSet' \gset
+SELECT span_id AS span_g_id,
+        get_span_start(span_start) as span_g_start,
+        get_span_end(span_start) as span_g_end
+		from pg_tracing_peek_spans where parent_id=:span_f_id and span_type='Result' \gset
+SELECT span_id AS span_h_id,
+        get_span_start(span_start) as span_h_start,
+        get_span_end(span_start) as span_h_end
+		from pg_tracing_peek_spans where parent_id=:span_f_id and span_type='Parse' \gset
+SELECT span_id AS span_i_id,
+        get_span_start(span_start) as span_i_start,
+        get_span_end(span_start) as span_i_end
+		from pg_tracing_peek_spans where parent_id=:span_f_id and span_type='Select' \gset
+SELECT span_id AS span_j_id,
+        get_span_start(span_start) as span_j_start,
+        get_span_end(span_start) as span_j_end
+		from pg_tracing_peek_spans where parent_id=:span_i_id and span_operation='ExecutorRun' \gset
+
+-- Check that spans' start and end are within expection
+SELECT :span_a_start <= :span_e_start AS top_query_before_run,
+		:span_a_end >= :span_e_end AS top_ends_after_run_end,
+
+		:span_e_start <= :span_f_start AS top_run_starts_before_project,
+
+		:span_e_end >= :span_f_end AS top_run_ends_after_project_end,
+		:span_e_end >= :span_h_end AS top_run_ends_before_select_end,
+		:span_e_end >= :span_i_end AS top_run_ends_after_nested_run_end;
+
+SELECT
+		:span_g_end >= :span_h_start AS nested_result_ends_before_parse,
+		:span_h_end <= :span_i_start AS nested_parse_ends_before_select,
+
+		:span_j_start >= :span_i_start AS run_starts_after_parent_select,
+		:span_j_end <= :span_i_end AS run_ends_after_select_end;
+
+-- Check that the root span is the longest one
+WITH max_end AS (select max(span_end) from pg_tracing_peek_spans)
+SELECT span_end = max_end.max from pg_tracing_peek_spans, max_end
+    where span_id = :span_a_id;
+
+-- Check that ExecutorRun is attached to the nested top span
+SELECT span_operation, deparse_info from pg_tracing_peek_spans where parent_id=:span_j_id order by span_operation;
+
+-- Check tracking with top tracking
+SET pg_tracing.track = 'top';
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000052-0000000000000052-01'*/ select test_function_project_set(1);
+SELECT count(*) from pg_tracing_consume_spans where trace_id=82;
+
+-- Check tracking with no tracking
+SET pg_tracing.track = 'none';
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000053-0000000000000053-01'*/ select test_function_project_set(1);
+SELECT count(*) from pg_tracing_consume_spans where trace_id=83;
+
+-- Reset tracking setting
+SET pg_tracing.track TO DEFAULT;
+
+-- Create test procedure
+CREATE OR REPLACE PROCEDURE sum_one(i int) AS $$
+DECLARE
+  r int;
+BEGIN
+  SELECT (i + i)::int INTO r;
+END; $$ LANGUAGE plpgsql;
+
+-- Test tracking of procedure with utility tracking enabled
+SET pg_tracing.track_utility=on;
+/*traceparent='00-00000000000000000000000000000054-0000000000000054-01'*/ CALL sum_one(3);
+select span_operation, lvl FROM peek_ordered_spans where trace_id=84;
+
+-- Test again with utility tracking disabled
+SET pg_tracing.track_utility=off;
+/*traceparent='00-00000000000000000000000000000055-0000000000000055-01'*/ CALL sum_one(10);
+select span_operation, lvl FROM peek_ordered_spans where trace_id=85;
+
+-- Create immutable function
+CREATE OR REPLACE FUNCTION test_immutable_function(a int) RETURNS oid
+AS 'SELECT oid from pg_class where oid = a;'
+LANGUAGE sql IMMUTABLE;
+
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000056-0000000000000056-01'*/ select test_immutable_function(1);
+select span_operation, lvl FROM peek_ordered_spans where trace_id=86;
+
+-- Create function with generate series
+
+CREATE OR REPLACE FUNCTION test_generate_series(IN anyarray, OUT x anyelement)
+    RETURNS SETOF anyelement
+    LANGUAGE sql
+    AS 'select * from pg_catalog.generate_series(array_lower($1, 1), array_upper($1, 1), 1)';
+
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000057-0000000000000057-01'*/ select test_generate_series('{1,2,3,4}'::int[]) FROM (VALUES (1,2));
+
+SELECT span_id AS span_project_set_id,
+        get_span_start(span_start) as span_project_set_start,
+        get_span_end(span_start) as span_project_set_end
+		from pg_tracing_peek_spans where span_type='ProjectSet' \gset
+
+SELECT span_id AS span_result_id,
+        get_span_start(span_start) as span_result_start,
+        get_span_end(span_start) as span_result_end
+		from pg_tracing_peek_spans where parent_id=:span_project_set_id and span_type='Result' \gset
+
+SELECT span_id AS span_parse,
+        get_span_start(span_start) as span_parse_start,
+        get_span_end(span_start) as span_parse_end
+		from pg_tracing_peek_spans where parent_id=:span_project_set_id and span_type='Parse' \gset
+
+-- Check that spans' start and end are within expection
+SELECT :span_project_set_start <= :span_parse_start AS project_set_starts_before_parse,
+        :span_result_start <= :span_parse_start AS result_starts_before_parse,
+        :span_result_end <= :span_parse_start AS result_ends_before_parse,
+        :span_project_set_end >= :span_parse_end AS project_set_ends_after_parse;
+
+select span_operation, lvl FROM peek_ordered_spans where trace_id=87;
+
+-- +---------------------------------------------------------------------------------------------------+
+-- | A: Select test_function(1);                                                                       |
+-- +-+--------++----------++----------------++--------------------------------------------------------++
+--   |B: Parse||C: Planner||D: ExecutorStart||E: ExecutorRun                                          |
+--   +--------++----------++----------------+++-----------------------------------------------------+-+
+--                                            |F: Result                                            |
+--                                            ++---------------+----------------------------------+-+
+--                                             |G: Parse       |     H: Insert INTO...            |
+--                                             +---------------+--------+--------------+----------+
+--                                                                      |I: ExecutorRun|
+--                                                                      +--------------+
+
+-- Check function with result node
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000058-0000000000000058-01'*/ select test_function_result(1, 'test');
+
+-- Gather span_id, span start and span end of function call statement
+SELECT span_id AS span_a_id,
+        get_span_start(span_start) as span_a_start,
+        get_span_end(span_start) as span_a_end
+		from pg_tracing_peek_spans where parent_id=88 and span_type!='Parse' \gset
+SELECT span_id AS span_e_id,
+        get_span_start(span_start) as span_e_start,
+        get_span_end(span_start) as span_e_end
+		from pg_tracing_peek_spans where parent_id=:span_a_id and span_type='Executor' and span_operation='ExecutorRun' \gset
+SELECT span_id AS span_f_id,
+        get_span_start(span_start) as span_f_start,
+        get_span_end(span_start) as span_f_end
+		from pg_tracing_peek_spans where parent_id=:span_e_id and span_type='Result' \gset
+SELECT span_id AS span_g_id,
+        get_span_start(span_start) as span_g_start,
+        get_span_end(span_start) as span_g_end
+		from pg_tracing_peek_spans where parent_id=:span_f_id and span_type='Parse' \gset
+SELECT span_id AS span_h_id,
+        get_span_start(span_start) as span_h_start,
+        get_span_end(span_start) as span_h_end
+		from pg_tracing_peek_spans where parent_id=:span_f_id and span_type='Insert' \gset
+
+-- Check that parse span is correctly positioned
+SELECT :span_g_start >= :span_f_start AS parse_start_after_result,
+		:span_g_end <= :span_f_end AS parse_ends_before_result,
+		:span_g_end <= :span_h_start AS parse_ends_before_insert_node;
+select span_operation, lvl FROM peek_ordered_spans where trace_id=88;
+
+-- Cleanup
+CALL clean_spans();
diff --git a/contrib/pg_tracing/sql/parallel.sql b/contrib/pg_tracing/sql/parallel.sql
new file mode 100644
index 0000000000..8d0e942eae
--- /dev/null
+++ b/contrib/pg_tracing/sql/parallel.sql
@@ -0,0 +1,23 @@
+begin;
+-- encourage use of parallel plans
+set local parallel_setup_cost=0;
+set local parallel_tuple_cost=0;
+set local min_parallel_table_scan_size=0;
+set local max_parallel_workers_per_gather=2;
+
+-- Trace parallel queries
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ select 1 from pg_class limit 1;
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000002-0000000000000002-01'*/ select 2 from pg_class limit 2;
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000003-0000000000000003-00'*/ select 3 from pg_class limit 3;
+commit;
+
+-- Get root top span id
+SELECT span_id as root_span_id from pg_tracing_peek_spans where span_type='Select' and trace_id=1 and parent_id=1 \gset
+-- Get executor top span id
+SELECT span_id as executor_span_id from pg_tracing_peek_spans where span_operation='ExecutorRun' and trace_id=1 and parent_id=:root_span_id \gset
+
+-- Check the select spans that are attached to the root top span
+SELECT trace_id, span_type, span_operation from pg_tracing_peek_spans where span_type='Select' and parent_id=:executor_span_id order by span_operation;
+
+-- Check number of executor spans
+SELECT count(*) from pg_tracing_consume_spans where span_type='Executor';
diff --git a/contrib/pg_tracing/sql/reset.sql b/contrib/pg_tracing/sql/reset.sql
new file mode 100644
index 0000000000..531db2172d
--- /dev/null
+++ b/contrib/pg_tracing/sql/reset.sql
@@ -0,0 +1,3 @@
+-- Check reset is working
+SELECT pg_tracing_reset();
+SELECT traces from pg_tracing_info;
diff --git a/contrib/pg_tracing/sql/sample.sql b/contrib/pg_tracing/sql/sample.sql
new file mode 100644
index 0000000000..ab19ede307
--- /dev/null
+++ b/contrib/pg_tracing/sql/sample.sql
@@ -0,0 +1,45 @@
+-- Trace nothing
+SET pg_tracing.sample_rate = 0.0;
+SET pg_tracing.caller_sample_rate = 0.0;
+
+-- Query with sampling flag
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ SELECT 1;
+select count(distinct(trace_id))=0 from pg_tracing_consume_spans;
+
+-- Query without trace context
+SELECT 1;
+select count(distinct(trace_id))=0 from pg_tracing_consume_spans;
+
+-- Enable full sampling
+SET pg_tracing.sample_rate = 1.0;
+
+-- Generate queries with sampling flag on, off and no trace context
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000002-0000000000000002-01'*/ SELECT 1;
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000003-0000000000000003-00'*/ SELECT 2;
+SELECT 3;
+SELECT 4;
+
+-- Check number of generated spans
+select count(distinct(trace_id)) from pg_tracing_peek_spans;
+-- Check span order
+select span_operation, parameters, lvl from peek_ordered_spans;
+-- Top spans should reuse generated ids and have trace_id = parent_id
+select span_operation, parameters from peek_ordered_spans where trace_id = parent_id;
+CALL clean_spans();
+
+-- Only trace query with sampled flag
+SET pg_tracing.sample_rate = 0.0;
+SET pg_tracing.caller_sample_rate = 1.0;
+
+-- Generate queries with sampling flag on, off and no trace context
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000004-0000000000000004-01'*/ SELECT 1;
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000005-0000000000000005-00'*/ SELECT 2;
+SELECT 1;
+
+-- Check number of generated spans
+select count(distinct(trace_id)) from pg_tracing_peek_spans;
+-- Check span ordering
+select span_operation, parameters, lvl from peek_ordered_spans;
+
+-- Cleaning
+CALL clean_spans();
diff --git a/contrib/pg_tracing/sql/select.sql b/contrib/pg_tracing/sql/select.sql
new file mode 100644
index 0000000000..f1bce13dc2
--- /dev/null
+++ b/contrib/pg_tracing/sql/select.sql
@@ -0,0 +1,99 @@
+-- Only trace queries with sample flag
+SET pg_tracing.sample_rate = 0.0;
+SET pg_tracing.caller_sample_rate = 1.0;
+
+-- Run a simple query
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ SELECT 1;
+-- Get top span id
+SELECT span_id AS top_span_id from pg_tracing_peek_spans where parent_id=1 and span_type!='Parse' \gset
+-- Check parameters
+SELECT parameters from pg_tracing_peek_spans where span_id=:top_span_id;
+-- Check the number of children
+SELECT count(*) from pg_tracing_peek_spans where parent_id=:'top_span_id';
+-- Check span_operation
+SELECT span_type, span_operation from pg_tracing_peek_spans where trace_id=1 order by span_start, span_end desc;
+-- Check count of query_id
+SELECT count(distinct query_id) from pg_tracing_consume_spans where trace_id=1;
+-- Check reported number of trace
+SELECT traces from pg_tracing_info;
+
+-- Trace a statement with function call
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000003-0000000000000003-01'*/ SELECT count(*) from current_database();
+-- Check the generated span span_type, span_operation and order of function call
+SELECT span_type, span_operation, lvl FROM peek_ordered_spans where trace_id=3;
+
+-- Trace a more complex query with multiple function calls
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000004-0000000000000004-01'*/ SELECT s.relation_size + s.index_size
+FROM (SELECT
+      pg_relation_size(C.oid) as relation_size,
+      pg_indexes_size(C.oid) as index_size
+    FROM pg_class C) as s limit 1;
+-- Check the nested level of spans for a query with multiple function calls
+SELECT span_type, span_operation, lvl FROM peek_ordered_spans where trace_id=4;
+
+-- Check that we're in a correct state after a timeout
+set statement_timeout=200;
+-- Trace query triggering a statement timeout
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000007-0000000000000007-01'*/ select * from pg_sleep(10);
+SELECT span_type, span_operation, sql_error_code, lvl FROM peek_ordered_spans where trace_id=7;
+-- Cleanup statement setting
+set statement_timeout=0;
+
+-- Trace a working query after the timeout to check we're in a consistent state
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000008-0000000000000008-01'*/ select 1;
+-- Check the spans order and error code
+SELECT span_type, span_operation, sql_error_code, lvl FROM peek_ordered_spans where trace_id=8;
+
+-- Create a prepare statement with trace context passed as the first parameter
+PREPARE test_prepared (text, integer) AS /*$1*/ SELECT $2;
+EXECUTE test_prepared('dddbs=''postgres.db'',traceparent=''00-00000000000000000000000000000009-0000000000000009-01''', 1);
+SELECT trace_id, span_type, span_operation, parameters, lvl FROM peek_ordered_spans where trace_id=9;
+
+-- Call the prepared statement with generic plan
+SET plan_cache_mode='force_generic_plan';
+EXECUTE test_prepared('dddbs=''postgres.db'',traceparent=''00-0000000000000000000000000000000a-000000000000000a-01''', 2);
+SELECT trace_id, span_type, span_operation, parameters, lvl FROM peek_ordered_spans where trace_id=10;
+
+-- Cleanup
+SET plan_cache_mode='auto';
+DEALLOCATE test_prepared;
+
+-- Run a statement with node not executed
+/*dddbs='postgres.db',traceparent='00-0000000000000000000000000000000b-000000000000000b-01'*/ select 1 limit 0;
+SELECT span_operation, parameters, lvl from peek_ordered_spans where trace_id=11;
+
+-- Test multiple statements in a single query
+/*dddbs='postgres.db',traceparent='00-0000000000000000000000000000000c-000000000000000c-01'*/ select 1; select 2;
+SELECT span_operation, parameters, lvl from peek_ordered_spans where trace_id=12;
+
+-- Check that parameters are not exported when disabled
+SET pg_tracing.export_parameters=false;
+/*dddbs='postgres.db',traceparent='00-0000000000000000000000000000000d-000000000000000d-01'*/ select 1, 2, 3;
+SELECT span_operation, parameters, lvl from peek_ordered_spans where trace_id=13;
+SET pg_tracing.export_parameters=true;
+
+-- Check generated spans when deparse is disabled
+SET pg_tracing.deparse_plan=false;
+/*dddbs='postgres.db',traceparent='00-0000000000000000000000000000000e-000000000000000e-01'*/ SELECT * from pg_tracing_test where a=1;
+SELECT span_operation, deparse_info, parameters, lvl from peek_ordered_spans where trace_id=14;
+
+-- Check generated spans when deparse is enabled
+SET pg_tracing.deparse_plan=true;
+/*dddbs='postgres.db',traceparent='00-0000000000000000000000000000000f-000000000000000f-01'*/ SELECT * from pg_tracing_test where a=1;
+SELECT trace_id, span_operation, deparse_info, parameters, lvl from peek_ordered_spans where trace_id=15;
+
+-- Check multi statement query
+CALL clean_spans();
+SET pg_tracing.sample_rate = 1.0;
+-- Force a multi-query statement with \;
+SELECT 1\; SELECT 1, 2;
+SELECT span_type, span_operation, parameters, lvl from peek_ordered_spans;
+CALL clean_spans();
+
+-- Check standalone trace
+SELECT 1;
+-- Make sure we have unique span ids
+select count(span_id) from pg_tracing_consume_spans group by span_id;
+
+-- Cleanup
+SET pg_tracing.sample_rate = 0.0;
diff --git a/contrib/pg_tracing/sql/subxact.sql b/contrib/pg_tracing/sql/subxact.sql
new file mode 100644
index 0000000000..239323a143
--- /dev/null
+++ b/contrib/pg_tracing/sql/subxact.sql
@@ -0,0 +1,18 @@
+-- Enable full sampling
+SET pg_tracing.sample_rate = 1.0;
+
+-- Start a transaction with subxaction
+BEGIN;
+SAVEPOINT s1;
+INSERT INTO pg_tracing_test VALUES(generate_series(1, 2), 'aaa');
+SAVEPOINT s2;
+INSERT INTO pg_tracing_test VALUES(generate_series(1, 2), 'aaa');
+SAVEPOINT s3;
+SELECT 1;
+COMMIT;
+
+-- Check that subxact_count is correctly reported
+select span_operation, parameters, subxact_count, lvl FROM peek_ordered_spans;
+
+-- Cleaning
+CALL clean_spans();
diff --git a/contrib/pg_tracing/sql/trigger.sql b/contrib/pg_tracing/sql/trigger.sql
new file mode 100644
index 0000000000..fe56974a56
--- /dev/null
+++ b/contrib/pg_tracing/sql/trigger.sql
@@ -0,0 +1,185 @@
+-- Only trace queries with sample flag
+SET pg_tracing.sample_rate = 0.0;
+SET pg_tracing.caller_sample_rate = 1.0;
+
+-- Create test tables
+CREATE TABLE Employee (
+    EmployeeId INT NOT NULL,
+    LastName VARCHAR(20) NOT NULL,
+    CONSTRAINT PK_Employee PRIMARY KEY (EmployeeId));
+CREATE TABLE Employee_Audit (
+    EmployeeId INT NOT NULL,
+    LastName VARCHAR(20) NOT NULL,
+    EmpAdditionTime VARCHAR(20) NOT NULL);
+
+-- Create test trigger
+CREATE OR REPLACE FUNCTION employee_insert_trigger_fnc()
+  RETURNS trigger AS
+$$
+BEGIN
+    INSERT INTO Employee_Audit (EmployeeId, LastName, EmpAdditionTime)
+         VALUES(NEW.EmployeeId,NEW.LastName,current_date);
+RETURN NEW;
+END;
+$$
+LANGUAGE plpgsql;
+
+-- Hook the trigger twice
+CREATE TRIGGER employee_insert_trigger
+  AFTER INSERT
+  ON Employee
+  FOR EACH ROW
+  EXECUTE PROCEDURE employee_insert_trigger_fnc();
+
+CREATE TRIGGER employee_insert_trigger_2
+  AFTER INSERT
+  ON Employee
+  FOR EACH ROW
+  EXECUTE PROCEDURE employee_insert_trigger_fnc();
+
+
+-- Call update
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ INSERT INTO Employee VALUES(10,'Adams');
+
+
+--
+-- +--------+---------------------------------------------------------------------------------------------------------------------------------------+
+-- |A: Parse| B: INSERT INTO Employee                                                                                                               |
+-- +--------++----------+-+-------------------------+---------------------------------------------------------------------------------------------+-+
+--           |C: Planner| |D: ExecutorRun           | G: ExecutorFinish                                                                           |
+--           +----------+ ++-----------------------++--+--------+-------------------------------------------+-+---------------------------------+-+
+--                         |E: Insert into employee|   |H: Parse|  I: INSERT INTO Employee_Audit...         | |N: INSERT INTO Employee_Audit...|
+--                         ++---------+------------+   +--------+-+----------++----------------------------++ +--------------------------------+
+--                          |F: Result|                           |J: Planner||K: ExecutorRun              |  |O: ExecutorRun |
+--                          +---------+                           +----------+++---------------------------+  ++--------------+
+--                                                                             |L: Insert on employee audit|   | ...          |
+--                                                                             +-+---------+---------------+   +--------------+
+--                                                                               |M: Result|
+--                                                                               +---------+
+
+-- Gather span_id, span start and span end of call with triggers
+SELECT span_id AS span_a_id,
+        get_span_start(span_start) as span_a_start,
+        get_span_end(span_start) as span_a_end
+		from pg_tracing_peek_spans where parent_id=1 and span_type='Parse' \gset
+SELECT span_id AS span_b_id,
+        get_span_start(span_start) as span_b_start,
+        get_span_end(span_start) as span_b_end
+		from pg_tracing_peek_spans where parent_id=1 and span_type!='Parse' \gset
+SELECT span_id AS span_c_id,
+        get_span_start(span_start) as span_c_start,
+        get_span_end(span_start) as span_c_end
+		from pg_tracing_peek_spans where parent_id=:span_b_id and span_type='Planner' \gset
+SELECT span_id AS span_d_id,
+        get_span_start(span_start) as span_d_start,
+        get_span_end(span_start) as span_d_end
+		from pg_tracing_peek_spans where parent_id=:span_b_id and span_type='Executor' and span_operation='ExecutorRun' \gset
+SELECT span_id AS span_e_id,
+        get_span_start(span_start) as span_e_start,
+        get_span_end(span_start) as span_e_end
+		from pg_tracing_peek_spans where parent_id=:span_d_id and span_type='Insert' \gset
+SELECT span_id AS span_f_id,
+        get_span_start(span_start) as span_f_start,
+        get_span_end(span_start) as span_f_end
+		from pg_tracing_peek_spans where parent_id=:span_e_id and span_type='Result' \gset
+
+-- Executor Finish, first trigger
+SELECT span_id AS span_g_id,
+        get_span_start(span_start) as span_g_start,
+        get_span_end(span_start) as span_g_end
+		from pg_tracing_peek_spans where parent_id=:span_b_id and span_type='Executor' and span_operation='ExecutorFinish' \gset
+SELECT span_id AS span_h_id,
+        get_span_start(span_start) as span_h_start,
+        get_span_end(span_start) as span_h_end
+		from pg_tracing_peek_spans where parent_id=:span_g_id and span_type='Parse' \gset
+SELECT span_id AS span_i_id,
+        get_span_start(span_start) as span_i_start,
+        get_span_end(span_start) as span_i_end
+		from pg_tracing_peek_spans where parent_id=:span_g_id and span_type='Insert' limit 1 \gset
+SELECT span_id AS span_j_id,
+        get_span_start(span_start) as span_j_start,
+        get_span_end(span_start) as span_j_end
+		from pg_tracing_peek_spans where parent_id=:span_i_id and span_type='Planner' \gset
+SELECT span_id AS span_k_id,
+        get_span_start(span_start) as span_k_start,
+        get_span_end(span_start) as span_k_end
+		from pg_tracing_peek_spans where parent_id=:span_i_id and span_type='Executor' and span_operation='ExecutorRun' \gset
+SELECT span_id AS span_l_id,
+        get_span_start(span_start) as span_l_start,
+        get_span_end(span_start) as span_l_end
+		from pg_tracing_peek_spans where parent_id=:span_k_id and span_type='Insert' \gset
+SELECT span_id AS span_m_id,
+        get_span_start(span_start) as span_m_start,
+        get_span_end(span_start) as span_m_end
+		from pg_tracing_peek_spans where parent_id=:span_l_id and span_type='Result' \gset
+
+-- Executor Finish, second trigger
+SELECT span_id AS span_n_id,
+        get_span_start(span_start) as span_n_start,
+        get_span_end(span_start) as span_n_end
+        from pg_tracing_peek_spans where parent_id=:span_g_id and span_type='Insert' limit 1 offset 1 \gset
+SELECT span_id AS span_o_id,
+        get_span_start(span_start) as span_o_start,
+        get_span_end(span_start) as span_o_end
+        from pg_tracing_peek_spans where parent_id=:span_n_id and span_type='Executor' and span_operation='ExecutorRun' \gset
+
+-- Check that spans' start and end are within expection
+-- Root span
+SELECT :span_a_end <= :span_b_start as parse_before_root_span;
+-- Planner
+SELECT :span_c_start >= :span_b_start as planner_starts_after_root_span;
+-- ExecutorRun
+SELECT :span_d_start >= :span_c_end as executor_run_starts_after_planner,
+       :span_d_end <= :span_g_start as executor_run_ends_before_finish;
+-- First Insert
+SELECT :span_e_start >= :span_d_start as insert_starts_after_executor_run,
+       :span_e_start <= :span_f_start as insert_ends_before_executor_run,
+       :span_e_end >= :span_f_end as insert_starts_before_child,
+       :span_e_end <= :span_d_end as insert_ends_after_child;
+-- ExecutorFinish
+SELECT :span_g_start <= :span_i_start as executor_finish_starts_before_child,
+       :span_g_end >= :span_o_end as executor_finish_ends_after_child;
+-- First trigger
+SELECT :span_h_end <= :span_i_start as parse_ends_before_first_trigger,
+       :span_i_end >= :span_n_end as first_trigger_ends_after_child;
+-- Second trigger
+SELECT :span_o_start >= :span_i_end  as second_trigger_starts_after_first,
+       :span_o_end >= :span_o_end as second_trigger_ends_after_child,
+       :span_o_end <= :span_g_end as second_trigger_ends_before_executorfinish_end,
+       :span_n_end <= :span_g_end as second_trigger_ends_before_root_executorfinish_end;
+
+-- Check span_operation
+SELECT span_type, span_operation, lvl from peek_ordered_spans where trace_id=1;
+
+-- Check count of query_id
+SELECT count(distinct query_id) from pg_tracing_consume_spans where trace_id=1;
+
+-- Second call, parse should not be present anymore
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ INSERT INTO Employee VALUES(11,'Adams');
+
+SELECT span_id AS span_b_id,
+        get_span_start(span_start) as span_b_start,
+        get_span_end(span_start) as span_b_end
+		from pg_tracing_peek_spans where parent_id=1 and span_type!='Parse' \gset
+SELECT span_id AS span_d_id,
+        get_span_start(span_start) as span_d_start,
+        get_span_end(span_start) as span_d_end
+		from pg_tracing_peek_spans where parent_id=:span_b_id and span_type='Executor' and span_operation='ExecutorRun' \gset
+SELECT span_id AS span_g_id,
+        get_span_start(span_start) as span_g_start,
+        get_span_end(span_start) as span_g_end
+		from pg_tracing_peek_spans where parent_id=:span_b_id and span_type='Executor' and span_operation='ExecutorFinish' \gset
+
+-- Check we don't have Parse span anymore
+SELECT count(*) = 0 from pg_tracing_peek_spans where parent_id=:span_g_id and span_type='Parse';
+-- Insert should be attached to the correct parent
+SELECT count(*) = 1 from pg_tracing_peek_spans where parent_id=:span_g_id and span_type='Insert' limit 1 \gset
+
+-- Check that ExecutorRun ends before ExecutorFinish start
+SELECT :span_d_end <= :span_g_start as finish_start_after_run;
+
+-- Check generated spans for the second call with trigger
+SELECT span_type, span_operation, lvl from peek_ordered_spans where trace_id=1;
+
+-- Check count of query_id
+SELECT count(distinct query_id) from pg_tracing_consume_spans where trace_id=1;
diff --git a/contrib/pg_tracing/sql/utility.sql b/contrib/pg_tracing/sql/utility.sql
new file mode 100644
index 0000000000..756f691fa8
--- /dev/null
+++ b/contrib/pg_tracing/sql/utility.sql
@@ -0,0 +1,183 @@
+-- Some helper functions
+CREATE OR REPLACE FUNCTION get_span_start(time_start timestamptz) RETURNS bigint AS
+$BODY$
+BEGIN
+    RETURN extract(epoch from time_start);
+END;
+$BODY$
+LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION get_span_end(time_end timestamptz) RETURNS bigint AS
+$BODY$
+BEGIN
+    RETURN extract(epoch from time_end);
+END;
+$BODY$
+LANGUAGE plpgsql;
+
+CREATE OR REPLACE PROCEDURE clean_spans() AS $$
+BEGIN
+    PERFORM count(*) from pg_tracing_consume_spans;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Create pg_tracing extension with sampling on
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ CREATE EXTENSION pg_tracing;
+
+-- This will create the following spans (non exhaustive list):
+--
+-- +-------------------------------------------------------------------------------------+
+-- | A: Utility: Create Extension                                                        |
+-- +-+-----------------------------------------------------------------------------------+
+--   +----------------------------------------------------------------------------------+
+--   |B: ProcessUtility: Create Extension                                               |
+--   +---+-----------------------------------+---+--------------------------------------+
+--       +-----------------------------------+   +-------------------------------------+
+--       |C: Utility: Create Function1       |   |E: Utility: Create Function2         |
+--       ++----------------------------------+   ++-----------------------------------++
+--        +----------------------------------+    +-----------------------------------+
+--        |D: ProcessUtility: Create Function|    |F: ProcessUtility: Create Function2|
+--        +----------------------------------+    +-----------------------------------+
+
+-- Extract span_ids, start and end of those spans
+SELECT span_id AS span_a_id,
+        get_span_start(span_start) as span_a_start,
+        get_span_end(span_start) as span_a_end
+		from pg_tracing_peek_spans where parent_id=1 and span_type='Utility' \gset
+
+SELECT span_id AS span_b_id,
+        get_span_start(span_start) as span_b_start,
+        get_span_end(span_start) as span_b_end
+		from pg_tracing_peek_spans where parent_id=:span_a_id and span_type='ProcessUtility' \gset
+
+SELECT span_id AS span_c_id,
+        get_span_start(span_start) as span_c_start,
+        get_span_end(span_start) as span_c_end
+		from pg_tracing_peek_spans where parent_id=:span_b_id and span_type='Utility' limit 1 \gset
+
+SELECT span_id AS span_d_id,
+        get_span_start(span_start) as span_d_start,
+        get_span_end(span_start) as span_d_end
+		from pg_tracing_peek_spans where parent_id=:span_c_id and span_type='ProcessUtility' \gset
+
+SELECT span_id AS span_e_id,
+        get_span_start(span_start) as span_e_start,
+        get_span_end(span_start) as span_e_end
+		from pg_tracing_peek_spans where parent_id=:span_b_id and span_type='Utility' limit 1 offset 1 \gset
+
+-- Check that the start and end of those spans are within expectation
+SELECT :span_a_start <= :span_b_start AS span_a_starts_first,
+		:span_a_end >= :span_b_end AS span_a_ends_last,
+
+		:span_d_end <= :span_c_end AS nested_span_ends_before_parent,
+		:span_c_end <= :span_e_start AS next_utility_starts_after;
+
+-- Clean current spans
+CALL clean_spans();
+
+--
+-- Test that no utility is captured with track_utility off
+--
+
+-- Set utility off
+SET pg_tracing.track_utility = off;
+
+-- Test utility tracking disabled + full sampling
+SET pg_tracing.sample_rate = 1.0;
+DROP EXTENSION pg_tracing;
+CREATE EXTENSION pg_tracing;
+SET pg_tracing.sample_rate = 0.0;
+
+-- View displaying spans with their nested level
+CREATE VIEW peek_spans_with_level AS
+    WITH RECURSIVE list_trace_spans(trace_id, parent_id, span_id, query_id, span_type, span_operation, span_start, span_end, sql_error_code, userid, dbid, pid, subxact_count, plan_startup_cost, plan_total_cost, plan_rows, plan_width, rows, nloops, shared_blks_hit, shared_blks_read, shared_blks_dirtied, shared_blks_written, local_blks_hit, local_blks_read, local_blks_dirtied, local_blks_written, blk_read_time, blk_write_time, temp_blks_read, temp_blks_written, temp_blk_read_time, temp_blk_write_time, wal_records, wal_fpi, wal_bytes, jit_functions, jit_generation_time, jit_inlining_time, jit_optimization_time, jit_emission_time, startup, parameters, deparse_info, lvl) AS (
+        SELECT p.*, 1
+        FROM pg_tracing_peek_spans p where trace_id=parent_id
+      UNION ALL
+        SELECT s.*, lvl + 1
+        FROM pg_tracing_peek_spans s, list_trace_spans st
+        WHERE s.parent_id = st.span_id
+    ) SELECT * FROM list_trace_spans;
+
+-- Create utility view to keep order stable
+CREATE VIEW peek_ordered_spans AS
+  SELECT * FROM peek_spans_with_level order by span_start, lvl;
+
+-- Nothing should have been generated
+select count(*) = 0 from pg_tracing_consume_spans;
+
+-- Prepare and execute a prepared statement
+PREPARE test_prepared_one_param (integer) AS SELECT $1;
+EXECUTE test_prepared_one_param(100);
+
+-- Nothing should be generated
+select count(*) = 0 from pg_tracing_consume_spans;
+
+-- Force a query to start from ExecutorRun
+SET plan_cache_mode='force_generic_plan';
+EXECUTE test_prepared_one_param(200);
+SET plan_cache_mode TO DEFAULT;
+
+-- Again, nothing should be generated
+select count(*) = 0 from pg_tracing_consume_spans;
+
+--
+-- Test that no utility is captured with track_utility off
+--
+
+-- Enable utility tracking and track everything
+SET pg_tracing.track_utility = on;
+SET pg_tracing.sample_rate = 1.0;
+
+-- Prepare and execute a prepared statement
+PREPARE test_prepared_one_param_2 (integer) AS SELECT $1;
+EXECUTE test_prepared_one_param_2(100);
+
+-- Check the number of generated spans
+select count(distinct(trace_id)) from pg_tracing_peek_spans;
+-- Check spans of test_prepared_one_param_2 execution
+select span_operation, parameters, lvl from peek_ordered_spans;
+-- Check the top span (standalone top span has trace_id=parent_id)
+select span_operation, parameters, lvl from peek_ordered_spans where trace_id = parent_id;
+CALL clean_spans();
+
+-- Test prepared statement with generic plan
+SET plan_cache_mode='force_generic_plan';
+EXECUTE test_prepared_one_param(200);
+SET plan_cache_mode TO DEFAULT;
+
+-- Check the number of generated spans
+select count(distinct(trace_id)) from pg_tracing_peek_spans;
+-- Check spans of test_prepared_one_param execution
+select span_operation, parameters, lvl from peek_ordered_spans;
+-- Check the top span (standalone top span has trace_id=parent_id)
+select span_operation, parameters, lvl from peek_ordered_spans where trace_id = parent_id;
+CALL clean_spans();
+
+-- Second create extension should generate an error that is captured by span
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ CREATE EXTENSION pg_tracing;
+select span_operation, parameters, sql_error_code, lvl from peek_ordered_spans where trace_id=1;
+
+-- Create test table
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000002-0000000000000002-01'*/ CREATE TABLE pg_tracing_test (a int, b char(20));
+-- Check create table spans
+select trace_id, span_type, span_operation, lvl from peek_ordered_spans where trace_id=2;
+
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000003-0000000000000003-01'*/ CREATE INDEX pg_tracing_index ON pg_tracing_test (a);
+-- Check create index spans
+select trace_id, span_type, span_operation, lvl from peek_ordered_spans where trace_id=3;
+
+CREATE OR REPLACE FUNCTION lazy_function(IN anyarray, OUT x anyelement, OUT n int)
+    RETURNS SETOF RECORD
+    LANGUAGE sql STRICT IMMUTABLE PARALLEL SAFE
+    AS 'select s from pg_catalog.generate_series(1, 1, 1) as g(s)';
+
+-- Check that tracing a function call with the wrong number of arguments is managed correctly
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000004-0000000000000004-01'*/ select lazy_function('{1,2,3}'::int[]);
+
+-- Check lazy function call with error
+select trace_id, span_type, span_operation, sql_error_code, lvl from peek_ordered_spans where trace_id=4;
+
+-- Cleanup
+CALL clean_spans();
+SET pg_tracing.track_utility TO DEFAULT;
diff --git a/contrib/pg_tracing/sql/wal.sql b/contrib/pg_tracing/sql/wal.sql
new file mode 100644
index 0000000000..83e1ccfac8
--- /dev/null
+++ b/contrib/pg_tracing/sql/wal.sql
@@ -0,0 +1,31 @@
+-- Enable wal instrumentation
+set pg_tracing.instrument_wal = true;
+
+-- Generate queries with wal write
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ INSERT INTO pg_tracing_test VALUES(generate_series(1, 10), 'aaa');
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000002-0000000000000002-01'*/ UPDATE pg_tracing_test SET b = 'bbb' WHERE a > 7;
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000003-0000000000000003-01'*/ DELETE FROM pg_tracing_test WHERE a > 9;
+
+-- Check WAL is generated for the above statements
+SELECT trace_id, span_type, span_operation, deparse_info,
+       wal_records > 0 as wal_records,
+       wal_bytes > 0 as wal_bytes
+FROM peek_ordered_spans;
+CALL clean_spans();
+
+-- Redo the same but without wal instrumentation
+set pg_tracing.instrument_wal = false;
+
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000001-0000000000000001-01'*/ INSERT INTO pg_tracing_test VALUES(generate_series(1, 10), 'aaa');
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000002-0000000000000002-01'*/ UPDATE pg_tracing_test SET b = 'bbb' WHERE a > 7;
+/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000003-0000000000000003-01'*/ DELETE FROM pg_tracing_test WHERE a > 9;
+
+-- With wal instrumentation disabled, wal counters should be set to 0
+SELECT trace_id, span_type, span_operation, deparse_info,
+       wal_records = 0 as wal_records,
+       wal_bytes = 0 as wal_bytes
+FROM peek_ordered_spans;
+
+-- Cleanup
+set pg_tracing.instrument_wal = true;
+CALL clean_spans();
diff --git a/contrib/pg_tracing/t/001_basic.pl b/contrib/pg_tracing/t/001_basic.pl
new file mode 100644
index 0000000000..0ca8dc0d46
--- /dev/null
+++ b/contrib/pg_tracing/t/001_basic.pl
@@ -0,0 +1,34 @@
+
+# Copyright (c) 2021-2023, PostgreSQL Global Development Group
+
+use strict;
+use warnings;
+
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
+use Test::More;
+
+
+my $node = PostgreSQL::Test::Cluster->new('main');
+
+$node->init;
+
+$node->append_conf('postgresql.conf',
+	qq{shared_preload_libraries = 'pg_tracing'
+	pg_tracing.notify_channel = pg_tracing_notify
+	pg_tracing.notify_threshold = 0
+	pg_tracing.sample_rate = 1.0
+	pg_tracing.track_utility = off
+	});
+$node->start;
+
+# setup
+$node->safe_psql("postgres", "CREATE EXTENSION pg_tracing;");
+
+my $result =
+	$node->safe_psql("postgres", "LISTEN pg_tracing_notify; SELECT 1;");
+like($result, qr/Asynchronous notification "pg_tracing_notify" received from server process with PID \d+\.$/, 'pg_tracing notification channel');
+
+$node->stop;
+
+done_testing();
diff --git a/doc/src/sgml/contrib.sgml b/doc/src/sgml/contrib.sgml
index ab7e38b52a..353a090a5b 100644
--- a/doc/src/sgml/contrib.sgml
+++ b/doc/src/sgml/contrib.sgml
@@ -160,6 +160,7 @@ CREATE EXTENSION <replaceable>extension_name</replaceable>;
  &pgstatstatements;
  &pgstattuple;
  &pgsurgery;
+ &pgtracing;
  &pgtrgm;
  &pgvisibility;
  &pgwalinspect;
diff --git a/doc/src/sgml/filelist.sgml b/doc/src/sgml/filelist.sgml
index bd42b3ef16..b7e1d4ab85 100644
--- a/doc/src/sgml/filelist.sgml
+++ b/doc/src/sgml/filelist.sgml
@@ -149,6 +149,7 @@
 <!ENTITY pgstatstatements SYSTEM "pgstatstatements.sgml">
 <!ENTITY pgstattuple     SYSTEM "pgstattuple.sgml">
 <!ENTITY pgsurgery       SYSTEM "pgsurgery.sgml">
+<!ENTITY pgtracing       SYSTEM "pgtracing.sgml">
 <!ENTITY pgtrgm          SYSTEM "pgtrgm.sgml">
 <!ENTITY pgvisibility    SYSTEM "pgvisibility.sgml">
 <!ENTITY pgwalinspect    SYSTEM "pgwalinspect.sgml">
diff --git a/doc/src/sgml/pgtracing.sgml b/doc/src/sgml/pgtracing.sgml
new file mode 100644
index 0000000000..cac096b158
--- /dev/null
+++ b/doc/src/sgml/pgtracing.sgml
@@ -0,0 +1,1010 @@
+<!-- doc/src/sgml/pgtracing.sgml -->
+
+<sect1 id="pgtracing" xreflabel="pg_tracing">
+ <title>pg_tracing &mdash; generate server-side spans for distributed tracing</title>
+
+ <indexterm zone="pgtracing">
+  <primary>pg_tracing</primary>
+ </indexterm>
+
+ <para>
+  The <filename>pg_tracing</filename> module provides a way to
+  generate server-side spans for distributed tracing.
+ </para>
+
+ <para>
+  The module must be loaded by adding <literal>pg_tracing</literal> to
+  <xref linkend="guc-shared-preload-libraries"/> in
+  <filename>postgresql.conf</filename> because it requires additional shared memory.
+  This means that a server restart is needed to add or remove the module.
+ </para>
+
+ <para>
+   When <filename>pg_tracing</filename> is active, it generates spans
+   on sampled queries. To access these spans, the module provides two views:
+   <structname>pg_tracing_consume_spans</structname> and
+   <structname>pg_tracing_peek_spans</structname>.
+   The utility functions <function>pg_tracing_reset</function> and
+   <function>pg_tracing_info</function> provide ways to read and reset
+   module's statistics. These are not available globally but
+   can be enabled for a specific database with
+   <command>CREATE EXTENSION pg_tracing</command>.
+ </para>
+
+ <sect2 id="pgtracing-pg-tracing-consume-spans">
+  <title>The <structname>pg_tracing_consume_spans</structname>/<structname>pg_tracing_peek_spans</structname> Views</title>
+
+  <para>
+   The spans generated by the module are made available via a
+   view named <structname>pg_tracing_consume_spans</structname>.
+   This view contains one row for each generated span.
+   The columns of the view are shown in <xref linkend="pgtracing-consume-spans-columns"/>.
+   The <structname>pg_tracing_peek_spans</structname> view
+   provides the same output as <structname>pg_tracing_consume_spans</structname>.
+   <structname>pg_tracing_peek_spans</structname> doesn't delete read spans.
+  </para>
+
+  <table id="pgtracing-consume-spans-columns">
+   <title><structname>pg_tracing_consume_spans</structname> Columns</title>
+   <tgroup cols="1">
+    <thead>
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       Column Type
+      </para>
+      <para>
+       Description
+      </para></entry>
+     </row>
+    </thead>
+
+    <tbody>
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>traceid</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Trace identifier of the span
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>parent_id</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Identifier of the span's parent
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>span_id</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Identifier of the span
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>queryid</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Hash code to identify identical normalized queries, 0 if query_id is disabled
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>span_type</structfield> <type>text</type>
+      </para>
+      <para>
+       Type of span (Parse, Planner, Executor...)
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>span_operation</structfield> <type>text</type>
+      </para>
+      <para>
+       Name of the span's operation
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>span_start</structfield> <type>timestamp with time zone</type>
+      </para>
+      <para>
+       Start time of the span
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>span_end</structfield> <type>timestamp with time zone</type>
+      </para>
+      <para>
+       End time of the span
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>sql_error_code</structfield> <type>bpchar</type>
+      </para>
+      <para>
+       Error code of the query. 00000 for a succesful query
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>pid</structfield> <type>integer</type>
+      </para>
+      <para>
+       Pid of the backend process that processed the query
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>subxact_count</structfield> <type>smallint</type>
+      </para>
+      <para>
+       Active count of backend's subtransaction when the span was created
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>plan_startup_cost</structfield> <type>double precision</type>
+      </para>
+      <para>
+       Estimated cost before fetching any tuples by the query planner
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>plan_total_cost</structfield> <type>double precision</type>
+      </para>
+      <para>
+       Estimated total cost by the query planner
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>plan_rows</structfield> <type>double precision</type>
+      </para>
+      <para>
+       Estimated number of row plan is expected to emit
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>plan_width</structfield> <type>integer</type>
+      </para>
+      <para>
+       Estimated row width in bytes by the query planner
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>rows</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Number of tuples processed
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>nloops</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Number of cycles for this node
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>shared_blks_hit</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Total number of shared block cache hits by the node
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>shared_blks_read</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Total number of shared blocks read by the node
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>shared_blks_dirtied</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Total number of shared blocks dirtied by the node
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>shared_blks_written</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Total number of shared blocks written by the node
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>local_blks_hit</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Total number of local block cache hits by the node
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>local_blks_read</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Total number of local blocks read by the node
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>local_blks_dirtied</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Total number of local blocks dirtied by the node
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>local_blks_written</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Total number of local blocks written by the node
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>blk_read_time</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Time spent reading blocks in milliseconds
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>blk_write_time</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Time spent writing blocks in milliseconds
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>temp_blks_read</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Total number of temp blocks read by the node
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>temp_blks_written</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Total number of temp blocks written by the node
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>temp_blk_read_time</structfield> <type>double precision</type>
+      </para>
+      <para>
+       Total time the node spent reading temporary file blocks, in
+       milliseconds (if <xref linkend="guc-track-io-timing"/> is enabled,
+       otherwise zero)
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>temp_blk_write_time</structfield> <type>double precision</type>
+      </para>
+      <para>
+       Total time the node spent writing temporary file blocks, in
+       milliseconds (if <xref linkend="guc-track-io-timing"/> is enabled,
+       otherwise zero)
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>wal_records</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Total number of WAL records generated by the node
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>wal_fpi</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Total number of WAL full page images generated by the node
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>wal_bytes</structfield> <type>numeric</type>
+      </para>
+      <para>
+       Total amount of WAL generated by the node in bytes
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>jit_functions</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Total number of functions JIT-compiled by the node
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>jit_generation_time</structfield> <type>double precision</type>
+      </para>
+      <para>
+       Total time spent by the node on generating JIT code, in milliseconds
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>jit_inlining_time</structfield> <type>double precision</type>
+      </para>
+      <para>
+       Total time spent by the node on inlining functions, in milliseconds
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>jit_optimization_time</structfield> <type>double precision</type>
+      </para>
+      <para>
+       Total time spent by the node on optimizing, in milliseconds
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>startup</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Time to the first tuple in nanoseconds
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>parameters</structfield> <type>text</type>
+      </para>
+      <para>
+       Value of the query's parameters
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>deparse_info</structfield> <type>text</type>
+      </para>
+      <para>
+       Informations extracted from deparsing a plan node
+      </para></entry>
+     </row>
+
+    </tbody>
+   </tgroup>
+  </table>
+
+  <para>
+   For security reasons, only superusers and roles with privileges of the
+   <literal>pg_read_all_stats</literal> role are allowed to access the
+   <structname>pg_tracing_peek_spans</structname> and
+   <structname>pg_tracing_consume_spans</structname>.
+  </para>
+
+ </sect2>
+
+ <sect2 id="pgtracing-pg-tracing-info">
+  <title>The <structname>pg_tracing_info</structname> View</title>
+
+  <indexterm>
+   <primary>pg_tracing_info</primary>
+  </indexterm>
+
+  <para>
+   The statistics of the <filename>pg_tracing</filename> module
+   itself are tracked and made available via a view named
+   <structname>pg_tracing_info</structname>.  This view contains
+   only a single row.  The columns of the view are shown in
+   <xref linkend="pgtracinginfo-columns"/>.
+  </para>
+
+  <table id="pgtracinginfo-columns">
+   <title><structname>pg_tracing_info</structname> Columns</title>
+   <tgroup cols="1">
+    <thead>
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       Column Type
+      </para>
+      <para>
+       Description
+      </para></entry>
+     </row>
+    </thead>
+
+    <tbody>
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>traces</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Total number traces captured by the module
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>spans</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Total number spans captured by the module
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>dropped_spans</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Total number of spans dropped because more than
+       <varname>pg_tracing.max_span</varname> were stored
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>failed_truncates</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Total number of times the module couldn't truncate the
+       query file due to a conflicting lock on pg_tracing's
+       text file
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>last_consume</structfield> <type>timestamp with time zone</type>
+      </para>
+      <para>
+       Time at which spans were consumed
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>stats_reset</structfield> <type>timestamp with time zone</type>
+      </para>
+      <para>
+       Time at which all statistics in the
+       <structname>pg_tracing_info</structname> view were last reset.
+      </para></entry>
+     </row>
+
+    </tbody>
+   </tgroup>
+  </table>
+ </sect2>
+
+ <sect2 id="pgtracing-funcs">
+  <title>Functions</title>
+
+  <variablelist>
+   <varlistentry>
+    <term>
+     <function>pg_tracing_reset() returns void</function>
+     <indexterm>
+      <primary>pg_tracing_reset</primary>
+     </indexterm>
+    </term>
+
+    <listitem>
+     <para>
+      <function>pg_tracing_reset</function> discards all statistics
+      gathered so far by <filename>pg_tracing</filename>.
+      Span buffer is not emptied by this function.
+      By default, this function can only be executed by superusers.
+      Access may be granted to others using <command>GRANT</command>.
+     </para>
+    </listitem>
+   </varlistentry>
+
+   <varlistentry>
+    <term>
+     <function>pg_tracing_spans(consume boolean) returns setof record</function>
+     <indexterm>
+      <primary>pg_tracing</primary>
+      <secondary>function</secondary>
+     </indexterm>
+    </term>
+
+    <listitem>
+     <para>
+      The <structname>pg_tracing_consume_spans</structname> and
+      <structname>pg_tracing_peek_spans</structname> views are defined in
+      terms of a function named <function>pg_tracing_spans</function>.
+      It is possible for clients to call the
+      <function>pg_tracing_spans</function> function directly. By
+      specifying <literal>consume := false</literal>, spans won't be removed
+      from the span buffer. With <literal>consume := true</literal>,
+      read spans will be deleted.
+     </para>
+    </listitem>
+   </varlistentry>
+  </variablelist>
+ </sect2>
+
+ <sect2 id="pgtracing-config-params">
+  <title>Configuration Parameters</title>
+
+  <variablelist>
+   <varlistentry>
+    <term>
+     <varname>pg_tracing.max_span</varname> (<type>integer</type>)
+     <indexterm>
+      <primary><varname>pg_tracing.max_span</varname> configuration parameter</primary>
+     </indexterm>
+    </term>
+
+    <listitem>
+     <para>
+      <varname>pg_tracing.max_span</varname> is the maximum number of
+      spans stored by the module (i.e., the maximum number of rows
+      returned by the <structname>pg_tracing_spans</structname> function).
+      If more spans are observed, the span buffer will be emptied if
+      <varname>pg_tracing.buffer_mode</varname> is <literal>drop_on_full</literal>. If
+      <varname>pg_tracing.buffer_mode</varname> is <literal>keep_on_full</literal>,
+      the new spans will be dropped and tracing will be aborted. The default value
+      is 5000. This parameter can only be set at server start.
+
+     <note>
+
+       <para>
+        A span takes around 370 bytes of memory so 5000 spans will use
+        1.7MB while 10000 spans will use 3.5MB. You can use the following query
+        to get the exact size used by the pg_tracing's spans:
+       </para>
+
+<programlisting>
+SELECT
+    pg_size_pretty(size) as total_span_size,
+    pg_size_pretty(size/(SELECT setting from pg_settings where name='pg_tracing.max_span')::int) as size_per_span
+FROM pg_shmem_allocations
+WHERE name ='PgTracing Spans';
+</programlisting>
+
+     </note>
+
+     </para>
+    </listitem>
+   </varlistentry>
+
+   <varlistentry>
+    <term>
+     <varname>pg_tracing.buffer_mode</varname> (<type>enum</type>)
+     <indexterm>
+      <primary><varname>pg_tracing.buffer_mode</varname> configuration parameter</primary>
+     </indexterm>
+    </term>
+
+    <listitem>
+     <para>
+      <varname>pg_tracing.buffer_mode</varname> controls span buffer's
+      behaviour when <varname>pg_tracing.max_span</varname> spans is reached.
+      If <literal>keep_on_full</literal>, existing buffer is kept while new spans are dropped.
+      If <literal>drop_on_full</literal>, existing buffer is dropped and new spans are added.
+      The default value is <literal>keep_on_full</literal>.
+     </para>
+    </listitem>
+   </varlistentry>
+
+   <varlistentry>
+    <term>
+     <varname>pg_tracing.max_parameter_size</varname> (<type>integer</type>)
+     <indexterm>
+      <primary><varname>pg_tracing.max_parameter_size</varname> configuration parameter</primary>
+     </indexterm>
+    </term>
+
+    <listitem>
+     <para>
+      <varname>pg_tracing.max_parameter_size</varname> controls the maximum
+      size of the parameter string.
+      The default value is <literal>1024</literal>.
+     </para>
+    </listitem>
+   </varlistentry>
+
+   <varlistentry>
+    <term>
+     <varname>pg_tracing.instrument_buffers</varname> (<type>boolean</type>)
+     <indexterm>
+      <primary><varname>pg_tracing.instrument_buffers</varname> configuration parameter</primary>
+     </indexterm>
+    </term>
+
+    <listitem>
+     <para>
+      <varname>pg_tracing.instrument_buffers</varname> controls whether
+      buffer instrumentation should be enable and exported in span metadata.
+      The default value is <literal>on</literal>.
+     </para>
+    </listitem>
+   </varlistentry>
+
+   <varlistentry>
+    <term>
+     <varname>pg_tracing.instrument_wal</varname> (<type>boolean</type>)
+     <indexterm>
+      <primary><varname>pg_tracing.instrument_wal</varname> configuration parameter</primary>
+     </indexterm>
+    </term>
+
+    <listitem>
+     <para>
+      <varname>pg_tracing.instrument_wal</varname> controls whether
+      WAL instrumentation should be enable and exported in span metadata.
+      The default value is <literal>on</literal>.
+     </para>
+    </listitem>
+   </varlistentry>
+
+   <varlistentry>
+    <term>
+     <varname>pg_tracing.initial_allocated_spans</varname> (<type>integer</type>)
+     <indexterm>
+      <primary><varname>pg_tracing.initial_allocated_spans</varname> configuration parameter</primary>
+     </indexterm>
+    </term>
+
+    <listitem>
+     <para>
+      <varname>pg_tracing.initial_allocated_spans</varname> controls the number
+      of allocated spans at the start of a trace.
+      The default value is <literal>25</literal>.
+     </para>
+    </listitem>
+   </varlistentry>
+
+   <varlistentry>
+    <term>
+     <varname>pg_tracing.track</varname> (<type>enum</type>)
+     <indexterm>
+      <primary><varname>pg_tracing.track</varname> configuration parameter</primary>
+     </indexterm>
+    </term>
+
+    <listitem>
+     <para>
+      <varname>pg_tracing.track</varname> controls which statements
+      should spans should be generated.
+      Specify <literal>top</literal> to only generate span for top-level
+      statements (those issued directly by clients), <literal>all</literal>
+      to also generate spans for nested statements (such as statements invoked
+      within functions), or <literal>none</literal> to disable span generation.
+      The default value is <literal>all</literal>.
+     </para>
+    </listitem>
+   </varlistentry>
+
+   <varlistentry>
+    <term>
+     <varname>pg_tracing.track_utility</varname> (<type>boolean</type>)
+     <indexterm>
+      <primary><varname>pg_tracing.track_utility</varname> configuration parameter</primary>
+     </indexterm>
+    </term>
+
+    <listitem>
+     <para>
+      <varname>pg_tracing.track_utility</varname> controls whether spans
+      should be generated for utility statements. Utility commands are
+      all those other than <command>SELECT</command>, <command>INSERT</command>,
+      <command>UPDATE</command>, <command>DELETE</command>, <command>TABLE</command>,
+      and <command>MERGE</command>. The default value is <literal>on</literal>.
+     </para>
+    </listitem>
+   </varlistentry>
+
+   <varlistentry>
+    <term>
+     <varname>pg_tracing.sample_rate</varname> (<type>real</type>)
+     <indexterm>
+      <primary><varname>pg_tracing.sample_rate</varname> configuration parameter</primary>
+     </indexterm>
+    </term>
+
+    <listitem>
+     <para>
+      <varname>pg_tracing.sample_rate</varname> controls the fraction of
+      statements that generate spans. Statements with tracecontext propagated
+      with SQLCommenter and sampled flag enabled are not impacted by this parameter.
+      In case of nested statements, either all will be explained or none.
+      The default value is <literal>0</literal>.
+     </para>
+    </listitem>
+   </varlistentry>
+
+   <varlistentry>
+    <term>
+     <varname>pg_tracing.caller_sample_rate</varname> (<type>real</type>)
+     <indexterm>
+      <primary><varname>pg_tracing.caller_sample_rate</varname> configuration parameter</primary>
+     </indexterm>
+    </term>
+
+    <listitem>
+     <para>
+      <varname>pg_tracing.caller_sample_rate</varname> controls the fraction of
+      statements with SQLCommenter tracecontext and an enabled sampled flag that
+      will generate spans. The default value is <literal>1</literal>.
+     </para>
+    </listitem>
+   </varlistentry>
+
+   <varlistentry>
+    <term>
+     <varname>pg_tracing.export_parameters</varname> (<type>boolean</type>)
+     <indexterm>
+      <primary><varname>pg_tracing.export_parameters</varname> configuration parameter</primary>
+     </indexterm>
+    </term>
+
+    <listitem>
+     <para>
+      <varname>pg_tracing.export_parameters</varname> controls whether
+      query's parameters should be exported in spans metadata.
+      The default value is <literal>on</literal>.
+     </para>
+    </listitem>
+   </varlistentry>
+
+   <varlistentry>
+    <term>
+     <varname>pg_tracing.deparse_plan</varname> (<type>boolean</type>)
+     <indexterm>
+      <primary><varname>pg_tracing.deparse_plan</varname> configuration parameter</primary>
+     </indexterm>
+    </term>
+
+    <listitem>
+     <para>
+      <varname>pg_tracing.deparse_plan</varname> controls whether
+      the query plan should be deparsed. Deparsing plan allows to
+      add more details in span's name. A
+      <literal>BitmapHeapScan on mytable</literal> node will
+      have <literal>Recheck Cond: (a = 1)</literal> as deparsing information.
+      The default value is <literal>on</literal>.
+     </para>
+    </listitem>
+   </varlistentry>
+
+   <varlistentry>
+    <term>
+     <varname>pg_tracing.notify_channel</varname> (<type>text</type>)
+     <indexterm>
+      <primary><varname>pg_tracing.notify_channel</varname> configuration parameter</primary>
+     </indexterm>
+    </term>
+
+    <listitem>
+     <para>
+      <varname>pg_tracing.notify_channel</varname> defines a channel
+      that will receive a notification when the span buffer exceeds
+      the <varname>pg_tracing.notify_threshold</varname> threshold.
+      No channel is defined by default.
+     </para>
+    </listitem>
+   </varlistentry>
+
+   <varlistentry>
+    <term>
+     <varname>pg_tracing.notify_threshold</varname> (<type>real</type>)
+     <indexterm>
+      <primary><varname>pg_tracing.notify_threshold</varname> configuration parameter</primary>
+     </indexterm>
+    </term>
+
+    <listitem>
+     <para>
+      <varname>pg_tracing.notify_threshold</varname> defines the
+      threhold for sending notification to the <varname>pg_tracing.notify_channel</varname>
+      channel.
+      The default value is <literal>0.8</literal>: a notification will be sent when span buffer
+      crosses the 80% of usage.
+     </para>
+    </listitem>
+   </varlistentry>
+  </variablelist>
+
+  <para>
+   The module requires additional shared memory proportional to
+   <varname>pg_tracing.max_span</varname>.  Note that this
+   memory is consumed whenever the module is loaded, even if
+   no spans are generated.
+  </para>
+
+  <para>
+   These parameters must be set in <filename>postgresql.conf</filename>.
+   Typical usage might be:
+
+<programlisting>
+# postgresql.conf
+shared_preload_libraries = 'pg_tracing'
+
+compute_query_id = on
+pg_tracing.span_max = 10000
+pg_tracing.track = all
+</programlisting>
+  </para>
+ </sect2>
+
+ <sect2 id="pgtracing-implementation-details">
+  <title>Implementation Details</title>
+
+ <sect3 id="pgtracing-sqlcommenter">
+  <title>SQLCommenter</title>
+  <para>
+   A query with <ulink url="https://google.github.io/sqlcommenter/">SQLcommenter</ulink> can propagate a trace context to the database. It will have the following format: <literal>/*dddbs='postgres.db',traceparent='00-00000000000000000000000000000009-0000000000000005-01'*/ select 1;</literal>. The traceparent fields are detailed in <ulink url="https://www.w3.org/TR/trace-context/#traceparent-header-field-values">w3c's trace-context</ulink>
+   <itemizedlist spacing="compact">
+    <listitem>
+     <para>
+      <literal>00000000000000000000000000000009</literal>: trace id
+     </para>
+    </listitem>
+    <listitem>
+     <para>
+      <literal>0000000000000005</literal>: parent id
+     </para>
+    </listitem>
+    <listitem>
+     <para>
+     <literal>01</literal>: trace flags (<literal>01 == sampled</literal>)
+     </para>
+    </listitem>
+   </itemizedlist>
+   When a query with SQLCommenter is detected, the trace context is extracted and used by <literal>pg_tracing</literal>.
+  </para>
+ </sect3>
+
+ <sect3 id="pgtracing-sampling-decision">
+  <title>Sampling Decision</title>
+  <para>
+  Spans will only be generated for sampled queries. A query is sampled if:
+  <itemizedlist spacing="compact">
+   <listitem>
+    <para>
+     It has a trace context propagated throught SQLCommenter with the sampled flag enabled and it passes the <varname>pg_tracing.caller_sample_rate</varname>
+    </para>
+   </listitem>
+   <listitem>
+    <para>
+    It has no SQLCommenter but the query randomly passes the global <varname>pg_tracing.sample_rate</varname>
+    </para>
+   </listitem>
+  </itemizedlist>
+   By default, <literal>pg_tracing.caller_sample_rate = 1</literal> and <literal>pg_tracing.sample_rate = 0</literal>.
+   Only queries with a trace context and a <literal>sampled := 01</literal> will be sampled, effectively leaving sampling decision to the callers.
+  </para>
+ </sect3>
+
+ <sect3 id="pgtracing-parse-span">
+  <title>Parse Span</title>
+  <para>
+   Parse spans generated by <filename>pg_tracing</filename> are an approximation.
+   No parse hook available, only post parse hook is available so the end of the 
+   parse is estimated at the start of the post parse.
+   For statement at the root level, the statement start is used as parse's start.
+   For nested statements, the start of the new nested level is used.
+  </para>
+ </sect3>
+
+ <sect3 id="pgtracing-query-error">
+  <title>Query error</title>
+  <para>
+   On query error (statement timeout reached, query canceled...), a sampled
+   query will still generate spans. The planstate will be partial so
+   the generated spans only reflect nodes that were executed and it's
+   possible that some part of the plan will be missing.
+  </para>
+ </sect3>
+
+ <sect3 id="pgtracing-overhead">
+  <title>Overhead</title>
+  <para>
+   Sampling a query will enable the same type of query instrumentation as
+   <command>EXPLAIN ANALYZE</command> and will have the same measurement overhead.
+   Machines with slow <function>gettimeofday()</function> operating-system calls
+   will have higher overhead. You can use the <xref linkend="pgtesttiming"/> tool
+   to measure the overhead of timing on your system.
+  </para>
+ </sect3>
+
+ </sect2>
+
+ <sect2 id="pgtracing-sample-output">
+  <title>Sample Output</title>
+
+<screen>
+=# SET pg_tracing.sample_rate = 1.0;
+
+=# SELECT 1;
+
+=# select trace_id, parent_id, span_id, span_start, span_end, span_type, span_operation from pg_tracing_consume_spans order by span_start;
+       trace_id       |      parent_id       |       span_id        |          span_start           |           span_end            | span_type | span_operation
+----------------------+----------------------+----------------------+-------------------------------+-------------------------------+-----------+----------------
+ -5836026165849631572 | -5836026165849631572 |  8715846786225769851 | 2023-12-06 12:59:14.173795+00 | 2023-12-06 12:59:14.173992+00 | Parse     | Parse
+ -5836026165849631572 | -5836026165849631572 | -1264410631790158863 | 2023-12-06 12:59:14.173992+00 | 2023-12-06 12:59:14.17422+00  | Select    | SELECT $1;
+ -5836026165849631572 | -1264410631790158863 |  3722334334669296769 | 2023-12-06 12:59:14.174023+00 | 2023-12-06 12:59:14.174098+00 | Planner   | Planner
+ -5836026165849631572 | -1264410631790158863 |  1932640932836881107 | 2023-12-06 12:59:14.174155+00 | 2023-12-06 12:59:14.174183+00 | Executor  | ExecutorRun
+ -5836026165849631572 |  1932640932836881107 |  5182317161555960082 | 2023-12-06 12:59:14.174164+00 | 2023-12-06 12:59:14.17417+00  | Result    | Result
+
+=# select trace_id, parent_id, span_id, span_start, span_end, span_type, span_operation from pg_tracing_consume_spans order by span_start;
+ trace_id | parent_id | span_id | span_start | duration | name | resource
+----------+-----------+---------+------------+----------+------+----------
+(0 rows)
+
+</screen>
+ </sect2>
+
+ <sect2 id="pgtracing-authors">
+  <title>Authors</title>
+
+  <para>
+   Anthonin Bonnefoy <email>anthonin.bonnefoy@datadoghq.com</email>.
+  </para>
+ </sect2>
+
+</sect1>
diff --git a/src/backend/executor/instrument.c b/src/backend/executor/instrument.c
index c383f34c06..6b6924ae59 100644
--- a/src/backend/executor/instrument.c
+++ b/src/backend/executor/instrument.c
@@ -67,9 +67,12 @@ InstrInit(Instrumentation *instr, int instrument_options)
 void
 InstrStartNode(Instrumentation *instr)
 {
-	if (instr->need_timer &&
-		!INSTR_TIME_SET_CURRENT_LAZY(instr->starttime))
-		elog(ERROR, "InstrStartNode called twice in a row");
+	if (instr->need_timer) {
+		if (!INSTR_TIME_SET_CURRENT_LAZY(instr->starttime))
+			elog(ERROR, "InstrStartNode called twice in a row");
+		if (instr->firsttime == 0)
+			instr->firsttime = GetCurrentTimestamp();
+	}
 
 	/* save buffer usage totals at node entry, if needed */
 	if (instr->need_bufusage)
diff --git a/src/include/executor/instrument.h b/src/include/executor/instrument.h
index d5d69941c5..8fd0366442 100644
--- a/src/include/executor/instrument.h
+++ b/src/include/executor/instrument.h
@@ -14,6 +14,7 @@
 #define INSTRUMENT_H
 
 #include "portability/instr_time.h"
+#include "utils/timestamp.h"
 
 
 /*
@@ -74,6 +75,7 @@ typedef struct Instrumentation
 	bool		async_mode;		/* true if node is in async mode */
 	/* Info about current plan cycle: */
 	bool		running;		/* true if we've completed first tuple */
+	TimestampTz	firsttime;		/* start time of this node */
 	instr_time	starttime;		/* start time of current iteration of node */
 	instr_time	counter;		/* accumulated runtime for this node */
 	double		firsttuple;		/* time for first tuple of this cycle */
-- 
2.39.3 (Apple Git-145)

